typia 3.8.2 → 3.8.3

package/src/transformers/features/stringifiers/ValidateStringifyTransformer.ts

@@ -1,10 +1,10 @@
-import { ValidateStringifyProgrammer } from "../../../programmers/ValidateStringifyProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ValidateStringifyTransformer {
-    export const transform = GenericTransformer.scalar("validatStringify")(
-        (project) => (modulo) =>
-            ValidateStringifyProgrammer.write(project)(modulo),
-    );
-}
+import { ValidateStringifyProgrammer } from "../../../programmers/ValidateStringifyProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ValidateStringifyTransformer {
+    export const transform = GenericTransformer.scalar("validatStringify")(
+        (project) => (modulo) =>
+            ValidateStringifyProgrammer.write(project)(modulo),
+    );
+}

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

@@ -1,11 +1,11 @@
-import { AssertProgrammer } from "../../../programmers/AssertProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace AssertTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.scalar(equals ? "assertEquals" : "assert")(
-            (project) => (modulo) =>
-                AssertProgrammer.write(project)(modulo)(equals),
-        );
-}
+import { AssertProgrammer } from "../../../programmers/AssertProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace AssertTransformer {
+    export const transform = (equals: boolean) =>
+        GenericTransformer.scalar(equals ? "assertEquals" : "assert")(
+            (project) => (modulo) =>
+                AssertProgrammer.write(project)(modulo)(equals),
+        );
+}

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

@@ -1,13 +1,13 @@
-import { AssertProgrammer } from "../../../programmers/AssertProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateAssertTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.factory(
-            equals ? "createAssertEquals" : "createAssert",
-        )(
-            (project) => (modulo) =>
-                AssertProgrammer.write(project)(modulo)(equals),
-        );
-}
+import { AssertProgrammer } from "../../../programmers/AssertProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateAssertTransformer {
+    export const transform = (equals: boolean) =>
+        GenericTransformer.factory(
+            equals ? "createAssertEquals" : "createAssert",
+        )(
+            (project) => (modulo) =>
+                AssertProgrammer.write(project)(modulo)(equals),
+        );
+}

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

@@ -1,11 +1,11 @@
-import { IsProgrammer } from "../../../programmers/IsProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateIsTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.factory(equals ? "createEquals" : "createIs")(
-            (project) => (modulo) =>
-                IsProgrammer.write(project)(modulo)(equals),
-        );
-}
+import { IsProgrammer } from "../../../programmers/IsProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateIsTransformer {
+    export const transform = (equals: boolean) =>
+        GenericTransformer.factory(equals ? "createEquals" : "createIs")(
+            (project) => (modulo) =>
+                IsProgrammer.write(project)(modulo)(equals),
+        );
+}

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

@@ -1,13 +1,13 @@
-import { ValidateProgrammer } from "../../../programmers/ValidateProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateValidateTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.factory(
-            equals ? "createValidateEquals" : "createValidate",
-        )(
-            (project) => (modulo) =>
-                ValidateProgrammer.write(project)(modulo)(equals),
-        );
-}
+import { ValidateProgrammer } from "../../../programmers/ValidateProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateValidateTransformer {
+    export const transform = (equals: boolean) =>
+        GenericTransformer.factory(
+            equals ? "createValidateEquals" : "createValidate",
+        )(
+            (project) => (modulo) =>
+                ValidateProgrammer.write(project)(modulo)(equals),
+        );
+}

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

@@ -1,11 +1,11 @@
-import { IsProgrammer } from "../../../programmers/IsProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace IsTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.scalar(equals ? "equals" : "is")(
-            (project) => (modulo) =>
-                IsProgrammer.write(project)(modulo)(equals),
-        );
-}
+import { IsProgrammer } from "../../../programmers/IsProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace IsTransformer {
+    export const transform = (equals: boolean) =>
+        GenericTransformer.scalar(equals ? "equals" : "is")(
+            (project) => (modulo) =>
+                IsProgrammer.write(project)(modulo)(equals),
+        );
+}

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

@@ -1,11 +1,11 @@
-import { ValidateProgrammer } from "../../../programmers/ValidateProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ValidateTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.scalar(equals ? "validateEquals" : "validate")(
-            (project) => (modulo) =>
-                ValidateProgrammer.write(project)(modulo)(equals),
-        );
-}
+import { ValidateProgrammer } from "../../../programmers/ValidateProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ValidateTransformer {
+    export const transform = (equals: boolean) =>
+        GenericTransformer.scalar(equals ? "validateEquals" : "validate")(
+            (project) => (modulo) =>
+                ValidateProgrammer.write(project)(modulo)(equals),
+        );
+}

package/src/transformers/internal/GenericTransformer.ts

