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

package/src/schemas/metadata/IMetadataAliasType.ts

@@ -0,0 +1,12 @@
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadata } from "./IMetadata";
+
+export interface IMetadataAliasType {
+  name: string;
+  value: IMetadata;
+  nullables: boolean[];
+
+  description: string | null;
+  jsDocTags: IJsDocTagInfo[];
+  recursive: boolean;
+}

package/src/schemas/metadata/IMetadataArray.ts

@@ -1,6 +1,6 @@
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-
-export interface IMetadataArray {
-  name: string;
-  tags: IMetadataTypeTag[][];
-}
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadataArray {
+  name: string;
+  tags: IMetadataTypeTag[][];
+}

package/src/schemas/metadata/IMetadataComponents.ts

@@ -1,11 +1,11 @@
-import { IMetadataAlias } from "./IMetadataAlias";
-import { IMetadataArrayType } from "./IMetadataArrayType";
-import { IMetadataObjectType } from "./IMetadataObjectType";
-import { IMetadataTupleType } from "./IMetadataTupleType";
-
-export interface IMetadataComponents {
-  objects: IMetadataObjectType[];
-  aliases: IMetadataAlias[];
-  arrays: IMetadataArrayType[];
-  tuples: IMetadataTupleType[];
-}
+import { IMetadataAliasType } from "./IMetadataAliasType";
+import { IMetadataArrayType } from "./IMetadataArrayType";
+import { IMetadataObjectType } from "./IMetadataObjectType";
+import { IMetadataTupleType } from "./IMetadataTupleType";
+
+export interface IMetadataComponents {
+  objects: IMetadataObjectType[];
+  aliases: IMetadataAliasType[];
+  arrays: IMetadataArrayType[];
+  tuples: IMetadataTupleType[];
+}

package/src/schemas/metadata/IMetadataConstantValue.ts

@@ -5,7 +5,7 @@ import { IMetadataTypeTag } from "./IMetadataTypeTag";
 
 export interface IMetadataConstantValue<T extends Atomic.Type> {
   value: T;
-  tags?: IMetadataTypeTag[][] | undefined;
+  tags: IMetadataTypeTag[][];
   description?: string | null;
   jsDocTags?: IJsDocTagInfo[];
 }

package/src/schemas/metadata/IMetadataDictionary.ts

@@ -1,11 +1,11 @@
-import { MetadataAlias } from "./MetadataAlias";
+import { MetadataAliasType } from "./MetadataAliasType";
 import { MetadataArrayType } from "./MetadataArrayType";
 import { MetadataObjectType } from "./MetadataObjectType";
 import { MetadataTupleType } from "./MetadataTupleType";
 
 export interface IMetadataDictionary {
   objects: Map<string, MetadataObjectType>;
-  aliases: Map<string, MetadataAlias>;
+  aliases: Map<string, MetadataAliasType>;
   arrays: Map<string, MetadataArrayType>;
   tuples: Map<string, MetadataTupleType>;
 }

package/src/schemas/metadata/IMetadataMap.ts

@@ -0,0 +1,8 @@
+import { IMetadata } from "./IMetadata";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadataMap {
+  key: IMetadata;
+  value: IMetadata;
+  tags: IMetadataTypeTag[][];
+}

package/src/schemas/metadata/IMetadataNative.ts

@@ -0,0 +1,6 @@
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadataNative {
+  name: string;
+  tags: IMetadataTypeTag[][];
+}

package/src/schemas/metadata/IMetadataObjectType.ts

@@ -1,13 +1,13 @@
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
-import { IMetadataProperty } from "./IMetadataProperty";
-
-export interface IMetadataObjectType {
-  name: string;
-  properties: IMetadataProperty[];
-  description?: undefined | string;
-  jsDocTags: IJsDocTagInfo[];
-
-  index: number;
-  recursive: boolean;
-  nullables: boolean[];
-}
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataProperty } from "./IMetadataProperty";
+
+export interface IMetadataObjectType {
+  name: string;
+  properties: IMetadataProperty[];
+  description?: undefined | string;
+  jsDocTags: IJsDocTagInfo[];
+
+  index: number;
+  recursive: boolean;
+  nullables: boolean[];
+}

package/src/schemas/metadata/IMetadataSet.ts

