ts-gems 3.3.0 → 3.5.0

package/lib/combine.d.ts

@@ -1,7 +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>;
+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/dto.d.ts

@@ -8,13 +8,17 @@ import { IfNever } from './type-check.js';
  * @template T - The type of the data being transferred.
  */
 export type DTO<T> = {
-  [K in keyof T as (IfNever<Exclude<T[K], undefined | Function>, never, K>)]:
-  // Deep process arrays
-  Exclude<T[K], undefined | null> extends (infer U)[] ? DTO<U>[]
-      // Do not deep process No-Deep values
-      : IfNoDeepValue<Exclude<T[K], undefined | null>> extends true ? Exclude<T[K], undefined | null>
-          // Deep process objects
-          : DTO<Exclude<T[K], undefined | null>>
+  [K in keyof T as IfNever<
+    Exclude<T[K], undefined | Function>,
+    never,
+    K
+  >]: Exclude<T[K], undefined | null> extends (infer U)[] // Deep process arrays
+    ? DTO<U>[]
+    : // Do not deep process No-Deep values
+      IfNoDeepValue<Exclude<T[K], undefined | null>> extends true
+      ? Exclude<T[K], undefined | null>
+      : // Deep process objects
+        DTO<Exclude<T[K], undefined | null>>;
 };
 
 export type PartialDTO<T> = DeepPartial<DTO<T>>;

package/lib/helpers.d.ts

@@ -4,25 +4,34 @@ import { Builtin } from './types';
 /**
  * Returns true if T is excluded from deep operations
  */
-export type IfNoDeepValue<T> =
-    T extends Builtin ? true
-        : IfAny<T> extends true ? T
-            : IfTuple<T> extends true ? true
-                : T extends Function ? true
-                    : IfClass<T> extends true ? true
-                        : T extends Map<any, any> ? true
-                            : T extends ReadonlyMap<any, any> ? true
-                                : T extends WeakMap<any, any> ? true
-                                    : T extends Set<any> ? true
-                                        : T extends ReadonlySet<any> ? true
-                                            : T extends WeakSet<any> ? true
-                                                : T extends any[] ? true
-                                                    : false;
-
+export type IfNoDeepValue<T> = T extends Builtin
+  ? true
+  : IfAny<T> extends true
+    ? T
+    : IfTuple<T> extends true
+      ? true
+      : T extends Function
+        ? true
+        : IfClass<T> extends true
+          ? true
+          : T extends Map<any, any>
+            ? true
+            : T extends ReadonlyMap<any, any>
+              ? true
+              : T extends WeakMap<any, any>
+                ? true
+                : T extends Set<any>
+                  ? true
+                  : T extends ReadonlySet<any>
+                    ? true
+                    : T extends WeakSet<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.cjs

@@ -0,0 +1,16 @@
+const noOp = x => x;
+
+module.exports = {
+  asMutable: noOp,
+  asDeepMutable: noOp,
+  asDeeperMutable: noOp,
+  asReadonly: noOp,
+  asDeepReadonly: noOp,
+  asDeeperReadonly: noOp,
+  asPartial: noOp,
+  asDeepPartial: noOp,
+  asDeeperPartial: noOp,
+  asRequired: noOp,
+  asDeepRequired: noOp,
+  asDeeperRequired: noOp,
+};

package/lib/index.d.ts

@@ -1,15 +1,61 @@
-export * from "./combine";
-export * from "./dto";
-export * from "./helpers";
-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";
+// noinspection JSUnusedGlobalSymbols
+
+import { DeeperMutable, DeepMutable, Mutable } from './mutable';
+import { DeeperPartial, DeepPartial } from './partial';
+import { DeeperReadonly, DeepReadonly } from './readonly';
+import { DeeperRequired, DeepRequired } from './required';
+
+export * from './combine';
+export * from './dto';
+export * from './helpers';
+export * from './logical';
+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';
+
+declare function asMutable<T>(x: T): Mutable<T>;
+
+declare function asDeepMutable<T>(x: T): DeepMutable<T>;
+
+declare function asDeeperMutable<T>(x: T): DeeperMutable<T>;
+
+declare function asReadonly<T>(x: T): Readonly<T>;
+
+declare function asDeepReadonly<T>(x: T): DeepReadonly<T>;
+
+declare function asDeeperReadonly<T>(x: T): DeeperReadonly<T>;
+
+declare function asPartial<T>(x: T): Partial<T>;
+
+declare function asDeepPartial<T>(x: T): DeepPartial<T>;
+
+declare function asDeeperPartial<T>(x: T): DeeperPartial<T>;
+
+declare function asRequired<T>(x: T): Required<T>;
+
+declare function asDeepRequired<T>(x: T): DeepRequired<T>;
+
+declare function asDeeperRequired<T>(x: T): DeeperRequired<T>;
+
+export {
+  asDeeperMutable,
+  asDeeperPartial,
+  asDeeperReadonly,
+  asDeeperRequired,
+  asDeepMutable,
+  asDeepPartial,
+  asDeepReadonly,
+  asDeepRequired,
+  asMutable,
+  asPartial,
+  asReadonly,
+  asRequired,
+};

