@typia/interface 12.0.0-dev.20260307-2 → 12.0.0-dev.20260310

package/src/typings/SnakeCase.ts

@@ -1,126 +1,126 @@
-import { Equal } from "./internal/Equal";
-import { NativeClass } from "./internal/NativeClass";
-import { ValueOf } from "./internal/ValueOf";
-
-/**
- * Converts all object keys to snake_case.
- *
- * `SnakeCase<T>` transforms object property names to snake_case format and
- * erases methods like {@link Resolved}. Recursively processes nested
- * structures.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @template T Target type to transform
- */
-export type SnakeCase<T> =
-  Equal<T, SnakageMain<T>> extends true ? T : SnakageMain<T>;
-
-/* -----------------------------------------------------------
-    OBJECT CONVERSION
------------------------------------------------------------ */
-
-type SnakageMain<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
-        ? SnakageObject<T>
-        : T;
-
-type SnakageObject<T extends object> =
-  T extends Array<infer U>
-    ? IsTuple<T> extends true
-      ? SnakageTuple<T>
-      : SnakageMain<U>[]
-    : T extends Set<infer U>
-      ? Set<SnakageMain<U>>
-      : T extends Map<infer K, infer V>
-        ? Map<SnakageMain<K>, SnakageMain<V>>
-        : T extends WeakSet<any> | WeakMap<any, any>
-          ? never
-          : T extends NativeClass
-            ? T
-            : {
-                [Key in keyof T as SnakageString<Key & string>]: SnakageMain<
-                  T[Key]
-                >;
-              };
-
-/* -----------------------------------------------------------
-    SPECIAL CASES
------------------------------------------------------------ */
-type IsTuple<T extends readonly any[] | { length: number }> = [T] extends [
-  never,
-]
-  ? false
-  : T extends readonly any[]
-    ? number extends T["length"]
-      ? false
-      : true
-    : false;
-type SnakageTuple<T extends readonly any[]> = T extends []
-  ? []
-  : T extends [infer F]
-    ? [SnakageMain<F>]
-    : T extends [infer F, ...infer Rest extends readonly any[]]
-      ? [SnakageMain<F>, ...SnakageTuple<Rest>]
-      : T extends [(infer F)?]
-        ? [SnakageMain<F>?]
-        : T extends [(infer F)?, ...infer Rest extends readonly any[]]
-          ? [SnakageMain<F>?, ...SnakageTuple<Rest>]
-          : [];
-
-/* -----------------------------------------------------------
-    STRING CONVERTER
------------------------------------------------------------ */
-type SnakageString<Key extends string> = Key extends `${infer _}`
-  ? SnakageStringRepeatedly<Key, "">
-  : Key;
-type SnakageStringRepeatedly<
-  S extends string,
-  Previous extends string,
-> = S extends `${infer First}${infer Second}${infer Rest}`
-  ? `${Underscore<Previous, First>}${Lowercase<First>}${Underscore<
-      First,
-      Second
-    >}${Lowercase<Second>}${SnakageStringRepeatedly<Rest, Second>}`
-  : S extends `${infer First}`
-    ? `${Underscore<Previous, First>}${Lowercase<First>}`
-    : "";
-type Underscore<First extends string, Second extends string> = First extends
-  | UpperAlphabetic
-  | ""
-  | "_"
-  ? ""
-  : Second extends UpperAlphabetic
-    ? "_"
-    : "";
-type UpperAlphabetic =
-  | "A"
-  | "B"
-  | "C"
-  | "D"
-  | "E"
-  | "F"
-  | "G"
-  | "H"
-  | "I"
-  | "J"
-  | "K"
-  | "L"
-  | "M"
-  | "N"
-  | "O"
-  | "P"
-  | "Q"
-  | "R"
-  | "S"
-  | "T"
-  | "U"
-  | "V"
-  | "W"
-  | "X"
-  | "Y"
-  | "Z";
+import { Equal } from "./internal/Equal";
+import { NativeClass } from "./internal/NativeClass";
+import { ValueOf } from "./internal/ValueOf";
+
+/**
+ * Converts all object keys to snake_case.
+ *
+ * `SnakeCase<T>` transforms object property names to snake_case format and
+ * erases methods like {@link Resolved}. Recursively processes nested
+ * structures.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @template T Target type to transform
+ */
+export type SnakeCase<T> =
+  Equal<T, SnakageMain<T>> extends true ? T : SnakageMain<T>;
+
+/* -----------------------------------------------------------
+    OBJECT CONVERSION
+----------------------------------------------------------- */
+
+type SnakageMain<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
+        ? SnakageObject<T>
+        : T;
+
+type SnakageObject<T extends object> =
+  T extends Array<infer U>
+    ? IsTuple<T> extends true
+      ? SnakageTuple<T>
+      : SnakageMain<U>[]
+    : T extends Set<infer U>
+      ? Set<SnakageMain<U>>
+      : T extends Map<infer K, infer V>
+        ? Map<SnakageMain<K>, SnakageMain<V>>
+        : T extends WeakSet<any> | WeakMap<any, any>
+          ? never
+          : T extends NativeClass
+            ? T
+            : {
+                [Key in keyof T as SnakageString<Key & string>]: SnakageMain<
+                  T[Key]
+                >;
+              };
+
+/* -----------------------------------------------------------
+    SPECIAL CASES
+----------------------------------------------------------- */
+type IsTuple<T extends readonly any[] | { length: number }> = [T] extends [
+  never,
+]
+  ? false
+  : T extends readonly any[]
+    ? number extends T["length"]
+      ? false
+      : true
+    : false;
+type SnakageTuple<T extends readonly any[]> = T extends []
+  ? []
+  : T extends [infer F]
+    ? [SnakageMain<F>]
+    : T extends [infer F, ...infer Rest extends readonly any[]]
+      ? [SnakageMain<F>, ...SnakageTuple<Rest>]
+      : T extends [(infer F)?]
+        ? [SnakageMain<F>?]
+        : T extends [(infer F)?, ...infer Rest extends readonly any[]]
+          ? [SnakageMain<F>?, ...SnakageTuple<Rest>]
+          : [];
+
+/* -----------------------------------------------------------
+    STRING CONVERTER
+----------------------------------------------------------- */
+type SnakageString<Key extends string> = Key extends `${infer _}`
+  ? SnakageStringRepeatedly<Key, "">
+  : Key;
+type SnakageStringRepeatedly<
+  S extends string,
+  Previous extends string,
+> = S extends `${infer First}${infer Second}${infer Rest}`
+  ? `${Underscore<Previous, First>}${Lowercase<First>}${Underscore<
+      First,
+      Second
+    >}${Lowercase<Second>}${SnakageStringRepeatedly<Rest, Second>}`
+  : S extends `${infer First}`
+    ? `${Underscore<Previous, First>}${Lowercase<First>}`
+    : "";
+type Underscore<First extends string, Second extends string> = First extends
+  | UpperAlphabetic
+  | ""
+  | "_"
+  ? ""
+  : Second extends UpperAlphabetic
+    ? "_"
+    : "";
+type UpperAlphabetic =
+  | "A"
+  | "B"
+  | "C"
+  | "D"
+  | "E"
+  | "F"
+  | "G"
+  | "H"
+  | "I"
+  | "J"
+  | "K"
+  | "L"
+  | "M"
+  | "N"
+  | "O"
+  | "P"
+  | "Q"
+  | "R"
+  | "S"
+  | "T"
+  | "U"
+  | "V"
+  | "W"
+  | "X"
+  | "Y"
+  | "Z";

