typia 4.0.0-dev.20230520 → 4.0.0-dev.20230603

package/src/programmers/internal/check_everything.ts

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

package/src/programmers/internal/check_native.ts

@@ -1,22 +1,21 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 
 /**
  * @internal
  */
-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;
-    };
+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;
+};
 
 const ATOMIC_LIKE = new Set(["Boolean", "Number", "String"]);

package/src/programmers/internal/check_number.ts

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

package/src/programmers/internal/check_object.ts

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

package/src/programmers/internal/check_string.ts

@@ -1,5 +1,4 @@
-import { JSDocTagInfo } from "typescript";
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
@@ -11,17 +10,16 @@ import { check_string_tags } from "./check_string_tags";
  * @internal
  */
 export const check_string =
-    (tsc: typeof ts) =>
     (importer: FunctionImporter) =>
     (metaTags: IMetadataTag[]) =>
-    (jsDocTags: JSDocTagInfo[]) =>
+    (jsDocTags: ts.JSDocTagInfo[]) =>
     (input: ts.Expression) => ({
-        expression: tsc.factory.createStrictEquality(
-            tsc.factory.createStringLiteral("string"),
-            tsc.factory.createTypeOfExpression(input),
+        expression: ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral("string"),
+            ts.factory.createTypeOfExpression(input),
         ),
         tags: [
-            ...check_string_tags(tsc)(importer)(metaTags)(input),
-            ...check_custom(tsc)("string")(importer)(jsDocTags)(input),
+            ...check_string_tags(importer)(metaTags)(input),
+            ...check_custom("string")(importer)(jsDocTags)(input),
         ],
     });

package/src/programmers/internal/check_string_tags.ts

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

package/src/programmers/internal/check_template.ts

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