ts-gems 2.9.3 → 3.0.0

package/lib/combine.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Merges types without merging types of properties.
+ */
+export type Combine<T1, T2, T3 = {}, T4 = {}> = T1
+    & Omit<T2, keyof T1>
+    & Omit<T3, keyof T1 | keyof T2>
+    & Omit<T4, keyof T1 | keyof T2 | keyof T3>;

package/lib/helpers.d.ts

@@ -1,11 +1,10 @@
-import { Builtin } from './common';
 import { IfAny, IfClass, IfTuple } from './type-check';
+import { Builtin } from './types';
 
 /**
  * Returns true if T is excluded from deep operations
  */
-export type IfNoDeepValue<T> = _IfNoDeepValue<T>
-type _IfNoDeepValue<T> =
+export type IfNoDeepValue<T> =
     T extends Builtin ? true
         : IfAny<T> extends true ? T
             : IfTuple<T> extends true ? true
@@ -17,5 +16,13 @@ type _IfNoDeepValue<T> =
                                     : T extends Set<any> ? true
                                         : T extends ReadonlySet<any> ? true
                                             : T extends WeakSet<any> ? true
-                                                // : T extends any[] ? true
+                                                : T extends any[] ? true
                                                     : false;
+
+
+/**
+ * ValuesOf
+ * @desc Returns the union type of all the values in a type
+ */
+export type ValuesOf<T> = T[keyof T];
+

package/lib/index.d.ts

@@ -1,16 +1,15 @@
-export * from "./common";
-export * from "./keys";
-export * from "./type-check";
-export * from "./modify";
-export * from "./deep-buildable";
-export * from "./deep-nullish";
-export * from "./deep-omit";
-export * from "./deep-partial";
-export * from "./deep-pick";
-export * from "./deep-readonly";
-export * from "./deep-remove-nulls";
-export * from "./deep-required";
-export * from "./deep-writable";
+export * from "./combine";
 export * from "./helpers";
-export * from "./pick";
+export * from "./logical.js";
+export * from "./mutable";
+export * from "./nullish";
 export * from "./omit";
+export * from "./omit-never";
+export * from "./opaque";
+export * from "./partial";
+export * from "./pick";
+export * from "./readonly";
+export * from "./required";
+export * from "./type-check";
+export * from "./types";
+

package/lib/logical.d.ts

@@ -0,0 +1,19 @@
+import { IfNever } from './type-check';
+
+export type And<T1, T2, T3 = true, T4 = true, T5 = true, T6 = true> =
+    IfNever<Exclude<T1, undefined | null | false>> extends true ? false :
+        IfNever<Exclude<T2, undefined | null | false>> extends true ? false :
+            IfNever<Exclude<T3, undefined | null | false>> extends true ? false :
+                IfNever<Exclude<T4, undefined | null | false>> extends true ? false :
+                    IfNever<Exclude<T5, undefined | null | false>> extends true ? false :
+                        IfNever<Exclude<T6, undefined | null | false>> extends true ? false :
+                            true;
+
+export type Or<T1, T2, T3 = false, T4 = false, T5 = false, T6 = false> =
+    IfNever<Exclude<T1, undefined | null | false>> extends false ? true :
+        IfNever<Exclude<T2, undefined | null | false>> extends false ? true :
+            IfNever<Exclude<T3, undefined | null | false>> extends false ? true :
+                IfNever<Exclude<T4, undefined | null | false>> extends false ? true :
+                    IfNever<Exclude<T5, undefined | null | false>> extends false ? true :
+                        IfNever<Exclude<T6, undefined | null | false>> extends false ? true :
+                            false;

package/lib/mutable.d.ts

