typia 4.0.0-dev.20230517 → 4.0.0-dev.20230519

package/src/programmers/AssertProgrammer.ts

@@ -1,285 +1,274 @@
-import ts from "typescript/lib/tsclibrary";
-
-import { IdentifierFactory } from "../factories/IdentifierFactory";
-import { StatementFactory } from "../factories/StatementFactory";
-import { TypeFactory } from "../factories/TypeFactory";
-
-import { IProject } from "../transformers/IProject";
-
-import { CheckerProgrammer } from "./CheckerProgrammer";
-import { IsProgrammer } from "./IsProgrammer";
-import { FunctionImporter } from "./helpers/FunctionImporeter";
-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 =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (equals: boolean) =>
-        (type: ts.Type, name?: string) => {
-            const importer: FunctionImporter = new FunctionImporter();
-            const program: ts.ArrowFunction = CheckerProgrammer.write(project)({
-                functors: "$ao",
-                unioners: "$au",
-                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_guard_call(importer)(
-                                    explore.from === "top"
-                                        ? ts.factory.createTrue()
-                                        : ts.factory.createIdentifier(
-                                              "_exceptionable",
-                                          ),
-                                )(
-                                    ts.factory.createIdentifier(
-                                        explore.postfix
-                                            ? `_path + ${explore.postfix}`
-                                            : "_path",
-                                    ),
-                                    tag.expected,
-                                    input,
-                                ),
-                            ),
-                        ),
-                    ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
-                combiner: combiner(equals)(importer),
-                joiner: joiner(equals)(importer),
-                success: ts.factory.createTrue(),
-            })(importer)(type, name);
-
-            return ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [
-                    IdentifierFactory.parameter(
-                        "input",
-                        TypeFactory.keyword("any"),
-                    ),
-                ],
-                ts.factory.createTypeReferenceNode(
-                    name ?? TypeFactory.getFullName(project.checker)(type),
-                ),
-                undefined,
-                ts.factory.createBlock(
-                    [
-                        ...importer.declare(modulo),
-                        StatementFactory.constant(
-                            "__is",
-                            IsProgrammer.write(project)(modulo, true)(equals)(
-                                type,
-                                name ??
-                                    TypeFactory.getFullName(project.checker)(
-                                        type,
-                                    ),
-                            ),
-                        ),
-                        ts.factory.createIfStatement(
-                            ts.factory.createStrictEquality(
-                                ts.factory.createFalse(),
-                                ts.factory.createCallExpression(
-                                    ts.factory.createIdentifier("__is"),
-                                    undefined,
-                                    [ts.factory.createIdentifier("input")],
-                                ),
-                            ),
-                            ts.factory.createExpressionStatement(
-                                ts.factory.createCallExpression(
-                                    program,
-                                    undefined,
-                                    [
-                                        ts.factory.createIdentifier("input"),
-                                        ts.factory.createStringLiteral(
-                                            "$input",
-                                        ),
-                                        ts.factory.createTrue(),
-                                    ],
-                                ),
-                            ),
-                            undefined,
-                        ),
-                        ts.factory.createReturnStatement(
-                            ts.factory.createIdentifier(`input`),
-                        ),
-                    ],
-                    true,
-                ),
-            );
-        };
-
-    const combiner =
-        (equals: boolean) =>
-        (importer: FunctionImporter): CheckerProgrammer.IConfig.Combiner =>
-        (explore: CheckerProgrammer.IExplore) => {
-            if (explore.tracable === false)
-                return IsProgrammer.configure({
-                    object: assert_object(equals)(importer),
-                    numeric: true,
-                })(importer).combiner(explore);
-
-            const path: string = explore.postfix
-                ? `_path + ${explore.postfix}`
-                : "_path";
-            return (logic) => (input, binaries, expected) =>
-                logic === "and"
-                    ? binaries
-                          .map((binary) =>
-                              binary.combined
-                                  ? binary.expression
-                                  : ts.factory.createLogicalOr(
-                                        binary.expression,
-                                        create_guard_call(importer)(
-                                            explore.source === "top"
-                                                ? ts.factory.createTrue()
-                                                : ts.factory.createIdentifier(
-                                                      "_exceptionable",
-                                                  ),
-                                        )(
-                                            ts.factory.createIdentifier(path),
-                                            expected,
-                                            input,
-                                        ),
-                                    ),
-                          )
-                          .reduce(ts.factory.createLogicalAnd)
-                    : (() => {
-                          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 = (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) =>
-                ts.factory.createLogicalOr(
-                    ts.factory.createStrictEquality(
-                        ts.factory.createFalse(),
-                        ts.factory.createIdentifier("_exceptionable"),
-                    ),
-                    expr,
-                ),
-        })(importer);
-
-    const joiner =
-        (equals: boolean) =>
-        (importer: FunctionImporter): CheckerProgrammer.IConfig.IJoiner => ({
-            object: assert_object(equals)(importer),
-            array: (input, arrow) =>
-                ts.factory.createCallExpression(
-                    IdentifierFactory.access(input)("every"),
-                    undefined,
-                    [arrow],
-                ),
-            failure: (value, expected, explore) =>
-                create_guard_call(importer)(
-                    explore?.from === "top"
-                        ? ts.factory.createTrue()
-                        : ts.factory.createIdentifier("_exceptionable"),
-                )(
-                    ts.factory.createIdentifier(
-                        explore?.postfix
-                            ? `_path + ${explore.postfix}`
-                            : "_path",
-                    ),
-                    expected,
-                    value,
-                ),
-            full: equals
-                ? undefined
-                : (condition) => (input, expected, explore) =>
-                      ts.factory.createLogicalOr(
-                          condition,
-                          create_guard_call(importer)(
-                              explore.from === "top"
-                                  ? ts.factory.createTrue()
-                                  : ts.factory.createIdentifier(
-                                        "_exceptionable",
-                                    ),
-                          )(
-                              ts.factory.createIdentifier("_path"),
-                              expected,
-                              input,
-                          ),
-                      ),
-        });
-
-    const create_guard_call =
-        (importer: FunctionImporter) =>
-        (exceptionable?: ts.Expression) =>
-        (
-            path: ts.Expression,
-            expected: string,
-            value: ts.Expression,
-        ): ts.Expression =>
-            ts.factory.createCallExpression(importer.use("guard"), undefined, [
-                exceptionable ?? ts.factory.createIdentifier("_exceptionable"),
-                ts.factory.createObjectLiteralExpression(
-                    [
-                        ts.factory.createPropertyAssignment("path", path),
-                        ts.factory.createPropertyAssignment(
-                            "expected",
-                            ts.factory.createStringLiteral(expected),
-                        ),
-                        ts.factory.createPropertyAssignment("value", value),
-                    ],
-                    true,
-                ),
-            ]);
-}
+import type ts from "typescript/lib/tsclibrary";
+
+import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { StatementFactory } from "../factories/StatementFactory";
+import { TypeFactory } from "../factories/TypeFactory";
+
+import { IProject } from "../transformers/IProject";
+
+import { CheckerProgrammer } from "./CheckerProgrammer";
+import { IsProgrammer } from "./IsProgrammer";
+import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { OptionPredicator } from "./helpers/OptionPredicator";
+import { check_object } from "./internal/check_object";
+
+export namespace AssertProgrammer {
+    export const write =
+        (p: 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",
+                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_guard_call(p.tsc)(importer)(
+                                    explore.from === "top"
+                                        ? p.tsc.factory.createTrue()
+                                        : p.tsc.factory.createIdentifier(
+                                              "_exceptionable",
+                                          ),
+                                )(
+                                    p.tsc.factory.createIdentifier(
+                                        explore.postfix
+                                            ? `_path + ${explore.postfix}`
+                                            : "_path",
+                                    ),
+                                    tag.expected,
+                                    input,
+                                ),
+                            ),
+                        ),
+                    ].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(),
+            })(importer)(type, name);
+
+            return p.tsc.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(p.tsc)(
+                        "input",
+                        TypeFactory.keyword(p.tsc)("any"),
+                    ),
+                ],
+                p.tsc.factory.createTypeReferenceNode(
+                    name ?? TypeFactory.getFullName(p)(type),
+                ),
+                undefined,
+                p.tsc.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"),
+                                    undefined,
+                                    [p.tsc.factory.createIdentifier("input")],
+                                ),
+                            ),
+                            p.tsc.factory.createExpressionStatement(
+                                p.tsc.factory.createCallExpression(
+                                    program,
+                                    undefined,
+                                    [
+                                        p.tsc.factory.createIdentifier("input"),
+                                        p.tsc.factory.createStringLiteral(
+                                            "$input",
+                                        ),
+                                        p.tsc.factory.createTrue(),
+                                    ],
+                                ),
+                            ),
+                            undefined,
+                        ),
+                        p.tsc.factory.createReturnStatement(
+                            p.tsc.factory.createIdentifier(`input`),
+                        ),
+                    ],
+                    true,
+                ),
+            );
+        };
+
+    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),
+                    numeric: true,
+                })(importer).combiner(explore);
+
+            const path: string = explore.postfix
+                ? `_path + ${explore.postfix}`
+                : "_path";
+            return (logic) => (input, binaries, expected) =>
+                logic === "and"
+                    ? binaries
+                          .map((binary) =>
+                              binary.combined
+                                  ? binary.expression
+                                  : tsc.factory.createLogicalOr(
+                                        binary.expression,
+                                        create_guard_call(tsc)(importer)(
+                                            explore.source === "top"
+                                                ? tsc.factory.createTrue()
+                                                : tsc.factory.createIdentifier(
+                                                      "_exceptionable",
+                                                  ),
+                                        )(
+                                            tsc.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);
+                      })();
+        };
+
+    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")],
+                            ),
+                        ),
+                        "undefined",
+                        value,
+                    ),
+                halt: (expr) =>
+                    tsc.factory.createLogicalOr(
+                        tsc.factory.createStrictEquality(
+                            tsc.factory.createFalse(),
+                            tsc.factory.createIdentifier("_exceptionable"),
+                        ),
+                        expr,
+                    ),
+            })(importer);
+
+    const joiner =
+        (tsc: typeof ts) =>
+        (equals: boolean) =>
+        (importer: FunctionImporter): CheckerProgrammer.IConfig.IJoiner => ({
+            object: assert_object(tsc)(equals)(importer),
+            array: (input, arrow) =>
+                tsc.factory.createCallExpression(
+                    IdentifierFactory.access(tsc)(input)("every"),
+                    undefined,
+                    [arrow],
+                ),
+            failure: (value, expected, explore) =>
+                create_guard_call(tsc)(importer)(
+                    explore?.from === "top"
+                        ? tsc.factory.createTrue()
+                        : tsc.factory.createIdentifier("_exceptionable"),
+                )(
+                    tsc.factory.createIdentifier(
+                        explore?.postfix
+                            ? `_path + ${explore.postfix}`
+                            : "_path",
+                    ),
+                    expected,
+                    value,
+                ),
+            full: equals
+                ? undefined
+                : (condition) => (input, expected, explore) =>
+                      tsc.factory.createLogicalOr(
+                          condition,
+                          create_guard_call(tsc)(importer)(
+                              explore.from === "top"
+                                  ? tsc.factory.createTrue()
+                                  : tsc.factory.createIdentifier(
+                                        "_exceptionable",
+                                    ),
+                          )(
+                              tsc.factory.createIdentifier("_path"),
+                              expected,
+                              input,
+                          ),
+                      ),
+        });
+
+    const create_guard_call =
+        (tsc: typeof ts) =>
+        (importer: FunctionImporter) =>
+        (exceptionable?: ts.Expression) =>
+        (
+            path: ts.Expression,
+            expected: string,
+            value: ts.Expression,
+        ): ts.Expression =>
+            tsc.factory.createCallExpression(importer.use("guard"), undefined, [
+                exceptionable ?? tsc.factory.createIdentifier("_exceptionable"),
+                tsc.factory.createObjectLiteralExpression(
+                    [
+                        tsc.factory.createPropertyAssignment("path", path),
+                        tsc.factory.createPropertyAssignment(
+                            "expected",
+                            tsc.factory.createStringLiteral(expected),
+                        ),
+                        tsc.factory.createPropertyAssignment("value", value),
+                    ],
+                    true,
+                ),
+            ]);
+}