TypeOps.ts

// export type Readonly<T> = {
//     readonly [P in keyof T]: T[P];
//   }

// export type Partial<T> = {
//     [P in keyof T]?: T[P];
//   }

// export type Pick<T, K extends keyof T> = {
//     [P in K]: T[P];
//   }

// export type Record<K extends string, T> = {
//     [P in K]: T;
//   }

export type TypeName<T> =
    T extends string ? "string" :
    T extends number ? "number" :
    T extends boolean ? "boolean" :
    T extends undefined ? "undefined" :
    T extends Function ? "function" :
    "object";

// export type Diff<T, U> = T extends U ? never : T;

// export type Filter<T, U> = T extends U ? T : never;

export type FunctionPropertyNames<T> = { [K in keyof T]: T[K] extends Function ? K : never }[keyof T];

export type FunctionProperties<T> = Pick<T, FunctionPropertyNames<T>>;

export type NonFunctionPropertyNames<T> = { [K in keyof T]: T[K] extends Function ? never : K }[keyof T];

export type NonFunctionProperties<T> = Pick<T, NonFunctionPropertyNames<T>>;

// export type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any;

export type Unpacked<T> =
    T extends (infer U)[] ? U :
    T extends (...args: any[]) => infer U ? U :
    T extends Promise<infer U> ? U :
    T;

// export type AnyFunction = (...args: any[]) => any;

// export type ReturnType2<T extends AnyFunction> = T extends (...args: any[]) => infer R ? R : any;

export type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;

export type MutableRequired<T> = { -readonly [P in keyof T]-?: T[P] };

export type ReadonlyPartial<T> = { +readonly [P in keyof T]+?: T[P] };

// export type Required<T> = { [P in keyof T]-?: T[P] };

export type Mutable<T> = { -readonly [P in keyof T]: T[P] };

export function getProperty<T, K extends keyof T>(obj: T, key: K) {
  return obj[key];
}

export function setProperty<T, K extends keyof T>(obj: T, key: K, value: T[K]) {
  obj[key] = value;
}

// export type Partial<T> = {
//     [P in keyof T]?: T[P];
//   };

// export type Readonly<T> = {
//     readonly [P in keyof T]: T[P];
//  };

export type Deferred<T> = {
    [P in keyof T]: Promise<T[P]>;
  };

export type Proxify<T> = {
    [P in keyof T]: { get(): T[P]; set(v: T[P]): void; };
  };