@@ -0,0 +1,84 @@
+import { IfNoDeepValue } from './helpers';
+import {
+  DeeperOmitReadonly,
+  DeeperPickReadonly,
+  DeepOmitReadonly,
+  DeepPickReadonly,
+  OmitReadonly,
+  PickReadonly
+} from './readonly';
+import { IfNever } from './type-check';
+
+/**
+ * Make all properties in T mutable
+ */
+export type Mutable<T> = {
+  -readonly [K in keyof T as (IfNever<Exclude<T[K], undefined>, never, K>)]: T[K];
+};
+
+
+/**
+ * Marks given keys as mutable
+ */
+export type MutableSome<T, K extends keyof T> = Mutable<Pick<T, K>> & Omit<T, K>;
+
+
+/**
+ * Make all properties in T mutable deeply
+ */
+export type DeepMutable<T> = {
+  -readonly [K in keyof T as (IfNever<Exclude<T[K], undefined>, never, K>)]:
+  // Do not deep process No-Deep values
+  IfNoDeepValue<Exclude<T[K], undefined>> extends true ? T[K]
+      // Deep process objects
+      : DeepMutable<Exclude<T[K], undefined>>
+};
+
+/**
+ * Make all properties in T mutable deeply
+ */
+export type DeeperMutable<T> = {
+  -readonly [K in keyof T as (IfNever<Exclude<T[K], undefined>, never, K>)]:
+  // Deep process arrays
+  Exclude<T[K], undefined> extends (infer U)[] ? DeeperMutable<U>[]
+      // Do not deep process No-Deep values
+      : IfNoDeepValue<Exclude<T[K], undefined>> extends true ? T[K]
+          // Deep process objects
+          : DeeperMutable<Exclude<T[K], undefined>>
+};
+
+/**
+ * Returns mutable keys of an object
+ */
+export type MutableKeys<T> = keyof OmitReadonly<T>;
+
+/**
+ * Pick all mutable properties in T
+ */
+export type PickMutable<T> = OmitReadonly<T>;
+
+/**
+ * Omit all mutable properties in T
+ */
+export type OmitMutable<T> = PickReadonly<T>;
+
+/**
+ * Pick all mutable properties in T deeply
+ */
+export type DeepPickMutable<T> = DeepOmitReadonly<T>;
+
+/**
+ * Pick all mutable properties in T deeply
+ */
+export type DeepOmitMutable<T> = DeepPickReadonly<T>;
+
+/**
+ * Pick all mutable properties in T deeply including arrays
+ */
+export type DeeperPickMutable<T> = DeeperOmitReadonly<T>;
+
+/**
+ * Pick all mutable properties in T deeply including arrays
+ */
+export type DeeperOmitMutable<T> = DeeperPickReadonly<T>;
+

package/lib/nullish.d.ts

@@ -0,0 +1,34 @@
+import { IfNoDeepValue } from './helpers';
+import { IfNever } from './type-check';
+
+/**
+ * Make all properties in T nullable
+ */
+export type Nullish<T = null> = {
+  [P in keyof T]?: T[P] | null;
+};
+
+
+/**
+ * Make all properties in T nullable deeply
+ */
+export type DeepNullish<T> = {
+  [K in keyof T as (IfNever<Exclude<T[K], undefined>, never, K>)]?:
+  // Do not deep process No-Deep values
+  IfNoDeepValue<Exclude<T[K], undefined>> extends true ? (T[K] | null)
+      // Deep process objects
+      : DeepNullish<Exclude<T[K], undefined>> | null
+};
+
+/**
+ * Make all properties in T nullable deeply including arrays
+ */
+export type DeeperNullish<T> = {
+  [K in keyof T as (IfNever<Exclude<T[K], undefined>, never, K>)]?:
+  // Deep process arrays
+  Exclude<T[K], undefined> extends (infer U)[] ? DeeperNullish<U>[] | null
+      // Do not deep process No-Deep values
+      : IfNoDeepValue<Exclude<T[K], undefined>> extends true ? (T[K] | null)
+          // Deep process objects
+          : DeeperNullish<Exclude<T[K], undefined>> | null
+};

package/lib/omit-never.d.ts

