@ngutil/common 0.0.7 → 0.0.8

package/types/merge-union.d.ts

@@ -0,0 +1,9 @@
+import { Eval } from "./util";
+type AllKeys<T> = T extends any ? keyof T : never;
+type TypeOfKey<T, TK extends AllKeys<T>> = T extends {
+    [K in TK]?: any;
+} ? T[TK] : never;
+export type MergeUnion<T> = Eval<{
+    [K in AllKeys<T>]: TypeOfKey<T, K>;
+}>;
+export {};

package/types/primitive.d.ts

@@ -0,0 +1,23 @@
+import { isPrimitive, Primitive } from "utility-types";
+import { IsAny } from "./util";
+export { Primitive, isPrimitive };
+export type Builtins = Primitive | Function | Date;
+export type ToPrimitiveMap = {
+    string: string;
+    default: string;
+    number: number;
+    bigint: bigint;
+    boolean: boolean;
+    symbol: symbol;
+};
+type AsString<T, P, F = never> = P extends string ? (T extends Primitive ? P : F) : never;
+type HasValueOf<T, P, F = never> = T extends {
+    valueOf(): P;
+} ? P : F;
+type HasToPrimitive<T, P, F = never> = T extends {
+    [Symbol.toPrimitive](hint: string): P;
+} ? P : F;
+type _AsPrimitive<T, P> = HasToPrimitive<T, P, HasValueOf<T, P, AsString<T, P>>>;
+export type AsPrimitive<T> = IsAny<T> extends true ? ToPrimitiveMap[keyof ToPrimitiveMap] : {
+    [K in keyof ToPrimitiveMap]: _AsPrimitive<T, ToPrimitiveMap[K]>;
+}[keyof ToPrimitiveMap];

package/types/readonly.d.ts

@@ -0,0 +1,14 @@
+import { Primitive } from "./primitive";
+import { IsAny, IsTuple, MaxRecursion } from "./util";
+export type DeepReadonly<T, D extends number = MaxRecursion> = _DeepReadonly<T, [], D>;
+type _DeepReadonly<T, P extends number[], D extends number> = P["length"] extends D ? never : IsAny<T> extends true ? any : T extends Primitive | ((...args: any[]) => any) ? T : T extends Date ? ReadonlyDate : T extends Array<infer V> ? IsTuple<T> extends true ? _DeepReadonlyTuple<T, P, D> : _DeepReadonlyArray<V, P, D> : T extends Map<infer MK, infer MV> ? _DeepReadonlyMap<MK, MV, P, D> : T extends Set<infer V> ? _DeepReadonlySet<V, P, D> : T extends object ? _DeepReadonlyObject<T, P, D> : T;
+type _DeepReadonlyTuple<T extends any[], P extends number[], D extends number> = _ReadonlyTuple<T, [], [], P, D>;
+type _ReadonlyTuple<T extends any[], K extends number[], R extends readonly any[], P extends number[], D extends number> = T["length"] extends K["length"] ? R : _ReadonlyTuple<T, [...K, K["length"]], readonly [...R, _DeepReadonly<T[K["length"]], [...P, 0], D>], P, D>;
+type _DeepReadonlyArray<T, P extends number[], D extends number> = ReadonlyArray<IsAny<T> extends true ? any : _DeepReadonly<T, [...P, 0], D>>;
+type _DeepReadonlyObject<T extends object, P extends number[], D extends number> = {
+    readonly [K in keyof T]: IsAny<T[K]> extends true ? any : _DeepReadonly<T[K], [...P, 0], D>;
+};
+type _DeepReadonlyMap<K, V, P extends number[], D extends number> = ReadonlyMap<K, _DeepReadonly<V, [...P, 0], D>>;
+type _DeepReadonlySet<V, P extends number[], D extends number> = ReadonlySet<_DeepReadonly<V, [...P, 0], D>>;
+export type ReadonlyDate = Omit<Date, "setTime" | "setMilliseconds" | "setUTCMilliseconds" | "setSeconds" | "setUTCSeconds" | "setMinutes" | "setUTCMinutes" | "setHours" | "setUTCHours" | "setDate" | "setUTCDate" | "setMonth" | "setUTCMonth" | "setFullYear" | "setUTCFullYear">;
+export {};

package/types/util.d.ts

@@ -0,0 +1,29 @@
+import { MergeUnion } from "./merge-union";
+export type MaxRecursion = 10;
+export type IfAny<O, T, F> = 0 extends 1 & O ? T : F;
+export type IsAny<T> = IfAny<T, true, false>;
+export type IfTuple<O, T, F, E = never> = O extends Array<any> ? (-1 extends O["length"] ? F : O["length"] extends 0 ? E : T) : F;
+export type IsTuple<T, E = never> = IfTuple<T, true, false, E>;
+/**
+ * @example
+ * ```ts
+ * type Tuple = TupleEntries<[1, "ok", false]>
+ * Tuple = {0: 1, 1: "ok", 2: false}
+ * ```
+ */
+export type TupleItems<T> = T extends Array<any> ? MergeUnion<_TupleItems<T>> : never;
+type _TupleItems<T extends any[], K extends number[] = [], O extends {
+    [key: string]: number;
+} = never> = T["length"] extends K["length"] ? O : _TupleItems<T, [...K, K["length"]], O | {
+    [key in K["length"]]: T[K["length"]];
+}>;
+export type ObjectKey = string | number | symbol;
+/**
+ * Evaulate type expressions
+ *
+ * ```ts
+ * export type KeyOf<T> = Eval<{ [K in keyof T]: T[K] extends never ? never : K }[keyof T]>
+ * ```
+ */
+export type Eval<T> = Array<T>[number];
+export {};

package/util.d.ts

@@ -0,0 +1,13 @@
+import { DeepReadonly } from "./types/readonly";
+export declare const deepClone: <T>(obj: T) => T;
+export declare const isPlainObject: (arg: any) => arg is {
+    [key: string]: any;
+};
+export declare function deepFreeze<T>(obj: T): DeepReadonly<T>;
+/**
+ * @example
+ * ```ts
+ * toSorted([{id: 1}, {id: 2}, {id: 3}], sortBy([{id: "desc"}]))
+ * ```
+ */
+export declare function toSorted<T>(items: readonly T[], fn: (a: T, b: T) => number): T[];