typia 9.7.1 → 10.0.0-dev.20251107

package/package.json

@@ -1,121 +1,122 @@
-{
-  "name": "typia",
-  "version": "9.7.1",
-  "description": "Superfast runtime validators with only one line",
-  "main": "lib/index.js",
-  "typings": "lib/index.d.ts",
-  "module": "lib/index.mjs",
-  "bin": {
-    "typia": "./lib/executable/typia.js"
-  },
-  "tsp": {
-    "tscOptions": {
-      "parseAllJsDoc": true
-    }
-  },
-  "scripts": {
-    "test": "ts-node deploy --tag test",
-    "test:template": "npm run --tag test --template",
-    "-------------------------------------------------": "",
-    "build": "rimraf lib && tsc && rollup -c",
-    "dev": "rimraf lib && tsc --watch",
-    "dev:errors": "tsc --project tsconfig.errors.json --watch",
-    "eslint": "eslint",
-    "eslint:fix": "eslint --fix",
-    "prettier": "prettier src --check",
-    "prettier:fix": "prettier src --write",
-    "------------------------------------------------": "",
-    "package:latest": "ts-node deploy --tag latest",
-    "package:next": "ts-node deploy --tag next",
-    "package:patch": "ts-node deploy --tag patch",
-    "package:tgz": "ts-node deploy/tgz.ts"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/samchon/typia"
-  },
-  "author": "Jeongho Nam",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/samchon/typia/issues"
-  },
-  "homepage": "https://typia.io",
-  "dependencies": {
-    "@samchon/openapi": "^4.7.1",
-    "@standard-schema/spec": "^1.0.0",
-    "commander": "^10.0.0",
-    "comment-json": "^4.2.3",
-    "inquirer": "^8.2.5",
-    "package-manager-detector": "^0.2.0",
-    "randexp": "^0.5.3"
-  },
-  "peerDependencies": {
-    "typescript": ">=4.8.0 <5.10.0"
-  },
-  "devDependencies": {
-    "@rollup/plugin-commonjs": "^26.0.1",
-    "@rollup/plugin-node-resolve": "^15.2.3",
-    "@rollup/plugin-typescript": "^11.1.6",
-    "@trivago/prettier-plugin-sort-imports": "^4.3.0",
-    "@types/inquirer": "^8.2.5",
-    "@types/node": "^18.15.12",
-    "@types/ts-expose-internals": "npm:ts-expose-internals@5.6.3",
-    "@typescript-eslint/eslint-plugin": "^8.1.0",
-    "@typescript-eslint/parser": "^8.1.0",
-    "chalk": "^4.0.0",
-    "eslint-plugin-deprecation": "^3.0.0",
-    "prettier": "^3.2.5",
-    "rimraf": "^5.0.5",
-    "rollup": "^4.18.0",
-    "rollup-plugin-auto-external": "^2.0.0",
-    "rollup-plugin-node-externals": "^8.0.0",
-    "suppress-warnings": "^1.0.2",
-    "tinyglobby": "^0.2.12",
-    "ts-node": "^10.9.2",
-    "typescript": "~5.9.2"
-  },
-  "sideEffects": false,
-  "files": [
-    "LICENSE",
-    "README.md",
-    "package.json",
-    "lib",
-    "src"
-  ],
-  "keywords": [
-    "fast",
-    "json",
-    "stringify",
-    "typescript",
-    "transform",
-    "ajv",
-    "io-ts",
-    "zod",
-    "schema",
-    "json-schema",
-    "generator",
-    "assert",
-    "clone",
-    "is",
-    "validate",
-    "equal",
-    "runtime",
-    "type",
-    "typebox",
-    "checker",
-    "validator",
-    "safe",
-    "parse",
-    "prune",
-    "random",
-    "protobuf",
-    "llm",
-    "llm-function-calling",
-    "structured-output",
-    "openai",
-    "chatgpt",
-    "claude",
-    "gemini",
-    "llama"
-  ]
+{
+  "name": "typia",
+  "version": "10.0.0-dev.20251107",
+  "description": "Superfast runtime validators with only one line",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "module": "lib/index.mjs",
+  "bin": {
+    "typia": "./lib/executable/typia.js"
+  },
+  "tsp": {
+    "tscOptions": {
+      "parseAllJsDoc": true
+    }
+  },
+  "scripts": {
+    "test": "ts-node deploy --tag test",
+    "test:template": "npm run --tag test --template",
+    "-------------------------------------------------": "",
+    "build": "rimraf lib && tsc && rollup -c",
+    "dev": "rimraf lib && tsc --watch",
+    "dev:errors": "tsc --project tsconfig.errors.json --watch",
+    "eslint": "eslint",
+    "eslint:fix": "eslint --fix",
+    "prettier": "prettier src --check",
+    "prettier:fix": "prettier src --write",
+    "------------------------------------------------": "",
+    "package:latest": "ts-node deploy --tag latest",
+    "package:next": "ts-node deploy --tag next",
+    "package:patch": "ts-node deploy --tag patch",
+    "package:tgz": "ts-node deploy/tgz.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/samchon/typia"
+  },
+  "author": "Jeongho Nam",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/samchon/typia/issues"
+  },
+  "homepage": "https://typia.io",
+  "dependencies": {
+    "@samchon/openapi": "^5.0.0-dev.20251107",
+    "@standard-schema/spec": "^1.0.0",
+    "commander": "^10.0.0",
+    "comment-json": "^4.2.3",
+    "inquirer": "^8.2.5",
+    "package-manager-detector": "^0.2.0",
+    "randexp": "^0.5.3"
+  },
+  "peerDependencies": {
+    "typescript": ">=4.8.0 <5.10.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^26.0.1",
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "@rollup/plugin-typescript": "^11.1.6",
+    "@trivago/prettier-plugin-sort-imports": "^4.3.0",
+    "@types/inquirer": "^8.2.5",
+    "@types/node": "^18.15.12",
+    "@types/ts-expose-internals": "npm:ts-expose-internals@5.6.3",
+    "@typescript-eslint/eslint-plugin": "^8.1.0",
+    "@typescript-eslint/parser": "^8.1.0",
+    "chalk": "^4.0.0",
+    "eslint-plugin-deprecation": "^3.0.0",
+    "prettier": "^3.2.5",
+    "prettier-plugin-jsdoc": "^1.3.3",
+    "rimraf": "^5.0.5",
+    "rollup": "^4.18.0",
+    "rollup-plugin-auto-external": "^2.0.0",
+    "rollup-plugin-node-externals": "^8.0.0",
+    "suppress-warnings": "^1.0.2",
+    "tinyglobby": "^0.2.12",
+    "ts-node": "^10.9.2",
+    "typescript": "~5.9.2"
+  },
+  "sideEffects": false,
+  "files": [
+    "LICENSE",
+    "README.md",
+    "package.json",
+    "lib",
+    "src"
+  ],
+  "keywords": [
+    "fast",
+    "json",
+    "stringify",
+    "typescript",
+    "transform",
+    "ajv",
+    "io-ts",
+    "zod",
+    "schema",
+    "json-schema",
+    "generator",
+    "assert",
+    "clone",
+    "is",
+    "validate",
+    "equal",
+    "runtime",
+    "type",
+    "typebox",
+    "checker",
+    "validator",
+    "safe",
+    "parse",
+    "prune",
+    "random",
+    "protobuf",
+    "llm",
+    "llm-function-calling",
+    "structured-output",
+    "openai",
+    "chatgpt",
+    "claude",
+    "gemini",
+    "llama"
+  ]
 }

