typia 3.5.0-dev.20221222 → 3.5.0-dev.20230107

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

@@ -1,32 +1,32 @@
-import ts from "typescript";
-
-import { AssertStringifyProgrammer } from "../../../programmers/AssertStringifyProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace CreateAssertStringifyTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
-            throw new Error(ErrorMessages.NOT_SPECIFIED);
-
-        // GET TYPE INFO
-        const type: ts.Type = project.checker.getTypeFromTypeNode(
-            expression.typeArguments[0],
-        );
-        if (type.isTypeParameter())
-            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
-
-        // DO TRANSFORM
-        return AssertStringifyProgrammer.generate(project, modulo)(type);
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.assertStringify(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.assertStringify(): non-specified generic argument.",
-}
+import ts from "typescript";
+
+import { AssertStringifyProgrammer } from "../../../programmers/AssertStringifyProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CreateAssertStringifyTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        // CHECK GENERIC ARGUMENT EXISTENCE
+        if (!expression.typeArguments || !expression.typeArguments[0])
+            throw new Error(ErrorMessages.NOT_SPECIFIED);
+
+        // GET TYPE INFO
+        const type: ts.Type = project.checker.getTypeFromTypeNode(
+            expression.typeArguments[0],
+        );
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return AssertStringifyProgrammer.generate(project, modulo)(type);
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.assertStringify(): generic argument is not specified.",
+    GENERIC_ARGUMENT = "Error on typia.assertStringify(): non-specified generic argument.",
+}

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

@@ -1,32 +1,32 @@
-import ts from "typescript";
-
-import { IsStringifyProgrammer } from "../../../programmers/IsStringifyProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace CreateIsStringifyTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
-            throw new Error(ErrorMessages.NOT_SPECIFIED);
-
-        // GET TYPE INFO
-        const type: ts.Type = project.checker.getTypeFromTypeNode(
-            expression.typeArguments[0],
-        );
-        if (type.isTypeParameter())
-            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
-
-        // DO TRANSFORM
-        return IsStringifyProgrammer.generate(project, modulo)(type);
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.isStringify(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.isStringify(): non-specified generic argument.",
-}
+import ts from "typescript";
+
+import { IsStringifyProgrammer } from "../../../programmers/IsStringifyProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CreateIsStringifyTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        // CHECK GENERIC ARGUMENT EXISTENCE
+        if (!expression.typeArguments || !expression.typeArguments[0])
+            throw new Error(ErrorMessages.NOT_SPECIFIED);
+
+        // GET TYPE INFO
+        const type: ts.Type = project.checker.getTypeFromTypeNode(
+            expression.typeArguments[0],
+        );
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return IsStringifyProgrammer.generate(project, modulo)(type);
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.isStringify(): generic argument is not specified.",
+    GENERIC_ARGUMENT = "Error on typia.isStringify(): non-specified generic argument.",
+}

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

@@ -1,31 +1,31 @@
-import ts from "typescript";
-
-import { StringifyProgrammer } from "../../../programmers/StringifyProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace CreateStringifyTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
-            throw new Error(ErrorMessages.NOT_SPECIFIED);
-
-        // GET TYPE INFO
-        const type: ts.Type = project.checker.getTypeFromTypeNode(
-            expression.typeArguments[0],
-        );
-        if (type.isTypeParameter())
-            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
-
-        return StringifyProgrammer.generate(project, modulo)(type);
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.stringify(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.stringify(): non-specified generic argument.",
-}
+import ts from "typescript";
+
+import { StringifyProgrammer } from "../../../programmers/StringifyProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CreateStringifyTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        // CHECK GENERIC ARGUMENT EXISTENCE
+        if (!expression.typeArguments || !expression.typeArguments[0])
+            throw new Error(ErrorMessages.NOT_SPECIFIED);
+
+        // GET TYPE INFO
+        const type: ts.Type = project.checker.getTypeFromTypeNode(
+            expression.typeArguments[0],
+        );
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        return StringifyProgrammer.generate(project, modulo)(type);
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.stringify(): generic argument is not specified.",
+    GENERIC_ARGUMENT = "Error on typia.stringify(): non-specified generic argument.",
+}

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

@@ -1,32 +1,32 @@
-import ts from "typescript";
-
-import { ValidateStringifyProgrammer } from "../../../programmers/ValidateStringifyProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace CreateValidateStringifyTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
-            throw new Error(ErrorMessages.NOT_SPECIFIED);
-
-        // GET TYPE INFO
-        const type: ts.Type = project.checker.getTypeFromTypeNode(
-            expression.typeArguments[0],
-        );
-        if (type.isTypeParameter())
-            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
-
-        // DO TRANSFORM
-        return ValidateStringifyProgrammer.generate(project, modulo)(type);
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.validateStringify(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.validateStringify(): non-specified generic argument.",
-}
+import ts from "typescript";
+
+import { ValidateStringifyProgrammer } from "../../../programmers/ValidateStringifyProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CreateValidateStringifyTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        // CHECK GENERIC ARGUMENT EXISTENCE
+        if (!expression.typeArguments || !expression.typeArguments[0])
+            throw new Error(ErrorMessages.NOT_SPECIFIED);
+
+        // GET TYPE INFO
+        const type: ts.Type = project.checker.getTypeFromTypeNode(
+            expression.typeArguments[0],
+        );
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return ValidateStringifyProgrammer.generate(project, modulo)(type);
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.validateStringify(): generic argument is not specified.",
+    GENERIC_ARGUMENT = "Error on typia.validateStringify(): non-specified generic argument.",
+}

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

