@kakasoo/deep-strict-types 2.0.4 → 2.0.5

package/bin/src/types/ElementOf.d.ts

@@ -1,5 +1,32 @@
 /**
  * @title Type for Inferring the Element Type of an Array.
+ *
+ * Extracts the element type from an array type. This utility type uses conditional types
+ * with the `infer` keyword to extract the type of elements contained within an array.
+ *
+ * @template T - The array type from which to extract the element type
+ * @returns The type of elements in the array, or `never` if T is not an array
+ *
+ * @example
+ * ```typescript
+ * type StringArray = string[];
+ * type StringElement = ElementOf<StringArray>; // string
+ *
+ * type NumberArray = number[];
+ * type NumberElement = ElementOf<NumberArray>; // number
+ *
+ * type MixedArray = (string | number)[];
+ * type MixedElement = ElementOf<MixedArray>; // string | number
+ *
+ * type ObjectArray = { id: number; name: string }[];
+ * type ObjectElement = ElementOf<ObjectArray>; // { id: number; name: string }
+ *
+ * type ReadonlyArray = readonly string[];
+ * type ReadonlyElement = ElementOf<ReadonlyArray>; // string
+ *
+ * type TupleArray = [string, number, boolean];
+ * type TupleElement = ElementOf<TupleArray>; // string | number | boolean
+ * ```
  */
-export type ElementOf<T extends Array<any>> = T extends Array<infer Element> ? Element : never;
+export type ElementOf<T extends any[] | readonly any[]> = T extends (infer E)[] ? E : T extends readonly (infer E)[] ? E : never;
 //# sourceMappingURL=ElementOf.d.ts.map

