typia 3.5.0-dev.20230211 → 3.5.0-dev.20230212

package/src/programmers/IsPruneProgrammer.ts

@@ -0,0 +1,63 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { StatementFactory } from "../factories/StatementFactory";
+
+import { IProject } from "../transformers/IProject";
+
+import { IsProgrammer } from "./IsProgrammer";
+import { PruneProgrammer } from "./PruneProgrammer";
+
+export namespace IsPruneProgrammer {
+    export const generate =
+        (project: IProject, modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type) =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("input")],
+                undefined,
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "is",
+                        IsProgrammer.generate(project, modulo)(type),
+                    ),
+                    StatementFactory.constant(
+                        "prune",
+                        PruneProgrammer.generate(
+                            {
+                                ...project,
+                                options: {
+                                    ...project.options,
+                                    functional: false,
+                                    numeric: false,
+                                },
+                            },
+                            modulo,
+                        )(type),
+                    ),
+                    ts.factory.createIfStatement(
+                        ts.factory.createPrefixUnaryExpression(
+                            ts.SyntaxKind.ExclamationToken,
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("is"),
+                                undefined,
+                                [ts.factory.createIdentifier("input")],
+                            ),
+                        ),
+                        ts.factory.createReturnStatement(
+                            ts.factory.createFalse(),
+                        ),
+                    ),
+                    ts.factory.createExpressionStatement(
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("prune"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(ts.factory.createTrue()),
+                ]),
+            );
+}

package/src/programmers/PruneProgrammer.ts

@@ -145,12 +145,15 @@ export namespace PruneProgrammer {
             //----
             // STATEMENTS
             //----
-            const value = (v: ts.Expression | ts.Block | ts.ReturnStatement) =>
+            const converter = (
+                v: ts.Expression | ts.Block | ts.ReturnStatement,
+            ) =>
                 ts.isReturnStatement(v) || ts.isBlock(v)
                     ? v
                     : ts.factory.createExpressionStatement(v);
+
             const statements: ts.Statement[] = unions.map((u) =>
-                ts.factory.createIfStatement(u.is(), value(u.value())),
+                ts.factory.createIfStatement(u.is(), converter(u.value())),
             );
             return ts.factory.createBlock(statements, true);
         };

package/src/programmers/ValidatePruneProgrammer.ts

@@ -0,0 +1,73 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { StatementFactory } from "../factories/StatementFactory";
+
+import { IProject } from "../transformers/IProject";
+
+import { PruneProgrammer } from "./PruneProgrammer";
+import { ValidateProgrammer } from "./ValidateProgrammer";
+
+export namespace ValidatePruneProgrammer {
+    export const generate =
+        (project: IProject, modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type) =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("input")],
+                undefined,
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "validate",
+                        ValidateProgrammer.generate(
+                            {
+                                ...project,
+                                options: {
+                                    ...project.options,
+                                    functional: false,
+                                    numeric: true,
+                                },
+                            },
+                            modulo,
+                        )(type),
+                    ),
+                    StatementFactory.constant(
+                        "prune",
+                        PruneProgrammer.generate(
+                            {
+                                ...project,
+                                options: {
+                                    ...project.options,
+                                    functional: false,
+                                    numeric: false,
+                                },
+                            },
+                            modulo,
+                        )(type),
+                    ),
+                    StatementFactory.constant(
+                        "output",
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("validate"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    ts.factory.createIfStatement(
+                        ts.factory.createIdentifier("output.success"),
+                        ts.factory.createExpressionStatement(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("prune"),
+                                undefined,
+                                [ts.factory.createIdentifier("input")],
+                            ),
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createIdentifier("output"),
+                    ),
+                ]),
+            );
+}

package/src/transformers/CallExpressionTransformer.ts

@@ -3,9 +3,15 @@ import ts from "typescript";
 
 import { IProject } from "./IProject";
 import { ApplicationTransformer } from "./features/miscellaneous/ApplicationTransformer";
+import { AssertPruneTransformer } from "./features/miscellaneous/AssertPruneTransformer";
+import { CreateAssertPruneTransformer } from "./features/miscellaneous/CreateAssertPruneTransformer";
+import { CreateIsPruneTransformer } from "./features/miscellaneous/CreateIsPruneTransformer";
 import { CreatePruneTransformer } from "./features/miscellaneous/CreatePruneTransformer";
+import { CreateValidatePruneTransformer } from "./features/miscellaneous/CreateValidatePruneTransformer";
+import { IsPruneTransformer } from "./features/miscellaneous/IsPruneTransformer";
 import { MetadataTransformer } from "./features/miscellaneous/MetadataTransformer";
 import { PruneTransformer } from "./features/miscellaneous/PruneTransformer";
+import { ValidatePruneTransformer } from "./features/miscellaneous/ValidatePruneTransformer";
 import { AssertParseTransformer } from "./features/parsers/AssertParseTransformer";
 import { CreateAssertParseTransformer } from "./features/parsers/CreateAssertParseTransformer";
 import { CreateIsParseTransformer } from "./features/parsers/CreateIsParseTransformer";
@@ -99,6 +105,9 @@ const FUNCTORS: Record<string, () => Task> = {
     application: () => ApplicationTransformer.transform,
     metadata: () => MetadataTransformer.transform,
     prune: () => PruneTransformer.transform,
+    assertPrune: () => AssertPruneTransformer.transform,
+    isPrune: () => IsPruneTransformer.transform,
+    validatePrune: () => ValidatePruneTransformer.transform,
 
     //----
     // FACTORY FUNCTIONS
@@ -127,4 +136,7 @@ const FUNCTORS: Record<string, () => Task> = {
 
     // MISC
     createPrune: () => CreatePruneTransformer.transform,
+    createAssertPrune: () => CreateAssertPruneTransformer.transform,
+    createIsPrune: () => CreateIsPruneTransformer.transform,
+    createValidatePrune: () => CreateValidatePruneTransformer.transform,
 };

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