typia 3.4.21 → 3.4.23

package/src/transformers/features/validators/CreateValidateTransformer.ts

@@ -1,35 +1,35 @@
-import ts from "typescript";
-
-import { ValidateProgrammer } from "../../../programmers/ValidateProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace CreateValidateTransformer {
-    export function transform(equals: boolean) {
-        const SYMBOL = equals ? "createValidateEquals" : "createValidate";
-        const MESSAGES = {
-            NOT_SPECIFIED: `Error on typia.${SYMBOL}(): generic argument is not specified.`,
-            GENERIC_ARGUMENT: `Error on typia.${SYMBOL}(): non-specified generic argument.`,
-        };
-
-        return function (
-            project: IProject,
-            modulo: ts.LeftHandSideExpression,
-            expression: ts.CallExpression,
-        ): ts.Expression {
-            // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments || !expression.typeArguments[0])
-                throw new Error(MESSAGES.NOT_SPECIFIED);
-
-            // GET TYPE INFO
-            const type: ts.Type = project.checker.getTypeFromTypeNode(
-                expression.typeArguments[0],
-            );
-            if (type.isTypeParameter())
-                throw new Error(MESSAGES.GENERIC_ARGUMENT);
-
-            // DO TRANSFORM
-            return ValidateProgrammer.generate(project, modulo, equals)(type);
-        };
-    }
-}
+import ts from "typescript";
+
+import { ValidateProgrammer } from "../../../programmers/ValidateProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CreateValidateTransformer {
+    export function transform(equals: boolean) {
+        const SYMBOL = equals ? "createValidateEquals" : "createValidate";
+        const MESSAGES = {
+            NOT_SPECIFIED: `Error on typia.${SYMBOL}(): generic argument is not specified.`,
+            GENERIC_ARGUMENT: `Error on typia.${SYMBOL}(): non-specified generic argument.`,
+        };
+
+        return function (
+            project: IProject,
+            modulo: ts.LeftHandSideExpression,
+            expression: ts.CallExpression,
+        ): ts.Expression {
+            // CHECK GENERIC ARGUMENT EXISTENCE
+            if (!expression.typeArguments || !expression.typeArguments[0])
+                throw new Error(MESSAGES.NOT_SPECIFIED);
+
+            // GET TYPE INFO
+            const type: ts.Type = project.checker.getTypeFromTypeNode(
+                expression.typeArguments[0],
+            );
+            if (type.isTypeParameter())
+                throw new Error(MESSAGES.GENERIC_ARGUMENT);
+
+            // DO TRANSFORM
+            return ValidateProgrammer.generate(project, modulo, equals)(type);
+        };
+    }
+}

package/src/transformers/features/validators/IsTransformer.ts

@@ -1,43 +1,43 @@
-import ts from "typescript";
-
-import { IsProgrammer } from "../../../programmers/IsProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace IsTransformer {
-    export function transform(equals: boolean) {
-        const SYMBOL = equals ? "equals" : "is";
-        const MESSAGES = {
-            NO_INPUT_VALUE: `Error on typia.${SYMBOL}(): no input value.`,
-            GENERIC_ARGUMENT: `Error on typia.${SYMBOL}(): non-specified generic argument.`,
-        };
-
-        return function (
-            project: IProject,
-            modulo: ts.LeftHandSideExpression,
-            expression: ts.CallExpression,
-        ): ts.Expression {
-            if (expression.arguments.length !== 1)
-                throw new Error(MESSAGES.NO_INPUT_VALUE);
-
-            // GET TYPE INFO
-            const type: ts.Type =
-                expression.typeArguments && expression.typeArguments[0]
-                    ? project.checker.getTypeFromTypeNode(
-                          expression.typeArguments[0],
-                      )
-                    : project.checker.getTypeAtLocation(
-                          expression.arguments[0]!,
-                      );
-            if (type.isTypeParameter())
-                throw new Error(MESSAGES.GENERIC_ARGUMENT);
-
-            // DO TRANSFORM
-            return ts.factory.createCallExpression(
-                IsProgrammer.generate(project, modulo, equals)(type),
-                undefined,
-                [expression.arguments[0]!],
-            );
-        };
-    }
-}
+import ts from "typescript";
+
+import { IsProgrammer } from "../../../programmers/IsProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace IsTransformer {
+    export function transform(equals: boolean) {
+        const SYMBOL = equals ? "equals" : "is";
+        const MESSAGES = {
+            NO_INPUT_VALUE: `Error on typia.${SYMBOL}(): no input value.`,
+            GENERIC_ARGUMENT: `Error on typia.${SYMBOL}(): non-specified generic argument.`,
+        };
+
+        return function (
+            project: IProject,
+            modulo: ts.LeftHandSideExpression,
+            expression: ts.CallExpression,
+        ): ts.Expression {
+            if (expression.arguments.length !== 1)
+                throw new Error(MESSAGES.NO_INPUT_VALUE);
+
+            // GET TYPE INFO
+            const type: ts.Type =
+                expression.typeArguments && expression.typeArguments[0]
+                    ? project.checker.getTypeFromTypeNode(
+                          expression.typeArguments[0],
+                      )
+                    : project.checker.getTypeAtLocation(
+                          expression.arguments[0]!,
+                      );
+            if (type.isTypeParameter())
+                throw new Error(MESSAGES.GENERIC_ARGUMENT);
+
+            // DO TRANSFORM
+            return ts.factory.createCallExpression(
+                IsProgrammer.generate(project, modulo, equals)(type),
+                undefined,
+                [expression.arguments[0]!],
+            );
+        };
+    }
+}

