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

package/src/programmers/misc/MiscPruneProgrammer.ts

@@ -85,9 +85,9 @@ export namespace MiscPruneProgrammer {
       .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 MiscPruneProgrammer {
               },
             }),
           ),
-        ),
+        }),
       );
 
   const write_tuple_functions = (props: {
@@ -126,9 +126,9 @@ export namespace MiscPruneProgrammer {
       .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 MiscPruneProgrammer {
               },
             }),
           ),
-        ),
+        }),
       );
 
   /* -----------------------------------------------------------
@@ -221,19 +221,19 @@ export namespace MiscPruneProgrammer {
       for (const native of props.metadata.natives)
         unions.push({
           type: "native",
-          is: () => ExpressionFactory.isInstanceOf(native)(props.input),
+          is: () => ExpressionFactory.isInstanceOf(native, props.input),
           value: () => ts.factory.createReturnStatement(),
         });
     if (props.metadata.sets.length)
       unions.push({
         type: "set",
-        is: () => ExpressionFactory.isInstanceOf("Set")(props.input),
+        is: () => ExpressionFactory.isInstanceOf("Set", props.input),
         value: () => ts.factory.createReturnStatement(),
       });
     if (props.metadata.maps.length)
       unions.push({
         type: "map",
-        is: () => ExpressionFactory.isInstanceOf("Map")(props.input),
+        is: () => ExpressionFactory.isInstanceOf("Map", props.input),
         value: () => ts.factory.createReturnStatement(),
       });
 
@@ -245,7 +245,8 @@ export namespace MiscPruneProgrammer {
           ExpressionFactory.isObject({
             checkNull: true,
             checkArray: false,
-          })(props.input),
+            input: props.input,
+          }),
         value: () =>
           explore_objects({
             ...props,
@@ -400,7 +401,7 @@ export namespace MiscPruneProgrammer {
         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)],
         ),
@@ -455,32 +456,39 @@ export namespace MiscPruneProgrammer {
       elements: props.arrays,
       factory: (next) =>
         UnionExplorer.array({
-          checker: (input, metadata, explore) =>
-            IsProgrammer.decode({
-              context: props.context,
-              importer: props.importer,
-              metadata,
-              input,
-              explore,
-            }),
-          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: props.importer,
-              expected,
-              input,
-            }),
-        })(next.parameters)(next.input, next.elements, next.explore),
+          config: {
+            checker: (v) =>
+              IsProgrammer.decode({
+                context: props.context,
+                importer: props.importer,
+                metadata: v.definition,
+                input: v.input,
+                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.createStringLiteral("[]"),
+            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,
+        }),
     });
+  //(next.parameters)(next.input, next.elements, next.explore),
 
   const explore_array_like_union_types = <
     T extends MetadataArray | MetadataTuple,
@@ -490,7 +498,7 @@ export namespace MiscPruneProgrammer {
     factory: (next: {
       parameters: ts.ParameterDeclaration[];
       input: ts.Expression;
-      elements: T[];
+      definitions: T[];
       explore: FeatureProgrammer.IExplore;
     }) => ts.ArrowFunction;
     input: ts.Expression;
@@ -503,7 +511,7 @@ export namespace MiscPruneProgrammer {
       input: ts.Expression;
     }): ts.ArrowFunction =>
       props.factory({
-        elements: props.elements,
+        definitions: props.elements,
         parameters: next.parameters,
         input: next.input,
         explore: next.explore,
@@ -573,7 +581,8 @@ export namespace MiscPruneProgrammer {
       types: {
         input: (type, name) =>
           ts.factory.createTypeReferenceNode(
-            name ?? TypeFactory.getFullName(props.context.checker)(type),
+            name ??
+              TypeFactory.getFullName({ checker: props.context.checker, type }),
           ),
         output: () => TypeFactory.keyword("void"),
       },
@@ -608,28 +617,33 @@ export namespace MiscPruneProgrammer {
           }),
         joiner: PruneJoiner.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/MiscValidateCloneProgrammer.ts

@@ -38,8 +38,14 @@ export namespace MiscValidateCloneProgrammer {
       statements: [
         ...validate.statements,
         ...clone.statements,
-        StatementFactory.constant("__validate", validate.arrow),
-        StatementFactory.constant("__clone", clone.arrow),
+        StatementFactory.constant({
+          name: "__validate",
+          value: validate.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__clone",
+          value: clone.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,
@@ -51,9 +57,9 @@ export namespace MiscValidateCloneProgrammer {
         undefined,
         ts.factory.createBlock(
           [
-            StatementFactory.constant(
-              "result",
-              ts.factory.createAsExpression(
+            StatementFactory.constant({
+              name: "result",
+              value: ts.factory.createAsExpression(
                 ts.factory.createCallExpression(
                   ts.factory.createIdentifier("__validate"),
                   undefined,
@@ -61,7 +67,7 @@ export namespace MiscValidateCloneProgrammer {
                 ),
                 TypeFactory.keyword("any"),
               ),
-            ),
+            }),
             ts.factory.createIfStatement(
               ts.factory.createIdentifier("result.success"),
               ts.factory.createExpressionStatement(

package/src/programmers/misc/MiscValidatePruneProgrammer.ts

@@ -39,8 +39,14 @@ export namespace MiscValidatePruneProgrammer {
       statements: [
         ...validate.statements,
         ...prune.statements,
-        StatementFactory.constant("__validate", validate.arrow),
-        StatementFactory.constant("__prune", prune.arrow),
+        StatementFactory.constant({
+          name: "__validate",
+          value: validate.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__prune",
+          value: prune.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,
@@ -49,20 +55,23 @@ export namespace MiscValidatePruneProgrammer {
         ts.factory.createTypeReferenceNode(
           `typia.IValidation<${
             props.name ??
-            TypeFactory.getFullName(props.context.checker)(props.type)
+            TypeFactory.getFullName({
+              checker: props.context.checker,
+              type: props.type,
+            })
           }>`,
         ),
         undefined,
         ts.factory.createBlock(
           [
-            StatementFactory.constant(
-              "result",
-              ts.factory.createCallExpression(
+            StatementFactory.constant({
+              name: "result",
+              value: ts.factory.createCallExpression(
                 ts.factory.createIdentifier("__validate"),
                 undefined,
                 [ts.factory.createIdentifier("input")],
               ),
-            ),
+            }),
             ts.factory.createIfStatement(
               ts.factory.createIdentifier("result.success"),
               ts.factory.createExpressionStatement(

package/src/programmers/notations/NotationAssertGeneralProgrammer.ts

@@ -45,8 +45,14 @@ export namespace NotationAssertGeneralProgrammer {
       statements: [
         ...assert.statements,
         ...notation.statements,
-        StatementFactory.constant("__assert", assert.arrow),
-        StatementFactory.constant("__notation", notation.arrow),
+        StatementFactory.constant({
+          name: "__assert",
+          value: assert.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__notation",
+          value: notation.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,