typia 7.0.0-dev.20240923 → 7.0.0-dev.20240928

package/src/programmers/AssertProgrammer.ts

@@ -11,6 +11,7 @@ import { CheckerProgrammer } from "./CheckerProgrammer";
 import { FeatureProgrammer } from "./FeatureProgrammer";
 import { IsProgrammer } from "./IsProgrammer";
 import { FunctionImporter } from "./helpers/FunctionImporter";
+import { IExpressionEntry } from "./helpers/IExpressionEntry";
 import { OptionPredicator } from "./helpers/OptionPredicator";
 import { check_object } from "./internal/check_object";
 
@@ -24,8 +25,8 @@ export namespace AssertProgrammer {
   }
 
   export const decompose = (props: {
-    context: ITypiaContext;
     config: IConfig;
+    context: ITypiaContext;
     importer: FunctionImporter;
     type: ts.Type;
     name: string | undefined;
@@ -45,33 +46,34 @@ export namespace AssertProgrammer {
         trace: true,
         numeric: OptionPredicator.numeric(props.context.options),
         equals: props.config.equals,
-        atomist: (explore) => (entry) => (input) =>
+        atomist: (next) =>
           [
-            ...(entry.expression ? [entry.expression] : []),
-            ...(entry.conditions.length === 0
+            ...(next.entry.expression ? [next.entry.expression] : []),
+            ...(next.entry.conditions.length === 0
               ? []
-              : entry.conditions.length === 1
-                ? entry.conditions[0]!.map((cond) =>
+              : next.entry.conditions.length === 1
+                ? next.entry.conditions[0]!.map((cond) =>
                     ts.factory.createLogicalOr(
                       cond.expression,
-                      create_guard_call(props.importer)(
-                        explore.from === "top"
-                          ? ts.factory.createTrue()
-                          : ts.factory.createIdentifier("_exceptionable"),
-                      )(
-                        ts.factory.createIdentifier(
-                          explore.postfix
-                            ? `_path + ${explore.postfix}`
+                      create_guard_call({
+                        importer: props.importer,
+                        exceptionable:
+                          next.explore.from === "top"
+                            ? ts.factory.createTrue()
+                            : ts.factory.createIdentifier("_exceptionable"),
+                        path: ts.factory.createIdentifier(
+                          next.explore.postfix
+                            ? `_path + ${next.explore.postfix}`
                             : "_path",
                         ),
-                        cond.expected,
-                        input,
-                      ),
+                        expected: cond.expected,
+                        input: next.input,
+                      }),
                     ),
                   )
                 : [
                     ts.factory.createLogicalOr(
-                      entry.conditions
+                      next.entry.conditions
                         .map((set) =>
                           set
                             .map((s) => s.expression)
@@ -80,24 +82,25 @@ export namespace AssertProgrammer {
                             ),
                         )
                         .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
-                      create_guard_call(props.importer)(
-                        explore.from === "top"
-                          ? ts.factory.createTrue()
-                          : ts.factory.createIdentifier("_exceptionable"),
-                      )(
-                        ts.factory.createIdentifier(
-                          explore.postfix
-                            ? `_path + ${explore.postfix}`
+                      create_guard_call({
+                        importer: props.importer,
+                        exceptionable:
+                          next.explore.from === "top"
+                            ? ts.factory.createTrue()
+                            : ts.factory.createIdentifier("_exceptionable"),
+                        path: ts.factory.createIdentifier(
+                          next.explore.postfix
+                            ? `_path + ${next.explore.postfix}`
                             : "_path",
                         ),
-                        entry.expected,
-                        input,
-                      ),
+                        expected: next.entry.expected,
+                        input: next.input,
+                      }),
                     ),
                   ]),
           ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
-        combiner: combiner(props.config.equals)(props.context)(props.importer),
-        joiner: joiner(props.config.equals)(props.context)(props.importer),
+        combiner: combiner(props),
+        joiner: joiner(props),
         success: ts.factory.createTrue(),
       },
     });
@@ -176,7 +179,6 @@ export namespace AssertProgrammer {
         true,
       ),
     );
-
     return {
       functions: {
         ...is.functions,
@@ -208,45 +210,63 @@ export namespace AssertProgrammer {
   };
 
   const combiner =
-    (equals: boolean) =>
-    (project: ITypiaContext) =>
-    (importer: FunctionImporter): CheckerProgrammer.IConfig.Combiner =>
-    (explore: CheckerProgrammer.IExplore) => {
-      if (explore.tracable === false)
+    (props: {
+      config: IConfig;
+      context: ITypiaContext;
+      importer: FunctionImporter;
+    }): CheckerProgrammer.IConfig.Combiner =>
+    (next) => {
+      if (next.explore.tracable === false)
         return IsProgrammer.configure({
-          object: assert_object(equals)(project)(importer),
+          object: (v) =>
+            assert_object({
+              config: props.config,
+              context: props.context,
+              importer: props.importer,
+              entries: v.entries,
+              input: v.input,
+            }),
           numeric: true,
-        })(project)(importer).combiner(explore);
+        })(props.context)(props.importer).combiner(next);
 
-      const path: string = explore.postfix
-        ? `_path + ${explore.postfix}`
+      const path: string = next.explore.postfix
+        ? `_path + ${next.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"
+      return next.logic === "and"
+        ? next.binaries
+            .map((binary) =>
+              binary.combined
+                ? binary.expression
+                : ts.factory.createLogicalOr(
+                    binary.expression,
+                    create_guard_call({
+                      importer: props.importer,
+                      exceptionable:
+                        next.explore.source === "top"
                           ? ts.factory.createTrue()
                           : ts.factory.createIdentifier("_exceptionable"),
-                      )(ts.factory.createIdentifier(path), expected, input),
-                    ),
-              )
-              .reduce(ts.factory.createLogicalAnd)
-          : ts.factory.createLogicalOr(
-              binaries
-                .map((binary) => binary.expression)
-                .reduce(ts.factory.createLogicalOr),
-              create_guard_call(importer)(
-                explore.source === "top"
+                      path: ts.factory.createIdentifier(path),
+                      expected: next.expected,
+                      input: next.input,
+                    }),
+                  ),
+            )
+            .reduce(ts.factory.createLogicalAnd)
+        : ts.factory.createLogicalOr(
+            next.binaries
+              .map((binary) => binary.expression)
+              .reduce(ts.factory.createLogicalOr),
+            create_guard_call({
+              importer: props.importer,
+              exceptionable:
+                next.explore.source === "top"
                   ? ts.factory.createTrue()
                   : ts.factory.createIdentifier("_exceptionable"),
-              )(ts.factory.createIdentifier(path), expected, input),
-            );
+              path: ts.factory.createIdentifier(path),
+              expected: next.expected,
+              input: next.input,
+            }),
+          );
       // : (() => {
       //       const addicted = binaries.slice();
       //       if (
@@ -273,96 +293,118 @@ export namespace AssertProgrammer {
       //   })();
     };
 
-  const assert_object =
-    (equals: boolean) =>
-    (project: ITypiaContext) =>
-    (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"),
-              ]),
+  const assert_object = (props: {
+    config: IConfig;
+    context: ITypiaContext;
+    importer: FunctionImporter;
+    entries: IExpressionEntry<ts.Expression>[];
+    input: ts.Expression;
+  }) =>
+    check_object({
+      equals: props.config.equals,
+      assert: true,
+      undefined: true,
+      reduce: ts.factory.createLogicalAnd,
+      positive: ts.factory.createTrue(),
+      superfluous: (input) =>
+        create_guard_call({
+          importer: props.importer,
+          path: ts.factory.createAdd(
+            ts.factory.createIdentifier("_path"),
+            ts.factory.createCallExpression(
+              props.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,
+          expected: "undefined",
+          input,
+        }),
+      halt: (expr) =>
+        ts.factory.createLogicalOr(
+          ts.factory.createStrictEquality(
+            ts.factory.createFalse(),
+            ts.factory.createIdentifier("_exceptionable"),
           ),
-      })(project)(importer);
-
-  const joiner =
-    (equals: boolean) =>
-    (project: ITypiaContext) =>
-    (importer: FunctionImporter): CheckerProgrammer.IConfig.IJoiner => ({
-      object: assert_object(equals)(project)(importer),
-      array: (props) =>
-        ts.factory.createCallExpression(
-          IdentifierFactory.access(props.input)("every"),
-          undefined,
-          [props.arrow],
+          expr,
         ),
-      failure: (value, expected, explore) =>
-        create_guard_call(importer)(
-          explore?.from === "top"
+    })(props.context)(props.importer)({
+      input: props.input,
+      entries: props.entries,
+    });
+
+  const joiner = (props: {
+    config: IConfig;
+    context: ITypiaContext;
+    importer: FunctionImporter;
+  }): CheckerProgrammer.IConfig.IJoiner => ({
+    object: (next) =>
+      assert_object({
+        config: props.config,
+        context: props.context,
+        importer: props.importer,
+        entries: next.entries,
+        input: next.input,
+      }),
+    array: (props) =>
+      ts.factory.createCallExpression(
+        IdentifierFactory.access(props.input)("every"),
+        undefined,
+        [props.arrow],
+      ),
+    failure: (next) =>
+      create_guard_call({
+        importer: props.importer,
+        exceptionable:
+          next.explore?.from === "top"
             ? ts.factory.createTrue()
             : ts.factory.createIdentifier("_exceptionable"),
-        )(
-          ts.factory.createIdentifier(
-            explore?.postfix ? `_path + ${explore.postfix}` : "_path",
-          ),
-          expected,
-          value,
+        path: ts.factory.createIdentifier(
+          next.explore?.postfix ? `_path + ${next.explore.postfix}` : "_path",
         ),
-      full: equals
-        ? undefined
-        : (condition) => (input, expected, explore) =>
-            ts.factory.createLogicalOr(
-              condition,
-              create_guard_call(importer)(
-                explore.from === "top"
+        expected: next.expected,
+        input: next.input,
+      }),
+    full: props.config.equals
+      ? undefined
+      : (next) =>
+          ts.factory.createLogicalOr(
+            next.condition,
+            create_guard_call({
+              importer: props.importer,
+              exceptionable:
+                next.explore.from === "top"
                   ? ts.factory.createTrue()
                   : ts.factory.createIdentifier("_exceptionable"),
-              )(ts.factory.createIdentifier("_path"), expected, input),
-            ),
-    });
+              path: ts.factory.createIdentifier("_path"),
+              expected: next.expected,
+              input: next.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,
-        ),
-        ts.factory.createIdentifier("_errorFactory"),
-      ]);
+  const create_guard_call = (props: {
+    importer: FunctionImporter;
+    expected: string;
+    input: ts.Expression;
+    path: ts.Expression;
+    exceptionable?: ts.Expression;
+  }): ts.Expression =>
+    ts.factory.createCallExpression(props.importer.use("guard"), undefined, [
+      props.exceptionable ?? ts.factory.createIdentifier("_exceptionable"),
+      ts.factory.createObjectLiteralExpression(
+        [
+          ts.factory.createPropertyAssignment("path", props.path),
+          ts.factory.createPropertyAssignment(
+            "expected",
+            ts.factory.createStringLiteral(props.expected),
+          ),
+          ts.factory.createPropertyAssignment("value", props.input),
+        ],
+        true,
+      ),
+      ts.factory.createIdentifier("_errorFactory"),
+    ]);
 
   export namespace Guardian {
     export const identifier = () => ts.factory.createIdentifier("errorFactory");