typia 5.5.6-dev.20240319 → 5.5.6-dev.20240320

package/src/CamelCase.ts

@@ -1,121 +1,118 @@
-/**
- * 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
-                | Blob
-                | File
-            ? 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 R}`
-  ? `_${CamelizeString<R>}`
-  : 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
+      | Blob
+      | File
+  ? 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 R}`
+  ? `_${CamelizeString<R>}`
+  : 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,62 +1,62 @@
-import { Customizable } from "./typings/Customizable";
-
-export interface IRandomGenerator {
-  // REGULAR
-  boolean(): boolean;
-  integer(minimum?: number, maximum?: number): number;
-  bigint(minimum?: bigint, maximum?: bigint): bigint;
-  number(minimum?: number, maximum?: number): number;
-  string(length?: number): string;
-
-  array<T>(closure: (index: number) => T, count?: number): T[];
-  length(): number;
-  pattern(regex: RegExp): string;
-
-  //----
-  // FORMAT
-  //----
-  // SPECIAL CHARACTERS
-  byte(): string;
-  password(): string;
-  regex(): string;
-  uuid(): string;
-
-  // ADDRESSES
-  email(): string;
-  hostname(): string;
-  idnEmail(): string;
-  idnHostname(): string;
-  iri(): string;
-  iriReference(): string;
-  ipv4(): string;
-  ipv6(): string;
-  uri(): string;
-  uriReference(): string;
-  uriTemplate(): string;
-  url(): string;
-
-  // TIMESTAMPS
-  datetime(minimum?: number, maximum?: number): string;
-  date(minimum?: number, maximum?: number): string;
-  time(): string;
-  duration(): string;
-
-  // POINTERS
-  jsonPointer(): string;
-  relativeJsonPointer(): 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 {
+  // REGULAR
+  boolean(): boolean;
+  integer(minimum?: number, maximum?: number): number;
+  bigint(minimum?: bigint, maximum?: bigint): bigint;
+  number(minimum?: number, maximum?: number): number;
+  string(length?: number): string;
+
+  array<T>(closure: (index: number) => T, count?: number): T[];
+  length(): number;
+  pattern(regex: RegExp): string;
+
+  //----
+  // FORMAT
+  //----
+  // SPECIAL CHARACTERS
+  byte(): string;
+  password(): string;
+  regex(): string;
+  uuid(): string;
+
+  // ADDRESSES
+  email(): string;
+  hostname(): string;
+  idnEmail(): string;
+  idnHostname(): string;
+  iri(): string;
+  iriReference(): string;
+  ipv4(): string;
+  ipv6(): string;
+  uri(): string;
+  uriReference(): string;
+  uriTemplate(): string;
+  url(): string;
+
+  // TIMESTAMPS
+  datetime(minimum?: number, maximum?: number): string;
+  date(minimum?: number, maximum?: number): string;
+  time(): string;
+  duration(): string;
+
+  // POINTERS
+  jsonPointer(): string;
+  relativeJsonPointer(): 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,121 +1,118 @@
-/**
- * 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
-                | Blob
-                | File
-            ? 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 R}`
-  ? `_${PascalizeString<R>}`
-  : 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
+      | Blob
+      | File
+  ? 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 R}`
+  ? `_${PascalizeString<R>}`
+  : 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;