typia 3.6.0 → 3.6.1

package/src/programmers/CloneProgrammer.ts

@@ -312,16 +312,15 @@ export namespace CloneProgrammer {
         importer: FunctionImporter,
     ): FeatureProgrammer.IConfig => ({
         types: {
-            input: (type) =>
+            input: (type, name) =>
                 ts.factory.createTypeReferenceNode(
-                    TypeFactory.getFullName(project.checker, type),
+                    name ?? TypeFactory.getFullName(project.checker, type),
                 ),
-            output: (type) =>
+            output: (type, name) =>
                 ts.factory.createTypeReferenceNode(
-                    `typia.Primitive<${TypeFactory.getFullName(
-                        project.checker,
-                        type,
-                    )}>`,
+                    `typia.Primitive<${
+                        name ?? TypeFactory.getFullName(project.checker, type)
+                    }>`,
                 ),
         },
         functors: FUNCTORS,

package/src/programmers/FeatureProgrammer.ts

@@ -70,8 +70,8 @@ export namespace FeatureProgrammer {
     }
     export namespace IConfig {
         export interface ITypes {
-            input: (type: ts.Type, node?: ts.TypeNode) => ts.TypeNode;
-            output: (type: ts.Type, node?: ts.TypeNode) => ts.TypeNode;
+            input: (type: ts.Type, name?: string) => ts.TypeNode;
+            output: (type: ts.Type, name?: string) => ts.TypeNode;
         }
 
         export interface IObjector {
@@ -227,7 +227,7 @@ export namespace FeatureProgrammer {
                 collection: MetadataCollection,
             ) => ts.Statement[] | undefined,
         ) =>
-        (type: ts.Type, typeNode?: ts.TypeNode) => {
+        (type: ts.Type, name?: string) => {
             const [collection, meta] = config.initializer(project, type);
 
             // ITERATE OVER ALL METADATA
@@ -257,10 +257,10 @@ export namespace FeatureProgrammer {
             return ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                PARAMETERS(config)(config.types.input(type, typeNode))(
+                PARAMETERS(config)(config.types.input(type, name))(
                     ValueFactory.INPUT(),
                 ),
-                config.types.output(type, typeNode),
+                config.types.output(type, name),
                 undefined,
                 ts.factory.createBlock(
                     [

package/src/programmers/IsCloneProgrammer.ts

@@ -12,7 +12,7 @@ import { IsProgrammer } from "./IsProgrammer";
 export namespace IsCloneProgrammer {
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type) =>
+        (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
@@ -24,10 +24,10 @@ export namespace IsCloneProgrammer {
                 ],
                 ts.factory.createUnionTypeNode([
                     ts.factory.createTypeReferenceNode(
-                        `typia.Primitive<${TypeFactory.getFullName(
-                            project.checker,
-                            type,
-                        )}>`,
+                        `typia.Primitive<${
+                            name ??
+                            TypeFactory.getFullName(project.checker, type)
+                        }>`,
                     ),
                     ts.factory.createLiteralTypeNode(ts.factory.createNull()),
                 ]),

package/src/programmers/IsParseProgrammer.ts

@@ -11,7 +11,7 @@ import { IsProgrammer } from "./IsProgrammer";
 export namespace IsParseProgrammer {
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type) =>
+        (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
@@ -22,10 +22,9 @@ export namespace IsParseProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    `typia.Primitive<${TypeFactory.getFullName(
-                        project.checker,
-                        type,
-                    )}>`,
+                    `typia.Primitive<${
+                        name ?? TypeFactory.getFullName(project.checker, type)
+                    }>`,
                 ),
                 undefined,
                 ts.factory.createBlock([

package/src/programmers/IsPruneProgrammer.ts

@@ -12,7 +12,7 @@ import { PruneProgrammer } from "./PruneProgrammer";
 export namespace IsPruneProgrammer {
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type) =>
+        (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
@@ -26,7 +26,7 @@ export namespace IsPruneProgrammer {
                     undefined,
                     "input",
                     ts.factory.createTypeReferenceNode(
-                        TypeFactory.getFullName(project.checker, type),
+                        name ?? TypeFactory.getFullName(project.checker, type),
                     ),
                 ),
                 undefined,

package/src/programmers/IsStringifyProgrammer.ts

@@ -12,7 +12,7 @@ import { StringifyProgrammer } from "./StringifyProgrammer";
 export namespace IsStringifyProgrammer {
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type) =>
+        (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
@@ -20,7 +20,8 @@ export namespace IsStringifyProgrammer {
                     IdentifierFactory.parameter(
                         "input",
                         ts.factory.createTypeReferenceNode(
-                            TypeFactory.getFullName(project.checker, type),
+                            name ??
+                                TypeFactory.getFullName(project.checker, type),
                         ),
                     ),
                 ],

package/src/programmers/PruneProgrammer.ts

@@ -272,9 +272,9 @@ export namespace PruneProgrammer {
         importer: FunctionImporter,
     ): FeatureProgrammer.IConfig => ({
         types: {
-            input: (type) =>
+            input: (type, name) =>
                 ts.factory.createTypeReferenceNode(
-                    TypeFactory.getFullName(project.checker, type),
+                    name ?? TypeFactory.getFullName(project.checker, type),
                 ),
             output: () => TypeFactory.keyword("void"),
         },

package/src/programmers/RandomProgrammer.ts

@@ -23,7 +23,7 @@ export namespace RandomProgrammer {
         modulo: ts.LeftHandSideExpression,
     ) {
         const importer: FunctionImporter = new FunctionImporter();
-        return (type: ts.Type) => {
+        return (type: ts.Type, name?: string) => {
             // INITIALIZE METADATA
             const collection: MetadataCollection = new MetadataCollection();
             const meta: Metadata = MetadataFactory.generate(
@@ -65,10 +65,9 @@ export namespace RandomProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    `typia.Primitive<${TypeFactory.getFullName(
-                        project.checker,
-                        type,
-                    )}>`,
+                    `typia.Primitive<${
+                        name ?? TypeFactory.getFullName(project.checker, type)
+                    }>`,
                 ),
                 undefined,
                 ts.factory.createBlock(

package/src/programmers/StringifyProgrammer.ts

@@ -708,9 +708,9 @@ export namespace StringifyProgrammer {
         importer: FunctionImporter,
     ): FeatureProgrammer.IConfig => ({
         types: {
-            input: (type) =>
+            input: (type, name) =>
                 ts.factory.createTypeReferenceNode(
-                    TypeFactory.getFullName(project.checker, type),
+                    name ?? TypeFactory.getFullName(project.checker, type),
                 ),
             output: () => TypeFactory.keyword("string"),
         },

package/src/programmers/ValidateCloneProgrammer.ts

@@ -12,7 +12,7 @@ import { ValidateProgrammer } from "./ValidateProgrammer";
 export namespace ValidateCloneProgrammer {
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type) =>
+        (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
@@ -23,10 +23,9 @@ export namespace ValidateCloneProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    `typia.IValidation<typia.Primitive<${TypeFactory.getFullName(
-                        project.checker,
-                        type,
-                    )}>>`,
+                    `typia.IValidation<typia.Primitive<${
+                        name ?? TypeFactory.getFullName(project.checker, type)
+                    }>>`,
                 ),
                 undefined,
                 ts.factory.createBlock([

package/src/programmers/ValidateParseProgrammer.ts

@@ -11,7 +11,7 @@ import { ValidateProgrammer } from "./ValidateProgrammer";
 export namespace ValidateParseProgrammer {
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type) =>
+        (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
@@ -22,10 +22,9 @@ export namespace ValidateParseProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    `typia.IValidation<typia.Primitive<${TypeFactory.getFullName(
-                        project.checker,
-                        type,
-                    )}>>`,
+                    `typia.IValidation<typia.Primitive<${
+                        name ?? TypeFactory.getFullName(project.checker, type)
+                    }>>`,
                 ),
                 undefined,
                 ts.factory.createBlock([

package/src/programmers/ValidateProgrammer.ts

@@ -20,7 +20,7 @@ export namespace ValidateProgrammer {
             modulo: ts.LeftHandSideExpression,
             equals: boolean = false,
         ) =>
-        (type: ts.Type) => {
+        (type: ts.Type, name?: string) => {
             const importer: FunctionImporter = new FunctionImporter();
             const program: ts.ArrowFunction = CheckerProgrammer.generate(
                 project,
@@ -48,10 +48,9 @@ export namespace ValidateProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    `typia.IValidation<${TypeFactory.getFullName(
-                        project.checker,
-                        type,
-                    )}>`,
+                    `typia.IValidation<${
+                        name ?? TypeFactory.getFullName(project.checker, type)
+                    }>`,
                 ),
                 undefined,
                 ts.factory.createBlock(

package/src/programmers/ValidatePruneProgrammer.ts

@@ -12,7 +12,7 @@ import { ValidateProgrammer } from "./ValidateProgrammer";
 export namespace ValidatePruneProgrammer {
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type) =>
+        (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
@@ -23,10 +23,9 @@ export namespace ValidatePruneProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    `typia.IValidation<${TypeFactory.getFullName(
-                        project.checker,
-                        type,
-                    )}>`,
+                    `typia.IValidation<${
+                        name ?? TypeFactory.getFullName(project.checker, type)
+                    }>`,
                 ),
                 undefined,
                 ts.factory.createBlock([

package/src/programmers/ValidateStringifyProgrammer.ts

@@ -12,7 +12,7 @@ import { ValidateProgrammer } from "./ValidateProgrammer";
 export namespace ValidateStringifyProgrammer {
     export const generate =
         (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type) =>
+        (type: ts.Type, name?: string) =>
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
@@ -20,7 +20,8 @@ export namespace ValidateStringifyProgrammer {
                     IdentifierFactory.parameter(
                         "input",
                         ts.factory.createTypeReferenceNode(
-                            TypeFactory.getFullName(project.checker, type),
+                            name ??
+                                TypeFactory.getFullName(project.checker, type),
                         ),
                     ),
                 ],

package/src/transformers/features/miscellaneous/AssertCloneTransformer.ts

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

package/src/transformers/features/miscellaneous/AssertPruneTransformer.ts

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

package/src/transformers/features/miscellaneous/CloneTransformer.ts

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

package/src/transformers/features/miscellaneous/CreateAssertCloneTransformer.ts

@@ -1,32 +1,9 @@
-import ts from "typescript";
-
 import { AssertCloneProgrammer } from "../../../programmers/AssertCloneProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateAssertCloneTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!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 AssertCloneProgrammer.generate(project, modulo)(type);
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.assertClone(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.assertClone(): non-specified generic argument.",
+    export const transform = GenericTransformer.factory("createAssertClone")(
+        (project, modulo) => AssertCloneProgrammer.generate(project, modulo),
+    );
 }

package/src/transformers/features/miscellaneous/CreateAssertPruneTransformer.ts

@@ -1,32 +1,9 @@
-import ts from "typescript";
-
 import { AssertPruneProgrammer } from "../../../programmers/AssertPruneProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateAssertPruneTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!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 AssertPruneProgrammer.generate(project, modulo)(type);
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.assertPrune(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.assertPrune(): non-specified generic argument.",
+    export const transform = GenericTransformer.factory("createAssertPrune")(
+        (project, modulo) => AssertPruneProgrammer.generate(project, modulo),
+    );
 }

package/src/transformers/features/miscellaneous/CreateCloneTransformer.ts

@@ -1,31 +1,9 @@
-import ts from "typescript";
-
 import { CloneProgrammer } from "../../../programmers/CloneProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateCloneTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!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 CloneProgrammer.generate(project, modulo)(type);
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.clone(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.clone(): non-specified generic argument.",
+    export const transform = GenericTransformer.factory("createClone")(
+        (project, modulo) => CloneProgrammer.generate(project, modulo),
+    );
 }

package/src/transformers/features/miscellaneous/CreateIsCloneTransformer.ts

@@ -1,32 +1,9 @@
-import ts from "typescript";
-
 import { IsCloneProgrammer } from "../../../programmers/IsCloneProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateIsCloneTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!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 IsCloneProgrammer.generate(project, modulo)(type);
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.isClone(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.isClone(): non-specified generic argument.",
+    export const transform = GenericTransformer.factory("createIsClone")(
+        (project, modulo) => IsCloneProgrammer.generate(project, modulo),
+    );
 }

package/src/transformers/features/miscellaneous/CreateIsPruneTransformer.ts

@@ -1,32 +1,9 @@
-import ts from "typescript";
-
 import { IsPruneProgrammer } from "../../../programmers/IsPruneProgrammer";
 
-import { IProject } from "../../IProject";
+import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateIsPruneTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!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 IsPruneProgrammer.generate(project, modulo)(type);
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.isPrune(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.isPrune(): non-specified generic argument.",
+    export const transform = GenericTransformer.factory("createIsPrune")(
+        (project, modulo) => IsPruneProgrammer.generate(project, modulo),
+    );
 }