typia 5.0.0-dev.20230823-2 → 5.0.0-dev.20230827

package/src/schemas/metadata/IMetadataArrayType.ts

@@ -0,0 +1,10 @@
+import { IMetadata } from "./IMetadata";
+
+export interface IMetadataArrayType {
+    name: string;
+    value: IMetadata;
+
+    nullables: boolean[];
+    recursive: boolean;
+    index: number | null;
+}

package/src/schemas/metadata/IMetadataAtomic.ts

@@ -0,0 +1,6 @@
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadataAtomic {
+    type: "boolean" | "bigint" | "number" | "string";
+    tags: IMetadataTypeTag[][];
+}

package/src/schemas/metadata/IMetadataCollection.ts

@@ -1,11 +1,11 @@
 import { IMetadataAlias } from "./IMetadataAlias";
-import { IMetadataArray } from "./IMetadataArray";
+import { IMetadataArrayType } from "./IMetadataArrayType";
 import { IMetadataObject } from "./IMetadataObject";
-import { IMetadataTuple } from "./IMetadataTuple";
+import { IMetadataTupleType } from "./IMetadataTupleType";
 
 export interface IMetadataCollection {
     objects: IMetadataObject[];
     aliases: IMetadataAlias[];
-    arrays: IMetadataArray[];
-    tuples: IMetadataTuple[];
+    arrays: IMetadataArrayType[];
+    tuples: IMetadataTupleType[];
 }

package/src/schemas/metadata/IMetadataDictionary.ts

@@ -1,7 +1,7 @@
 import { MetadataAlias } from "./MetadataAlias";
-import { MetadataArray } from "./MetadataArray";
+import { MetadataArrayType } from "./MetadataArrayType";
 import { MetadataObject } from "./MetadataObject";
