typia 5.0.4 → 5.0.5-dev.20230921

package/src/typings/ProtobufAtomic.ts

@@ -1,19 +1,19 @@
-export type ProtobufAtomic =
-    | "bool"
-    | "int32"
-    | "uint32"
-    | "int64"
-    | "uint64"
-    | "float"
-    | "double"
-    | "string";
-export namespace ProtobufAtomic {
-    export type Numeric =
-        | "int32"
-        | "uint32"
-        | "int64"
-        | "uint64"
-        | "float"
-        | "double";
-    export type BigNumeric = "int64" | "uint64";
-}
+export type ProtobufAtomic =
+    | "bool"
+    | "int32"
+    | "uint32"
+    | "int64"
+    | "uint64"
+    | "float"
+    | "double"
+    | "string";
+export namespace ProtobufAtomic {
+    export type Numeric =
+        | "int32"
+        | "uint32"
+        | "int64"
+        | "uint64"
+        | "float"
+        | "double";
+    export type BigNumeric = "int64" | "uint64";
+}

package/src/typings/SpecialFields.ts

@@ -1,3 +1,3 @@
-export type SpecialFields<Instance extends object, Target> = {
-    [P in keyof Instance]: Instance[P] extends Target ? P : never;
-}[keyof Instance & string];
+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,9 +1,9 @@
-export type ValidationPipe<T, E> =
-    | {
-          success: true;
-          data: T;
-      }
-    | {
-          success: false;
-          errors: E[];
-      };
+export type ValidationPipe<T, E> =
+    | {
+          success: true;
+          data: T;
+      }
+    | {
+          success: false;
+          errors: E[];
+      };

package/src/typings/Writable.ts

@@ -1,11 +1,11 @@
-import { ClassProperties } from "./ClassProperties";
-
-export type Writable<T extends object> = {
-    -readonly [P in keyof T]: T[P];
-};
-
-export function Writable<T extends object>(
-    elem: T,
-): Writable<ClassProperties<T>> {
-    return elem as any;
-}
+import { ClassProperties } from "./ClassProperties";
+
+export type Writable<T extends object> = {
+    -readonly [P in keyof T]: T[P];
+};
+
+export function Writable<T extends object>(
+    elem: T,
+): Writable<ClassProperties<T>> {
+    return elem as any;
+}

package/src/utils/ArrayUtil.ts

@@ -1,45 +1,45 @@
-export namespace ArrayUtil {
-    export const has = <T>(array: T[], pred: (elem: T) => boolean): boolean =>
-        array.some(pred);
-
-    export const add = <T>(
-        array: T[],
-        value: T,
-        pred: (x: T, y: T) => boolean = (x, y) => x === y,
-    ): boolean => {
-        if (array.some((elem) => pred(elem, value))) return false;
-        array.push(value);
-        return true;
-    };
-
-    export const set = <Key, T>(
-        array: T[],
-        value: T,
-        key: (elem: T) => Key,
-    ): void => {
-        if (array.some((elem) => key(elem) === key(value))) return;
-        array.push(value);
-    };
-
-    export const take = <T>(
-        array: T[],
-        pred: (elem: T) => boolean,
-        init: () => T,
-    ): T => {
-        const index: number = array.findIndex(pred);
-        if (index !== -1) return array[index]!;
-
-        const elem: T = init();
-        array.push(elem);
-        return elem;
-    };
-
-    export const repeat = <T>(
-        count: number,
-        closure: (index: number, count: number) => T,
-    ): T[] =>
-        new Array(count).fill("").map((_, index) => closure(index, count));
-
-    export const flat = <T>(matrix: T[][]): T[] =>
-        ([] as T[]).concat(...matrix);
-}
+export namespace ArrayUtil {
+    export const has = <T>(array: T[], pred: (elem: T) => boolean): boolean =>
+        array.some(pred);
+
+    export const add = <T>(
+        array: T[],
+        value: T,
+        pred: (x: T, y: T) => boolean = (x, y) => x === y,
+    ): boolean => {
+        if (array.some((elem) => pred(elem, value))) return false;
+        array.push(value);
+        return true;
+    };
+
+    export const set = <Key, T>(
+        array: T[],
+        value: T,
+        key: (elem: T) => Key,
+    ): void => {
+        if (array.some((elem) => key(elem) === key(value))) return;
+        array.push(value);
+    };
+
+    export const take = <T>(
+        array: T[],
+        pred: (elem: T) => boolean,
+        init: () => T,
+    ): T => {
+        const index: number = array.findIndex(pred);
+        if (index !== -1) return array[index]!;
+
+        const elem: T = init();
+        array.push(elem);
+        return elem;
+    };
+
+    export const repeat = <T>(
+        count: number,
+        closure: (index: number, count: number) => T,
+    ): T[] =>
+        new Array(count).fill("").map((_, index) => closure(index, count));
+
+    export const flat = <T>(matrix: T[][]): T[] =>
+        ([] as T[]).concat(...matrix);
+}

