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

package/src/programmers/IsProgrammer.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { ExpressionFactory } from "../factories/ExpressionFactory";
 import { IdentifierFactory } from "../factories/IdentifierFactory";
@@ -12,11 +12,13 @@ import { CheckerProgrammer } from "./CheckerProgrammer";
 import { FunctionImporter } from "./helpers/FunctionImporeter";
 import { IExpressionEntry } from "./helpers/IExpressionEntry";
 import { OptionPredicator } from "./helpers/OptionPredicator";
+import { disable_function_importer_declare } from "./helpers/disable_function_importer_declare";
 import { check_object } from "./internal/check_object";
 import { feature_object_entries } from "./internal/feature_object_entries";
 
 export namespace IsProgrammer {
     export const configure =
+        (tsc: typeof ts) =>
         (options?: Partial<CONFIG.IOptions>) =>
         (importer: FunctionImporter): CheckerProgrammer.IConfig => ({
             functors: "$io",
@@ -31,16 +33,16 @@ export namespace IsProgrammer {
                 [
                     entry.expression,
                     ...entry.tags.map((tag) => tag.expression),
-                ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
+                ].reduce((x, y) => tsc.factory.createLogicalAnd(x, y)),
             combiner: () => (type: "and" | "or") => {
                 const initial: ts.TrueLiteral | ts.FalseLiteral =
                     type === "and"
-                        ? ts.factory.createTrue()
-                        : ts.factory.createFalse();
+                        ? tsc.factory.createTrue()
+                        : tsc.factory.createFalse();
                 const binder =
                     type === "and"
-                        ? ts.factory.createLogicalAnd
-                        : ts.factory.createLogicalOr;
+                        ? tsc.factory.createLogicalAnd
+                        : tsc.factory.createLogicalOr;
                 return (
                     _input: ts.Expression,
                     binaries: CheckerProgrammer.IBinary[],
@@ -54,25 +56,25 @@ export namespace IsProgrammer {
             joiner: {
                 object:
                     options?.object ||
-                    check_object({
+                    check_object(tsc)({
                         equals: !!options?.object,
                         undefined: OptionPredicator.undefined({
                             undefined: options?.undefined,
                         }),
                         assert: true,
-                        reduce: ts.factory.createLogicalAnd,
-                        positive: ts.factory.createTrue(),
-                        superfluous: () => ts.factory.createFalse(),
+                        reduce: tsc.factory.createLogicalAnd,
+                        positive: tsc.factory.createTrue(),
+                        superfluous: () => tsc.factory.createFalse(),
                     })(importer),
                 array: (input, arrow) =>
-                    ts.factory.createCallExpression(
-                        IdentifierFactory.access(input)("every"),
+                    tsc.factory.createCallExpression(
+                        IdentifierFactory.access(tsc)(input)("every"),
                         undefined,
                         [arrow],
                     ),
-                failure: () => ts.factory.createFalse(),
+                failure: () => tsc.factory.createFalse(),
             },
-            success: ts.factory.createTrue(),
+            success: tsc.factory.createTrue(),
         });
 
     export namespace CONFIG {
@@ -102,23 +104,28 @@ export namespace IsProgrammer {
             write(project)(modulo)(equals)(type, name);
 
     export const write =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
+        (p: IProject) =>
+        (modulo: ts.LeftHandSideExpression, disable?: boolean) =>
         (equals: boolean) => {
-            const importer: FunctionImporter = new FunctionImporter();
+            const importer: FunctionImporter =
+                disable === true
+                    ? disable_function_importer_declare(
+                          new FunctionImporter(p.tsc),
+                      )
+                    : new FunctionImporter(p.tsc);
 
             // CONFIGURATION
             const config: CheckerProgrammer.IConfig = {
-                ...configure({
-                    object: check_object({
+                ...configure(p.tsc)({
+                    object: check_object(p.tsc)({
                         equals,
-                        undefined: OptionPredicator.undefined(project.options),
+                        undefined: OptionPredicator.undefined(p.options),
                         assert: true,
-                        reduce: ts.factory.createLogicalAnd,
-                        positive: ts.factory.createTrue(),
-                        superfluous: () => ts.factory.createFalse(),
+                        reduce: p.tsc.factory.createLogicalAnd,
+                        positive: p.tsc.factory.createTrue(),
+                        superfluous: () => p.tsc.factory.createFalse(),
                     })(importer),
-                    numeric: OptionPredicator.numeric(project.options),
+                    numeric: OptionPredicator.numeric(p.options),
                 })(importer),
                 trace: equals,
                 addition: () => importer.declare(modulo),
@@ -136,23 +143,22 @@ export namespace IsProgrammer {
                     if (
                         obj._Is_simple() &&
                         (equals === false ||
-                            OptionPredicator.undefined(project.options) ===
-                                false)
+                            OptionPredicator.undefined(p.options) === false)
                     )
-                        return ts.factory.createLogicalAnd(
-                            ExpressionFactory.isObject({
+                        return p.tsc.factory.createLogicalAnd(
+                            ExpressionFactory.isObject(p.tsc)({
                                 checkNull: true,
                                 checkArray: false,
                             })(input),
                             config.joiner.object(
                                 input,
-                                feature_object_entries(config as any)(importer)(
-                                    obj,
-                                )(input),
+                                feature_object_entries(p.tsc)(config as any)(
+                                    importer,
+                                )(obj)(input),
                             ),
                         );
                 }
-                return CheckerProgrammer.decode(project)(config)(importer)(
+                return CheckerProgrammer.decode(p)(config)(importer)(
                     input,
                     target,
                     explore,
@@ -162,51 +168,56 @@ export namespace IsProgrammer {
             };
 
             // GENERATE CHECKER
-            return CheckerProgrammer.write(project)(config)(importer);
+            return CheckerProgrammer.write(p)(config)(importer);
         };
 
     export const write_functors =
-        (project: IProject) => (importer: FunctionImporter) =>
-            CheckerProgrammer.write_functors(project)(configure()(importer))(
+        (p: IProject) => (importer: FunctionImporter) =>
+            CheckerProgrammer.write_functors(p)(configure(p.tsc)()(importer))(
                 importer,
             );
 
     export const write_unioners =
-        (project: IProject) => (importer: FunctionImporter) =>
+        (p: IProject) => (importer: FunctionImporter) =>
             CheckerProgrammer.write_unioners(
-                project,
-                configure()(importer),
+                p,
+                configure(p.tsc)()(importer),
                 importer,
             );
 
     /* -----------------------------------------------------------
         DECODERS
     ----------------------------------------------------------- */
-    export const decode = (project: IProject, importer: FunctionImporter) =>
-        CheckerProgrammer.decode(project)(configure()(importer))(importer);
+    export const decode = (p: IProject) => (importer: FunctionImporter) =>
+        CheckerProgrammer.decode(p)(configure(p.tsc)()(importer))(importer);
 
-    export const decode_object = (importer: FunctionImporter) =>
-        CheckerProgrammer.decode_object(configure()(importer))(importer);
+    export const decode_object =
+        (tsc: typeof ts) => (importer: FunctionImporter) =>
+            CheckerProgrammer.decode_object(tsc)(configure(tsc)()(importer))(
+                importer,
+            );
 
     export const decode_to_json =
+        (tsc: typeof ts) =>
         (checkNull: boolean) =>
         (input: ts.Expression): ts.Expression =>
-            ts.factory.createLogicalAnd(
-                ExpressionFactory.isObject({
+            tsc.factory.createLogicalAnd(
+                ExpressionFactory.isObject(tsc)({
                     checkArray: false,
                     checkNull,
                 })(input),
-                ts.factory.createStrictEquality(
-                    ts.factory.createStringLiteral("function"),
-                    ValueFactory.TYPEOF(
-                        IdentifierFactory.access(input)("toJSON"),
+                tsc.factory.createStrictEquality(
+                    tsc.factory.createStringLiteral("function"),
+                    ValueFactory.TYPEOF(tsc)(
+                        IdentifierFactory.access(tsc)(input)("toJSON"),
                     ),
                 ),
             );
 
-    export const decode_functional = (input: ts.Expression) =>
-        ts.factory.createStrictEquality(
-            ts.factory.createStringLiteral("function"),
-            ValueFactory.TYPEOF(input),
-        );
+    export const decode_functional =
+        (tsc: typeof ts) => (input: ts.Expression) =>
+            tsc.factory.createStrictEquality(
+                tsc.factory.createStringLiteral("function"),
+                ValueFactory.TYPEOF(tsc)(input),
+            );
 }

package/src/programmers/IsPruneProgrammer.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";
@@ -19,63 +19,65 @@ export namespace IsPruneProgrammer {
             write(project)(modulo)(type, name);
 
     export const write =
-        (project: IProject) =>
+        (p: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
         (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
+            p.tsc.factory.createArrowFunction(
                 undefined,
                 undefined,
                 [
-                    IdentifierFactory.parameter(
+                    IdentifierFactory.parameter(p.tsc)(
                         "input",
-                        TypeFactory.keyword("any"),
+                        TypeFactory.keyword(p.tsc)("any"),
                     ),
                 ],
-                ts.factory.createTypePredicateNode(
+                p.tsc.factory.createTypePredicateNode(
                     undefined,
                     "input",
-                    ts.factory.createTypeReferenceNode(
-                        name ?? TypeFactory.getFullName(project.checker)(type),
+                    p.tsc.factory.createTypeReferenceNode(
+                        name ?? TypeFactory.getFullName(p)(type),
                     ),
                 ),
                 undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
+                p.tsc.factory.createBlock([
+                    StatementFactory.constant(p.tsc)(
                         "is",
-                        IsProgrammer.write(project)(modulo)(false)(type, name),
+                        IsProgrammer.write(p)(modulo)(false)(type, name),
                     ),
-                    StatementFactory.constant(
+                    StatementFactory.constant(p.tsc)(
                         "prune",
                         PruneProgrammer.write({
-                            ...project,
+                            ...p,
                             options: {
-                                ...project.options,
+                                ...p.options,
                                 functional: false,
                                 numeric: false,
                             },
                         })(modulo)(type, name),
                     ),
-                    ts.factory.createIfStatement(
-                        ts.factory.createPrefixUnaryExpression(
-                            ts.SyntaxKind.ExclamationToken,
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("is"),
+                    p.tsc.factory.createIfStatement(
+                        p.tsc.factory.createPrefixUnaryExpression(
+                            p.tsc.SyntaxKind.ExclamationToken,
+                            p.tsc.factory.createCallExpression(
+                                p.tsc.factory.createIdentifier("is"),
                                 undefined,
-                                [ts.factory.createIdentifier("input")],
+                                [p.tsc.factory.createIdentifier("input")],
                             ),
                         ),
-                        ts.factory.createReturnStatement(
-                            ts.factory.createFalse(),
+                        p.tsc.factory.createReturnStatement(
+                            p.tsc.factory.createFalse(),
                         ),
                     ),
-                    ts.factory.createExpressionStatement(
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("prune"),
+                    p.tsc.factory.createExpressionStatement(
+                        p.tsc.factory.createCallExpression(
+                            p.tsc.factory.createIdentifier("prune"),
                             undefined,
-                            [ts.factory.createIdentifier("input")],
+                            [p.tsc.factory.createIdentifier("input")],
                         ),
                     ),
-                    ts.factory.createReturnStatement(ts.factory.createTrue()),
+                    p.tsc.factory.createReturnStatement(
+                        p.tsc.factory.createTrue(),
+                    ),
                 ]),
             );
 }

package/src/programmers/IsStringifyProgrammer.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";
@@ -10,73 +10,66 @@ import { IsProgrammer } from "./IsProgrammer";
 import { StringifyProgrammer } from "./StringifyProgrammer";
 
 export namespace IsStringifyProgrammer {
-    /**
-     * @deprecated Use `write()` function instead
-     */
-    export const generate =
-        (project: IProject, modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            write(project)(modulo)(type, name);
-
     export const write =
-        (project: IProject) =>
+        (p: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
         (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
+            p.tsc.factory.createArrowFunction(
                 undefined,
                 undefined,
                 [
-                    IdentifierFactory.parameter(
+                    IdentifierFactory.parameter(p.tsc)(
                         "input",
-                        ts.factory.createTypeReferenceNode(
-                            name ??
-                                TypeFactory.getFullName(project.checker)(type),
+                        p.tsc.factory.createTypeReferenceNode(
+                            name ?? TypeFactory.getFullName(p)(type),
                         ),
                     ),
                 ],
-                ts.factory.createUnionTypeNode([
-                    TypeFactory.keyword("string"),
-                    ts.factory.createLiteralTypeNode(ts.factory.createNull()),
+                p.tsc.factory.createUnionTypeNode([
+                    TypeFactory.keyword(p.tsc)("string"),
+                    p.tsc.factory.createLiteralTypeNode(
+                        p.tsc.factory.createNull(),
+                    ),
                 ]),
                 undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
+                p.tsc.factory.createBlock([
+                    StatementFactory.constant(p.tsc)(
                         "is",
                         IsProgrammer.write({
-                            ...project,
+                            ...p,
                             options: {
-                                ...project.options,
+                                ...p.options,
                                 functional: false,
                                 numeric: true,
                             },
                         })(modulo)(false)(type, name),
                     ),
-                    StatementFactory.constant(
+                    StatementFactory.constant(p.tsc)(
                         "stringify",
                         StringifyProgrammer.write({
-                            ...project,
+                            ...p,
                             options: {
-                                ...project.options,
+                                ...p.options,
                                 functional: false,
                                 numeric: false,
                             },
                         })(modulo)(type, name),
                     ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createConditionalExpression(
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("is"),
+                    p.tsc.factory.createReturnStatement(
+                        p.tsc.factory.createConditionalExpression(
+                            p.tsc.factory.createCallExpression(
+                                p.tsc.factory.createIdentifier("is"),
                                 undefined,
-                                [ts.factory.createIdentifier("input")],
+                                [p.tsc.factory.createIdentifier("input")],
                             ),
                             undefined,
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("stringify"),
+                            p.tsc.factory.createCallExpression(
+                                p.tsc.factory.createIdentifier("stringify"),
                                 undefined,
-                                [ts.factory.createIdentifier("input")],
+                                [p.tsc.factory.createIdentifier("input")],
                             ),
                             undefined,
-                            ts.factory.createNull(),
+                            p.tsc.factory.createNull(),
                         ),
                     ),
                 ]),

package/src/programmers/LiteralsProgrammer.ts

@@ -1,4 +1,4 @@
-import ts from "typescript";
+import type ts from "typescript/lib/tsclibrary";
 
 import { MetadataCollection } from "../factories/MetadataCollection";
 import { MetadataFactory } from "../factories/MetadataFactory";
@@ -18,8 +18,8 @@ export namespace LiteralsProgrammer {
     export const generate = (project: IProject) => (type: ts.Type) =>
         write(project)(type);
 
-    export const write = (project: IProject) => (type: ts.Type) => {
-        const meta: Metadata = MetadataFactory.analyze(project.checker)({
+    export const write = (p: IProject) => (type: ts.Type) => {
+        const meta: Metadata = MetadataFactory.analyze(p)({
             resolve: true,
             constant: true,
             validate: (meta) => {
@@ -39,22 +39,22 @@ export namespace LiteralsProgrammer {
                 ? [true, false]
                 : []),
         ]);
-        return ts.factory.createAsExpression(
-            ts.factory.createArrayLiteralExpression(
+        return p.tsc.factory.createAsExpression(
+            p.tsc.factory.createArrayLiteralExpression(
                 [...values].map((v) =>
                     typeof v === "boolean"
                         ? v
-                            ? ts.factory.createTrue()
-                            : ts.factory.createFalse()
+                            ? p.tsc.factory.createTrue()
+                            : p.tsc.factory.createFalse()
                         : typeof v === "number"
-                        ? ts.factory.createNumericLiteral(v)
+                        ? p.tsc.factory.createNumericLiteral(v)
                         : typeof v === "bigint"
-                        ? ts.factory.createBigIntLiteral(v.toString())
-                        : ts.factory.createStringLiteral(v),
+                        ? p.tsc.factory.createBigIntLiteral(v.toString())
+                        : p.tsc.factory.createStringLiteral(v),
                 ),
                 true,
             ),
-            ts.factory.createTypeReferenceNode("const"),
+            p.tsc.factory.createTypeReferenceNode("const"),
         );
     };
 }