semlinker

function hideProperty(target, prefix = "_") {
  return new Proxy(target, {
    has: (obj, prop) => !prop.startsWith(prefix) && prop in obj,
    ownKeys: (obj) =>
      Reflect.ownKeys(obj).filter(
        (prop) => typeof prop !== "string" || !prop.startsWith(prefix)
      ),
    get: (obj, prop, rec) => (prop in rec ? obj[prop] : undefined),
  });
}

semlinker

function tracePropertyAccess(obj, propKeys) {
  const propKeySet = new Set(propKeys);
  return new Proxy(obj, {
    get(target, propKey, receiver) {
      if (propKeySet.has(propKey)) {
        console.log("GET " + propKey);
      }
      return Reflect.get(target, propKey, receiver);
    },
    set(target, propKey, value, receiver) {

semlinker

function traceMethodCall(obj) {
  const handler = {
    get(target, propKey, receiver) {
      const propValue = target[propKey]; // Get the original method
      return typeof propValue !== "function"
        ? propValue
        : function (...args) {
            const result = propValue.apply(this, args);
            console.log(
              `Call ${propKey} method -> ${JSON.stringify(result)}`

semlinker

const man = { name: "Bytefer" };

function freezeObject(obj) {
  return new Proxy(obj, {
    set() {
      return true;
    },
    deleteProperty() {
      return false;
    },

semlinker

const enhancedObject = (target) =>
  new Proxy(target, {
    get(target, property) {
      if (property in target) {
        return target[property];
      } else {
        return getPropertyValue(property, target);
      }
    },
  });

semlinker

function enhancedArray(arr) {
  return new Proxy(arr, {
    get(target, property, receiver) {
      const range = getRange(property);
      const indices = range ? range : getIndices(property);
      const values = indices.map((index) => {
        const key = index < 0 ? target.length + index : index;
        return Reflect.get(target, key, receiver);
      });
      return values.length === 1 ? values[0] : values;

semlinker

type TypeName<T> =
    T extends string ? "string" :
    T extends number ? "number" :
    T extends boolean ? "boolean" :
    T extends undefined ? "undefined" :
    T extends Function ? "function" :
    "object";
    
// "string" | "function"
type T10 = TypeName<string | (() => void)>;  

semlinker

function area(s: Shape) {
  switch (s.kind) {
    case "square":
      return s.size * s.size;
    case "rectangle":
      return s.width * s.height;
    case "circle":
      return Math.PI * s.radius * s.radius;
    default: 
      return assertExhaustive(s, 'Reached unexpected case')

semlinker

type OmitByType<T, U> = {
  [P in keyof T as T[P] extends U ? never : P]: T[P]
}
  
type OmitBoolean = OmitByType<{
  name: string
  count: number
  isReadonly: boolean
  isEnable: boolean
}, boolean> // { name: string; count: number }

semlinker

type PickByType<T, U> = {
  [P in keyof T as T[P] extends U ? P : never]: T[P];
};

type OnlyBoolean = PickByType<
  {
    name: string;
    count: number;
    isReadonly: boolean;
    isEnable: boolean;