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

package/src/programmers/IsParseProgrammer.ts

@@ -1,4 +1,4 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { StatementFactory } from "../factories/StatementFactory";
@@ -9,62 +9,70 @@ import { IProject } from "../transformers/IProject";
 import { IsProgrammer } from "./IsProgrammer";
 
 export namespace IsParseProgrammer {
+    /**
+     * @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 =
-        (p: IProject) =>
+        (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
         (type: ts.Type, name?: string) =>
-            p.tsc.factory.createArrowFunction(
+            ts.factory.createArrowFunction(
                 undefined,
                 undefined,
                 [
-                    IdentifierFactory.parameter(p.tsc)(
+                    IdentifierFactory.parameter(
                         "input",
-                        TypeFactory.keyword(p.tsc)("any"),
+                        TypeFactory.keyword("any"),
                     ),
                 ],
-                p.tsc.factory.createTypeReferenceNode(
+                ts.factory.createTypeReferenceNode(
                     `typia.Primitive<${
-                        name ?? TypeFactory.getFullName(p)(type)
+                        name ?? TypeFactory.getFullName(project.checker)(type)
                     }>`,
                 ),
                 undefined,
-                p.tsc.factory.createBlock([
-                    StatementFactory.constant(p.tsc)(
+                ts.factory.createBlock([
+                    StatementFactory.constant(
                         "is",
                         IsProgrammer.write({
-                            ...p,
+                            ...project,
                             options: {
-                                ...p.options,
+                                ...project.options,
                                 functional: false,
                                 numeric: false,
                             },
                         })(modulo)(false)(type, name),
                     ),
-                    p.tsc.factory.createExpressionStatement(
-                        p.tsc.factory.createBinaryExpression(
-                            p.tsc.factory.createIdentifier("input"),
-                            p.tsc.SyntaxKind.EqualsToken,
-                            p.tsc.factory.createCallExpression(
-                                p.tsc.factory.createIdentifier("JSON.parse"),
+                    ts.factory.createExpressionStatement(
+                        ts.factory.createBinaryExpression(
+                            ts.factory.createIdentifier("input"),
+                            ts.SyntaxKind.EqualsToken,
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("JSON.parse"),
                                 undefined,
-                                [p.tsc.factory.createIdentifier("input")],
+                                [ts.factory.createIdentifier("input")],
                             ),
                         ),
                     ),
-                    p.tsc.factory.createReturnStatement(
-                        p.tsc.factory.createConditionalExpression(
-                            p.tsc.factory.createCallExpression(
-                                p.tsc.factory.createIdentifier("is"),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createConditionalExpression(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("is"),
                                 undefined,
-                                [p.tsc.factory.createIdentifier("input")],
+                                [ts.factory.createIdentifier("input")],
                             ),
                             undefined,
-                            p.tsc.factory.createAsExpression(
-                                p.tsc.factory.createIdentifier("input"),
-                                TypeFactory.keyword(p.tsc)("any"),
+                            ts.factory.createAsExpression(
+                                ts.factory.createIdentifier("input"),
+                                TypeFactory.keyword("any"),
                             ),
                             undefined,
-                            p.tsc.factory.createNull(),
+                            ts.factory.createNull(),
                         ),
                     ),
                 ]),

package/src/programmers/IsProgrammer.ts

@@ -1,7 +1,9 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { ExpressionFactory } from "../factories/ExpressionFactory";
 import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { MetadataCollection } from "../factories/MetadataCollection";
+import { TypeFactory } from "../factories/TypeFactory";
 import { ValueFactory } from "../factories/ValueFactory";
 
 import { MetadataObject } from "../metadata/MetadataObject";
@@ -18,11 +20,9 @@ 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",
-            unioners: "$iu",
+            prefix: "$i",
             trace: false,
             path: false,
             equals: !!options?.object,
@@ -33,16 +33,16 @@ export namespace IsProgrammer {
                 [
                     entry.expression,
                     ...entry.tags.map((tag) => tag.expression),
-                ].reduce((x, y) => tsc.factory.createLogicalAnd(x, y)),
+                ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
             combiner: () => (type: "and" | "or") => {
                 const initial: ts.TrueLiteral | ts.FalseLiteral =
                     type === "and"
-                        ? tsc.factory.createTrue()
-                        : tsc.factory.createFalse();
+                        ? ts.factory.createTrue()
+                        : ts.factory.createFalse();
                 const binder =
                     type === "and"
-                        ? tsc.factory.createLogicalAnd
-                        : tsc.factory.createLogicalOr;
+                        ? ts.factory.createLogicalAnd
+                        : ts.factory.createLogicalOr;
                 return (
                     _input: ts.Expression,
                     binaries: CheckerProgrammer.IBinary[],
@@ -56,25 +56,25 @@ export namespace IsProgrammer {
             joiner: {
                 object:
                     options?.object ||
-                    check_object(tsc)({
+                    check_object({
                         equals: !!options?.object,
                         undefined: OptionPredicator.undefined({
                             undefined: options?.undefined,
                         }),
                         assert: true,
-                        reduce: tsc.factory.createLogicalAnd,
-                        positive: tsc.factory.createTrue(),
-                        superfluous: () => tsc.factory.createFalse(),
+                        reduce: ts.factory.createLogicalAnd,
+                        positive: ts.factory.createTrue(),
+                        superfluous: () => ts.factory.createFalse(),
                     })(importer),
                 array: (input, arrow) =>
-                    tsc.factory.createCallExpression(
-                        IdentifierFactory.access(tsc)(input)("every"),
+                    ts.factory.createCallExpression(
+                        IdentifierFactory.access(input)("every"),
                         undefined,
                         [arrow],
                     ),
-                failure: () => tsc.factory.createFalse(),
+                failure: () => ts.factory.createFalse(),
             },
-            success: tsc.factory.createTrue(),
+            success: ts.factory.createTrue(),
         });
 
     export namespace CONFIG {
@@ -104,120 +104,147 @@ export namespace IsProgrammer {
             write(project)(modulo)(equals)(type, name);
 
     export const write =
-        (p: IProject) =>
+        (project: IProject) =>
         (modulo: ts.LeftHandSideExpression, disable?: boolean) =>
         (equals: boolean) => {
             const importer: FunctionImporter =
-                disable === true
-                    ? disable_function_importer_declare(
-                          new FunctionImporter(p.tsc),
-                      )
-                    : new FunctionImporter(p.tsc);
+                disable === <any>{}
+                    ? disable_function_importer_declare(new FunctionImporter())
+                    : new FunctionImporter();
 
             // CONFIGURATION
             const config: CheckerProgrammer.IConfig = {
-                ...configure(p.tsc)({
-                    object: check_object(p.tsc)({
+                ...configure({
+                    object: check_object({
                         equals,
-                        undefined: OptionPredicator.undefined(p.options),
+                        undefined: OptionPredicator.undefined(project.options),
                         assert: true,
-                        reduce: p.tsc.factory.createLogicalAnd,
-                        positive: p.tsc.factory.createTrue(),
-                        superfluous: () => p.tsc.factory.createFalse(),
+                        reduce: ts.factory.createLogicalAnd,
+                        positive: ts.factory.createTrue(),
+                        superfluous: () => ts.factory.createFalse(),
                     })(importer),
-                    numeric: OptionPredicator.numeric(p.options),
+                    numeric: OptionPredicator.numeric(project.options),
                 })(importer),
                 trace: equals,
                 addition: () => importer.declare(modulo),
             };
 
-            config.decoder = (input, target, explore, tags, jsDocTags) => {
-                if (
-                    target.size() === 1 &&
-                    target.objects.length === 1 &&
-                    target.required === true &&
-                    target.nullable === false
-                ) {
-                    // ONLY WHEN OBJECT WITH SOME ATOMIC PROPERTIES
-                    const obj: MetadataObject = target.objects[0]!;
+            config.decoder =
+                () => (input, target, explore, tags, jsDocTags) => {
                     if (
-                        obj._Is_simple() &&
-                        (equals === false ||
-                            OptionPredicator.undefined(p.options) === false)
-                    )
-                        return p.tsc.factory.createLogicalAnd(
-                            ExpressionFactory.isObject(p.tsc)({
-                                checkNull: true,
-                                checkArray: false,
-                            })(input),
-                            config.joiner.object(
-                                input,
-                                feature_object_entries(p.tsc)(config as any)(
-                                    importer,
-                                )(obj)(input),
-                            ),
-                        );
-                }
-                return CheckerProgrammer.decode(p)(config)(importer)(
-                    input,
-                    target,
-                    explore,
-                    tags,
-                    jsDocTags,
-                );
-            };
+                        target.size() === 1 &&
+                        target.objects.length === 1 &&
+                        target.required === true &&
+                        target.nullable === false
+                    ) {
+                        // ONLY WHEN OBJECT WITH SOME ATOMIC PROPERTIES
+                        const obj: MetadataObject = target.objects[0]!;
+                        if (
+                            obj._Is_simple() &&
+                            (equals === false ||
+                                OptionPredicator.undefined(project.options) ===
+                                    false)
+                        )
+                            return ts.factory.createLogicalAnd(
+                                ExpressionFactory.isObject({
+                                    checkNull: true,
+                                    checkArray: false,
+                                })(input),
+                                config.joiner.object(
+                                    ts.factory.createAsExpression(
+                                        input,
+                                        TypeFactory.keyword("any"),
+                                    ),
+                                    feature_object_entries(config as any)(
+                                        importer,
+                                    )(obj)(
+                                        ts.factory.createAsExpression(
+                                            input,
+                                            TypeFactory.keyword("any"),
+                                        ),
+                                    ),
+                                ),
+                            );
+                    }
+                    return CheckerProgrammer.decode(project)(config)(importer)(
+                        input,
+                        target,
+                        explore,
+                        tags,
+                        jsDocTags,
+                    );
+                };
 
             // GENERATE CHECKER
-            return CheckerProgrammer.write(p)(config)(importer);
+            return CheckerProgrammer.write(project)(config)(importer);
         };
 
-    export const write_functors =
-        (p: IProject) => (importer: FunctionImporter) =>
-            CheckerProgrammer.write_functors(p)(configure(p.tsc)()(importer))(
-                importer,
-            );
-
-    export const write_unioners =
-        (p: IProject) => (importer: FunctionImporter) =>
-            CheckerProgrammer.write_unioners(
-                p,
-                configure(p.tsc)()(importer),
-                importer,
-            );
+    export const write_function_statements =
+        (project: IProject) =>
+        (importer: FunctionImporter) =>
+        (collection: MetadataCollection) => {
+            const config = configure()(importer);
+            const objects =
+                CheckerProgrammer.write_object_functions(project)(config)(
+                    importer,
+                )(collection);
+            const unions =
+                CheckerProgrammer.write_union_functions(project)(config)(
+                    importer,
+                )(collection);
+            const arrays =
+                CheckerProgrammer.write_array_functions(project)(config)(
+                    importer,
+                )(collection);
+            const tuples =
+                CheckerProgrammer.write_tuple_functions(project)(config)(
+                    importer,
+                )(collection);
+
+            return [
+                ...objects.filter((_, i) =>
+                    importer.hasLocal(`${config.prefix}o${i}`),
+                ),
+                ...unions.filter((_, i) =>
+                    importer.hasLocal(`${config.prefix}u${i}`),
+                ),
+                ...arrays.filter((_, i) =>
+                    importer.hasLocal(`${config.prefix}a${i}`),
+                ),
+                ...tuples.filter((_, i) =>
+                    importer.hasLocal(`${config.prefix}t${i}`),
+                ),
+            ];
+        };
 
     /* -----------------------------------------------------------
         DECODERS
     ----------------------------------------------------------- */
-    export const decode = (p: IProject) => (importer: FunctionImporter) =>
-        CheckerProgrammer.decode(p)(configure(p.tsc)()(importer))(importer);
+    export const decode = (project: IProject) => (importer: FunctionImporter) =>
+        CheckerProgrammer.decode(project)(configure()(importer))(importer);
 
-    export const decode_object =
-        (tsc: typeof ts) => (importer: FunctionImporter) =>
-            CheckerProgrammer.decode_object(tsc)(configure(tsc)()(importer))(
-                importer,
-            );
+    export const decode_object = (importer: FunctionImporter) =>
+        CheckerProgrammer.decode_object(configure()(importer))(importer);
 
     export const decode_to_json =
-        (tsc: typeof ts) =>
         (checkNull: boolean) =>
         (input: ts.Expression): ts.Expression =>
-            tsc.factory.createLogicalAnd(
-                ExpressionFactory.isObject(tsc)({
+            ts.factory.createLogicalAnd(
+                ExpressionFactory.isObject({
                     checkArray: false,
                     checkNull,
                 })(input),
-                tsc.factory.createStrictEquality(
-                    tsc.factory.createStringLiteral("function"),
-                    ValueFactory.TYPEOF(tsc)(
-                        IdentifierFactory.access(tsc)(input)("toJSON"),
+                ts.factory.createStrictEquality(
+                    ts.factory.createStringLiteral("function"),
+                    ValueFactory.TYPEOF(
+                        IdentifierFactory.access(input)("toJSON"),
                     ),
                 ),
             );
 
-    export const decode_functional =
-        (tsc: typeof ts) => (input: ts.Expression) =>
-            tsc.factory.createStrictEquality(
-                tsc.factory.createStringLiteral("function"),
-                ValueFactory.TYPEOF(tsc)(input),
-            );
+    export const decode_functional = (input: ts.Expression) =>
+        ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral("function"),
+            ValueFactory.TYPEOF(input),
+        );
 }

package/src/programmers/IsPruneProgrammer.ts

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

package/src/programmers/IsStringifyProgrammer.ts

@@ -1,4 +1,4 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { StatementFactory } from "../factories/StatementFactory";
@@ -10,66 +10,73 @@ 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 =
-        (p: IProject) =>
+        (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
         (type: ts.Type, name?: string) =>
-            p.tsc.factory.createArrowFunction(
+            ts.factory.createArrowFunction(
                 undefined,
                 undefined,
                 [
-                    IdentifierFactory.parameter(p.tsc)(
+                    IdentifierFactory.parameter(
                         "input",
-                        p.tsc.factory.createTypeReferenceNode(
-                            name ?? TypeFactory.getFullName(p)(type),
+                        ts.factory.createTypeReferenceNode(
+                            name ??
+                                TypeFactory.getFullName(project.checker)(type),
                         ),
                     ),
                 ],
-                p.tsc.factory.createUnionTypeNode([
-                    TypeFactory.keyword(p.tsc)("string"),
-                    p.tsc.factory.createLiteralTypeNode(
-                        p.tsc.factory.createNull(),
-                    ),
+                ts.factory.createUnionTypeNode([
+                    TypeFactory.keyword("string"),
+                    ts.factory.createLiteralTypeNode(ts.factory.createNull()),
                 ]),
                 undefined,
-                p.tsc.factory.createBlock([
-                    StatementFactory.constant(p.tsc)(
+                ts.factory.createBlock([
+                    StatementFactory.constant(
                         "is",
                         IsProgrammer.write({
-                            ...p,
+                            ...project,
                             options: {
-                                ...p.options,
+                                ...project.options,
                                 functional: false,
                                 numeric: true,
                             },
                         })(modulo)(false)(type, name),
                     ),
-                    StatementFactory.constant(p.tsc)(
+                    StatementFactory.constant(
                         "stringify",
                         StringifyProgrammer.write({
-                            ...p,
+                            ...project,
                             options: {
-                                ...p.options,
+                                ...project.options,
                                 functional: false,
                                 numeric: false,
                             },
                         })(modulo)(type, name),
                     ),
-                    p.tsc.factory.createReturnStatement(
-                        p.tsc.factory.createConditionalExpression(
-                            p.tsc.factory.createCallExpression(
-                                p.tsc.factory.createIdentifier("is"),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createConditionalExpression(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("is"),
                                 undefined,
-                                [p.tsc.factory.createIdentifier("input")],
+                                [ts.factory.createIdentifier("input")],
                             ),
                             undefined,
-                            p.tsc.factory.createCallExpression(
-                                p.tsc.factory.createIdentifier("stringify"),
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("stringify"),
                                 undefined,
-                                [p.tsc.factory.createIdentifier("input")],
+                                [ts.factory.createIdentifier("input")],
                             ),
                             undefined,
-                            p.tsc.factory.createNull(),
+                            ts.factory.createNull(),
                         ),
                     ),
                 ]),