package/src/typings/SpecialFields.ts

@@ -1,13 +1,13 @@
-/**
- * Extracts property keys whose value type extends the target type.
- *
- * `SpecialFields<Instance, Target>` returns a union of property names from
- * `Instance` where the property value extends `Target`.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @template Instance Source object type
- * @template Target Target value type to match
- */
-export type SpecialFields<Instance extends object, Target> = {
-  [P in keyof Instance]: Instance[P] extends Target ? P : never;
-}[keyof Instance & string];
+/**
+ * Extracts property keys whose value type extends the target type.
+ *
+ * `SpecialFields<Instance, Target>` returns a union of property names from
+ * `Instance` where the property value extends `Target`.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @template Instance Source object type
+ * @template Target Target value type to match
+ */
+export type SpecialFields<Instance extends object, Target> = {
+  [P in keyof Instance]: Instance[P] extends Target ? P : never;
+}[keyof Instance & string];

package/src/typings/ValidationPipe.ts

@@ -1,20 +1,20 @@
-/**
- * Discriminated union for validation results.
- *
- * `ValidationPipe<T, E>` represents either a successful validation with data of
- * type `T`, or a failed validation with an array of errors of type `E`. Use the
- * `success` discriminant to narrow the type.
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @template T Success data type
- * @template E Error type
- */
-export type ValidationPipe<T, E> =
-  | {
-      success: true;
-      data: T;
-    }
-  | {
-      success: false;
-      errors: E[];
-    };
+/**
+ * Discriminated union for validation results.
+ *
+ * `ValidationPipe<T, E>` represents either a successful validation with data of
+ * type `T`, or a failed validation with an array of errors of type `E`. Use the
+ * `success` discriminant to narrow the type.
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @template T Success data type
+ * @template E Error type
+ */
+export type ValidationPipe<T, E> =
+  | {
+      success: true;
+      data: T;
+    }
+  | {
+      success: false;
+      errors: E[];
+    };

