typia 4.0.0-dev.20230517 → 4.0.0-dev.20230519

package/src/programmers/ValidatePruneProgrammer.ts

@@ -1,86 +1,86 @@
-import ts from "typescript/lib/tsclibrary";
-
-import { IdentifierFactory } from "../factories/IdentifierFactory";
-import { StatementFactory } from "../factories/StatementFactory";
-import { TypeFactory } from "../factories/TypeFactory";
-
-import { IProject } from "../transformers/IProject";
-
-import { PruneProgrammer } from "./PruneProgrammer";
-import { ValidateProgrammer } from "./ValidateProgrammer";
-
-export namespace ValidatePruneProgrammer {
-    /**
-     * @deprecated Use `write()` function instead
-     */
-    export const generate =
-        (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            write(project)(modulo)(type, name);
-
-    export const write =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [
-                    IdentifierFactory.parameter(
-                        "input",
-                        TypeFactory.keyword("any"),
-                    ),
-                ],
-                ts.factory.createTypeReferenceNode(
-                    `typia.IValidation<${
-                        name ?? TypeFactory.getFullName(project.checker)(type)
-                    }>`,
-                ),
-                undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
-                        "validate",
-                        ValidateProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: true,
-                            },
-                        })(modulo)(false)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "prune",
-                        PruneProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(type, name),
-                    ),
-                    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"),
-                    ),
-                ]),
-            );
-}
+import type ts from "typescript/lib/tsclibrary";
+
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { StatementFactory } from "../factories/StatementFactory";
+import { TypeFactory } from "../factories/TypeFactory";
+
+import { IProject } from "../transformers/IProject";
+
+import { PruneProgrammer } from "./PruneProgrammer";
+import { ValidateProgrammer } from "./ValidateProgrammer";
+
+export namespace ValidatePruneProgrammer {
+    /**
+     * @deprecated Use `write()` function instead
+     */
+    export const generate =
+        (project: IProject, modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            write(project)(modulo)(type, name);
+
+    export const write =
+        (p: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            p.tsc.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(p.tsc)(
+                        "input",
+                        TypeFactory.keyword(p.tsc)("any"),
+                    ),
+                ],
+                p.tsc.factory.createTypeReferenceNode(
+                    `typia.IValidation<${
+                        name ?? TypeFactory.getFullName(p)(type)
+                    }>`,
+                ),
+                undefined,
+                p.tsc.factory.createBlock([
+                    StatementFactory.constant(p.tsc)(
+                        "validate",
+                        ValidateProgrammer.write({
+                            ...p,
+                            options: {
+                                ...p.options,
+                                functional: false,
+                                numeric: true,
+                            },
+                        })(modulo)(false)(type, name),
+                    ),
+                    StatementFactory.constant(p.tsc)(
+                        "prune",
+                        PruneProgrammer.write({
+                            ...p,
+                            options: {
+                                ...p.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(type, name),
+                    ),
+                    StatementFactory.constant(p.tsc)(
+                        "output",
+                        p.tsc.factory.createCallExpression(
+                            p.tsc.factory.createIdentifier("validate"),
+                            undefined,
+                            [p.tsc.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    p.tsc.factory.createIfStatement(
+                        p.tsc.factory.createIdentifier("output.success"),
+                        p.tsc.factory.createExpressionStatement(
+                            p.tsc.factory.createCallExpression(
+                                p.tsc.factory.createIdentifier("prune"),
+                                undefined,
+                                [p.tsc.factory.createIdentifier("input")],
+                            ),
+                        ),
+                    ),
+                    p.tsc.factory.createReturnStatement(
+                        p.tsc.factory.createIdentifier("output"),
+                    ),
+                ]),
+            );
+}

package/src/programmers/ValidateStringifyProgrammer.ts

@@ -1,92 +1,93 @@
-import ts from "typescript/lib/tsclibrary";
-
-import { IdentifierFactory } from "../factories/IdentifierFactory";
-import { StatementFactory } from "../factories/StatementFactory";
-import { TypeFactory } from "../factories/TypeFactory";
-
-import { IProject } from "../transformers/IProject";
-
-import { StringifyProgrammer } from "./StringifyProgrammer";
-import { ValidateProgrammer } from "./ValidateProgrammer";
-
-export namespace ValidateStringifyProgrammer {
-    /**
-     * @deprecated Use `write()` function instead
-     */
-    export const generate =
-        (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            write(project)(modulo)(type, name);
-
-    export const write =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [
-                    IdentifierFactory.parameter(
-                        "input",
-                        ts.factory.createTypeReferenceNode(
-                            name ??
-                                TypeFactory.getFullName(project.checker)(type),
-                        ),
-                    ),
-                ],
-                ts.factory.createTypeReferenceNode("typia.IValidation<string>"),
-                undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
-                        "validate",
-                        ValidateProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: true,
-                            },
-                        })(modulo)(false)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "stringify",
-                        StringifyProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "output",
-                        ts.factory.createAsExpression(
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("validate"),
-                                undefined,
-                                [ts.factory.createIdentifier("input")],
-                            ),
-                            TypeFactory.keyword("any"),
-                        ),
-                    ),
-                    ts.factory.createIfStatement(
-                        ts.factory.createIdentifier("output.success"),
-                        ts.factory.createExpressionStatement(
-                            ts.factory.createBinaryExpression(
-                                ts.factory.createIdentifier("output.data"),
-                                ts.SyntaxKind.EqualsToken,
-                                ts.factory.createCallExpression(
-                                    ts.factory.createIdentifier("stringify"),
-                                    undefined,
-                                    [ts.factory.createIdentifier("input")],
-                                ),
-                            ),
-                        ),
-                    ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createIdentifier("output"),
-                    ),
-                ]),
-            );
-}
+import type ts from "typescript/lib/tsclibrary";
+
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { StatementFactory } from "../factories/StatementFactory";
+import { TypeFactory } from "../factories/TypeFactory";
+
+import { IProject } from "../transformers/IProject";
+
+import { StringifyProgrammer } from "./StringifyProgrammer";
+import { ValidateProgrammer } from "./ValidateProgrammer";
+
+export namespace ValidateStringifyProgrammer {
+    /**
+     * @deprecated Use `write()` function instead
+     */
+    export const generate =
+        (project: IProject, modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            write(project)(modulo)(type, name);
+
+    export const write =
+        (p: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            p.tsc.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(p.tsc)(
+                        "input",
+                        p.tsc.factory.createTypeReferenceNode(
+                            name ?? TypeFactory.getFullName(p)(type),
+                        ),
+                    ),
+                ],
+                p.tsc.factory.createTypeReferenceNode(
+                    "typia.IValidation<string>",
+                ),
+                undefined,
+                p.tsc.factory.createBlock([
+                    StatementFactory.constant(p.tsc)(
+                        "validate",
+                        ValidateProgrammer.write({
+                            ...p,
+                            options: {
+                                ...p.options,
+                                functional: false,
+                                numeric: true,
+                            },
+                        })(modulo)(false)(type, name),
+                    ),
+                    StatementFactory.constant(p.tsc)(
+                        "stringify",
+                        StringifyProgrammer.write({
+                            ...p,
+                            options: {
+                                ...p.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(type, name),
+                    ),
+                    StatementFactory.constant(p.tsc)(
+                        "output",
+                        p.tsc.factory.createAsExpression(
+                            p.tsc.factory.createCallExpression(
+                                p.tsc.factory.createIdentifier("validate"),
+                                undefined,
+                                [p.tsc.factory.createIdentifier("input")],
+                            ),
+                            TypeFactory.keyword(p.tsc)("any"),
+                        ),
+                    ),
+                    p.tsc.factory.createIfStatement(
+                        p.tsc.factory.createIdentifier("output.success"),
+                        p.tsc.factory.createExpressionStatement(
+                            p.tsc.factory.createBinaryExpression(
+                                p.tsc.factory.createIdentifier("output.data"),
+                                p.tsc.SyntaxKind.EqualsToken,
+                                p.tsc.factory.createCallExpression(
+                                    p.tsc.factory.createIdentifier("stringify"),
+                                    undefined,
+                                    [p.tsc.factory.createIdentifier("input")],
+                                ),
+                            ),
+                        ),
+                    ),
+                    p.tsc.factory.createReturnStatement(
+                        p.tsc.factory.createIdentifier("output"),
+                    ),
+                ]),
+            );
+}

package/src/programmers/helpers/CloneJoiner.ts

@@ -1,131 +1,138 @@
-import ts from "typescript/lib/tsclibrary";
-
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { Escaper } from "../../utils/Escaper";
-
-import { metadata_to_pattern } from "../internal/metadata_to_pattern";
-import { IExpressionEntry } from "./IExpressionEntry";
-
-export namespace CloneJoiner {
-    export const object = (
-        input: ts.Expression,
-        entries: IExpressionEntry<ts.Expression>[],
-    ): ts.ConciseBody => {
-        if (entries.length === 0) return ts.factory.createIdentifier("{}");
-
-        const regular = entries.filter((e) => e.key.isSoleLiteral());
-        const dynamic = entries.filter((e) => !e.key.isSoleLiteral());
-        const literal = ts.factory.createObjectLiteralExpression(
-            regular.map((entry) => {
-                const str: string = entry.key.getSoleLiteral()!;
-                return ts.factory.createPropertyAssignment(
-                    Escaper.variable(str)
-                        ? str
-                        : ts.factory.createStringLiteral(str),
-                    entry.expression,
-                );
-            }),
-            true,
-        );
-        if (dynamic.length === 0) return literal;
-
-        const key = ts.factory.createIdentifier("key");
-        const value = ts.factory.createIdentifier("value");
-        const output = ts.factory.createIdentifier("output");
-
-        const statements: ts.Statement[] = dynamic.map((entry) =>
-            ts.factory.createIfStatement(
-                ts.factory.createCallExpression(
-                    ts.factory.createIdentifier(
-                        `RegExp(/${metadata_to_pattern(true)(
-                            entry.key,
-                        )}/).test`,
-                    ),
-                    undefined,
-                    [key],
-                ),
-                ts.factory.createBlock([
-                    ts.factory.createExpressionStatement(
-                        ts.factory.createBinaryExpression(
-                            ts.factory.createElementAccessExpression(
-                                output,
-                                key,
-                            ),
-                            ts.factory.createToken(ts.SyntaxKind.EqualsToken),
-                            entry.expression,
-                        ),
-                    ),
-                    ts.factory.createContinueStatement(),
-                ]),
-            ),
-        );
-
-        return ts.factory.createBlock([
-            StatementFactory.constant(
-                "output",
-                ts.factory.createAsExpression(
-                    literal,
-                    TypeFactory.keyword("any"),
-                ),
-            ),
-            ts.factory.createForOfStatement(
-                undefined,
-                ts.factory.createVariableDeclarationList(
-                    [
-                        ts.factory.createVariableDeclaration(
-                            ts.factory.createArrayBindingPattern([
-                                ts.factory.createBindingElement(
-                                    undefined,
-                                    undefined,
-                                    key,
-                                    undefined,
-                                ),
-                                ts.factory.createBindingElement(
-                                    undefined,
-                                    undefined,
-                                    value,
-                                    undefined,
-                                ),
-                            ]),
-                            undefined,
-                            undefined,
-                            undefined,
-                        ),
-                    ],
-                    ts.NodeFlags.Const,
-                ),
-                ts.factory.createCallExpression(
-                    ts.factory.createIdentifier("Object.entries"),
-                    undefined,
-                    [input],
-                ),
-                ts.factory.createBlock(statements),
-            ),
-            ts.factory.createReturnStatement(output),
-        ]);
-    };
-
-    export const tuple = (
-        children: ts.Expression[],
-        rest: ts.Expression | null,
-    ): ts.Expression => {
-        return ts.factory.createAsExpression(
-            ts.factory.createArrayLiteralExpression(
-                rest === null
-                    ? children
-                    : [...children, ts.factory.createSpreadElement(rest)],
-                true,
-            ),
-            TypeFactory.keyword("any"),
-        );
-    };
-
-    export const array = (input: ts.Expression, arrow: ts.Expression) =>
-        ts.factory.createCallExpression(
-            ts.factory.createPropertyAccessExpression(input, "map"),
-            undefined,
-            [arrow],
-        );
-}
+import type ts from "typescript/lib/tsclibrary";
+
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { Escaper } from "../../utils/Escaper";
+
+import { metadata_to_pattern } from "../internal/metadata_to_pattern";
+import { IExpressionEntry } from "./IExpressionEntry";
+
+export namespace CloneJoiner {
+    export const object =
+        (tsc: typeof ts) =>
+        (
+            input: ts.Expression,
+            entries: IExpressionEntry<ts.Expression>[],
+        ): ts.ConciseBody => {
+            if (entries.length === 0) return tsc.factory.createIdentifier("{}");
+
+            const regular = entries.filter((e) => e.key.isSoleLiteral());
+            const dynamic = entries.filter((e) => !e.key.isSoleLiteral());
+            const literal = tsc.factory.createObjectLiteralExpression(
+                regular.map((entry) => {
+                    const str: string = entry.key.getSoleLiteral()!;
+                    return tsc.factory.createPropertyAssignment(
+                        Escaper.variable(str)
+                            ? str
+                            : tsc.factory.createStringLiteral(str),
+                        entry.expression,
+                    );
+                }),
+                true,
+            );
+            if (dynamic.length === 0) return literal;
+
+            const key = tsc.factory.createIdentifier("key");
+            const value = tsc.factory.createIdentifier("value");
+            const output = tsc.factory.createIdentifier("output");
+
+            const statements: ts.Statement[] = dynamic.map((entry) =>
+                tsc.factory.createIfStatement(
+                    tsc.factory.createCallExpression(
+                        tsc.factory.createIdentifier(
+                            `RegExp(/${metadata_to_pattern(true)(
+                                entry.key,
+                            )}/).test`,
+                        ),
+                        undefined,
+                        [key],
+                    ),
+                    tsc.factory.createBlock([
+                        tsc.factory.createExpressionStatement(
+                            tsc.factory.createBinaryExpression(
+                                tsc.factory.createElementAccessExpression(
+                                    output,
+                                    key,
+                                ),
+                                tsc.factory.createToken(
+                                    tsc.SyntaxKind.EqualsToken,
+                                ),
+                                entry.expression,
+                            ),
+                        ),
+                        tsc.factory.createContinueStatement(),
+                    ]),
+                ),
+            );
+
+            return tsc.factory.createBlock([
+                StatementFactory.constant(tsc)(
+                    "output",
+                    tsc.factory.createAsExpression(
+                        literal,
+                        TypeFactory.keyword(tsc)("any"),
+                    ),
+                ),
+                tsc.factory.createForOfStatement(
+                    undefined,
+                    tsc.factory.createVariableDeclarationList(
+                        [
+                            tsc.factory.createVariableDeclaration(
+                                tsc.factory.createArrayBindingPattern([
+                                    tsc.factory.createBindingElement(
+                                        undefined,
+                                        undefined,
+                                        key,
+                                        undefined,
+                                    ),
+                                    tsc.factory.createBindingElement(
+                                        undefined,
+                                        undefined,
+                                        value,
+                                        undefined,
+                                    ),
+                                ]),
+                                undefined,
+                                undefined,
+                                undefined,
+                            ),
+                        ],
+                        tsc.NodeFlags.Const,
+                    ),
+                    tsc.factory.createCallExpression(
+                        tsc.factory.createIdentifier("Object.entries"),
+                        undefined,
+                        [input],
+                    ),
+                    tsc.factory.createBlock(statements),
+                ),
+                tsc.factory.createReturnStatement(output),
+            ]);
+        };
+
+    export const tuple =
+        (tsc: typeof ts) =>
+        (
+            children: ts.Expression[],
+            rest: ts.Expression | null,
+        ): ts.Expression => {
+            return tsc.factory.createAsExpression(
+                tsc.factory.createArrayLiteralExpression(
+                    rest === null
+                        ? children
+                        : [...children, tsc.factory.createSpreadElement(rest)],
+                    true,
+                ),
+                TypeFactory.keyword(tsc)("any"),
+            );
+        };
+
+    export const array =
+        (tsc: typeof ts) => (input: ts.Expression, arrow: ts.Expression) =>
+            tsc.factory.createCallExpression(
+                tsc.factory.createPropertyAccessExpression(input, "map"),
+                undefined,
+                [arrow],
+            );
+}