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

package/src/programmers/internal/check_dynamic_properties.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";
@@ -13,6 +13,7 @@ import { metadata_to_pattern } from "./metadata_to_pattern";
  * @internal
  */
 export const check_dynamic_properties =
+    (tsc: typeof ts) =>
     (props: check_object.IProps) =>
     (importer: FunctionImporter) =>
     (
@@ -20,9 +21,9 @@ export const check_dynamic_properties =
         regular: IExpressionEntry<ts.Expression>[],
         dynamic: IExpressionEntry<ts.Expression>[],
     ): ts.Expression => {
-        const length = IdentifierFactory.access(
-            ts.factory.createCallExpression(
-                ts.factory.createIdentifier("Object.keys"),
+        const length = IdentifierFactory.access(tsc)(
+            tsc.factory.createCallExpression(
+                tsc.factory.createIdentifier("Object.keys"),
                 undefined,
                 [input],
             ),
@@ -31,21 +32,21 @@ export const check_dynamic_properties =
             props.equals === true && dynamic.length === 0
                 ? props.undefined === true ||
                   regular.every((r) => r.meta.required)
-                    ? ts.factory.createStrictEquality(
-                          ts.factory.createNumericLiteral(
+                    ? tsc.factory.createStrictEquality(
+                          tsc.factory.createNumericLiteral(
                               regular.filter((r) => r.meta.required).length,
                           ),
                           length,
                       )
-                    : ts.factory.createCallExpression(
+                    : tsc.factory.createCallExpression(
                           importer.use("is_between"),
                           [],
                           [
                               length,
-                              ts.factory.createNumericLiteral(
+                              tsc.factory.createNumericLiteral(
                                   regular.filter((r) => r.meta.required).length,
                               ),
-                              ts.factory.createNumericLiteral(regular.length),
+                              tsc.factory.createNumericLiteral(regular.length),
                           ],
                       )
                 : null;
@@ -57,36 +58,37 @@ export const check_dynamic_properties =
             return left;
 
         const criteria = props.entries
-            ? ts.factory.createCallExpression(props.entries, undefined, [
-                  ts.factory.createCallExpression(
-                      ts.factory.createIdentifier("Object.keys"),
+            ? tsc.factory.createCallExpression(props.entries, undefined, [
+                  tsc.factory.createCallExpression(
+                      tsc.factory.createIdentifier("Object.keys"),
                       undefined,
                       [input],
                   ),
-                  check_dynamic_property(props)(input, regular, dynamic),
+                  check_dynamic_property(tsc)(props)(input, regular, dynamic),
               ])
-            : ts.factory.createCallExpression(
-                  IdentifierFactory.access(
-                      ts.factory.createCallExpression(
-                          ts.factory.createIdentifier("Object.keys"),
+            : tsc.factory.createCallExpression(
+                  IdentifierFactory.access(tsc)(
+                      tsc.factory.createCallExpression(
+                          tsc.factory.createIdentifier("Object.keys"),
                           undefined,
                           [input],
                       ),
                   )(props.assert ? "every" : "map"),
                   undefined,
-                  [check_dynamic_property(props)(input, regular, dynamic)],
+                  [check_dynamic_property(tsc)(props)(input, regular, dynamic)],
               );
         const right: ts.Expression = (props.halt || ((elem) => elem))(
-            props.assert ? criteria : check_everything(criteria),
+            props.assert ? criteria : check_everything(tsc)(criteria),
         );
         return left
             ? (props.undefined
-                  ? ts.factory.createLogicalOr
-                  : ts.factory.createLogicalAnd)(left, right)
+                  ? tsc.factory.createLogicalOr
+                  : tsc.factory.createLogicalAnd)(left, right)
             : right;
     };
 
 const check_dynamic_property =
+    (tsc: typeof ts) =>
     (props: check_object.IProps) =>
     (
         input: ts.Expression,
@@ -97,31 +99,31 @@ const check_dynamic_property =
         // IF CONDITIONS
         //----
         // PREPARE ASSETS
-        const key = ts.factory.createIdentifier("key");
-        const value = ts.factory.createIdentifier("value");
+        const key = tsc.factory.createIdentifier("key");
+        const value = tsc.factory.createIdentifier("value");
 
         const statements: ts.Statement[] = [];
         const add = (exp: ts.Expression, output: ts.Expression) =>
             statements.push(
-                ts.factory.createIfStatement(
+                tsc.factory.createIfStatement(
                     exp,
-                    ts.factory.createReturnStatement(output),
+                    tsc.factory.createReturnStatement(output),
                 ),
             );
 
         // GATHER CONDITIONS
         if (props.equals === true && regular.length)
-            add(is_regular_property(regular), props.positive);
+            add(is_regular_property(tsc)(regular), props.positive);
         statements.push(
-            StatementFactory.constant(
+            StatementFactory.constant(tsc)(
                 "value",
-                ts.factory.createElementAccessExpression(input, key),
+                tsc.factory.createElementAccessExpression(input, key),
             ),
         );
         if (props.undefined === true)
             add(
-                ts.factory.createStrictEquality(
-                    ts.factory.createIdentifier("undefined"),
+                tsc.factory.createStrictEquality(
+                    tsc.factory.createIdentifier("undefined"),
                     value,
                 ),
                 props.positive,
@@ -129,8 +131,8 @@ const check_dynamic_property =
 
         for (const entry of dynamic)
             add(
-                ts.factory.createCallExpression(
-                    ts.factory.createIdentifier(
+                tsc.factory.createCallExpression(
+                    tsc.factory.createIdentifier(
                         `RegExp(/${metadata_to_pattern(true)(
                             entry.key,
                         )}/).test`,
@@ -145,10 +147,10 @@ const check_dynamic_property =
         // FUNCTION BODY
         //----
         // CLOSURE BLOCK
-        const block: ts.Block = ts.factory.createBlock(
+        const block: ts.Block = tsc.factory.createBlock(
             [
                 ...statements,
-                ts.factory.createReturnStatement(
+                tsc.factory.createReturnStatement(
                     props.equals === true
                         ? props.superfluous(value)
                         : props.positive,
@@ -158,36 +160,38 @@ const check_dynamic_property =
         );
 
         // RETURNS
-        return ts.factory.createArrowFunction(
+        return tsc.factory.createArrowFunction(
             undefined,
             undefined,
-            [IdentifierFactory.parameter("key")],
+            [IdentifierFactory.parameter(tsc)("key")],
             undefined,
             undefined,
             block,
         );
     };
 
-const is_regular_property = (regular: IExpressionEntry[]) =>
-    ts.factory.createCallExpression(
-        IdentifierFactory.access(
-            ts.factory.createArrayLiteralExpression(
+const is_regular_property = (tsc: typeof ts) => (regular: IExpressionEntry[]) =>
+    tsc.factory.createCallExpression(
+        IdentifierFactory.access(tsc)(
+            tsc.factory.createArrayLiteralExpression(
                 regular.map((entry) =>
-                    ts.factory.createStringLiteral(entry.key.getSoleLiteral()!),
+                    tsc.factory.createStringLiteral(
+                        entry.key.getSoleLiteral()!,
+                    ),
                 ),
             ),
         )("some"),
         undefined,
         [
-            ts.factory.createArrowFunction(
+            tsc.factory.createArrowFunction(
                 undefined,
                 undefined,
-                [IdentifierFactory.parameter("prop")],
+                [IdentifierFactory.parameter(tsc)("prop")],
                 undefined,
                 undefined,
-                ts.factory.createStrictEquality(
-                    ts.factory.createIdentifier("key"),
-                    ts.factory.createIdentifier("prop"),
+                tsc.factory.createStrictEquality(
+                    tsc.factory.createIdentifier("key"),
+                    tsc.factory.createIdentifier("prop"),
                 ),
             ),
         ],

package/src/programmers/internal/check_everything.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
@@ -6,23 +6,23 @@ import { TypeFactory } from "../../factories/TypeFactory";
 /**
  * @internal
  */
-export const check_everything = (array: ts.Expression) =>
-    ts.factory.createCallExpression(
-        IdentifierFactory.access(array)("every"),
+export const check_everything = (tsc: typeof ts) => (array: ts.Expression) =>
+    tsc.factory.createCallExpression(
+        IdentifierFactory.access(tsc)(array)("every"),
         undefined,
         [
-            ts.factory.createArrowFunction(
+            tsc.factory.createArrowFunction(
                 undefined,
                 undefined,
                 [
-                    IdentifierFactory.parameter(
+                    IdentifierFactory.parameter(tsc)(
                         "flag",
-                        TypeFactory.keyword("boolean"),
+                        TypeFactory.keyword(tsc)("boolean"),
                     ),
                 ],
                 undefined,
                 undefined,
-                ts.factory.createIdentifier("flag"),
+                tsc.factory.createIdentifier("flag"),
             ),
         ],
     );

package/src/programmers/internal/check_native.ts

@@ -1,21 +1,22 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 
 /**
  * @internal
  */
-export const check_native = (type: string) => (input: ts.Expression) => {
-    const instanceOf = ExpressionFactory.isInstanceOf(type)(input);
-    return ATOMIC_LIKE.has(type)
-        ? ts.factory.createLogicalOr(
-              ts.factory.createStrictEquality(
-                  ts.factory.createStringLiteral(type.toLowerCase()),
-                  ts.factory.createTypeOfExpression(input),
-              ),
-              instanceOf,
-          )
-        : instanceOf;
-};
+export const check_native =
+    (tsc: typeof ts) => (type: string) => (input: ts.Expression) => {
+        const instanceOf = ExpressionFactory.isInstanceOf(tsc)(type)(input);
+        return ATOMIC_LIKE.has(type)
+            ? tsc.factory.createLogicalOr(
+                  tsc.factory.createStrictEquality(
+                      tsc.factory.createStringLiteral(type.toLowerCase()),
+                      tsc.factory.createTypeOfExpression(input),
+                  ),
+                  instanceOf,
+              )
+            : instanceOf;
+    };
 
 const ATOMIC_LIKE = new Set(["Boolean", "Number", "String"]);

package/src/programmers/internal/check_number.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,7 +14,7 @@ import { check_custom } from "./check_custom";
  * @internal
  */
 export const check_number =
-    (project: IProject, numeric: boolean) =>
+    (p: IProject, numeric: boolean) =>
     (importer: FunctionImporter) =>
     (metaTags: IMetadataTag[]) =>
     (jsDocTag: IJsDocTagInfo[]) =>
@@ -24,9 +24,9 @@ export const check_number =
             if (tag.kind === "type") {
                 entries.push([
                     tag,
-                    ts.factory.createStrictEquality(
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("parseInt"),
+                    p.tsc.factory.createStrictEquality(
+                        p.tsc.factory.createCallExpression(
+                            p.tsc.factory.createIdentifier("parseInt"),
                             undefined,
                             [input],
                         ),
@@ -36,26 +36,26 @@ export const check_number =
                 if (tag.value === "uint")
                     entries.push([
                         tag,
-                        ts.factory.createLessThanEquals(
-                            ts.factory.createNumericLiteral(0),
+                        p.tsc.factory.createLessThanEquals(
+                            p.tsc.factory.createNumericLiteral(0),
                             input,
                         ),
                     ]);
             } else if (tag.kind === "multipleOf")
                 entries.push([
                     tag,
-                    ts.factory.createStrictEquality(
-                        ts.factory.createNumericLiteral(0),
-                        ts.factory.createModulo(
+                    p.tsc.factory.createStrictEquality(
+                        p.tsc.factory.createNumericLiteral(0),
+                        p.tsc.factory.createModulo(
                             input,
-                            ts.factory.createNumericLiteral(tag.value),
+                            p.tsc.factory.createNumericLiteral(tag.value),
                         ),
                     ),
                 ]);
             else if (tag.kind === "step") {
-                const modulo = ts.factory.createModulo(
+                const modulo = p.tsc.factory.createModulo(
                     input,
-                    ts.factory.createNumericLiteral(tag.value),
+                    p.tsc.factory.createNumericLiteral(tag.value),
                 );
                 const minimum =
                     (metaTags.find(
@@ -65,12 +65,12 @@ export const check_number =
                     )?.value as number | undefined) ?? undefined;
                 entries.push([
                     tag,
-                    ts.factory.createStrictEquality(
-                        ts.factory.createNumericLiteral(0),
+                    p.tsc.factory.createStrictEquality(
+                        p.tsc.factory.createNumericLiteral(0),
                         minimum !== undefined
-                            ? ts.factory.createSubtract(
+                            ? p.tsc.factory.createSubtract(
                                   modulo,
-                                  ts.factory.createNumericLiteral(minimum),
+                                  p.tsc.factory.createNumericLiteral(minimum),
                               )
                             : modulo,
                     ),
@@ -78,44 +78,44 @@ export const check_number =
             } else if (tag.kind === "minimum")
                 entries.push([
                     tag,
-                    ts.factory.createLessThanEquals(
-                        ts.factory.createNumericLiteral(tag.value),
+                    p.tsc.factory.createLessThanEquals(
+                        p.tsc.factory.createNumericLiteral(tag.value),
                         input,
                     ),
                 ]);
             else if (tag.kind === "maximum")
                 entries.push([
                     tag,
-                    ts.factory.createGreaterThanEquals(
-                        ts.factory.createNumericLiteral(tag.value),
+                    p.tsc.factory.createGreaterThanEquals(
+                        p.tsc.factory.createNumericLiteral(tag.value),
                         input,
                     ),
                 ]);
             else if (tag.kind === "exclusiveMinimum")
                 entries.push([
                     tag,
-                    ts.factory.createLessThan(
-                        ts.factory.createNumericLiteral(tag.value),
+                    p.tsc.factory.createLessThan(
+                        p.tsc.factory.createNumericLiteral(tag.value),
                         input,
                     ),
                 ]);
             else if (tag.kind === "exclusiveMaximum")
                 entries.push([
                     tag,
-                    ts.factory.createGreaterThan(
-                        ts.factory.createNumericLiteral(tag.value),
+                    p.tsc.factory.createGreaterThan(
+                        p.tsc.factory.createNumericLiteral(tag.value),
                         input,
                     ),
                 ]);
 
         return {
-            expression: is_number(project, numeric)(metaTags)(input),
+            expression: is_number(p, numeric)(metaTags)(input),
             tags: [
                 ...entries.map(([tag, expression]) => ({
                     expected: `number (@${tag.kind} ${tag.value})`,
                     expression,
                 })),
-                ...check_custom("number")(importer)(jsDocTag)(input),
+                ...check_custom(p.tsc)("number")(importer)(jsDocTag)(input),
             ],
         };
     };
@@ -124,14 +124,14 @@ export const check_number =
  * @internal
  */
 const is_number =
-    ({ options }: IProject, numeric: boolean) =>
+    ({ tsc, options }: IProject, numeric: boolean) =>
     (metaTags: IMetadataTag[]) =>
     (input: ts.Expression) => {
         // TYPEOF STATEMENT
         const conditions: ts.Expression[] = [
-            ts.factory.createStrictEquality(
-                ts.factory.createStringLiteral("number"),
-                ts.factory.createTypeOfExpression(input),
+            tsc.factory.createStrictEquality(
+                tsc.factory.createStringLiteral("number"),
+                tsc.factory.createTypeOfExpression(input),
             ),
         ];
 
@@ -153,17 +153,17 @@ const is_number =
         if (numeric === true && finite === false)
             if (OptionPredicator.finite(options))
                 conditions.push(
-                    ts.factory.createCallExpression(
-                        ts.factory.createIdentifier("Number.isFinite"),
+                    tsc.factory.createCallExpression(
+                        tsc.factory.createIdentifier("Number.isFinite"),
                         undefined,
                         [input],
                     ),
                 );
             else if (OptionPredicator.numeric(options))
                 conditions.push(
-                    ts.factory.createLogicalNot(
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("Number.isNaN"),
+                    tsc.factory.createLogicalNot(
+                        tsc.factory.createCallExpression(
+                            tsc.factory.createIdentifier("Number.isNaN"),
                             undefined,
                             [input],
                         ),
@@ -173,5 +173,5 @@ const is_number =
         // COMBINATE
         return conditions.length === 1
             ? conditions[0]!
-            : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+            : conditions.reduce((x, y) => tsc.factory.createLogicalAnd(x, y));
     };

package/src/programmers/internal/check_object.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { FunctionImporter } from "../helpers/FunctionImporeter";
 import { IExpressionEntry } from "../helpers/IExpressionEntry";
@@ -9,6 +9,7 @@ import { check_everything } from "./check_everything";
  * @internal
  */
 export const check_object =
+    (tsc: typeof ts) =>
     (props: check_object.IProps) =>
     (importer: FunctionImporter) =>
     (input: ts.Expression, entries: IExpressionEntry<ts.Expression>[]) => {
@@ -19,13 +20,19 @@ export const check_object =
 
         // REGULAR WITHOUT DYNAMIC PROPERTIES
         if (props.equals === false && dynamic.length === 0)
-            return regular.length === 0 ? props.positive : reduce(props)(flags);
+            return regular.length === 0
+                ? props.positive
+                : reduce(tsc)(props)(flags);
 
         // CHECK DYNAMIC PROPERTIES
         flags.push(
-            check_dynamic_properties(props)(importer)(input, regular, dynamic),
+            check_dynamic_properties(tsc)(props)(importer)(
+                input,
+                regular,
+                dynamic,
+            ),
         );
-        return reduce(props)(flags);
+        return reduce(tsc)(props)(flags);
     };
 
 /**
@@ -47,9 +54,12 @@ export namespace check_object {
 /**
  * @internal
  */
-const reduce = (props: check_object.IProps) => (expressions: ts.Expression[]) =>
-    props.assert
-        ? expressions.reduce(props.reduce)
-        : check_everything(
-              ts.factory.createArrayLiteralExpression(expressions),
-          );
+const reduce =
+    (tsc: typeof ts) =>
+    (props: check_object.IProps) =>
+    (expressions: ts.Expression[]) =>
+        props.assert
+            ? expressions.reduce(props.reduce)
+            : check_everything(tsc)(
+                  tsc.factory.createArrayLiteralExpression(expressions),
+              );

package/src/programmers/internal/check_string.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";
 
@@ -10,16 +11,17 @@ import { check_string_tags } from "./check_string_tags";
  * @internal
  */
 export const check_string =
+    (tsc: typeof ts) =>
     (importer: FunctionImporter) =>
     (metaTags: IMetadataTag[]) =>
-    (jsDocTags: ts.JSDocTagInfo[]) =>
+    (jsDocTags: JSDocTagInfo[]) =>
     (input: ts.Expression) => ({
-        expression: ts.factory.createStrictEquality(
-            ts.factory.createStringLiteral("string"),
-            ts.factory.createTypeOfExpression(input),
+        expression: tsc.factory.createStrictEquality(
+            tsc.factory.createStringLiteral("string"),
+            tsc.factory.createTypeOfExpression(input),
         ),
         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_string_tags.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 
@@ -11,6 +11,7 @@ import { ICheckEntry } from "../helpers/ICheckEntry";
  * @internal
  */
 export const check_string_tags =
+    (tsc: typeof ts) =>
     (importer: FunctionImporter) =>
     (tagList: IMetadataTag[]) =>
     (input: ts.Expression): ICheckEntry.ITag[] => {
@@ -19,7 +20,7 @@ export const check_string_tags =
             if (tag.kind === "format")
                 conditions.push([
                     tag,
-                    ts.factory.createCallExpression(
+                    tsc.factory.createCallExpression(
                         importer.use(`is_${tag.value}`),
                         undefined,
                         [input],
@@ -28,8 +29,8 @@ export const check_string_tags =
             else if (tag.kind === "pattern")
                 conditions.push([
                     tag,
-                    ts.factory.createCallExpression(
-                        ts.factory.createIdentifier(
+                    tsc.factory.createCallExpression(
+                        tsc.factory.createIdentifier(
                             `RegExp(/${tag.value}/).test`,
                         ),
                         undefined,
@@ -39,25 +40,25 @@ export const check_string_tags =
             else if (tag.kind === "length")
                 conditions.push([
                     tag,
-                    ts.factory.createStrictEquality(
-                        ts.factory.createNumericLiteral(tag.value),
-                        IdentifierFactory.access(input)("length"),
+                    tsc.factory.createStrictEquality(
+                        tsc.factory.createNumericLiteral(tag.value),
+                        IdentifierFactory.access(tsc)(input)("length"),
                     ),
                 ]);
             else if (tag.kind === "minLength")
                 conditions.push([
                     tag,
-                    ts.factory.createLessThanEquals(
-                        ts.factory.createNumericLiteral(tag.value),
-                        IdentifierFactory.access(input)("length"),
+                    tsc.factory.createLessThanEquals(
+                        tsc.factory.createNumericLiteral(tag.value),
+                        IdentifierFactory.access(tsc)(input)("length"),
                     ),
                 ]);
             else if (tag.kind === "maxLength")
                 conditions.push([
                     tag,
-                    ts.factory.createGreaterThanEquals(
-                        ts.factory.createNumericLiteral(tag.value),
-                        IdentifierFactory.access(input)("length"),
+                    tsc.factory.createGreaterThanEquals(
+                        tsc.factory.createNumericLiteral(tag.value),
+                        IdentifierFactory.access(tsc)(input)("length"),
                     ),
                 ]);
         return conditions.map(([tag, expression]) => ({