package/src/utils/Escaper.ts

@@ -1,46 +1,46 @@
-export namespace Escaper {
-    export const variable = (str: string): boolean =>
-        reserved(str) === false && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str);
-
-    export const reserved = (str: string): boolean => RESERVED.has(str);
-}
-
-const RESERVED: Set<string> = new Set([
-    "break",
-    "case",
-    "catch",
-    "class",
-    "const",
-    "continue",
-    "debugger",
-    "default",
-    "delete",
-    "do",
-    "else",
-    "enum",
-    "export",
-    "extends",
-    "false",
-    "finally",
-    "for",
-    "function",
-    "if",
-    "import",
-    "in",
-    "instanceof",
-    "new",
-    "null",
-    "package",
-    "return",
-    "super",
-    "switch",
-    "this",
-    "throw",
-    "true",
-    "try",
-    "typeof",
-    "var",
-    "void",
-    "while",
-    "with",
-]);
+export namespace Escaper {
+    export const variable = (str: string): boolean =>
+        reserved(str) === false && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str);
+
+    export const reserved = (str: string): boolean => RESERVED.has(str);
+}
+
+const RESERVED: Set<string> = new Set([
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "enum",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "import",
+    "in",
+    "instanceof",
+    "new",
+    "null",
+    "package",
+    "return",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with",
+]);

package/src/utils/MapUtil.ts

@@ -1,12 +1,12 @@
-export namespace MapUtil {
-    export const take =
-        <Key, T>(dict: Map<Key, T>) =>
-        (key: Key, generator: () => T): T => {
-            const oldbie: T | undefined = dict.get(key);
-            if (oldbie) return oldbie;
-
-            const value: T = generator();
-            dict.set(key, value);
-            return value;
-        };
-}
+export namespace MapUtil {
+    export const take =
+        <Key, T>(dict: Map<Key, T>) =>
+        (key: Key, generator: () => T): T => {
+            const oldbie: T | undefined = dict.get(key);
+            if (oldbie) return oldbie;
+
+            const value: T = generator();
+            dict.set(key, value);
+            return value;
+        };
+}

package/src/utils/NameEncoder.ts

@@ -1,32 +1,32 @@
-export namespace NameEncoder {
-    export function encode(str: string): string {
-        for (const [before, after] of REPLACERS)
-            str = str.split(before).join(after);
-        return str;
-    }
-
-    export function decode(str: string): string {
-        for (const [before, after] of REPLACERS)
-            if (after !== "") str = str.split(after).join(before);
-        return str;
-    }
-}
-
-const REPLACERS: [string, string][] = [
-    ["$", "_dollar_"],
-    ["&", "_and_"],
-    ["|", "_or_"],
-    ["{", "_blt_"],
-    ["}", "_bgt_"],
-    ["<", "_lt_"],
-    [">", "_gt_"],
-    ["(", "_lp_"],
-    [")", "_rp_"],
-    ["[", "_alt_"],
-    ["]", "_agt_"],
-    [",", "_comma_"],
-    ["`", "_backquote_"],
-    ["'", "_singlequote_"],
-    ['"', "_doublequote_"],
-    [" ", "_space_"],
-];
+export namespace NameEncoder {
+    export function encode(str: string): string {
+        for (const [before, after] of REPLACERS)
+            str = str.split(before).join(after);
+        return str;
+    }
+
+    export function decode(str: string): string {
+        for (const [before, after] of REPLACERS)
+            if (after !== "") str = str.split(after).join(before);
+        return str;
+    }
+}
+
+const REPLACERS: [string, string][] = [
+    ["$", "_dollar_"],
+    ["&", "_and_"],
+    ["|", "_or_"],
+    ["{", "_blt_"],
+    ["}", "_bgt_"],
+    ["<", "_lt_"],
+    [">", "_gt_"],
+    ["(", "_lp_"],
+    [")", "_rp_"],
+    ["[", "_alt_"],
+    ["]", "_agt_"],
+    [",", "_comma_"],
+    ["`", "_backquote_"],
+    ["'", "_singlequote_"],
+    ['"', "_doublequote_"],
+    [" ", "_space_"],
+];

