typia 7.0.0-dev.20240928 → 7.0.0-dev.20240930

package/src/programmers/IsProgrammer.ts

@@ -19,68 +19,69 @@ import { OptionPredicator } from "./helpers/OptionPredicator";
 import { check_object } from "./internal/check_object";
 
 export namespace IsProgrammer {
-  export const configure =
-    (options?: Partial<CONFIG.IOptions>) =>
-    (project: ITypiaContext) =>
-    (importer: FunctionImporter): CheckerProgrammer.IConfig => ({
-      prefix: "$i",
-      equals: !!options?.object,
-      trace: false,
-      path: false,
-      numeric: OptionPredicator.numeric({
-        numeric: options?.numeric,
-      }),
-      atomist: ({ entry }) =>
-        [
-          ...(entry.expression ? [entry.expression] : []),
-          ...(entry.conditions.length === 0
-            ? []
-            : [
-                entry.conditions
-                  .map((set) =>
-                    set
-                      .map((s) => s.expression)
-                      .reduce((a, b) => ts.factory.createLogicalAnd(a, b)),
-                  )
-                  .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
-              ]),
-        ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
-      combiner: (next) => {
-        const initial: ts.TrueLiteral | ts.FalseLiteral =
-          next.logic === "and"
-            ? ts.factory.createTrue()
-            : ts.factory.createFalse();
-        const binder =
-          next.logic === "and"
-            ? ts.factory.createLogicalAnd
-            : ts.factory.createLogicalOr;
-        return next.binaries.length
-          ? next.binaries.map((binary) => binary.expression).reduce(binder)
-          : initial;
-      },
-      joiner: {
-        object:
-          options?.object ||
-          check_object({
-            equals: !!options?.object,
-            undefined: OptionPredicator.undefined({
-              undefined: options?.undefined,
-            }),
-            assert: true,
-            reduce: ts.factory.createLogicalAnd,
-            positive: ts.factory.createTrue(),
-            superfluous: () => ts.factory.createFalse(),
-          })(project)(importer),
-        array: (props) =>
-          ts.factory.createCallExpression(
-            IdentifierFactory.access(props.input)("every"),
-            undefined,
-            [props.arrow],
-          ),
-        failure: () => ts.factory.createFalse(),
-      },
-      success: ts.factory.createTrue(),
-    });
+  export const configure = (props: {
+    options?: Partial<CONFIG.IOptions>;
+    context: ITypiaContext;
+    importer: FunctionImporter;
+  }): CheckerProgrammer.IConfig => ({
+    prefix: "$i",
+    equals: !!props.options?.object,
+    trace: false,
+    path: false,
+    numeric: OptionPredicator.numeric({
+      numeric: props.options?.numeric,
+    }),
+    atomist: ({ entry }) =>
+      [
+        ...(entry.expression ? [entry.expression] : []),
+        ...(entry.conditions.length === 0
+          ? []
+          : [
+              entry.conditions
+                .map((set) =>
+                  set
+                    .map((s) => s.expression)
+                    .reduce((a, b) => ts.factory.createLogicalAnd(a, b)),
+                )
+                .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
+            ]),
+      ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
+    combiner: (next) => {
+      const initial: ts.TrueLiteral | ts.FalseLiteral =
+        next.logic === "and"
+          ? ts.factory.createTrue()
+          : ts.factory.createFalse();
+      const binder =
+        next.logic === "and"
+          ? ts.factory.createLogicalAnd
+          : ts.factory.createLogicalOr;
+      return next.binaries.length
+        ? next.binaries.map((binary) => binary.expression).reduce(binder)
+        : initial;
+    },
+    joiner: {
+      object:
+        props.options?.object ||
+        check_object({
+          equals: !!props.options?.object,
+          undefined: OptionPredicator.undefined({
+            undefined: props.options?.undefined,
+          }),
+          assert: true,
+          reduce: ts.factory.createLogicalAnd,
+          positive: ts.factory.createTrue(),
+          superfluous: () => ts.factory.createFalse(),
+        })(props.context)(props.importer),
+      array: (props) =>
+        ts.factory.createCallExpression(
+          IdentifierFactory.access(props.input)("every"),
+          undefined,
+          [props.arrow],
+        ),
+      failure: () => ts.factory.createFalse(),
+    },
+    success: ts.factory.createTrue(),
+  });
 
   export namespace CONFIG {
     export interface IOptions {
@@ -113,16 +114,20 @@ export namespace IsProgrammer {
     // CONFIGURATION
     const config: CheckerProgrammer.IConfig = {
       ...configure({
-        object: check_object({
-          equals: props.config.equals,
-          undefined: OptionPredicator.undefined(props.context.options),
-          assert: true,
-          reduce: ts.factory.createLogicalAnd,
-          positive: ts.factory.createTrue(),
-          superfluous: () => ts.factory.createFalse(),
-        })(props.context)(props.importer),
-        numeric: OptionPredicator.numeric(props.context.options),
-      })(props.context)(props.importer),
+        options: {
+          object: check_object({
+            equals: props.config.equals,
+            undefined: OptionPredicator.undefined(props.context.options),
+            assert: true,
+            reduce: ts.factory.createLogicalAnd,
+            positive: ts.factory.createTrue(),
+            superfluous: () => ts.factory.createFalse(),
+          })(props.context)(props.importer),
+          numeric: OptionPredicator.numeric(props.context.options),
+        },
+        context: props.context,
+        importer: props.importer,
+      }),
       trace: props.config.equals,
     };
 
@@ -168,9 +173,7 @@ export namespace IsProgrammer {
     importer: FunctionImporter;
     collection: MetadataCollection;
   }) => {
-    const config: CheckerProgrammer.IConfig = configure()(props.context)(
-      props.importer,
-    );
+    const config: CheckerProgrammer.IConfig = configure(props);
     const next = {
       ...props,
       config,
@@ -212,7 +215,7 @@ export namespace IsProgrammer {
   }) =>
     CheckerProgrammer.decode({
       context: props.context,
-      config: configure()(props.context)(props.importer),
+      config: configure(props),
       importer: props.importer,
       metadata: props.metadata,
       input: props.input,
@@ -227,7 +230,7 @@ export namespace IsProgrammer {
     explore: FeatureProgrammer.IExplore;
   }) =>
     CheckerProgrammer.decode_object({
-      config: configure()(props.context)(props.importer),
+      config: configure(props),
       importer: props.importer,
       object: props.object,
       input: props.input,

package/src/programmers/ValidateProgrammer.ts

@@ -251,9 +251,13 @@ const combine =
   (next) => {
     if (next.explore.tracable === false)
       return IsProgrammer.configure({
-        object: validate_object(props),
-        numeric: true,
-      })(props.context)(props.importer).combiner(next);
+        options: {
+          object: validate_object(props),
+          numeric: true,
+        },
+        context: props.context,
+        importer: props.importer,
+      }).combiner(next);
 
     const path: string = next.explore.postfix
       ? `_path + ${next.explore.postfix}`

package/src/programmers/helpers/UnionExplorer.ts

@@ -36,23 +36,32 @@ export namespace UnionExplorer {
     ): ts.Expression => {
       // BREAKER
       if (targets.length === 1)
-        return config.objector.decoder()(input, targets[0]!, explore);
+        return config.objector.decoder({
+          input,
+          object: targets[0]!,
+          explore,
+        });
 
       const expected: string = `(${targets.map((t) => t.name).join(" | ")})`;
 
       // POSSIBLE TO SPECIALIZE?
       const specList = UnionPredicator.object(targets);
       if (specList.length === 0) {
-        const condition: ts.Expression = config.objector.unionizer(
+        const condition: ts.Expression = config.objector.unionizer({
           input,
-          targets,
-          {
+          objects: targets,
+          explore: {
             ...explore,
             tracable: false,
           },
-        );
+        });
         return config.objector.full
-          ? config.objector.full(condition)(input, expected, explore)
+          ? config.objector.full({
+              condition,
+              expected,
+              explore,
+              input,
+            })
           : condition;
       }
       const remained: MetadataObject[] = targets.filter(
@@ -66,10 +75,14 @@ export namespace UnionExplorer {
           const key: string = spec.property.key.getSoleLiteral()!;
           const accessor: ts.Expression = IdentifierFactory.access(input)(key);
           const pred: ts.Expression = spec.neighbour
-            ? config.objector.checker()(accessor, spec.property.value, {
-                ...explore,
-                tracable: false,
-                postfix: IdentifierFactory.postfix(key),
+            ? config.objector.checker({
+                input: accessor,
+                metadata: spec.property.value,
+                explore: {
+                  ...explore,
+                  tracable: false,
+                  postfix: IdentifierFactory.postfix(key),
+                },
               })
             : (config.objector.required || ((exp) => exp))(
                 ExpressionFactory.isRequired(accessor),
@@ -77,14 +90,22 @@ export namespace UnionExplorer {
           return ts.factory.createIfStatement(
             (config.objector.is || ((exp) => exp))(pred),
             ts.factory.createReturnStatement(
-              config.objector.decoder()(input, spec.object, explore),
+              config.objector.decoder({
+                object: spec.object,
+                input,
+                explore,
+              }),
             ),
             i === array.length - 1
               ? remained.length
                 ? ts.factory.createReturnStatement(
                     object(config, level + 1)(input, remained, explore),
                   )
-                : config.objector.failure(input, expected, explore)
+                : config.objector.failure({
+                    input,
+                    expected,
+                    explore,
+                  })
               : undefined,
           );
         })

package/src/programmers/internal/feature_object_entries.ts

@@ -20,9 +20,9 @@ export const feature_object_entries =
     >,
   ) =>
   (importer: FunctionImporter) =>
-  (obj: MetadataObject) =>
+  (object: MetadataObject) =>
   (input: ts.Expression, from: "object" | "top" | "array" = "object") =>
-    obj.properties.map((prop) => {
+    object.properties.map((prop) => {
       const sole: string | null = prop.key.getSoleLiteral();
       const propInput =
         sole === null
@@ -36,23 +36,26 @@ export const feature_object_entries =
                 input,
                 ts.factory.createStringLiteral(sole),
               );
-
       return {
         input: propInput,
         key: prop.key,
         meta: prop.value,
-        expression: config.decoder()(propInput, prop.value, {
-          tracable: config.path || config.trace,
-          source: "function",
-          from,
-          postfix: config.trace
-            ? sole !== null
-              ? IdentifierFactory.postfix(sole)
-              : (() => {
-                  importer.use("join");
-                  return `$join(key)`;
-                })()
-            : "",
+        expression: config.decoder({
+          input: propInput,
+          metadata: prop.value,
+          explore: {
+            tracable: config.path || config.trace,
+            source: "function",
+            from,
+            postfix: config.trace
+              ? sole !== null
+                ? IdentifierFactory.postfix(sole)
+                : (() => {
+                    importer.use("join");
+                    return `$join(key)`;
+                  })()
+              : "",
+          },
         }),
       };
     });

package/src/programmers/json/JsonStringifyProgrammer.ts

@@ -100,9 +100,11 @@ export namespace JsonStringifyProgrammer {
           ts.factory.createArrowFunction(
             undefined,
             undefined,
-            FeatureProgrammer.parameterDeclarations(props.config)(
-              TypeFactory.keyword("any"),
-            )(ts.factory.createIdentifier("input")),
+            FeatureProgrammer.parameterDeclarations({
+              config: props.config,
+              type: TypeFactory.keyword("any"),
+              input: ts.factory.createIdentifier("input"),
+            }),
             TypeFactory.keyword("any"),
             undefined,
             decode_array_inline({
@@ -139,9 +141,11 @@ export namespace JsonStringifyProgrammer {
           ts.factory.createArrowFunction(
             undefined,
             undefined,
-            FeatureProgrammer.parameterDeclarations(props.config)(
-              TypeFactory.keyword("any"),
-            )(ts.factory.createIdentifier("input")),
+            FeatureProgrammer.parameterDeclarations({
+              config: props.config,
+              type: TypeFactory.keyword("any"),
+              input: ts.factory.createIdentifier("input"),
+            }),
             TypeFactory.keyword("any"),
             undefined,
             decode_tuple_inline({
@@ -520,10 +524,16 @@ export namespace JsonStringifyProgrammer {
     explore: FeatureProgrammer.IExplore;
   }): ts.CallExpression =>
     FeatureProgrammer.decode_object({
-      trace: false,
-      path: false,
-      prefix: PREFIX,
-    })(props.importer)(props.input, props.object, props.explore);
+      config: {
+        trace: false,
+        path: false,
+        prefix: PREFIX,
+      },
+      importer: props.importer,
+      object: props.object,
+      input: props.input,
+      explore: props.explore,
+    });
 
   const decode_array = (props: {
     config: FeatureProgrammer.IConfig;
@@ -540,11 +550,15 @@ export namespace JsonStringifyProgrammer {
             ),
           ),
           undefined,
-          FeatureProgrammer.argumentsArray(props.config)({
-            ...props.explore,
-            source: "function",
-            from: "array",
-          })(props.input),
+          FeatureProgrammer.argumentsArray({
+            config: props.config,
+            input: props.input,
+            explore: {
+              ...props.explore,
+              source: "function",
+              from: "array",
+            },
+          }),
         )
       : decode_array_inline(props);
 
@@ -555,9 +569,14 @@ export namespace JsonStringifyProgrammer {
     array: MetadataArray;
     explore: FeatureProgrammer.IExplore;
   }) =>
-    FeatureProgrammer.decode_array(props.config)(props.importer)(
-      StringifyJoiner.array,
-    )(props.input, props.array, props.explore);
+    FeatureProgrammer.decode_array({
+      config: props.config,
+      importer: props.importer,
+      combiner: StringifyJoiner.array,
+      array: props.array,
+      input: props.input,
+      explore: props.explore,
+    });
 
   const decode_tuple = (props: {
     context: ITypiaContext;
@@ -575,10 +594,14 @@ export namespace JsonStringifyProgrammer {
             ),
           ),
           undefined,
-          FeatureProgrammer.argumentsArray(props.config)({
-            ...props.explore,
-            source: "function",
-          })(props.input),
+          FeatureProgrammer.argumentsArray({
+            config: props.config,
+            explore: {
+              ...props.explore,
+              source: "function",
+            },
+            input: props.input,
+          }),
         )
       : decode_tuple_inline({
           ...props,
@@ -738,9 +761,7 @@ export namespace JsonStringifyProgrammer {
             props.importer.useLocal(`${PREFIX}u${props.metadata.union_index!}`),
           ),
           undefined,
-          FeatureProgrammer.argumentsArray(props.config)(props.explore)(
-            props.input,
-          ),
+          FeatureProgrammer.argumentsArray(props),
         );
 
   const explore_arrays = (props: {
@@ -832,9 +853,11 @@ export namespace JsonStringifyProgrammer {
           props.elements.map((e) => e.type.name).join(" | "),
           () =>
             arrow({
-              parameters: FeatureProgrammer.parameterDeclarations(props.config)(
-                TypeFactory.keyword("any"),
-              )(ts.factory.createIdentifier("input")),
+              parameters: FeatureProgrammer.parameterDeclarations({
+                config: props.config,
+                type: TypeFactory.keyword("any"),
+                input: ts.factory.createIdentifier("input"),
+              }),
               explore: {
                 ...arrayExplore,
                 postfix: "",
@@ -844,7 +867,11 @@ export namespace JsonStringifyProgrammer {
         ),
       ),
       undefined,
-      FeatureProgrammer.argumentsArray(props.config)(arrayExplore)(props.input),
+      FeatureProgrammer.argumentsArray({
+        config: props.config,
+        explore: arrayExplore,
+        input: props.input,
+      }),
     );
   };
 
@@ -947,73 +974,74 @@ export namespace JsonStringifyProgrammer {
       trace: false,
       path: false,
       initializer,
-      decoder: () => (input, metadata, explore) =>
+      decoder: (next) =>
         decode({
           context: props.context,
           importer: props.importer,
           config,
-          input,
-          metadata,
-          explore,
+          metadata: next.metadata,
+          input: next.input,
+          explore: next.explore,
         }),
       objector: {
-        checker: () => (input, metadata, explore) =>
+        checker: (next) =>
           IsProgrammer.decode({
             context: props.context,
             importer: props.importer,
-            metadata,
-            input,
-            explore,
+            metadata: next.metadata,
+            input: next.input,
+            explore: next.explore,
           }),
-        decoder: () => (input, object, explore) =>
+        decoder: (next) =>
           decode_object({
             importer: props.importer,
-            input,
-            object,
-            explore,
+            input: next.input,
+            object: next.object,
+            explore: next.explore,
           }),
         joiner: (next) =>
           StringifyJoiner.object({
             ...next,
             importer: props.importer,
           }),
-        unionizer: decode_union_object((input, object, explore) =>
-          IsProgrammer.decode_object({
-            context: props.context,
-            importer: props.importer,
-            input,
-            object,
-            explore,
-          }),
-        )((input, object, explore) =>
-          decode_object({
-            importer: props.importer,
-            input,
-            object,
-            explore,
-          }),
-        )((exp) => exp)((input, expected) =>
-          create_throw_error({
-            importer: props.importer,
-            expected,
-            input,
-          }),
-        ),
-        failure: (input, expected) =>
+        unionizer: (next) =>
+          decode_union_object((input, object, explore) =>
+            IsProgrammer.decode_object({
+              context: props.context,
+              importer: props.importer,
+              input,
+              object,
+              explore,
+            }),
+          )((input, object, explore) =>
+            decode_object({
+              importer: props.importer,
+              input,
+              object,
+              explore,
+            }),
+          )((exp) => exp)((input, expected) =>
+            create_throw_error({
+              importer: props.importer,
+              expected,
+              input,
+            }),
+          )(next.input, next.objects, next.explore),
+        failure: (next) =>
           create_throw_error({
             importer: props.importer,
-            expected,
-            input,
+            expected: next.expected,
+            input: next.input,
           }),
       },
       generator: {
-        arrays: () => (collection) =>
+        arrays: (collection) =>
           write_array_functions({
             config,
             importer: props.importer,
             collection,
           }),
-        tuples: () => (collection) =>
+        tuples: (collection) =>
           write_tuple_functions({
             config,
             context: props.context,
@@ -1025,14 +1053,13 @@ export namespace JsonStringifyProgrammer {
     return config;
   };
 
-  const initializer: FeatureProgrammer.IConfig["initializer"] =
-    (context) => (importer) => (type) =>
-      JsonMetadataFactory.analyze({
-        method: `typia.json.${importer.method}`,
-        checker: context.checker,
-        transformer: context.transformer,
-        type,
-      });
+  const initializer: FeatureProgrammer.IConfig["initializer"] = (props) =>
+    JsonMetadataFactory.analyze({
+      method: `typia.json.${props.importer.method}`,
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      type: props.type,
+    });
 
   const create_throw_error = (props: {
     importer: FunctionImporter;