package/src/typings/index.ts

@@ -1,14 +1,14 @@
-export * from "./AssertionGuard";
-export * from "./CamelCase";
-export * from "./PascalCase";
-export * from "./Primitive";
-export * from "./Resolved";
-export * from "./SnakeCase";
-
-export * from "./Atomic";
-export * from "./ClassProperties";
-export * from "./DeepPartial";
-export * from "./OmitNever";
-export * from "./ProtobufAtomic";
-export * from "./SpecialFields";
-export * from "./ValidationPipe";
+export * from "./AssertionGuard";
+export * from "./CamelCase";
+export * from "./PascalCase";
+export * from "./Primitive";
+export * from "./Resolved";
+export * from "./SnakeCase";
+
+export * from "./Atomic";
+export * from "./ClassProperties";
+export * from "./DeepPartial";
+export * from "./OmitNever";
+export * from "./ProtobufAtomic";
+export * from "./SpecialFields";
+export * from "./ValidationPipe";

package/src/typings/internal/Equal.ts

@@ -1,14 +1,14 @@
-/**
- * Checks if two types are exactly equal.
- *
- * `Equal<X, Y>` returns `true` if types X and Y are identical, `false`
- * otherwise. Works with any TypeScript types including unions.
- *
- * @author Kyungsu Kang - https://github.com/kakasoo
- * @template X First type to compare
- * @template Y Second type to compare
- */
-export type Equal<X, Y> =
-  (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2
-    ? true
-    : false;
+/**
+ * Checks if two types are exactly equal.
+ *
+ * `Equal<X, Y>` returns `true` if types X and Y are identical, `false`
+ * otherwise. Works with any TypeScript types including unions.
+ *
+ * @author Kyungsu Kang - https://github.com/kakasoo
+ * @template X First type to compare
+ * @template Y Second type to compare
+ */
+export type Equal<X, Y> =
+  (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2
+    ? true
+    : false;

package/src/typings/internal/IsTuple.ts

@@ -1,17 +1,17 @@
-/**
- * Checks if an array type is a tuple (fixed length) or regular array.
- *
- * Returns `true` for tuple types like `[string, number]` where length is fixed,
- * and `false` for array types like `string[]` where length is variable.
- *
- * @template T Array or tuple type to check
- */
-export type IsTuple<T extends readonly any[] | { length: number }> = [
-  T,
-] extends [never]
-  ? false
-  : T extends readonly any[]
-    ? number extends T["length"]
-      ? false
-      : true
-    : false;
+/**
+ * Checks if an array type is a tuple (fixed length) or regular array.
+ *
+ * Returns `true` for tuple types like `[string, number]` where length is fixed,
+ * and `false` for array types like `string[]` where length is variable.
+ *
+ * @template T Array or tuple type to check
+ */
+export type IsTuple<T extends readonly any[] | { length: number }> = [
+  T,
+] extends [never]
+  ? false
+  : T extends readonly any[]
+    ? number extends T["length"]
+      ? false
+      : true
+    : false;

package/src/typings/internal/NativeClass.ts

@@ -1,31 +1,31 @@
-/**
- * Union of JavaScript built-in class types.
- *
- * `NativeClass` includes Date, collections (Set, Map, WeakSet, WeakMap), typed
- * arrays (Uint8Array, Int32Array, etc.), binary data types (ArrayBuffer,
- * DataView, Blob, File), and RegExp. These types receive special handling in
- * typia's serialization and validation.
- */
-export type NativeClass =
-  | Date
-  | Set<any>
-  | Map<any, any>
-  | WeakSet<any>
-  | WeakMap<any, any>
-  | Uint8Array
-  | Uint8ClampedArray
-  | Uint16Array
-  | Uint32Array
-  | BigUint64Array
-  | Int8Array
-  | Int16Array
-  | Int32Array
-  | BigInt64Array
-  | Float32Array
-  | Float64Array
-  | ArrayBuffer
-  | SharedArrayBuffer
-  | DataView
-  | Blob
-  | File
-  | RegExp;
+/**
+ * Union of JavaScript built-in class types.
+ *
+ * `NativeClass` includes Date, collections (Set, Map, WeakSet, WeakMap), typed
+ * arrays (Uint8Array, Int32Array, etc.), binary data types (ArrayBuffer,
+ * DataView, Blob, File), and RegExp. These types receive special handling in
+ * typia's serialization and validation.
+ */
+export type NativeClass =
+  | Date
+  | Set<any>
+  | Map<any, any>
+  | WeakSet<any>
+  | WeakMap<any, any>
+  | Uint8Array
+  | Uint8ClampedArray
+  | Uint16Array
+  | Uint32Array
+  | BigUint64Array
+  | Int8Array
+  | Int16Array
+  | Int32Array
+  | BigInt64Array
+  | Float32Array
+  | Float64Array
+  | ArrayBuffer
+  | SharedArrayBuffer
+  | DataView
+  | Blob
+  | File
+  | RegExp;

package/src/typings/internal/ValueOf.ts

@@ -1,29 +1,29 @@
-/**
- * Extracts the primitive value type from boxed primitives.
- *
- * `ValueOf<Instance>` converts boxed primitive types (Boolean, Number, String)
- * to their primitive equivalents (boolean, number, string). Non-boxed types are
- * returned unchanged.
- *
- * @template Instance Type to extract primitive from
- */
-export type ValueOf<Instance> =
-  IsValueOf<Instance, Boolean> extends true
-    ? boolean
-    : IsValueOf<Instance, Number> extends true
-      ? number
-      : IsValueOf<Instance, String> extends true
-        ? string
-        : Instance;
-
-type IsValueOf<Instance, Object extends IValueOf<any>> = Instance extends Object
-  ? Object extends IValueOf<infer Primitive>
-    ? Instance extends Primitive
-      ? false
-      : true // not Primitive, but Object
-    : false // cannot be
-  : false;
-
-interface IValueOf<T> {
-  valueOf(): T;
-}
+/**
+ * Extracts the primitive value type from boxed primitives.
+ *
+ * `ValueOf<Instance>` converts boxed primitive types (Boolean, Number, String)
+ * to their primitive equivalents (boolean, number, string). Non-boxed types are
+ * returned unchanged.
+ *
+ * @template Instance Type to extract primitive from
+ */
+export type ValueOf<Instance> =
+  IsValueOf<Instance, Boolean> extends true
+    ? boolean
+    : IsValueOf<Instance, Number> extends true
+      ? number
+      : IsValueOf<Instance, String> extends true
+        ? string
+        : Instance;
+
+type IsValueOf<Instance, Object extends IValueOf<any>> = Instance extends Object
+  ? Object extends IValueOf<infer Primitive>
+    ? Instance extends Primitive
+      ? false
+      : true // not Primitive, but Object
+    : false // cannot be
+  : false;
+
+interface IValueOf<T> {
+  valueOf(): T;
+}