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

package/src/schemas/metadata/IMetadataObject.ts

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

package/src/schemas/metadata/IMetadataObjectType.ts

@@ -0,0 +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[];
+}

package/src/schemas/metadata/IMetadataTuple.ts

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

package/src/schemas/metadata/Metadata.ts

@@ -12,6 +12,7 @@ import { MetadataConstant } from "./MetadataConstant";
 import { MetadataEscaped } from "./MetadataEscaped";
 import { MetadataFunction } from "./MetadataFunction";
 import { MetadataObject } from "./MetadataObject";
+import { MetadataObjectType } from "./MetadataObjectType";
 import { MetadataTemplate } from "./MetadataTemplate";
 import { MetadataTuple } from "./MetadataTuple";
 
@@ -122,15 +123,9 @@ export class Metadata {
       escaped: this.escaped ? this.escaped.toJSON() : null,
 
       rest: this.rest ? this.rest.toJSON() : null,
-      arrays: this.arrays.map((array) => ({
-        name: array.type.name,
-        tags: array.tags.map((r) => r.slice()),
-      })),
-      tuples: this.tuples.map((tuple) => ({
-        name: tuple.type.name,
-        tags: tuple.tags.map((r) => r.slice()),
-      })),
-      objects: this.objects.map((obj) => obj.name),
+      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(),
@@ -178,13 +173,16 @@ export class Metadata {
           tags: t.tags.map((r) => r.slice()),
         });
       }),