package/src/transformers/features/validators/ValidateTransformer.ts

@@ -1,43 +1,43 @@
-import ts from "typescript";
-
-import { ValidateProgrammer } from "../../../programmers/ValidateProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace ValidateTransformer {
-    export function transform(equals: boolean) {
-        const SYMBOL = equals ? "validateEquals" : "validate";
-        const MESSAGES = {
-            NO_INPUT_VALUE: `Error on typia.${SYMBOL}(): no input value.`,
-            GENERIC_ARGUMENT: `Error on typia.${SYMBOL}(): non-specified generic argument.`,
-        };
-
-        return function (
-            project: IProject,
-            modulo: ts.LeftHandSideExpression,
-            expression: ts.CallExpression,
-        ): ts.Expression {
-            if (expression.arguments.length !== 1)
-                throw new Error(MESSAGES.NO_INPUT_VALUE);
-
-            // GET TYPE INFO
-            const type: ts.Type =
-                expression.typeArguments && expression.typeArguments[0]
-                    ? project.checker.getTypeFromTypeNode(
-                          expression.typeArguments[0],
-                      )
-                    : project.checker.getTypeAtLocation(
-                          expression.arguments[0]!,
-                      );
-            if (type.isTypeParameter())
-                throw new Error(MESSAGES.GENERIC_ARGUMENT);
-
-            // DO TRANSFORM
-            return ts.factory.createCallExpression(
-                ValidateProgrammer.generate(project, modulo, equals)(type),
-                undefined,
-                [expression.arguments[0]!],
-            );
-        };
-    }
-}
+import ts from "typescript";
+
+import { ValidateProgrammer } from "../../../programmers/ValidateProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace ValidateTransformer {
+    export function transform(equals: boolean) {
+        const SYMBOL = equals ? "validateEquals" : "validate";
+        const MESSAGES = {
+            NO_INPUT_VALUE: `Error on typia.${SYMBOL}(): no input value.`,
+            GENERIC_ARGUMENT: `Error on typia.${SYMBOL}(): non-specified generic argument.`,
+        };
+
+        return function (
+            project: IProject,
+            modulo: ts.LeftHandSideExpression,
+            expression: ts.CallExpression,
+        ): ts.Expression {
+            if (expression.arguments.length !== 1)
+                throw new Error(MESSAGES.NO_INPUT_VALUE);
+
+            // GET TYPE INFO
+            const type: ts.Type =
+                expression.typeArguments && expression.typeArguments[0]
+                    ? project.checker.getTypeFromTypeNode(
+                          expression.typeArguments[0],
+                      )
+                    : project.checker.getTypeAtLocation(
+                          expression.arguments[0]!,
+                      );
+            if (type.isTypeParameter())
+                throw new Error(MESSAGES.GENERIC_ARGUMENT);
+
+            // DO TRANSFORM
+            return ts.factory.createCallExpression(
+                ValidateProgrammer.generate(project, modulo, equals)(type),
+                undefined,
+                [expression.arguments[0]!],
+            );
+        };
+    }
+}

package/src/typings/Atomic.ts

