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

package/src/programmers/internal/check_template.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
 import { IMetadataTag } from "../../metadata/IMetadataTag";
@@ -14,6 +14,7 @@ import { template_to_pattern } from "./template_to_pattern";
  * @internal
  */
 export const check_template =
+    (tsc: typeof ts) =>
     (importer: FunctionImporter) =>
     (metaTags: IMetadataTag[]) =>
     (jsDocTags: IJsDocTagInfo[]) =>
@@ -21,16 +22,16 @@ export const check_template =
     (input: ts.Expression): ICheckEntry => {
         // TYPEOF STRING & TAGS
         const conditions: ts.Expression[] = [
-            ts.factory.createStrictEquality(
-                ts.factory.createStringLiteral("string"),
-                ts.factory.createTypeOfExpression(input),
+            tsc.factory.createStrictEquality(
+                tsc.factory.createStringLiteral("string"),
+                tsc.factory.createTypeOfExpression(input),
             ),
         ];
 
         // TEMPLATES
         const internal: ts.Expression[] = templates.map((tpl) =>
-            ts.factory.createCallExpression(
-                ts.factory.createIdentifier(
+            tsc.factory.createCallExpression(
+                tsc.factory.createIdentifier(
                     `RegExp(/${template_to_pattern(true)(tpl)}/).test`,
                 ),
                 undefined,
@@ -40,17 +41,17 @@ export const check_template =
         conditions.push(
             internal.length === 1
                 ? internal[0]!
-                : internal.reduce((x, y) => ts.factory.createLogicalOr(x, y)),
+                : internal.reduce((x, y) => tsc.factory.createLogicalOr(x, y)),
         );
 
         // COMBINATION
         return {
             expression: conditions.reduce((x, y) =>
-                ts.factory.createLogicalAnd(x, y),
+                tsc.factory.createLogicalAnd(x, y),
             ),
             tags: [
-                ...check_string_tags(importer)(metaTags)(input),
-                ...check_custom("string")(importer)(jsDocTags)(input),
+                ...check_string_tags(tsc)(importer)(metaTags)(input),
+                ...check_custom(tsc)("string")(importer)(jsDocTags)(input),
             ],
         };
     };

package/src/programmers/internal/check_union_array_like.ts

@@ -1,4 +1,5 @@
-import ts from "typescript";
+import { JSDocTagInfo } from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
@@ -14,6 +15,7 @@ import { UnionExplorer } from "../helpers/UnionExplorer";
  * @internal
  */
 export const check_union_array_like =
+    (tsc: typeof ts) =>
     <T>(accessor: check_union_array_like.IAccessor<T>) =>
     (props: check_union_array_like.IProps<T>) =>
     (
@@ -21,7 +23,7 @@ export const check_union_array_like =
         targets: T[],
         explore: FeatureProgrammer.IExplore,
         tags: IMetadataTag[],
-        jsDocTags: ts.JSDocTagInfo[],
+        jsDocTags: JSDocTagInfo[],
     ) => {
         // ONLY ONE TYPE
         if (targets.length === 1)
@@ -38,24 +40,24 @@ export const check_union_array_like =
         //----
         // TUPLES
         const tupleListVariable: ts.VariableStatement =
-            StatementFactory.constant(
+            StatementFactory.constant(tsc)(
                 "tupleList",
-                ts.factory.createArrayLiteralExpression(
+                tsc.factory.createArrayLiteralExpression(
                     targets.map((meta) =>
-                        ts.factory.createArrayLiteralExpression([
-                            ts.factory.createArrowFunction(
+                        tsc.factory.createArrayLiteralExpression([
+                            tsc.factory.createArrowFunction(
                                 undefined,
                                 undefined,
                                 [
-                                    IdentifierFactory.parameter(
+                                    IdentifierFactory.parameter(tsc)(
                                         "top",
-                                        TypeFactory.keyword("any"),
+                                        TypeFactory.keyword(tsc)("any"),
                                     ),
                                 ],
                                 undefined,
                                 undefined,
                                 props.checker(
-                                    ts.factory.createIdentifier("top"),
+                                    tsc.factory.createIdentifier("top"),
                                     meta,
                                     {
                                         ...explore,
@@ -67,19 +69,19 @@ export const check_union_array_like =
                                     input,
                                 ),
                             ),
-                            ts.factory.createArrowFunction(
+                            tsc.factory.createArrowFunction(
                                 undefined,
                                 undefined,
                                 [
-                                    IdentifierFactory.parameter(
+                                    IdentifierFactory.parameter(tsc)(
                                         "top",
-                                        TypeFactory.keyword("any"),
+                                        TypeFactory.keyword(tsc)("any"),
                                     ),
                                 ],
                                 undefined,
                                 undefined,
                                 props.decoder(
-                                    ts.factory.createIdentifier("top"),
+                                    tsc.factory.createIdentifier("top"),
                                     meta,
                                     {
                                         ...explore,
@@ -95,24 +97,24 @@ export const check_union_array_like =
             );
 
         // FILTERED TUPLES
-        const filteredVariable = StatementFactory.constant(
+        const filteredVariable = StatementFactory.constant(tsc)(
             "filtered",
-            ts.factory.createCallExpression(
-                ts.factory.createIdentifier("tupleList.filter"),
+            tsc.factory.createCallExpression(
+                tsc.factory.createIdentifier("tupleList.filter"),
                 undefined,
                 [
-                    ts.factory.createArrowFunction(
+                    tsc.factory.createArrowFunction(
                         undefined,
                         undefined,
-                        [IdentifierFactory.parameter("tuple")],
+                        [IdentifierFactory.parameter(tsc)("tuple")],
                         undefined,
                         undefined,
-                        ts.factory.createStrictEquality(
+                        tsc.factory.createStrictEquality(
                             props.success,
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("tuple[0]"),
+                            tsc.factory.createCallExpression(
+                                tsc.factory.createIdentifier("tuple[0]"),
                                 undefined,
-                                [ts.factory.createIdentifier("front")],
+                                [tsc.factory.createIdentifier("front")],
                             ),
                         ),
                     ),
@@ -124,14 +126,14 @@ export const check_union_array_like =
         // STATEMENTS
         //----
         // ONLY ONE TYPE
-        const uniqueStatement = ts.factory.createIfStatement(
-            ts.factory.createStrictEquality(
-                ts.factory.createNumericLiteral(1),
-                ts.factory.createIdentifier("filtered.length"),
+        const uniqueStatement = tsc.factory.createIfStatement(
+            tsc.factory.createStrictEquality(
+                tsc.factory.createNumericLiteral(1),
+                tsc.factory.createIdentifier("filtered.length"),
             ),
-            ts.factory.createReturnStatement(
-                ts.factory.createCallExpression(
-                    ts.factory.createIdentifier(`filtered[0][1]`),
+            tsc.factory.createReturnStatement(
+                tsc.factory.createCallExpression(
+                    tsc.factory.createIdentifier(`filtered[0][1]`),
                     undefined,
                     [accessor.array(input)],
                 ),
@@ -139,56 +141,56 @@ export const check_union_array_like =
         );
 
         // UNION TYPE
-        const forOfStatement = ts.factory.createForOfStatement(
+        const forOfStatement = tsc.factory.createForOfStatement(
             undefined,
-            ts.factory.createVariableDeclarationList(
-                [ts.factory.createVariableDeclaration("tuple")],
-                ts.NodeFlags.Const,
+            tsc.factory.createVariableDeclarationList(
+                [tsc.factory.createVariableDeclaration("tuple")],
+                tsc.NodeFlags.Const,
             ),
             // StatementFactory.variable(ts.NodeFlags.Const, "tuple"),
-            ts.factory.createIdentifier("filtered"),
-            ts.factory.createIfStatement(
-                ts.factory.createCallExpression(
-                    IdentifierFactory.access(
-                        ts.factory.createIdentifier("array"),
+            tsc.factory.createIdentifier("filtered"),
+            tsc.factory.createIfStatement(
+                tsc.factory.createCallExpression(
+                    IdentifierFactory.access(tsc)(
+                        tsc.factory.createIdentifier("array"),
                     )("every"),
                     undefined,
                     [
-                        ts.factory.createArrowFunction(
+                        tsc.factory.createArrowFunction(
                             undefined,
                             undefined,
                             [
-                                IdentifierFactory.parameter(
+                                IdentifierFactory.parameter(tsc)(
                                     "value",
-                                    TypeFactory.keyword("any"),
+                                    TypeFactory.keyword(tsc)("any"),
                                 ),
                             ],
                             undefined,
                             undefined,
-                            ts.factory.createStrictEquality(
+                            tsc.factory.createStrictEquality(
                                 props.success,
-                                ts.factory.createCallExpression(
-                                    ts.factory.createIdentifier("tuple[0]"),
+                                tsc.factory.createCallExpression(
+                                    tsc.factory.createIdentifier("tuple[0]"),
                                     undefined,
-                                    [ts.factory.createIdentifier("value")],
+                                    [tsc.factory.createIdentifier("value")],
                                 ),
                             ),
                         ),
                     ],
                 ),
-                ts.factory.createReturnStatement(
-                    ts.factory.createCallExpression(
-                        ts.factory.createIdentifier(`tuple[1]`),
+                tsc.factory.createReturnStatement(
+                    tsc.factory.createCallExpression(
+                        tsc.factory.createIdentifier(`tuple[1]`),
                         undefined,
-                        [ts.factory.createIdentifier("array")],
+                        [tsc.factory.createIdentifier("array")],
                     ),
                 ),
             ),
         );
-        const unionStatement = ts.factory.createIfStatement(
-            ts.factory.createLessThan(
-                ts.factory.createNumericLiteral(1),
-                ts.factory.createIdentifier("filtered.length"),
+        const unionStatement = tsc.factory.createIfStatement(
+            tsc.factory.createLessThan(
+                tsc.factory.createNumericLiteral(1),
+                tsc.factory.createIdentifier("filtered.length"),
             ),
             forOfStatement,
         );
@@ -197,26 +199,26 @@ export const check_union_array_like =
             // ARRAY.LENGTH := 0
             ...(accessor.size !== null
                 ? [
-                      ts.factory.createIfStatement(
-                          ts.factory.createStrictEquality(
-                              ts.factory.createNumericLiteral(0),
+                      tsc.factory.createIfStatement(
+                          tsc.factory.createStrictEquality(
+                              tsc.factory.createNumericLiteral(0),
                               accessor.size(input),
                           ),
-                          ts.isReturnStatement(props.empty)
+                          tsc.isReturnStatement(props.empty)
                               ? props.empty
-                              : ts.factory.createReturnStatement(props.empty),
+                              : tsc.factory.createReturnStatement(props.empty),
                       ),
                   ]
                 : []),
 
             // UNION PREDICATORS
             tupleListVariable,
-            StatementFactory.constant("front", accessor.front(input)),
+            StatementFactory.constant(tsc)("front", accessor.front(input)),
             filteredVariable,
             uniqueStatement,
 
             // CONDITIONAL STATEMENTS
-            StatementFactory.constant("array", accessor.array(input)),
+            StatementFactory.constant(tsc)("array", accessor.array(input)),
             unionStatement,
             props.failure(
                 input,
@@ -225,14 +227,14 @@ export const check_union_array_like =
             ),
         ];
 
-        return ts.factory.createCallExpression(
-            ts.factory.createArrowFunction(
+        return tsc.factory.createCallExpression(
+            tsc.factory.createArrowFunction(
                 undefined,
                 undefined,
                 [],
                 undefined,
                 undefined,
-                ts.factory.createBlock(block, true),
+                tsc.factory.createBlock(block, true),
             ),
             undefined,
             undefined,
@@ -249,7 +251,7 @@ export namespace check_union_array_like {
             target: T,
             explore: FeatureProgrammer.IExplore,
             tags: IMetadataTag[],
-            jsDocTags: ts.JSDocTagInfo[],
+            jsDocTags: JSDocTagInfo[],
             array: ts.Expression,
         ): ts.Expression;
         decoder: UnionExplorer.Decoder<T>;

package/src/programmers/internal/check_union_tuple.ts

@@ -1,4 +1,5 @@
-import ts from "typescript";
+import { JSDocTagInfo } from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 import { Metadata } from "../../metadata/Metadata";
@@ -21,7 +22,7 @@ export const check_union_tuple =
         elements: Metadata[],
         explore: CheckerProgrammer.IExplore,
         tags: IMetadataTag[],
-        jsDocTags: ts.JSDocTagInfo[],
+        jsDocTags: JSDocTagInfo[],
         array: ts.Expression,
     ) =>
         CheckerProgrammer.decode_tuple(project)(config)(importer)(true)(

package/src/programmers/internal/decode_union_object.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { MetadataObject } from "../../metadata/MetadataObject";
 
@@ -8,6 +8,7 @@ import { FeatureProgrammer } from "../FeatureProgrammer";
  * @internal
  */
 export const decode_union_object =
+    (tsc: typeof ts) =>
     (
         checker: (
             input: ts.Expression,
@@ -29,14 +30,14 @@ export const decode_union_object =
         targets: MetadataObject[],
         explore: FeatureProgrammer.IExplore,
     ): ts.CallExpression =>
-        ts.factory.createCallExpression(
-            ts.factory.createArrowFunction(
+        tsc.factory.createCallExpression(
+            tsc.factory.createArrowFunction(
                 undefined,
                 undefined,
                 [],
                 undefined,
                 undefined,
-                iterate(escaper)(
+                iterate(tsc)(escaper)(
                     input,
                     targets.map((obj) => ({
                         type: "object",
@@ -51,14 +52,15 @@ export const decode_union_object =
         );
 
 const iterate =
+    (tsc: typeof ts) =>
     (escaper: (value: ts.Expression, expected: string) => ts.Statement) =>
     (input: ts.Expression, unions: IUnion[], expected: string) =>
-        ts.factory.createBlock(
+        tsc.factory.createBlock(
             [
                 ...unions.map((u) =>
-                    ts.factory.createIfStatement(
+                    tsc.factory.createIfStatement(
                         u.is(),
-                        ts.factory.createReturnStatement(u.value()),
+                        tsc.factory.createReturnStatement(u.value()),
                     ),
                 ),
                 escaper(input, expected),

package/src/programmers/internal/feature_object_entries.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 
@@ -13,6 +13,7 @@ import { FunctionImporter } from "../helpers/FunctionImporeter";
  * @internal
  */
 export const feature_object_entries =
+    (tsc: typeof ts) =>
     <Output extends ts.ConciseBody>(
         config: Pick<
             FeatureProgrammer.IConfig<Output>,
@@ -26,15 +27,15 @@ export const feature_object_entries =
             const sole: string | null = prop.key.getSoleLiteral();
             const propInput =
                 sole === null
-                    ? ts.factory.createIdentifier("value")
+                    ? tsc.factory.createIdentifier("value")
                     : Escaper.variable(sole)
-                    ? ts.factory.createPropertyAccessExpression(
+                    ? tsc.factory.createPropertyAccessExpression(
                           input,
-                          ts.factory.createIdentifier(sole),
+                          tsc.factory.createIdentifier(sole),
                       )
-                    : ts.factory.createElementAccessExpression(
+                    : tsc.factory.createElementAccessExpression(
                           input,
-                          ts.factory.createStringLiteral(sole),
+                          tsc.factory.createStringLiteral(sole),
                       );
 
             return {

package/src/programmers/internal/prune_object_properties.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { StatementFactory } from "../../factories/StatementFactory";
 
@@ -9,52 +9,55 @@ import { metadata_to_pattern } from "./metadata_to_pattern";
 /**
  * @internal
  */
-export const prune_object_properties = (obj: MetadataObject) => {
-    const input: ts.Expression = ts.factory.createIdentifier("input");
-    const key: ts.Expression = ts.factory.createIdentifier("key");
+export const prune_object_properties =
+    (tsc: typeof ts) => (obj: MetadataObject) => {
+        const input: ts.Expression = tsc.factory.createIdentifier("input");
+        const key: ts.Expression = tsc.factory.createIdentifier("key");
 
-    const condition: ts.Expression[] = obj.properties.map((prop) => {
-        const name: string | null = prop.key.getSoleLiteral();
-        if (name !== null)
-            return ts.factory.createStrictEquality(
-                ts.factory.createStringLiteral(name),
-                ts.factory.createIdentifier("key"),
+        const condition: ts.Expression[] = obj.properties.map((prop) => {
+            const name: string | null = prop.key.getSoleLiteral();
+            if (name !== null)
+                return tsc.factory.createStrictEquality(
+                    tsc.factory.createStringLiteral(name),
+                    tsc.factory.createIdentifier("key"),
+                );
+            return tsc.factory.createCallExpression(
+                tsc.factory.createIdentifier(
+                    `RegExp(/${metadata_to_pattern(true)(prop.key)}/).test`,
+                ),
+                undefined,
+                [key],
             );
-        return ts.factory.createCallExpression(
-            ts.factory.createIdentifier(
-                `RegExp(/${metadata_to_pattern(true)(prop.key)}/).test`,
-            ),
-            undefined,
-            [key],
-        );
-    });
+        });
 
-    const statements: ts.Statement[] = [];
-    if (condition.length)
+        const statements: ts.Statement[] = [];
+        if (condition.length)
+            statements.push(
+                tsc.factory.createIfStatement(
+                    condition.reduce((a, b) =>
+                        tsc.factory.createLogicalOr(a, b),
+                    ),
+                    tsc.factory.createContinueStatement(),
+                ),
+            );
         statements.push(
-            ts.factory.createIfStatement(
-                condition.reduce((a, b) => ts.factory.createLogicalOr(a, b)),
-                ts.factory.createContinueStatement(),
+            tsc.factory.createExpressionStatement(
+                tsc.factory.createDeleteExpression(
+                    tsc.factory.createElementAccessExpression(input, key),
+                ),
             ),
         );
-    statements.push(
-        ts.factory.createExpressionStatement(
-            ts.factory.createDeleteExpression(
-                ts.factory.createElementAccessExpression(input, key),
-            ),
-        ),
-    );
 
-    return ts.factory.createForOfStatement(
-        undefined,
-        StatementFactory.constant("key").declarationList,
-        ts.factory.createCallExpression(
-            ts.factory.createIdentifier("Object.keys"),
+        return tsc.factory.createForOfStatement(
             undefined,
-            [input],
-        ),
-        statements.length === 1
-            ? statements[0]!
-            : ts.factory.createBlock(statements, true),
-    );
-};
+            StatementFactory.constant(tsc)("key").declarationList,
+            tsc.factory.createCallExpression(
+                tsc.factory.createIdentifier("Object.keys"),
+                undefined,
+                [input],
+            ),
+            statements.length === 1
+                ? statements[0]!
+                : tsc.factory.createBlock(statements, true),
+        );
+    };

package/src/programmers/internal/random_custom.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { LiteralFactory } from "../../factories/LiteralFactory";
@@ -11,19 +11,20 @@ import { Customizable } from "../../typings/Customizable";
  * @internal
  */
 export const random_custom =
+    (tsc: typeof ts) =>
     (accessor: (name: string) => ts.Expression) =>
     (type: keyof Customizable) =>
     (comments: ICommentTag[]) =>
     (expression: ts.Expression) =>
-        ExpressionFactory.coalesce(
-            ts.factory.createCallChain(
-                ts.factory.createPropertyAccessChain(
+        ExpressionFactory.coalesce(tsc)(
+            tsc.factory.createCallChain(
+                tsc.factory.createPropertyAccessChain(
                     accessor("customs"),
-                    ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
-                    ts.factory.createIdentifier(type),
+                    tsc.factory.createToken(tsc.SyntaxKind.QuestionDotToken),
+                    tsc.factory.createIdentifier(type),
                 ),
-                ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+                tsc.factory.createToken(tsc.SyntaxKind.QuestionDotToken),
                 undefined,
-                [LiteralFactory.generate(comments)],
+                [LiteralFactory.generate(tsc)(comments)],
             ),
         )(expression);