typia 7.0.0-dev.20241001 → 7.0.0-dev.20241002-2

package/src/programmers/AssertProgrammer.ts

@@ -117,12 +117,18 @@ export namespace AssertProgrammer {
             ts.factory.createIdentifier("input"),
             ts.factory.createTypeReferenceNode(
               props.name ??
-                TypeFactory.getFullName(props.context.checker)(props.type),
+                TypeFactory.getFullName({
+                  checker: props.context.checker,
+                  type: props.type,
+                }),
             ),
           )
         : 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(
@@ -187,8 +193,13 @@ export namespace AssertProgrammer {
       statements: [
         ...is.statements,
         ...composed.statements,
-        StatementFactory.constant("__is", is.arrow),
-        StatementFactory.mut("_errorFactory"),
+        StatementFactory.constant({
+          name: "__is",
+          value: is.arrow,
+        }),
+        StatementFactory.mut({
+          name: "_errorFactory",
+        }),
       ],
       arrow,
     };
@@ -355,7 +366,7 @@ export namespace AssertProgrammer {
       }),
     array: (props) =>
       ts.factory.createCallExpression(
-        IdentifierFactory.access(props.input)("every"),
+        IdentifierFactory.access(props.input, "every"),
         undefined,
         [props.arrow],
       ),

package/src/programmers/CheckerProgrammer.ts

@@ -173,9 +173,9 @@ export namespace CheckerProgrammer {
       .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({
@@ -200,7 +200,7 @@ export namespace CheckerProgrammer {
               },
             }),
           ),
-        ),
+        }),
       );
 
   export const write_tuple_functions = (props: {
@@ -213,9 +213,9 @@ export namespace CheckerProgrammer {
       .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({
@@ -239,7 +239,7 @@ export namespace CheckerProgrammer {
               },
             }),
           ),
-        ),
+        }),
       );
 
   const configure = (props: {
@@ -254,7 +254,8 @@ export namespace CheckerProgrammer {
           undefined,
           "input",
           ts.factory.createTypeReferenceNode(
-            name ?? TypeFactory.getFullName(props.context.checker)(type),
+            name ??
+              TypeFactory.getFullName({ checker: props.context.checker, type }),
           ),
         ),
     },
@@ -530,7 +531,8 @@ export namespace CheckerProgrammer {
                 ],
               ),
             ),
-          )("has"),
+            "has",
+          ),
           undefined,
           [props.input],
         ),
@@ -808,7 +810,8 @@ export namespace CheckerProgrammer {
               (prop) => !prop.key.isSoleLiteral() || !prop.value.isRequired(),
             ),
           ),
-        })(props.input),
+          input: props.input,
+        }),
         expected: props.metadata.objects.map((obj) => obj.name).join(" | "),
         body: explore_objects({
           config: props.config,
@@ -1104,7 +1107,7 @@ export namespace CheckerProgrammer {
             context: props.context,
             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)],
             ),
