typia 4.0.0-dev.20230502 → 4.0.0-dev.20230519

package/src/programmers/helpers/CloneJoiner.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
@@ -9,123 +9,130 @@ 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("{}");
+    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 = 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 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 = ts.factory.createIdentifier("key");
-        const value = ts.factory.createIdentifier("value");
-        const output = ts.factory.createIdentifier("output");
+            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) =>
-            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,
+            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],
                     ),
-                    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,
+                    tsc.factory.createBlock([
+                        tsc.factory.createExpressionStatement(
+                            tsc.factory.createBinaryExpression(
+                                tsc.factory.createElementAccessExpression(
+                                    output,
                                     key,
-                                    undefined,
                                 ),
-                                ts.factory.createBindingElement(
-                                    undefined,
-                                    undefined,
-                                    value,
-                                    undefined,
+                                tsc.factory.createToken(
+                                    tsc.SyntaxKind.EqualsToken,
                                 ),
-                            ]),
-                            undefined,
-                            undefined,
-                            undefined,
+                                entry.expression,
+                            ),
                         ),
-                    ],
-                    ts.NodeFlags.Const,
+                        tsc.factory.createContinueStatement(),
+                    ]),
                 ),
-                ts.factory.createCallExpression(
-                    ts.factory.createIdentifier("Object.entries"),
+            );
+
+            return tsc.factory.createBlock([
+                StatementFactory.constant(tsc)(
+                    "output",
+                    tsc.factory.createAsExpression(
+                        literal,
+                        TypeFactory.keyword(tsc)("any"),
+                    ),
+                ),
+                tsc.factory.createForOfStatement(
                     undefined,
-                    [input],
+                    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),
                 ),
-                ts.factory.createBlock(statements),
-            ),
-            ts.factory.createReturnStatement(output),
-        ]);
-    };
+                tsc.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 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 = (input: ts.Expression, arrow: ts.Expression) =>
-        ts.factory.createCallExpression(
-            ts.factory.createPropertyAccessExpression(input, "map"),
-            undefined,
-            [arrow],
-        );
+    export const array =
+        (tsc: typeof ts) => (input: ts.Expression, arrow: ts.Expression) =>
+            tsc.factory.createCallExpression(
+                tsc.factory.createPropertyAccessExpression(input, "map"),
+                undefined,
+                [arrow],
+            );
 }

