typia 7.0.0-dev.20241011 → 7.0.0-dev.20241012

package/src/programmers/helpers/NotationJoiner.ts

@@ -1,144 +1,144 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { Escaper } from "../../utils/Escaper";
-
-import { metadata_to_pattern } from "../internal/metadata_to_pattern";
-import { IExpressionEntry } from "./IExpressionEntry";
-
-export namespace NotationJoiner {
-  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 = 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 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(),
-        ),
-      );
-    statements.push(
-      ...dynamic.map((entry) =>
-        ts.factory.createIfStatement(
-          ts.factory.createCallExpression(
-            ts.factory.createIdentifier(
-              `RegExp(/${metadata_to_pattern({
-                top: true,
-                metadata: entry.key,
-              })}/).test`,
-            ),
-            undefined,
-            [key],
-          ),
-          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(),
-          ]),
-        ),
-      ),
-    );
-
-    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[];
-    rest: ts.Expression | null;
-  }): ts.Expression => {
-    return ts.factory.createAsExpression(
-      ts.factory.createArrayLiteralExpression(
-        props.rest === null
-          ? props.elements
-          : [...props.elements, ts.factory.createSpreadElement(props.rest)],
-        true,
-      ),
-      TypeFactory.keyword("any"),
-    );
-  };
-
-  export const array = (props: {
-    input: ts.Expression;
-    arrow: ts.Expression;
-  }) =>
-    ts.factory.createCallExpression(
-      ts.factory.createPropertyAccessExpression(props.input, "map"),
-      undefined,
-      [props.arrow],
-    );
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { Escaper } from "../../utils/Escaper";
+
+import { metadata_to_pattern } from "../internal/metadata_to_pattern";
+import { IExpressionEntry } from "./IExpressionEntry";
+
+export namespace NotationJoiner {
+  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 = 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 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(),
+        ),
+      );
+    statements.push(
+      ...dynamic.map((entry) =>
+        ts.factory.createIfStatement(
+          ts.factory.createCallExpression(
+            ts.factory.createIdentifier(
+              `RegExp(/${metadata_to_pattern({
+                top: true,
+                metadata: entry.key,
+              })}/).test`,
+            ),
+            undefined,
+            [key],
+          ),
+          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(),
+          ]),
+        ),
+      ),
+    );
+
+    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[];
+    rest: ts.Expression | null;
+  }): ts.Expression => {
+    return ts.factory.createAsExpression(
+      ts.factory.createArrayLiteralExpression(
+        props.rest === null
+          ? props.elements
+          : [...props.elements, ts.factory.createSpreadElement(props.rest)],
+        true,
+      ),
+      TypeFactory.keyword("any"),
+    );
+  };
+
+  export const array = (props: {
+    input: ts.Expression;
+    arrow: ts.Expression;
+  }) =>
+    ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(props.input, "map"),
+      undefined,
+      [props.arrow],
+    );
+}

package/src/programmers/helpers/ProtobufUtil.ts