package/src/AssertionGuard.ts

@@ -1,39 +1,41 @@
-/**
- * Type definition for assertion guard functions in `typia`.
- *
- * An assertion guard is a function that asserts an input value's type at runtime
- * and performs a TypeScript type assertion if validation passes. Unlike regular
- * assertion functions that return the validated value, assertion guards return
- * nothing but automatically cast the input parameter to the expected type `T`.
- *
- * This type is used by `typia.createAssertGuard<T>()` and `typia.createAssertGuardEquals<T>()`
- * to generate reusable assertion guard functions.
- *
- * @template T - The expected type to validate and assert against
- * @param input - The value to validate (type unknown)
- * @throws {TypeGuardError} When the input value doesn't match the expected type T
- * @returns void - Returns nothing, but asserts that input is type T
- *
- * @example
- * ```typescript
- * interface IMember {
- *   name: string;
- *   age: number;
- * }
- *
- * // Create reusable assertion guard
- * const assertMember: AssertionGuard<IMember> = typia.createAssertGuard<IMember>();
- *
- * // Usage - input will be automatically cast to IMember if validation passes
- * const unknownData: unknown = { name: "John", age: 25 };
- *
- * assertMember(unknownData);
- * // After this line, unknownData is automatically treated as IMember type
- * console.log(unknownData.name); // TypeScript knows this is safe
- * ```
- *
- * @see {@link https://github.com/samchon/typia#assertguard-functions} Typia assertion guards documentation
- * @see {@link TypeGuardError} Error thrown when assertion fails
- * @author Jeongho Nam - https://github.com/samchon
- */
-export type AssertionGuard<T> = (input: unknown) => asserts input is T;
+/**
+ * Type definition for assertion guard functions in `typia`.
+ *
+ * An assertion guard is a function that asserts an input value's type at
+ * runtime and performs a TypeScript type assertion if validation passes. Unlike
+ * regular assertion functions that return the validated value, assertion guards
+ * return nothing but automatically cast the input parameter to the expected
+ * type `T`.
+ *
+ * This type is used by `typia.createAssertGuard<T>()` and
+ * `typia.createAssertGuardEquals<T>()` to generate reusable assertion guard
+ * functions.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @example
+ *   ```typescript
+ *   interface IMember {
+ *     name: string;
+ *     age: number;
+ *   }
+ *
+ *   // Create reusable assertion guard
+ *   const assertMember: AssertionGuard<IMember> = typia.createAssertGuard<IMember>();
+ *
+ *   // Usage - input will be automatically cast to IMember if validation passes
+ *   const unknownData: unknown = { name: "John", age: 25 };
+ *
+ *   assertMember(unknownData);
+ *   // After this line, unknownData is automatically treated as IMember type
+ *   console.log(unknownData.name); // TypeScript knows this is safe
+ *   ```;
+ *
+ * @template T - The expected type to validate and assert against
+ * @param input - The value to validate (type unknown)
+ * @returns Void - Returns nothing, but asserts that input is type T
+ * @throws {TypeGuardError} When the input value doesn't match the expected type
+ *   T
+ * @see {@link https://github.com/samchon/typia#assertguard-functions} Typia assertion guards documentation
+ * @see {@link TypeGuardError} Error thrown when assertion fails
+ */
+export type AssertionGuard<T> = (input: unknown) => asserts input is T;