@@ -0,0 +1,49 @@
+import { IfNoDeepValue } from './helpers';
+import { IfNever } from './type-check';
+
+/**
+ * OmitNever<T> is a type that omits all properties with a value of type "never".
+ *
+ * @template T - The original type
+ *
+ * @example
+ * type MyType = {
+ *   a: string;
+ *   b: number;
+ *   c?: never;
+ * };
+ *
+ * type Result = OmitNever<MyType>;
+ * // Result is:
+ * // {
+ * //   a: string;
+ * //   b: number;
+ * // }
+ */
+export type OmitNever<T> = {
+  [K in keyof T as (IfNever<Exclude<T[K], undefined>, never, K>)]: T[K]
+};
+
+/**
+ * Omit all "never" and "undefined" properties in T deeply
+ */
+export type DeepOmitNever<T> = {
+  [K in keyof T as (IfNever<Exclude<T[K], undefined>, never, K>)]:
+  // Do not deep process No-Deep values
+  IfNoDeepValue<Exclude<T[K], undefined>> extends true ? T[K]
+      // Deep process objects
+      : DeepOmitNever<Exclude<T[K], undefined>>
+};
+
+/**
+ * Omit all "never" and "undefined" properties in T deeply including arrays
+ */
+export type DeeperOmitNever<T> = {
+  [K in keyof T as (IfNever<Exclude<T[K], undefined>, never, K>)]:
+  // Deep process arrays
+  Exclude<T[K], undefined> extends (infer U)[] ? DeeperOmitNever<U>[]
+      // Do not deep process No-Deep values
+      : IfNoDeepValue<Exclude<T[K], undefined>> extends true ? T[K]
+          // Deep process objects
+          : DeepOmitNever<Exclude<T[K], undefined>>
+};

package/lib/omit.d.ts

@@ -1,65 +1,54 @@
-import {
-  JsonKeys,
-  OptionalKeys,
-  ReadonlyKeys,
-  RequiredKeys,
-  WritableKeys
-} from './keys';
-
-/**
- * OmitNever<T> is a type that omits all properties with a value of type "never".
- *
- * @template T - The original type
- *
- * @example
- * type MyType = {
- *   a: string;
- *   b: number;
- *   c?: never;
- * };
- *
- * type Result = OmitNever<MyType>;
- * // Result is:
- * // {
- * //   a: string;
- * //   b: number;
- * // }
- */
-export type OmitNever<T> = {
-  [K in keyof T as (Exclude<T[K], undefined> extends never ? never : K)]: T[K]
-};
+import { IfNoDeepValue } from './helpers';
+import { Or } from './logical.js';
+import { IfFunction, IfNever } from './type-check';
 
 /**
  * Construct a type with the properties of T except for those in type K,
  * while preserving strict type checking.
- *
- * @template T - The original type.
- * @template K - The keys of the properties to be removed from the original type.
- */
-export type StrictOmit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
-
-/**
- * Omit all optional properties in T
  */
-export type OmitOptional<T> = OmitNever<Omit<T, OptionalKeys<T>>>;
+export type StrictOmit<T, X extends keyof T> = {
+  [K in keyof T as (K extends X ? never : K)]: T[K]
+};
 
 /**
- * Omit all required properties in T
+ * Omit all function properties in T
  */
-export type OmitRequired<T> = OmitNever<Omit<T, RequiredKeys<T>>>;
+export type OmitFunctions<T> = {
+  [K in keyof T as (
+      Or<
+          // Omit never keys
+          IfNever<Exclude<T[K], undefined>>,
+          // Omit functions
+          IfFunction<Exclude<T[K], undefined>>
+      > extends true ? never : K
+      )]: T[K]
+};
 
 /**
- * Omit all readonly properties in T
+ * Exclude from properties of T those types that are assignable to X
  */