-import { MetadataTuple } from "./MetadataTuple";
+import { MetadataTupleType } from "./MetadataTupleType";
 
 /**
  * @internal
@@ -9,6 +9,6 @@ import { MetadataTuple } from "./MetadataTuple";
 export interface IMetadataDictionary {
     objects: Map<string, MetadataObject>;
     aliases: Map<string, MetadataAlias>;
-    arrays: Map<string, MetadataArray>;
-    tuples: Map<string, MetadataTuple>;
+    arrays: Map<string, MetadataArrayType>;
+    tuples: Map<string, MetadataTupleType>;
 }

package/src/schemas/metadata/IMetadataProperty.ts

@@ -1,11 +1,9 @@
 import { IJsDocTagInfo } from "./IJsDocTagInfo";
 import { IMetadata } from "./IMetadata";
-import { IMetadataTag } from "./IMetadataTag";
 
 export interface IMetadataProperty {
     key: IMetadata;
     value: IMetadata;
     description: string | null;
-    tags: IMetadataTag[];
     jsDocTags: IJsDocTagInfo[];
 }

package/src/schemas/metadata/IMetadataTuple.ts

@@ -1,10 +1,7 @@
-import { IMetadata } from "./IMetadata";
+import { IMetadataTupleType } from "./IMetadataTupleType";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
 
 export interface IMetadataTuple {
-    name: string;
-    elements: IMetadata[];
-
-    index: number | null;
-    recursive: boolean;
-    nullables: boolean[];
+    type: IMetadataTupleType;
+    tags: IMetadataTypeTag[][];
 }

package/src/schemas/metadata/IMetadataTupleType.ts

@@ -0,0 +1,10 @@
+import { IMetadata } from "./IMetadata";
+
+export interface IMetadataTupleType {
+    name: string;
+    elements: IMetadata[];
+
+    index: number | null;
+    recursive: boolean;
+    nullables: boolean[];
+}

package/src/schemas/metadata/IMetadataTypeTag.ts

@@ -0,0 +1,8 @@
+export interface IMetadataTypeTag {
+    target: "bigint" | "number" | "string" | "array";
+    name: string;
+    kind: string;
+    value: any;
+    validate: string;
+    exclusive: boolean | string[];
+}

package/src/schemas/metadata/Metadata.ts

@@ -1,4 +1,3 @@
-import { Atomic } from "../../typings/Atomic";
 import { ClassProperties } from "../../typings/ClassProperties";
 import { Writable } from "../../typings/Writable";
 
@@ -7,13 +6,17 @@ import { ArrayUtil } from "../../utils/ArrayUtil";
 import { IMetadata } from "./IMetadata";
 import { IMetadataCollection } from "./IMetadataCollection";
 import { IMetadataDictionary } from "./IMetadataDictionary";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
 import { MetadataAlias } from "./MetadataAlias";
 import { MetadataArray } from "./MetadataArray";
+import { MetadataArrayType } from "./MetadataArrayType";
+import { MetadataAtomic } from "./MetadataAtomic";
 import { MetadataConstant } from "./MetadataConstant";
 import { MetadataEscaped } from "./MetadataEscaped";
 import { MetadataObject } from "./MetadataObject";
 import { MetadataProperty } from "./MetadataProperty";
 import { MetadataTuple } from "./MetadataTuple";
+import { MetadataTupleType } from "./MetadataTupleType";
 
 export class Metadata {
     public any: boolean;
@@ -23,7 +26,7 @@ export class Metadata {
     public functional: boolean;
 
     public escaped: MetadataEscaped | null;
-    public atomics: Atomic.Literal[];
+    public atomics: MetadataAtomic[];
     public constants: MetadataConstant[];
     public templates: Metadata[][];
 
@@ -115,16 +118,30 @@ export class Metadata {
             nullable: this.nullable,
             functional: this.functional,
 
-            atomics: this.atomics.slice(),
-            constants: JSON.parse(JSON.stringify(this.constants)),
+            atomics: this.atomics.map((a) =>
+                MetadataAtomic.create({
+                    type: a.type,
+                    tags: a.tags.map((r) => r.slice()),
+                }),
+            ),
+            constants: this.constants.map((c) => ({
+                type: c.type,
+                values: c.values.slice() as any,
+            })),
             templates: this.templates.map((tpl) =>
                 tpl.map((meta) => meta.toJSON()),
             ),
             escaped: this.escaped ? this.escaped.toJSON() : null,
 
             rest: this.rest ? this.rest.toJSON() : null,
-            arrays: this.arrays.map((array) => array.name),
-            tuples: this.tuples.map((tuple) => tuple.name),
+            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),
             aliases: this.aliases.map((alias) => alias.name),
 
@@ -157,13 +174,13 @@ export class Metadata {
             arrays: new Map(
                 collection.arrays.map((arr) => [
                     arr.name,
-                    MetadataArray._From_without_value(arr),
+                    MetadataArrayType._From_without_value(arr),
                 ]),
             ),
             tuples: new Map(
                 collection.tuples.map((tpl) => [
                     tpl.name,
-                    MetadataTuple._From_without_elements(tpl),
+                    MetadataTupleType._From_without_elements(tpl),
                 ]),
             ),
         };
@@ -204,8 +221,10 @@ export class Metadata {
             nullable: meta.nullable,
             functional: meta.functional,
 
-            constants: JSON.parse(JSON.stringify(meta.constants)),
-            atomics: meta.atomics.slice(),
+            constants: meta.constants.slice(),
+            atomics: meta.atomics.map((a) =>
+                MetadataAtomic.create({ type: a.type, tags: a.tags }),
+            ),
             templates: meta.templates.map((tpl) =>
                 tpl.map((meta) => this._From(meta, dict)),
             ),
@@ -214,21 +233,27 @@ export class Metadata {
                 : null,
 
             rest: meta.rest ? this._From(meta.rest, dict) : null,
-            arrays: meta.arrays.map((id) => {
-                const array = dict.arrays.get(id);
-                if (array === undefined)
+            arrays: meta.arrays.map((ref) => {
+                const type = dict.arrays.get(ref.name);
+                if (type === undefined)
                     throw new Error(
-                        `Error on Metadata.from(): failed to find array "${id}".`,
+                        `Error on Metadata.from(): failed to find array "${ref.name}".`,
                     );
-                return array;
+                return MetadataArray.create({
+                    type,
+                    tags: ref.tags.map((row) => row.slice()),
+                });
             }),
-            tuples: meta.tuples.map((id) => {
-                const tuple = dict.tuples.get(id);
-                if (tuple === undefined)
+            tuples: meta.tuples.map((t) => {
+                const type = dict.tuples.get(t.name);
+                if (type === undefined)
                     throw new Error(
-                        `Error on Metadata.from(): failed to find tuple "${id}".`,
+                        `Error on Metadata.from(): failed to find tuple "${t.name}".`,
                     );
-                return tuple;
+                return MetadataTuple.create({
+                    type,
+                    tags: t.tags.map((r) => r.slice()),
+                });
             }),
             objects: meta.objects.map((name) => {
                 const found = dict.objects.get(name);
@@ -260,8 +285,7 @@ export class Metadata {
         ACCESSORS
     ----------------------------------------------------------- */
     public getName(): string {
-        this.name_ ??= getName(this);
-        return this.name_;
+        return (this.name_ ??= getName(this));
     }
 
     public empty(): boolean {
@@ -289,24 +313,6 @@ export class Metadata {
         );
     }
 
