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

package/src/programmers/json/JsonStringifyProgrammer.ts

@@ -95,9 +95,9 @@ export namespace JsonStringifyProgrammer {
       .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({
@@ -123,7 +123,7 @@ export namespace JsonStringifyProgrammer {
               },
             }),
           ),
-        ),
+        }),
       );
 
   const write_tuple_functions = (props: {
@@ -136,9 +136,9 @@ export namespace JsonStringifyProgrammer {
       .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({
@@ -162,7 +162,7 @@ export namespace JsonStringifyProgrammer {
               },
             }),
           ),
-        ),
+        }),
       );
 
   /* -----------------------------------------------------------
@@ -236,7 +236,11 @@ export namespace JsonStringifyProgrammer {
         is:
           props.metadata.escaped.original.size() === 1 &&
           props.metadata.escaped.original.natives[0] === "Date"
-            ? () => check_native("Date")(props.input)
+            ? () =>
+                check_native({
+                  type: "Date",
+                  input: props.input,
+                })
             : () =>
                 IsProgrammer.decode_to_json({
                   checkNull: false,
@@ -421,7 +425,11 @@ export namespace JsonStringifyProgrammer {
       for (const native of props.metadata.natives)
         unions.push({
           type: "object",
-          is: () => check_native(native)(props.input),
+          is: () =>
+            check_native({
+              type: native,
+              input: props.input,
+            }),
           value: () =>
             AtomicPredicator.native(native)
               ? decode_atomic({
@@ -435,7 +443,7 @@ export namespace JsonStringifyProgrammer {
     if (props.metadata.sets.length)
       unions.push({
         type: "object",
-        is: () => ExpressionFactory.isInstanceOf("Set")(props.input),
+        is: () => ExpressionFactory.isInstanceOf("Set", props.input),
         value: () => ts.factory.createStringLiteral("{}"),
       });
 
@@ -443,7 +451,7 @@ export namespace JsonStringifyProgrammer {
     if (props.metadata.maps.length)
       unions.push({
         type: "object",
-        is: () => ExpressionFactory.isInstanceOf("Map")(props.input),
+        is: () => ExpressionFactory.isInstanceOf("Map", props.input),
         value: () => ts.factory.createStringLiteral("{}"),
       });
 
@@ -459,7 +467,8 @@ export namespace JsonStringifyProgrammer {
                 (prop) => !prop.key.isSoleLiteral() || !prop.value.isRequired(),
               ),
             ),
-          })(props.input),
+            input: props.input,
+          }),
         value: () =>
           explore_objects({
             ...props,
@@ -640,7 +649,7 @@ export namespace JsonStringifyProgrammer {
       const code = decode({
         ...props,
         input: ts.factory.createCallExpression(
-          IdentifierFactory.access(props.input)("slice"),
+          IdentifierFactory.access(props.input, "slice"),
           undefined,
           [ExpressionFactory.number(props.tuple.elements.length - 1)],
         ),
@@ -691,7 +700,7 @@ export namespace JsonStringifyProgrammer {
     return props.explore.from !== "top"
       ? props.input
       : ts.factory.createCallExpression(
-          IdentifierFactory.access(props.input)("toString"),
+          IdentifierFactory.access(props.input, "toString"),
           undefined,
           undefined,
         );
@@ -727,7 +736,7 @@ export namespace JsonStringifyProgrammer {
     return decode({
       ...props,
       input: ts.factory.createCallExpression(
-        IdentifierFactory.access(props.input)("toJSON"),
+        IdentifierFactory.access(props.input, "toJSON"),
         undefined,
         [],
       ),
@@ -777,31 +786,38 @@ export namespace JsonStringifyProgrammer {
       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 = <
@@ -812,7 +828,7 @@ export namespace JsonStringifyProgrammer {
     factory: (next: {
       parameters: ts.ParameterDeclaration[];
       input: ts.Expression;
-      elements: T[];
+      definitions: T[];
       explore: FeatureProgrammer.IExplore;
     }) => ts.ArrowFunction;
     input: ts.Expression;
@@ -825,7 +841,7 @@ export namespace JsonStringifyProgrammer {
       input: ts.Expression;
     }): ts.ArrowFunction =>
       props.factory({
-        elements: props.elements,
+        definitions: props.elements,
         parameters: next.parameters,
         input: next.input,
         explore: next.explore,
@@ -966,7 +982,8 @@ export namespace JsonStringifyProgrammer {
       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("string"),
       },
@@ -1005,28 +1022,33 @@ export namespace JsonStringifyProgrammer {
             importer: props.importer,
           }),
         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,
+              }),
+            objects: next.objects,
+            explore: next.explore,
+            input: next.input,
+          }),
         failure: (next) =>
           create_throw_error({
             importer: props.importer,

package/src/programmers/json/JsonValidateParseProgrammer.ts

@@ -38,7 +38,10 @@ export namespace JsonValidateParseProgrammer {
       functions: validate.functions,
       statements: [
         ...validate.statements,
-        StatementFactory.constant("__validate", validate.arrow),
+        StatementFactory.constant({
+          name: "__validate",
+          value: validate.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,
@@ -47,7 +50,10 @@ export namespace JsonValidateParseProgrammer {
         ts.factory.createTypeReferenceNode(
           `typia.IValidation<typia.Primitive<${
             props.name ??
-            TypeFactory.getFullName(props.context.checker)(props.type)
+            TypeFactory.getFullName({
+              checker: props.context.checker,
+              type: props.type,
+            })
           }>>`,
         ),
         undefined,

package/src/programmers/json/JsonValidateStringifyProgrammer.ts

@@ -48,8 +48,14 @@ export namespace JsonValidateStringifyProgrammer {
       statements: [
         ...validate.statements,
         ...stringify.statements,
-        StatementFactory.constant("__validate", validate.arrow),
-        StatementFactory.constant("__stringify", stringify.arrow),
+        StatementFactory.constant({
+          name: "__validate",
+          value: validate.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__stringify",
+          value: stringify.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,
@@ -60,9 +66,9 @@ export namespace JsonValidateStringifyProgrammer {
         ]),
         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,
@@ -70,7 +76,7 @@ export namespace JsonValidateStringifyProgrammer {
               ),
               TypeFactory.keyword("any"),
             ),
-          ),
+          }),
           ts.factory.createIfStatement(
             ts.factory.createIdentifier("result.success"),
             ts.factory.createExpressionStatement(

package/src/programmers/misc/MiscAssertCloneProgrammer.ts

@@ -39,8 +39,14 @@ export namespace MiscAssertCloneProgrammer {
       statements: [
         ...assert.statements,
         ...clone.statements,
-        StatementFactory.constant("__assert", assert.arrow),
-        StatementFactory.constant("__clone", clone.arrow),
+        StatementFactory.constant({
+          name: "__assert",
+          value: assert.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__clone",
+          value: clone.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,

package/src/programmers/misc/MiscAssertPruneProgrammer.ts

@@ -39,8 +39,14 @@ export namespace MiscAssertPruneProgrammer {
       statements: [
         ...assert.statements,
         ...prune.statements,
-        StatementFactory.constant("__assert", assert.arrow),
-        StatementFactory.constant("__prune", prune.arrow),
+        StatementFactory.constant({
+          name: "__assert",
+          value: assert.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__prune",
+          value: prune.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,
@@ -51,7 +57,10 @@ export namespace MiscAssertPruneProgrammer {
         ],
         ts.factory.createTypeReferenceNode(
           props.name ??
-            TypeFactory.getFullName(props.context.checker)(props.type),
+            TypeFactory.getFullName({
+              checker: props.context.checker,
+              type: props.type,
+            }),
         ),
         undefined,
         ts.factory.createBlock(