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

package/src/programmers/FeatureProgrammer.ts

@@ -46,7 +46,7 @@ export namespace FeatureProgrammer {
      * Initializer of metadata.
      */
     initializer: (
-      project: ITypiaContext,
+      context: ITypiaContext,
     ) => (
       importer: FunctionImporter,
     ) => (type: ts.Type) => [MetadataCollection, Metadata];
@@ -234,9 +234,12 @@ export namespace FeatureProgrammer {
       functions: {
         ...Object.fromEntries(
           (
-            props.config.generator.objects?.() ??
-            write_object_functions(props.config)(props.importer)
-          )(collection).map((v, i) => [`${props.config.prefix}o${i}`, v]),
+            props.config.generator.objects?.()(collection) ??
+            write_object_functions({
+              ...props,
+              collection,
+            })
+          ).map((v, i) => [`${props.config.prefix}o${i}`, v]),
         ),
         ...Object.fromEntries(
           (
@@ -288,11 +291,11 @@ export namespace FeatureProgrammer {
     );
 
   export const write =
-    (project: ITypiaContext) =>
+    (context: ITypiaContext) =>
     (config: IConfig) =>
     (importer: FunctionImporter) =>
     (type: ts.Type, name?: string): ts.ArrowFunction => {
-      const [collection, meta] = config.initializer(project)(importer)(type);
+      const [collection, meta] = config.initializer(context)(importer)(type);
 
       // ITERATE OVER ALL METADATA
       const output: ts.ConciseBody = config.decoder()(
@@ -308,10 +311,13 @@ export namespace FeatureProgrammer {
 
       // RETURNS THE OPTIMAL ARROW FUNCTION
       const functions = {
-        objects: (
-          config.generator.objects?.() ??
-          write_object_functions(config)(importer)
-        )(collection),
+        objects:
+          config.generator.objects?.()(collection) ??
+          write_object_functions({
+            config,
+            importer,
+            collection,
+          }),
         unions: (config.generator.unions?.() ?? write_union_functions(config))(
           collection,
         ),
@@ -352,31 +358,32 @@ export namespace FeatureProgrammer {
       );
     };
 
-  export const write_object_functions =
-    (config: IConfig) =>
-    (importer: FunctionImporter) =>
-    (collection: MetadataCollection) =>
-      collection.objects().map((object) =>
-        StatementFactory.constant(
-          `${config.prefix}o${object.index}`,
-          ts.factory.createArrowFunction(
-            undefined,
-            undefined,
-            parameterDeclarations(config)(TypeFactory.keyword("any"))(
-              ValueFactory.INPUT(),
-            ),
-            config.objector.type ?? TypeFactory.keyword("any"),
-            undefined,
-            config.objector.joiner({
-              input: ts.factory.createIdentifier("input"),
-              entries: feature_object_entries(config)(importer)(object)(
-                ts.factory.createIdentifier("input"),
-              ),
-              object,
-            }),
+  export const write_object_functions = (props: {
+    config: IConfig;
+    importer: FunctionImporter;
+    collection: MetadataCollection;
+  }) =>
+    props.collection.objects().map((object) =>
+      StatementFactory.constant(
+        `${props.config.prefix}o${object.index}`,
+        ts.factory.createArrowFunction(
+          undefined,
+          undefined,
+          parameterDeclarations(props.config)(TypeFactory.keyword("any"))(
+            ValueFactory.INPUT(),
           ),
+          props.config.objector.type ?? TypeFactory.keyword("any"),
+          undefined,
+          props.config.objector.joiner({
+            input: ts.factory.createIdentifier("input"),
+            entries: feature_object_entries(props.config)(props.importer)(
+              object,
+            )(ts.factory.createIdentifier("input")),
+            object,
+          }),
         ),
-      );
+      ),
+    );
 
   export const write_union_functions =
     (config: IConfig) => (collection: MetadataCollection) =>
@@ -433,7 +440,6 @@ export namespace FeatureProgrammer {
               ),
             ]
           : [];
-
       return (
         input: ts.Expression,
         array: MetadataArray,

package/src/programmers/IsProgrammer.ts

@@ -5,6 +5,9 @@ import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { MetadataCollection } from "../factories/MetadataCollection";
 import { ValueFactory } from "../factories/ValueFactory";
 
+import { Metadata } from "../schemas/metadata/Metadata";
+import { MetadataObject } from "../schemas/metadata/MetadataObject";
+
 import { IProgrammerProps } from "../transformers/IProgrammerProps";
 import { ITypiaContext } from "../transformers/ITypiaContext";
 
@@ -27,7 +30,7 @@ export namespace IsProgrammer {
       numeric: OptionPredicator.numeric({
         numeric: options?.numeric,
       }),
-      atomist: () => (entry) => () =>
+      atomist: ({ entry }) =>
         [
           ...(entry.expression ? [entry.expression] : []),
           ...(entry.conditions.length === 0
@@ -42,22 +45,18 @@ export namespace IsProgrammer {
                   .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
               ]),
         ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
-      combiner: () => (type: "and" | "or") => {
+      combiner: (next) => {
         const initial: ts.TrueLiteral | ts.FalseLiteral =
-          type === "and" ? ts.factory.createTrue() : ts.factory.createFalse();
+          next.logic === "and"
+            ? ts.factory.createTrue()
+            : ts.factory.createFalse();
         const binder =
-          type === "and"
+          next.logic === "and"
             ? ts.factory.createLogicalAnd
             : ts.factory.createLogicalOr;
-        return (
-          _input: ts.Expression,
-          binaries: CheckerProgrammer.IBinary[],
-        ) =>
-          binaries.length
-            ? binaries
-                .map((binary) => binary.expression)
-                .reduce((x, y) => binder(x, y))
-            : initial;
+        return next.binaries.length
+          ? next.binaries.map((binary) => binary.expression).reduce(binder)
+          : initial;
       },
       joiner: {
         object:
@@ -164,62 +163,91 @@ export namespace IsProgrammer {
     });
   };
 
-  export const write_function_statements =
-    (project: ITypiaContext) =>
-    (importer: FunctionImporter) =>
-    (collection: MetadataCollection) => {
-      const config = configure()(project)(importer);
-      const objects =
-        CheckerProgrammer.write_object_functions(project)(config)(importer)(
-          collection,
-        );
-      const unions =
-        CheckerProgrammer.write_union_functions(project)(config)(importer)(
-          collection,
-        );
-      const arrays =
-        CheckerProgrammer.write_array_functions(project)(config)(importer)(
-          collection,
-        );
-      const tuples =
-        CheckerProgrammer.write_tuple_functions(project)(config)(importer)(
-          collection,
-        );
-
-      return [
-        ...objects.filter((_, i) => importer.hasLocal(`${config.prefix}o${i}`)),
-        ...unions.filter((_, i) => importer.hasLocal(`${config.prefix}u${i}`)),
-        ...arrays.filter((_, i) => importer.hasLocal(`${config.prefix}a${i}`)),
-        ...tuples.filter((_, i) => importer.hasLocal(`${config.prefix}t${i}`)),
-      ];
+  export const write_function_statements = (props: {
+    context: ITypiaContext;
+    importer: FunctionImporter;
+    collection: MetadataCollection;
+  }) => {
+    const config: CheckerProgrammer.IConfig = configure()(props.context)(
+      props.importer,
+    );
+    const next = {
+      ...props,
+      config,
     };
+    const objects: ts.VariableStatement[] =
+      CheckerProgrammer.write_object_functions(next);
+    const unions: ts.VariableStatement[] =
+      CheckerProgrammer.write_union_functions(next);
+    const arrays: ts.VariableStatement[] =
+      CheckerProgrammer.write_array_functions(next);
+    const tuples: ts.VariableStatement[] =
+      CheckerProgrammer.write_tuple_functions(next);
+
+    return [
+      ...objects.filter((_, i) =>
+        props.importer.hasLocal(`${config.prefix}o${i}`),
+      ),
+      ...unions.filter((_, i) =>
+        props.importer.hasLocal(`${config.prefix}u${i}`),
+      ),
+      ...arrays.filter((_, i) =>
+        props.importer.hasLocal(`${config.prefix}a${i}`),
+      ),
+      ...tuples.filter((_, i) =>
+        props.importer.hasLocal(`${config.prefix}t${i}`),
+      ),
+    ];
+  };
 
   /* -----------------------------------------------------------
-        DECODERS
-    ----------------------------------------------------------- */
-  export const decode =
-    (project: ITypiaContext) => (importer: FunctionImporter) =>
-      CheckerProgrammer.decode(project)(configure()(project)(importer))(
-        importer,
-      );
-
-  export const decode_object =
-    (project: ITypiaContext) => (importer: FunctionImporter) =>
-      CheckerProgrammer.decode_object(configure()(project)(importer))(importer);
-
-  export const decode_to_json =
-    (checkNull: boolean) =>
-    (input: ts.Expression): ts.Expression =>
-      ts.factory.createLogicalAnd(
-        ExpressionFactory.isObject({
-          checkArray: false,
-          checkNull,
-        })(input),
-        ts.factory.createStrictEquality(
-          ts.factory.createStringLiteral("function"),
-          ValueFactory.TYPEOF(IdentifierFactory.access(input)("toJSON")),
-        ),
-      );
+    DECODERS
+  ----------------------------------------------------------- */
+  export const decode = (props: {
+    context: ITypiaContext;
+    importer: FunctionImporter;
+    metadata: Metadata;
+    input: ts.Expression;
+    explore: CheckerProgrammer.IExplore;
+  }) =>
+    CheckerProgrammer.decode({
+      context: props.context,
+      config: configure()(props.context)(props.importer),
+      importer: props.importer,
+      metadata: props.metadata,
+      input: props.input,
+      explore: props.explore,
+    });
+
+  export const decode_object = (props: {
+    context: ITypiaContext;
+    importer: FunctionImporter;
+    object: MetadataObject;
+    input: ts.Expression;
+    explore: FeatureProgrammer.IExplore;
+  }) =>
+    CheckerProgrammer.decode_object({
+      config: configure()(props.context)(props.importer),
+      importer: props.importer,
+      object: props.object,
+      input: props.input,
+      explore: props.explore,
+    });
+
+  export const decode_to_json = (props: {
+    input: ts.Expression;
+    checkNull: boolean;
+  }): ts.Expression =>
+    ts.factory.createLogicalAnd(
+      ExpressionFactory.isObject({
+        checkArray: false,
+        checkNull: props.checkNull,
+      })(props.input),
+      ts.factory.createStrictEquality(
+        ts.factory.createStringLiteral("function"),
+        ValueFactory.TYPEOF(IdentifierFactory.access(props.input)("toJSON")),
+      ),
+    );
 
   export const decode_functional = (input: ts.Expression) =>
     ts.factory.createStrictEquality(

package/src/programmers/ValidateProgrammer.ts

@@ -41,33 +41,33 @@ export namespace ValidateProgrammer {
         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_report_call(
-                        explore.from === "top"
-                          ? ts.factory.createTrue()
-                          : ts.factory.createIdentifier("_exceptionable"),
-                      )(
-                        ts.factory.createIdentifier(
-                          explore.postfix
-                            ? `_path + ${explore.postfix}`
+                      create_report_call({
+                        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)
@@ -76,24 +76,24 @@ export namespace ValidateProgrammer {
                             ),
                         )
                         .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
-                      create_report_call(
-                        explore.from === "top"
-                          ? ts.factory.createTrue()
-                          : ts.factory.createIdentifier("_exceptionable"),
-                      )(
-                        ts.factory.createIdentifier(
-                          explore.postfix
-                            ? `_path + ${explore.postfix}`
+                      create_report_call({
+                        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: combine(props.config.equals)(props.context)(props.importer),
-        joiner: joiner(props.config.equals)(props.context)(props.importer),
+        combiner: combine(props),
+        joiner: joiner(props),
         success: ts.factory.createTrue(),
       },
     });
@@ -243,106 +243,119 @@ export namespace ValidateProgrammer {
 }
 
 const combine =
-  (equals: boolean) =>
-  (project: ITypiaContext) =>
-  (importer: FunctionImporter): CheckerProgrammer.IConfig.Combiner =>
-  (explore: CheckerProgrammer.IExplore) => {
-    if (explore.tracable === false)
+  (props: {
+    config: ValidateProgrammer.IConfig;
+    context: ITypiaContext;
+    importer: FunctionImporter;
+  }): CheckerProgrammer.IConfig.Combiner =>
+  (next) => {
+    if (next.explore.tracable === false)
       return IsProgrammer.configure({
-        object: validate_object(equals)(project)(importer),
+        object: validate_object(props),
         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_report_call(
-                      explore.source === "top"
+    return next.logic === "and"
+      ? next.binaries
+          .map((binary) =>
+            binary.combined
+              ? binary.expression
+              : ts.factory.createLogicalOr(
+                  binary.expression,
+                  create_report_call({
+                    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_report_call(
-              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_report_call({
+            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 validate_object =
-  (equals: boolean) =>
-  (project: ITypiaContext) =>
-  (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"),
-            ]),
+const validate_object = (props: {
+  config: ValidateProgrammer.IConfig;
+  context: ITypiaContext;
+  importer: FunctionImporter;
+}) =>
+  check_object({
+    equals: props.config.equals,
+    undefined: true,
+    assert: false,
+    reduce: ts.factory.createLogicalAnd,
+    positive: ts.factory.createTrue(),
+    superfluous: (input) =>
+      create_report_call({
+        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);
+        expr,
+      ),
+  })(props.context)(props.importer);
 
-const joiner =
-  (equals: boolean) =>
-  (project: ITypiaContext) =>
-  (importer: FunctionImporter): CheckerProgrammer.IConfig.IJoiner => ({
-    object: validate_object(equals)(project)(importer),
-    array: (props) =>
-      check_everything(
-        ts.factory.createCallExpression(
-          IdentifierFactory.access(props.input)("map"),
-          undefined,
-          [props.arrow],
-        ),
+const joiner = (props: {
+  config: ValidateProgrammer.IConfig;
+  context: ITypiaContext;
+  importer: FunctionImporter;
+}): CheckerProgrammer.IConfig.IJoiner => ({
+  object: validate_object(props),
+  array: (props) =>
+    check_everything(
+      ts.factory.createCallExpression(
+        IdentifierFactory.access(props.input)("map"),
+        undefined,
+        [props.arrow],
       ),
-    failure: (value, expected, explore) =>
-      create_report_call(
-        explore?.from === "top"
+    ),
+  failure: (next) =>
+    create_report_call({
+      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",
       ),
-    tuple: (binaries) =>
-      check_everything(ts.factory.createArrayLiteralExpression(binaries, true)),
-  });
+      expected: next.expected,
+      input: next.input,
+    }),
+  tuple: (binaries) =>
+    check_everything(ts.factory.createArrayLiteralExpression(binaries, true)),
+});
 
 const create_output = () =>
   ts.factory.createObjectLiteralExpression(
@@ -363,28 +376,27 @@ const create_output = () =>
     true,
   );
 
-const create_report_call =
-  (exceptionable?: ts.Expression) =>
-  (
-    path: ts.Expression,
-    expected: string,
-    value: ts.Expression,
-  ): ts.Expression =>
-    ts.factory.createCallExpression(
-      ts.factory.createIdentifier("$report"),
-      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,
-        ),
-      ],
-    );
+const create_report_call = (props: {
+  exceptionable?: ts.Expression;
+  path: ts.Expression;
+  expected: string;
+  input: ts.Expression;
+}): ts.Expression =>
+  ts.factory.createCallExpression(
+    ts.factory.createIdentifier("$report"),
+    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,
+      ),
+    ],
+  );

package/src/programmers/helpers/UnionExplorer.ts

@@ -158,7 +158,7 @@ export namespace UnionExplorer {
   export namespace array_or_tuple {
     export type IProps = check_union_array_like.IProps<
       MetadataArray | MetadataTuple,
-      Metadata
+      Metadata | MetadataTuple
     >;
   }