typia 7.0.0-dev.20240929 → 7.0.0-dev.20241001

package/src/programmers/notations/NotationGeneralProgrammer.ts

@@ -9,6 +9,7 @@ import { TypeFactory } from "../../factories/TypeFactory";
 
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
@@ -32,9 +33,10 @@ export namespace NotationGeneralProgrammer {
     rename: (str: string) => string;
   }
 
-  export const returnType =
-    (rename: (str: string) => string) => (type: string) =>
-      `typia.${StringUtil.capitalize(rename.name)}Case<${type}>`;
+  export const returnType = (props: {
+    rename: (str: string) => string;
+    type: string;
+  }) => `typia.${StringUtil.capitalize(props.rename.name)}Case<${props.type}>`;
 
   export const decompose = (props: {
     rename: (str: string) => string;
@@ -64,10 +66,12 @@ export namespace NotationGeneralProgrammer {
         undefined,
         composed.parameters,
         ts.factory.createTypeReferenceNode(
-          returnType(props.rename)(
-            props.name ??
+          returnType({
+            rename: props.rename,
+            type:
+              props.name ??
               TypeFactory.getFullName(props.context.checker)(props.type),
-          ),
+          }),
         ),
         undefined,
         composed.body,
@@ -105,9 +109,11 @@ export namespace NotationGeneralProgrammer {
           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({
@@ -143,9 +149,11 @@ export namespace NotationGeneralProgrammer {
           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({
@@ -238,7 +246,7 @@ export namespace NotationGeneralProgrammer {
         value: () =>
           explore_arrays({
             ...props,
-            elements: props.metadata.arrays,
+            arrays: props.metadata.arrays,
             explore: {
               ...props.explore,
               from: "array",
@@ -342,12 +350,23 @@ export namespace NotationGeneralProgrammer {
     }
   };
 
-  const decode_object = (importer: FunctionImporter) =>
+  const decode_object = (props: {
+    importer: FunctionImporter;
+    object: MetadataObject;
+    input: ts.Expression;
+    explore: FeatureProgrammer.IExplore;
+  }) =>
     FeatureProgrammer.decode_object({
-      trace: false,
-      path: false,
-      prefix: PREFIX,
-    })(importer);
+      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;
@@ -364,11 +383,15 @@ export namespace NotationGeneralProgrammer {
             ),
           ),
           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);
 
@@ -379,9 +402,14 @@ export namespace NotationGeneralProgrammer {
     array: MetadataArray;
     explore: FeatureProgrammer.IExplore;
   }) =>
-    FeatureProgrammer.decode_array(props.config)(props.importer)(
-      NotationJoiner.array,
-    )(props.input, props.array, props.explore);
+    FeatureProgrammer.decode_array({
+      config: props.config,
+      importer: props.importer,
+      combiner: NotationJoiner.array,
+      array: props.array,
+      input: props.input,
+      explore: props.explore,
+    });
 
   const decode_tuple = (props: {
     context: ITypiaContext;
@@ -399,10 +427,14 @@ export namespace NotationGeneralProgrammer {
             ),
           ),
           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,
@@ -485,37 +517,47 @@ export namespace NotationGeneralProgrammer {
   }): ts.Expression =>
     ts.factory.createCallExpression(
       UnionExplorer.set({
-        checker: (input, metadata, explore) =>
-          IsProgrammer.decode({
-            context: props.context,
-            importer: props.importer,
-            input,
-            metadata,
-            explore,
-          }),
-        decoder: (input, array, explore) =>
-          ts.factory.createNewExpression(
+        config: {
+          checker: (v) =>
+            IsProgrammer.decode({
+              context: props.context,
+              importer: props.importer,
+              input: v.input,
+              metadata: v.definition,
+              explore: v.explore,
+            }),
+          decoder: (v) =>
+            ts.factory.createNewExpression(
+              ts.factory.createIdentifier("Set"),
+              [TypeFactory.keyword("any")],
+              [
+                decode_array({
+                  config: props.config,
+                  importer: props.importer,
+                  input: v.input,
+                  array: v.definition,
+                  explore: v.explore,
+                }),
+              ],
+            ),
+          empty: ts.factory.createNewExpression(
             ts.factory.createIdentifier("Set"),
             [TypeFactory.keyword("any")],
-            [
-              decode_array({
-                config: props.config,
-                importer: props.importer,
-                input,
-                array,
-                explore,
-              }),
-            ],
+            [],
           ),
-        empty: ts.factory.createNewExpression(
-          ts.factory.createIdentifier("Set"),
-          [TypeFactory.keyword("any")],
-          [],
-        ),
-        success: ts.factory.createTrue(),
-        failure: (input, expected) =>
-          create_throw_error({ importer: props.importer, expected, input }),
-      })([])(props.input, props.sets, props.explore),
+          success: ts.factory.createTrue(),
+          failure: (v) =>
+            create_throw_error({
+              importer: props.importer,
+              expected: v.expected,
+              input: v.input,
+            }),
+        },
+        parameters: [],
+        input: props.input,
+        sets: props.sets,
+        explore: props.explore,
+      }),
       undefined,
       undefined,
     );
@@ -530,52 +572,62 @@ export namespace NotationGeneralProgrammer {
   }): ts.Expression =>
     ts.factory.createCallExpression(
       UnionExplorer.map({
-        checker: (top, entry, explore) =>
-          ts.factory.createLogicalAnd(
-            IsProgrammer.decode({
-              context: props.context,
-              importer: props.importer,
-              input: ts.factory.createElementAccessExpression(top, 0),
-              metadata: entry[0],
-              explore: {
-                ...props.explore,
-                postfix: `${explore.postfix}[0]`,
-              },
-            }),
-            IsProgrammer.decode({
-              context: props.context,
-              importer: props.importer,
-              input: ts.factory.createElementAccessExpression(top, 1),
-              metadata: entry[1],
-              explore: {
-                ...props.explore,
-                postfix: `${props.explore.postfix}[1]`,
-              },
-            }),
-          ),
-        decoder: (input, array, explore) =>
-          ts.factory.createNewExpression(
-            ts.factory.createIdentifier("Map"),
-            [TypeFactory.keyword("any"), TypeFactory.keyword("any")],
-            [
-              decode_array({
-                config: props.config,
+        config: {
+          checker: (v) =>
+            ts.factory.createLogicalAnd(
+              IsProgrammer.decode({
+                context: props.context,
                 importer: props.importer,
-                input,
-                array,
-                explore,
+                input: ts.factory.createElementAccessExpression(v.input, 0),
+                metadata: v.definition[0],
+                explore: {
+                  ...props.explore,
+                  postfix: `${v.explore.postfix}[0]`,
+                },
               }),
-            ],
+              IsProgrammer.decode({
+                context: props.context,
+                importer: props.importer,
+                input: ts.factory.createElementAccessExpression(v.input, 1),
+                metadata: v.definition[1],
+                explore: {
+                  ...props.explore,
+                  postfix: `${props.explore.postfix}[1]`,
+                },
+              }),
+            ),
+          decoder: (v) =>
+            ts.factory.createNewExpression(
+              ts.factory.createIdentifier("Map"),
+              [TypeFactory.keyword("any"), TypeFactory.keyword("any")],
+              [
+                decode_array({
+                  config: props.config,
+                  importer: props.importer,
+                  input: v.input,
+                  array: v.definition,
+                  explore: v.explore,
+                }),
+              ],
+            ),
+          empty: ts.factory.createNewExpression(
+            ts.factory.createIdentifier("Map"),
+            [TypeFactory.keyword("any"), TypeFactory.keyword("any")],
+            [],
           ),
-        empty: ts.factory.createNewExpression(
-          ts.factory.createIdentifier("Map"),
-          [TypeFactory.keyword("any"), TypeFactory.keyword("any")],
-          [],
-        ),
-        success: ts.factory.createTrue(),
-        failure: (input, expected) =>
-          create_throw_error({ importer: props.importer, expected, input }),
-      })([])(props.input, props.maps, props.explore),
+          success: ts.factory.createTrue(),
+          failure: (v) =>
+            create_throw_error({
+              importer: props.importer,
+              expected: v.expected,
+              input: v.input,
+            }),
+        },
+        parameters: [],
+        input: props.input,
+        maps: props.maps,
+        explore: props.explore,
+      }),
       undefined,
       undefined,
     );
@@ -588,19 +640,18 @@ export namespace NotationGeneralProgrammer {
     explore: FeatureProgrammer.IExplore;
   }) => {
     if (props.metadata.objects.length === 1)
-      return decode_object(props.importer)(
-        props.input,
-        props.metadata.objects[0]!,
-        props.explore,
-      );
+      return decode_object({
+        importer: props.importer,
+        object: props.metadata.objects[0]!,
+        input: props.input,
+        explore: props.explore,
+      });
     return ts.factory.createCallExpression(
       ts.factory.createIdentifier(
         props.importer.useLocal(`${PREFIX}u${props.metadata.union_index!}`),
       ),
       undefined,
-      FeatureProgrammer.argumentsArray(props.config)(props.explore)(
-        props.input,
-      ),
+      FeatureProgrammer.argumentsArray(props),
     );
   };
 
@@ -609,37 +660,47 @@ export namespace NotationGeneralProgrammer {
     config: FeatureProgrammer.IConfig;
     importer: FunctionImporter;
     input: ts.Expression;
-    elements: MetadataArray[];
+    arrays: MetadataArray[];
     explore: FeatureProgrammer.IExplore;
   }): ts.Expression =>
     explore_array_like_union_types({
       ...props,
-      factory: UnionExplorer.array({
-        checker: (input, metadata, explore) =>
-          IsProgrammer.decode({
-            context: props.context,
-            importer: props.importer,
-            input,
-            metadata,
-            explore,
-          }),
-        decoder: (input, array, explore) =>
-          decode_array({
-            config: props.config,
-            importer: props.importer,
-            input,
-            array,
-            explore,
-          }),
-        empty: ts.factory.createIdentifier("[]"),
-        success: ts.factory.createTrue(),
-        failure: (input, expected) =>
-          create_throw_error({
-            importer: props.importer,
-            expected,
-            input,
-          }),
-      }),
+      factory: (next) =>
+        UnionExplorer.array({
+          config: {
+            checker: (v) =>
+              IsProgrammer.decode({
+                context: props.context,
+                importer: props.importer,
+                input: v.input,
+                metadata: v.definition,
+                explore: v.explore,
+              }),
+            decoder: (v) =>
+              decode_array({
+                config: props.config,
+                importer: props.importer,
+                input: v.input,
+                array: v.definition,
+                explore: v.explore,
+              }),
+            empty: ts.factory.createIdentifier("[]"),
+            success: ts.factory.createTrue(),
+            failure: (v) =>
+              create_throw_error({
+                importer: props.importer,
+                expected: v.expected,
+                input: v.input,
+              }),
+          },
+          parameters: next.parameters,
+          input: next.input,
+          arrays: next.definitions,
+          explore: next.explore,
+        }),
+      definitions: props.arrays,
+      input: props.input,
+      explore: props.explore,
     });
 
   const explore_array_like_union_types = <
@@ -647,23 +708,27 @@ export namespace NotationGeneralProgrammer {
   >(props: {
     config: FeatureProgrammer.IConfig;
     importer: FunctionImporter;
-    factory: (
-      parameters: ts.ParameterDeclaration[],
-    ) => (
-      input: ts.Expression,
-      elements: T[],
-      explore: FeatureProgrammer.IExplore,
-    ) => ts.ArrowFunction;
+    factory: (next: {
+      parameters: ts.ParameterDeclaration[];
+      input: ts.Expression;
+      definitions: T[];
+      explore: FeatureProgrammer.IExplore;
+    }) => ts.ArrowFunction;
     input: ts.Expression;
-    elements: T[];
+    definitions: T[];
     explore: FeatureProgrammer.IExplore;
   }): ts.Expression => {
     const arrow =
       (parameters: ts.ParameterDeclaration[]) =>
       (explore: FeatureProgrammer.IExplore) =>
       (input: ts.Expression): ts.ArrowFunction =>
-        props.factory(parameters)(input, props.elements, explore);
-    if (props.elements.every((e) => e.type.recursive === false))
+        props.factory({
+          parameters,
+          input,
+          definitions: props.definitions,
+          explore,
+        });
+    if (props.definitions.every((e) => e.type.recursive === false))
       ts.factory.createCallExpression(
         arrow([])(props.explore)(props.input),
         undefined,
@@ -679,12 +744,14 @@ export namespace NotationGeneralProgrammer {
       ts.factory.createIdentifier(
         props.importer.emplaceUnion(
           props.config.prefix,
-          props.elements.map((e) => e.type.name).join(" | "),
+          props.definitions.map((e) => e.type.name).join(" | "),
           () =>
             arrow(
-              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"),
+              }),
             )({
               ...arrayExplore,
               postfix: "",
@@ -692,7 +759,11 @@ export namespace NotationGeneralProgrammer {
         ),
       ),
       undefined,
-      FeatureProgrammer.argumentsArray(props.config)(arrayExplore)(props.input),
+      FeatureProgrammer.argumentsArray({
+        config: props.config,
+        explore: arrayExplore,
+        input: props.input,
+      }),
     );
   };
 
@@ -705,8 +776,8 @@ export namespace NotationGeneralProgrammer {
     rename: (str: string) => string;
     context: ITypiaContext;
     importer: FunctionImporter;
-  }): FeatureProgrammer.IConfig => {
-    const config: FeatureProgrammer.IConfig = {
+  }): FeatureProgrammer.IConfig<ts.Expression> => {
+    const config: FeatureProgrammer.IConfig<ts.Expression> = {
       types: {
         input: (type, name) =>
           ts.factory.createTypeReferenceNode(
@@ -714,65 +785,91 @@ export namespace NotationGeneralProgrammer {
           ),
         output: (type, name) =>
           ts.factory.createTypeReferenceNode(
-            returnType(props.rename)(
-              name ?? TypeFactory.getFullName(props.context.checker)(type),
-            ),
+            returnType({
+              rename: props.rename,
+              type:
+                name ?? TypeFactory.getFullName(props.context.checker)(type),
+            }),
           ),
       },
       prefix: PREFIX,
       trace: false,
       path: false,
       initializer,
-      decoder: () => (input, metadata, explore) =>
+      decoder: (next) =>
         decode({
           context: props.context,
           config,
           importer: props.importer,
-          metadata,
-          explore,
-          input,
+          metadata: next.metadata,
+          explore: next.explore,
+          input: next.input,
         }),
       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: () => decode_object(props.importer),
-        joiner: NotationJoiner.object(props.rename),
-        unionizer: decode_union_object((input, object, explore) =>
-          IsProgrammer.decode_object({
-            context: props.context,
+        decoder: (next) =>
+          decode_object({
             importer: props.importer,
-            object,
-            input,
-            explore,
+            object: next.object,
+            input: next.input,
+            explore: next.explore,
           }),
-        )(decode_object(props.importer))((exp) => exp)((input, expected) =>
-          create_throw_error({
-            importer: props.importer,
-            expected,
-            input,
+        joiner: (next) =>
+          NotationJoiner.object({
+            rename: props.rename,
+            input: next.input!,
+            entries: next.entries,
           }),
-        ),
-        failure: (input, expected) =>
+        unionizer: (next) =>
+          decode_union_object({
+            checker: (v) =>
+              IsProgrammer.decode_object({
+                context: props.context,
+                importer: props.importer,
+                object: v.object,
+                input: v.input,
+                explore: v.explore,
+              }),
+            decoder: (v) =>
+              decode_object({
+                importer: props.importer,
+                object: v.object,
+                input: v.input,
+                explore: v.explore,
+              }),
+            success: (exp) => exp,
+            escaper: (v) =>
+              create_throw_error({
+                importer: props.importer,
+                expected: v.expected,
+                input: v.input,
+              }),
+            input: next.input,
+            objects: next.objects,
+            explore: 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,
@@ -784,26 +881,25 @@ export namespace NotationGeneralProgrammer {
     return config;
   };
 
-  const initializer: FeatureProgrammer.IConfig["initializer"] =
-    (project) => (importer) => (type) => {
-      const collection = new MetadataCollection();
-      const result = MetadataFactory.analyze({
-        checker: project.checker,
-        transformer: project.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;
@@ -829,12 +925,12 @@ export namespace NotationGeneralProgrammer {
       ),
     );
 
-  const is_instance = (meta: Metadata): boolean =>
-    !!meta.objects.length ||
-    !!meta.arrays.length ||
-    !!meta.tuples.length ||
-    !!meta.sets.length ||
-    !!meta.maps.length ||
-    !!meta.natives.length ||
-    (meta.rest !== null && is_instance(meta.rest));
+  const is_instance = (metadata: Metadata): boolean =>
+    !!metadata.objects.length ||
+    !!metadata.arrays.length ||
+    !!metadata.tuples.length ||
+    !!metadata.sets.length ||
+    !!metadata.maps.length ||
+    !!metadata.natives.length ||
+    (metadata.rest !== null && is_instance(metadata.rest));
 }