package/bin/src/types/ElementOf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ElementOf.d.ts","sourceRoot":"","sources":["../../../src/types/ElementOf.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,KAAK,CAAC,MAAM,OAAO,CAAC,GAAG,OAAO,GAAG,KAAK,CAAC"}
+{"version":3,"file":"ElementOf.d.ts","sourceRoot":"","sources":["../../../src/types/ElementOf.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,GAAG,EAAE,GAAG,SAAS,GAAG,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,GAC3E,CAAC,GACD,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,GAC5B,CAAC,GACD,KAAK,CAAC"}

package/bin/src/types/Equal.d.ts

@@ -1,13 +1,39 @@
 /**
- * Implementation method
+ * Helper type that creates a generic function signature for type comparison.
+ * This technique leverages TypeScript's strict function type checking to determine type equality.
+ *
+ * @internal
  */
 type Expression<X> = <T>() => T extends X ? 1 : 2;
 /**
  * @title Type for Checking if Two Types are Equal.
  *
  * The `Equal<X, Y>` type uses conditional types and a helper type `Expression<X>`
- * to determine if two types `X` and `Y` are the same. It returns `true` if they are
+ * to determine if two types `X` and `Y` are exactly the same. It returns `true` if they are
  * equal, and `false` otherwise.
+ *
+ * This type performs a strict equality check that distinguishes between:
+ * - `any` vs other types
+ * - `unknown` vs other types
+ * - Union types with different members
+ * - Branded types vs their base types
+ *
+ * @template X - The first type to compare
+ * @template Y - The second type to compare
+ * @returns `true` if X and Y are exactly the same type, `false` otherwise
+ *
+ * @example
+ * ```typescript
+ * type Test1 = Equal<string, string>; // true
+ * type Test2 = Equal<string, number>; // false
+ * type Test3 = Equal<string | number, string | number>; // true
+ * type Test4 = Equal<string | number, number | string>; // true (order doesn't matter)
+ * type Test5 = Equal<{ a: string }, { a: string }>; // true
+ * type Test6 = Equal<{ a: string }, { a: string; b?: string }>; // false
+ * type Test7 = Equal<any, string>; // false
+ * type Test8 = Equal<unknown, any>; // false
+ * type Test9 = Equal<string & { __brand: 'ID' }, string>; // false (branded types)
+ * ```
  */
 export type Equal<X, Y> = Expression<X> extends Expression<Y> ? true : false;
 export {};

package/bin/src/types/Equal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Equal.d.ts","sourceRoot":"","sources":["../../../src/types/Equal.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,KAAK,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAElD;;;;;;GAMG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,SAAS,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC"}
+{"version":3,"file":"Equal.d.ts","sourceRoot":"","sources":["../../../src/types/Equal.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,KAAK,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,MAAM,KAAK,CAAC,CAAC,EAAE,CAAC,IAAI,UAAU,CAAC,CAAC,CAAC,SAAS,UAAU,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC"}

package/bin/src/types/GetType.d.ts

@@ -3,27 +3,49 @@ import type { DeepStrictObjectKeys } from './DeepStrictObjectKeys';
 import type { ElementOf } from './ElementOf';
 import type { RemoveArraySymbol } from './RemoveArraySymbol';
 /**
- * @title Type to infer all value types of generic T
+ * Helper type that extracts all value types from an object type.
+ * Similar to `T[keyof T]`, it returns a union of all property value types.
+ *
+ * @internal
+ * @template T - The object type to extract values from
  */
 type ValueOf<T> = T[keyof T];
 /**
- * @title The type that pulls out the type of a particular key on an interface.
+ * @title Type for extracting the type at a specific nested path in an object.
  *
- * This type extracts the type of a specific key from a nested object,
+ * This type extracts the type of a specific key from a nested object structure,
  * supporting arrays and deeply nested keys. It uses `DeepStrictObjectKeys`
- * to handle the extraction of keys and correctly resolves the type for the given key.
+ * to validate the key path and correctly resolves the type for the given key.
+ *
+ * Key features:
+ * - Supports dot notation for nested object access (e.g., "a.b.c")
+ * - Handles array access with `[*]` notation (e.g., "items[*].name")
+ * - Type-safe: only accepts valid key paths as defined by `DeepStrictObjectKeys`
+ * - Recursively resolves nested types through objects and arrays
  *
- * - If the key points to a primitive value, the type is returned directly.
- * - If the key points to an array, the type of the array elements is resolved.
- * - It supports nested keys using `.` notation to handle deep objects and arrays.
+ * @template T - The object type to extract from
+ * @template K - The key path string (must be a valid key from DeepStrictObjectKeys<T>)
+ * @returns The type at the specified path, or `never` if the path is invalid
  *
- * @template T The interface type.
- * @template K The key string, which can represent a nested key path.
+ * @example
+ * ```typescript
+ * type Data = {
+ *   user: {
+ *     name: string;
+ *     posts: {
+ *       title: string;
+ *       tags: string[];
+ *     }[];
+ *   };
+ * };
  *
- * Example usage:
- * ```ts
- * type Example1 = GetType<{ a: { b: { c: number } } }, "a.b">; // { c: number }
- * type Example2 = GetType<{ a: { b: { c: number } } }, "a.b.c">; // number
+ * type UserType = GetType<Data, "user">; // { name: string; posts: {...}[] }
+ * type NameType = GetType<Data, "user.name">; // string
+ * type PostsType = GetType<Data, "user.posts">; // { title: string; tags: string[] }[]
+ * type PostType = GetType<Data, "user.posts[*]">; // { title: string; tags: string[] }
+ * type TitleType = GetType<Data, "user.posts[*].title">; // string
+ * type TagsType = GetType<Data, "user.posts[*].tags">; // string[]
+ * type TagType = GetType<Data, "user.posts[*].tags[*]">; // string
  * ```
  */
 export type GetType<T extends object, K extends DeepStrictObjectKeys<T>> = StringType.Split<K, '.'> extends [infer First extends keyof T] ? ValueOf<Pick<T, First>> : StringType.Split<K, '.'> extends [infer First extends string, ...infer Rest extends string[]] ? RemoveArraySymbol<First> extends keyof T ? ValueOf<Pick<T, RemoveArraySymbol<First>>> extends object ? ValueOf<Pick<T, RemoveArraySymbol<First>>> extends Array<infer E> ? E extends object ? GetType<E, Extract<ArrayType.Join<Rest, '.'>, DeepStrictObjectKeys<E>>> : E : GetType<ValueOf<Pick<T, RemoveArraySymbol<First>>>, Extract<ArrayType.Join<Rest, '.'>, DeepStrictObjectKeys<ValueOf<Pick<T, RemoveArraySymbol<First>>>>>> : never : T extends any[] ? RemoveArraySymbol<First> extends '' ? GetType<ElementOf<T>, Extract<ArrayType.Join<Rest, '.'>, DeepStrictObjectKeys<ElementOf<T>>>> : never : never : never;

package/bin/src/types/GetType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GetType.d.ts","sourceRoot":"","sources":["../../../src/types/GetType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D;;GAEG;AACH,KAAK,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,oBAAoB,CAAC,CAAC,CAAC,IACrE,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,SAAS,CAAC,MAAM,KAAK,SAAS,MAAM,CAAC,CAAC,GAC1D,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,GACvB,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,SAAS,CAAC,MAAM,KAAK,SAAS,MAAM,EAAE,GAAG,MAAM,IAAI,SAAS,MAAM,EAAE,CAAC,GAC3F,iBAAiB,CAAC,KAAK,CAAC,SAAS,MAAM,CAAC,GACtC,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,MAAM,GACvD,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,GAC/D,CAAC,SAAS,MAAM,GACd,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC,GACvE,CAAC,GACH,OAAO,CACL,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC,EAC1C,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,oBAAoB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CACrG,GACH,KAAK,GACP,CAAC,SAAS,GAAG,EAAE,GACb,iBAAiB,CAAC,KAAK,CAAC,SAAS,EAAE,GACjC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,oBAAoB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAC7F,KAAK,GACP,KAAK,GACT,KAAK,CAAC"}
+{"version":3,"file":"GetType.d.ts","sourceRoot":"","sources":["../../../src/types/GetType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AACvE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAC7C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D;;;;;;GAMG;AACH,KAAK,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAE7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,oBAAoB,CAAC,CAAC,CAAC,IACrE,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,SAAS,CAAC,MAAM,KAAK,SAAS,MAAM,CAAC,CAAC,GAC1D,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,GACvB,UAAU,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,SAAS,CAAC,MAAM,KAAK,SAAS,MAAM,EAAE,GAAG,MAAM,IAAI,SAAS,MAAM,EAAE,CAAC,GAC3F,iBAAiB,CAAC,KAAK,CAAC,SAAS,MAAM,CAAC,GACtC,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,MAAM,GACvD,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,KAAK,CAAC,MAAM,CAAC,CAAC,GAC/D,CAAC,SAAS,MAAM,GACd,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC,GACvE,CAAC,GACH,OAAO,CACL,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC,EAC1C,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,oBAAoB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CACrG,GACH,KAAK,GACP,CAAC,SAAS,GAAG,EAAE,GACb,iBAAiB,CAAC,KAAK,CAAC,SAAS,EAAE,GACjC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,CAAC,EAAE,oBAAoB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAC7F,KAAK,GACP,KAAK,GACT,KAAK,CAAC"}

package/bin/src/types/IsUnion.d.ts

@@ -1,19 +1,39 @@
 import type { Equal } from './Equal';
 /**
- * 제네릭 타입 `T`가 자기 자신의 요소와 동일한지를 검증한다.
+ * Helper type that checks if a partition of type T is the same as the entire type T.
+ * This works by distributing T through conditional types and checking if each partition
+ * equals the whole. For union types, this produces `false | true`, while for single types
+ * it produces just `false`.
+ *
+ * @internal
+ * @template T - The type to check
+ * @template P - The preserved original type (defaults to T)
  */
 type IsPartitionSameEntire<T, P = T> = T extends any ? P extends T ? false : true : never;
 /**
  * @title Type for checking if a type is a union type.
  *
- * This type uses the `IsPartitionSameEntire` type to check whether the provided type `T` is a union type.
- * - It works by partitioning the type `T` and checking if the type consists of multiple distinct elements.
- * - If the type `T` is a union type, the result will be `true`, otherwise `false`.
+ * This type uses the `IsPartitionSameEntire` helper type to check whether the provided type `T` is a union type.
+ * It works by partitioning the type `T` and checking if the type consists of multiple distinct elements.
+ *
+ * The detection mechanism:
+ * - For union types: produces `boolean` (which is `false | true`)
+ * - For single types: produces `false`
+ * - Then checks if the result equals `boolean` to determine if it's a union
+ *
+ * @template T - The type to check
+ * @returns `true` if T is a union type, `false` otherwise
  *
- * Example usage:
- * ```ts
+ * @example
+ * ```typescript
  * type Test1 = IsUnion<string | number>; // true
  * type Test2 = IsUnion<string>; // false
+ * type Test3 = IsUnion<'a' | 'b' | 'c'>; // true
+ * type Test4 = IsUnion<{ a: string } | { b: number }>; // true
+ * type Test5 = IsUnion<never>; // false
+ * type Test6 = IsUnion<unknown>; // false
+ * type Test7 = IsUnion<any>; // false
+ * type Test8 = IsUnion<boolean>; // true (boolean is true | false)
  * ```
  */
 export type IsUnion<T> = Equal<IsPartitionSameEntire<T>, boolean> extends true ? true : false;

package/bin/src/types/IsUnion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"IsUnion.d.ts","sourceRoot":"","sources":["../../../src/types/IsUnion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC;;GAEG;AACH,KAAK,qBAAqB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,GAAG,GAChD,CAAC,SAAS,CAAC,GACT,KAAK,GACL,IAAI,GACN,KAAK,CAAC;AAEV;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC"}
+{"version":3,"file":"IsUnion.d.ts","sourceRoot":"","sources":["../../../src/types/IsUnion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC;;;;;;;;;GASG;AACH,KAAK,qBAAqB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,GAAG,GAChD,CAAC,SAAS,CAAC,GACT,KAAK,GACL,IAAI,GACN,KAAK,CAAC;AAEV;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,SAAS,IAAI,GAAG,IAAI,GAAG,KAAK,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kakasoo/deep-strict-types",
-  "version": "2.0.4",
+  "version": "2.0.5",
   "description": "typescript utility types including deep-strict-omit and pick type",
   "private": false,
   "publishConfig": {