typia 7.0.0-dev.20241001 → 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 {
               },
             }),
           ),
-        ),
+        }),
       );
 
   /* -----------------------------------------------------------
@@ -443,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("{}"),
       });
 
@@ -451,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("{}"),
       });
 
@@ -467,7 +467,8 @@ export namespace JsonStringifyProgrammer {
                 (prop) => !prop.key.isSoleLiteral() || !prop.value.isRequired(),
               ),
             ),
-          })(props.input),
+            input: props.input,
+          }),
         value: () =>
           explore_objects({
             ...props,
@@ -648,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)],
         ),
@@ -699,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,
         );
@@ -735,7 +736,7 @@ export namespace JsonStringifyProgrammer {
     return decode({
       ...props,
       input: ts.factory.createCallExpression(
-        IdentifierFactory.access(props.input)("toJSON"),
+        IdentifierFactory.access(props.input, "toJSON"),
         undefined,
         [],
       ),
@@ -981,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"),
       },

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(

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")],
     );
 
   /* -----------------------------------------------------------
@@ -847,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(
@@ -858,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,

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,

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)],
         ),
@@ -580,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"),
       },

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,