@@ -1,125 +1,125 @@
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-
-import { ProtobufAtomic } from "../../typings/ProtobufAtomic";
-
-export namespace ProtobufUtil {
-  export const isStaticObject = (obj: MetadataObject): boolean =>
-    obj.properties.length >= 1 &&
-    obj.properties.every((p) => p.key.isSoleLiteral());
-
-  export const size = (meta: Metadata): number =>
-    getAtomics(meta).length +
-    meta.arrays.length +
-    meta.tuples.length +
-    meta.natives.length +
-    meta.objects.length +
-    meta.maps.length;
-
-  export const isUnion = (meta: Metadata): boolean => size(meta) > 1;
-
-  export const getAtomics = (meta: Metadata): ProtobufAtomic[] => {
-    const set: Set<ProtobufAtomic> = new Set();
-    if (meta.templates.length) set.add("string");
-    for (const c of meta.constants)
-      if (c.type === "boolean") set.add("bool");
-      else if (c.type === "bigint") set.add("uint64");
-      else if (c.type === "number")
-        set.add(deduce_numeric_type(c.values.map((v) => v.value) as number[]));
-      else if (c.type === "string") set.add("string");
-    for (const atomic of meta.atomics)
-      if (atomic.type === "boolean") set.add("bool");
-      else if (atomic.type === "bigint")
-        decode_bigint(atomic.tags).forEach((t) => set.add(t));
-      else if (atomic.type === "number")
-        decode_number(atomic.tags).forEach((t) => set.add(t));
-      else if (atomic.type === "string") set.add("string");
-
-    return [...set].sort(compare);
-  };
-
-  export const getNumbers = (meta: Metadata): ProtobufAtomic.Numeric[] => {
-    const set: Set<ProtobufAtomic.Numeric> = new Set();
-    for (const c of meta.constants)
-      if (c.type === "number")
-        set.add(deduce_numeric_type(c.values.map((v) => v.value) as number[]));
-    for (const atomic of meta.atomics)
-      if (atomic.type === "number")
-        decode_number(atomic.tags).forEach((t) => set.add(t));
-    return [...set].sort(compare);
-  };
-
-  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)
-      if (atomic.type === "bigint")
-        decode_bigint(atomic.tags).forEach((t) => set.add(t));
-    return [...set].sort(compare);
-  };
-
-  const compare = (x: ProtobufAtomic, y: ProtobufAtomic): number =>
-    ATOMIC_ORDER.get(x)! - ATOMIC_ORDER.get(y)!;
-}
-
-const ATOMIC_ORDER = new Map<ProtobufAtomic, number>(
-  (
-    [
-      "bool",
-      "int32",
-      "uint32",
-      "int64",
-      "uint64",
-      "float",
-      "double",
-      "string",
-    ] as const
-  ).map((str, i) => [str, i]),
-);
-
-const deduce_numeric_type = (values: number[]): ProtobufAtomic.Numeric =>
-  values.every((v) => Math.floor(v) === v)
-    ? values.every((v) => -2147483648 <= v && v <= 2147483647)
-      ? "int32"
-      : "int64"
-    : "double";
-
-const decode_bigint = (
-  typeTags: IMetadataTypeTag[][],
-): ProtobufAtomic.BigNumeric[] => {
-  if (typeTags.length === 0) return ["int64"];
-
-  const types: Set<ProtobufAtomic.BigNumeric> = new Set();
-  for (const row of typeTags) {
-    const value: ProtobufAtomic.BigNumeric | undefined = row.find(
-      (tag) =>
-        tag.kind === "type" &&
-        (tag.value === "int64" || tag.value === "uint64"),
-    )?.value;
-    types.add(value ?? "int64");
-  }
-  return [...types];
-};
-
-const decode_number = (
-  typeTags: IMetadataTypeTag[][],
-): ProtobufAtomic.Numeric[] => {
-  if (typeTags.length === 0) return ["double"];
-
-  const types: Set<ProtobufAtomic.Numeric> = new Set();
-  for (const row of typeTags) {
-    const value: ProtobufAtomic.Numeric | undefined = row.find(
-      (tag) =>
-        tag.kind === "type" &&
-        (tag.value === "int32" ||
-          tag.value === "uint32" ||
-          tag.value === "int64" ||
-          tag.value === "uint64" ||
-          tag.value === "float" ||
-          tag.value === "double"),
-    )?.value;
-    types.add(value ?? "double");
-  }
-  return [...types];
-};
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
+
+import { ProtobufAtomic } from "../../typings/ProtobufAtomic";
+
+export namespace ProtobufUtil {
+  export const isStaticObject = (obj: MetadataObjectType): boolean =>
+    obj.properties.length >= 1 &&
+    obj.properties.every((p) => p.key.isSoleLiteral());
+
+  export const size = (meta: Metadata): number =>
+    getAtomics(meta).length +
+    meta.arrays.length +
+    meta.tuples.length +
+    meta.natives.length +
+    meta.objects.length +
+    meta.maps.length;
+
+  export const isUnion = (meta: Metadata): boolean => size(meta) > 1;
+
+  export const getAtomics = (meta: Metadata): ProtobufAtomic[] => {
+    const set: Set<ProtobufAtomic> = new Set();
+    if (meta.templates.length) set.add("string");
+    for (const c of meta.constants)
+      if (c.type === "boolean") set.add("bool");
+      else if (c.type === "bigint") set.add("uint64");
+      else if (c.type === "number")
+        set.add(deduce_numeric_type(c.values.map((v) => v.value) as number[]));
+      else if (c.type === "string") set.add("string");
+    for (const atomic of meta.atomics)
+      if (atomic.type === "boolean") set.add("bool");
+      else if (atomic.type === "bigint")
+        decode_bigint(atomic.tags).forEach((t) => set.add(t));
+      else if (atomic.type === "number")
+        decode_number(atomic.tags).forEach((t) => set.add(t));
+      else if (atomic.type === "string") set.add("string");
+
+    return [...set].sort(compare);
+  };
+
+  export const getNumbers = (meta: Metadata): ProtobufAtomic.Numeric[] => {
+    const set: Set<ProtobufAtomic.Numeric> = new Set();
+    for (const c of meta.constants)
+      if (c.type === "number")
+        set.add(deduce_numeric_type(c.values.map((v) => v.value) as number[]));
+    for (const atomic of meta.atomics)
+      if (atomic.type === "number")
+        decode_number(atomic.tags).forEach((t) => set.add(t));
+    return [...set].sort(compare);
+  };
+
+  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)
+      if (atomic.type === "bigint")
+        decode_bigint(atomic.tags).forEach((t) => set.add(t));
+    return [...set].sort(compare);
+  };
+
+  const compare = (x: ProtobufAtomic, y: ProtobufAtomic): number =>
+    ATOMIC_ORDER.get(x)! - ATOMIC_ORDER.get(y)!;
+}
+
+const ATOMIC_ORDER = new Map<ProtobufAtomic, number>(
+  (
+    [
+      "bool",
+      "int32",
+      "uint32",
+      "int64",
+      "uint64",
+      "float",
+      "double",
+      "string",
+    ] as const
+  ).map((str, i) => [str, i]),
+);
+
+const deduce_numeric_type = (values: number[]): ProtobufAtomic.Numeric =>
+  values.every((v) => Math.floor(v) === v)
+    ? values.every((v) => -2147483648 <= v && v <= 2147483647)
+      ? "int32"
+      : "int64"
+    : "double";
+
+const decode_bigint = (
+  typeTags: IMetadataTypeTag[][],
+): ProtobufAtomic.BigNumeric[] => {
+  if (typeTags.length === 0) return ["int64"];
+
+  const types: Set<ProtobufAtomic.BigNumeric> = new Set();
+  for (const row of typeTags) {
+    const value: ProtobufAtomic.BigNumeric | undefined = row.find(
+      (tag) =>
+        tag.kind === "type" &&
+        (tag.value === "int64" || tag.value === "uint64"),
+    )?.value;
+    types.add(value ?? "int64");
+  }
+  return [...types];
+};
+
+const decode_number = (
+  typeTags: IMetadataTypeTag[][],
+): ProtobufAtomic.Numeric[] => {
+  if (typeTags.length === 0) return ["double"];
+
+  const types: Set<ProtobufAtomic.Numeric> = new Set();
+  for (const row of typeTags) {
+    const value: ProtobufAtomic.Numeric | undefined = row.find(
+      (tag) =>
+        tag.kind === "type" &&
+        (tag.value === "int32" ||
+          tag.value === "uint32" ||
+          tag.value === "int64" ||
+          tag.value === "uint64" ||
+          tag.value === "float" ||
+          tag.value === "double"),
+    )?.value;
+    types.add(value ?? "double");
+  }
+  return [...types];
+};