typia 7.0.0-dev.20241012 → 7.0.0-dev.20241018

package/src/programmers/CheckerProgrammer.ts

@@ -11,7 +11,9 @@ import { ValueFactory } from "../factories/ValueFactory";
 import { Metadata } from "../schemas/metadata/Metadata";
 import { MetadataArray } from "../schemas/metadata/MetadataArray";
 import { MetadataConstant } from "../schemas/metadata/MetadataConstant";
+import { MetadataMap } from "../schemas/metadata/MetadataMap";
 import { MetadataObjectType } from "../schemas/metadata/MetadataObjectType";
+import { MetadataSet } from "../schemas/metadata/MetadataSet";
 import { MetadataTuple } from "../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../schemas/metadata/MetadataTupleType";
 
@@ -630,7 +632,7 @@ export namespace CheckerProgrammer {
     for (const native of props.metadata.natives)
       binaries.push({
         expression: check_native({
-          type: native,
+          name: native.name,
           input: props.input,
         }),
         combined: false,
@@ -652,7 +654,7 @@ export namespace CheckerProgrammer {
       const install = (body: ts.Expression | null) =>
         prepare({
           head: check_native({
-            type: "Set",
+            name: "Set",
             input: props.input,
           }),
           expected: props.metadata.sets
@@ -660,7 +662,7 @@ export namespace CheckerProgrammer {
             .join(" | "),
           body,
         });
-      if (props.metadata.sets.some((elem) => elem.any)) install(null);
+      if (props.metadata.sets.some((elem) => elem.value.any)) install(null);
       else
         install(
           explore_sets({
@@ -682,7 +684,7 @@ export namespace CheckerProgrammer {
       const install = (body: ts.Expression | null) =>
         prepare({
           head: check_native({
-            type: "Map",
+            name: "Map",
             input: props.input,
           }),
           expected: props.metadata.maps
@@ -880,7 +882,7 @@ export namespace CheckerProgrammer {
           props.metadata.escaped.original.size() === 1 &&
           props.metadata.escaped.original.natives.length === 1
             ? check_native({
-                type: props.metadata.escaped.original.natives[0]!,
+                name: props.metadata.escaped.original.natives[0]!.name,
                 input: props.input,
               })
             : ts.factory.createLogicalAnd(
@@ -1228,7 +1230,7 @@ export namespace CheckerProgrammer {
     context: ITypiaContext;
     config: IConfig;
     functor: FunctionProgrammer;
-    sets: Metadata[];
+    sets: MetadataSet[];
     input: ts.Expression;
     explore: IExplore;
   }): ts.Expression =>
@@ -1272,7 +1274,7 @@ export namespace CheckerProgrammer {
     config: IConfig;
     functor: FunctionProgrammer;
     input: ts.Expression;
-    maps: Metadata.Entry[];
+    maps: MetadataMap[];
     explore: IExplore;
   }): ts.Expression =>
     ts.factory.createCallExpression(

package/src/programmers/RandomProgrammer.ts

@@ -15,7 +15,9 @@ import { Metadata } from "../schemas/metadata/Metadata";
 import { MetadataArray } from "../schemas/metadata/MetadataArray";
 import { MetadataArrayType } from "../schemas/metadata/MetadataArrayType";
 import { MetadataAtomic } from "../schemas/metadata/MetadataAtomic";
+import { MetadataMap } from "../schemas/metadata/MetadataMap";
 import { MetadataObjectType } from "../schemas/metadata/MetadataObjectType";
+import { MetadataSet } from "../schemas/metadata/MetadataSet";
 import { MetadataTemplate } from "../schemas/metadata/MetadataTemplate";
 import { MetadataTuple } from "../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../schemas/metadata/MetadataTupleType";
@@ -64,9 +66,9 @@ export namespace RandomProgrammer {
         absorb: true,
         validate: (meta) => {
           const output: string[] = [];
-          if (meta.natives.some((n) => n === "WeakSet"))
+          if (meta.natives.some((native) => native.name === "WeakSet"))
             output.push(`WeakSet is not supported.`);
-          else if (meta.natives.some((n) => n === "WeakMap"))
+          else if (meta.natives.some((native) => native.name === "WeakMap"))
             output.push(`WeakMap is not supported.`);
           return output;
         },
@@ -411,27 +413,27 @@ export namespace RandomProgrammer {
           object: object.type,
         }),
       );
-    for (const name of props.metadata.natives)
+    for (const native of props.metadata.natives)
       expressions.push(
         decode_native({
           context: props.context,
           functor: props.functor,
           explore: props.explore,
-          name,
+          name: native.name,
         }),
       );
-    for (const metadata of props.metadata.sets)
+    for (const set of props.metadata.sets)
       expressions.push(
         decode_set({
           ...props,
-          metadata,
+          set,
         }),
       );
     for (const entry of props.metadata.maps)
       expressions.push(
         decode_map({
           ...props,
-          entry,
+          map: entry,
         }),
       );
 
@@ -694,7 +696,7 @@ export namespace RandomProgrammer {
     context: ITypiaContext;
     functor: FunctionProgrammer;
     explore: IExplore;
-    metadata: Metadata;
+    set: MetadataSet;
   }) =>
     ts.factory.createNewExpression(
       ts.factory.createIdentifier("Set"),
@@ -705,11 +707,11 @@ export namespace RandomProgrammer {
           array: MetadataArray.create({
             tags: [],
             type: MetadataArrayType.create({
-              value: props.metadata,
+              value: props.set.value,
               recursive: false,
               index: null,
               nullables: [],
-              name: `Set<${props.metadata.getName()}>`,
+              name: props.set.getName(),
             }),
           }),
         })[0]!,
@@ -720,7 +722,7 @@ export namespace RandomProgrammer {
     context: ITypiaContext;
     functor: FunctionProgrammer;
     explore: IExplore;
-    entry: Metadata.Entry;
+    map: MetadataMap;
   }) =>
     ts.factory.createNewExpression(
       ts.factory.createIdentifier("Map"),
@@ -731,7 +733,7 @@ export namespace RandomProgrammer {
           array: MetadataArray.create({
             tags: [],
             type: MetadataArrayType.create({
-              name: `Map<${props.entry.key.getName()}, ${props.entry.value.getName()}>`,
+              name: props.map.getName(),
               index: null,
               recursive: false,
               nullables: [],
@@ -740,11 +742,11 @@ export namespace RandomProgrammer {
                 tuples: [
                   (() => {
                     const type = MetadataTupleType.create({
-                      name: `[${props.entry.key.getName()}, ${props.entry.value.getName()}]`,
+                      name: `[${props.map.key.getName()}, ${props.map.value.getName()}]`,
                       index: null,
                       recursive: false,
                       nullables: [],
-                      elements: [props.entry.key, props.entry.value],
+                      elements: [props.map.key, props.map.value],
                     });
                     type.of_map = true;
                     return MetadataTuple.create({

package/src/programmers/helpers/AtomicPredicator.ts

@@ -11,7 +11,7 @@ export namespace AtomicPredicator {
   }): boolean =>
     !ArrayUtil.has(
       props.metadata.natives,
-      (native) => native.toLowerCase() === props.name,
+      (native) => native.name.toLowerCase() === props.name,
     );
 
   export const atomic = (props: {
@@ -20,7 +20,7 @@ export namespace AtomicPredicator {
   }): boolean =>
     !ArrayUtil.has(
       props.metadata.natives,
-      (native) => native.toLowerCase() === props.name,
+      (native) => native.name.toLowerCase() === props.name,
     );
 
   export const native = (name: string) => LIKE.has(name.toLowerCase());
@@ -28,7 +28,7 @@ export namespace AtomicPredicator {
   export const template = (metadata: Metadata): boolean =>
     !ArrayUtil.has(
       metadata.natives,
-      (native) => native.toLowerCase() === "string",
+      (native) => native.name.toLowerCase() === "string",
     );
 }
 

package/src/programmers/helpers/ProtobufUtil.ts

@@ -10,53 +10,150 @@ export namespace ProtobufUtil {
     obj.properties.every((p) => p.key.isSoleLiteral());
 
   export const size = (meta: Metadata): number =>
-    getAtomics(meta).length +
+    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): ProtobufAtomic[] => {
-    const set: Set<ProtobufAtomic> = new Set();
-    if (meta.templates.length) set.add("string");
+  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") 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");
+      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") set.add("bool");
+      if (atomic.type === "boolean")
+        map.set("bool", getSequence(atomic.tags[0] ?? []));
       else if (atomic.type === "bigint")
-        decode_bigint(atomic.tags).forEach((t) => set.add(t));
+        decode_bigint({
+          map,
+          tags: atomic.tags,
+          default: "int64",
+        });
       else if (atomic.type === "number")
-        decode_number(atomic.tags).forEach((t) => set.add(t));
-      else if (atomic.type === "string") set.add("string");
+        decode_number({
+          map,
+          tags: atomic.tags,
+          default: "double",
+        });
+      else if (atomic.type === "string")
+        map.set("string", getSequence(atomic.tags[0] ?? []));
 
-    return [...set].sort(compare);
+    // SORTING IF REQUIRED
+    if (Array.from(map.values()).some((v) => v === null)) arrange(map);
+    return map;
   };
 
-  export const getNumbers = (meta: Metadata): ProtobufAtomic.Numeric[] => {
-    const set: Set<ProtobufAtomic.Numeric> = new Set();
+  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")
-        set.add(deduce_numeric_type(c.values.map((v) => v.value) as number[]));
+      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(atomic.tags).forEach((t) => set.add(t));
-    return [...set].sort(compare);
+        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): ProtobufAtomic.BigNumeric[] => {
-    const set: Set<ProtobufAtomic.BigNumeric> = new Set();
-    for (const c of meta.constants) if (c.type === "bigint") set.add("uint64");
+  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(atomic.tags).forEach((t) => set.add(t));
-    return [...set].sort(compare);
+        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);
   };
 
   const compare = (x: ProtobufAtomic, y: ProtobufAtomic): number =>
@@ -78,6 +175,8 @@ const ATOMIC_ORDER = new Map<ProtobufAtomic, number>(
   ).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)
@@ -85,30 +184,35 @@ const deduce_numeric_type = (values: number[]): ProtobufAtomic.Numeric =>
       : "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 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;
-    types.add(value ?? "int64");
+    next.map.set(value ?? "int64", ProtobufUtil.getSequence(row));
   }
-  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 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" &&
@@ -119,7 +223,6 @@ const decode_number = (
           tag.value === "float" ||
           tag.value === "double"),
     )?.value;
-    types.add(value ?? "double");
+    next.map.set(value ?? "double", ProtobufUtil.getSequence(row));
   }
-  return [...types];
 };

package/src/programmers/helpers/UnionExplorer.ts

@@ -6,7 +6,9 @@ import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
 import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
+import { MetadataMap } from "../../schemas/metadata/MetadataMap";
 import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
+import { MetadataSet } from "../../schemas/metadata/MetadataSet";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
@@ -236,7 +238,7 @@ export namespace UnionExplorer {
     config: set.IConfig;
     parameters: ts.ParameterDeclaration[];
     input: ts.Expression;
-    sets: Metadata[];
+    sets: MetadataSet[];
     explore: FeatureProgrammer.IExplore;
   }) =>
     check_union_array_like<Metadata, MetadataArray, Metadata>({
@@ -280,7 +282,7 @@ export namespace UnionExplorer {
       },
       parameters: props.parameters,
       input: props.input,
-      definitions: props.sets,
+      definitions: props.sets.map((s) => s.value),
       explore: props.explore,
     });
   export namespace set {
@@ -294,74 +296,72 @@ export namespace UnionExplorer {
     config: map.IConfig;
     parameters: ts.ParameterDeclaration[];
     input: ts.Expression;
-    maps: Metadata.Entry[];
+    maps: MetadataMap[];
     explore: FeatureProgrammer.IExplore;
   }) =>
-    check_union_array_like<Metadata.Entry, MetadataArray, [Metadata, Metadata]>(
-      {
-        config: props.config,
-        accessor: {
-          element: (array) =>
-            array.type.value.tuples[0]!.type.elements as [Metadata, Metadata],
-          size: (input) => IdentifierFactory.access(input, "size"),
-          front: (input) =>
-            IdentifierFactory.access(
-              ts.factory.createCallExpression(
-                IdentifierFactory.access(
-                  ts.factory.createCallExpression(
-                    IdentifierFactory.access(input, "entries"),
-                    undefined,
-                    undefined,
-                  ),
-                  "next",
+    check_union_array_like<MetadataMap, MetadataArray, [Metadata, Metadata]>({
+      config: props.config,
+      accessor: {
+        element: (array) =>
+          array.type.value.tuples[0]!.type.elements as [Metadata, Metadata],
+        size: (input) => IdentifierFactory.access(input, "size"),
+        front: (input) =>
+          IdentifierFactory.access(
+            ts.factory.createCallExpression(
+              IdentifierFactory.access(
+                ts.factory.createCallExpression(
+                  IdentifierFactory.access(input, "entries"),
+                  undefined,
+                  undefined,
                 ),
-                undefined,
-                undefined,
+                "next",
               ),
-              "value",
-            ),
-          array: (input) =>
-            ts.factory.createArrayLiteralExpression(
-              [ts.factory.createSpreadElement(input)],
-              false,
+              undefined,
+              undefined,
             ),
-          name: (_m, [k, v]) => `Map<${k.getName()}, ${v.getName()}>`,
-          transform: (m: Metadata.Entry) =>
-            MetadataArray.create({
-              tags: [],
-              type: MetadataArrayType.create({
-                name: `Map<${m.key.getName()}, ${m.value.getName()}>`,
-                index: null,
-                recursive: false,
-                nullables: [],
-                value: Metadata.create({
-                  ...Metadata.initialize(),
-                  tuples: [
-                    (() => {
-                      const tuple = MetadataTuple.create({
-                        tags: [],
-                        type: MetadataTupleType.create({
-                          name: `[${m.key.getName()}, ${m.value.getName()}]`,
-                          index: null,
-                          recursive: false,
-                          nullables: [],
-                          elements: [m.key, m.value],
-                        }),
-                      });
-                      tuple.type.of_map = true;
-                      return tuple;
-                    })(),
-                  ],
-                }),
+            "value",
+          ),
+        array: (input) =>
+          ts.factory.createArrayLiteralExpression(
+            [ts.factory.createSpreadElement(input)],
+            false,
+          ),
+        name: (_m, [k, v]) => `Map<${k.getName()}, ${v.getName()}>`,
+        transform: (m: MetadataMap) =>
+          MetadataArray.create({
+            tags: [],
+            type: MetadataArrayType.create({
+              name: `Map<${m.key.getName()}, ${m.value.getName()}>`,
+              index: null,
+              recursive: false,
+              nullables: [],
+              value: Metadata.create({
+                ...Metadata.initialize(),
+                tuples: [
+                  (() => {
+                    const tuple = MetadataTuple.create({
+                      tags: [],
+                      type: MetadataTupleType.create({
+                        name: `[${m.key.getName()}, ${m.value.getName()}]`,
+                        index: null,
+                        recursive: false,
+                        nullables: [],
+                        elements: [m.key, m.value],
+                      }),
+                    });
+                    tuple.type.of_map = true;
+                    return tuple;
+                  })(),
+                ],
               }),
             }),
-        },
-        parameters: props.parameters,
-        input: props.input,
-        definitions: props.maps,
-        explore: props.explore,
+          }),
       },
-    );
+      parameters: props.parameters,
+      input: props.input,
+      definitions: props.maps,
+      explore: props.explore,
+    });
 
   export namespace map {
     export type IConfig = check_union_array_like.IConfig<

package/src/programmers/http/HttpFormDataProgrammer.ts

@@ -129,7 +129,9 @@ export namespace HttpFormDataProgrammer {
         meta.atomics.length +
         meta.templates.length +
         meta.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0) +
-        meta.natives.filter((n) => n === "Blob" || n === "File").length;
+        meta.natives.filter(
+          (native) => native.name === "Blob" || native.name === "File",
+        ).length;
       if (atomics.size > 1) insert("union type is not allowed in array.");
       if (meta.size() !== expected)
         insert(
@@ -151,7 +153,9 @@ export namespace HttpFormDataProgrammer {
         meta.objects.length ||
         meta.sets.length ||
         meta.maps.length ||
-        meta.natives.filter((n) => n !== "Blob" && n !== "File").length
+        meta.natives.filter(
+          (native) => native.name !== "Blob" && native.name !== "File",
+        ).length
       )
         insert("nested object type is not allowed.");
     }
@@ -198,9 +202,9 @@ export namespace HttpFormDataProgrammer {
         ? [value.constants[0]!.type, false]
         : value.templates.length
           ? ["string", false]
-          : value.natives.includes("Blob")
+          : value.natives.some((native) => native.name === "Blob")
             ? ["blob", false]
-            : value.natives.includes("File")
+            : value.natives.some((native) => native.name === "File")
               ? ["file", false]
               : (() => {
                   const meta =
@@ -210,9 +214,9 @@ export namespace HttpFormDataProgrammer {
                     ? [meta.atomics[0]!.type, true]
                     : meta.templates.length
                       ? ["string", true]
-                      : meta.natives.includes("Blob")
+                      : meta.natives.some((native) => native.name === "Blob")
                         ? ["blob", true]
-                        : meta.natives.includes("File")
+                        : meta.natives.some((native) => native.name === "File")
                           ? ["file", true]
                           : [meta.constants[0]!.type, true];
                 })();