typia 5.3.0-dev.20231122 → 5.3.0-dev.20231126

package/src/CamelCase.ts

@@ -1,114 +1,114 @@
-/**
- * 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/IRandomGenerator.ts

@@ -1,35 +1,35 @@
-import { Customizable } from "./typings/Customizable";
-
-export interface IRandomGenerator {
-  boolean(): boolean;
-  integer(minimum?: number, maximum?: number): number;
-  number(minimum?: number, maximum?: number): number;
-  bigint(minimum?: bigint, maximum?: bigint): bigint;
-  string(length?: number): string;
-  array<T>(closure: (index: number) => T, count?: number): T[];
-  length(): number;
-
-  uuid(): string;
-  email(): string;
-  url(): string;
-  ipv4(): string;
-  ipv6(): string;
-  pattern(regex: RegExp): string;
-  date(minimum?: number, maximum?: number): string;
-  datetime(minimum?: number, maximum?: number): string;
-
-  customs?: IRandomGenerator.CustomMap;
-}
-export namespace IRandomGenerator {
-  export type CustomMap = {
-    [Type in keyof Customizable]?: (
-      tags: ITypeTag[],
-    ) => Customizable[Type] | undefined;
-  };
-
-  export interface ITypeTag {
-    name: string;
-    kind: string;
-    value: any;
-  }
-}
+import { Customizable } from "./typings/Customizable";
+
+export interface IRandomGenerator {
+  boolean(): boolean;
+  integer(minimum?: number, maximum?: number): number;
+  number(minimum?: number, maximum?: number): number;
+  bigint(minimum?: bigint, maximum?: bigint): bigint;
+  string(length?: number): string;
+  array<T>(closure: (index: number) => T, count?: number): T[];
+  length(): number;
+
+  uuid(): string;
+  email(): string;
+  url(): string;
+  ipv4(): string;
+  ipv6(): string;
+  pattern(regex: RegExp): string;
+  date(minimum?: number, maximum?: number): string;
+  datetime(minimum?: number, maximum?: number): string;
+
+  customs?: IRandomGenerator.CustomMap;
+}
+export namespace IRandomGenerator {
+  export type CustomMap = {
+    [Type in keyof Customizable]?: (
+      tags: ITypeTag[],
+    ) => Customizable[Type] | undefined;
+  };
+
+  export interface ITypeTag {
+    name: string;
+    kind: string;
+    value: any;
+  }
+}

package/src/IValidation.ts

@@ -1,21 +1,21 @@
-export type IValidation<T = unknown> =
-  | IValidation.ISuccess<T>
-  | IValidation.IFailure;
-export namespace IValidation {
-  export interface ISuccess<T = unknown> {
-    success: true;
-    data: T;
-    errors: [];
-  }
-
-  export interface IFailure {
-    success: false;
-    errors: IError[];
-  }
-
-  export interface IError {
-    path: string;
-    expected: string;
-    value: any;
-  }
-}
+export type IValidation<T = unknown> =
+  | IValidation.ISuccess<T>
+  | IValidation.IFailure;
+export namespace IValidation {
+  export interface ISuccess<T = unknown> {
+    success: true;
+    data: T;
+    errors: [];
+  }
+
+  export interface IFailure {
+    success: false;
+    errors: IError[];
+  }
+
+  export interface IError {
+    path: string;
+    expected: string;
+    value: any;
+  }
+}

package/src/PascalCase.ts

@@ -1,114 +1,114 @@
-/**
- * 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;
+/**
+ * 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;