@@ -1,17 +1,17 @@
-export namespace Atomic {
-    export type Type = boolean | number | string | bigint;
-    export type Literal =
-        | "boolean"
-        | "integer"
-        | "number"
-        | "string"
-        | "bigint";
-
-    export type Mapper = {
-        boolean: boolean;
-        integer: number;
-        number: number;
-        string: string;
-        bigint: bigint;
-    };
-}
+export namespace Atomic {
+    export type Type = boolean | number | string | bigint;
+    export type Literal =
+        | "boolean"
+        | "integer"
+        | "number"
+        | "string"
+        | "bigint";
+
+    export type Mapper = {
+        boolean: boolean;
+        integer: number;
+        number: number;
+        string: string;
+        bigint: bigint;
+    };
+}

package/src/typings/ClassProperties.ts

@@ -1,5 +1,5 @@
-import { OmitNever } from "./OmitNever";
-
-export type ClassProperties<T extends object> = OmitNever<{
-    [K in keyof T]: T[K] extends Function ? never : T[K];
-}>;
+import { OmitNever } from "./OmitNever";
+
+export type ClassProperties<T extends object> = OmitNever<{
+    [K in keyof T]: T[K] extends Function ? never : T[K];
+}>;

package/src/typings/OmitNever.ts

@@ -1,3 +1,3 @@
-import { SpecialFields } from "./SpecialFields";
-
-export type OmitNever<T extends object> = Omit<T, SpecialFields<T, never>>;
+import { SpecialFields } from "./SpecialFields";
+
+export type OmitNever<T extends object> = Omit<T, SpecialFields<T, never>>;

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/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,49 +1,49 @@
-export namespace ArrayUtil {
-    export function has<T>(array: T[], pred: (elem: T) => boolean): boolean {
-        return array.some(pred);
-    }
-
-    export function add<T>(
-        array: T[],
-        value: T,
-        pred: (x: T, y: T) => boolean = (x, y) => x === y,
-    ): void {
-        if (array.some((elem) => pred(elem, value))) return;
-        array.push(value);
-    }
-
-    export function 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 function 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 function repeat<T>(
-        count: number,
-        closure: (index: number, count: number) => T,
-    ): T[] {
-        return new Array(count)
-            .fill("")
-            .map((_, index) => closure(index, count));
-    }
-
-    export function flat<T>(matrix: T[][]): T[] {
-        return ([] as T[]).concat(...matrix);
-    }
-}
+export namespace ArrayUtil {
+    export function has<T>(array: T[], pred: (elem: T) => boolean): boolean {
+        return array.some(pred);
+    }
+
+    export function add<T>(
+        array: T[],
+        value: T,
+        pred: (x: T, y: T) => boolean = (x, y) => x === y,
+    ): void {
+        if (array.some((elem) => pred(elem, value))) return;
+        array.push(value);
+    }
+
+    export function 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 function 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 function repeat<T>(
+        count: number,
+        closure: (index: number, count: number) => T,
+    ): T[] {
+        return new Array(count)
+            .fill("")
+            .map((_, index) => closure(index, count));
+    }
+
+    export function flat<T>(matrix: T[][]): T[] {
+        return ([] as T[]).concat(...matrix);
+    }
+}

package/src/utils/Escaper.ts

@@ -1,50 +1,50 @@
-export namespace Escaper {
-    export function variable(str: string): boolean {
-        return (
-            reserved(str) === false && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str)
-        );
-    }
-
-    function reserved(str: string): boolean {
-        return 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",
-    "return",
-    "super",
-    "switch",
-    "this",
-    "throw",
-    "true",
-    "try",
-    "typeof",
-    "var",
-    "void",
-    "while",
-    "with",
-]);
+export namespace Escaper {
+    export function variable(str: string): boolean {
+        return (
+            reserved(str) === false && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str)
+        );
+    }
+
+    function reserved(str: string): boolean {
+        return 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",
+    "return",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with",
+]);

package/src/utils/MapUtil.ts

@@ -1,14 +1,14 @@
-export namespace MapUtil {
-    export function 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 function 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/PatternUtil.ts

@@ -1,30 +1,30 @@
-export namespace PatternUtil {
-    export function 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 function escape(str: string): string {
-        return str
-            .replace(/[|\\/{}()[\]^$+*?.]/g, "\\$&")
-            .replace(/-/g, "\\x2d");
-    }
-
-    export const NUMBER = "-?\\d+\\.?\\d*";
-    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 function 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 function escape(str: string): string {
+        return str
+            .replace(/[|\\/{}()[\]^$+*?.]/g, "\\$&")
+            .replace(/-/g, "\\x2d");
+    }
+
+    export const NUMBER = "-?\\d+\\.?\\d*";
+    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/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 = {};