typia 3.5.0-dev.20230211 → 3.5.0-dev.20230213

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

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

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

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

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

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

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

@@ -0,0 +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 || !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/CreateIsPruneTransformer.ts

@@ -0,0 +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 || !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/CreateValidatePruneTransformer.ts

@@ -0,0 +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 || !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/IsPruneTransformer.ts

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

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

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