typia 7.0.0-dev.20240929 → 7.0.0-dev.20241001

package/src/programmers/helpers/NotationJoiner.ts

@@ -10,103 +10,105 @@ 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],
-            ),
-            ts.factory.createBlock([
-              ts.factory.createExpressionStatement(
-                ts.factory.createBinaryExpression(
-                  ts.factory.createElementAccessExpression(output, key),
-                  ts.factory.createToken(ts.SyntaxKind.EqualsToken),
-                  entry.expression,
+            )("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(),
-            ]),
+            ],
           ),
+          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(
+        "output",
+        ts.factory.createAsExpression(literal, TypeFactory.keyword("any")),
+      ),
+      ts.factory.createForOfStatement(
+        undefined,
+        StatementFactory.entry("key")("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)

package/src/programmers/helpers/PruneJoiner.ts

@@ -124,7 +124,10 @@ const iterate_dynamic_properties = (props: {
               ts.factory.createIfStatement(
                 ts.factory.createCallExpression(
                   ts.factory.createIdentifier(
-                    `RegExp(/${metadata_to_pattern(true)(dynamic.key)}/).test`,
+                    `RegExp(/${metadata_to_pattern({
+                      top: true,
+                      metadata: dynamic.key,
+                    })}/).test`,
                   ),
                   undefined,
                   [ts.factory.createIdentifier("key")],

package/src/programmers/helpers/RandomJoiner.ts

@@ -11,7 +11,7 @@ import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
 import { Escaper } from "../../utils/Escaper";
 
 export namespace RandomJoiner {
-  export type Decoder = (meta: Metadata) => ts.Expression;
+  export type Decoder = (metadata: Metadata) => ts.Expression;
 
   export const array = (props: {
     coalesce: (method: string) => ts.Expression;
@@ -54,7 +54,10 @@ export namespace RandomJoiner {
     );
   };
 
-  export const tuple = (props: { decode: Decoder; elements: Metadata[] }) =>
+  export const tuple = (props: {
+    decode: Decoder;
+    elements: Metadata[];
+  }): ts.ArrayLiteralExpression =>
     ts.factory.createArrayLiteralExpression(
       props.elements.map((elem) => props.decode(elem.rest ?? elem)),
       true,

package/src/programmers/helpers/RandomRanger.ts

@@ -182,7 +182,14 @@ const take = (props: {
   return value !== undefined ? Number(value) : undefined;
 };
 
-const multiplier = (props: { range: IRange; gap: number; value: number }) => {
+const multiplier = (props: {
+  range: IRange;
+  gap: number;
+  value: number;
+}): {
+  minimum: number;
+  maximum: number;
+} => {
   const minimum: number =
     props.range.minimum.value === undefined
       ? 0

package/src/programmers/helpers/StringifyJoinder.ts

@@ -24,7 +24,10 @@ export namespace StringifyJoiner {
       (entry) => !entry.key.isSoleLiteral(),
     );
     const expressions: ts.Expression[] = [
-      ...stringify_regular_properties(regular, dynamic),
+      ...stringify_regular_properties({
+        regular,
+        dynamic,
+      }),
       ...(dynamic.length
         ? [
             stringify_dynamic_properties(

package/src/programmers/helpers/StringifyPredicator.ts

@@ -4,9 +4,10 @@ export namespace StringifyPredicator {
   export const require_escape = (value: string): boolean =>
     value.split("").some((ch) => ESCAPED.some((escaped) => escaped === ch));
 
-  export const undefindable = (meta: Metadata): boolean =>
-    meta.isRequired() === false ||
-    (meta.escaped !== null && meta.escaped.returns.isRequired() === false);
+  export const undefindable = (metadata: Metadata): boolean =>
+    metadata.isRequired() === false ||
+    (metadata.escaped !== null &&
+      metadata.escaped.returns.isRequired() === false);
 
   const ESCAPED = ['"', "\\", "\b", "\f", "\n", "\n", "\r", "\t"];
 }