@@ -0,0 +1,7 @@
+import { IMetadata } from "./IMetadata";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadataSet {
+  value: IMetadata;
+  tags: IMetadataTypeTag[][];
+}

package/src/schemas/metadata/IMetadataTemplate.ts

@@ -1,7 +1,7 @@
-import { IMetadata } from "./IMetadata";
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-
-export interface IMetadataTemplate {
-  row: IMetadata[];
-  tags?: IMetadataTypeTag[][] | undefined;
-}
+import { IMetadata } from "./IMetadata";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadataTemplate {
+  row: IMetadata[];
+  tags: IMetadataTypeTag[][];
+}

package/src/schemas/metadata/IMetadataTuple.ts

@@ -1,6 +1,6 @@
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-
-export interface IMetadataTuple {
-  name: string;
-  tags: IMetadataTypeTag[][];
-}
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadataTuple {
+  name: string;
+  tags: IMetadataTypeTag[][];
+}

package/src/schemas/metadata/IMetadataTypeTag.ts

@@ -1,16 +1,16 @@
-import type ts from "typescript";
-
-export interface IMetadataTypeTag {
-  target: "boolean" | "bigint" | "number" | "string" | "array";
-  name: string;
-  kind: string;
-  exclusive: boolean | string[];
-  value?: any;
-  validate?: string | undefined;
-  schema?: object | undefined;
-
-  /**
-   * @internal
-   */
-  predicate?: (input: ts.Expression) => ts.Expression;
-}
+import type ts from "typescript";
+
+export interface IMetadataTypeTag {
+  target: "boolean" | "bigint" | "number" | "string" | "array" | "object";
+  name: string;
+  kind: string;
+  exclusive: boolean | string[];
+  value?: any;
+  validate?: string | undefined;
+  schema?: object | undefined;
+
+  /**
+   * @internal
+   */
+  predicate?: (input: ts.Expression) => ts.Expression;
+}

package/src/schemas/metadata/Metadata.ts

@@ -11,8 +11,11 @@ import { MetadataAtomic } from "./MetadataAtomic";
 import { MetadataConstant } from "./MetadataConstant";
 import { MetadataEscaped } from "./MetadataEscaped";
 import { MetadataFunction } from "./MetadataFunction";
+import { MetadataMap } from "./MetadataMap";
+import { MetadataNative } from "./MetadataNative";
 import { MetadataObject } from "./MetadataObject";
 import { MetadataObjectType } from "./MetadataObjectType";
+import { MetadataSet } from "./MetadataSet";
 import { MetadataTemplate } from "./MetadataTemplate";
 import { MetadataTuple } from "./MetadataTuple";
 