package/src/programmers/helpers/FunctionImporeter.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
@@ -9,13 +9,15 @@ export class FunctionImporter {
     private readonly local_: Set<string> = new Set();
     private sequence_: number = 0;
 
+    public constructor(private readonly tsc_: typeof ts) {}
+
     public empty(): boolean {
         return this.used_.size === 0;
     }
 
     public use(name: string): ts.Identifier {
         this.used_.add(name);
-        return ts.factory.createIdentifier("$" + name);
+        return this.tsc_.factory.createIdentifier("$" + name);
     }
 
     public useLocal(name: string): string {
@@ -29,13 +31,13 @@ export class FunctionImporter {
 
     public declare(modulo: ts.LeftHandSideExpression): ts.Statement[] {
         return [...this.used_].map((name) =>
-            StatementFactory.constant(
+            StatementFactory.constant(this.tsc_)(
                 "$" + name,
-                IdentifierFactory.access(
-                    ts.factory.createParenthesizedExpression(
-                        ts.factory.createAsExpression(
+                IdentifierFactory.access(this.tsc_)(
+                    this.tsc_.factory.createParenthesizedExpression(
+                        this.tsc_.factory.createAsExpression(
                             modulo,
-                            TypeFactory.keyword("any"),
+                            TypeFactory.keyword(this.tsc_)("any"),
                         ),
                     ),
                 )(name),

package/src/programmers/helpers/ICheckEntry.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 export interface ICheckEntry {
     expression: ts.Expression;

package/src/programmers/helpers/IExpressionEntry.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { Metadata } from "../../metadata/Metadata";
 

package/src/programmers/helpers/PruneJoiner.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 
@@ -11,83 +11,95 @@ import { prune_object_properties } from "../internal/prune_object_properties";
 import { IExpressionEntry } from "./IExpressionEntry";
 
 export namespace PruneJoiner {
-    export const object = (
-        input: ts.Expression,
-        entries: IExpressionEntry[],
-        obj: MetadataObject,
-    ): ts.ConciseBody => {
-        // PREPARE ASSETS
-        const regular = entries.filter((entry) => entry.key.isSoleLiteral());
-        const dynamic = entries.filter((entry) => !entry.key.isSoleLiteral());
+    export const object =
+        (tsc: typeof ts) =>
+        (
+            input: ts.Expression,
+            entries: IExpressionEntry[],
+            obj: MetadataObject,
+        ): ts.ConciseBody => {
+            // PREPARE ASSETS
+            const regular = entries.filter((entry) =>
+                entry.key.isSoleLiteral(),
+            );
+            const dynamic = entries.filter(
+                (entry) => !entry.key.isSoleLiteral(),
+            );
 
-        const statements: ts.Statement[] = ArrayUtil.flat(
-            regular.map((entry) =>
-                ts.isBlock(entry.expression)
-                    ? [...entry.expression.statements]
-                    : [ts.factory.createExpressionStatement(entry.expression)],
-            ),
-        );
-        if (dynamic.length)
-            statements.push(
-                ts.factory.createExpressionStatement(
-                    iterate_dynamic_properties({ regular, dynamic })(input),
+            const statements: ts.Statement[] = ArrayUtil.flat(
+                regular.map((entry) =>
+                    tsc.isBlock(entry.expression)
+                        ? [...entry.expression.statements]
+                        : [
+                              tsc.factory.createExpressionStatement(
+                                  entry.expression,
+                              ),
+                          ],
                 ),
             );
+            if (dynamic.length)
+                statements.push(
+                    tsc.factory.createExpressionStatement(
+                        iterate_dynamic_properties(tsc)({ regular, dynamic })(
+                            input,
+                        ),
+                    ),
+                );
 
-        statements.push(prune_object_properties(obj));
-        return ts.factory.createBlock(statements, true);
-    };
+            statements.push(prune_object_properties(tsc)(obj));
+            return tsc.factory.createBlock(statements, true);
+        };
 
-    export const array = (input: ts.Expression, arrow: ts.ArrowFunction) =>
-        ts.factory.createCallExpression(
-            IdentifierFactory.access(input)("forEach"),
-            undefined,
-            [arrow],
-        );
+    export const array =
+        (tsc: typeof ts) => (input: ts.Expression, arrow: ts.ArrowFunction) =>
+            tsc.factory.createCallExpression(
+                IdentifierFactory.access(tsc)(input)("forEach"),
+                undefined,
+                [arrow],
+            );
 
-    export const tuple = (
-        children: ts.ConciseBody[],
-        rest: ts.ConciseBody | null,
-    ): ts.Block => {
-        const entire: ts.ConciseBody[] = [...children];
-        if (rest !== null) entire.push(rest);
+    export const tuple =
+        (tsc: typeof ts) =>
+        (children: ts.ConciseBody[], rest: ts.ConciseBody | null): ts.Block => {
+            const entire: ts.ConciseBody[] = [...children];
+            if (rest !== null) entire.push(rest);
 
-        const statements: ts.Statement[] = ArrayUtil.flat(
-            entire.map((elem) =>
-                ts.isBlock(elem)
-                    ? [...elem.statements]
-                    : [ts.factory.createExpressionStatement(elem)],
-            ),
-        );
-        return ts.factory.createBlock(statements, true);
-    };
+            const statements: ts.Statement[] = ArrayUtil.flat(
+                entire.map((elem) =>
+                    tsc.isBlock(elem)
+                        ? [...elem.statements]
+                        : [tsc.factory.createExpressionStatement(elem)],
+                ),
+            );
+            return tsc.factory.createBlock(statements, true);
+        };
 }
 
 const iterate_dynamic_properties =
+    (tsc: typeof ts) =>
     (props: { regular: IExpressionEntry[]; dynamic: IExpressionEntry[] }) =>
     (input: ts.Expression) =>
-        ts.factory.createCallExpression(
-            IdentifierFactory.join(
-                ts.factory.createCallExpression(
-                    ts.factory.createIdentifier("Object.entries"),
+        tsc.factory.createCallExpression(
+            IdentifierFactory.access(tsc)(
+                tsc.factory.createCallExpression(
+                    tsc.factory.createIdentifier("Object.entries"),
                     undefined,
                     [input],
                 ),
-                "forEach",
-            ),
+            )("forEach"),
             undefined,
             [
-                ts.factory.createArrowFunction(
+                tsc.factory.createArrowFunction(
                     undefined,
                     undefined,
                     [
-                        IdentifierFactory.parameter(
-                            ts.factory.createArrayBindingPattern(
+                        IdentifierFactory.parameter(tsc)(
+                            tsc.factory.createArrayBindingPattern(
                                 ["key", "value"].map((l) =>
-                                    ts.factory.createBindingElement(
+                                    tsc.factory.createBindingElement(
                                         undefined,
                                         undefined,
-                                        ts.factory.createIdentifier(l),
+                                        tsc.factory.createIdentifier(l),
                                         undefined,
                                     ),
                                 ),
@@ -96,41 +108,41 @@ const iterate_dynamic_properties =
                     ],
                     undefined,
                     undefined,
-                    ts.factory.createBlock(
+                    tsc.factory.createBlock(
                         [
-                            ts.factory.createIfStatement(
-                                ts.factory.createStrictEquality(
-                                    ts.factory.createIdentifier("undefined"),
-                                    ts.factory.createIdentifier("value"),
+                            tsc.factory.createIfStatement(
+                                tsc.factory.createStrictEquality(
+                                    tsc.factory.createIdentifier("undefined"),
+                                    tsc.factory.createIdentifier("value"),
                                 ),
-                                ts.factory.createReturnStatement(),
+                                tsc.factory.createReturnStatement(),
                             ),
                             ...props.regular.map(({ key }) =>
-                                ts.factory.createIfStatement(
-                                    ts.factory.createStrictEquality(
-                                        ts.factory.createStringLiteral(
+                                tsc.factory.createIfStatement(
+                                    tsc.factory.createStrictEquality(
+                                        tsc.factory.createStringLiteral(
                                             key.getSoleLiteral()!,
                                         ),
-                                        ts.factory.createIdentifier("key"),
+                                        tsc.factory.createIdentifier("key"),
                                     ),
-                                    ts.factory.createReturnStatement(),
+                                    tsc.factory.createReturnStatement(),
                                 ),
                             ),
                             ...props.dynamic.map((dynamic) =>
-                                ts.factory.createIfStatement(
-                                    ts.factory.createCallExpression(
-                                        ts.factory.createIdentifier(
+                                tsc.factory.createIfStatement(
+                                    tsc.factory.createCallExpression(
+                                        tsc.factory.createIdentifier(
                                             `RegExp(/${metadata_to_pattern(
                                                 true,
                                             )(dynamic.key)}/).test`,
                                         ),
                                         undefined,
-                                        [ts.factory.createIdentifier("key")],
+                                        [tsc.factory.createIdentifier("key")],
                                     ),
-                                    ts.isBlock(dynamic.expression)
+                                    tsc.isBlock(dynamic.expression)
                                         ? dynamic.expression
-                                        : ts.factory.createBlock([
-                                              ts.factory.createExpressionStatement(
+                                        : tsc.factory.createBlock([
+                                              tsc.factory.createExpressionStatement(
                                                   dynamic.expression,
                                               ),
                                           ]),