@@ -1,38 +1,38 @@
-import ts from "typescript";
-
-import { IsStringifyProgrammer } from "../../../programmers/IsStringifyProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace IsStringifyTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        if (expression.arguments.length !== 1)
-            throw new Error(ErrorMessages.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(ErrorMessages.GENERIC_ARGUMENT);
-
-        // DO TRANSFORM
-        return ts.factory.createCallExpression(
-            IsStringifyProgrammer.generate(project, modulo)(type),
-            undefined,
-            [expression.arguments[0]!],
-        );
-    }
-}
-
-const enum ErrorMessages {
-    NO_INPUT_VALUE = "Error on typia.isStringify(): no input value.",
-    GENERIC_ARGUMENT = "Error on typia.isStringify(): non-specified generic argument.",
-}
+import ts from "typescript";
+
+import { IsStringifyProgrammer } from "../../../programmers/IsStringifyProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace IsStringifyTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        if (expression.arguments.length !== 1)
+            throw new Error(ErrorMessages.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(ErrorMessages.GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return ts.factory.createCallExpression(
+            IsStringifyProgrammer.generate(project, modulo)(type),
+            undefined,
+            [expression.arguments[0]!],
+        );
+    }
+}
+
+const enum ErrorMessages {
+    NO_INPUT_VALUE = "Error on typia.isStringify(): no input value.",
+    GENERIC_ARGUMENT = "Error on typia.isStringify(): non-specified generic argument.",
+}

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

@@ -1,38 +1,38 @@
-import ts from "typescript";
-
-import { ValidateStringifyProgrammer } from "../../../programmers/ValidateStringifyProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace ValidateStringifyTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        if (expression.arguments.length !== 1)
-            throw new Error(ErrorMessages.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(ErrorMessages.GENERIC_ARGUMENT);
-
-        // DO TRANSFORM
-        return ts.factory.createCallExpression(
-            ValidateStringifyProgrammer.generate(project, modulo)(type),
-            undefined,
-            [expression.arguments[0]!],
-        );
-    }
-}
-
-const enum ErrorMessages {
-    NO_INPUT_VALUE = "Error on typia.validateStringify(): no input value.",
-    GENERIC_ARGUMENT = "Error on typia.validateStringify(): non-specified generic argument.",
-}
+import ts from "typescript";
+
+import { ValidateStringifyProgrammer } from "../../../programmers/ValidateStringifyProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace ValidateStringifyTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        if (expression.arguments.length !== 1)
+            throw new Error(ErrorMessages.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(ErrorMessages.GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return ts.factory.createCallExpression(
+            ValidateStringifyProgrammer.generate(project, modulo)(type),
+            undefined,
+            [expression.arguments[0]!],
+        );
+    }
+}
+
+const enum ErrorMessages {
+    NO_INPUT_VALUE = "Error on typia.validateStringify(): no input value.",
+    GENERIC_ARGUMENT = "Error on typia.validateStringify(): non-specified generic argument.",
+}

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

@@ -1,43 +1,43 @@
-import ts from "typescript";
-
-import { AssertProgrammer } from "../../../programmers/AssertProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace AssertTransformer {
-    export function transform(equals: boolean) {
-        const SYMBOL = equals ? "assertEquals" : "assert";
-        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(
-                AssertProgrammer.generate(project, modulo, equals)(type),
-                undefined,
-                [expression.arguments[0]!],
-            );
-        };
-    }
-}
+import ts from "typescript";
+
+import { AssertProgrammer } from "../../../programmers/AssertProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace AssertTransformer {
+    export function transform(equals: boolean) {
+        const SYMBOL = equals ? "assertEquals" : "assert";
+        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(
+                AssertProgrammer.generate(project, modulo, equals)(type),
+                undefined,
+                [expression.arguments[0]!],
+            );
+        };
+    }
+}

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

@@ -1,35 +1,35 @@
-import ts from "typescript";
-
-import { AssertProgrammer } from "../../../programmers/AssertProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace CreateAssertTransformer {
-    export function transform(equals: boolean) {
-        const SYMBOL = equals ? "createAssertEquals" : "createAssert";
-        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 AssertProgrammer.generate(project, modulo, equals)(type);
-        };
-    }
-}
+import ts from "typescript";
+
+import { AssertProgrammer } from "../../../programmers/AssertProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CreateAssertTransformer {
+    export function transform(equals: boolean) {
+        const SYMBOL = equals ? "createAssertEquals" : "createAssert";
+        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 AssertProgrammer.generate(project, modulo, equals)(type);
+        };
+    }
+}

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

@@ -1,35 +1,35 @@
-import ts from "typescript";
-
-import { IsProgrammer } from "../../../programmers/IsProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace CreateIsTransformer {
-    export function transform(equals: boolean) {
-        const SYMBOL = equals ? "createEquals" : "createIs";
-        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 IsProgrammer.generate(project, modulo, equals)(type);
-        };
-    }
-}
+import ts from "typescript";
+
+import { IsProgrammer } from "../../../programmers/IsProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CreateIsTransformer {
+    export function transform(equals: boolean) {
+        const SYMBOL = equals ? "createEquals" : "createIs";
+        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 IsProgrammer.generate(project, modulo, equals)(type);
+        };
+    }
+}