typia 7.0.0-dev.20240922 → 7.0.0-dev.20240924

package/src/programmers/json/JsonStringifyProgrammer.ts

@@ -11,6 +11,7 @@ import { ValueFactory } from "../../factories/ValueFactory";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
 import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
@@ -19,8 +20,6 @@ import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { Atomic } from "../../typings/Atomic";
 
-import { ArrayUtil } from "../../utils/ArrayUtil";
-
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { IsProgrammer } from "../IsProgrammer";
 import { AtomicPredicator } from "../helpers/AtomicPredicator";
@@ -45,9 +44,7 @@ export namespace JsonStringifyProgrammer {
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
-    const config: FeatureProgrammer.IConfig = configure(props.context)(
-      props.importer,
-    );
+    const config: FeatureProgrammer.IConfig = configure(props);
     if (props.validated === false)
       config.addition = (collection) =>
         IsProgrammer.write_function_statements(props.context)(props.importer)(
@@ -87,589 +84,631 @@ export namespace JsonStringifyProgrammer {
     });
   };
 
-  const write_array_functions =
-    (config: FeatureProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    (collection: MetadataCollection): ts.VariableStatement[] =>
-      collection
-        .arrays()
-        .filter((a) => a.recursive)
-        .map((type, i) =>
-          StatementFactory.constant(
-            `${config.prefix}a${i}`,
-            ts.factory.createArrowFunction(
-              undefined,
-              undefined,
-              FeatureProgrammer.parameterDeclarations(config)(
-                TypeFactory.keyword("any"),
-              )(ts.factory.createIdentifier("input")),
+  const write_array_functions = (props: {
+    config: FeatureProgrammer.IConfig;
+    importer: FunctionImporter;
+    collection: MetadataCollection;
+  }): ts.VariableStatement[] =>
+    props.collection
+      .arrays()
+      .filter((a) => a.recursive)
+      .map((type, i) =>
+        StatementFactory.constant(
+          `${props.config.prefix}a${i}`,
+          ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            FeatureProgrammer.parameterDeclarations(props.config)(
               TypeFactory.keyword("any"),
-              undefined,
-              decode_array_inline(config)(importer)(
-                ts.factory.createIdentifier("input"),
-                MetadataArray.create({
-                  type,
-                  tags: [],
-                }),
-                {
-                  tracable: config.trace,
-                  source: "function",
-                  from: "array",
-                  postfix: "",
-                },
-              ),
-            ),
+            )(ts.factory.createIdentifier("input")),
+            TypeFactory.keyword("any"),
+            undefined,
+            decode_array_inline({
+              config: props.config,
+              importer: props.importer,
+              input: ts.factory.createIdentifier("input"),
+              array: MetadataArray.create({
+                type,
+                tags: [],
+              }),
+              explore: {
+                tracable: props.config.trace,
+                source: "function",
+                from: "array",
+                postfix: "",
+              },
+            }),
           ),
-        );
+        ),
+      );
 
-  const write_tuple_functions =
-    (project: ITypiaContext) =>
-    (config: FeatureProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    (collection: MetadataCollection): ts.VariableStatement[] =>
-      collection
-        .tuples()
-        .filter((t) => t.recursive)
-        .map((tuple, i) =>
-          StatementFactory.constant(
-            `${config.prefix}t${i}`,
-            ts.factory.createArrowFunction(
-              undefined,
-              undefined,
-              FeatureProgrammer.parameterDeclarations(config)(
-                TypeFactory.keyword("any"),
-              )(ts.factory.createIdentifier("input")),
+  const write_tuple_functions = (props: {
+    context: ITypiaContext;
+    config: FeatureProgrammer.IConfig;
+    importer: FunctionImporter;
+    collection: MetadataCollection;
+  }): ts.VariableStatement[] =>
+    props.collection
+      .tuples()
+      .filter((t) => t.recursive)
+      .map((tuple, i) =>
+        StatementFactory.constant(
+          `${props.config.prefix}t${i}`,
+          ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            FeatureProgrammer.parameterDeclarations(props.config)(
               TypeFactory.keyword("any"),
-              undefined,
-              decode_tuple_inline(project)(config)(importer)(
-                ts.factory.createIdentifier("input"),
-                tuple,
-                {
-                  tracable: config.trace,
-                  source: "function",
-                  from: "array",
-                  postfix: "",
-                },
-              ),
-            ),
+            )(ts.factory.createIdentifier("input")),
+            TypeFactory.keyword("any"),
+            undefined,
+            decode_tuple_inline({
+              context: props.context,
+              config: props.config,
+              importer: props.importer,
+              input: ts.factory.createIdentifier("input"),
+              tuple,
+              explore: {
+                tracable: props.config.trace,
+                source: "function",
+                from: "array",
+                postfix: "",
+              },
+            }),
           ),
-        );
+        ),
+      );
 
   /* -----------------------------------------------------------
     DECODERS
   ----------------------------------------------------------- */
-  const decode =
-    (project: ITypiaContext) =>
-    (config: FeatureProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      metadata: Metadata,
-      explore: FeatureProgrammer.IExplore,
-    ): ts.Expression => {
-      // ANY TYPE
-      if (metadata.any === true)
-        return wrap_required(
-          input,
-          metadata,
-          explore,
-        )(
-          wrap_functional({
-            input,
-            metadata,
-            explore,
-            expression: ts.factory.createCallExpression(
-              ts.factory.createIdentifier("JSON.stringify"),
+  const decode = (props: {
+    context: ITypiaContext;
+    config: FeatureProgrammer.IConfig;
+    importer: FunctionImporter;
+    input: ts.Expression;
+    metadata: Metadata;
+    explore: FeatureProgrammer.IExplore;
+  }): ts.Expression => {
+    // ANY TYPE
+    if (props.metadata.any === true)
+      return wrap_required({
+        input: props.input,
+        metadata: props.metadata,
+        explore: props.explore,
+        expression: wrap_functional({
+          input: props.input,
+          metadata: props.metadata,
+          explore: props.explore,
+          expression: ts.factory.createCallExpression(
+            ts.factory.createIdentifier("JSON.stringify"),
+            undefined,
+            [props.input],
+          ),
+        }),
+      });
+
+    // ONLY NULL OR UNDEFINED
+    const size: number = props.metadata.size();
+    if (
+      size === 0 &&
+      (props.metadata.isRequired() === false ||
+        props.metadata.nullable === true)
+    ) {
+      if (
+        props.metadata.isRequired() === false &&
+        props.metadata.nullable === true
+      )
+        return props.explore.from === "array"
+          ? ts.factory.createStringLiteral("null")
+          : ts.factory.createConditionalExpression(
+              ts.factory.createStrictEquality(
+                ts.factory.createNull(),
+                props.input,
+              ),
               undefined,
-              [input],
-            ),
+              ts.factory.createStringLiteral("null"),
+              undefined,
+              ts.factory.createIdentifier("undefined"),
+            );
+      else if (props.metadata.isRequired() === false)
+        return props.explore.from === "array"
+          ? ts.factory.createStringLiteral("null")
+          : ts.factory.createIdentifier("undefined");
+      else return ts.factory.createStringLiteral("null");
+    }
+
+    //----
+    // LIST UP UNION TYPES
+    //----
+    const unions: IUnion[] = [];
+
+    // toJSON() METHOD
+    if (props.metadata.escaped !== null)
+      unions.push({
+        type: "resolved",
+        is:
+          props.metadata.escaped.original.size() === 1 &&
+          props.metadata.escaped.original.natives[0] === "Date"
+            ? () => check_native("Date")(props.input)
+            : () => IsProgrammer.decode_to_json(false)(props.input),
+        value: () =>
+          decode_to_json({
+            ...props,
+            metadata: props.metadata.escaped!.returns,
           }),
-        );
+      });
+    else if (props.metadata.functions.length)
+      unions.push({
+        type: "functional",
+        is: () => IsProgrammer.decode_functional(props.input),
+        value: () => decode_functional(props.explore),
+      });
 
-      // ONLY NULL OR UNDEFINED
-      const size: number = metadata.size();
-      if (
-        size === 0 &&
-        (metadata.isRequired() === false || metadata.nullable === true)
-      ) {
-        if (metadata.isRequired() === false && metadata.nullable === true)
-          return explore.from === "array"
-            ? ts.factory.createStringLiteral("null")
-            : ts.factory.createConditionalExpression(
-                ts.factory.createStrictEquality(ts.factory.createNull(), input),
-                undefined,
-                ts.factory.createStringLiteral("null"),
-                undefined,
-                ts.factory.createIdentifier("undefined"),
-              );
-        else if (metadata.isRequired() === false)
-          return explore.from === "array"
-            ? ts.factory.createStringLiteral("null")
-            : ts.factory.createIdentifier("undefined");
-        else return ts.factory.createStringLiteral("null");
+    // TEMPLATES
+    if (props.metadata.templates.length)
+      if (AtomicPredicator.template(props.metadata)) {
+        const partial = Metadata.initialize();
+        partial.atomics.push(
+          MetadataAtomic.create({ type: "string", tags: [] }),
+        ),
+          unions.push({
+            type: "template literal",
+            is: () =>
+              IsProgrammer.decode(props.context)(props.importer)(
+                props.input,
+                partial,
+                props.explore,
+              ),
+            value: () =>
+              decode_atomic({
+                ...props,
+                type: "string",
+              }),
+          });
       }
 
-      //----
-      // LIST UP UNION TYPES
-      //----
-      const unions: IUnion[] = [];
-
-      // toJSON() METHOD
-      if (metadata.escaped !== null)
+    // CONSTANTS
+    for (const constant of props.metadata.constants)
+      if (
+        AtomicPredicator.constant({
+          metadata: props.metadata,
+          name: constant.type,
+        }) === false
+      )
+        continue;
+      else if (constant.type !== "string")
         unions.push({
-          type: "resolved",
-          is:
-            metadata.escaped.original.size() === 1 &&
-            metadata.escaped.original.natives[0] === "Date"
-              ? () => check_native("Date")(input)
-              : () => IsProgrammer.decode_to_json(false)(input),
-          value: () =>
-            decode_to_json(project)(config)(importer)(
-              input,
-              metadata.escaped!.returns,
-              explore,
+          type: "atomic",
+          is: () =>
+            IsProgrammer.decode(props.context)(props.importer)(
+              props.input,
+              (() => {
+                const partial = Metadata.initialize();
+                partial.atomics.push(
+                  MetadataAtomic.create({
+                    type: constant.type,
+                    tags: [],
+                  }),
+                );
+                return partial;
+              })(),
+              props.explore,
             ),
+          value: () =>
+            decode_atomic({
+              ...props,
+              type: constant.type,
+            }),
         });
-      else if (metadata.functions.length)
+      else if (props.metadata.templates.length === 0)
         unions.push({
-          type: "functional",
-          is: () => IsProgrammer.decode_functional(input),
-          value: () => decode_functional(explore),
+          type: "const string",
+          is: () =>
+            IsProgrammer.decode(props.context)(props.importer)(
+              props.input,
+              (() => {
+                const partial = Metadata.initialize();
+                partial.atomics.push(
+                  MetadataAtomic.create({
+                    type: "string",
+                    tags: [],
+                  }),
+                );
+                return partial;
+              })(),
+              props.explore,
+            ),
+          value: () =>
+            decode_constant_string({
+              ...props,
+              values: [...constant.values.map((v) => v.value)] as string[],
+            }),
         });
 
-      // TEMPLATES
+    /// ATOMICS
+    for (const a of props.metadata.atomics)
       if (
-        metadata.templates.length ||
-        ArrayUtil.has(metadata.constants, (c) => c.type === "string")
+        AtomicPredicator.atomic({
+          metadata: props.metadata,
+          name: a.type,
+        })
       )
-        if (AtomicPredicator.template(metadata)) {
-          const partial = Metadata.initialize();
-          partial.atomics.push(
-            MetadataAtomic.create({ type: "string", tags: [] }),
-          ),
-            unions.push({
-              type: "template literal",
-              is: () =>
-                IsProgrammer.decode(project)(importer)(input, partial, explore),
-              value: () =>
-                decode_atomic(project)(importer)(input, "string", explore),
-            });
-        }
-
-      // CONSTANTS
-      for (const constant of metadata.constants)
-        if (
-          AtomicPredicator.constant({
-            metadata,
-            name: constant.type,
-          }) === false
-        )
-          continue;
-        else if (constant.type !== "string")
-          unions.push({
-            type: "atomic",
-            is: () =>
-              IsProgrammer.decode(project)(importer)(
-                input,
-                (() => {
-                  const partial = Metadata.initialize();
-                  partial.atomics.push(
-                    MetadataAtomic.create({
-                      type: constant.type,
-                      tags: [],
-                    }),
-                  );
-                  return partial;
-                })(),
-                explore,
-              ),
-            value: () =>
-              decode_atomic(project)(importer)(input, constant.type, explore),
-          });
-        else if (metadata.templates.length === 0)
-          unions.push({
-            type: "const string",
-            is: () =>
-              IsProgrammer.decode(project)(importer)(
-                input,
-                (() => {
-                  const partial = Metadata.initialize();
-                  partial.atomics.push(
-                    MetadataAtomic.create({
-                      type: "string",
-                      tags: [],
-                    }),
-                  );
-                  return partial;
-                })(),
-                explore,
-              ),
-            value: () =>
-              decode_constant_string(project)(importer)(
-                input,
-                [...constant.values.map((v) => v.value)] as string[],
-                explore,
-              ),
-          });
-
-      /// ATOMICS
-      for (const a of metadata.atomics)
-        if (
-          AtomicPredicator.atomic({
-            metadata,
-            name: a.type,
-          })
-        )
-          unions.push({
-            type: "atomic",
-            is: () =>
-              IsProgrammer.decode(project)(importer)(
-                input,
-                (() => {
-                  const partial = Metadata.initialize();
-                  partial.atomics.push(a);
-                  return partial;
-                })(),
-                explore,
-              ),
-            value: () =>
-              decode_atomic(project)(importer)(input, a.type, explore),
-          });
-
-      // TUPLES
-      for (const tuple of metadata.tuples)
         unions.push({
-          type: "tuple",
+          type: "atomic",
           is: () =>
-            IsProgrammer.decode(project)(importer)(
-              input,
+            IsProgrammer.decode(props.context)(props.importer)(
+              props.input,
               (() => {
                 const partial = Metadata.initialize();
-                partial.tuples.push(tuple);
+                partial.atomics.push(a);
                 return partial;
               })(),
-              explore,
+              props.explore,
             ),
           value: () =>
-            decode_tuple(project)(config)(importer)(input, tuple, explore),
+            decode_atomic({
+              ...props,
+              type: a.type,
+            }),
         });
 
-      // ARRAYS
-      if (metadata.arrays.length) {
-        const value: () => ts.Expression =
-          metadata.arrays.length === 1
-            ? () =>
-                decode_array(config)(importer)(input, metadata.arrays[0]!, {
-                  ...explore,
-                  from: "array",
-                })
-            : metadata.arrays.some((elem) => elem.type.value.any)
-              ? () =>
-                  ts.factory.createCallExpression(
-                    ts.factory.createIdentifier("JSON.stringify"),
-                    undefined,
-                    [input],
-                  )
-              : () =>
-                  explore_arrays(project)(config)(importer)(
-                    input,
-                    metadata.arrays,
-                    {
-                      ...explore,
-                      from: "array",
-                    },
-                  );
+    // TUPLES
+    for (const tuple of props.metadata.tuples)
+      unions.push({
+        type: "tuple",
+        is: () =>
+          IsProgrammer.decode(props.context)(props.importer)(
+            props.input,
+            (() => {
+              const partial = Metadata.initialize();
+              partial.tuples.push(tuple);
+              return partial;
+            })(),
+            props.explore,
+          ),
+        value: () =>
+          decode_tuple({
+            ...props,
+            tuple,
+          }),
+      });
 
-        unions.push({
-          type: "array",
-          is: () => ExpressionFactory.isArray(input),
-          value,
-        });
-      }
+    // ARRAYS
+    if (props.metadata.arrays.length) {
+      const value: () => ts.Expression =
+        props.metadata.arrays.length === 1
+          ? () =>
+              decode_array({
+                ...props,
+                array: props.metadata.arrays[0]!,
+                explore: {
+                  ...props.explore,
+                  from: "array",
+                },
+              })
+          : props.metadata.arrays.some((elem) => elem.type.value.any)
+            ? () =>
+                ts.factory.createCallExpression(
+                  ts.factory.createIdentifier("JSON.stringify"),
+                  undefined,
+                  [props.input],
+                )
+            : () =>
+                explore_arrays({
+                  ...props,
+                  arrays: props.metadata.arrays,
+                  explore: {
+                    ...props.explore,
+                    from: "array",
+                  },
+                });
 
-      // BUILT-IN CLASSES
-      if (metadata.natives.length)
-        for (const native of metadata.natives)
-          unions.push({
-            type: "object",
-            is: () => check_native(native)(input),
-            value: () =>
-              AtomicPredicator.native(native)
-                ? decode_atomic(project)(importer)(
-                    input,
-                    native.toLowerCase() as Atomic.Literal,
-                    explore,
-                  )
-                : ts.factory.createStringLiteral("{}"),
-          });
+      unions.push({
+        type: "array",
+        is: () => ExpressionFactory.isArray(props.input),
+        value,
+      });
+    }
 
-      // SETS
-      if (metadata.sets.length)
+    // BUILT-IN CLASSES
+    if (props.metadata.natives.length)
+      for (const native of props.metadata.natives)
         unions.push({
           type: "object",
-          is: () => ExpressionFactory.isInstanceOf("Set")(input),
-          value: () => ts.factory.createStringLiteral("{}"),
+          is: () => check_native(native)(props.input),
+          value: () =>
+            AtomicPredicator.native(native)
+              ? decode_atomic({
+                  ...props,
+                  type: native.toLowerCase() as Atomic.Literal,
+                })
+              : ts.factory.createStringLiteral("{}"),
         });
 
-      // MAPS
-      if (metadata.maps.length)
-        unions.push({
-          type: "object",
-          is: () => ExpressionFactory.isInstanceOf("Map")(input),
-          value: () => ts.factory.createStringLiteral("{}"),
-        });
+    // SETS
+    if (props.metadata.sets.length)
+      unions.push({
+        type: "object",
+        is: () => ExpressionFactory.isInstanceOf("Set")(props.input),
+        value: () => ts.factory.createStringLiteral("{}"),
+      });
 
-      // OBJECTS
-      if (metadata.objects.length)
-        unions.push({
-          type: "object",
-          is: () =>
-            ExpressionFactory.isObject({
-              checkNull: true,
-              checkArray: metadata.objects.some((obj) =>
-                obj.properties.every(
-                  (prop) =>
-                    !prop.key.isSoleLiteral() || !prop.value.isRequired(),
-                ),
+    // MAPS
+    if (props.metadata.maps.length)
+      unions.push({
+        type: "object",
+        is: () => ExpressionFactory.isInstanceOf("Map")(props.input),
+        value: () => ts.factory.createStringLiteral("{}"),
+      });
+
+    // OBJECTS
+    if (props.metadata.objects.length)
+      unions.push({
+        type: "object",
+        is: () =>
+          ExpressionFactory.isObject({
+            checkNull: true,
+            checkArray: props.metadata.objects.some((objects) =>
+              objects.properties.every(
+                (prop) => !prop.key.isSoleLiteral() || !prop.value.isRequired(),
               ),
-            })(input),
-          value: () =>
-            explore_objects(config)(importer)(input, metadata, {
-              ...explore,
+            ),
+          })(props.input),
+        value: () =>
+          explore_objects({
+            ...props,
+            explore: {
+              ...props.explore,
               from: "object",
-            }),
-        });
+            },
+          }),
+      });
 
-      //----
-      // RETURNS
-      //----
-      // CHECK NULL AND UNDEFINED
-      const wrapper = (output: ts.Expression) =>
-        wrap_required(
-          input,
-          metadata,
-          explore,
-        )(wrap_nullable(input, metadata)(output));
+    //----
+    // RETURNS
+    //----
+    // CHECK NULL AND UNDEFINED
+    const wrapper = (output: ts.Expression) =>
+      wrap_required({
+        input: props.input,
+        metadata: props.metadata,
+        explore: props.explore,
+        expression: wrap_nullable({
+          input: props.input,
+          metadata: props.metadata,
+          expression: output,
+        }),
+      });
 
-      // DIRECT RETURN
-      if (unions.length === 0)
-        return ts.factory.createCallExpression(
-          ts.factory.createIdentifier("JSON.stringify"),
-          undefined,
-          [input],
-        );
-      else if (unions.length === 1) return wrapper(unions[0]!.value());
+    // DIRECT RETURN
+    if (unions.length === 0)
+      return ts.factory.createCallExpression(
+        ts.factory.createIdentifier("JSON.stringify"),
+        undefined,
+        [props.input],
+      );
+    else if (unions.length === 1) return wrapper(unions[0]!.value());
 
-      // RETURN WITH TYPE CHECKING
-      return wrapper(
-        ts.factory.createCallExpression(
-          ts.factory.createArrowFunction(
-            undefined,
-            undefined,
-            [],
-            undefined,
-            undefined,
-            iterate({
-              importer,
-              input,
-              unions,
-              expected: metadata.getName(),
-            }),
-          ),
+    // RETURN WITH TYPE CHECKING
+    return wrapper(
+      ts.factory.createCallExpression(
+        ts.factory.createArrowFunction(
+          undefined,
+          undefined,
+          [],
           undefined,
           undefined,
+          iterate({
+            importer: props.importer,
+            input: props.input,
+            expected: props.metadata.getName(),
+            unions,
+          }),
         ),
-      );
-    };
+        undefined,
+        undefined,
+      ),
+    );
+  };
 
-  const decode_object = (importer: FunctionImporter) =>
+  const decode_object = (props: {
+    importer: FunctionImporter;
+    input: ts.Expression;
+    object: MetadataObject;
+    explore: FeatureProgrammer.IExplore;
+  }): ts.CallExpression =>
     FeatureProgrammer.decode_object({
       trace: false,
       path: false,
       prefix: PREFIX,
-    })(importer);
-
-  const decode_array =
-    (config: FeatureProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      array: MetadataArray,
-      explore: FeatureProgrammer.IExplore,
-    ) =>
-      array.type.recursive
-        ? ts.factory.createCallExpression(
-            ts.factory.createIdentifier(
-              importer.useLocal(`${config.prefix}a${array.type.index}`),
-            ),
-            undefined,
-            FeatureProgrammer.argumentsArray(config)({
-              ...explore,
-              source: "function",
-              from: "array",
-            })(input),
-          )
-        : decode_array_inline(config)(importer)(input, array, explore);
-
-  const decode_array_inline =
-    (config: FeatureProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      array: MetadataArray,
-      explore: FeatureProgrammer.IExplore,
-    ) =>
-      FeatureProgrammer.decode_array(config)(importer)(StringifyJoiner.array)(
-        input,
-        array,
-        explore,
-      );
+    })(props.importer)(props.input, props.object, props.explore);
 
-  const decode_tuple =
-    (project: ITypiaContext) =>
-    (config: FeatureProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      tuple: MetadataTuple,
-      explore: FeatureProgrammer.IExplore,
-    ): ts.Expression =>
-      tuple.type.recursive
-        ? ts.factory.createCallExpression(
-            ts.factory.createIdentifier(
-              importer.useLocal(`${config.prefix}t${tuple.type.index}`),
+  const decode_array = (props: {
+    config: FeatureProgrammer.IConfig;
+    importer: FunctionImporter;
+    input: ts.Expression;
+    array: MetadataArray;
+    explore: FeatureProgrammer.IExplore;
+  }) =>
+    props.array.type.recursive
+      ? ts.factory.createCallExpression(
+          ts.factory.createIdentifier(
+            props.importer.useLocal(
+              `${props.config.prefix}a${props.array.type.index}`,
             ),
-            undefined,
-            FeatureProgrammer.argumentsArray(config)({
-              ...explore,
-              source: "function",
-            })(input),
-          )
-        : decode_tuple_inline(project)(config)(importer)(
-            input,
-            tuple.type,
-            explore,
-          );
-
-  const decode_tuple_inline =
-    (project: ITypiaContext) =>
-    (config: FeatureProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      tuple: MetadataTupleType,
-      explore: FeatureProgrammer.IExplore,
-    ): ts.Expression => {
-      const elements: ts.Expression[] = tuple.elements
-        .filter((elem) => elem.rest === null)
-        .map((elem, index) =>
-          decode(project)(config)(importer)(
-            ts.factory.createElementAccessExpression(input, index),
-            elem,
-            {
-              ...explore,
-              from: "array",
-              postfix: explore.postfix.length
-                ? `${postfix_of_tuple(explore.postfix)}[${index}]"`
-                : `"[${index}]"`,
-            },
           ),
-        );
-      const rest = (() => {
-        if (tuple.elements.length === 0) return null;
-        const last = tuple.elements.at(-1)!;
-        if (last.rest === null) return null;
-
-        const code = decode(project)(config)(importer)(
-          ts.factory.createCallExpression(
-            IdentifierFactory.access(input)("slice"),
-            undefined,
-            [ExpressionFactory.number(tuple.elements.length - 1)],
+          undefined,
+          FeatureProgrammer.argumentsArray(props.config)({
+            ...props.explore,
+            source: "function",
+            from: "array",
+          })(props.input),
+        )
+      : decode_array_inline(props);
+
+  const decode_array_inline = (props: {
+    config: FeatureProgrammer.IConfig;
+    importer: FunctionImporter;
+    input: ts.Expression;
+    array: MetadataArray;
+    explore: FeatureProgrammer.IExplore;
+  }) =>
+    FeatureProgrammer.decode_array(props.config)(props.importer)(
+      StringifyJoiner.array,
+    )(props.input, props.array, props.explore);
+
+  const decode_tuple = (props: {
+    context: ITypiaContext;
+    config: FeatureProgrammer.IConfig;
+    importer: FunctionImporter;
+    input: ts.Expression;
+    tuple: MetadataTuple;
+    explore: FeatureProgrammer.IExplore;
+  }): ts.Expression =>
+    props.tuple.type.recursive
+      ? ts.factory.createCallExpression(
+          ts.factory.createIdentifier(
+            props.importer.useLocal(
+              `${props.config.prefix}t${props.tuple.type.index}`,
+            ),
           ),
-          wrap_metadata_rest_tuple(tuple.elements.at(-1)!.rest!),
-          {
-            ...explore,
-            start: tuple.elements.length - 1,
+          undefined,
+          FeatureProgrammer.argumentsArray(props.config)({
+            ...props.explore,
+            source: "function",
+          })(props.input),
+        )
+      : decode_tuple_inline({
+          ...props,
+          tuple: props.tuple.type,
+        });
+
+  const decode_tuple_inline = (props: {
+    context: ITypiaContext;
+    config: FeatureProgrammer.IConfig;
+    importer: FunctionImporter;
+    input: ts.Expression;
+    tuple: MetadataTupleType;
+    explore: FeatureProgrammer.IExplore;
+  }): ts.Expression => {
+    const elements: ts.Expression[] = props.tuple.elements
+      .filter((elem) => elem.rest === null)
+      .map((elem, index) =>
+        decode({
+          ...props,
+          input: ts.factory.createElementAccessExpression(props.input, index),
+          metadata: elem,
+          explore: {
+            ...props.explore,
+            from: "array",
+            postfix: props.explore.postfix.length
+              ? `${postfix_of_tuple(props.explore.postfix)}[${index}]"`
+              : `"[${index}]"`,
           },
-        );
-        return ts.factory.createCallExpression(
-          importer.use("rest"),
+        }),
+      );
+    const rest = (() => {
+      if (props.tuple.elements.length === 0) return null;
+      const last = props.tuple.elements.at(-1)!;
+      if (last.rest === null) return null;
+
+      const code = decode({
+        ...props,
+        input: ts.factory.createCallExpression(
+          IdentifierFactory.access(props.input)("slice"),
           undefined,
-          [code],
-        );
-      })();
-      return StringifyJoiner.tuple({
-        elements,
-        rest,
+          [ExpressionFactory.number(props.tuple.elements.length - 1)],
+        ),
+        metadata: wrap_metadata_rest_tuple(props.tuple.elements.at(-1)!.rest!),
+        explore: {
+          ...props.explore,
+          start: props.tuple.elements.length - 1,
+        },
       });
-    };
+      return ts.factory.createCallExpression(
+        props.importer.use("rest"),
+        undefined,
+        [code],
+      );
+    })();
+    return StringifyJoiner.tuple({
+      elements,
+      rest,
+    });
+  };
 
-  const decode_atomic =
-    (project: ITypiaContext) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      type: string,
-      explore: FeatureProgrammer.IExplore,
-    ) => {
-      if (type === "string")
-        return ts.factory.createCallExpression(
-          importer.use("string"),
+  const decode_atomic = (props: {
+    context: ITypiaContext;
+    importer: FunctionImporter;
+    input: ts.Expression;
+    type: string;
+    explore: FeatureProgrammer.IExplore;
+  }): ts.Expression => {
+    if (props.type === "string")
+      return ts.factory.createCallExpression(
+        props.importer.use("string"),
+        undefined,
+        [props.input],
+      );
+    else if (
+      props.type === "number" &&
+      OptionPredicator.numeric(props.context.options)
+    )
+      props = {
+        ...props,
+        input: ts.factory.createCallExpression(
+          props.importer.use("number"),
+          undefined,
+          [props.input],
+        ),
+      };
+
+    return props.explore.from !== "top"
+      ? props.input
+      : ts.factory.createCallExpression(
+          IdentifierFactory.access(props.input)("toString"),
           undefined,
-          [input],
-        );
-      else if (type === "number" && OptionPredicator.numeric(project.options))
-        input = ts.factory.createCallExpression(
-          importer.use("number"),
           undefined,
-          [input],
         );
+  };
 
-      return explore.from !== "top"
-        ? input
-        : ts.factory.createCallExpression(
-            IdentifierFactory.access(input)("toString"),
-            undefined,
-            undefined,
-          );
-    };
-
-  const decode_constant_string =
-    (project: ITypiaContext) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      values: string[],
-      explore: FeatureProgrammer.IExplore,
-    ): ts.Expression => {
-      if (values.every((v) => !StringifyPredicator.require_escape(v)))
-        return [
-          ts.factory.createStringLiteral('"'),
-          input,
-          ts.factory.createStringLiteral('"'),
-        ].reduce((x, y) => ts.factory.createAdd(x, y));
-      else return decode_atomic(project)(importer)(input, "string", explore);
-    };
+  const decode_constant_string = (props: {
+    context: ITypiaContext;
+    importer: FunctionImporter;
+    input: ts.Expression;
+    values: string[];
+    explore: FeatureProgrammer.IExplore;
+  }): ts.Expression => {
+    if (props.values.every((v) => !StringifyPredicator.require_escape(v)))
+      return [
+        ts.factory.createStringLiteral('"'),
+        props.input,
+        ts.factory.createStringLiteral('"'),
+      ].reduce((x, y) => ts.factory.createAdd(x, y));
+    return decode_atomic({
+      ...props,
+      type: "string",
+    });
+  };
 
-  const decode_to_json =
-    (project: ITypiaContext) =>
-    (config: FeatureProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      resolved: Metadata,
-      explore: FeatureProgrammer.IExplore,
-    ): ts.Expression => {
-      return decode(project)(config)(importer)(
-        ts.factory.createCallExpression(
-          IdentifierFactory.access(input)("toJSON"),
-          undefined,
-          [],
-        ),
-        resolved,
-        explore,
-      );
-    };
+  const decode_to_json = (props: {
+    context: ITypiaContext;
+    config: FeatureProgrammer.IConfig;
+    importer: FunctionImporter;
+    input: ts.Expression;
+    metadata: Metadata;
+    explore: FeatureProgrammer.IExplore;
+  }): ts.Expression => {
+    return decode({
+      ...props,
+      input: ts.factory.createCallExpression(
+        IdentifierFactory.access(props.input)("toJSON"),
+        undefined,
+        [],
+      ),
+    });
+  };
 
   const decode_functional = (explore: FeatureProgrammer.IExplore) =>
     explore.from === "array"
@@ -679,137 +718,166 @@ export namespace JsonStringifyProgrammer {
   /* -----------------------------------------------------------
     EXPLORERS
   ----------------------------------------------------------- */
-  const explore_objects =
-    (config: FeatureProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      meta: Metadata,
-      explore: FeatureProgrammer.IExplore,
-    ) =>
-      meta.objects.length === 1
-        ? decode_object(importer)(input, meta.objects[0]!, explore)
-        : ts.factory.createCallExpression(
-            ts.factory.createIdentifier(
-              importer.useLocal(`${PREFIX}u${meta.union_index!}`),
-            ),
-            undefined,
-            FeatureProgrammer.argumentsArray(config)(explore)(input),
-          );
-
-  const explore_arrays =
-    (project: ITypiaContext) =>
-    (config: FeatureProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-      input: ts.Expression,
-      elements: MetadataArray[],
-      explore: FeatureProgrammer.IExplore,
-    ): ts.Expression =>
-      explore_array_like_union_types(config)(importer)(
+  const explore_objects = (props: {
+    config: FeatureProgrammer.IConfig;
+    importer: FunctionImporter;
+    input: ts.Expression;
+    metadata: Metadata;
+    explore: FeatureProgrammer.IExplore;
+  }) =>
+    props.metadata.objects.length === 1
+      ? decode_object({
+          importer: props.importer,
+          input: props.input,
+          object: props.metadata.objects[0]!,
+          explore: props.explore,
+        })
+      : ts.factory.createCallExpression(
+          ts.factory.createIdentifier(
+            props.importer.useLocal(`${PREFIX}u${props.metadata.union_index!}`),
+          ),
+          undefined,
+          FeatureProgrammer.argumentsArray(props.config)(props.explore)(
+            props.input,
+          ),
+        );
+
+  const explore_arrays = (props: {
+    context: ITypiaContext;
+    config: FeatureProgrammer.IConfig;
+    importer: FunctionImporter;
+    input: ts.Expression;
+    arrays: MetadataArray[];
+    explore: FeatureProgrammer.IExplore;
+  }): ts.Expression =>
+    explore_array_like_union_types({
+      ...props,
+      elements: props.arrays,
+      factory: (next) =>
         UnionExplorer.array({
-          checker: IsProgrammer.decode(project)(importer),
-          decoder: decode_array(config)(importer),
+          checker: IsProgrammer.decode(props.context)(props.importer),
+          decoder: (input, array, explore) =>
+            decode_array({
+              config: props.config,
+              importer: props.importer,
+              input,
+              array,
+              explore,
+            }),
           empty: ts.factory.createStringLiteral("[]"),
           success: ts.factory.createTrue(),
           failure: (input, expected) =>
-            create_throw_error({ importer, expected, input }),
+            create_throw_error({
+              importer: props.importer,
+              expected,
+              input,
+            }),
+        })(next.parameters)(next.input, next.elements, next.explore),
+    });
+
+  const explore_array_like_union_types = <
+    T extends MetadataArray | MetadataTuple,
+  >(props: {
+    config: FeatureProgrammer.IConfig;
+    importer: FunctionImporter;
+    factory: (next: {
+      parameters: ts.ParameterDeclaration[];
+      input: ts.Expression;
+      elements: T[];
+      explore: FeatureProgrammer.IExplore;
+    }) => ts.ArrowFunction;
+    input: ts.Expression;
+    elements: T[];
+    explore: FeatureProgrammer.IExplore;
+  }): ts.Expression => {
+    const arrow = (next: {
+      parameters: ts.ParameterDeclaration[];
+      explore: FeatureProgrammer.IExplore;
+      input: ts.Expression;
+    }): ts.ArrowFunction =>
+      props.factory({
+        elements: props.elements,
+        parameters: next.parameters,
+        input: next.input,
+        explore: next.explore,
+      });
+    if (props.elements.every((e) => e.type.recursive === false))
+      ts.factory.createCallExpression(
+        arrow({
+          parameters: [],
+          explore: props.explore,
+          input: props.input,
         }),
-      )(input, elements, explore);
-
-  const explore_array_like_union_types =
-    (config: FeatureProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    <T extends MetadataArray | MetadataTuple>(
-      factory: (
-        parameters: ts.ParameterDeclaration[],
-      ) => (
-        input: ts.Expression,
-        elements: T[],
-        explore: FeatureProgrammer.IExplore,
-      ) => ts.ArrowFunction,
-    ) =>
-    (
-      input: ts.Expression,
-      elements: T[],
-      explore: FeatureProgrammer.IExplore,
-    ): ts.Expression => {
-      const arrow =
-        (parameters: ts.ParameterDeclaration[]) =>
-        (explore: FeatureProgrammer.IExplore) =>
-        (input: ts.Expression): ts.ArrowFunction =>
-          factory(parameters)(input, elements, explore);
-      if (elements.every((e) => e.type.recursive === false))
-        ts.factory.createCallExpression(
-          arrow([])(explore)(input),
-          undefined,
-          [],
-        );
+        undefined,
+        [],
+      );
 
-      explore = {
-        ...explore,
-        source: "function",
-        from: "array",
-      };
-      return ts.factory.createCallExpression(
-        ts.factory.createIdentifier(
-          importer.emplaceUnion(
-            config.prefix,
-            elements.map((e) => e.type.name).join(" | "),
-            () =>
-              arrow(
-                FeatureProgrammer.parameterDeclarations(config)(
-                  TypeFactory.keyword("any"),
-                )(ts.factory.createIdentifier("input")),
-              )({
+    const explore: FeatureProgrammer.IExplore = {
+      ...props.explore,
+      source: "function",
+      from: "array",
+    };
+    return ts.factory.createCallExpression(
+      ts.factory.createIdentifier(
+        props.importer.emplaceUnion(
+          props.config.prefix,
+          props.elements.map((e) => e.type.name).join(" | "),
+          () =>
+            arrow({
+              parameters: FeatureProgrammer.parameterDeclarations(props.config)(
+                TypeFactory.keyword("any"),
+              )(ts.factory.createIdentifier("input")),
+              explore: {
                 ...explore,
                 postfix: "",
-              })(ts.factory.createIdentifier("input")),
-          ),
+              },
+              input: ts.factory.createIdentifier("input"),
+            }),
         ),
-        undefined,
-        FeatureProgrammer.argumentsArray(config)(explore)(input),
-      );
-    };
+      ),
+      undefined,
+      FeatureProgrammer.argumentsArray(props.config)(explore)(props.input),
+    );
+  };
 
   /* -----------------------------------------------------------
     RETURN SCRIPTS
   ----------------------------------------------------------- */
-  const wrap_required = (
-    input: ts.Expression,
-    meta: Metadata,
-    explore: FeatureProgrammer.IExplore,
-  ): ((expression: ts.Expression) => ts.Expression) => {
-    if (meta.isRequired() === true && meta.any === false)
-      return (expression) => expression;
-    return (expression) =>
-      ts.factory.createConditionalExpression(
-        ts.factory.createStrictInequality(
-          ts.factory.createIdentifier("undefined"),
-          input,
-        ),
-        undefined,
-        expression,
-        undefined,
-        explore.from === "array"
-          ? ts.factory.createStringLiteral("null")
-          : ts.factory.createIdentifier("undefined"),
-      );
+  const wrap_required = (props: {
+    input: ts.Expression;
+    metadata: Metadata;
+    explore: FeatureProgrammer.IExplore;
+    expression: ts.Expression;
+  }): ts.Expression => {
+    if (props.metadata.isRequired() === true && props.metadata.any === false)
+      return props.expression;
+    return ts.factory.createConditionalExpression(
+      ts.factory.createStrictInequality(
+        ts.factory.createIdentifier("undefined"),
+        props.input,
+      ),
+      undefined,
+      props.expression,
+      undefined,
+      props.explore.from === "array"
+        ? ts.factory.createStringLiteral("null")
+        : ts.factory.createIdentifier("undefined"),
+    );
   };
 
-  const wrap_nullable = (
-    input: ts.Expression,
-    meta: Metadata,
-  ): ((expression: ts.Expression) => ts.Expression) => {
-    if (meta.nullable === false) return (expression) => expression;
-    return (expression) =>
-      ts.factory.createConditionalExpression(
-        ts.factory.createStrictInequality(ts.factory.createNull(), input),
-        undefined,
-        expression,
-        undefined,
-        ts.factory.createStringLiteral("null"),
-      );
+  const wrap_nullable = (props: {
+    input: ts.Expression;
+    metadata: Metadata;
+    expression: ts.Expression;
+  }): ts.Expression => {
+    if (props.metadata.nullable === false) return props.expression;
+    return ts.factory.createConditionalExpression(
+      ts.factory.createStrictInequality(ts.factory.createNull(), props.input),
+      undefined,
+      props.expression,
+      undefined,
+      ts.factory.createStringLiteral("null"),
+    );
   };
 
   const wrap_functional = (props: {
@@ -855,52 +923,93 @@ export namespace JsonStringifyProgrammer {
   ----------------------------------------------------------- */
   const PREFIX = "$s";
 
-  const configure =
-    (project: ITypiaContext) =>
-    (importer: FunctionImporter): FeatureProgrammer.IConfig => {
-      const config: FeatureProgrammer.IConfig<ts.Expression> = {
-        types: {
-          input: (type, name) =>
-            ts.factory.createTypeReferenceNode(
-              name ?? TypeFactory.getFullName(project.checker)(type),
-            ),
-          output: () => TypeFactory.keyword("string"),
-        },
-        prefix: PREFIX,
-        trace: false,
-        path: false,
-        initializer,
-        decoder: () => decode(project)(config)(importer),
-        objector: {
-          checker: () => IsProgrammer.decode(project)(importer),
-          decoder: () => decode_object(importer),
-          joiner: (props) =>
-            StringifyJoiner.object({
-              ...props,
-              importer,
-            }),
-          unionizer: decode_union_object(
-            IsProgrammer.decode_object(project)(importer),
-          )(decode_object(importer))((exp) => exp)((input, expected) =>
-            create_throw_error({ importer, expected, input }),
+  const configure = (props: {
+    context: ITypiaContext;
+    importer: FunctionImporter;
+  }): FeatureProgrammer.IConfig => {
+    const config: FeatureProgrammer.IConfig<ts.Expression> = {
+      types: {
+        input: (type, name) =>
+          ts.factory.createTypeReferenceNode(
+            name ?? TypeFactory.getFullName(props.context.checker)(type),
           ),
-          failure: (input, expected) =>
-            create_throw_error({ importer, expected, input }),
-        },
-        generator: {
-          arrays: () => write_array_functions(config)(importer),
-          tuples: () => write_tuple_functions(project)(config)(importer),
-        },
-      };
-      return config;
+        output: () => TypeFactory.keyword("string"),
+      },
+      prefix: PREFIX,
+      trace: false,
+      path: false,
+      initializer,
+      decoder: () => (input, metadata, explore) =>
+        decode({
+          context: props.context,
+          importer: props.importer,
+          config,
+          input,
+          metadata,
+          explore,
+        }),
+      objector: {
+        checker: () => IsProgrammer.decode(props.context)(props.importer),
+        decoder: () => (input, object, explore) =>
+          decode_object({
+            importer: props.importer,
+            input,
+            object,
+            explore,
+          }),
+        joiner: (next) =>
+          StringifyJoiner.object({
+            ...next,
+            importer: props.importer,
+          }),
+        unionizer: decode_union_object(
+          IsProgrammer.decode_object(props.context)(props.importer),
+        )((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) =>
+          create_throw_error({
+            importer: props.importer,
+            expected,
+            input,
+          }),
+      },
+      generator: {
+        arrays: () => (collection) =>
+          write_array_functions({
+            config,
+            importer: props.importer,
+            collection,
+          }),
+        tuples: () => (collection) =>
+          write_tuple_functions({
+            config,
+            context: props.context,
+            importer: props.importer,
+            collection,
+          }),
+      },
     };
+    return config;
+  };
 
   const initializer: FeatureProgrammer.IConfig["initializer"] =
-    (project) => (importer) => (type) =>
+    (context) => (importer) => (type) =>
       JsonMetadataFactory.analyze({
         method: `typia.json.${importer.method}`,
-        checker: project.checker,
-        transformer: project.transformer,
+        checker: context.checker,
+        transformer: context.transformer,
         type,
       });