typia 3.4.12 → 3.4.14

package/src/transformers/features/parsers/AssertParseTransformer.ts

@@ -1,36 +1,36 @@
-import ts from "typescript";
-
-import { AssertParseProgrammer } from "../../../programmers/AssertParseProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace AssertParseTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXVALIDATETENCE
-        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 ts.factory.createCallExpression(
-            AssertParseProgrammer.generate(project, modulo)(type),
-            undefined,
-            [expression.arguments[0]!],
-        );
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.assertParse(): generic argument is not specified",
-    GENERIC_ARGUMENT = "Error on typia.assertParse(): non-specified generic argument.",
-}
+import ts from "typescript";
+
+import { AssertParseProgrammer } from "../../../programmers/AssertParseProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace AssertParseTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        // CHECK GENERIC ARGUMENT EXVALIDATETENCE
+        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 ts.factory.createCallExpression(
+            AssertParseProgrammer.generate(project, modulo)(type),
+            undefined,
+            [expression.arguments[0]!],
+        );
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.assertParse(): generic argument is not specified",
+    GENERIC_ARGUMENT = "Error on typia.assertParse(): non-specified generic argument.",
+}

package/src/transformers/features/parsers/CreateAssertParseTransformer.ts

@@ -1,32 +1,32 @@
-import ts from "typescript";
-
-import { AssertParseProgrammer } from "../../../programmers/AssertParseProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace CreateAssertParseTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXASSERTTENCE
-        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 AssertParseProgrammer.generate(project, modulo)(type);
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.assertParse(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.assertParse(): non-specified generic argument.",
-}
+import ts from "typescript";
+
+import { AssertParseProgrammer } from "../../../programmers/AssertParseProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CreateAssertParseTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        // CHECK GENERIC ARGUMENT EXASSERTTENCE
+        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 AssertParseProgrammer.generate(project, modulo)(type);
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.assertParse(): generic argument is not specified.",
+    GENERIC_ARGUMENT = "Error on typia.assertParse(): non-specified generic argument.",
+}

package/src/transformers/features/parsers/CreateIsParseTransformer.ts

@@ -1,32 +1,32 @@
-import ts from "typescript";
-
-import { IsParseProgrammer } from "../../../programmers/IsParseProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace CreateIsParseTransformer {
-    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 IsParseProgrammer.generate(project, modulo)(type);
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.isParse(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.isParse(): non-specified generic argument.",
-}
+import ts from "typescript";
+
+import { IsParseProgrammer } from "../../../programmers/IsParseProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CreateIsParseTransformer {
+    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 IsParseProgrammer.generate(project, modulo)(type);
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.isParse(): generic argument is not specified.",
+    GENERIC_ARGUMENT = "Error on typia.isParse(): non-specified generic argument.",
+}

package/src/transformers/features/parsers/CreateValidateParseTransformer.ts

@@ -1,32 +1,32 @@
-import ts from "typescript";
-
-import { ValidateParseProgrammer } from "../../../programmers/ValidateParseProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace CreateValidateParseTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXVALIDATETENCE
-        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 ValidateParseProgrammer.generate(project, modulo)(type);
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.validateParse(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.validateParse(): non-specified generic argument.",
-}
+import ts from "typescript";
+
+import { ValidateParseProgrammer } from "../../../programmers/ValidateParseProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CreateValidateParseTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        // CHECK GENERIC ARGUMENT EXVALIDATETENCE
+        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 ValidateParseProgrammer.generate(project, modulo)(type);
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.validateParse(): generic argument is not specified.",
+    GENERIC_ARGUMENT = "Error on typia.validateParse(): non-specified generic argument.",
+}

package/src/transformers/features/parsers/IsParseTransformer.ts

@@ -1,36 +1,36 @@
-import ts from "typescript";
-
-import { IsParseProgrammer } from "../../../programmers/IsParseProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace IsParseTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXVALIDATETENCE
-        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 ts.factory.createCallExpression(
-            IsParseProgrammer.generate(project, modulo)(type),
-            undefined,
-            [expression.arguments[0]!],
-        );
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.isParse(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.isParse(): non-specified generic argument.",
-}
+import ts from "typescript";
+
+import { IsParseProgrammer } from "../../../programmers/IsParseProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace IsParseTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        // CHECK GENERIC ARGUMENT EXVALIDATETENCE
+        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 ts.factory.createCallExpression(
+            IsParseProgrammer.generate(project, modulo)(type),
+            undefined,
+            [expression.arguments[0]!],
+        );
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.isParse(): generic argument is not specified.",
+    GENERIC_ARGUMENT = "Error on typia.isParse(): non-specified generic argument.",
+}

package/src/transformers/features/parsers/ValidateParseTransformer.ts

@@ -1,36 +1,36 @@
-import ts from "typescript";
-
-import { ValidateParseProgrammer } from "../../../programmers/ValidateParseProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace ValidateParseTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXVALIDATETENCE
-        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 ts.factory.createCallExpression(
-            ValidateParseProgrammer.generate(project, modulo)(type),
-            undefined,
-            [expression.arguments[0]!],
-        );
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.validateParse(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.validateParse(): non-specified generic argument.",
-}
+import ts from "typescript";
+
+import { ValidateParseProgrammer } from "../../../programmers/ValidateParseProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace ValidateParseTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        // CHECK GENERIC ARGUMENT EXVALIDATETENCE
+        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 ts.factory.createCallExpression(
+            ValidateParseProgrammer.generate(project, modulo)(type),
+            undefined,
+            [expression.arguments[0]!],
+        );
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.validateParse(): generic argument is not specified.",
+    GENERIC_ARGUMENT = "Error on typia.validateParse(): non-specified generic argument.",
+}

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

@@ -1,38 +1,38 @@
-import ts from "typescript";
-
-import { AssertStringifyProgrammer } from "../../../programmers/AssertStringifyProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace AssertStringifyTransformer {
-    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(
-            AssertStringifyProgrammer.generate(project, modulo)(type),
-            undefined,
-            [expression.arguments[0]!],
-        );
-    }
-}
-
-const enum ErrorMessages {
-    NO_INPUT_VALUE = "Error on typia.assertStringify(): no input value.",
-    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 AssertStringifyTransformer {
+    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(
+            AssertStringifyProgrammer.generate(project, modulo)(type),
+            undefined,
+            [expression.arguments[0]!],
+        );
+    }
+}
+
+const enum ErrorMessages {
+    NO_INPUT_VALUE = "Error on typia.assertStringify(): no input value.",
+    GENERIC_ARGUMENT = "Error on typia.assertStringify(): non-specified generic argument.",
+}

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.",
+}