@@ -1205,7 +1208,7 @@ export namespace CheckerProgrammer {
       undefined,
       [
         ts.factory.createCallExpression(
-          IdentifierFactory.access(props.input)("toJSON"),
+          IdentifierFactory.access(props.input, "toJSON"),
           undefined,
           [],
         ),

package/src/programmers/FeatureProgrammer.ts

@@ -397,9 +397,9 @@ export namespace FeatureProgrammer {
     collection: MetadataCollection;
   }) =>
     props.collection.objects().map((object) =>
-      StatementFactory.constant(
-        `${props.config.prefix}o${object.index}`,
-        ts.factory.createArrowFunction(
+      StatementFactory.constant({
+        name: `${props.config.prefix}o${object.index}`,
+        value: ts.factory.createArrowFunction(
           undefined,
           undefined,
           parameterDeclarations({
@@ -420,7 +420,7 @@ export namespace FeatureProgrammer {
             object,
           }),
         ),
-      ),
+      }),
     );
 
   export const write_union_functions = (props: {
@@ -428,13 +428,13 @@ export namespace FeatureProgrammer {
     collection: MetadataCollection;
   }) =>
     props.collection.unions().map((union, i) =>
-      StatementFactory.constant(
-        `${props.config.prefix}u${i}`,
-        write_union({
+      StatementFactory.constant({
+        name: `${props.config.prefix}u${i}`,
+        value: write_union({
           config: props.config,
           objects: union,
         }),
-      ),
+      }),
     );
 
   const write_union = (props: { config: IConfig; objects: MetadataObject[] }) =>

package/src/programmers/IsProgrammer.ts

@@ -81,7 +81,7 @@ export namespace IsProgrammer {
             }),
       array: (props) =>
         ts.factory.createCallExpression(
-          IdentifierFactory.access(props.input)("every"),
+          IdentifierFactory.access(props.input, "every"),
           undefined,
           [props.arrow],
         ),
@@ -259,10 +259,11 @@ export namespace IsProgrammer {
       ExpressionFactory.isObject({
         checkArray: false,
         checkNull: props.checkNull,
-      })(props.input),
+        input: props.input,
+      }),
       ts.factory.createStrictEquality(
         ts.factory.createStringLiteral("function"),
-        ValueFactory.TYPEOF(IdentifierFactory.access(props.input)("toJSON")),
+        ValueFactory.TYPEOF(IdentifierFactory.access(props.input, "toJSON")),
       ),
     );
 

package/src/programmers/RandomProgrammer.ts

@@ -107,7 +107,10 @@ export namespace RandomProgrammer {
         [
           ts.factory.createTypeReferenceNode(
             props.name ??
-              TypeFactory.getFullName(props.context.checker)(props.type),
+              TypeFactory.getFullName({
+                checker: props.context.checker,
+                type: props.type,
+              }),
           ),
         ],
         false,
@@ -138,7 +141,7 @@ export namespace RandomProgrammer {
     );
     return {
       functions,
-      statements: [StatementFactory.mut("_generator")],
+      statements: [StatementFactory.mut({ name: "_generator" })],
       arrow,
     };
   };
@@ -163,9 +166,9 @@ export namespace RandomProgrammer {
     collection: MetadataCollection;
   }): ts.VariableStatement[] =>
     props.collection.objects().map((obj, i) =>
-      StatementFactory.constant(
-        Prefix.object(i),
-        ts.factory.createArrowFunction(
+      StatementFactory.constant({
+        name: Prefix.object(i),
+        value: ts.factory.createArrowFunction(
           undefined,
           undefined,
           [
@@ -196,7 +199,7 @@ export namespace RandomProgrammer {
             object: obj,
           }),
         ),
-      ),
+      }),
     );
 
   const write_array_functions = (props: {
@@ -207,9 +210,9 @@ export namespace RandomProgrammer {
       .arrays()
       .filter((a) => a.recursive)
       .map((array, i) =>
-        StatementFactory.constant(
-          Prefix.array(i),
-          ts.factory.createArrowFunction(
+        StatementFactory.constant({
+          name: Prefix.array(i),
+          value: ts.factory.createArrowFunction(
             undefined,
             undefined,
             [
@@ -254,7 +257,7 @@ export namespace RandomProgrammer {
               metadata: array.value,
             }),
           ),
-        ),
+        }),
       );
 
   const write_tuple_functions = (props: {
@@ -265,9 +268,9 @@ export namespace RandomProgrammer {
       .tuples()
       .filter((a) => a.recursive)
       .map((tuple, i) =>
-        StatementFactory.constant(
-          Prefix.tuple(i),
-          ts.factory.createArrowFunction(
+        StatementFactory.constant({
+          name: Prefix.tuple(i),
+          value: ts.factory.createArrowFunction(
             undefined,
             undefined,
             [
@@ -297,7 +300,7 @@ export namespace RandomProgrammer {
               elements: tuple.elements,
             }),
           ),
-        ),
+        }),
       );
 
   /* -----------------------------------------------------------
@@ -1005,39 +1008,41 @@ export namespace RandomProgrammer {
             importer: props.importer,
             name: "Uint8Array",
           }),
-        )("buffer")
+          "buffer",
+        )
       : ExpressionFactory.selfCall(
           ts.factory.createBlock(
             [
-              StatementFactory.constant(
-                "length",
-                ts.factory.createCallExpression(
+              StatementFactory.constant({
+                name: "length",
+                value: ts.factory.createCallExpression(
                   coalesce(props.importer)("integer"),
                   undefined,
                   [],
                 ),
-              ),
-              StatementFactory.constant(
-                "buffer",
-                ts.factory.createNewExpression(
+              }),
+              StatementFactory.constant({
+                name: "buffer",
+                value: ts.factory.createNewExpression(
                   ts.factory.createIdentifier("SharedArrayBuffer"),
                   [],
                   [ts.factory.createIdentifier("length")],
                 ),
-              ),
-              StatementFactory.constant(
-                "bytes",
-                ts.factory.createNewExpression(
+              }),
+              StatementFactory.constant({
+                name: "bytes",
+                value: ts.factory.createNewExpression(
                   ts.factory.createIdentifier("Uint8Array"),
                   [],
                   [ts.factory.createIdentifier("buffer")],
                 ),
-              ),
+              }),
               ts.factory.createExpressionStatement(
                 ts.factory.createCallExpression(
                   IdentifierFactory.access(
                     ts.factory.createIdentifier("bytes"),
-                  )("set"),
+                    "set",
+                  ),
                   undefined,
                   [
                     ts.factory.createCallExpression(
@@ -1084,7 +1089,8 @@ export namespace RandomProgrammer {
             importer,
             name: "Uint8Array",
           }),
-        )("buffer"),
+          "buffer",
+        ),
       ],
     );
 
@@ -1121,7 +1127,8 @@ const coalesce = (importer: FunctionImporter) => (name: string) =>
           ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
           ts.factory.createStringLiteral(name),
         ),
-  )(IdentifierFactory.access(importer.use("generator"))(name));
+    IdentifierFactory.access(importer.use("generator"), name),
+  );
 
 const emendFormat = (key: keyof Format.Validator) =>
   key === "date-time"

package/src/programmers/ValidateProgrammer.ts

@@ -105,7 +105,10 @@ export namespace ValidateProgrammer {
       ts.factory.createTypeReferenceNode(
         `typia.IValidation<${
           props.name ??
-          TypeFactory.getFullName(props.context.checker)(props.type)
+          TypeFactory.getFullName({
+            checker: props.context.checker,
+            type: props.type,
+          })
         }>`,
       ),
       undefined,
@@ -142,7 +145,8 @@ export namespace ValidateProgrammer {
                           TypeFactory.keyword("any"),
                         ),
                       ),
-                    )("report"),
+                      "report",
+                    ),
                     [],
                     [ts.factory.createIdentifier("errors")],
                   ),
@@ -166,13 +170,13 @@ export namespace ValidateProgrammer {
                   ],
                 ),
               ),
-              StatementFactory.constant(
-                "success",
-                ts.factory.createStrictEquality(
+              StatementFactory.constant({
+                name: "success",
+                value: ts.factory.createStrictEquality(
                   ExpressionFactory.number(0),
                   ts.factory.createIdentifier("errors.length"),
                 ),
-              ),
+              }),
               ts.factory.createReturnStatement(
                 ts.factory.createAsExpression(
                   create_output(),
@@ -215,9 +219,12 @@ export namespace ValidateProgrammer {
       statements: [
         ...is.statements,
         ...composed.statements,
-        StatementFactory.constant("__is", is.arrow),
-        StatementFactory.mut("errors"),
-        StatementFactory.mut("$report"),
+        StatementFactory.constant({
+          name: "__is",
+          value: is.arrow,
+        }),
+        StatementFactory.mut({ name: "errors" }),
+        StatementFactory.mut({ name: "$report" }),
       ],
       arrow,
     };
@@ -363,7 +370,7 @@ const joiner = (props: {
   array: (props) =>
     check_everything(
       ts.factory.createCallExpression(
-        IdentifierFactory.access(props.input)("map"),
+        IdentifierFactory.access(props.input, "map"),
         undefined,
         [props.arrow],
       ),

package/src/programmers/functional/FunctionalAssertParametersProgrammer.ts

@@ -92,9 +92,9 @@ export namespace FunctionalAssertParametersProgrammer {
 
   export const decompose = (props: IDecomposeProps): IDecomposeOutput => ({
     functions: props.parameters.map((p, i) =>
-      StatementFactory.constant(
-        `__assert_param_${i}`,
-        AssertProgrammer.write({
+      StatementFactory.constant({
+        name: `__assert_param_${i}`,
+        value: AssertProgrammer.write({
           context: props.context,
           modulo: props.modulo,
           config: {
@@ -124,7 +124,7 @@ export namespace FunctionalAssertParametersProgrammer {
         // ),
         // undefined,
         // [ts.factory.createIdentifier(p.name.getText())],
-      ),
+      }),
     ),
     expressions: props.parameters.map((p, i) =>
       ts.factory.createCallExpression(

package/src/programmers/functional/FunctionalAssertReturnProgrammer.ts

@@ -87,9 +87,9 @@ export namespace FunctionAssertReturnProgrammer {
     return {
       async,
       functions: [
-        StatementFactory.constant(
-          "__assert_return",
-          AssertProgrammer.write({
+        StatementFactory.constant({
+          name: "__assert_return",
+          value: AssertProgrammer.write({
             context: props.context,
             modulo: props.modulo,
             config: {
@@ -103,7 +103,7 @@ export namespace FunctionAssertReturnProgrammer {
               replacer: "$input.return",
             }),
           }),
-        ),
+        }),
       ],
       value: ts.factory.createCallExpression(
         ts.factory.createIdentifier("__assert_return"),

package/src/programmers/functional/FunctionalIsParametersProgrammer.ts

@@ -80,9 +80,9 @@ export namespace FunctionalIsParametersProgrammer {
 
   export const decompose = (props: IDecomposeProps): IDecomposeOutput => ({
     functions: props.declaration.parameters.map((p, i) =>
-      StatementFactory.constant(
-        `__is_param_${i}`,
-        IsProgrammer.write({
+      StatementFactory.constant({
+        name: `__is_param_${i}`,
+        value: IsProgrammer.write({
           context: props.context,
           modulo: props.modulo,
           config: props.config,
@@ -92,7 +92,7 @@ export namespace FunctionalIsParametersProgrammer {
           init: undefined,
           name: undefined,
         }),
-      ),
+      }),
     ),
     statements: props.declaration.parameters
       .map((p, i) => [

package/src/programmers/functional/FunctionalIsReturnProgrammer.ts

@@ -81,21 +81,21 @@ export namespace FunctionalIsReturnProgrammer {
     return {
       async,
       functions: [
-        StatementFactory.constant(
-          "__is_return",
-          IsProgrammer.write({
+        StatementFactory.constant({
+          name: "__is_return",
+          value: IsProgrammer.write({
             ...props,
             type,
             name: undefined,
             init: undefined,
           }),
-        ),
+        }),
       ],
       statements: [
-        StatementFactory.constant(
+        StatementFactory.constant({
           name,
-          async ? ts.factory.createAwaitExpression(caller) : caller,
-        ),
+          value: async ? ts.factory.createAwaitExpression(caller) : caller,
+        }),
         ts.factory.createReturnStatement(
           ts.factory.createConditionalExpression(
             ts.factory.createCallExpression(

package/src/programmers/functional/FunctionalValidateParametersProgrammer.ts

@@ -202,9 +202,9 @@ export namespace FunctionalValidateParametersProgrammer {
     );
     return {
       functions: props.declaration.parameters.map((p, i) =>
-        StatementFactory.constant(
-          `__validate_param_${i}`,
-          ValidateProgrammer.write({
+        StatementFactory.constant({
+          name: `__validate_param_${i}`,
+          value: ValidateProgrammer.write({
             ...props,
             type: props.context.checker.getTypeFromTypeNode(
               p.type ?? TypeFactory.keyword("any"),
@@ -212,10 +212,13 @@ export namespace FunctionalValidateParametersProgrammer {
             name: undefined,
             init: undefined,
           }),
-        ),
+        }),
       ),
       statements: [
-        StatementFactory.constant(resultName, failures),
+        StatementFactory.constant({
+          name: resultName,
+          value: failures,
+        }),
         ts.factory.createIfStatement(
           ts.factory.createStrictInequality(
             ts.factory.createNumericLiteral("0"),
@@ -238,7 +241,8 @@ export namespace FunctionalValidateParametersProgrammer {
                       ts.factory.createCallExpression(
                         IdentifierFactory.access(
                           ts.factory.createIdentifier(resultName),
-                        )("map"),
+                          "map",
+                        ),
                         undefined,
                         [
                           ts.factory.createArrowFunction(
@@ -254,11 +258,13 @@ export namespace FunctionalValidateParametersProgrammer {
                             undefined,
                             IdentifierFactory.access(
                               ts.factory.createIdentifier("r"),
-                            )("errors"),
+                              "errors",
+                            ),
                           ),
                         ],
                       ),
-                    )("flat"),
+                      "flat",
+                    ),
                     undefined,
                     undefined,
                   ),

package/src/programmers/functional/FunctionalValidateReturnProgrammer.ts

@@ -82,25 +82,25 @@ export namespace FunctionalValidateReturnProgrammer {
     return {
       async,
       functions: [
-        StatementFactory.constant(
-          "__validate_return",
-          ValidateProgrammer.write({
+        StatementFactory.constant({
+          name: "__validate_return",
+          value: ValidateProgrammer.write({
             ...props,
             type,
             name: undefined,
             init: undefined,
           }),
-        ),
+        }),
       ],
       statements: [
-        StatementFactory.constant(
+        StatementFactory.constant({
           name,
-          ts.factory.createCallExpression(
+          value: ts.factory.createCallExpression(
             ts.factory.createIdentifier("__validate_return"),
             undefined,
             [async ? ts.factory.createAwaitExpression(caller) : caller],
           ),
-        ),
+        }),
         ts.factory.createIfStatement(
           ts.factory.createStrictEquality(
             ts.factory.createFalse(),

package/src/programmers/helpers/CloneJoiner.ts

@@ -44,7 +44,8 @@ export namespace CloneJoiner {
                   ts.factory.createStringLiteral(r.key.getSoleLiteral()!),
                 ),
               ),
-            )("some"),
+              "some",
+            ),
             undefined,
             [
               ts.factory.createArrowFunction(
@@ -91,13 +92,19 @@ export namespace CloneJoiner {
     );
 
     return ts.factory.createBlock([
-      StatementFactory.constant(
-        "output",
-        ts.factory.createAsExpression(literal, TypeFactory.keyword("any")),
-      ),
+      StatementFactory.constant({
+        name: "output",
+        value: ts.factory.createAsExpression(
+          literal,
+          TypeFactory.keyword("any"),
+        ),
+      }),
       ts.factory.createForOfStatement(
         undefined,
-        StatementFactory.entry("key")("value"),
+        StatementFactory.entry({
+          key: "key",
+          value: "value",
+        }),
         ts.factory.createCallExpression(
           ts.factory.createIdentifier("Object.entries"),
           undefined,