-      objects: meta.objects.map((name) => {
-        const found = dict.objects.get(name);
+      objects: meta.objects.map((obj) => {
+        const found = dict.objects.get(obj.name);
         if (found === undefined)
           throw new RangeError(
             `Error on Metadata.from(): failed to find object "${name}".`,
           );
-        return found;
+        return MetadataObject.create({
+          type: found,
+          tags: obj.tags.map((r) => r.slice()),
+        });
       }),
       aliases: meta.aliases.map((alias) => {
         const found = dict.aliases.get(alias);
@@ -194,7 +192,6 @@ export class Metadata {
           );
         return found;
       }),
-
       natives: meta.natives.slice(),
       sets: meta.sets.map((meta) => this.from(meta, dict)),
       maps: meta.maps.map((entry) => ({
@@ -418,7 +415,10 @@ export namespace Metadata {
 
     // OBJECTS
     for (const yo of y.objects)
-      if (x.objects.some((xo) => MetadataObject.covers(xo, yo)) === false)
+      if (
+        x.objects.some((xo) => MetadataObjectType.covers(xo.type, yo.type)) ===
+        false
+      )
         return false;
 
     // ALIASES
@@ -528,7 +528,7 @@ export namespace Metadata {
         ArrayUtil.add(target.values, value, (a, b) => a.value === b.value);
     }
     for (const obj of y.objects)
-      ArrayUtil.set(output.objects, obj, (elem) => elem.name);
+      ArrayUtil.set(output.objects, obj, (elem) => elem.type.name);
     for (const alias of y.aliases)
       ArrayUtil.set(output.aliases, alias, (elem) => elem.name);
 
@@ -563,7 +563,7 @@ const getName = (metadata: Metadata): string => {
   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.name);
+  for (const object of metadata.objects) elements.push(object.getName());
   for (const alias of metadata.aliases) elements.push(alias.name);
   if (metadata.escaped !== null) elements.push(metadata.escaped.getName());
 

package/src/schemas/metadata/MetadataArray.ts

@@ -42,7 +42,7 @@ export class MetadataArray {
 
   public toJSON(): IMetadataArray {
     return {
-      type: this.type.toJSON(),
+      name: this.type.name,
       tags: this.tags.map((row) => row.slice()),
     };
   }

package/src/schemas/metadata/MetadataComponents.ts

@@ -6,13 +6,13 @@ import { IMetadataDictionary } from "./IMetadataDictionary";
 import { Metadata } from "./Metadata";
 import { MetadataAlias } from "./MetadataAlias";
 import { MetadataArrayType } from "./MetadataArrayType";
-import { MetadataObject } from "./MetadataObject";
+import { MetadataObjectType } from "./MetadataObjectType";
 import { MetadataProperty } from "./MetadataProperty";
 import { MetadataTupleType } from "./MetadataTupleType";
 
 export class MetadataComponents {
   public readonly aliases: MetadataAlias[];
-  public readonly objects: MetadataObject[];
+  public readonly objects: MetadataObjectType[];
   public readonly arrays: MetadataArrayType[];
   public readonly tuples: MetadataTupleType[];
   public readonly dictionary: IMetadataDictionary;
@@ -31,7 +31,7 @@ export class MetadataComponents {
       objects: new Map(
         json.objects.map((obj) => [
           obj.name,
-          MetadataObject._From_without_properties(obj),
+          MetadataObjectType._From_without_properties(obj),
         ]),
       ),
       aliases: new Map(

package/src/schemas/metadata/MetadataObject.ts

@@ -1,139 +1,48 @@
 import { ClassProperties } from "../../typings/ClassProperties";
 
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
 import { IMetadataObject } from "./IMetadataObject";
-import { MetadataProperty } from "./MetadataProperty";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+import { MetadataObjectType } from "./MetadataObjectType";
 
 export class MetadataObject {
-  public readonly name: string;
-  public readonly properties: Array<MetadataProperty>;
-  public readonly description: string | undefined;
-  public readonly jsDocTags: IJsDocTagInfo[];
-
-  public readonly index: number;
-  public validated: boolean;
-  public recursive: boolean;
-  public nullables: boolean[] = [];
-
-  /**
-   * @internal
-   */
-  public tagged_: boolean = false;
+  public readonly type: MetadataObjectType;
+  public readonly tags: IMetadataTypeTag[][];
+  private name_?: string;
 
-  /**
-   * @internal
-   */
-  private literal_?: boolean;
-
-  /* -----------------------------------------------------------
-        CONSTRUCTORS
-    ----------------------------------------------------------- */
   /**
    * @hidden
    */
-  private constructor(props: Omit<ClassProperties<MetadataObject>, "tagged_">) {
-    this.name = props.name;
-    this.properties = props.properties;
-    this.description = props.description;
-    this.jsDocTags = props.jsDocTags;
-
-    this.index = props.index;
-    this.validated = props.validated;
-    this.recursive = props.recursive;
-    this.nullables = props.nullables.slice();
-
-    this.tagged_ = false;
+  private constructor(props: ClassProperties<MetadataObject>) {
+    this.type = props.type;
+    this.tags = props.tags;
   }
 
-  /**
-   * @internal
-   */
-  public static create(
-    props: Omit<ClassProperties<MetadataObject>, "tagged_">,
-  ) {
+  public static create(props: ClassProperties<MetadataObject>): MetadataObject {
     return new MetadataObject(props);
   }
 
-  /**
-   * @internal
-   */
-  public static _From_without_properties(obj: IMetadataObject): MetadataObject {
-    return MetadataObject.create({
-      name: obj.name,
-      properties: [],
-      description: obj.description,
-      jsDocTags: obj.jsDocTags,
-
-      index: obj.index,
-      validated: false,
-      recursive: obj.recursive,
-      nullables: obj.nullables.slice(),
-    });
-  }
-
-  public isPlain(level: number = 0): boolean {
-    return (
-      this.recursive === false &&
-      this.properties.length < 10 &&
-      this.properties.every(
-        (property) =>
-          property.key.isSoleLiteral() &&
-          property.value.size() === 1 &&
-          property.value.isRequired() === true &&
-          property.value.nullable === false &&
-          (property.value.atomics.length === 1 ||
-            (level < 1 &&
-              property.value.objects.length === 1 &&
-              property.value.objects[0]!.isPlain(level + 1))),
-      )
-    );
-  }
-
-  public isLiteral(): boolean {
-    return (this.literal_ ??= (() => {
-      if (this.recursive === true) return false;
-      return (
-        this.name === "__type" ||
-        this.name === "__object" ||
-        this.name.startsWith("__type.") ||
-        this.name.startsWith("__object.") ||
-        this.name.includes("readonly [")
-      );
+  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(): IMetadataObject {
     return {
-      name: this.name,
-      properties: this.properties.map((property) => property.toJSON()),
-      description: this.description,
-      jsDocTags: this.jsDocTags,
-
-      index: this.index,
-      recursive: this.recursive,
-      nullables: this.nullables.slice(),
+      name: this.type.name,
+      tags: this.tags.map((row) => row.slice()),
     };
   }
 }
-
-/**
- * @internal
- */
-export namespace MetadataObject {
-  export const intersects = (x: MetadataObject, y: MetadataObject): boolean =>
-    x.properties.some(
-      (prop) =>
-        y.properties.find(
-          (oppo) => prop.key.getName() === oppo.key.getName(),
-        ) !== undefined,
-    );
-
-  export const covers = (x: MetadataObject, y: MetadataObject): boolean =>
-    x.properties.length >= y.properties.length &&
-    x.properties.every(
-      (prop) =>
-        y.properties.find(
-          (oppo) => prop.key.getName() === oppo.key.getName(),
-        ) !== undefined,
-    );
-}

package/src/schemas/metadata/MetadataObjectType.ts

@@ -0,0 +1,149 @@
+import { ClassProperties } from "../../typings/ClassProperties";
+
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataObjectType } from "./IMetadataObjectType";
+import { MetadataProperty } from "./MetadataProperty";
+
+export class MetadataObjectType {
+  public readonly name: string;
+  public readonly properties: Array<MetadataProperty>;
+  public readonly description: string | undefined;
+  public readonly jsDocTags: IJsDocTagInfo[];
+
+  public readonly index: number;
+  public validated: boolean;
+  public recursive: boolean;
+  public nullables: boolean[] = [];
+
+  /**
+   * @internal
+   */
+  public tagged_: boolean = false;
+
+  /**
+   * @internal
+   */
+  private literal_?: boolean;
+
+  /* -----------------------------------------------------------
+        CONSTRUCTORS
+    ----------------------------------------------------------- */
+  /**
+   * @hidden
+   */
+  private constructor(
+    props: Omit<ClassProperties<MetadataObjectType>, "tagged_">,
+  ) {
+    this.name = props.name;
+    this.properties = props.properties;
+    this.description = props.description;
+    this.jsDocTags = props.jsDocTags;
+
+    this.index = props.index;
+    this.validated = props.validated;
+    this.recursive = props.recursive;
+    this.nullables = props.nullables.slice();
+
+    this.tagged_ = false;
+  }
+
+  /**
+   * @internal
+   */
+  public static create(
+    props: Omit<ClassProperties<MetadataObjectType>, "tagged_">,
+  ) {
+    return new MetadataObjectType(props);
+  }
+
+  /**
+   * @internal
+   */
+  public static _From_without_properties(
+    obj: IMetadataObjectType,
+  ): MetadataObjectType {
+    return MetadataObjectType.create({
+      name: obj.name,
+      properties: [],
+      description: obj.description,
+      jsDocTags: obj.jsDocTags,
+
+      index: obj.index,
+      validated: false,
+      recursive: obj.recursive,
+      nullables: obj.nullables.slice(),
+    });
+  }
+
+  public isPlain(level: number = 0): boolean {
+    return (
+      this.recursive === false &&
+      this.properties.length < 10 &&
+      this.properties.every(
+        (property) =>
+          property.key.isSoleLiteral() &&
+          property.value.size() === 1 &&
+          property.value.isRequired() === true &&
+          property.value.nullable === false &&
+          (property.value.atomics.length === 1 ||
+            (level < 1 &&
+              property.value.objects.length === 1 &&
+              property.value.objects[0]!.type.isPlain(level + 1))),
+      )
+    );
+  }
+
+  public isLiteral(): boolean {
+    return (this.literal_ ??= (() => {
+      if (this.recursive === true) return false;
+      return (
+        this.name === "__type" ||
+        this.name === "__object" ||
+        this.name.startsWith("__type.") ||
+        this.name.startsWith("__object.") ||
+        this.name.includes("readonly [")
+      );
+    })());
+  }
+
+  public toJSON(): IMetadataObjectType {
+    return {
+      name: this.name,
+      properties: this.properties.map((property) => property.toJSON()),
+      description: this.description,
+      jsDocTags: this.jsDocTags,
+
+      index: this.index,
+      recursive: this.recursive,
+      nullables: this.nullables.slice(),
+    };
+  }
+}
+
+/**
+ * @internal
+ */
+export namespace MetadataObjectType {
+  export const intersects = (
+    x: MetadataObjectType,
+    y: MetadataObjectType,
+  ): boolean =>
+    x.properties.some(
+      (prop) =>
+        y.properties.find(
+          (oppo) => prop.key.getName() === oppo.key.getName(),
+        ) !== undefined,
+    );
+
+  export const covers = (
+    x: MetadataObjectType,
+    y: MetadataObjectType,
+  ): boolean =>
+    x.properties.length >= y.properties.length &&
+    x.properties.every(
+      (prop) =>
+        y.properties.find(
+          (oppo) => prop.key.getName() === oppo.key.getName(),
+        ) !== undefined,
+    );
+}

package/src/schemas/metadata/MetadataTuple.ts

@@ -25,7 +25,7 @@ export class MetadataTuple {
 
   public toJSON(): IMetadataTuple {
     return {
-      type: this.type.toJSON(),
+      name: this.type.name,
       tags: this.tags.map((row) => row.slice()),
     };
   }

package/src/transformers/TransformerError.ts

@@ -1,6 +1,6 @@
 import { MetadataFactory } from "../factories/MetadataFactory";
 
-import { MetadataObject } from "../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../schemas/metadata/MetadataObjectType";
 
 import { Escaper } from "../utils/Escaper";
 
@@ -50,10 +50,11 @@ export namespace TransformerError {
     });
   };
 
-  const join = (object: MetadataObject) => (key: string | object | null) => {
-    if (key === null) return object.name;
-    else if (typeof key === "object") return `${object.name}[key]`;
-    else if (Escaper.variable(key)) return `${object.name}.${key}`;
-    return `${object.name}[${JSON.stringify(key)}]`;
-  };
+  const join =
+    (object: MetadataObjectType) => (key: string | object | null) => {
+      if (key === null) return object.name;
+      else if (typeof key === "object") return `${object.name}[key]`;
+      else if (Escaper.variable(key)) return `${object.name}.${key}`;
+      return `${object.name}[${JSON.stringify(key)}]`;
+    };
 }