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

package/src/programmers/ValidateProgrammer.ts

@@ -12,6 +12,7 @@ import { CheckerProgrammer } from "./CheckerProgrammer";
 import { FeatureProgrammer } from "./FeatureProgrammer";
 import { IsProgrammer } from "./IsProgrammer";
 import { FunctionImporter } from "./helpers/FunctionImporter";
+import { IExpressionEntry } from "./helpers/IExpressionEntry";
 import { OptionPredicator } from "./helpers/OptionPredicator";
 import { check_everything } from "./internal/check_everything";
 import { check_object } from "./internal/check_object";
@@ -104,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,
@@ -141,7 +145,8 @@ export namespace ValidateProgrammer {
                           TypeFactory.keyword("any"),
                         ),
                       ),
-                    )("report"),
+                      "report",
+                    ),
                     [],
                     [ts.factory.createIdentifier("errors")],
                   ),
@@ -165,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(),
@@ -214,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,
     };
@@ -252,7 +260,14 @@ const combine =
     if (next.explore.tracable === false)
       return IsProgrammer.configure({
         options: {
-          object: validate_object(props),
+          object: (v) =>
+            validate_object({
+              context: props.context,
+              importer: props.importer,
+              config: props.config,
+              entries: v.entries,
+              input: v.input,
+            }),
           numeric: true,
         },
         context: props.context,
@@ -301,46 +316,61 @@ const validate_object = (props: {
   config: ValidateProgrammer.IConfig;
   context: ITypiaContext;
   importer: FunctionImporter;
+  entries: IExpressionEntry<ts.Expression>[];
+  input: ts.Expression;
 }) =>
   check_object({
-    equals: props.config.equals,
-    undefined: true,
-    assert: false,
-    reduce: ts.factory.createLogicalAnd,
-    positive: ts.factory.createTrue(),
-    superfluous: (input) =>
-      create_report_call({
-        path: ts.factory.createAdd(
-          ts.factory.createIdentifier("_path"),
-          ts.factory.createCallExpression(
-            props.importer.use("join"),
-            undefined,
-            [ts.factory.createIdentifier("key")],
+    config: {
+      equals: props.config.equals,
+      undefined: true,
+      assert: false,
+      reduce: ts.factory.createLogicalAnd,
+      positive: ts.factory.createTrue(),
+      superfluous: (input) =>
+        create_report_call({
+          path: ts.factory.createAdd(
+            ts.factory.createIdentifier("_path"),
+            ts.factory.createCallExpression(
+              props.importer.use("join"),
+              undefined,
+              [ts.factory.createIdentifier("key")],
+            ),
           ),
+          expected: "undefined",
+          input,
+        }),
+      halt: (expr) =>
+        ts.factory.createLogicalOr(
+          ts.factory.createStrictEquality(
+            ts.factory.createFalse(),
+            ts.factory.createIdentifier("_exceptionable"),
+          ),
+          expr,
         ),
-        expected: "undefined",
-        input,
-      }),
-    halt: (expr) =>
-      ts.factory.createLogicalOr(
-        ts.factory.createStrictEquality(
-          ts.factory.createFalse(),
-          ts.factory.createIdentifier("_exceptionable"),
-        ),
-        expr,
-      ),
-  })(props.context)(props.importer);
+    },
+    context: props.context,
+    importer: props.importer,
+    entries: props.entries,
+    input: props.input,
+  });
 
 const joiner = (props: {
   config: ValidateProgrammer.IConfig;
   context: ITypiaContext;
   importer: FunctionImporter;
 }): CheckerProgrammer.IConfig.IJoiner => ({
-  object: validate_object(props),
+  object: (v) =>
+    validate_object({
+      context: props.context,
+      importer: props.importer,
+      config: props.config,
+      entries: v.entries,
+      input: v.input,
+    }),
   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(
@@ -68,7 +69,10 @@ export namespace CloneJoiner {
         ts.factory.createIfStatement(
           ts.factory.createCallExpression(
             ts.factory.createIdentifier(
-              `RegExp(/${metadata_to_pattern(true)(entry.key)}/).test`,
+              `RegExp(/${metadata_to_pattern({
+                top: true,
+                metadata: entry.key,
+              })}/).test`,
             ),
             undefined,
             [key],
@@ -88,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,

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

@@ -10,103 +10,112 @@ import { metadata_to_pattern } from "../internal/metadata_to_pattern";
 import { IExpressionEntry } from "./IExpressionEntry";
 
 export namespace NotationJoiner {
-  export const object =
-    (rename: (str: string) => string) =>
-    (props: {
-      input: ts.Expression;
-      entries: IExpressionEntry<ts.Expression>[];
-    }): ts.ConciseBody => {
-      if (props.entries.length === 0) return ts.factory.createIdentifier("{}");
+  export const object = (props: {
+    rename: (str: string) => string;
+    input: ts.Expression;
+    entries: IExpressionEntry<ts.Expression>[];
+  }): ts.ConciseBody => {
+    if (props.entries.length === 0) return ts.factory.createIdentifier("{}");
 
-      const regular = props.entries.filter((e) => e.key.isSoleLiteral());
-      const dynamic = props.entries.filter((e) => !e.key.isSoleLiteral());
-      const literal = ts.factory.createObjectLiteralExpression(
-        regular.map((entry) => {
-          const str: string = rename(entry.key.getSoleLiteral()!);
-          return ts.factory.createPropertyAssignment(
-            Escaper.variable(str) ? str : ts.factory.createStringLiteral(str),
-            entry.expression,
-          );
-        }),
-        true,
-      );
-      if (dynamic.length === 0) return literal;
+    const regular = props.entries.filter((e) => e.key.isSoleLiteral());
+    const dynamic = props.entries.filter((e) => !e.key.isSoleLiteral());
+    const literal = ts.factory.createObjectLiteralExpression(
+      regular.map((entry) => {
+        const str: string = props.rename(entry.key.getSoleLiteral()!);
+        return ts.factory.createPropertyAssignment(
+          Escaper.variable(str) ? str : ts.factory.createStringLiteral(str),
+          entry.expression,
+        );
+      }),
+      true,
+    );
+    if (dynamic.length === 0) return literal;
 
-      const key = ts.factory.createIdentifier("key");
-      const output = ts.factory.createIdentifier("output");
+    const key = ts.factory.createIdentifier("key");
+    const output = ts.factory.createIdentifier("output");
 
-      const statements: ts.Statement[] = [];
-      if (regular.length !== 0)
-        statements.push(
-          ts.factory.createIfStatement(
-            ts.factory.createCallExpression(
-              IdentifierFactory.access(
-                ts.factory.createArrayLiteralExpression(
-                  regular.map((r) =>
-                    ts.factory.createStringLiteral(r.key.getSoleLiteral()!),
-                  ),
-                ),
-              )("some"),
-              undefined,
-              [
-                ts.factory.createArrowFunction(
-                  undefined,
-                  undefined,
-                  [IdentifierFactory.parameter("regular")],
-                  undefined,
-                  undefined,
-                  ts.factory.createStrictEquality(
-                    ts.factory.createIdentifier("regular"),
-                    ts.factory.createIdentifier("key"),
-                  ),
-                ),
-              ],
-            ),
-            ts.factory.createContinueStatement(),
-          ),
-        );
+    const statements: ts.Statement[] = [];
+    if (regular.length !== 0)
       statements.push(
-        ...dynamic.map((entry) =>
-          ts.factory.createIfStatement(
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier(
-                `RegExp(/${metadata_to_pattern(true)(entry.key)}/).test`,
+        ts.factory.createIfStatement(
+          ts.factory.createCallExpression(
+            IdentifierFactory.access(
+              ts.factory.createArrayLiteralExpression(
+                regular.map((r) =>
+                  ts.factory.createStringLiteral(r.key.getSoleLiteral()!),
+                ),
               ),
-              undefined,
-              [key],
+              "some",
             ),
-            ts.factory.createBlock([
-              ts.factory.createExpressionStatement(
-                ts.factory.createBinaryExpression(
-                  ts.factory.createElementAccessExpression(output, key),
-                  ts.factory.createToken(ts.SyntaxKind.EqualsToken),
-                  entry.expression,
+            undefined,
+            [
+              ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("regular")],
+                undefined,
+                undefined,
+                ts.factory.createStrictEquality(
+                  ts.factory.createIdentifier("regular"),
+                  ts.factory.createIdentifier("key"),
                 ),
               ),
-              ts.factory.createContinueStatement(),
-            ]),
+            ],
           ),
+          ts.factory.createContinueStatement(),
         ),
       );
-
-      return ts.factory.createBlock([
-        StatementFactory.constant(
-          "output",
-          ts.factory.createAsExpression(literal, TypeFactory.keyword("any")),
-        ),
-        ts.factory.createForOfStatement(
-          undefined,
-          StatementFactory.entry("key")("value"),
+    statements.push(
+      ...dynamic.map((entry) =>
+        ts.factory.createIfStatement(
           ts.factory.createCallExpression(
-            ts.factory.createIdentifier("Object.entries"),
+            ts.factory.createIdentifier(
+              `RegExp(/${metadata_to_pattern({
+                top: true,
+                metadata: entry.key,
+              })}/).test`,
+            ),
             undefined,
-            [props.input],
+            [key],
           ),
-          ts.factory.createBlock(statements),
+          ts.factory.createBlock([
+            ts.factory.createExpressionStatement(
+              ts.factory.createBinaryExpression(
+                ts.factory.createElementAccessExpression(output, key),
+                ts.factory.createToken(ts.SyntaxKind.EqualsToken),
+                entry.expression,
+              ),
+            ),
+            ts.factory.createContinueStatement(),
+          ]),
         ),
-        ts.factory.createReturnStatement(output),
-      ]);
-    };
+      ),
+    );
+
+    return ts.factory.createBlock([
+      StatementFactory.constant({
+        name: "output",
+        value: ts.factory.createAsExpression(
+          literal,
+          TypeFactory.keyword("any"),
+        ),
+      }),
+      ts.factory.createForOfStatement(
+        undefined,
+        StatementFactory.entry({
+          key: "key",
+          value: "value",
+        }),
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("Object.entries"),
+          undefined,
+          [props.input],
+        ),
+        ts.factory.createBlock(statements),
+      ),
+      ts.factory.createReturnStatement(output),
+    ]);
+  };
 
   export const tuple = (props: {
     elements: ts.Expression[];

package/src/programmers/helpers/ProtobufUtil.ts

@@ -39,7 +39,7 @@ export namespace ProtobufUtil {
     return [...set].sort(compare);
   };
 
-  export const getNumbers = (meta: Metadata) => {
+  export const getNumbers = (meta: Metadata): ProtobufAtomic.Numeric[] => {
     const set: Set<ProtobufAtomic.Numeric> = new Set();
     for (const c of meta.constants)
       if (c.type === "number")
@@ -50,7 +50,7 @@ export namespace ProtobufUtil {
     return [...set].sort(compare);
   };
 
-  export const getBigints = (meta: Metadata) => {
+  export const getBigints = (meta: Metadata): ProtobufAtomic.BigNumeric[] => {
     const set: Set<ProtobufAtomic.BigNumeric> = new Set();
     for (const c of meta.constants) if (c.type === "bigint") set.add("uint64");
     for (const atomic of meta.atomics)