-    /**
-     * @internal
-     */
-    public binarySize(): number {
-        return (
-            new Set([
-                ...this.atomics,
-                ...this.constants.map((c) => c.type),
-                ...(this.templates.length ? ["string"] : []),
-            ]).size +
-            this.arrays.length +
-            this.tuples.length +
-            this.natives.length +
-            this.objects.length +
-            this.maps.length
-        );
-    }
-
     public bucket(): number {
         return (
             (this.any ? 1 : 0) +
@@ -344,13 +350,6 @@ export class Metadata {
         return emended > 1;
     }
 
-    /**
-     * @internal
-     */
-    public isBinaryUnion(): boolean {
-        return this.binarySize() > 1;
-    }
-
     /**
      * @internal
      */
@@ -403,7 +402,7 @@ export namespace Metadata {
         //----
         // ATOMICS
         for (const atomic of x.atomics)
-            if (y.atomics.includes(atomic)) return true;
+            if (y.atomics.some((ya) => atomic.type === ya.type)) return true;
 
         // CONSTANTS
         for (const constant of x.constants) {
@@ -440,7 +439,7 @@ export namespace Metadata {
             for (const ya of y.arrays)
                 if (
                     !x.arrays.some((xa) =>
-                        covers(xa.value, ya.value, level + 1),
+                        covers(xa.type.value, ya.type.value, level + 1),
                     )
                 ) {
                     return false;
@@ -449,14 +448,15 @@ export namespace Metadata {
             // TUPLES
             for (const yt of y.tuples)
                 if (
-                    yt.elements.length !== 0 &&
+                    yt.type.elements.length !== 0 &&
                     x.tuples.some(
                         (xt) =>
-                            xt.elements.length >= yt.elements.length &&
-                            xt.elements
-                                .slice(yt.elements.length)
+                            xt.type.elements.length >=
+                                yt.type.elements.length &&
+                            xt.type.elements
+                                .slice(yt.type.elements.length)
                                 .every((xv, i) =>
-                                    covers(xv, yt.elements[i]!, level + 1),
+                                    covers(xv, yt.type.elements[i]!, level + 1),
                                 ),
                     ) === false
                 )
@@ -485,12 +485,16 @@ export namespace Metadata {
         // VALUES
         //----
         // ATOMICS
-        if (y.atomics.some((atomic) => x.atomics.includes(atomic) === false))
+        if (
+            y.atomics.some(
+                (ya) => x.atomics.some((xa) => xa.type === ya.type) === false,
+            )
+        )
             return false;
 
         // CONSTANTS
         for (const yc of y.constants) {
-            if (x.atomics.some((type) => yc.type === type)) continue;
+            if (x.atomics.some((atom) => yc.type === atom.type)) continue;
             const xc: MetadataConstant | undefined = x.constants.find(
                 (elem) => elem.type === yc.type,
             );
@@ -523,8 +527,7 @@ export namespace Metadata {
 
             escaped:
                 x.escaped !== null && y.escaped !== null
-                    ? //? merge(x.resolved, y.resolved)
-                      MetadataEscaped.create({
+                    ? MetadataEscaped.create({
                           original: merge(
                               x.escaped.original,
                               y.escaped.original,
@@ -532,7 +535,11 @@ export namespace Metadata {
                           returns: merge(x.escaped.returns, y.escaped.returns),
                       })
                     : x.escaped ?? y.escaped,
-            atomics: [...new Set([...x.atomics, ...y.atomics])],
+            atomics: mergeTaggedTypes({
+                container: x.atomics,
+                equals: (x, y) => x.type === y.type,
+                getter: (x) => x.tags,
+            })(y.atomics),
             constants: [...x.constants],
             templates: x.templates.slice(),
 
@@ -540,8 +547,17 @@ export namespace Metadata {
                 x.rest !== null && y.rest !== null
                     ? merge(x.rest, y.rest)
                     : x.rest ?? y.rest,
-            arrays: x.arrays.slice(),
-            tuples: x.tuples.slice(),
+            // arrays: x.arrays.slice(),
+            arrays: mergeTaggedTypes({
+                container: x.arrays,
+                equals: (x, y) => x.type.name === y.type.name,
+                getter: (x) => x.tags,
+            })(y.arrays),
+            tuples: mergeTaggedTypes({
+                container: x.tuples,
+                equals: (x, y) => x.type.name === y.type.name,
+                getter: (x) => x.tags,
+            })(y.tuples),
             objects: x.objects.slice(),
             aliases: x.aliases.slice(),
 
@@ -561,10 +577,6 @@ export namespace Metadata {
             for (const value of constant.values)
                 ArrayUtil.add(target.values, value);
         }
-        for (const array of y.arrays)
-            ArrayUtil.set(output.arrays, array, (elem) => elem.name);
-        for (const tuple of y.tuples)
-            ArrayUtil.set(output.tuples, tuple, (elem) => elem.name);
         for (const obj of y.objects)
             ArrayUtil.set(output.objects, obj, (elem) => elem.name);
         for (const alias of y.aliases)
@@ -584,12 +596,16 @@ const getName = (metadata: Metadata): string => {
     if (metadata.isRequired() === false) elements.push("undefined");
 
     // ATOMIC
-    for (const type of metadata.atomics) {
-        elements.push(type);
+    for (const atom of metadata.atomics) {
+        elements.push(atom.getName());
     }
     for (const constant of metadata.constants)
         for (const value of constant.values)
-            elements.push(JSON.stringify(value));
+            elements.push(
+                constant.type === "string"
+                    ? JSON.stringify(value)
+                    : value.toString(),
+            );
     for (const template of metadata.templates)
         elements.push(
             "`" +
@@ -613,8 +629,8 @@ const getName = (metadata: Metadata): string => {
 
     // INSTANCES
     if (metadata.rest !== null) elements.push(`...${metadata.rest.getName()}`);
-    for (const tuple of metadata.tuples) elements.push(tuple.name);
-    for (const array of metadata.arrays) elements.push(array.name);
+    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 alias of metadata.aliases) elements.push(alias.name);
     if (metadata.escaped !== null) elements.push(metadata.escaped.getName());
@@ -632,3 +648,38 @@ export namespace Metadata {
         value: Metadata;
     }
 }
+
+const mergeTaggedTypes =
+    <T>(props: {
+        container: T[];
+        equals: (x: T, y: T) => boolean;
+        getter: (x: T) => IMetadataTypeTag[][];
+    }) =>
+    (opposite: T[]) => {
+        const output: T[] = [...props.container];
+        for (const elem of opposite) {
+            const equal = props.container.find((x) => props.equals(x, elem));
+            if (equal === undefined) {
+                output.push(elem);
+                continue;
+            }
+
+            const matrix: string[][] = props
+                .getter(equal)
+                .map((tags) => tags.map((t) => t.name))
+                .sort();
+            for (const tags of props.getter(elem)) {
+                const names: string[] = tags.map((t) => t.name).sort();
+                if (
+                    matrix.some(
+                        (m) =>
+                            m.length === names.length &&
+                            m.every((s, i) => s === names[i]),
+                    )
+                )
+                    continue;
+                props.getter(equal).push(tags);
+            }
+        }
+        return output;
+    };

package/src/schemas/metadata/MetadataAlias.ts

@@ -2,14 +2,12 @@ import { ClassProperties } from "../../typings/ClassProperties";
 
 import { IJsDocTagInfo } from "./IJsDocTagInfo";
 import { IMetadataAlias } from "./IMetadataAlias";
-import { IMetadataTag } from "./IMetadataTag";
 import { Metadata } from "./Metadata";
 
 export class MetadataAlias {
     public readonly name: string;
     public readonly value: Metadata;
     public readonly description: string | null;
-    public readonly tags: IMetadataTag[];
     public readonly jsDocTags: IJsDocTagInfo[];
     public readonly recursive: boolean;
     public readonly nullables: boolean[];
@@ -24,7 +22,6 @@ export class MetadataAlias {
         this.name = props.name;
         this.value = props.value;
         this.description = props.description;
-        this.tags = props.tags;
         this.jsDocTags = props.jsDocTags;
         this.recursive = props.recursive;
         this.nullables = props.nullables;
@@ -46,7 +43,6 @@ export class MetadataAlias {
             value: null!,
             description: props.description,
             recursive: props.recursive,
-            tags: props.tags.slice(),
             jsDocTags: props.jsDocTags.slice(),
             nullables: props.nullables.slice(),
         });
@@ -58,7 +54,6 @@ export class MetadataAlias {
             value: this.value.toJSON(),
             description: this.description,
             recursive: this.recursive,
-            tags: this.tags.slice(),
             jsDocTags: this.jsDocTags.slice(),
             nullables: this.nullables.slice(),
         };

package/src/schemas/metadata/MetadataArray.ts

@@ -1,55 +1,49 @@
 import { ClassProperties } from "../../typings/ClassProperties";
 
 import { IMetadataArray } from "./IMetadataArray";
-import { Metadata } from "./Metadata";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+import { MetadataArrayType } from "./MetadataArrayType";
 
 export class MetadataArray {
-    public readonly name: string;
-    public readonly value: Metadata;
-    public readonly nullables: boolean[];
-    public readonly recursive: boolean;
-    public readonly index: number | null;
+    public readonly type: MetadataArrayType;
+    public readonly tags: IMetadataTypeTag[][];
+
+    private name_?: string;
 
     /**
      * @hidden
      */
     private constructor(props: ClassProperties<MetadataArray>) {
-        this.name = props.name;
-        this.value = props.value;
-        this.index = props.index;
-        this.recursive = props.recursive;
-        this.nullables = props.nullables;
-    }
-
-    /**
-     * @internal
-     */
-    public static _From_without_value(
-        props: Omit<IMetadataArray, "value">,
-    ): MetadataArray {
-        return this.create({
-            name: props.name,
-            value: null!,
-            index: props.index,
-            recursive: props.recursive,
-            nullables: props.nullables,
-        });
+        this.type = props.type;
+        this.tags = props.tags;
     }
 
-    /**
-     * @internal
-     */
     public static create(props: ClassProperties<MetadataArray>): MetadataArray {
         return new MetadataArray(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(): IMetadataArray {
         return {
-            name: this.name,
-            value: this.value.toJSON(),
-            nullables: this.nullables,
-            recursive: this.recursive,
-            index: this.index,
+            type: this.type.toJSON(),
+            tags: this.tags.map((row) => row.slice()),
         };
     }
 }

package/src/schemas/metadata/MetadataArrayType.ts

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