@kakasoo/deep-strict-types 2.0.5 → 2.0.7

package/README.md

@@ -1,362 +1,275 @@
-# DeepStrictTypes Library Documentation
+# @kakasoo/deep-strict-types
 
-- [한국어 설명](./docs/README_KO.md)
+[![npm version](https://img.shields.io/npm/v/@kakasoo/deep-strict-types.svg)](https://www.npmjs.com/package/@kakasoo/deep-strict-types)
+[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](https://opensource.org/licenses/ISC)
+[![TypeScript](https://img.shields.io/badge/TypeScript-%3E%3D5.0-blue)](https://www.typescriptlang.org/)
 
-## Table of Contents
+Type-safe `Pick`, `Omit`, and key extraction for deeply nested TypeScript objects and arrays.
 
-1. [Introduction](#introduction)
-2. [DeepStrictObjectKeys](#deepstrictobjectkeys)
-3. [DeepStrictOmit](#deepstrictomit)
-4. [DeepStrictPick](#deepstrictpick)
-5. [StringToDeepObject](#stringtodeepobject)
-6. [DeepStrictMerge](#deepstrictmerge)
-7. [DeepDateToString](#deepdatetostring)
+[한국어 설명](./docs/README_KO.md)
 
-## Introduction
+![example](https://github.com/user-attachments/assets/28316425-8302-453e-b238-0c732606e6a7)
 
-DeepStrictTypes is a tool that takes TypeScript’s type manipulation to the next level.  
-It helps you safely perform tasks like `Omit` and `Pick` even with complex nested objects or arrays.  
-By addressing the limitations of TypeScript’s built-in utility types, it allows you to easily handle internal keys with strict and precise type inference.
+## Why in the AI Era?
 
-Key features include:
+AI writes more code than ever — and makes more subtle mistakes than ever. This library serves as a **compile-time guardrail** for AI-generated code.
 
-- **Safe Nested Key Extraction:** It extracts all keys from within an object, boosting type safety.
-- **Precise Type Manipulation:** You can pick or omit only the keys you need even in deeply nested structures, making it easier to work with complex data.
-- **Unbranding and Merging:** It removes unnecessary constraints from branded types and safely merges multiple types.
-- **Utility Function Support (Experimental):** It even provides runtime functions to further ensure type safety during development.
+### The Problem
 
-Below is a GIF showing an example of how to use the library.
+AI coding tools often produce code that looks correct but has subtle type mismatches in deeply nested structures:
 
-![example](https://github.com/user-attachments/assets/28316425-8302-453e-b238-0c732606e6a7)
+```typescript
+// AI-generated code: looks fine, but "prce" is a typo
+function getTotal(order: Order) {
+  return order.items.map(i => i.prce); // no error with loose types
+}
+```
 
-## DeepStrictObjectKeys
+### The Solution
 
-`DeepStrictObjectKeys` extracts all keys from a nested object, preserving its hierarchical structure as a union of string paths.  
-That means you can access not only top-level keys but also nested keys using dot notation or, for arrays, using `[*]`.
+With strict deep types as constraints, the TypeScript compiler catches AI mistakes **instantly**:
 
-### Key Features
+```typescript
+import { DeepStrictPick } from '@kakasoo/deep-strict-types';
 
-- **Preserves Hierarchy:** It retrieves every key from within an object so you can express paths like "user.address.city".
-- **Accurate Type Inference:** Instead of just using `keyof`, it thoroughly infers every nested key for enhanced type safety.
-- **Array Support:** For objects within arrays, it uses `[*]` instead of an index, so you cover all elements at once.
+type OrderSummary = DeepStrictPick<Order, 'items[*].price' | 'customer.name'>;
 
-### Example
+// Now AI gets a precise error:
+// Type '"items[*].prce"' is not assignable to
+//   type '"items" | "items[*]" | "items[*].price" | "customer" | "customer.name"'
+```
 
-The following example shows how to extract keys from a nested object using `DeepStrictObjectKeys`.
+### AI Self-Correction Loop
 
-```typescript
-type Example = {
-  user: {
-    name: string;
-    address: {
-      city: string;
-      zip: number;
-    };
-  };
-};
+When used with `tsc` or `tsx` in a build loop, AI agents can read the type error, understand exactly what went wrong, and fix it automatically:
 
-// Result: "user" | "user.name" | "user.address" | "user.address.city" | "user.address.zip"
-type Keys = DeepStrictObjectKeys<Example>;
+```
+AI generates code → tsc compile → type error → AI reads error → AI self-corrects → recompile
 ```
 
-The library also offers a utility function `deepStrictObjectKeys` based on this type, which works like `Object.keys` but correctly extracts nested paths.
+The stricter your types, the better the error messages, and the faster AI converges on correct code. **In an AI-driven workflow, deep strict types aren't overhead — they're the safety net.**
 
-```typescript
-type Target = { a: 1 }[][];
-const keys = deepStrictObjectKeys({} as Target); // Result: ["[*].[*].a"]
+## Installation
+
+```bash
+npm install @kakasoo/deep-strict-types
 ```
 
-## DeepStrictOmit
+## Quick Start
 
-`DeepStrictOmit` creates a new type by removing specified keys from a nested object type.
-Similar to the built-in `Omit`, it lets you precisely specify key paths—even in nested structures and arrays—to remove unwanted properties.
+```typescript
+import { DeepStrictObjectKeys, DeepStrictPick, DeepStrictOmit } from '@kakasoo/deep-strict-types';
 
-### Key Features
+type User = {
+  id: string;
+  profile: {
+    name: string;
+    age: number;
+  };
+  posts: {
+    title: string;
+    tags: string[];
+  }[];
+};
 
-- **Omit Nested Keys:** You can specify a nested key path like `"user.profile.name"` to remove just that property.
-- **Handles Arrays:** It applies the same logic to objects within arrays, so you can remove a key from every element.
-- **Accurate Type Inference:** It preserves the rest of the object’s structure and types after omission.
-- **Supports Branded Types:** It works safely with branded types, removing unnecessary constraints.
+// Extract all nested key paths
+type Keys = DeepStrictObjectKeys<User>;
+// "id" | "profile" | "profile.name" | "profile.age" | "posts" | "posts[*].title" | "posts[*].tags"
 
-### Example
+// Pick only what you need
+type NameOnly = DeepStrictPick<User, 'profile.name'>;
+// { profile: { name: string } }
 
-Below is an example of how to apply `DeepStrictOmit` to both nested objects and objects within arrays.
+// Remove what you don't need
+type NoAge = DeepStrictOmit<User, 'profile.age'>;
+// { id: string; profile: { name: string }; posts: { title: string; tags: string[] }[] }
+```
+
+## Core Types
+
+### `DeepStrictObjectKeys<T>`
+
+Extracts all keys from a nested object as a union of dot-notation string paths. Arrays use `[*]` notation.
 
 ```typescript
-// Define an example object type
 type Example = {
   user: {
-    id: string;
-    profile: {
-      name: string;
-      age: number;
-      email: string;
-    };
-    posts: {
-      title: string;
-      content: string;
-      meta: {
-        likes: number;
-        shares: number;
-      };
-    }[];
+    name: string;
+    address: { city: string; zip: number };
   };
 };
 
-// Remove the keys 'user.profile.email' and 'user.posts[*].meta.shares'
-type Omitted = DeepStrictOmit<Example, 'user.profile.email' | 'user.posts[*].meta.shares'>;
-
-/*
-  Resulting type Omitted:
-  {
-    user: {
-      id: string;
-      profile: {
-        name: string;
-        age: number;
-      };
-      posts: {
-        title: string;
-        content: string;
-        meta: {
-          likes: number;
-        };
-      }[];
-    };
-  }
-*/
+type Keys = DeepStrictObjectKeys<Example>;
+// "user" | "user.name" | "user.address" | "user.address.city" | "user.address.zip"
 ```
 
-In short, with `DeepStrictOmit` you can neatly remove only the keys you want from even the most complex nested objects or arrays.
-
-## DeepStrictPick
-
-`DeepStrictPick` creates a new type by selecting only the specified keys from a nested object type.
-It works like the built-in `Pick` but lets you precisely choose key paths—even in nested structures and arrays—so you only get the properties you need.
-
-### Key Features
+```typescript
+type WithArray = { items: { name: string; price: number }[] };
 
-- **Pick Nested Keys:** Specify a nested key path like `"user.profile.name"` to pick only that property.
-- **Handles Arrays:** It also works on objects within arrays, allowing you to extract just the desired data.
-- **Accurate Type Inference:** It builds a type that only includes the selected properties, enhancing both type safety and readability.
-- **Flexible:** You can specify multiple nested keys at once.
+type Keys = DeepStrictObjectKeys<WithArray>;
+// "items" | "items[*].name" | "items[*].price"
+```
 
-### Example
+### `DeepStrictPick<T, K>`
 
-Below is an example of using `DeepStrictPick` on nested objects and arrays.
+Creates a new type by selecting only the specified nested keys, preserving the object structure.
 
 ```typescript
-// Define an example object type
 type Example = {
   user: {
     id: string;
-    profile: {
-      name: string;
-      age: number;
-      email: string;
-    };
-    posts: {
-      title: string;
-      content: string;
-      meta: {
-        likes: number;
-        shares: number;
-      };
-    }[];
+    profile: { name: string; age: number; email: string };
+    posts: { title: string; content: string; meta: { likes: number; shares: number } }[];
   };
 };
 
-// Pick only the keys 'user.profile.name' and 'user.posts[*].meta.likes'
 type Picked = DeepStrictPick<Example, 'user.profile.name' | 'user.posts[*].meta.likes'>;
-
 /*
-  Resulting type Picked:
   {
     user: {
-      profile: {
-        name: string;
-      };
-      posts: {
-        meta: {
-          likes: number;
-        };
-      }[];
+      profile: { name: string };
+      posts: { meta: { likes: number } }[];
     };
   }
 */
 ```
 
-So, `DeepStrictPick` lets you extract only the properties you want from even the most deeply nested structures.
-
-## StringToDeepObject
-
-`StringToDeepObject` takes a string path in dot notation and generates a nested object type corresponding to that path.
-It parses the path string step by step, building a nested object and assigning the desired type to the final property.
+### `DeepStrictOmit<T, K>`
 
-### Key Features
-
-- **Parses Path Strings:** Converts a string like "user.profile.name" into an object where each segment becomes a key.
-- **Dynamically Creates Objects:** Automatically builds a nested object based on the path, assigning the specified type at the end.
-- **Merges Union Types:** If you pass a union of path strings, it merges the resulting objects into one combined type.
-- **Type Safe:** Handles string paths safely within the type system to accurately represent nested structures.
-
-### Example
+Creates a new type by removing the specified nested keys.
 
 ```typescript
-// Example: Assigning a string type to the path 'user.profile.name'
-type DeepObj = StringToDeepObject<'user.profile.name', string>;
-
+type Omitted = DeepStrictOmit<Example, 'user.profile.email' | 'user.posts[*].meta.shares'>;
 /*
-  Resulting type DeepObj:
   {
     user: {
-      profile: {
-        name: string;
-      };
+      id: string;
+      profile: { name: string; age: number };
+      posts: { title: string; content: string; meta: { likes: number } }[];
     };
   }
 */
+```
 
-// Another example: Assigning a number type at the end of a path
-type DeepNumberObj = StringToDeepObject<'settings.display.brightness', number>;
+### `DeepStrictMerge<Target, Source>`
 
-/*
-  Resulting type DeepNumberObj:
-  {
-    settings: {
-      display: {
-        brightness: number;
-      };
-    };
-  }
-*/
+Deeply merges two object types. When both types share a key, `Target` takes precedence.
 
-// Union type example: Two paths merge into one combined object type
-type MergedObj = StringToDeepObject<'user.profile.name' | 'user.profile.age', string | number>;
+```typescript
+type A = { user: { id: string; profile: { name: string } } };
+type B = { user: { profile: { email: string }; settings: { theme: string } } };
 
+type Merged = DeepStrictMerge<A, B>;
 /*
-  Resulting type MergedObj:
   {
     user: {
-      profile: {
-        name: string;
-        age: number;
-      };
+      id: string;
+      profile: { name: string; email: string };
+      settings: { theme: string };
     };
   }
 */
 ```
 
-In short, `StringToDeepObject` lets you quickly create nested object types from a dot-delimited string, and even merge multiple paths if needed.
+Arrays of objects are also merged element-wise:
 
-## DeepStrictMerge
-
-`DeepStrictMerge` deeply merges two or more object types into a single unified type.
-It recursively combines every property in nested structures, and when the same key exists in multiple objects, it follows a set of rules to merge them.
-
-### Key Features
+```typescript
+type Merged = DeepStrictMerge<{ a: number }[], { b: string }[]>;
+// { a: number; b: string }[]
+```
 
-- **Deep Merge:** Recursively merges not only top-level properties but also all nested objects.
-- **Accurate Type Inference:** Each object’s type information is retained in the merged result, ensuring type safety.
-- **Conflict Resolution:** When the same key exists in multiple objects, it resolves the conflict according to defined rules.
-- **Flexible:** You can merge several object types at once, making it easy to manage complex data structures.
+### `GetType<T, K>`
 
-### Example
+Extracts the type at a specific nested path.
 
 ```typescript
-// Define two object types to merge
-type ObjA = {
+type Data = {
   user: {
-    id: string;
-    profile: {
-      name: string;
-      age: number;
-    };
+    name: string;
+    posts: { title: string; tags: string[] }[];
   };
 };
 
-type ObjB = {
-  user: {
-    profile: {
-      email: string;
-      // If both objects have the key 'age', the merge rule applies.
-      age: number;
-    };
-    settings: {
-      theme: string;
-    };
-  };
+type T1 = GetType<Data, 'user.name'>;           // string
+type T2 = GetType<Data, 'user.posts'>;           // { title: string; tags: string[] }[]
+type T3 = GetType<Data, 'user.posts[*].title'>;  // string
+type T4 = GetType<Data, 'user.posts[*].tags'>;   // string[]
+```
+
+### `DeepDateToString<T>`
+
+Recursively converts all `Date` types to `string`. Useful for representing serialized/JSON response types.
+
+```typescript
+type Input = {
+  createdAt: Date;
+  user: { name: string; birthDate: Date };
 };
 
-// Deep merge the two objects into one type
-type Merged = DeepStrictMerge<ObjA, ObjB>;
+type Output = DeepDateToString<Input>;
+// { createdAt: string; user: { name: string; birthDate: string } }
+```
 
-/*
-  Resulting type Merged:
-  {
-    user: {
-      id: string;
-      profile: {
-        name: string;
-        age: number;  // Merged according to the rules
-        email: string;
-      };
-      settings: {
-        theme: string;
-      };
-    };
-  }
-*/
+### `DeepStrictUnbrand<T>`
+
+Recursively removes branding (e.g., `typia` tags like `Format<'uuid'>`) from types, restoring base primitives.
+
+```typescript
+type Branded = {
+  id: string & { __brand: 'uuid' };
+  profile: { email: string & { __brand: 'email' } };
+};
+
+type Clean = DeepStrictUnbrand<Branded>;
+// { id: string; profile: { email: string } }
 ```
 
-So, `DeepStrictMerge` lets you seamlessly combine different object types into one, even when they have complex nested structures.
+## Runtime Functions
 
-## DeepDateToString
+### `deepStrictObjectKeys(obj)`
 
-`DeepDateToString` finds every `Date` type in an object and converts it to a `string` recursively.
-It locates all `Date` properties—even deep within nested objects or arrays—and converts them to strings, which is especially useful for serialization or JSON conversion.
+Runtime counterpart of `DeepStrictObjectKeys`. Returns an array of all dot-notation key paths.
 
-### Key Features
+```typescript
+import { deepStrictObjectKeys } from '@kakasoo/deep-strict-types';
+
+const keys = deepStrictObjectKeys({ a: { b: 1, c: 2 } });
+// ["a", "a.b", "a.c"]
+```
 
-- **Recursive Conversion:** It transforms every `Date` type found in the object, including those in nested objects and arrays.
-- **Ensures Type Consistency:** By explicitly converting `Date` to `string`, it prevents type mismatches during serialization or API responses.
-- **Handles Complex Structures:** Works reliably even with deeply nested objects and arrays containing `Date` values.
+### `deepStrictAssert(obj)(key)`
 
-### Example
+Curried runtime function that extracts a specific nested property, preserving the object structure. Type-safe counterpart of `DeepStrictPick`.
 
 ```typescript
-// Define an example object type
-type Example = {
-  createdAt: Date;
-  updatedAt: Date;
-  user: {
-    name: string;
-    birthDate: Date;
-    posts: {
-      title: string;
-      publishedAt: Date;
-    }[];
-  };
-};
+import { deepStrictAssert } from '@kakasoo/deep-strict-types';
 
-// Convert all Date properties to string using DeepDateToString
-type StringifiedExample = DeepDateToString<Example>;
+const data = {
+  user: { name: 'Alice', age: 30 },
+  posts: [{ title: 'Hello', content: 'World' }],
+};
 
-/*
-  Resulting type StringifiedExample:
-  {
-    createdAt: string;
-    updatedAt: string;
-    user: {
-      name: string;
-      birthDate: string;
-      posts: {
-        title: string;
-        publishedAt: string;
-      }[];
-    };
-  }
-*/
+const result = deepStrictAssert(data)('user.name');
+// { user: { name: 'Alice' } }
 ```
 
-In short, `DeepDateToString` makes sure that every `Date` inside an object is converted to a `string`, ensuring type consistency for operations like serialization or JSON conversion.
+## Utility Types
+
+| Type | Description | Example |
+|------|-------------|---------|
+| `DeepStrictObjectLastKeys<T>` | Extracts only the leaf-level (deepest) keys | `"a.b.c"` instead of `"a" \| "a.b" \| "a.b.c"` |
+| `StringToDeepObject<T>` | Converts a comma-separated dot-notation string to a nested object type | `StringToDeepObject<"a.b,c">` = `{ a: { b: any }; c: any }` |
+| `Equal<X, Y>` | Type-level equality check (returns `true` or `false`) | `Equal<string, string>` = `true` |
+| `ElementOf<T>` | Extracts the element type from an array | `ElementOf<string[]>` = `string` |
+| `IsAny<T>` | Checks if a type is `any` | `IsAny<any>` = `true` |
+| `IsUnion<T>` | Checks if a type is a union | `IsUnion<string \| number>` = `true` |
+| `ValueType` | Union of all primitive types + `Date` | `string \| number \| boolean \| ...` |
+| `GetMember<T, Prefix>` | Extracts key segments after a dot-notation prefix | Internal helper for `DeepStrictOmit` |
+| `GetElementMember<T, Prefix>` | Extracts array element sub-keys after a `[*]` prefix | Internal helper for `DeepStrictOmit` |
+| `RemoveAfterDot<T, K>` | Generates wildcard patterns for descendant keys | Internal helper for `DeepStrictPick` |
+| `RemoveArraySymbol<T>` | Strips `[*]` suffix from a key string | `RemoveArraySymbol<"items[*]">` = `"items"` |
+| `RemoveLastProperty<T>` | Extracts all parent path segments | `RemoveLastProperty<"a.b.c">` = `"a" \| "a.b"` |
+
+## License
+
+ISC

package/bin/src/functions/DeepStrictAssert.d.ts

@@ -1,4 +1,25 @@
 import { DeepStrictObjectKeys } from '../types/DeepStrictObjectKeys';
 import { DeepStrictPick } from '../types/DeepStrictPick';
+/**
+ * @title Runtime Function for Type-Safe Deep Property Extraction.
+ *
+ * A curried function that takes an object and returns a picker function.
+ * The picker function accepts a dot-notation key path and returns a new object
+ * containing only the specified nested property, preserving the original structure.
+ *
+ * This is the runtime counterpart of the {@link DeepStrictPick} type.
+ *
+ * @deprecated Use {@link deepStrictPick} instead. This curried form will be removed in a future version.
+ *
+ * @template T - The object type of the input
+ * @param input - The source object to extract properties from
+ * @returns A function that accepts a key path `K` and returns the deeply-picked result
+ *
+ * @example
+ * ```ts
+ * const result = deepStrictAssert({ a: { b: 1, c: 2 } })('a.b');
+ * // result: { a: { b: 1 } }
+ * ```
+ */
 export declare const deepStrictAssert: <T extends object>(input: T) => <K extends DeepStrictObjectKeys<T>>(key: K) => DeepStrictPick<T, K>;
 //# sourceMappingURL=DeepStrictAssert.d.ts.map

package/bin/src/functions/DeepStrictAssert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DeepStrictAssert.d.ts","sourceRoot":"","sources":["../../../src/functions/DeepStrictAssert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAEzD,eAAO,MAAM,gBAAgB,GAC1B,CAAC,SAAS,MAAM,SAAS,CAAC,MAC1B,CAAC,SAAS,oBAAoB,CAAC,CAAC,CAAC,OAAO,CAAC,KAAG,cAAc,CAAC,CAAC,EAAE,CAAC,CAiC/D,CAAC"}
+{"version":3,"file":"DeepStrictAssert.d.ts","sourceRoot":"","sources":["../../../src/functions/DeepStrictAssert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,gBAAgB,GAC1B,CAAC,SAAS,MAAM,SAAS,CAAC,MAC1B,CAAC,SAAS,oBAAoB,CAAC,CAAC,CAAC,OAAO,CAAC,KAAG,cAAc,CAAC,CAAC,EAAE,CAAC,CAiC/D,CAAC"}

package/bin/src/functions/DeepStrictAssert.js

@@ -1,6 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deepStrictAssert = void 0;
+/**
+ * @title Runtime Function for Type-Safe Deep Property Extraction.
+ *
+ * A curried function that takes an object and returns a picker function.
+ * The picker function accepts a dot-notation key path and returns a new object
+ * containing only the specified nested property, preserving the original structure.
+ *
+ * This is the runtime counterpart of the {@link DeepStrictPick} type.
+ *
+ * @deprecated Use {@link deepStrictPick} instead. This curried form will be removed in a future version.
+ *
+ * @template T - The object type of the input
+ * @param input - The source object to extract properties from
+ * @returns A function that accepts a key path `K` and returns the deeply-picked result
+ *
+ * @example
+ * ```ts
+ * const result = deepStrictAssert({ a: { b: 1, c: 2 } })('a.b');
+ * // result: { a: { b: 1 } }
+ * ```
+ */
 const deepStrictAssert = (input) => (key) => {
     const keys = key.split(/(?:\[\*\])?\./g).filter(Boolean);
     const traverse = (input, keys) => {

package/bin/src/functions/DeepStrictAssert.js.map

@@ -1 +1 @@
-{"version":3,"file":"DeepStrictAssert.js","sourceRoot":"","sources":["../../../src/functions/DeepStrictAssert.ts"],"names":[],"mappings":";;;AAGO,MAAM,gBAAgB,GAC3B,CAAmB,KAAQ,EAAE,EAAE,CAC/B,CAAoC,GAAM,EAAwB,EAAE;IAClE,MAAM,IAAI,GAAG,GAAG,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAEzD,MAAM,QAAQ,GAAG,CAAC,KAAkD,EAAE,IAAc,EAAO,EAAE;QAC3F,MAAM,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;QAE9B,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;YAC3B,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE;gBACrC,IAAI,KAAK,IAAI,OAAO,EAAE,CAAC;oBACrB,IAAI,OAAO,OAAO,CAAC,KAAK,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,CAAC,KAAK,IAAI,EAAE,CAAC;wBAClE,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC;oBACrD,CAAC;oBAED,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;gBACrC,CAAC;gBAED,OAAO,OAAO,CAAC;YACjB,CAAC,CAAC,CAAC;YAEH,OAAO,QAAQ,CAAC;QAClB,CAAC;aAAM,CAAC;YACN,IAAI,KAAK,IAAI,KAAK,EAAE,CAAC;gBACnB,IAAI,OAAO,KAAK,CAAC,KAAK,CAAC,KAAK,QAAQ,IAAI,KAAK,CAAC,KAAK,CAAC,KAAK,IAAI,EAAE,CAAC;oBAC9D,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC;gBACnD,CAAC;gBACD,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;YACnC,CAAC;YAED,MAAM,IAAI,KAAK,CAAC,2BAA2B,KAAK,EAAE,CAAC,CAAC;QACtD,CAAC;IACH,CAAC,CAAC;IAEF,OAAO,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAyB,CAAC;AACvD,CAAC,CAAC;AAnCS,QAAA,gBAAgB,oBAmCzB"}
+{"version":3,"file":"DeepStrictAssert.js","sourceRoot":"","sources":["../../../src/functions/DeepStrictAssert.ts"],"names":[],"mappings":";;;AAGA;;;;;;;;;;;;;;;;;;;;GAoBG;AACI,MAAM,gBAAgB,GAC3B,CAAmB,KAAQ,EAAE,EAAE,CAC/B,CAAoC,GAAM,EAAwB,EAAE;IAClE,MAAM,IAAI,GAAG,GAAG,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAEzD,MAAM,QAAQ,GAAG,CAAC,KAAkD,EAAE,IAAc,EAAO,EAAE;QAC3F,MAAM,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;QAE9B,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;YAC3B,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE;gBACrC,IAAI,KAAK,IAAI,OAAO,EAAE,CAAC;oBACrB,IAAI,OAAO,OAAO,CAAC,KAAK,CAAC,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,CAAC,KAAK,IAAI,EAAE,CAAC;wBAClE,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC;oBACrD,CAAC;oBAED,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;gBACrC,CAAC;gBAED,OAAO,OAAO,CAAC;YACjB,CAAC,CAAC,CAAC;YAEH,OAAO,QAAQ,CAAC;QAClB,CAAC;aAAM,CAAC;YACN,IAAI,KAAK,IAAI,KAAK,EAAE,CAAC;gBACnB,IAAI,OAAO,KAAK,CAAC,KAAK,CAAC,KAAK,QAAQ,IAAI,KAAK,CAAC,KAAK,CAAC,KAAK,IAAI,EAAE,CAAC;oBAC9D,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC;gBACnD,CAAC;gBACD,OAAO,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;YACnC,CAAC;YAED,MAAM,IAAI,KAAK,CAAC,2BAA2B,KAAK,EAAE,CAAC,CAAC;QACtD,CAAC;IACH,CAAC,CAAC;IAEF,OAAO,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAyB,CAAC;AACvD,CAAC,CAAC;AAnCS,QAAA,gBAAgB,oBAmCzB"}

package/bin/src/functions/DeepStrictObjectKeys.d.ts

@@ -1,6 +1,13 @@
 import { DeepStrictObjectKeys } from '../types';
+/** @internal Removes a leading dot from a string type. e.g., `".foo"` becomes `"foo"`. */
 type RemoveStartWithDot<T extends string> = T extends `.${infer R extends string}` ? R : T;
+/** @internal Replaces all `[*]` array notation with `${number}` for runtime key path access. */
 type Replace<S extends string> = S extends '[*]' ? `${number}` : S extends `[*].${infer Rest}` ? `${number}.${Replace<Rest>}` : S extends `${infer Prefix extends string}.[*]${infer Rest}` ? `${Prefix}.${number}${Replace<Rest>}` : S extends `${infer Prefix extends string}[*]${infer Rest}` ? `${Prefix}.${number}${Replace<Rest>}` : S;
+/**
+ * @internal The return type for {@link deepStrictObjectKeys}.
+ * Converts type-level keys (with `[*]` notation) to runtime-friendly keys (with `${number}` notation),
+ * strips leading dots, and wraps the result in an array type.
+ */
 type ReturnType<Target extends object, Joiner extends {
     array: string;
     object: string;
@@ -8,6 +15,26 @@ type ReturnType<Target extends object, Joiner extends {
     array: '[*]';
     object: '.';
 }> = [Target] extends [never] ? [] : RemoveStartWithDot<Replace<DeepStrictObjectKeys<Target, Joiner, false>>>[];
+/**
+ * @title Runtime Function for Extracting All Nested Keys from an Object.
+ *
+ * Recursively traverses the input object and returns a flat array of all key paths
+ * using dot notation. Nested objects produce paths like `"a.b.c"`, and arrays produce
+ * indexed paths at runtime.
+ *
+ * This is the runtime counterpart of the {@link DeepStrictObjectKeys} type.
+ *
+ * @template Target - The object type to extract keys from
+ * @template Joiner - Separator symbols (defaults to `{ array: '[*]', object: '.' }`)
+ * @param target - The object instance to extract keys from
+ * @returns An array of all dot-notation key paths in the object
+ *
+ * @example
+ * ```ts
+ * const keys = deepStrictObjectKeys({ a: { b: 1, c: 2 } });
+ * // keys: ["a", "a.b", "a.c"]
+ * ```
+ */
 export declare function deepStrictObjectKeys<Target extends object, Joiner extends {
     array: string;
     object: string;

package/bin/src/functions/DeepStrictObjectKeys.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DeepStrictObjectKeys.d.ts","sourceRoot":"","sources":["../../../src/functions/DeepStrictObjectKeys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAEhD,KAAK,kBAAkB,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,IAAI,MAAM,CAAC,SAAS,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;AAE3F,KAAK,OAAO,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,KAAK,GAC5C,GAAG,MAAM,EAAE,GACX,CAAC,SAAS,OAAO,MAAM,IAAI,EAAE,GAC3B,GAAG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,EAAE,GAC5B,CAAC,SAAS,GAAG,MAAM,MAAM,SAAS,MAAM,OAAO,MAAM,IAAI,EAAE,GACzD,GAAG,MAAM,IAAI,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,EAAE,GACrC,CAAC,SAAS,GAAG,MAAM,MAAM,SAAS,MAAM,MAAM,MAAM,IAAI,EAAE,GACxD,GAAG,MAAM,IAAI,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,EAAE,GACrC,CAAC,CAAC;AAEZ,KAAK,UAAU,CACb,MAAM,SAAS,MAAM,EACrB,MAAM,SAAS;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,GAAG,CAAA;CAAE,IAC9E,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,kBAAkB,CAAC,OAAO,CAAC,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;AAE/G,wBAAgB,oBAAoB,CAClC,MAAM,SAAS,MAAM,EACrB,MAAM,SAAS;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,GAAG,CAAA;CAAE,EAChF,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAqB5C"}
+{"version":3,"file":"DeepStrictObjectKeys.d.ts","sourceRoot":"","sources":["../../../src/functions/DeepStrictObjectKeys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAEhD,0FAA0F;AAC1F,KAAK,kBAAkB,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,IAAI,MAAM,CAAC,SAAS,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;AAE3F,gGAAgG;AAChG,KAAK,OAAO,CAAC,CAAC,SAAS,MAAM,IAAI,CAAC,SAAS,KAAK,GAC5C,GAAG,MAAM,EAAE,GACX,CAAC,SAAS,OAAO,MAAM,IAAI,EAAE,GAC3B,GAAG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,EAAE,GAC5B,CAAC,SAAS,GAAG,MAAM,MAAM,SAAS,MAAM,OAAO,MAAM,IAAI,EAAE,GACzD,GAAG,MAAM,IAAI,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,EAAE,GACrC,CAAC,SAAS,GAAG,MAAM,MAAM,SAAS,MAAM,MAAM,MAAM,IAAI,EAAE,GACxD,GAAG,MAAM,IAAI,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,EAAE,GACrC,CAAC,CAAC;AAEZ;;;;GAIG;AACH,KAAK,UAAU,CACb,MAAM,SAAS,MAAM,EACrB,MAAM,SAAS;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,GAAG,CAAA;CAAE,IAC9E,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,EAAE,GAAG,kBAAkB,CAAC,OAAO,CAAC,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;AAE/G;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,SAAS,MAAM,EACrB,MAAM,SAAS;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,KAAK,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,GAAG,CAAA;CAAE,EAChF,MAAM,EAAE,MAAM,GAAG,UAAU,CAAC,MAAM,EAAE,MAAM,CAAC,CAqB5C"}