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

package/src/programmers/ValidateProgrammer.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";
@@ -27,130 +27,130 @@ export namespace ValidateProgrammer {
             write(project)(modulo)(equals)(type, name);
 
     export const write =
-        (p: IProject) =>
+        (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
         (equals: boolean) =>
         (type: ts.Type, name?: string) => {
-            const importer: FunctionImporter = new FunctionImporter(p.tsc);
-            const program: ts.ArrowFunction = CheckerProgrammer.write(p)({
-                functors: "$vo",
-                unioners: "$vu",
-                path: true,
-                trace: true,
-                numeric: OptionPredicator.numeric(p.options),
-                equals,
-                atomist: (explore) => (tuple) => (input) =>
-                    [
-                        tuple.expression,
-                        ...tuple.tags.map((tag) =>
-                            p.tsc.factory.createLogicalOr(
-                                tag.expression,
-                                create_report_call(p.tsc)(
-                                    explore.from === "top"
-                                        ? p.tsc.factory.createTrue()
-                                        : p.tsc.factory.createIdentifier(
-                                              "_exceptionable",
-                                          ),
-                                )(
-                                    p.tsc.factory.createIdentifier(
-                                        explore.postfix
-                                            ? `_path + ${explore.postfix}`
-                                            : "_path",
+            const importer: FunctionImporter = new FunctionImporter();
+
+            const is = IsProgrammer.write(project)(modulo, true)(equals)(
+                type,
+                name ?? TypeFactory.getFullName(project.checker)(type),
+            );
+            const validate: ts.ArrowFunction = CheckerProgrammer.write(project)(
+                {
+                    prefix: "$v",
+                    path: true,
+                    trace: true,
+                    numeric: OptionPredicator.numeric(project.options),
+                    equals,
+                    atomist: (explore) => (tuple) => (input) =>
+                        [
+                            tuple.expression,
+                            ...tuple.tags.map((tag) =>
+                                ts.factory.createLogicalOr(
+                                    tag.expression,
+                                    create_report_call(
+                                        explore.from === "top"
+                                            ? ts.factory.createTrue()
+                                            : ts.factory.createIdentifier(
+                                                  "_exceptionable",
+                                              ),
+                                    )(
+                                        ts.factory.createIdentifier(
+                                            explore.postfix
+                                                ? `_path + ${explore.postfix}`
+                                                : "_path",
+                                        ),
+                                        tag.expected,
+                                        input,
                                     ),
-                                    tag.expected,
-                                    input,
                                 ),
                             ),
-                        ),
-                    ].reduce((x, y) => p.tsc.factory.createLogicalAnd(x, y)),
-                combiner: combine(p.tsc)(equals)(importer),
-                joiner: joiner(p.tsc)(equals)(importer),
-                success: p.tsc.factory.createTrue(),
-            })(importer)(type, name);
+                        ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
+                    combiner: combine(equals)(importer),
+                    joiner: joiner(equals)(importer),
+                    success: ts.factory.createTrue(),
+                    addition: () => importer.declare(modulo),
+                },
+            )(importer)(type, name);
 
-            return p.tsc.factory.createArrowFunction(
+            return 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.IValidation<${
-                        name ?? TypeFactory.getFullName(p)(type)
+                        name ?? TypeFactory.getFullName(project.checker)(type)
                     }>`,
                 ),
                 undefined,
-                p.tsc.factory.createBlock(
+                ts.factory.createBlock(
                     [
-                        StatementFactory.constant(p.tsc)(
-                            "__is",
-                            IsProgrammer.write(p)(modulo, true)(equals)(
-                                type,
-                                name ?? TypeFactory.getFullName(p)(type),
-                            ),
-                        ),
-                        StatementFactory.constant(p.tsc)(
+                        StatementFactory.constant(
                             "errors",
-                            p.tsc.factory.createAsExpression(
-                                p.tsc.factory.createArrayLiteralExpression([]),
-                                p.tsc.factory.createArrayTypeNode(
-                                    TypeFactory.keyword(p.tsc)("any"),
+                            ts.factory.createAsExpression(
+                                ts.factory.createArrayLiteralExpression([]),
+                                ts.factory.createArrayTypeNode(
+                                    TypeFactory.keyword("any"),
                                 ),
                             ),
                         ),
-                        StatementFactory.constant(p.tsc)(
+                        StatementFactory.constant(
                             "$report",
-                            p.tsc.factory.createCallExpression(
-                                IdentifierFactory.access(p.tsc)(
-                                    p.tsc.factory.createParenthesizedExpression(
-                                        p.tsc.factory.createAsExpression(
+                            ts.factory.createCallExpression(
+                                IdentifierFactory.access(
+                                    ts.factory.createParenthesizedExpression(
+                                        ts.factory.createAsExpression(
                                             modulo,
-                                            TypeFactory.keyword(p.tsc)("any"),
+                                            TypeFactory.keyword("any"),
                                         ),
                                     ),
                                 )("report"),
                                 [],
-                                [p.tsc.factory.createIdentifier("errors")],
+                                [ts.factory.createIdentifier("errors")],
                             ),
                         ),
-                        ...importer.declare(modulo),
-                        p.tsc.factory.createIfStatement(
-                            p.tsc.factory.createStrictEquality(
-                                p.tsc.factory.createFalse(),
-                                p.tsc.factory.createCallExpression(
-                                    p.tsc.factory.createIdentifier("__is"),
+                        StatementFactory.constant("__is", is),
+                        ts.factory.createIfStatement(
+                            ts.factory.createStrictEquality(
+                                ts.factory.createFalse(),
+                                ts.factory.createCallExpression(
+                                    ts.factory.createIdentifier("__is"),
                                     undefined,
-                                    [p.tsc.factory.createIdentifier("input")],
+                                    [ts.factory.createIdentifier("input")],
                                 ),
                             ),
-                            p.tsc.factory.createExpressionStatement(
-                                p.tsc.factory.createCallExpression(
-                                    program,
+                            ts.factory.createExpressionStatement(
+                                ts.factory.createCallExpression(
+                                    validate,
                                     undefined,
                                     [
-                                        p.tsc.factory.createIdentifier("input"),
-                                        p.tsc.factory.createStringLiteral(
+                                        ts.factory.createIdentifier("input"),
+                                        ts.factory.createStringLiteral(
                                             "$input",
                                         ),
-                                        p.tsc.factory.createTrue(),
+                                        ts.factory.createTrue(),
                                     ],
                                 ),
                             ),
                         ),
-                        StatementFactory.constant(p.tsc)(
+                        StatementFactory.constant(
                             "success",
-                            p.tsc.factory.createStrictEquality(
-                                p.tsc.factory.createNumericLiteral(0),
-                                p.tsc.factory.createIdentifier("errors.length"),
+                            ts.factory.createStrictEquality(
+                                ts.factory.createNumericLiteral(0),
+                                ts.factory.createIdentifier("errors.length"),
                             ),
                         ),
-                        p.tsc.factory.createReturnStatement(
-                            p.tsc.factory.createAsExpression(
-                                create_output(p.tsc),
-                                TypeFactory.keyword(p.tsc)("any"),
+                        ts.factory.createReturnStatement(
+                            ts.factory.createAsExpression(
+                                create_output(),
+                                TypeFactory.keyword("any"),
                             ),
                         ),
                     ],
@@ -161,13 +161,12 @@ export namespace ValidateProgrammer {
 }
 
 const combine =
-    (tsc: typeof ts) =>
     (equals: boolean) =>
     (importer: FunctionImporter): CheckerProgrammer.IConfig.Combiner =>
     (explore: CheckerProgrammer.IExplore) => {
         if (explore.tracable === false)
-            return IsProgrammer.configure(tsc)({
-                object: validate_object(tsc)(equals)(importer),
+            return IsProgrammer.configure({
+                object: validate_object(equals)(importer),
                 numeric: true,
             })(importer).combiner(explore);
 
@@ -180,109 +179,107 @@ const combine =
                       .map((binary) =>
                           binary.combined
                               ? binary.expression
-                              : tsc.factory.createLogicalOr(
+                              : ts.factory.createLogicalOr(
                                     binary.expression,
-                                    create_report_call(tsc)(
+                                    create_report_call(
                                         explore.source === "top"
-                                            ? tsc.factory.createTrue()
-                                            : tsc.factory.createIdentifier(
+                                            ? ts.factory.createTrue()
+                                            : ts.factory.createIdentifier(
                                                   "_exceptionable",
                                               ),
                                     )(
-                                        tsc.factory.createIdentifier(path),
+                                        ts.factory.createIdentifier(path),
                                         expected,
                                         input,
                                     ),
                                 ),
                       )
-                      .reduce(tsc.factory.createLogicalAnd)
-                : tsc.factory.createLogicalOr(
+                      .reduce(ts.factory.createLogicalAnd)
+                : ts.factory.createLogicalOr(
                       binaries
                           .map((binary) => binary.expression)
-                          .reduce(tsc.factory.createLogicalOr),
-                      create_report_call(tsc)(
+                          .reduce(ts.factory.createLogicalOr),
+                      create_report_call(
                           explore.source === "top"
-                              ? tsc.factory.createTrue()
-                              : tsc.factory.createIdentifier("_exceptionable"),
-                      )(tsc.factory.createIdentifier(path), expected, input),
+                              ? ts.factory.createTrue()
+                              : ts.factory.createIdentifier("_exceptionable"),
+                      )(ts.factory.createIdentifier(path), expected, input),
                   );
     };
 
-const validate_object =
-    (tsc: typeof ts) => (equals: boolean) => (importer: FunctionImporter) =>
-        check_object(tsc)({
-            equals,
-            undefined: true,
-            assert: false,
-            reduce: tsc.factory.createLogicalAnd,
-            positive: tsc.factory.createTrue(),
-            superfluous: (value) =>
-                create_report_call(tsc)()(
-                    tsc.factory.createAdd(
-                        tsc.factory.createIdentifier("_path"),
-                        tsc.factory.createCallExpression(
-                            importer.use("join"),
-                            undefined,
-                            [tsc.factory.createIdentifier("key")],
-                        ),
+const validate_object = (equals: boolean) => (importer: FunctionImporter) =>
+    check_object({
+        equals,
+        undefined: true,
+        assert: false,
+        reduce: ts.factory.createLogicalAnd,
+        positive: ts.factory.createTrue(),
+        superfluous: (value) =>
+            create_report_call()(
+                ts.factory.createAdd(
+                    ts.factory.createIdentifier("_path"),
+                    ts.factory.createCallExpression(
+                        importer.use("join"),
+                        undefined,
+                        [ts.factory.createIdentifier("key")],
                     ),
-                    "undefined",
-                    value,
                 ),
-            halt: (expr) =>
-                tsc.factory.createLogicalOr(
-                    tsc.factory.createStrictEquality(
-                        tsc.factory.createFalse(),
-                        tsc.factory.createIdentifier("_exceptionable"),
-                    ),
-                    expr,
+                "undefined",
+                value,
+            ),
+        halt: (expr) =>
+            ts.factory.createLogicalOr(
+                ts.factory.createStrictEquality(
+                    ts.factory.createFalse(),
+                    ts.factory.createIdentifier("_exceptionable"),
                 ),
-        })(importer);
+                expr,
+            ),
+    })(importer);
 
 const joiner =
-    (tsc: typeof ts) =>
     (equals: boolean) =>
     (importer: FunctionImporter): CheckerProgrammer.IConfig.IJoiner => ({
-        object: validate_object(tsc)(equals)(importer),
+        object: validate_object(equals)(importer),
         array: (input, arrow) =>
-            check_everything(tsc)(
-                tsc.factory.createCallExpression(
-                    IdentifierFactory.access(tsc)(input)("map"),
+            check_everything(
+                ts.factory.createCallExpression(
+                    IdentifierFactory.access(input)("map"),
                     undefined,
                     [arrow],
                 ),
             ),
         failure: (value, expected, explore) =>
-            create_report_call(tsc)(
+            create_report_call(
                 explore?.from === "top"
-                    ? tsc.factory.createTrue()
-                    : tsc.factory.createIdentifier("_exceptionable"),
+                    ? ts.factory.createTrue()
+                    : ts.factory.createIdentifier("_exceptionable"),
             )(
-                tsc.factory.createIdentifier(
+                ts.factory.createIdentifier(
                     explore?.postfix ? `_path + ${explore.postfix}` : "_path",
                 ),
                 expected,
                 value,
             ),
         tuple: (binaries) =>
-            check_everything(tsc)(
-                tsc.factory.createArrayLiteralExpression(binaries, true),
+            check_everything(
+                ts.factory.createArrayLiteralExpression(binaries, true),
             ),
     });
 
-const create_output = (tsc: typeof ts) =>
-    tsc.factory.createObjectLiteralExpression(
+const create_output = () =>
+    ts.factory.createObjectLiteralExpression(
         [
-            tsc.factory.createShorthandPropertyAssignment("success"),
-            tsc.factory.createShorthandPropertyAssignment("errors"),
-            tsc.factory.createPropertyAssignment(
+            ts.factory.createShorthandPropertyAssignment("success"),
+            ts.factory.createShorthandPropertyAssignment("errors"),
+            ts.factory.createPropertyAssignment(
                 "data",
-                tsc.factory.createConditionalExpression(
-                    tsc.factory.createIdentifier("success"),
+                ts.factory.createConditionalExpression(
+                    ts.factory.createIdentifier("success"),
                     undefined,
-                    tsc.factory.createIdentifier("input"),
+                    ts.factory.createIdentifier("input"),
                     undefined,
-                    tsc.factory.createIdentifier("undefined"),
+                    ts.factory.createIdentifier("undefined"),
                 ),
             ),
         ],
@@ -290,26 +287,25 @@ const create_output = (tsc: typeof ts) =>
     );
 
 const create_report_call =
-    (tsc: typeof ts) =>
     (exceptionable?: ts.Expression) =>
     (
         path: ts.Expression,
         expected: string,
         value: ts.Expression,
     ): ts.Expression =>
-        tsc.factory.createCallExpression(
-            tsc.factory.createIdentifier("$report"),
+        ts.factory.createCallExpression(
+            ts.factory.createIdentifier("$report"),
             undefined,
             [
-                exceptionable ?? tsc.factory.createIdentifier("_exceptionable"),
-                tsc.factory.createObjectLiteralExpression(
+                exceptionable ?? ts.factory.createIdentifier("_exceptionable"),
+                ts.factory.createObjectLiteralExpression(
                     [
-                        tsc.factory.createPropertyAssignment("path", path),
-                        tsc.factory.createPropertyAssignment(
+                        ts.factory.createPropertyAssignment("path", path),
+                        ts.factory.createPropertyAssignment(
                             "expected",
-                            tsc.factory.createStringLiteral(expected),
+                            ts.factory.createStringLiteral(expected),
                         ),
-                        tsc.factory.createPropertyAssignment("value", value),
+                        ts.factory.createPropertyAssignment("value", value),
                     ],
                     true,
                 ),

package/src/programmers/ValidatePruneProgrammer.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,67 +19,67 @@ export namespace ValidatePruneProgrammer {
             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.IValidation<${
-                        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(
                         "validate",
                         ValidateProgrammer.write({
-                            ...p,
+                            ...project,
                             options: {
-                                ...p.options,
+                                ...project.options,
                                 functional: false,
                                 numeric: true,
                             },
                         })(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),
                     ),
-                    StatementFactory.constant(p.tsc)(
+                    StatementFactory.constant(
                         "output",
-                        p.tsc.factory.createCallExpression(
-                            p.tsc.factory.createIdentifier("validate"),
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("validate"),
                             undefined,
-                            [p.tsc.factory.createIdentifier("input")],
+                            [ts.factory.createIdentifier("input")],
                         ),
                     ),
-                    p.tsc.factory.createIfStatement(
-                        p.tsc.factory.createIdentifier("output.success"),
-                        p.tsc.factory.createExpressionStatement(
-                            p.tsc.factory.createCallExpression(
-                                p.tsc.factory.createIdentifier("prune"),
+                    ts.factory.createIfStatement(
+                        ts.factory.createIdentifier("output.success"),
+                        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.createIdentifier("output"),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createIdentifier("output"),
                     ),
                 ]),
             );

package/src/programmers/ValidateStringifyProgrammer.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,74 +19,73 @@ export namespace ValidateStringifyProgrammer {
             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.createTypeReferenceNode(
-                    "typia.IValidation<string>",
-                ),
+                ts.factory.createTypeReferenceNode("typia.IValidation<string>"),
                 undefined,
-                p.tsc.factory.createBlock([
-                    StatementFactory.constant(p.tsc)(
+                ts.factory.createBlock([
+                    StatementFactory.constant(
                         "validate",
                         ValidateProgrammer.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),
                     ),
-                    StatementFactory.constant(p.tsc)(
+                    StatementFactory.constant(
                         "output",
-                        p.tsc.factory.createAsExpression(
-                            p.tsc.factory.createCallExpression(
-                                p.tsc.factory.createIdentifier("validate"),
+                        ts.factory.createAsExpression(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("validate"),
                                 undefined,
-                                [p.tsc.factory.createIdentifier("input")],
+                                [ts.factory.createIdentifier("input")],
                             ),
-                            TypeFactory.keyword(p.tsc)("any"),
+                            TypeFactory.keyword("any"),
                         ),
                     ),
-                    p.tsc.factory.createIfStatement(
-                        p.tsc.factory.createIdentifier("output.success"),
-                        p.tsc.factory.createExpressionStatement(
-                            p.tsc.factory.createBinaryExpression(
-                                p.tsc.factory.createIdentifier("output.data"),
-                                p.tsc.SyntaxKind.EqualsToken,
-                                p.tsc.factory.createCallExpression(
-                                    p.tsc.factory.createIdentifier("stringify"),
+                    ts.factory.createIfStatement(
+                        ts.factory.createIdentifier("output.success"),
+                        ts.factory.createExpressionStatement(
+                            ts.factory.createBinaryExpression(
+                                ts.factory.createIdentifier("output.data"),
+                                ts.SyntaxKind.EqualsToken,
+                                ts.factory.createCallExpression(
+                                    ts.factory.createIdentifier("stringify"),
                                     undefined,
-                                    [p.tsc.factory.createIdentifier("input")],
+                                    [ts.factory.createIdentifier("input")],
                                 ),
                             ),
                         ),
                     ),
-                    p.tsc.factory.createReturnStatement(
-                        p.tsc.factory.createIdentifier("output"),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createIdentifier("output"),
                     ),
                 ]),
             );