typia 5.2.0-dev.20231007 → 5.2.0

package/lib/CamelCase.d.ts

@@ -1,3 +1,13 @@
+/**
+ * Camel case type.
+ *
+ * `CamelCase` type is a type that all keys of an object are camelized.
+ *
+ * It also erase every method properties 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 Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
 type CamelizeMain<T> = T extends [never] ? never : T extends {

package/lib/PascalCase.d.ts

@@ -1,3 +1,13 @@
+/**
+ * Pascal case type.
+ *
+ * `PascalCase` type is a type that all keys of an object are pascalized.
+ *
+ * It also erase every method properties like {@link Resolved} type.
+ *
+ * @template T Target type to be pascalized
+ * @author Jeongho Nam - https://github.com/samchon
+ */
 export type PascalCase<T> = Equal<T, PascalizeMain<T>> extends true ? T : PascalizeMain<T>;
 type Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
 type PascalizeMain<T> = T extends [never] ? never : T extends {

package/lib/Primitive.d.ts

@@ -27,7 +27,7 @@
  * Native Class            | `{}`
  * Others                  | No change
  *
- * @template Instance Target argument type.
+ * @template T Target argument type.
  * @author Jeongho Nam - https://github.com/samchon
  * @author Kyungsu Kang - https://github.com/kakasoo
  * @author Michael - https://github.com/8471919

package/lib/Resolved.d.ts

@@ -22,7 +22,7 @@
  * `Class`                 | `interface`
  * Native Class or Others  | No change
  *
- * @template Instance Target argument type.
+ * @template T Target argument type.
  * @author Jeongho Nam - https://github.com/samchon
  * @author Kyungsu Kang - https://github.com/kakasoo
  */

package/lib/SnakeCase.d.ts

@@ -1,3 +1,13 @@
+/**
+ * Snake case type.
+ *
+ * `SnakeCase` type is a type that all keys of an object are converted to snake case.
+ *
+ * It also erase every method properties like {@link Resolved} type.
+ *
+ * @template T Target type to be snake cased
+ * @author Jeongho Nam - https://github.com/samchon
+ */
 export type SnakeCase<T> = Equal<T, SnakageMain<T>> extends true ? T : SnakageMain<T>;
 type Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
 type SnakageMain<T> = T extends [never] ? never : T extends {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "5.2.0-dev.20231007",
+  "version": "5.2.0",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",

package/src/CamelCase.ts

@@ -1,116 +1,116 @@
-/**
- * Camel case type.
- *
- * `CamelCase` type is a type that all keys of an object are camelized.
- *
- * It also erase every method properties 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>;
-
-/* -----------------------------------------------------------
-    OBJECT CONVERSION
------------------------------------------------------------ */
-type Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
-
-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
-          | Date
-          | Uint8Array
-          | Uint8ClampedArray
-          | Uint16Array
-          | Uint32Array
-          | BigUint64Array
-          | Int8Array
-          | Int16Array
-          | Int32Array
-          | BigInt64Array
-          | Float32Array
-          | Float64Array
-          | ArrayBuffer
-          | SharedArrayBuffer
-          | DataView
-    ? T
-    : {
-          [Key in keyof T as CamelizeString<Key & string>]: CamelizeMain<
-              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 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 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;
-}
-
-/* -----------------------------------------------------------
-    STRING CONVERTER
------------------------------------------------------------ */
-type CamelizeString<Key extends string> = Key extends `${infer F}${infer R}`
-    ? `${Lowercase<F>}${CamelizeStringRepeatedly<R>}`
-    : Key;
-type CamelizeStringRepeatedly<Key extends string> =
-    Key extends `${infer F}_${infer R}`
-        ? `${F}${Capitalize<CamelizeStringRepeatedly<R>>}`
-        : Key;
+/**
+ * Camel case type.
+ *
+ * `CamelCase` type is a type that all keys of an object are camelized.
+ *
+ * It also erase every method properties 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>;
+
+/* -----------------------------------------------------------
+    OBJECT CONVERSION
+----------------------------------------------------------- */
+type Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
+
+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
+          | Date
+          | Uint8Array
+          | Uint8ClampedArray
+          | Uint16Array
+          | Uint32Array
+          | BigUint64Array
+          | Int8Array
+          | Int16Array
+          | Int32Array
+          | BigInt64Array
+          | Float32Array
+          | Float64Array
+          | ArrayBuffer
+          | SharedArrayBuffer
+          | DataView
+    ? T
+    : {
+          [Key in keyof T as CamelizeString<Key & string>]: CamelizeMain<
+              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 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 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;
+}
+
+/* -----------------------------------------------------------
+    STRING CONVERTER
+----------------------------------------------------------- */
+type CamelizeString<Key extends string> = Key extends `${infer F}${infer R}`
+    ? `${Lowercase<F>}${CamelizeStringRepeatedly<R>}`
+    : Key;
+type CamelizeStringRepeatedly<Key extends string> =
+    Key extends `${infer F}_${infer R}`
+        ? `${F}${Capitalize<CamelizeStringRepeatedly<R>>}`
+        : Key;

package/src/PascalCase.ts

@@ -1,106 +1,116 @@
-export type PascalCase<T> = Equal<T, PascalizeMain<T>> extends true
-    ? T
-    : PascalizeMain<T>;
-
-/* -----------------------------------------------------------
-    OBJECT CONVERSION
------------------------------------------------------------ */
-type Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
-
-type PascalizeMain<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
-    ? PascalizeObject<T>
-    : T;
-
-type PascalizeObject<T extends object> = T extends Array<infer U>
-    ? IsTuple<T> extends true
-        ? PascalizeTuple<T>
-        : PascalizeMain<U>[]
-    : T extends Set<infer U>
-    ? Set<PascalizeMain<U>>
-    : T extends Map<infer K, infer V>
-    ? Map<PascalizeMain<K>, PascalizeMain<V>>
-    : T extends WeakSet<any> | WeakMap<any, any>
-    ? never
-    : T extends
-          | Date
-          | Uint8Array
-          | Uint8ClampedArray
-          | Uint16Array
-          | Uint32Array
-          | BigUint64Array
-          | Int8Array
-          | Int16Array
-          | Int32Array
-          | BigInt64Array
-          | Float32Array
-          | Float64Array
-          | ArrayBuffer
-          | SharedArrayBuffer
-          | DataView
-    ? T
-    : {
-          [Key in keyof T as PascalizeString<Key & string>]: PascalizeMain<
-              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 PascalizeTuple<T extends readonly any[]> = T extends []
-    ? []
-    : T extends [infer F]
-    ? [PascalizeMain<F>]
-    : T extends [infer F, ...infer Rest extends readonly any[]]
-    ? [PascalizeMain<F>, ...PascalizeTuple<Rest>]
-    : T extends [(infer F)?]
-    ? [PascalizeMain<F>?]
-    : T extends [(infer F)?, ...infer Rest extends readonly any[]]
-    ? [PascalizeMain<F>?, ...PascalizeTuple<Rest>]
-    : [];
-
-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;
-}
-
-/* -----------------------------------------------------------
-    STRING CONVERTER
------------------------------------------------------------ */
-type PascalizeString<Key extends string> = Key extends `${infer F}${infer R}`
-    ? `${Uppercase<F>}${PascalizeStringRepeatedly<R>}`
-    : Key;
-type PascalizeStringRepeatedly<Key extends string> =
-    Key extends `${infer F}_${infer R}`
-        ? `${F}${Capitalize<PascalizeStringRepeatedly<R>>}`
-        : Key;
+/**
+ * Pascal case type.
+ *
+ * `PascalCase` type is a type that all keys of an object are pascalized.
+ *
+ * It also erase every method properties like {@link Resolved} type.
+ *
+ * @template T Target type to be pascalized
+ * @author Jeongho Nam - https://github.com/samchon
+ */
+export type PascalCase<T> = Equal<T, PascalizeMain<T>> extends true
+    ? T
+    : PascalizeMain<T>;
+
+/* -----------------------------------------------------------
+    OBJECT CONVERSION
+----------------------------------------------------------- */
+type Equal<X, Y> = X extends Y ? (Y extends X ? true : false) : false;
+
+type PascalizeMain<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
+    ? PascalizeObject<T>
+    : T;
+
+type PascalizeObject<T extends object> = T extends Array<infer U>
+    ? IsTuple<T> extends true
+        ? PascalizeTuple<T>
+        : PascalizeMain<U>[]
+    : T extends Set<infer U>
+    ? Set<PascalizeMain<U>>
+    : T extends Map<infer K, infer V>
+    ? Map<PascalizeMain<K>, PascalizeMain<V>>
+    : T extends WeakSet<any> | WeakMap<any, any>
+    ? never
+    : T extends
+          | Date
+          | Uint8Array
+          | Uint8ClampedArray
+          | Uint16Array
+          | Uint32Array
+          | BigUint64Array
+          | Int8Array
+          | Int16Array
+          | Int32Array
+          | BigInt64Array
+          | Float32Array
+          | Float64Array
+          | ArrayBuffer
+          | SharedArrayBuffer
+          | DataView
+    ? T
+    : {
+          [Key in keyof T as PascalizeString<Key & string>]: PascalizeMain<
+              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 PascalizeTuple<T extends readonly any[]> = T extends []
+    ? []
+    : T extends [infer F]
+    ? [PascalizeMain<F>]
+    : T extends [infer F, ...infer Rest extends readonly any[]]
+    ? [PascalizeMain<F>, ...PascalizeTuple<Rest>]
+    : T extends [(infer F)?]
+    ? [PascalizeMain<F>?]
+    : T extends [(infer F)?, ...infer Rest extends readonly any[]]
+    ? [PascalizeMain<F>?, ...PascalizeTuple<Rest>]
+    : [];
+
+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;
+}
+
+/* -----------------------------------------------------------
+    STRING CONVERTER
+----------------------------------------------------------- */
+type PascalizeString<Key extends string> = Key extends `${infer F}${infer R}`
+    ? `${Uppercase<F>}${PascalizeStringRepeatedly<R>}`
+    : Key;
+type PascalizeStringRepeatedly<Key extends string> =
+    Key extends `${infer F}_${infer R}`
+        ? `${F}${Capitalize<PascalizeStringRepeatedly<R>>}`
+        : Key;