@@ -34,15 +37,16 @@ export class Metadata {
   public objects: MetadataObject[];
   public functions: MetadataFunction[];
 
-  public natives: string[];
-  public sets: Metadata[];
-  public maps: Metadata.Entry[];
+  public natives: MetadataNative[];
+  public sets: MetadataSet[];
+  public maps: MetadataMap[];
 
   /** @internal */ private name_?: string;
   /** @internal */ private parent_resolved_: boolean = false;
   /** @internal */ public union_index?: number;
   /** @internal */ public fixed_?: number | null;
   /** @internal */ public boolean_literal_intersected_?: boolean;
+  /** @internal */ private is_sequence_?: boolean;
 
   /* -----------------------------------------------------------
     CONSTRUCTORS
@@ -126,14 +130,11 @@ export class Metadata {
       arrays: this.arrays.map((array) => array.toJSON()),
       tuples: this.tuples.map((tuple) => tuple.toJSON()),
       objects: this.objects.map((obj) => obj.toJSON()),
-      aliases: this.aliases.map((alias) => alias.name),
-
-      natives: this.natives.slice(),
-      sets: this.sets.map((meta) => meta.toJSON()),
-      maps: this.maps.map((entry) => ({
-        key: entry.key.toJSON(),
-        value: entry.value.toJSON(),
-      })),
+      aliases: this.aliases.map((alias) => alias.toJSON()),
+
+      natives: this.natives.map((native) => native.toJSON()),
+      sets: this.sets.map((set) => set.toJSON()),
+      maps: this.maps.map((map) => map.toJSON()),
     };
   }
 
@@ -185,19 +186,30 @@ export class Metadata {
         });
       }),
       aliases: meta.aliases.map((alias) => {
-        const found = dict.aliases.get(alias);
-        if (found === undefined)
+        const type = dict.aliases.get(alias.name);
+        if (type === undefined)
           throw new RangeError(
             `Error on Metadata.from(): failed to find alias "${alias}".`,
           );
-        return found;
+        return MetadataAlias.create({
+          type,
+          tags: alias.tags.map((r) => r.slice()),
+        });
       }),
-      natives: meta.natives.slice(),
-      sets: meta.sets.map((meta) => this.from(meta, dict)),
-      maps: meta.maps.map((entry) => ({
-        key: this.from(entry.key, dict),
-        value: this.from(entry.value, dict),
-      })),
+      natives: meta.natives.map((native) => MetadataNative.create(native)),
+      sets: meta.sets.map((set) =>
+        MetadataSet.create({
+          value: Metadata.from(set.value, dict),
+          tags: set.tags.map((r) => r.slice()),
+        }),
+      ),
+      maps: meta.maps.map((map) =>
+        MetadataMap.create({
+          key: this.from(map.key, dict),
+          value: this.from(map.value, dict),
+          tags: map.tags.map((r) => r.slice()),
+        }),
+      ),
     });
   }
 
@@ -250,6 +262,39 @@ export class Metadata {
     );
   }
 
+  /**
+   * @internal
+   */
+  public isSequence(): boolean {
+    return (this.is_sequence_ ??= (() => {
+      const exists = (tags: IMetadataTypeTag[][]): boolean =>
+        tags.some((row) => {
+          const sequence = row.find(
+            (t) =>
+              t.kind === "sequence" &&
+              typeof (t.schema as any)?.["x-protobuf-sequence"] === "number",
+          );
+          if (sequence === undefined) return false;
+          const value: number = Number(
+            (sequence.schema as any)["x-protobuf-sequence"],
+          );
+          return !Number.isNaN(value);
+        });
+      return (
+        this.atomics.some((atomic) => exists(atomic.tags)) &&
+        this.constants.some((c) =>
+          c.values.some((v) => exists(v.tags ?? [])),
+        ) &&
+        this.templates.some((tpl) => exists(tpl.tags)) &&
+        this.arrays.some((array) => exists(array.tags)) &&
+        this.objects.some((object) => exists(object.tags)) &&
+        this.natives.some(
+          (native) => native.name === "Uint8Array" && exists(native.tags),
+        )
+      );
+    })());
+  }
+
   public isConstant(): boolean {
     return this.bucket() === (this.constants.length ? 1 : 0);
   }
@@ -423,7 +468,8 @@ export namespace Metadata {
 
     // ALIASES
     for (const yd of y.aliases)
-      if (x.aliases.some((xd) => xd.name === yd.name) === false) return false;
+      if (x.aliases.some((xd) => xd.type.name === yd.type.name) === false)
+        return false;
 
     // NATIVES
     for (const yn of y.natives)
@@ -431,7 +477,8 @@ export namespace Metadata {
 
     // SETS
     for (const ys of y.sets)
-      if (x.sets.some((xs) => covers(xs, ys)) === false) return false;
+      if (x.sets.some((xs) => covers(xs.value, ys.value)) === false)
+        return false;
 
     //----
     // VALUES
@@ -476,7 +523,6 @@ export namespace Metadata {
       required: x.required && y.required,
       optional: x.optional || y.optional,
       functions: x.functions.length ? x.functions : y.functions, // @todo
-
       escaped:
         x.escaped !== null && y.escaped !== null
           ? MetadataEscaped.create({
@@ -491,12 +537,10 @@ export namespace Metadata {
       })(y.atomics),
       constants: [...x.constants],
       templates: x.templates.slice(),
-
       rest:
         x.rest !== null && y.rest !== null
           ? merge(x.rest, y.rest)
           : (x.rest ?? y.rest),
-      // arrays: x.arrays.slice(),
       arrays: mergeTaggedTypes({
         container: x.arrays,
         equals: (x, y) => x.type.name === y.type.name,
@@ -507,12 +551,33 @@ export namespace Metadata {
         equals: (x, y) => x.type.name === y.type.name,
         getter: (x) => x.tags,
       })(y.tuples),
-      objects: x.objects.slice(),
-      aliases: x.aliases.slice(),
-
-      natives: [...new Set([...x.natives, ...y.natives])],
-      sets: x.sets.slice(),
-      maps: x.maps.slice(),
+      objects: mergeTaggedTypes({
+        container: x.objects,
+        equals: (x, y) => x.type.name === y.type.name,
+        getter: (x) => x.tags,
+      })(y.objects),
+      aliases: mergeTaggedTypes({
+        container: x.aliases,
+        equals: (x, y) => x.type.name === y.type.name,
+        getter: (x) => x.tags,
+      })(y.aliases),
+      natives: mergeTaggedTypes({
+        container: x.natives,
+        equals: (x, y) => x.name === y.name,
+        getter: (x) => x.tags,
+      })(y.natives),
+      sets: mergeTaggedTypes({
+        container: x.sets,
+        equals: (x, y) => x.value.getName() === y.value.getName(),
+        getter: (x) => x.tags,
+      })(y.sets),
+      maps: mergeTaggedTypes({
+        container: x.maps,
+        equals: (x, y) =>
+          x.key.getName() === y.key.getName() &&
+          x.value.getName() === y.value.getName(),
+        getter: (x) => x.tags,
+      })(y.maps),
     });
     for (const constant of y.constants) {
       const target: MetadataConstant = ArrayUtil.take(
@@ -527,11 +592,6 @@ export namespace Metadata {
       for (const value of constant.values)
         ArrayUtil.add(target.values, value, (a, b) => a.value === b.value);
     }
-    for (const obj of y.objects)
-      ArrayUtil.set(output.objects, obj, (elem) => elem.type.name);
-    for (const alias of y.aliases)
-      ArrayUtil.set(output.aliases, alias, (elem) => elem.name);
-
     return output;
   };
 }
@@ -554,17 +614,16 @@ const getName = (metadata: Metadata): string => {
   for (const template of metadata.templates) elements.push(template.getName());
 
   // NATIVES
-  for (const native of metadata.natives) elements.push(native);
-  for (const set of metadata.sets) elements.push(`Set<${set.getName()}>`);
-  for (const map of metadata.maps)
-    elements.push(`Map<${map.key.getName()}, ${map.value.getName()}>`);
+  for (const native of metadata.natives) elements.push(native.getName());
+  for (const set of metadata.sets) elements.push(set.getName());
+  for (const map of metadata.maps) elements.push(map.getName());
 
   // INSTANCES
   if (metadata.rest !== null) elements.push(`...${metadata.rest.getName()}`);
   for (const tuple of metadata.tuples) elements.push(tuple.type.name);
   for (const array of metadata.arrays) elements.push(array.getName());
   for (const object of metadata.objects) elements.push(object.getName());
-  for (const alias of metadata.aliases) elements.push(alias.name);
+  for (const alias of metadata.aliases) elements.push(alias.getName());
   if (metadata.escaped !== null) elements.push(metadata.escaped.getName());
 
   // RETURNS
@@ -574,12 +633,6 @@ const getName = (metadata: Metadata): string => {
   elements.sort();
   return `(${elements.join(" | ")})`;
 };
-export namespace Metadata {
-  export interface Entry {
-    key: Metadata;
-    value: Metadata;
-  }
-}
 
 const mergeTaggedTypes =
   <T>(props: {

package/src/schemas/metadata/MetadataAlias.ts

@@ -1,61 +1,46 @@
-import { ClassProperties } from "../../typings/ClassProperties";
-
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
-import { IMetadataAlias } from "./IMetadataAlias";
-import { Metadata } from "./Metadata";
-
-export class MetadataAlias {
-  public readonly name: string;
-  public readonly value: Metadata;
-  public readonly description: string | null;
-  public readonly jsDocTags: IJsDocTagInfo[];
-  public readonly recursive: boolean;
-  public readonly nullables: boolean[];
-
-  /* -----------------------------------------------------------
-        CONSTRUCTORS
-    ----------------------------------------------------------- */
-  /**
-   * @hidden
-   */
-  private constructor(props: ClassProperties<MetadataAlias>) {
-    this.name = props.name;
-    this.value = props.value;
-    this.description = props.description;
-    this.jsDocTags = props.jsDocTags;
-    this.recursive = props.recursive;
-    this.nullables = props.nullables;
-  }
-
-  /**
-   * @internal
-   */
-  public static create(props: ClassProperties<MetadataAlias>): MetadataAlias {
-    return new MetadataAlias(props);
-  }
-
-  /**
-   * @internal
-   */
-  public static _From_without_value(props: Omit<IMetadataAlias, "value">) {
-    return MetadataAlias.create({
-      name: props.name,
-      value: null!,
-      description: props.description,
-      recursive: props.recursive,
-      jsDocTags: props.jsDocTags.slice(),
-      nullables: props.nullables.slice(),
-    });
-  }
-
-  public toJSON(): IMetadataAlias {
-    return {
-      name: this.name,
-      value: this.value.toJSON(),
-      description: this.description,
-      recursive: this.recursive,
-      jsDocTags: this.jsDocTags.slice(),
-      nullables: this.nullables.slice(),
-    };
-  }
-}
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IMetadataAlias } from "./IMetadataAlias";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+import { MetadataAliasType } from "./MetadataAliasType";
+
+export class MetadataAlias {
+  public readonly type: MetadataAliasType;
+  public readonly tags: IMetadataTypeTag[][];
+  private name_?: string;
+
+  private constructor(props: ClassProperties<MetadataAlias>) {
+    this.type = props.type;
+    this.tags = props.tags;
+    this.type = props.type;
+  }
+
+  public static create(props: ClassProperties<MetadataAlias>): MetadataAlias {
+    return new MetadataAlias(props);
+  }
+
+  public getName(): string {
+    return (this.name_ ??= (() => {
+      if (this.tags.length === 0) return this.type.name;
+      else if (this.tags.length === 1) {
+        const str: string = [
+          this.type.name,
+          ...this.tags[0]!.map((t) => t.name),
+        ].join(" & ");
+        return `(${str})`;
+      }
+      const rows: string[] = this.tags.map((row) => {
+        const str: string = row.map((t) => t.name).join(" & ");
+        return row.length === 1 ? str : `(${str})`;
+      });
+      return `(${this.type.name} & (${rows.join(" | ")}))`;
+    })());
+  }
+
+  public toJSON(): IMetadataAlias {
+    return {
+      name: this.type.name,
+      tags: this.tags,
+    };
+  }
+}

package/src/schemas/metadata/MetadataAliasType.ts

@@ -0,0 +1,63 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataAliasType } from "./IMetadataAliasType";
+import { Metadata } from "./Metadata";
+
+export class MetadataAliasType {
+  public readonly name: string;
+  public readonly value: Metadata;
+  public readonly description: string | null;
+  public readonly jsDocTags: IJsDocTagInfo[];
+  public readonly recursive: boolean;
+  public readonly nullables: boolean[];
+
+  /* -----------------------------------------------------------
+        CONSTRUCTORS
+    ----------------------------------------------------------- */
+  /**
+   * @hidden
+   */
+  private constructor(props: ClassProperties<MetadataAliasType>) {
+    this.name = props.name;
+    this.value = props.value;
+    this.description = props.description;
+    this.jsDocTags = props.jsDocTags;
+    this.recursive = props.recursive;
+    this.nullables = props.nullables;
+  }
+
+  /**
+   * @internal
+   */
+  public static create(
+    props: ClassProperties<MetadataAliasType>,
+  ): MetadataAliasType {
+    return new MetadataAliasType(props);
+  }
+
+  /**
+   * @internal
+   */
+  public static _From_without_value(props: Omit<IMetadataAliasType, "value">) {
+    return MetadataAliasType.create({
+      name: props.name,
+      value: null!,
+      description: props.description,
+      recursive: props.recursive,
+      jsDocTags: props.jsDocTags.slice(),
+      nullables: props.nullables.slice(),
+    });
+  }
+
+  public toJSON(): IMetadataAliasType {
+    return {
+      name: this.name,
+      value: this.value.toJSON(),
+      description: this.description,
+      recursive: this.recursive,
+      jsDocTags: this.jsDocTags.slice(),
+      nullables: this.nullables.slice(),
+    };
+  }
+}