@@ -1,97 +1,97 @@
-import ts from "typescript";
-
-import { IProject } from "../IProject";
-
-export namespace GenericTransformer {
-    export const scalar =
-        (method: string) =>
-        (
-            programmer: (
-                project: IProject,
-            ) => (
-                modulo: ts.LeftHandSideExpression,
-            ) => (type: ts.Type, name: string) => ts.ArrowFunction,
-        ) =>
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (expression: ts.CallExpression) => {
-            // CHECK PARAMETER
-            if (expression.arguments.length !== 1)
-                throw new Error(`Error on typia.${method}(): no input value.`);
-
-            // GET TYPE INFO
-            const [type, node, generic]: [ts.Type, ts.Node, boolean] =
-                expression.typeArguments && expression.typeArguments[0]
-                    ? [
-                          project.checker.getTypeFromTypeNode(
-                              expression.typeArguments[0],
-                          ),
-                          expression.typeArguments[0],
-                          true,
-                      ]
-                    : [
-                          project.checker.getTypeAtLocation(
-                              expression.arguments[0]!,
-                          ),
-                          expression.arguments[0]!,
-                          false,
-                      ];
-            if (type.isTypeParameter())
-                throw new Error(
-                    `Error on typia.${method}(): non-specified generic argument.`,
-                );
-
-            // DO TRANSFORM
-            return ts.factory.createCallExpression(
-                programmer(project)(modulo)(
-                    type,
-                    generic
-                        ? node.getFullText().trim()
-                        : name(project.checker)(type)(node),
-                ),
-                undefined,
-                [expression.arguments[0]!],
-            );
-        };
-
-    export const factory =
-        (method: string) =>
-        (
-            programmer: (
-                project: IProject,
-            ) => (
-                modulo: ts.LeftHandSideExpression,
-            ) => (type: ts.Type, name: string) => ts.ArrowFunction,
-        ) =>
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (expression: ts.CallExpression) => {
-            // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments?.[0])
-                throw new Error(
-                    `Error on typia.${method}(): generic argument is not specified.`,
-                );
-
-            // GET TYPE INFO
-            const node: ts.TypeNode = expression.typeArguments[0];
-            const type: ts.Type = project.checker.getTypeFromTypeNode(node);
-
-            if (type.isTypeParameter())
-                throw new Error(
-                    `Error on typia.${method}(): non-specified generic argument.`,
-                );
-
-            // DO TRANSFORM
-            return programmer(project)(modulo)(type, node.getFullText().trim());
-        };
-
-    const name =
-        (checker: ts.TypeChecker) =>
-        (type: ts.Type) =>
-        (node: ts.Node): string =>
-            checker.typeToString(
-                type,
-                node,
-                ts.TypeFormatFlags.NodeBuilderFlagsMask,
-            );
-}
+import ts from "typescript";
+
+import { IProject } from "../IProject";
+
+export namespace GenericTransformer {
+    export const scalar =
+        (method: string) =>
+        (
+            programmer: (
+                project: IProject,
+            ) => (
+                modulo: ts.LeftHandSideExpression,
+            ) => (type: ts.Type, name: string) => ts.ArrowFunction,
+        ) =>
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (expression: ts.CallExpression) => {
+            // CHECK PARAMETER
+            if (expression.arguments.length !== 1)
+                throw new Error(`Error on typia.${method}(): no input value.`);
+
+            // GET TYPE INFO
+            const [type, node, generic]: [ts.Type, ts.Node, boolean] =
+                expression.typeArguments && expression.typeArguments[0]
+                    ? [
+                          project.checker.getTypeFromTypeNode(
+                              expression.typeArguments[0],
+                          ),
+                          expression.typeArguments[0],
+                          true,
+                      ]
+                    : [
+                          project.checker.getTypeAtLocation(
+                              expression.arguments[0]!,
+                          ),
+                          expression.arguments[0]!,
+                          false,
+                      ];
+            if (type.isTypeParameter())
+                throw new Error(
+                    `Error on typia.${method}(): non-specified generic argument.`,
+                );
+
+            // DO TRANSFORM
+            return ts.factory.createCallExpression(
+                programmer(project)(modulo)(
+                    type,
+                    generic
+                        ? node.getFullText().trim()
+                        : name(project.checker)(type)(node),
+                ),
+                undefined,
+                [expression.arguments[0]!],
+            );
+        };
+
+    export const factory =
+        (method: string) =>
+        (
+            programmer: (
+                project: IProject,
+            ) => (
+                modulo: ts.LeftHandSideExpression,
+            ) => (type: ts.Type, name: string) => ts.ArrowFunction,
+        ) =>
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (expression: ts.CallExpression) => {
+            // CHECK GENERIC ARGUMENT EXISTENCE
+            if (!expression.typeArguments?.[0])
+                throw new Error(
+                    `Error on typia.${method}(): generic argument is not specified.`,
+                );
+
+            // GET TYPE INFO
+            const node: ts.TypeNode = expression.typeArguments[0];
+            const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+
+            if (type.isTypeParameter())
+                throw new Error(
+                    `Error on typia.${method}(): non-specified generic argument.`,
+                );
+
+            // DO TRANSFORM
+            return programmer(project)(modulo)(type, node.getFullText().trim());
+        };
+
+    const name =
+        (checker: ts.TypeChecker) =>
+        (type: ts.Type) =>
+        (node: ts.Node): string =>
+            checker.typeToString(
+                type,
+                node,
+                ts.TypeFormatFlags.NodeBuilderFlagsMask,
+            );
+}

package/src/utils/ArrayUtil.ts

@@ -1,44 +1,44 @@
-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,
-    ): void => {
-        if (array.some((elem) => pred(elem, value))) return;
-        array.push(value);
-    };
-
-    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,
+    ): void => {
+        if (array.some((elem) => pred(elem, value))) return;
+        array.push(value);
+    };
+
+    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,45 +1,45 @@
-export namespace Escaper {
-    export const variable = (str: string): boolean =>
-        reserved(str) === false && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str);
-
-    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",
-    "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);
+
+    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",
+    "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/PatternUtil.ts

@@ -1,30 +1,30 @@
-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 = "-?\\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 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 = "-?\\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;
+    };