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

package/src/programmers/AssertProgrammer.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";
@@ -13,33 +13,48 @@ import { OptionPredicator } from "./helpers/OptionPredicator";
 import { check_object } from "./internal/check_object";
 
 export namespace AssertProgrammer {
+    /**
+     * @deprecated Use `write()` function instead
+     */
+    export const generate =
+        (
+            project: IProject,
+            modulo: ts.LeftHandSideExpression,
+            equals: boolean = false,
+        ) =>
+        (type: ts.Type, name?: string) =>
+            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: "$ao",
-                unioners: "$au",
+            const importer: FunctionImporter = new FunctionImporter();
+            const is = IsProgrammer.write(project)(modulo, true)(equals)(
+                type,
+                name ?? TypeFactory.getFullName(project.checker)(type),
+            );
+            const assert: ts.ArrowFunction = CheckerProgrammer.write(project)({
+                prefix: "$a",
                 path: true,
                 trace: true,
-                numeric: OptionPredicator.numeric(p.options),
+                numeric: OptionPredicator.numeric(project.options),
                 equals,
                 atomist: (explore) => (tuple) => (input) =>
                     [
                         tuple.expression,
                         ...tuple.tags.map((tag) =>
-                            p.tsc.factory.createLogicalOr(
+                            ts.factory.createLogicalOr(
                                 tag.expression,
-                                create_guard_call(p.tsc)(importer)(
+                                create_guard_call(importer)(
                                     explore.from === "top"
-                                        ? p.tsc.factory.createTrue()
-                                        : p.tsc.factory.createIdentifier(
+                                        ? ts.factory.createTrue()
+                                        : ts.factory.createIdentifier(
                                               "_exceptionable",
                                           ),
                                 )(
-                                    p.tsc.factory.createIdentifier(
+                                    ts.factory.createIdentifier(
                                         explore.postfix
                                             ? `_path + ${explore.postfix}`
                                             : "_path",
@@ -49,61 +64,55 @@ export namespace AssertProgrammer {
                                 ),
                             ),
                         ),
-                    ].reduce((x, y) => p.tsc.factory.createLogicalAnd(x, y)),
-                combiner: combiner(p.tsc)(equals)(importer),
-                joiner: joiner(p.tsc)(equals)(importer),
-                success: p.tsc.factory.createTrue(),
+                    ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
+                combiner: combiner(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(
-                    name ?? TypeFactory.getFullName(p)(type),
+                ts.factory.createTypeReferenceNode(
+                    name ?? TypeFactory.getFullName(project.checker)(type),
                 ),
                 undefined,
-                p.tsc.factory.createBlock(
+                ts.factory.createBlock(
                     [
-                        ...importer.declare(modulo),
-                        StatementFactory.constant(p.tsc)(
-                            "__is",
-                            IsProgrammer.write(p)(modulo, true)(equals)(
-                                type,
-                                name ?? TypeFactory.getFullName(p)(type),
-                            ),
-                        ),
-                        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(
+                                    assert,
                                     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(),
                                     ],
                                 ),
                             ),
                             undefined,
                         ),
-                        p.tsc.factory.createReturnStatement(
-                            p.tsc.factory.createIdentifier(`input`),
+                        ts.factory.createReturnStatement(
+                            ts.factory.createIdentifier(`input`),
                         ),
                     ],
                     true,
@@ -112,13 +121,12 @@ export namespace AssertProgrammer {
         };
 
     const combiner =
-        (tsc: typeof ts) =>
         (equals: boolean) =>
         (importer: FunctionImporter): CheckerProgrammer.IConfig.Combiner =>
         (explore: CheckerProgrammer.IExplore) => {
             if (explore.tracable === false)
-                return IsProgrammer.configure(tsc)({
-                    object: assert_object(tsc)(equals)(importer),
+                return IsProgrammer.configure({
+                    object: assert_object(equals)(importer),
                     numeric: true,
                 })(importer).combiner(explore);
 
@@ -131,97 +139,107 @@ export namespace AssertProgrammer {
                           .map((binary) =>
                               binary.combined
                                   ? binary.expression
-                                  : tsc.factory.createLogicalOr(
+                                  : ts.factory.createLogicalOr(
                                         binary.expression,
-                                        create_guard_call(tsc)(importer)(
+                                        create_guard_call(importer)(
                                             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)
-                    : (() => {
-                          const addicted = binaries.slice();
-                          if (
-                              addicted[addicted.length - 1]!.combined === false
-                          ) {
-                              addicted.push({
-                                  combined: true,
-                                  expression: create_guard_call(tsc)(importer)(
-                                      explore.source === "top"
-                                          ? tsc.factory.createTrue()
-                                          : tsc.factory.createIdentifier(
-                                                "_exceptionable",
-                                            ),
-                                  )(
-                                      tsc.factory.createIdentifier(path),
-                                      expected,
-                                      input,
-                                  ),
-                              });
-                          }
-                          return addicted
-                              .map((b) => b.expression)
-                              .reduce(tsc.factory.createLogicalOr);
-                      })();
+                          .reduce(ts.factory.createLogicalAnd)
+                    : ts.factory.createLogicalOr(
+                          binaries
+                              .map((binary) => binary.expression)
+                              .reduce(ts.factory.createLogicalOr),
+                          create_guard_call(importer)(
+                              explore.source === "top"
+                                  ? ts.factory.createTrue()
+                                  : ts.factory.createIdentifier(
+                                        "_exceptionable",
+                                    ),
+                          )(ts.factory.createIdentifier(path), expected, input),
+                      );
+            // : (() => {
+            //       const addicted = binaries.slice();
+            //       if (
+            //           addicted[addicted.length - 1]!.combined === false
+            //       ) {
+            //           addicted.push({
+            //               combined: true,
+            //               expression: create_guard_call(importer)(
+            //                   explore.source === "top"
+            //                       ? ts.factory.createTrue()
+            //                       : ts.factory.createIdentifier(
+            //                             "_exceptionable",
+            //                         ),
+            //               )(
+            //                   ts.factory.createIdentifier(path),
+            //                   expected,
+            //                   input,
+            //               ),
+            //           });
+            //       }
+            //       return addicted
+            //           .map((b) => b.expression)
+            //           .reduce(ts.factory.createLogicalOr);
+            //   })();
         };
 
-    const assert_object =
-        (tsc: typeof ts) => (equals: boolean) => (importer: FunctionImporter) =>
-            check_object(tsc)({
-                equals,
-                assert: true,
-                undefined: true,
-                reduce: tsc.factory.createLogicalAnd,
-                positive: tsc.factory.createTrue(),
-                superfluous: (value) =>
-                    create_guard_call(tsc)(importer)()(
-                        tsc.factory.createAdd(
-                            tsc.factory.createIdentifier("_path"),
-                            tsc.factory.createCallExpression(
-                                importer.use("join"),
-                                undefined,
-                                [tsc.factory.createIdentifier("key")],
-                            ),
+    const assert_object = (equals: boolean) => (importer: FunctionImporter) =>
+        check_object({
+            equals,
+            assert: true,
+            undefined: true,
+            reduce: ts.factory.createLogicalAnd,
+            positive: ts.factory.createTrue(),
+            superfluous: (value) =>
+                create_guard_call(importer)()(
+                    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: assert_object(tsc)(equals)(importer),
+            object: assert_object(equals)(importer),
             array: (input, arrow) =>
-                tsc.factory.createCallExpression(
-                    IdentifierFactory.access(tsc)(input)("every"),
+                ts.factory.createCallExpression(
+                    IdentifierFactory.access(input)("every"),
                     undefined,
                     [arrow],
                 ),
             failure: (value, expected, explore) =>
-                create_guard_call(tsc)(importer)(
+                create_guard_call(importer)(
                     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",
@@ -232,16 +250,16 @@ export namespace AssertProgrammer {
             full: equals
                 ? undefined
                 : (condition) => (input, expected, explore) =>
-                      tsc.factory.createLogicalOr(
+                      ts.factory.createLogicalOr(
                           condition,
-                          create_guard_call(tsc)(importer)(
+                          create_guard_call(importer)(
                               explore.from === "top"
-                                  ? tsc.factory.createTrue()
-                                  : tsc.factory.createIdentifier(
+                                  ? ts.factory.createTrue()
+                                  : ts.factory.createIdentifier(
                                         "_exceptionable",
                                     ),
                           )(
-                              tsc.factory.createIdentifier("_path"),
+                              ts.factory.createIdentifier("_path"),
                               expected,
                               input,
                           ),
@@ -249,7 +267,6 @@ export namespace AssertProgrammer {
         });
 
     const create_guard_call =
-        (tsc: typeof ts) =>
         (importer: FunctionImporter) =>
         (exceptionable?: ts.Expression) =>
         (
@@ -257,16 +274,16 @@ export namespace AssertProgrammer {
             expected: string,
             value: ts.Expression,
         ): ts.Expression =>
-            tsc.factory.createCallExpression(importer.use("guard"), undefined, [
-                exceptionable ?? tsc.factory.createIdentifier("_exceptionable"),
-                tsc.factory.createObjectLiteralExpression(
+            ts.factory.createCallExpression(importer.use("guard"), undefined, [
+                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/AssertPruneProgrammer.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,54 +19,57 @@ export namespace AssertPruneProgrammer {
             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(
-                    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(
                         "assert",
-                        AssertProgrammer.write(p)(modulo)(false)(type, name),
+                        AssertProgrammer.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.createExpressionStatement(
-                        p.tsc.factory.createCallExpression(
-                            p.tsc.factory.createIdentifier("assert"),
+                    ts.factory.createExpressionStatement(
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("assert"),
                             undefined,
-                            [p.tsc.factory.createIdentifier("input")],
+                            [ts.factory.createIdentifier("input")],
                         ),
                     ),
-                    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.createIdentifier("input"),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createIdentifier("input"),
                     ),
                 ]),
             );

package/src/programmers/AssertStringifyProgrammer.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,53 +10,61 @@ import { AssertProgrammer } from "./AssertProgrammer";
 import { StringifyProgrammer } from "./StringifyProgrammer";
 
 export namespace AssertStringifyProgrammer {
+    /**
+     * @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"),
                     ),
                 ],
-                TypeFactory.keyword(p.tsc)("string"),
+                TypeFactory.keyword("string"),
                 undefined,
-                p.tsc.factory.createBlock([
-                    StatementFactory.constant(p.tsc)(
+                ts.factory.createBlock([
+                    StatementFactory.constant(
                         "assert",
                         AssertProgrammer.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.createCallExpression(
-                            p.tsc.factory.createIdentifier("stringify"),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("stringify"),
                             undefined,
                             [
-                                p.tsc.factory.createCallExpression(
-                                    p.tsc.factory.createIdentifier("assert"),
+                                ts.factory.createCallExpression(
+                                    ts.factory.createIdentifier("assert"),
                                     undefined,
-                                    [p.tsc.factory.createIdentifier("input")],
+                                    [ts.factory.createIdentifier("input")],
                                 ),
                             ],
                         ),