typia 3.6.0-dev.20230219 → 3.6.0-dev.20230225

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

@@ -1,31 +1,31 @@
-import ts from "typescript";
-
-import { CloneProgrammer } from "../../../programmers/CloneProgrammer";
-
-import { IProject } from "../../IProject";
-
-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.",
-}
+import ts from "typescript";
+
+import { CloneProgrammer } from "../../../programmers/CloneProgrammer";
+
+import { IProject } from "../../IProject";
+
+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.",
+}

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

@@ -1,32 +1,32 @@
-import ts from "typescript";
-
-import { IsCloneProgrammer } from "../../../programmers/IsCloneProgrammer";
-
-import { IProject } from "../../IProject";
-
-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.",
-}
+import ts from "typescript";
+
+import { IsCloneProgrammer } from "../../../programmers/IsCloneProgrammer";
+
+import { IProject } from "../../IProject";
+
+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.",
+}

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

@@ -1,32 +1,32 @@
-import ts from "typescript";
-
-import { IsPruneProgrammer } from "../../../programmers/IsPruneProgrammer";
-
-import { IProject } from "../../IProject";
-
-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.",
-}
+import ts from "typescript";
+
+import { IsPruneProgrammer } from "../../../programmers/IsPruneProgrammer";
+
+import { IProject } from "../../IProject";
+
+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.",
+}

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

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

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

@@ -1,39 +1,39 @@
-import ts from "typescript";
-
-import { RandomProgrammer } from "../../../programmers/RandomProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace CreateRandomTransformer {
-    export function transform(
-        project: IProject,
-        modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        if (!expression.typeArguments?.[0])
-            throw new Error(ErrorMessages.NOT_SPECIFIED);
-
-        const type: ts.Type | undefined = project.checker.getTypeFromTypeNode(
-            expression.typeArguments[0],
-        );
-        if (type.isTypeParameter())
-            throw new Error(ErrorMessages.NO_GENERIC_ARGUMENT);
-
-        return RandomProgrammer.generate(
-            {
-                ...project,
-                options: {
-                    ...project.options,
-                    functional: false,
-                    numeric: false,
-                },
-            },
-            modulo,
-        )(type);
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.createRandom(): generic argument is not specified.",
-    NO_GENERIC_ARGUMENT = "Error on typia.createRandom(): non-specified generic argument.",
-}
+import ts from "typescript";
+
+import { RandomProgrammer } from "../../../programmers/RandomProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CreateRandomTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        if (!expression.typeArguments?.[0])
+            throw new Error(ErrorMessages.NOT_SPECIFIED);
+
+        const type: ts.Type | undefined = project.checker.getTypeFromTypeNode(
+            expression.typeArguments[0],
+        );
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.NO_GENERIC_ARGUMENT);
+
+        return RandomProgrammer.generate(
+            {
+                ...project,
+                options: {
+                    ...project.options,
+                    functional: false,
+                    numeric: false,
+                },
+            },
+            modulo,
+        )(type);
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.createRandom(): generic argument is not specified.",
+    NO_GENERIC_ARGUMENT = "Error on typia.createRandom(): non-specified generic argument.",
+}

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

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

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

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

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

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

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

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