typia 7.0.0-dev.20240930 → 7.0.0-dev.20241002

package/src/programmers/misc/MiscCloneProgrammer.ts

@@ -85,9 +85,9 @@ export namespace MiscCloneProgrammer {
       .arrays()
       .filter((a) => a.recursive)
       .map((type, i) =>
-        StatementFactory.constant(
-          `${props.config.prefix}a${i}`,
-          ts.factory.createArrowFunction(
+        StatementFactory.constant({
+          name: `${props.config.prefix}a${i}`,
+          value: ts.factory.createArrowFunction(
             undefined,
             undefined,
             FeatureProgrammer.parameterDeclarations({
@@ -113,7 +113,7 @@ export namespace MiscCloneProgrammer {
               },
             }),
           ),
-        ),
+        }),
       );
 
   const write_tuple_functions = (props: {
@@ -126,9 +126,9 @@ export namespace MiscCloneProgrammer {
       .tuples()
       .filter((t) => t.recursive)
       .map((tuple, i) =>
-        StatementFactory.constant(
-          `${props.config.prefix}t${i}`,
-          ts.factory.createArrowFunction(
+        StatementFactory.constant({
+          name: `${props.config.prefix}t${i}`,
+          value: ts.factory.createArrowFunction(
             undefined,
             undefined,
             FeatureProgrammer.parameterDeclarations({
@@ -152,7 +152,7 @@ export namespace MiscCloneProgrammer {
               },
             }),
           ),
-        ),
+        }),
       );
 
   /* -----------------------------------------------------------
@@ -242,7 +242,7 @@ export namespace MiscCloneProgrammer {
     if (props.metadata.sets.length)
       unions.push({
         type: "set",
-        is: () => ExpressionFactory.isInstanceOf("Set")(props.input),
+        is: () => ExpressionFactory.isInstanceOf("Set", props.input),
         value: () =>
           explore_sets({
             ...props,
@@ -256,7 +256,7 @@ export namespace MiscCloneProgrammer {
     if (props.metadata.maps.length)
       unions.push({
         type: "map",
-        is: () => ExpressionFactory.isInstanceOf("Map")(props.input),
+        is: () => ExpressionFactory.isInstanceOf("Map", props.input),
         value: () =>
           explore_maps({
             ...props,
@@ -270,11 +270,11 @@ export namespace MiscCloneProgrammer {
     for (const native of props.metadata.natives)
       unions.push({
         type: "native",
-        is: () => ExpressionFactory.isInstanceOf(native)(props.input),
+        is: () => ExpressionFactory.isInstanceOf(native, props.input),
         value: () =>
           native === "Boolean" || native === "Number" || native === "String"
             ? ts.factory.createCallExpression(
-                IdentifierFactory.access(props.input)("valueOf"),
+                IdentifierFactory.access(props.input, "valueOf"),
                 undefined,
                 undefined,
               )
@@ -292,7 +292,8 @@ export namespace MiscCloneProgrammer {
           ExpressionFactory.isObject({
             checkNull: true,
             checkArray: false,
-          })(props.input),
+            input: props.input,
+          }),
         value: () =>
           explore_objects({
             ...props,
@@ -461,7 +462,7 @@ export namespace MiscCloneProgrammer {
         config: props.config,
         importer: props.importer,
         input: ts.factory.createCallExpression(
-          IdentifierFactory.access(props.input)("slice"),
+          IdentifierFactory.access(props.input, "slice"),
           undefined,
           [ExpressionFactory.number(props.tuple.elements.length - 1)],
         ),
@@ -526,14 +527,14 @@ export namespace MiscCloneProgrammer {
     ExpressionFactory.selfCall(
       ts.factory.createBlock(
         [
-          StatementFactory.constant(
-            "buffer",
-            ts.factory.createNewExpression(
+          StatementFactory.constant({
+            name: "buffer",
+            value: ts.factory.createNewExpression(
               ts.factory.createIdentifier(props.type),
               undefined,
-              [IdentifierFactory.access(props.input)("byteLength")],
+              [IdentifierFactory.access(props.input, "byteLength")],
             ),
-          ),
+          }),
           ts.factory.createExpressionStatement(
             ts.factory.createCallExpression(
               IdentifierFactory.access(
@@ -542,7 +543,8 @@ export namespace MiscCloneProgrammer {
                   undefined,
                   [ts.factory.createIdentifier("buffer")],
                 ),
-              )("set"),
+                "set",
+              ),
               undefined,
               [
                 ts.factory.createNewExpression(
@@ -565,7 +567,7 @@ export namespace MiscCloneProgrammer {
     ts.factory.createNewExpression(
       ts.factory.createIdentifier("DataView"),
       undefined,
-      [IdentifierFactory.access(input)("buffer")],
+      [IdentifierFactory.access(input, "buffer")],
     );
 
   /* -----------------------------------------------------------
@@ -581,41 +583,47 @@ export namespace MiscCloneProgrammer {
   }): 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,
     );
@@ -630,56 +638,63 @@ export namespace MiscCloneProgrammer {
   }): 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: {
-                ...explore,
-                postfix: `${explore.postfix}[0]`,
-              },
-            }),
-            IsProgrammer.decode({
-              context: props.context,
-              importer: props.importer,
-              input: ts.factory.createElementAccessExpression(top, 1),
-              metadata: entry[1],
-              explore: {
-                ...explore,
-                postfix: `${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: {
+                  ...v.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: {
+                  ...v.explore,
+                  postfix: `${v.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,
+      }),
+      // ([])(props.input, props.maps, props.explore),
       undefined,
       undefined,
     );
@@ -714,34 +729,40 @@ export namespace MiscCloneProgrammer {
   }): ts.Expression =>
     explore_array_like_union_types({
       ...props,
-      elements: props.arrays,
+      definitions: props.arrays,
       factory: (next) =>
         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,
-            }),
-        })(next.parameters)(next.input, next.elements, next.explore),
+          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,
+          arrays: next.definitions,
+          input: next.input,
+          explore: next.explore,
+        }),
     });
 
   const explore_array_like_union_types = <
@@ -752,11 +773,11 @@ export namespace MiscCloneProgrammer {
     factory: (next: {
       parameters: ts.ParameterDeclaration[];
       input: ts.Expression;
-      elements: T[];
+      definitions: T[];
       explore: FeatureProgrammer.IExplore;
     }) => ts.ArrowFunction;
     input: ts.Expression;
-    elements: T[];
+    definitions: T[];
     explore: FeatureProgrammer.IExplore;
   }): ts.Expression => {
     const arrow = (next: {
@@ -765,12 +786,12 @@ export namespace MiscCloneProgrammer {
       input: ts.Expression;
     }): ts.ArrowFunction =>
       props.factory({
-        elements: props.elements,
+        definitions: props.definitions,
         parameters: next.parameters,
         input: next.input,
         explore: next.explore,
       });
-    if (props.elements.every((e) => e.type.recursive === false))
+    if (props.definitions.every((e) => e.type.recursive === false))
       ts.factory.createCallExpression(
         arrow({
           parameters: [],
@@ -790,7 +811,7 @@ export namespace MiscCloneProgrammer {
       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({
               parameters: FeatureProgrammer.parameterDeclarations({
@@ -828,7 +849,8 @@ export namespace MiscCloneProgrammer {
       types: {
         input: (type, name) =>
           ts.factory.createTypeReferenceNode(
-            name ?? TypeFactory.getFullName(props.context.checker)(type),
+            name ??
+              TypeFactory.getFullName({ checker: props.context.checker, type }),
           ),
         output: (type, name) =>
           ts.factory.createImportTypeNode(
@@ -839,7 +861,11 @@ export namespace MiscCloneProgrammer {
             ts.factory.createIdentifier("Resolved"),
             [
               ts.factory.createTypeReferenceNode(
-                name ?? TypeFactory.getFullName(props.context.checker)(type),
+                name ??
+                  TypeFactory.getFullName({
+                    checker: props.context.checker,
+                    type,
+                  }),
               ),
             ],
             false,
@@ -876,28 +902,33 @@ export namespace MiscCloneProgrammer {
           }),
         joiner: CloneJoiner.object,
         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),
+          decode_union_object({
+            checker: (v) =>
+              IsProgrammer.decode_object({
+                context: props.context,
+                importer: props.importer,
+                input: v.input,
+                object: v.object,
+                explore: v.explore,
+              }),
+            decoder: (v) =>
+              decode_object({
+                importer: props.importer,
+                input: v.input,
+                object: v.object,
+                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,

package/src/programmers/misc/MiscIsCloneProgrammer.ts

@@ -37,8 +37,14 @@ export namespace MiscIsCloneProgrammer {
       statements: [
         ...is.statements,
         ...clone.statements,
-        StatementFactory.constant("__is", is.arrow),
-        StatementFactory.constant("__clone", clone.arrow),
+        StatementFactory.constant({
+          name: "__is",
+          value: is.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__clone",
+          value: clone.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,

package/src/programmers/misc/MiscIsPruneProgrammer.ts

@@ -37,8 +37,14 @@ export namespace MiscIsPruneProgrammer {
       statements: [
         ...is.statements,
         ...prune.statements,
-        StatementFactory.constant("__is", is.arrow),
-        StatementFactory.constant("__prune", prune.arrow),
+        StatementFactory.constant({
+          name: "__is",
+          value: is.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__prune",
+          value: prune.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,