package/src/CamelCase.ts

@@ -1,75 +1,75 @@
-import { Equal } from "./typings/Equal";
-import { IsTuple } from "./typings/IsTuple";
-import { NativeClass } from "./typings/NativeClass";
-import { ValueOf } from "./typings/ValueOf";
-
-/**
- * Camel case type.
- *
- * `CamelCase` type is a type that all keys of an object are camelized.
- *
- * It also erases every method property like {@link Resolved} type.
- *
- * @template T Target type to be camelized
- * @author Jeongho Nam - https://github.com/samchon
- */
-export type CamelCase<T> =
-  Equal<T, CamelizeMain<T>> extends true ? T : CamelizeMain<T>;
-
-type CamelizeMain<T> = T extends [never]
-  ? never // special trick for (jsonable | null) type
-  : T extends { valueOf(): boolean | bigint | number | string }
-    ? ValueOf<T>
-    : T extends Function
-      ? never
-      : T extends object
-        ? CamelizeObject<T>
-        : T;
-
-type CamelizeObject<T extends object> =
-  T extends Array<infer U>
-    ? IsTuple<T> extends true
-      ? CamelizeTuple<T>
-      : CamelizeMain<U>[]
-    : T extends Set<infer U>
-      ? Set<CamelizeMain<U>>
-      : T extends Map<infer K, infer V>
-        ? Map<CamelizeMain<K>, CamelizeMain<V>>
-        : T extends WeakSet<any> | WeakMap<any, any>
-          ? never
-          : T extends NativeClass
-            ? T
-            : {
-                [Key in keyof T as CamelizeString<Key & string>]: CamelizeMain<
-                  T[Key]
-                >;
-              };
-
-type CamelizeTuple<T extends readonly any[]> = T extends []
-  ? []
-  : T extends [infer F]
-    ? [CamelizeMain<F>]
-    : T extends [infer F, ...infer Rest extends readonly any[]]
-      ? [CamelizeMain<F>, ...CamelizeTuple<Rest>]
-      : T extends [(infer F)?]
-        ? [CamelizeMain<F>?]
-        : T extends [(infer F)?, ...infer Rest extends readonly any[]]
-          ? [CamelizeMain<F>?, ...CamelizeTuple<Rest>]
-          : [];
-
-type CamelizeString<Key extends string> = Key extends `_${infer R}`
-  ? `_${CamelizeString<R>}`
-  : Key extends `${infer _F}_${infer _R}`
-    ? CamelizeSnakeString<Key>
-    : Key extends Uppercase<Key>
-      ? Lowercase<Key>
-      : CamelizePascalString<Key>;
-type CamelizePascalString<Key extends string> =
-  Key extends `${infer F}${infer R}` ? `${Lowercase<F>}${R}` : Key;
-type CamelizeSnakeString<Key extends string> = Key extends `_${infer R}`
-  ? CamelizeSnakeString<R>
-  : Key extends `${infer F}_${infer M}${infer R}`
-    ? M extends "_"
-      ? CamelizeSnakeString<`${F}_${R}`>
-      : `${Lowercase<F>}${Uppercase<M>}${CamelizeSnakeString<R>}`
-    : Lowercase<Key>;
+import { Equal } from "./typings/Equal";
+import { IsTuple } from "./typings/IsTuple";
+import { NativeClass } from "./typings/NativeClass";
+import { ValueOf } from "./typings/ValueOf";
+
+/**
+ * Camel case type.
+ *
+ * `CamelCase` type is a type that all keys of an object are camelized.
+ *
+ * It also erases every method property like {@link Resolved} type.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @template T Target type to be camelized
+ */
+export type CamelCase<T> =
+  Equal<T, CamelizeMain<T>> extends true ? T : CamelizeMain<T>;
+
+type CamelizeMain<T> = T extends [never]
+  ? never // special trick for (jsonable | null) type
+  : T extends { valueOf(): boolean | bigint | number | string }
+    ? ValueOf<T>
+    : T extends Function
+      ? never
+      : T extends object
+        ? CamelizeObject<T>
+        : T;
+
+type CamelizeObject<T extends object> =
+  T extends Array<infer U>
+    ? IsTuple<T> extends true
+      ? CamelizeTuple<T>
+      : CamelizeMain<U>[]
+    : T extends Set<infer U>
+      ? Set<CamelizeMain<U>>
+      : T extends Map<infer K, infer V>
+        ? Map<CamelizeMain<K>, CamelizeMain<V>>
+        : T extends WeakSet<any> | WeakMap<any, any>
+          ? never
+          : T extends NativeClass
+            ? T
+            : {
+                [Key in keyof T as CamelizeString<Key & string>]: CamelizeMain<
+                  T[Key]
+                >;
+              };
+
+type CamelizeTuple<T extends readonly any[]> = T extends []
+  ? []
+  : T extends [infer F]
+    ? [CamelizeMain<F>]
+    : T extends [infer F, ...infer Rest extends readonly any[]]
+      ? [CamelizeMain<F>, ...CamelizeTuple<Rest>]
+      : T extends [(infer F)?]
+        ? [CamelizeMain<F>?]
+        : T extends [(infer F)?, ...infer Rest extends readonly any[]]
+          ? [CamelizeMain<F>?, ...CamelizeTuple<Rest>]
+          : [];
+
+type CamelizeString<Key extends string> = Key extends `_${infer R}`
+  ? `_${CamelizeString<R>}`
+  : Key extends `${infer _F}_${infer _R}`
+    ? CamelizeSnakeString<Key>
+    : Key extends Uppercase<Key>
+      ? Lowercase<Key>
+      : CamelizePascalString<Key>;
+type CamelizePascalString<Key extends string> =
+  Key extends `${infer F}${infer R}` ? `${Lowercase<F>}${R}` : Key;
+type CamelizeSnakeString<Key extends string> = Key extends `_${infer R}`
+  ? CamelizeSnakeString<R>
+  : Key extends `${infer F}_${infer M}${infer R}`
+    ? M extends "_"
+      ? CamelizeSnakeString<`${F}_${R}`>
+      : `${Lowercase<F>}${Uppercase<M>}${CamelizeSnakeString<R>}`
+    : Lowercase<Key>;