typia 3.6.0 → 3.6.2

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

@@ -1,46 +1,9 @@
-import ts from "typescript";
-
 import { StringifyProgrammer } from "../../../programmers/StringifyProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace StringifyTransformer {
-    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);
-
-        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);
-
-        return ts.factory.createCallExpression(
-            StringifyProgrammer.generate(
-                {
-                    ...project,
-                    options: {
-                        ...project.options,
-                        functional: false,
-                        numeric: true,
-                    },
-                },
-                modulo,
-            )(type),
-            undefined,
-            [expression.arguments[0]!],
-        );
-    }
-}
-
-const enum ErrorMessages {
-    NO_INPUT_VALUE = "Error on typia.stringify(): no input value.",
-    GENERIC_ARGUMENT = "Error on typia.stringify(): non-specified generic argument.",
+    export const transform = GenericTransformer.scalar("stringify")(
+        (project, modulo) => StringifyProgrammer.generate(project, modulo),
+    );
 }

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

@@ -1,38 +1,10 @@
-import ts from "typescript";
-
 import { ValidateStringifyProgrammer } from "../../../programmers/ValidateStringifyProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 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.",
+    export const transform = GenericTransformer.scalar("validatStringify")(
+        (project, modulo) =>
+            ValidateStringifyProgrammer.generate(project, modulo),
+    );
 }

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

@@ -1,43 +1,11 @@
-import ts from "typescript";
-
 import { AssertProgrammer } from "../../../programmers/AssertProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 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]!],
-            );
-        };
-    }
+    export const transform = (equals: boolean) =>
+        GenericTransformer.scalar(equals ? "assertEquals" : "assert")(
+            (project, modulo) =>
+                AssertProgrammer.generate(project, modulo, equals),
+        );
 }

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

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

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

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

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

@@ -1,35 +1,12 @@
-import ts from "typescript";
-
 import { ValidateProgrammer } from "../../../programmers/ValidateProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 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?.[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);
-        };
-    }
+    export const transform = (equals: boolean) =>
+        GenericTransformer.factory(
+            equals ? "createValidateEquals" : "createValidate",
+        )((project, modulo) =>
+            ValidateProgrammer.generate(project, modulo, equals),
+        );
 }

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

@@ -1,43 +1,10 @@
-import ts from "typescript";
-
 import { IsProgrammer } from "../../../programmers/IsProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 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]!],
-            );
-        };
-    }
+    export const transform = (equals: boolean) =>
+        GenericTransformer.scalar(equals ? "equals" : "is")((project, modulo) =>
+            IsProgrammer.generate(project, modulo, equals),
+        );
 }

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

@@ -1,43 +1,11 @@
-import ts from "typescript";
-
 import { ValidateProgrammer } from "../../../programmers/ValidateProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 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]!],
-            );
-        };
-    }
+    export const transform = (equals: boolean) =>
+        GenericTransformer.scalar(equals ? "validateEquals" : "validate")(
+            (project, modulo) =>
+                ValidateProgrammer.generate(project, modulo, equals),
+        );
 }

package/src/transformers/internal/GenericTransformer.ts

@@ -0,0 +1,99 @@
+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.getText()
+                        : 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.getText());
+        };
+
+    const name =
+        (checker: ts.TypeChecker) =>
+        (type: ts.Type) =>
+        (node: ts.Node): string =>
+            checker.typeToString(
+                type,
+                node,
+                ts.TypeFormatFlags.NodeBuilderFlagsMask,
+            );
+}