typia 7.2.1 → 7.3.0-dev.20241213

package/src/programmers/helpers/ProtobufUtil.ts

@@ -1,228 +1,228 @@
-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).size +
-    meta.arrays.length +
-    meta.tuples.length +
-    meta.natives.length +
-    meta.objects.length +
-    meta.maps.length;
-
-  export const getSequence = (tags: IMetadataTypeTag[]): number | null => {
-    const sequence = tags.find(
-      (t) =>
-        t.kind === "sequence" &&
-        typeof (t.schema as any)?.["x-protobuf-sequence"] === "number",
-    );
-    if (sequence === undefined) return null;
-    const value: number = Number(
-      (sequence.schema as any)["x-protobuf-sequence"],
-    );
-    return Number.isNaN(value) ? null : value;
-  };
-
-  export const isUnion = (meta: Metadata): boolean => size(meta) > 1;
-
-  export const getAtomics = (
-    meta: Metadata,
-    union?: Map<string, number | null>,
-  ): Map<string, number | null> => {
-    const map: Map<ProtobufAtomic, number | null> = union ?? new Map();
-
-    // CONSTANTS
-    for (const c of meta.constants)
-      if (c.type === "boolean")
-        map.set("bool", getSequence(c.values[0]?.tags[0] ?? []));
-      else if (c.type === "bigint") {
-        const init: ProtobufAtomic.BigNumeric = deduce_bigint_type(
-          c.values.map((v) => BigInt(v.value)),
-        );
-        for (const value of c.values)
-          decode_bigint({
-            map,
-            tags: value.tags,
-            default: init,
-          });
-      } else if (c.type === "number") {
-        const init: ProtobufAtomic.Numeric = deduce_numeric_type(
-          c.values.map((v) => v.value) as number[],
-        );
-        for (const value of c.values)
-          decode_number({
-            map,
-            tags: value.tags,
-            default: init,
-          });
-      } else if (c.type === "string")
-        map.set("string", getSequence(c.values[0]?.tags[0] ?? []));
-    if (meta.templates.length)
-      map.set("string", getSequence(meta.templates[0]?.tags[0] ?? []));
-
-    // ATOMICS
-    for (const atomic of meta.atomics)
-      if (atomic.type === "boolean")
-        map.set("bool", getSequence(atomic.tags[0] ?? []));
-      else if (atomic.type === "bigint")
-        decode_bigint({
-          map,
-          tags: atomic.tags,
-          default: "int64",
-        });
-      else if (atomic.type === "number")
-        decode_number({
-          map,
-          tags: atomic.tags,
-          default: "double",
-        });
-      else if (atomic.type === "string")
-        map.set("string", getSequence(atomic.tags[0] ?? []));
-
-    // SORTING IF REQUIRED
-    if (Array.from(map.values()).some((v) => v === null)) arrange(map);
-    return map;
-  };
-
-  export const getNumbers = (
-    meta: Metadata,
-    union?: Map<string, number | null>,
-  ): Map<string, number | null> => {
-    const map: Map<ProtobufAtomic.Numeric, number | null> = union ?? new Map();
-    for (const c of meta.constants)
-      if (c.type === "number") {
-        const init: ProtobufAtomic.Numeric = deduce_numeric_type(
-          c.values.map((v) => v.value) as number[],
-        );
-        for (const value of c.values)
-          decode_number({
-            map,
-            tags: value.tags,
-            default: init,
-          });
-      }
-    for (const atomic of meta.atomics)
-      if (atomic.type === "number")
-        decode_number({
-          map,
-          tags: atomic.tags,
-          default: "double",
-        });
-    if (Array.from(map.values()).some((v) => v === null)) arrange(map);
-    return map;
-  };
-
-  export const getBigints = (
-    meta: Metadata,
-    union?: Map<string, number | null>,
-  ): Map<string, number | null> => {
-    const map: Map<ProtobufAtomic.BigNumeric, number | null> =
-      union ?? new Map();
-    for (const c of meta.constants)
-      if (c.type === "bigint") {
-        const init: ProtobufAtomic.BigNumeric = deduce_bigint_type(
-          c.values.map((v) => BigInt(v.value)),
-        );
-        for (const value of c.values)
-          decode_bigint({
-            map,
-            tags: value.tags,
-            default: init,
-          });
-      }
-    for (const atomic of meta.atomics)
-      if (atomic.type === "bigint")
-        decode_bigint({
-          map,
-          tags: atomic.tags,
-          default: "int64",
-        });
-    if (Array.from(map.values()).some((v) => v === null)) arrange(map);
-    return map;
-  };
-
-  const arrange = (map: Map<ProtobufAtomic, number | null>): void => {
-    const entries = Array.from(map.entries()).sort((a, b) =>
-      compare(a[0], b[0]),
-    );
-    map.clear();
-    for (const [key, value] of entries) map.set(key, value);
-  };
-
-  export 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_bigint_type = (values: bigint[]): ProtobufAtomic.BigNumeric =>
-  values.some((v) => v < 0) ? "int64" : "uint64";
-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 = (next: {
-  map: Map<ProtobufAtomic, number | null>;
-  tags: IMetadataTypeTag[][];
-  default: ProtobufAtomic.BigNumeric;
-}): void => {
-  if (next.tags.length === 0) {
-    next.map.set(next.default, null);
-    return;
-  }
-  for (const row of next.tags) {
-    const value: ProtobufAtomic.BigNumeric | undefined = row.find(
-      (tag) =>
-        tag.kind === "type" &&
-        (tag.value === "int64" || tag.value === "uint64"),
-    )?.value;
-    next.map.set(value ?? "int64", ProtobufUtil.getSequence(row));
-  }
-};
-
-const decode_number = (next: {
-  map: Map<ProtobufAtomic, number | null>;
-  tags: IMetadataTypeTag[][];
-  default: ProtobufAtomic.Numeric;
-}): void => {
-  if (next.tags.length === 0) {
-    next.map.set(next.default, null);
-    return;
-  }
-  for (const row of next.tags) {
-    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;
-    next.map.set(value ?? "double", ProtobufUtil.getSequence(row));
-  }
-};
+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).size +
+    meta.arrays.length +
+    meta.tuples.length +
+    meta.natives.length +
+    meta.objects.length +
+    meta.maps.length;
+
+  export const getSequence = (tags: IMetadataTypeTag[]): number | null => {
+    const sequence = tags.find(
+      (t) =>
+        t.kind === "sequence" &&
+        typeof (t.schema as any)?.["x-protobuf-sequence"] === "number",
+    );
+    if (sequence === undefined) return null;
+    const value: number = Number(
+      (sequence.schema as any)["x-protobuf-sequence"],
+    );
+    return Number.isNaN(value) ? null : value;
+  };
+
+  export const isUnion = (meta: Metadata): boolean => size(meta) > 1;
+
+  export const getAtomics = (
+    meta: Metadata,
+    union?: Map<string, number | null>,
+  ): Map<string, number | null> => {
+    const map: Map<ProtobufAtomic, number | null> = union ?? new Map();
+
+    // CONSTANTS
+    for (const c of meta.constants)
+      if (c.type === "boolean")
+        map.set("bool", getSequence(c.values[0]?.tags[0] ?? []));
+      else if (c.type === "bigint") {
+        const init: ProtobufAtomic.BigNumeric = deduce_bigint_type(
+          c.values.map((v) => BigInt(v.value)),
+        );
+        for (const value of c.values)
+          decode_bigint({
+            map,
+            tags: value.tags,
+            default: init,
+          });
+      } else if (c.type === "number") {
+        const init: ProtobufAtomic.Numeric = deduce_numeric_type(
+          c.values.map((v) => v.value) as number[],
+        );
+        for (const value of c.values)
+          decode_number({
+            map,
+            tags: value.tags,
+            default: init,
+          });
+      } else if (c.type === "string")
+        map.set("string", getSequence(c.values[0]?.tags[0] ?? []));
+    if (meta.templates.length)
+      map.set("string", getSequence(meta.templates[0]?.tags[0] ?? []));
+
+    // ATOMICS
+    for (const atomic of meta.atomics)
+      if (atomic.type === "boolean")
+        map.set("bool", getSequence(atomic.tags[0] ?? []));
+      else if (atomic.type === "bigint")
+        decode_bigint({
+          map,
+          tags: atomic.tags,
+          default: "int64",
+        });
+      else if (atomic.type === "number")
+        decode_number({
+          map,
+          tags: atomic.tags,
+          default: "double",
+        });
+      else if (atomic.type === "string")
+        map.set("string", getSequence(atomic.tags[0] ?? []));
+
+    // SORTING IF REQUIRED
+    if (Array.from(map.values()).some((v) => v === null)) arrange(map);
+    return map;
+  };
+
+  export const getNumbers = (
+    meta: Metadata,
+    union?: Map<string, number | null>,
+  ): Map<string, number | null> => {
+    const map: Map<ProtobufAtomic.Numeric, number | null> = union ?? new Map();
+    for (const c of meta.constants)
+      if (c.type === "number") {
+        const init: ProtobufAtomic.Numeric = deduce_numeric_type(
+          c.values.map((v) => v.value) as number[],
+        );
+        for (const value of c.values)
+          decode_number({
+            map,
+            tags: value.tags,
+            default: init,
+          });
+      }
+    for (const atomic of meta.atomics)
+      if (atomic.type === "number")
+        decode_number({
+          map,
+          tags: atomic.tags,
+          default: "double",
+        });
+    if (Array.from(map.values()).some((v) => v === null)) arrange(map);
+    return map;
+  };
+
+  export const getBigints = (
+    meta: Metadata,
+    union?: Map<string, number | null>,
+  ): Map<string, number | null> => {
+    const map: Map<ProtobufAtomic.BigNumeric, number | null> =
+      union ?? new Map();
+    for (const c of meta.constants)
+      if (c.type === "bigint") {
+        const init: ProtobufAtomic.BigNumeric = deduce_bigint_type(
+          c.values.map((v) => BigInt(v.value)),
+        );
+        for (const value of c.values)
+          decode_bigint({
+            map,
+            tags: value.tags,
+            default: init,
+          });
+      }
+    for (const atomic of meta.atomics)
+      if (atomic.type === "bigint")
+        decode_bigint({
+          map,
+          tags: atomic.tags,
+          default: "int64",
+        });
+    if (Array.from(map.values()).some((v) => v === null)) arrange(map);
+    return map;
+  };
+
+  const arrange = (map: Map<ProtobufAtomic, number | null>): void => {
+    const entries = Array.from(map.entries()).sort((a, b) =>
+      compare(a[0], b[0]),
+    );
+    map.clear();
+    for (const [key, value] of entries) map.set(key, value);
+  };
+
+  export 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_bigint_type = (values: bigint[]): ProtobufAtomic.BigNumeric =>
+  values.some((v) => v < 0) ? "int64" : "uint64";
+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 = (next: {
+  map: Map<ProtobufAtomic, number | null>;
+  tags: IMetadataTypeTag[][];
+  default: ProtobufAtomic.BigNumeric;
+}): void => {
+  if (next.tags.length === 0) {
+    next.map.set(next.default, null);
+    return;
+  }
+  for (const row of next.tags) {
+    const value: ProtobufAtomic.BigNumeric | undefined = row.find(
+      (tag) =>
+        tag.kind === "type" &&
+        (tag.value === "int64" || tag.value === "uint64"),
+    )?.value;
+    next.map.set(value ?? "int64", ProtobufUtil.getSequence(row));
+  }
+};
+
+const decode_number = (next: {
+  map: Map<ProtobufAtomic, number | null>;
+  tags: IMetadataTypeTag[][];
+  default: ProtobufAtomic.Numeric;
+}): void => {
+  if (next.tags.length === 0) {
+    next.map.set(next.default, null);
+    return;
+  }
+  for (const row of next.tags) {
+    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;
+    next.map.set(value ?? "double", ProtobufUtil.getSequence(row));
+  }
+};