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

package/src/programmers/misc/MiscCloneProgrammer.ts

@@ -90,9 +90,11 @@ export namespace MiscCloneProgrammer {
           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({
@@ -129,9 +131,11 @@ export namespace MiscCloneProgrammer {
           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({
@@ -335,10 +339,16 @@ export namespace MiscCloneProgrammer {
     explore: FeatureProgrammer.IExplore;
   }) =>
     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,
+      input: props.input,
+      object: props.object,
+      explore: props.explore,
+    });
 
   const decode_array = (props: {
     config: FeatureProgrammer.IConfig;
@@ -355,11 +365,15 @@ export namespace MiscCloneProgrammer {
             ),
           ),
           undefined,
-          FeatureProgrammer.argumentsArray(props.config)({
-            ...props.explore,
-            source: "function",
-            from: "array",
-          })(props.input),
+          FeatureProgrammer.argumentsArray({
+            config: props.config,
+            explore: {
+              ...props.explore,
+              source: "function",
+              from: "array",
+            },
+            input: props.input,
+          }),
         )
       : decode_array_inline(props);
 
@@ -370,9 +384,14 @@ export namespace MiscCloneProgrammer {
     array: MetadataArray;
     explore: FeatureProgrammer.IExplore;
   }) =>
-    FeatureProgrammer.decode_array(props.config)(props.importer)(
-      CloneJoiner.array,
-    )(props.input, props.array, props.explore);
+    FeatureProgrammer.decode_array({
+      config: props.config,
+      importer: props.importer,
+      combiner: CloneJoiner.array,
+      array: props.array,
+      input: props.input,
+      explore: props.explore,
+    });
 
   const decode_tuple = (props: {
     context: ITypiaContext;
@@ -390,10 +409,14 @@ export namespace MiscCloneProgrammer {
             ),
           ),
           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,
@@ -678,9 +701,7 @@ export namespace MiscCloneProgrammer {
             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: {
@@ -772,9 +793,11 @@ export namespace MiscCloneProgrammer {
           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: "",
@@ -784,7 +807,11 @@ export namespace MiscCloneProgrammer {
         ),
       ),
       undefined,
-      FeatureProgrammer.argumentsArray(props.config)(arrayExplore)(props.input),
+      FeatureProgrammer.argumentsArray({
+        config: props.config,
+        input: props.input,
+        explore: arrayExplore,
+      }),
     );
   };
 
@@ -822,69 +849,70 @@ export namespace MiscCloneProgrammer {
       trace: false,
       path: false,
       initializer,
-      decoder: () => (input, metadata, explore) =>
+      decoder: (next) =>
         decode({
           context: props.context,
           importer: props.importer,
           config,
-          input,
-          metadata,
-          explore,
+          input: next.input,
+          metadata: next.metadata,
+          explore: next.explore,
         }),
       objector: {
-        checker: () => (input, metadata, explore) =>
+        checker: (next) =>
           IsProgrammer.decode({
             context: props.context,
             importer: props.importer,
-            input,
-            metadata,
-            explore,
+            input: next.input,
+            metadata: next.metadata,
+            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: CloneJoiner.object,
-        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({
             importer: props.importer,
             config,
             collection,
           }),
-        tuples: () => (collection) =>
+        tuples: (collection) =>
           write_tuple_functions({
             context: props.context,
             importer: props.importer,
@@ -896,34 +924,33 @@ export namespace MiscCloneProgrammer {
     return config;
   };
 
-  const initializer: FeatureProgrammer.IConfig["initializer"] =
-    (context) => (importer) => (type) => {
-      const collection = new MetadataCollection();
-      const result = MetadataFactory.analyze({
-        checker: context.checker,
-        transformer: context.transformer,
-        options: {
-          escape: false,
-          constant: true,
-          absorb: true,
-          validate: (metadata) => {
-            const output: string[] = [];
-            if (metadata.natives.some((n) => n === "WeakSet"))
-              output.push("unable to clone WeakSet");
-            else if (metadata.natives.some((n) => n === "WeakMap"))
-              output.push("unable to clone WeakMap");
-            return output;
-          },
+  const initializer: FeatureProgrammer.IConfig["initializer"] = (props) => {
+    const collection = new MetadataCollection();
+    const result = MetadataFactory.analyze({
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      options: {
+        escape: false,
+        constant: true,
+        absorb: true,
+        validate: (metadata) => {
+          const output: string[] = [];
+          if (metadata.natives.some((n) => n === "WeakSet"))
+            output.push("unable to clone WeakSet");
+          else if (metadata.natives.some((n) => n === "WeakMap"))
+            output.push("unable to clone WeakMap");
+          return output;
         },
-        collection,
-        type,
-      });
-      if (result.success === false)
-        throw TransformerError.from(`typia.misc.${importer.method}`)(
-          result.errors,
-        );
-      return [collection, result.data];
-    };
+      },
+      collection,
+      type: props.type,
+    });
+    if (result.success === false)
+      throw TransformerError.from(`typia.misc.${props.importer.method}`)(
+        result.errors,
+      );
+    return [collection, result.data];
+  };
 
   const create_throw_error = (props: {
     importer: FunctionImporter;

package/src/programmers/misc/MiscPruneProgrammer.ts

@@ -90,9 +90,11 @@ export namespace MiscPruneProgrammer {
           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({
@@ -129,9 +131,11 @@ export namespace MiscPruneProgrammer {
           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({
@@ -273,10 +277,16 @@ export namespace MiscPruneProgrammer {
     explore: FeatureProgrammer.IExplore;
   }) =>
     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;
@@ -293,11 +303,15 @@ export namespace MiscPruneProgrammer {
             ),
           ),
           undefined,
-          FeatureProgrammer.argumentsArray(props.config)({
-            ...props.explore,
-            source: "function",
-            from: "array",
-          })(props.input),
+          FeatureProgrammer.argumentsArray({
+            config: props.config,
+            explore: {
+              ...props.explore,
+              source: "function",
+              from: "array",
+            },
+            input: props.input,
+          }),
         )
       : decode_array_inline(props);
 
@@ -308,9 +322,14 @@ export namespace MiscPruneProgrammer {
     array: MetadataArray;
     explore: FeatureProgrammer.IExplore;
   }): ts.Expression =>
-    FeatureProgrammer.decode_array(props.config)(props.importer)(
-      PruneJoiner.array,
-    )(props.input, props.array, props.explore);
+    FeatureProgrammer.decode_array({
+      config: props.config,
+      importer: props.importer,
+      combiner: PruneJoiner.array,
+      array: props.array,
+      input: props.input,
+      explore: props.explore,
+    });
 
   const decode_tuple = (props: {
     context: ITypiaContext;
@@ -328,10 +347,14 @@ export namespace MiscPruneProgrammer {
             ),
           ),
           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,
@@ -415,9 +438,7 @@ export namespace MiscPruneProgrammer {
         props.importer.useLocal(`${PREFIX}u${props.metadata.union_index!}`),
       ),
       undefined,
-      FeatureProgrammer.argumentsArray(props.config)(props.explore)(
-        props.input,
-      ),
+      FeatureProgrammer.argumentsArray(props),
     );
   };
 
@@ -510,9 +531,11 @@ export namespace MiscPruneProgrammer {
           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: "",
@@ -522,9 +545,7 @@ export namespace MiscPruneProgrammer {
         ),
       ),
       undefined,
-      FeatureProgrammer.argumentsArray(props.config)(props.explore)(
-        props.input,
-      ),
+      FeatureProgrammer.argumentsArray(props),
     );
   };
 
@@ -560,69 +581,70 @@ export namespace MiscPruneProgrammer {
       trace: false,
       path: false,
       initializer,
-      decoder: () => (input, metadata, explore) =>
+      decoder: (next) =>
         decode({
           context: props.context,
           importer: props.importer,
           config,
-          input,
-          metadata,
-          explore,
+          input: next.input,
+          metadata: next.metadata,
+          explore: next.explore,
         }),
       objector: {
-        checker: () => (input, metadata, explore) =>
+        checker: (next) =>
           IsProgrammer.decode({
             context: props.context,
             importer: props.importer,
-            input,
-            metadata,
-            explore,
+            input: next.input,
+            metadata: next.metadata,
+            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: PruneJoiner.object,
-        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,
@@ -634,26 +656,25 @@ export namespace MiscPruneProgrammer {
     return config;
   };
 
-  const initializer: FeatureProgrammer.IConfig["initializer"] =
-    (context) => (importer) => (type) => {
-      const collection = new MetadataCollection();
-      const result = MetadataFactory.analyze({
-        checker: context.checker,
-        transformer: context.transformer,
-        options: {
-          escape: false,
-          constant: true,
-          absorb: true,
-        },
-        collection,
-        type,
-      });
-      if (result.success === false)
-        throw TransformerError.from(`typia.misc.${importer.method}`)(
-          result.errors,
-        );
-      return [collection, result.data];
-    };
+  const initializer: FeatureProgrammer.IConfig["initializer"] = (props) => {
+    const collection = new MetadataCollection();
+    const result = MetadataFactory.analyze({
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      options: {
+        escape: false,
+        constant: true,
+        absorb: true,
+      },
+      collection,
+      type: props.type,
+    });
+    if (result.success === false)
+      throw TransformerError.from(`typia.misc.${props.importer.method}`)(
+        result.errors,
+      );
+    return [collection, result.data];
+  };
 
   const create_throw_error = (props: {
     importer: FunctionImporter;