package/src/utils/PatternUtil.ts

@@ -1,33 +1,33 @@
-export namespace PatternUtil {
-    export const fix = (str: string): string => {
-        const first: number = str.indexOf(STRING);
-        const last: number = str.lastIndexOf(STRING);
-        return [
-            first === -1 || none("(")(str.slice(0, first)) ? "^" : "",
-            str,
-            last === -1 || none(")")(str.slice(last + STRING.length))
-                ? "$"
-                : "",
-        ].join("");
-    };
-
-    export const escape = (str: string): string => {
-        return str
-            .replace(/[|\\/{}()[\]^$+*?.]/g, "\\$&")
-            .replace(/-/g, "\\x2d");
-    };
-
-    export const NUMBER =
-        "[+-]?" + // optional sign
-        "\\d+(?:\\.\\d+)?" + // integer or decimal
-        "(?:[eE][+-]?\\d+)?"; // optional exponent
-    export const BOOLEAN = "true|false";
-    export const STRING = "(.*)";
-}
-
-const none =
-    (parenthesis: string) =>
-    (str: string): boolean => {
-        for (const ch of str) if (ch !== parenthesis) return true;
-        return false;
-    };
+export namespace PatternUtil {
+    export const fix = (str: string): string => {
+        const first: number = str.indexOf(STRING);
+        const last: number = str.lastIndexOf(STRING);
+        return [
+            first === -1 || none("(")(str.slice(0, first)) ? "^" : "",
+            str,
+            last === -1 || none(")")(str.slice(last + STRING.length))
+                ? "$"
+                : "",
+        ].join("");
+    };
+
+    export const escape = (str: string): string => {
+        return str
+            .replace(/[|\\/{}()[\]^$+*?.]/g, "\\$&")
+            .replace(/-/g, "\\x2d");
+    };
+
+    export const NUMBER =
+        "[+-]?" + // optional sign
+        "\\d+(?:\\.\\d+)?" + // integer or decimal
+        "(?:[eE][+-]?\\d+)?"; // optional exponent
+    export const BOOLEAN = "true|false";
+    export const STRING = "(.*)";
+}
+
+const none =
+    (parenthesis: string) =>
+    (str: string): boolean => {
+        for (const ch of str) if (ch !== parenthesis) return true;
+        return false;
+    };

package/src/utils/RandomGenerator.ts