-export type OmitReadonly<T> = OmitNever<Omit<T, ReadonlyKeys<T>>>;
-
+export type OmitTypes<T, X> = {
+  [K in keyof T as (IfNever<Exclude<T[K], undefined | X>, never, K>)]: Exclude<T[K], X>
+};
 
 /**
- * Omit all writable properties in T
+ * Omit all function properties in T
  */
-export type OmitWritable<T> = OmitNever<Omit<T, WritableKeys<T>>>;
+export type DeepOmitTypes<T, X> = {
+  [K in keyof T as (IfNever<Exclude<T[K], undefined | X>, never, K>)]:  // Do not deep process No-Deep values
+  IfNoDeepValue<Exclude<T[K], undefined>> extends true ? Exclude<T[K], X>
+      // Deep process objects
+      : DeepOmitTypes<Exclude<T[K], undefined>, X>
+};
 
 /**
- * Omit all JSON friendly properties in T
+ * Omit all function properties in T deeply including arrays
  */
-export type OmitJson<T> = OmitNever<Omit<T, JsonKeys<T>>>;
+export type DeeperOmitTypes<T, X> = {
+  [K in keyof T as (IfNever<Exclude<T[K], undefined | X>, never, K>)]:  // Do not deep process No-Deep values
+  // Deep process arrays
+  Exclude<T[K], undefined> extends (infer U)[] ? DeeperOmitTypes<U, X>[]
+      : IfNoDeepValue<Exclude<T[K], undefined>> extends true ? Exclude<T[K], X>
+          // Deep process objects
+          : DeeperOmitTypes<Exclude<T[K], undefined>, X>
+};

package/lib/opaque.ts

@@ -0,0 +1,12 @@
+/**
+ * Opaque
+ * @desc Create unique type that can't be assigned to base type by accident.
+ */
+declare namespace Symbols {
+  export const base: unique symbol;
+  export const brand: unique symbol;
+}
+export type Opaque<T, N extends string> = T & {
+  readonly [Symbols.base]: N;
+  readonly [Symbols.brand]: N;
+}

package/lib/partial.d.ts

@@ -0,0 +1,78 @@
+import { IfNoDeepValue } from './helpers';
+import {
+  DeeperOmitRequired,
+  DeeperPickRequired,
+  DeepOmitRequired,
+  DeepPickRequired,
+  OmitRequired,
+  PickRequired
+} from './required';
+import { IfNever } from './type-check';
+
+
+/**
+ * Marks given keys as optional
+ */
+export type PartialSome<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;
+
+
+/**
+ * Partial but deeply
+ */
+export type DeepPartial<T> = {
+  [K in keyof T as (IfNever<Exclude<T[K], undefined>, never, K>)]?:
+  // Do not deep process No-Deep values
+  IfNoDeepValue<Exclude<T[K], undefined>> extends true ? T[K]
+      // Deep process objects
+      : DeepPartial<Exclude<T[K], undefined>>
+};
+
+/**
+ * Partial but deeply including arrays
+ */
+export type DeeperPartial<T> = {
+  [K in keyof T as (IfNever<Exclude<T[K], undefined>, never, K>)]?:
+  // Deep process arrays
+  Exclude<T[K], undefined> extends (infer U)[] ? DeeperPartial<U>[]
+      // Do not deep process No-Deep values
+      : IfNoDeepValue<Exclude<T[K], undefined>> extends true ? T[K]
+          // Deep process objects
+          : DeeperPartial<Exclude<T[K], undefined>>
+};
+
+
+/**
+ * OptionalKeys
+ * @desc Returns optional keys of an object
+ */
+export type OptionalKeys<T> = keyof PickOptional<T>;
+
+/**
+ * Pick all optional properties in T
+ */
+export type PickOptional<T> = OmitRequired<T>;
+
+/**
+ * Omit all optional properties in T
+ */
+export type OmitOptional<T> = PickRequired<T>;
+
+/**
+ * Pick all optional properties in T deeply
+ */
+export type DeepPickOptional<T> = DeepOmitRequired<T>;
+
+/**
+ * Omit all optional properties in T deeply
+ */
+export type DeepOmitOptional<T> = DeepPickRequired<T>;
+
+/**
+ * Pick all optional properties in T deeply including arrays
+ */
+export type DeeperPickOptional<T> = DeeperOmitRequired<T>;
+
+/**
+ * Omit all optional properties in T deeply including arrays
+ */
+export type DeeperOmitOptional<T> = DeeperPickRequired<T>;

