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

package/src/programmers/helpers/FunctionImporter.ts

@@ -37,29 +37,30 @@ export class FunctionImporter {
   ): ts.Statement[] {
     return [
       ...[...this.used_].map((name) =>
-        StatementFactory.constant(
-          "$" + name,
-          IdentifierFactory.access(
+        StatementFactory.constant({
+          name: "$" + name,
+          value: IdentifierFactory.access(
             ts.factory.createParenthesizedExpression(
               ts.factory.createAsExpression(modulo, TypeFactory.keyword("any")),
             ),
-          )(name),
-        ),
+            name,
+          ),
+        }),
       ),
-      ...[...this.variables_.entries()].map(([key, value]) =>
-        StatementFactory.constant(key, value),
+      ...[...this.variables_.entries()].map(([name, value]) =>
+        StatementFactory.constant({ name, value }),
       ),
       ...(includeUnions === true
-        ? [...this.unions_.values()].map(([key, arrow]) =>
-            StatementFactory.constant(key, arrow),
+        ? [...this.unions_.values()].map(([name, value]) =>
+            StatementFactory.constant({ name, value }),
           )
         : []),
     ];
   }
 
   public declareUnions(): ts.Statement[] {
-    return [...this.unions_.values()].map(([key, arrow]) =>
-      StatementFactory.constant(key, arrow),
+    return [...this.unions_.values()].map(([name, value]) =>
+      StatementFactory.constant({ name, value }),
     );
   }
 

package/src/programmers/helpers/NotationJoiner.ts

@@ -45,7 +45,8 @@ export namespace NotationJoiner {
                   ts.factory.createStringLiteral(r.key.getSoleLiteral()!),
                 ),
               ),
-            )("some"),
+              "some",
+            ),
             undefined,
             [
               ts.factory.createArrowFunction(
@@ -92,13 +93,19 @@ export namespace NotationJoiner {
     );
 
     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,

package/src/programmers/helpers/PruneJoiner.ts

@@ -45,7 +45,7 @@ export namespace PruneJoiner {
     arrow: ts.ArrowFunction;
   }) =>
     ts.factory.createCallExpression(
-      IdentifierFactory.access(props.input)("forEach"),
+      IdentifierFactory.access(props.input, "forEach"),
       undefined,
       [props.arrow],
     );
@@ -80,7 +80,8 @@ const iterate_dynamic_properties = (props: {
         undefined,
         [props.input],
       ),
-    )("forEach"),
+      "forEach",
+    ),
     undefined,
     [
       ts.factory.createArrowFunction(

package/src/programmers/helpers/RandomJoiner.ts

@@ -104,10 +104,13 @@ export namespace RandomJoiner {
     );
     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"),
+          ),
+        }),
         ...(props.object.recursive
           ? [
               ts.factory.createIfStatement(

package/src/programmers/helpers/StringifyJoinder.ts

@@ -70,7 +70,7 @@ export namespace StringifyJoiner {
       ts.factory.createCallExpression(
         ts.factory.createPropertyAccessExpression(
           ts.factory.createCallExpression(
-            IdentifierFactory.access(props.input)("map"),
+            IdentifierFactory.access(props.input, "map"),
             undefined,
             [props.arrow],
           ),

package/src/programmers/helpers/UnionExplorer.ts

@@ -73,7 +73,8 @@ export namespace UnionExplorer {
       .filter((spec) => spec.property.key.getSoleLiteral() !== null)
       .map((spec, i, array) => {
         const key: string = spec.property.key.getSoleLiteral()!;
-        const accessor: ts.Expression = IdentifierFactory.access(props.input)(
+        const accessor: ts.Expression = IdentifierFactory.access(
+          props.input,
           key,
         );
         const pred: ts.Expression = spec.neighbour
@@ -181,7 +182,7 @@ export namespace UnionExplorer {
       accessor: {
         transform: (x) => x,
         element: (x) => x.type.value,
-        size: (input) => IdentifierFactory.access(input)("length"),
+        size: (input) => IdentifierFactory.access(input, "length"),
         front: (input) => ts.factory.createElementAccessExpression(input, 0),
         array: (input) => input,
         name: (t) => t.type.name,
@@ -214,7 +215,7 @@ export namespace UnionExplorer {
       accessor: {
         transform: (x) => x,
         element: (x) => (x instanceof MetadataArray ? x.type.value : x),
-        size: (input) => IdentifierFactory.access(input)("length"),
+        size: (input) => IdentifierFactory.access(input, "length"),
         front: (input) => ts.factory.createElementAccessExpression(input, 0),
         array: (input) => input,
         name: (m) => m.type.name,
@@ -253,21 +254,23 @@ export namespace UnionExplorer {
             }),
           }),
         element: (array) => array.type.value,
-        size: (input) => IdentifierFactory.access(input)("size"),
+        size: (input) => IdentifierFactory.access(input, "size"),
         front: (input) =>
           IdentifierFactory.access(
             ts.factory.createCallExpression(
               IdentifierFactory.access(
                 ts.factory.createCallExpression(
-                  IdentifierFactory.access(input)("values"),
+                  IdentifierFactory.access(input, "values"),
                   undefined,
                   undefined,
                 ),
-              )("next"),
+                "next",
+              ),
               undefined,
               undefined,
             ),
-          )("value"),
+            "value",
+          ),
         array: (input) =>
           ts.factory.createArrayLiteralExpression(
             [ts.factory.createSpreadElement(input)],
@@ -300,21 +303,23 @@ export namespace UnionExplorer {
         accessor: {
           element: (array) =>
             array.type.value.tuples[0]!.type.elements as [Metadata, Metadata],
-          size: (input) => IdentifierFactory.access(input)("size"),
+          size: (input) => IdentifierFactory.access(input, "size"),
           front: (input) =>
             IdentifierFactory.access(
               ts.factory.createCallExpression(
                 IdentifierFactory.access(
                   ts.factory.createCallExpression(
-                    IdentifierFactory.access(input)("entries"),
+                    IdentifierFactory.access(input, "entries"),
                     undefined,
                     undefined,
                   ),
-                )("next"),
+                  "next",
+                ),
                 undefined,
                 undefined,
               ),
-            )("value"),
+              "value",
+            ),
           array: (input) =>
             ts.factory.createArrayLiteralExpression(
               [ts.factory.createSpreadElement(input)],

package/src/programmers/helpers/UnionPredicator.ts

@@ -20,7 +20,7 @@ export namespace UnionPredicator {
       for (const prop of obj.properties) {
         const key: string | null = prop.key.getSoleLiteral();
         if (key !== null)
-          MapUtil.take(matrix)(key, () =>
+          MapUtil.take(matrix, key, () =>
             ArrayUtil.repeat(objects.length, () => null),
           );
       }

package/src/programmers/http/HttpAssertFormDataProgrammer.ts

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

package/src/programmers/http/HttpAssertHeadersProgrammer.ts

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

package/src/programmers/http/HttpAssertQueryProgrammer.ts

@@ -50,8 +50,14 @@ export namespace HttpAssertQueryProgrammer {
       statements: [
         ...assert.statements,
         ...decode.statements,
-        StatementFactory.constant("__assert", assert.arrow),
-        StatementFactory.constant("__decode", decode.arrow),
+        StatementFactory.constant({
+          name: "__assert",
+          value: assert.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__decode",
+          value: decode.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,

package/src/programmers/http/HttpFormDataProgrammer.ts

@@ -76,7 +76,10 @@ export namespace HttpFormDataProgrammer {
           [
             ts.factory.createTypeReferenceNode(
               props.name ??
-                TypeFactory.getFullName(props.context.checker)(props.type),
+                TypeFactory.getFullName({
+                  checker: props.context.checker,
+                  type: props.type,
+                }),
             ),
           ],
           false,
@@ -164,9 +167,9 @@ export namespace HttpFormDataProgrammer {
     // const input: ts.Identifier = ts.factory.createIdentifier("input");
     const output: ts.Identifier = ts.factory.createIdentifier("output");
     return [
-      StatementFactory.constant(
-        "output",
-        ts.factory.createObjectLiteralExpression(
+      StatementFactory.constant({
+        name: "output",
+        value: ts.factory.createObjectLiteralExpression(
           props.object.properties.map((p) =>
             decode_regular_property({
               importer: props.importer,
@@ -175,7 +178,7 @@ export namespace HttpFormDataProgrammer {
           ),
           true,
         ),
-      ),
+      }),
       ts.factory.createReturnStatement(
         ts.factory.createAsExpression(output, TypeFactory.keyword("any")),
       ),
@@ -228,7 +231,8 @@ export namespace HttpFormDataProgrammer {
                   undefined,
                   [ts.factory.createStringLiteral(key)],
                 ),
-              )("map"),
+                "map",
+              ),
               undefined,
               [
                 ts.factory.createArrowFunction(

package/src/programmers/http/HttpHeadersProgrammer.ts

@@ -80,7 +80,10 @@ export namespace HttpHeadersProgrammer {
           [
             ts.factory.createTypeReferenceNode(
               props.name ??
-                TypeFactory.getFullName(props.context.checker)(props.type),
+                TypeFactory.getFullName({
+                  checker: props.context.checker,
+                  type: props.type,
+                }),
             ),
           ],
           false,
@@ -185,7 +188,7 @@ export namespace HttpHeadersProgrammer {
         const key: string | null = prop.key.getSoleLiteral();
         if (key === null) continue;
 
-        MapUtil.take(counter)(key.toLowerCase(), () => new Set()).add(key);
+        MapUtil.take(counter, key.toLowerCase(), () => new Set()).add(key);
       }
       for (const [key, set] of counter)
         if (set.size > 1)
@@ -205,9 +208,9 @@ export namespace HttpHeadersProgrammer {
     const output: ts.Identifier = ts.factory.createIdentifier("output");
     const optionals: string[] = [];
     return [
-      StatementFactory.constant(
-        "output",
-        ts.factory.createObjectLiteralExpression(
+      StatementFactory.constant({
+        name: "output",
+        value: ts.factory.createObjectLiteralExpression(
           props.object.properties.map((p) => {
             if (
               !p.value.isRequired() &&
@@ -221,13 +224,13 @@ export namespace HttpHeadersProgrammer {
           }),
           true,
         ),
-      ),
+      }),
       ...optionals.map((key) => {
-        const access = IdentifierFactory.access(output)(key);
+        const access = IdentifierFactory.access(output, key);
         return ts.factory.createIfStatement(
           ts.factory.createStrictEquality(
             ExpressionFactory.number(0),
-            IdentifierFactory.access(access)("length"),
+            IdentifierFactory.access(access, "length"),
           ),
           ts.factory.createExpressionStatement(
             ts.factory.createDeleteExpression(access),
@@ -266,7 +269,8 @@ export namespace HttpHeadersProgrammer {
             })();
     const input = IdentifierFactory.access(
       ts.factory.createIdentifier("input"),
-    )(key.toLowerCase());
+      key.toLowerCase(),
+    );
 
     return ts.factory.createPropertyAssignment(
       Escaper.variable(key) ? key : ts.factory.createStringLiteral(key),
@@ -335,7 +339,7 @@ export namespace HttpHeadersProgrammer {
       ExpressionFactory.isArray(props.input),
       undefined,
       ts.factory.createCallExpression(
-        IdentifierFactory.access(props.input)("map"),
+        IdentifierFactory.access(props.input, "map"),
         undefined,
         [props.importer.use(props.type)],
       ),

package/src/programmers/http/HttpIsFormDataProgrammer.ts

@@ -42,8 +42,14 @@ export namespace HttpIsFormDataProgrammer {
       statements: [
         ...is.statements,
         ...decode.statements,
-        StatementFactory.constant("__is", is.arrow),
-        StatementFactory.constant("__decode", decode.arrow),
+        StatementFactory.constant({
+          name: "__is",
+          value: is.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__decode",
+          value: decode.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,
@@ -56,14 +62,14 @@ export namespace HttpIsFormDataProgrammer {
         undefined,
         ts.factory.createBlock(
           [
-            StatementFactory.constant(
-              "value",
-              ts.factory.createCallExpression(
+            StatementFactory.constant({
+              name: "value",
+              value: ts.factory.createCallExpression(
                 ts.factory.createIdentifier("__decode"),
                 undefined,
                 [ts.factory.createIdentifier("input")],
               ),
-            ),
+            }),
             ts.factory.createIfStatement(
               ts.factory.createPrefixUnaryExpression(
                 ts.SyntaxKind.ExclamationToken,

package/src/programmers/http/HttpIsHeadersProgrammer.ts

@@ -42,8 +42,14 @@ export namespace HttpIsHeadersProgrammer {
       statements: [
         ...is.statements,
         ...decode.statements,
-        StatementFactory.constant("__is", is.arrow),
-        StatementFactory.constant("__decode", decode.arrow),
+        StatementFactory.constant({
+          name: "__is",
+          value: is.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__decode",
+          value: decode.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,
@@ -56,14 +62,14 @@ export namespace HttpIsHeadersProgrammer {
         undefined,
         ts.factory.createBlock(
           [
-            StatementFactory.constant(
-              "value",
-              ts.factory.createCallExpression(
+            StatementFactory.constant({
+              name: "value",
+              value: ts.factory.createCallExpression(
                 ts.factory.createIdentifier("__decode"),
                 undefined,
                 [ts.factory.createIdentifier("input")],
               ),
-            ),
+            }),
             ts.factory.createIfStatement(
               ts.factory.createPrefixUnaryExpression(
                 ts.SyntaxKind.ExclamationToken,

package/src/programmers/http/HttpIsQueryProgrammer.ts

@@ -47,8 +47,14 @@ export namespace HttpIsQueryProgrammer {
       statements: [
         ...is.statements,
         ...decode.statements,
-        StatementFactory.constant("__is", is.arrow),
-        StatementFactory.constant("__decode", decode.arrow),
+        StatementFactory.constant({
+          name: "__is",
+          value: is.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__decode",
+          value: decode.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,
@@ -61,14 +67,14 @@ export namespace HttpIsQueryProgrammer {
         undefined,
         ts.factory.createBlock(
           [
-            StatementFactory.constant(
-              "value",
-              ts.factory.createCallExpression(
+            StatementFactory.constant({
+              name: "value",
+              value: ts.factory.createCallExpression(
                 ts.factory.createIdentifier("__decode"),
                 undefined,
                 [ts.factory.createIdentifier("input")],
               ),
-            ),
+            }),
             ts.factory.createIfStatement(
               ts.factory.createPrefixUnaryExpression(
                 ts.SyntaxKind.ExclamationToken,

package/src/programmers/http/HttpParameterProgrammer.ts

@@ -37,9 +37,9 @@ export namespace HttpParameterProgrammer {
       props.modulo.getText(),
     );
     const block: ts.Statement[] = [
-      StatementFactory.constant(
-        "assert",
-        AssertProgrammer.write({
+      StatementFactory.constant({
+        name: "assert",
+        value: AssertProgrammer.write({
           ...props,
           context: {
             ...props.context,
@@ -52,13 +52,15 @@ export namespace HttpParameterProgrammer {
             guard: false,
           },
         }),
-      ),
-      StatementFactory.constant(
-        "value",
-        ts.factory.createCallExpression(importer.use(atomic), undefined, [
-          ts.factory.createIdentifier("input"),
-        ]),
-      ),
+      }),
+      StatementFactory.constant({
+        name: "value",
+        value: ts.factory.createCallExpression(
+          importer.use(atomic),
+          undefined,
+          [ts.factory.createIdentifier("input")],
+        ),
+      }),
       ts.factory.createReturnStatement(
         ts.factory.createCallExpression(
           ts.factory.createIdentifier("assert"),
@@ -79,7 +81,10 @@ export namespace HttpParameterProgrammer {
       ],
       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/http/HttpQueryProgrammer.ts

@@ -84,7 +84,10 @@ export namespace HttpQueryProgrammer {
           [
             ts.factory.createTypeReferenceNode(
               props.name ??
-                TypeFactory.getFullName(props.context.checker)(props.type),
+                TypeFactory.getFullName({
+                  checker: props.context.checker,
+                  type: props.type,
+                }),
             ),
           ],
           false,
@@ -198,9 +201,9 @@ export namespace HttpQueryProgrammer {
           ),
         ),
       ),
-      StatementFactory.constant(
-        "output",
-        ts.factory.createObjectLiteralExpression(
+      StatementFactory.constant({
+        name: "output",
+        value: ts.factory.createObjectLiteralExpression(
           props.object.properties.map((p) =>
             decode_regular_property({
               importer: props.importer,
@@ -209,7 +212,7 @@ export namespace HttpQueryProgrammer {
           ),
           true,
         ),
-      ),
+      }),
       ts.factory.createReturnStatement(
         ts.factory.createAsExpression(output, TypeFactory.keyword("any")),
       ),
@@ -253,7 +256,8 @@ export namespace HttpQueryProgrammer {
                   undefined,
                   [ts.factory.createStringLiteral(key)],
                 ),
-              )("map"),
+                "map",
+              ),
               undefined,
               [
                 ts.factory.createArrowFunction(

package/src/programmers/http/HttpValidateFormDataProgrammer.ts

@@ -41,8 +41,14 @@ export namespace HttpValidateFormDataProgrammer {
       },
       statements: [
         ...validate.statements,
-        StatementFactory.constant("__validate", validate.arrow),
-        StatementFactory.constant("__decode", decode.arrow),
+        StatementFactory.constant({
+          name: "__validate",
+          value: validate.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__decode",
+          value: decode.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,

package/src/programmers/http/HttpValidateHeadersProgrammer.ts

@@ -41,8 +41,14 @@ export namespace HttpValidateHeadersProgrammer {
       },
       statements: [
         ...validate.statements,
-        StatementFactory.constant("__validate", validate.arrow),
-        StatementFactory.constant("__decode", decode.arrow),
+        StatementFactory.constant({
+          name: "__validate",
+          value: validate.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__decode",
+          value: decode.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,

package/src/programmers/http/HttpValidateQueryProgrammer.ts

@@ -46,8 +46,14 @@ export namespace HttpValidateQueryProgrammer {
       },
       statements: [
         ...validate.statements,
-        StatementFactory.constant("__validate", validate.arrow),
-        StatementFactory.constant("__decode", decode.arrow),
+        StatementFactory.constant({
+          name: "__validate",
+          value: validate.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__decode",
+          value: decode.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,

package/src/programmers/internal/check_array_length.ts

@@ -40,7 +40,7 @@ const check_array_type_tags = (props: {
         expected: `Array<> & ${tag.name}`,
         expression: (
           tag.predicate ??
-          ExpressionFactory.transpile(props.context.transformer)(tag.validate!)
+          ExpressionFactory.transpile(props.context.transformer, tag.validate!)
         )(props.input),
       })),
     );

package/src/programmers/internal/check_bigint.ts

@@ -43,7 +43,7 @@ const check_bigint_type_tags = (props: {
         expected: `bigint & ${tag.name}`,
         expression: (
           tag.predicate ??
-          ExpressionFactory.transpile(props.context.transformer)(tag.validate!)
+          ExpressionFactory.transpile(props.context.transformer, tag.validate!)
         )(props.input),
       })),
     );