@@ -1,83 +1,83 @@
-import RandExp from "randexp";
-
-/**
- * @internal
- */
-export namespace RandomGenerator {
-    const ALPHABETS = "abcdefghijklmnopqrstuvwxyz";
-
-    /* -----------------------------------------------------------
-        REGULAR
-    ----------------------------------------------------------- */
-    export const boolean = () => Math.random() < 0.5;
-
-    export const integer = (min?: number, max?: number) => {
-        min ??= 0;
-        max ??= 100;
-        return Math.floor(Math.random() * (max - min + 1)) + min;
-    };
-
-    export const bigint = (min?: bigint, max?: bigint) => {
-        min ??= BigInt(0);
-        max ??= BigInt(100);
-        return BigInt(integer(Number(min), Number(max)));
-    };
-
-    export const number = (min?: number, max?: number) => {
-        min ??= 0;
-        max ??= 100;
-        return Math.random() * (max - min) + min;
-    };
-
-    export const string = (length?: number): string =>
-        new Array(length ?? integer(5, 10))
-            .fill(0)
-            .map(() => ALPHABETS[integer(0, ALPHABETS.length - 1)])
-            .join("");
-
-    export const array = <T>(
-        closure: (index: number) => T,
-        count?: number,
-    ): T[] =>
-        new Array(count ?? length()).fill(0).map((_e, index) => closure(index));
-
-    export const pick = <T>(array: T[]): T =>
-        array[integer(0, array.length - 1)]!;
-
-    export const length = () => integer(0, 3);
-
-    /* -----------------------------------------------------------
-        SECIAL FORMATS
-    ----------------------------------------------------------- */
-    export const uuid = () =>
-        "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
-            const r = (Math.random() * 16) | 0;
-            const v = c === "x" ? r : (r & 0x3) | 0x8;
-            return v.toString(16);
-        });
-
-    export const email = () => `${string(10)}@${string(10)}.${string(3)}`;
-
-    export const url = () => `https://${string(10)}.${string(3)}`;
-
-    export const ipv4 = () => array(() => integer(0, 255), 4).join(".");
-
-    export const ipv6 = (): string =>
-        array(() => integer(0, 65535).toString(16), 8).join(":");
-
-    export const pattern = (regex: RegExp): string => new RandExp(regex).gen();
-
-    export const date = (min?: number, max?: number) => {
-        min ??= 0;
-        max ??= Date.now() * 2;
-        return new Date(number(min, max)).toISOString().substring(0, 10);
-    };
-
-    export const datetime = (min?: number, max?: number) => {
-        min ??= Date.now() - 30 * DAY;
-        max ??= Date.now() + 7 * DAY;
-        return new Date(number(min, max)).toISOString();
-    };
-}
-
-const DAY = 1000 * 60 * 60 * 24;
+import RandExp from "randexp";
+
+/**
+ * @internal
+ */
+export namespace RandomGenerator {
+    const ALPHABETS = "abcdefghijklmnopqrstuvwxyz";
+
+    /* -----------------------------------------------------------
+        REGULAR
+    ----------------------------------------------------------- */
+    export const boolean = () => Math.random() < 0.5;
+
+    export const integer = (min?: number, max?: number) => {
+        min ??= 0;
+        max ??= 100;
+        return Math.floor(Math.random() * (max - min + 1)) + min;
+    };
+
+    export const bigint = (min?: bigint, max?: bigint) => {
+        min ??= BigInt(0);
+        max ??= BigInt(100);
+        return BigInt(integer(Number(min), Number(max)));
+    };
+
+    export const number = (min?: number, max?: number) => {
+        min ??= 0;
+        max ??= 100;
+        return Math.random() * (max - min) + min;
+    };
+
+    export const string = (length?: number): string =>
+        new Array(length ?? integer(5, 10))
+            .fill(0)
+            .map(() => ALPHABETS[integer(0, ALPHABETS.length - 1)])
+            .join("");
+
+    export const array = <T>(
+        closure: (index: number) => T,
+        count?: number,
+    ): T[] =>
+        new Array(count ?? length()).fill(0).map((_e, index) => closure(index));
+
+    export const pick = <T>(array: T[]): T =>
+        array[integer(0, array.length - 1)]!;
+
+    export const length = () => integer(0, 3);
+
+    /* -----------------------------------------------------------
+        SECIAL FORMATS
+    ----------------------------------------------------------- */
+    export const uuid = () =>
+        "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+            const r = (Math.random() * 16) | 0;
+            const v = c === "x" ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+
+    export const email = () => `${string(10)}@${string(10)}.${string(3)}`;
+
+    export const url = () => `https://${string(10)}.${string(3)}`;
+
+    export const ipv4 = () => array(() => integer(0, 255), 4).join(".");
+
+    export const ipv6 = (): string =>
+        array(() => integer(0, 65535).toString(16), 8).join(":");
+
+    export const pattern = (regex: RegExp): string => new RandExp(regex).gen();
+
+    export const date = (min?: number, max?: number) => {
+        min ??= 0;
+        max ??= Date.now() * 2;
+        return new Date(number(min, max)).toISOString().substring(0, 10);
+    };
+
+    export const datetime = (min?: number, max?: number) => {
+        min ??= Date.now() - 30 * DAY;
+        max ??= Date.now() + 7 * DAY;
+        return new Date(number(min, max)).toISOString();
+    };
+}
+
+const DAY = 1000 * 60 * 60 * 24;

package/src/utils/Singleton.ts

@@ -1,17 +1,17 @@
-export class Singleton<T, Args extends any[] = []> {
-    private readonly closure_: (...args: Args) => T;
-    private value_: T | object;
-
-    public constructor(closure: (...args: Args) => T) {
-        this.closure_ = closure;
-        this.value_ = NOT_MOUNTED_YET;
-    }
-
-    public get(...args: Args): T {
-        if (this.value_ === NOT_MOUNTED_YET)
-            this.value_ = this.closure_(...args);
-        return this.value_ as T;
-    }
-}
-
-const NOT_MOUNTED_YET = {};
+export class Singleton<T, Args extends any[] = []> {
+    private readonly closure_: (...args: Args) => T;
+    private value_: T | object;
+
+    public constructor(closure: (...args: Args) => T) {
+        this.closure_ = closure;
+        this.value_ = NOT_MOUNTED_YET;
+    }
+
+    public get(...args: Args): T {
+        if (this.value_ === NOT_MOUNTED_YET)
+            this.value_ = this.closure_(...args);
+        return this.value_ as T;
+    }
+}
+
+const NOT_MOUNTED_YET = {};