package/lib/pick.d.ts

@@ -1,33 +1,93 @@
-import {
-  JsonKeys,
-  OptionalKeys,
-  ReadonlyKeys,
-  RequiredKeys,
-  WritableKeys
-} from './keys';
+import { Or } from './logical.js';
+import { OmitFunctions } from './omit';
+import { IfAny, IfEmptyObject, IfFunction, IfNever, IfUnknown } from './type-check';
 
 /**
- * Pick all optional properties in T
+ * From T, pick a set of properties whose keys are in the union K,
+ * while preserving strict type checking.
  */
-export type PickOptional<T> = Pick<T, OptionalKeys<T>>;
+export type StrictPick<T, X extends keyof T> = {
+  [K in keyof T as (
+      Or<
+          // Omit never keys
+          IfNever<Exclude<T[K], undefined>>,
+          // Omit X
+          K extends X ? false : true
+      > extends true ? never : K
+      )]: T[K]
+};
 
 /**
- * Pick all required properties in T
+ * Pick all function properties in T
  */
-export type PickRequired<T> = Pick<T, RequiredKeys<T>>;
+export type PickFunctions<T> = {
+  [K in keyof T as (
+      Or<
+          // Omit never keys
+          IfNever<Exclude<T[K], undefined>>,
+          // Omit non functions
+          IfFunction<Exclude<T[K], undefined>, false, true>
+      > extends true ? never : K
+      )]: T[K]
+};
+
 
 /**
- * Pick all readonly properties in T
+ * Pick all function properties in T
  */
-export type PickReadonly<T> = Pick<T, ReadonlyKeys<T>>;
+export type PickTypes<T, X> = {
+  [K in keyof T as (
+      Or<
+          // Omit never keys
+          IfNever<Exclude<T[K], undefined>>,
+          // Omit types which not exists in X
+          T[K] extends X ? false :
+              X extends T[K] ? false : true
+      > extends true ? never : K
+      )]: T[K]
+};
 
 
 /**
- * Pick all writable properties in T
+ * Pick all function properties in T
  */
-export type PickWritable<T> = Pick<T, WritableKeys<T>>;
+export type StrictPickTypes<T, X> = {
+  [K in keyof T as (
+      Or<
+          // Omit never keys
+          IfNever<Exclude<T[K], undefined>>,
+          // Omit unknown
+          IfUnknown<T[K]>,
+          // Omit any
+          IfAny<T[K]>,
+          // Omit {}
+          IfEmptyObject<T[K]>,
+          // Omit types which not exists in X
+          T[K] extends X ? false :
+              X extends T[K] ? false : true
+      > extends true ? never : K
+      )]: T[K]
+};
+
 
 /**
- * Pick all JSON friendly properties (no symbols) in T
+ * @desc Returns Function keys of an object
  */
-export type PickJson<T> = Pick<T, JsonKeys<T>>;
+export type FunctionKeys<T> = keyof PickFunctions<T>;
+
+/**
+ * @desc Returns non function keys of an object
+ */
+export type NonFunctionKeys<T> = keyof OmitFunctions<T>;
+
+
+/**
+ * @desc Returns keys that match given type
+ */
+export type KeysOfTypes<T, X> = keyof PickTypes<T, X>;
+
+/**
+ * @desc Returns keys that equals given type
+ */
+export type StrictKeysOfTypes<T, X> = keyof StrictPickTypes<T, X>;
+