package/lib/index.mjs

@@ -0,0 +1,16 @@
+const noOp = x => x;
+
+export {
+  noOp as asDeeperMutable,
+  noOp as asDeeperPartial,
+  noOp as asDeeperReadonly,
+  noOp as asDeeperRequired,
+  noOp as asDeepMutable,
+  noOp as asDeepPartial,
+  noOp as asDeepReadonly,
+  noOp as asDeepRequired,
+  noOp as asMutable,
+  noOp as asPartial,
+  noOp as asReadonly,
+  noOp as asRequired,
+};

package/lib/logical.d.ts

@@ -1,19 +1,31 @@
 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;
+  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;
+  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

@@ -5,7 +5,7 @@ import {
   DeepOmitReadonly,
   DeepPickReadonly,
   OmitReadonly,
-  PickReadonly
+  PickReadonly,
 } from './readonly';
 import { IfNever } from './type-check';
 
@@ -13,38 +13,44 @@ 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];
+  -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>;
-
+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>>
+  -readonly [K in keyof T as IfNever<
+    Exclude<T[K], undefined>,
+    never,
+    K
+  >]: IfNoDeepValue<Exclude<T[K], undefined>> extends true // Do not deep process No-Deep values
+    ? 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>>
+  -readonly [K in keyof T as IfNever<
+    Exclude<T[K], undefined>,
+    never,
+    K
+  >]: Exclude<T[K], undefined> extends (infer U)[] // Deep process arrays
+    ? 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>>;
 };
 
 /**
@@ -81,4 +87,3 @@ 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

@@ -4,31 +4,36 @@ import { IfNever } from './type-check';
 /**
  * Make all properties in T nullish
  */
-export type NullishObject<T = null> ={
-  [K in keyof T as (IfNever<Exclude<T[K], undefined>, never, K>)]?: T[K] | null
+export type NullishObject<T = null> = {
+  [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]?: T[K] | null;
 };
 
-
 /**
  * Make all properties in T nullish 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
+  [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]?: IfNoDeepValue<
+    // Do not deep process No-Deep values
+    Exclude<T[K], undefined>
+  > extends true
+    ? T[K] | null
+    : // Deep process objects
+      DeepNullish<Exclude<T[K], undefined>> | null;
 };
 
 /**
  * Make all properties in T nullish 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
+  [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]?: Exclude<
+    // Deep process arrays
+    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

@@ -21,29 +21,35 @@ import { IfNever } from './type-check';
  * // }
  */
 export type OmitNever<T> = {
-  [K in keyof T as (IfNever<Exclude<T[K], undefined>, never, K>)]: T[K]
+  [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>>
+  [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]: IfNoDeepValue<
+    // Do not deep process No-Deep values
+    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>>
+  [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]: Exclude<
+    // Deep process arrays
+    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

@@ -7,48 +7,59 @@ import { IfFunction, IfNever } from './type-check';
  * while preserving strict type checking.
  */
 export type StrictOmit<T, X extends keyof T> = {
-  [K in keyof T as (K extends X ? never : K)]: T[K]
+  [K in keyof T as K extends X ? never : K]: T[K];
 };
 
 /**
  * Omit all function properties in 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]
+  [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];
 };
 
 /**
  * Exclude from properties of T those types that are assignable to X
  */
 export type OmitTypes<T, X> = {
-  [K in keyof T as (IfNever<Exclude<T[K], undefined | X>, never, K>)]: Exclude<T[K], X>
+  [K in keyof T as IfNever<Exclude<T[K], undefined | X>, never, K>]: Exclude<
+    T[K],
+    X
+  >;
 };
 
 /**
  * Omit all function properties in 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>
+  [K in keyof T as IfNever<
+    Exclude<T[K], undefined | X>,
+    never,
+    K
+  >]: IfNoDeepValue<Exclude<T[K], undefined>> extends true // Do not deep process No-Deep values
+    ? Exclude<T[K], X>
+    : // Deep process objects
+      DeepOmitTypes<Exclude<T[K], undefined>, X>;
 };
 
 /**
  * Omit all function properties in T deeply including arrays
  */
 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>
+  [K in keyof T as IfNever<Exclude<T[K], undefined | X>, never, K>]: Exclude<
+    // Deep process arrays // Do not deep process No-Deep values
+    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

@@ -9,4 +9,4 @@ declare namespace Symbols {
 export type Opaque<T, N extends string> = T & {
   readonly [Symbols.base]: N;
   readonly [Symbols.brand]: N;
-}
+};

package/lib/partial.d.ts

@@ -5,42 +5,46 @@ import {
   DeepOmitRequired,
   DeepPickRequired,
   OmitRequired,
-  PickRequired
+  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>;
-
+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>>
+  [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]?: IfNoDeepValue<
+    // Do not deep process No-Deep values
+    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>>
+  [K in keyof T as IfNever<Exclude<T[K], undefined>, never, K>]?: Exclude<
+    // Deep process arrays
+    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