typia 5.0.0-dev.20230823 → 5.0.0-dev.20230824

package/src/schemas/json/IJsonSchema.ts

@@ -1,5 +1,5 @@
 import { IJsDocTagInfo } from "../metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../metadata/IMetadataTag";
+import { IMetadataCommentTag } from "../metadata/IMetadataCommentTag";
 
 import { Atomic } from "../../typings/Atomic";
 
@@ -124,7 +124,7 @@ export namespace IJsonSchema {
         deprecated?: boolean;
         title?: string;
         description?: string;
-        "x-typia-metaTags"?: IMetadataTag[];
+        "x-typia-metaTags"?: IMetadataCommentTag[];
         "x-typia-jsDocTags"?: IJsDocTagInfo[];
         "x-typia-required"?: boolean;
         "x-typia-optional"?: boolean;

package/src/schemas/metadata/IMetadata.ts

@@ -1,8 +1,8 @@
-import { Atomic } from "../../typings/Atomic";
-
+import { IMetadataAtomic } from "./IMetadataAtomic";
 import { IMetadataConstant } from "./IMetadataConstant";
 import { IMetadataEntry } from "./IMetadataEntry";
-import { IMetadataResolved } from "./IMetadataResolved";
+import { IMetadataEscaped } from "./IMetadataEscaped";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
 
 export interface IMetadata {
     any: boolean;
@@ -11,14 +11,20 @@ export interface IMetadata {
     nullable: boolean;
     functional: boolean;
 
-    atomics: Atomic.Literal[];
+    atomics: IMetadataAtomic[];
     constants: IMetadataConstant[];
     templates: IMetadata[][];
-    resolved: IMetadataResolved | null;
+    escaped: IMetadataEscaped | null;
 
     rest: IMetadata | null;
-    arrays: string[];
-    tuples: string[];
+    arrays: {
+        name: string;
+        tags: IMetadataTypeTag[][];
+    }[];
+    tuples: {
+        name: string;
+        tags: IMetadataTypeTag[][];
+    }[];
     objects: string[];
     aliases: string[];
 

package/src/schemas/metadata/IMetadataAlias.ts

@@ -1,6 +1,6 @@
 import { IJsDocTagInfo } from "./IJsDocTagInfo";
 import { IMetadata } from "./IMetadata";
-import { IMetadataTag } from "./IMetadataTag";
+import { IMetadataCommentTag } from "./IMetadataCommentTag";
 
 export interface IMetadataAlias {
     name: string;
@@ -8,7 +8,7 @@ export interface IMetadataAlias {
     nullables: boolean[];
 
     description: string | null;
-    tags: IMetadataTag[];
+    tags: IMetadataCommentTag[];
     jsDocTags: IJsDocTagInfo[];
     recursive: boolean;
 }

package/src/schemas/metadata/IMetadataArray.ts

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

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/{IMetadataTag.ts → IMetadataCommentTag.ts}

@@ -1,24 +1,24 @@
-export type IMetadataTag =
+export type IMetadataCommentTag =
     // NUMBER
-    | IMetadataTag.INumberType
-    | IMetadataTag.IMinimum
-    | IMetadataTag.IMaximum
-    | IMetadataTag.IExclusiveMinimum
-    | IMetadataTag.IExclusiveMaximum
-    | IMetadataTag.IMultipleOf
-    | IMetadataTag.IStep
+    | IMetadataCommentTag.INumberType
+    | IMetadataCommentTag.IMinimum
+    | IMetadataCommentTag.IMaximum
+    | IMetadataCommentTag.IExclusiveMinimum
+    | IMetadataCommentTag.IExclusiveMaximum
+    | IMetadataCommentTag.IMultipleOf
+    | IMetadataCommentTag.IStep
     // STRING
-    | IMetadataTag.IFormat
-    | IMetadataTag.IPattern
-    | IMetadataTag.ILength
-    | IMetadataTag.IMinLength
-    | IMetadataTag.IMaxLength
+    | IMetadataCommentTag.IFormat
+    | IMetadataCommentTag.IPattern
+    | IMetadataCommentTag.ILength
+    | IMetadataCommentTag.IMinLength
+    | IMetadataCommentTag.IMaxLength
     // ARRAY
-    | IMetadataTag.IItems
-    | IMetadataTag.IMinItems
-    | IMetadataTag.IMaxItems;
+    | IMetadataCommentTag.IItems
+    | IMetadataCommentTag.IMinItems
+    | IMetadataCommentTag.IMaxItems;
 
-export namespace IMetadataTag {
+export namespace IMetadataCommentTag {
     /* -----------------------------------------------------------
         NUMBER
     ----------------------------------------------------------- */

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/{IMetadataResolved.ts → IMetadataEscaped.ts}

@@ -1,6 +1,6 @@
 import { IMetadata } from "./IMetadata";
 
-export interface IMetadataResolved {
+export interface IMetadataEscaped {
     original: IMetadata;
     returns: IMetadata;
 }

package/src/schemas/metadata/IMetadataProperty.ts

@@ -1,11 +1,11 @@
 import { IJsDocTagInfo } from "./IJsDocTagInfo";
 import { IMetadata } from "./IMetadata";
-import { IMetadataTag } from "./IMetadataTag";
+import { IMetadataCommentTag } from "./IMetadataCommentTag";
 
 export interface IMetadataProperty {
     key: IMetadata;
     value: IMetadata;
     description: string | null;
-    tags: IMetadataTag[];
+    tags: IMetadataCommentTag[];
     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,6 @@
+export interface IMetadataTypeTag {
+    name: string;
+    kind: string;
+    value: any;
+    validate: string;
+}

package/src/schemas/metadata/Metadata.ts

@@ -1,19 +1,24 @@
-import { Atomic } from "../../typings/Atomic";
+import { $clone } from "../../functional/$clone";
+
 import { ClassProperties } from "../../typings/ClassProperties";
 import { Writable } from "../../typings/Writable";
 
 import { ArrayUtil } from "../../utils/ArrayUtil";
 
 import { IMetadata } from "./IMetadata";
+import { IMetadataAtomic } from "./IMetadataAtomic";
 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 { MetadataConstant } from "./MetadataConstant";
+import { MetadataEscaped } from "./MetadataEscaped";
 import { MetadataObject } from "./MetadataObject";
 import { MetadataProperty } from "./MetadataProperty";
-import { MetadataResolved } from "./MetadataResolved";
 import { MetadataTuple } from "./MetadataTuple";
+import { MetadataTupleType } from "./MetadataTupleType";
 
 export class Metadata {
     public any: boolean;
@@ -22,8 +27,8 @@ export class Metadata {
     public nullable: boolean;
     public functional: boolean;
 
-    public resolved: MetadataResolved | null;
-    public atomics: Atomic.Literal[];
+    public escaped: MetadataEscaped | null;
+    public atomics: IMetadataAtomic[];
     public constants: MetadataConstant[];
     public templates: Metadata[][];
 
@@ -55,7 +60,7 @@ export class Metadata {
         this.nullable = props.nullable;
         this.functional = props.functional;
 
-        this.resolved = props.resolved;
+        this.escaped = props.escaped;
         this.atomics = props.atomics;
         this.constants = props.constants;
         this.templates = props.templates;
@@ -89,7 +94,7 @@ export class Metadata {
             optional: false,
             functional: false,
 
-            resolved: null,
+            escaped: null,
             constants: [],
             atomics: [],
             templates: [],
@@ -115,16 +120,22 @@ export class Metadata {
             nullable: this.nullable,
             functional: this.functional,
 
-            atomics: this.atomics.slice(),
-            constants: JSON.parse(JSON.stringify(this.constants)),
+            atomics: $clone(this.atomics),
+            constants: $clone(this.constants),
             templates: this.templates.map((tpl) =>
                 tpl.map((meta) => meta.toJSON()),
             ),
-            resolved: this.resolved ? this.resolved.toJSON() : null,
+            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: $clone(array.tags),
+            })),
+            tuples: this.tuples.map((tuple) => ({
+                name: tuple.type.name,
+                tags: $clone(tuple.tags),
+            })),
             objects: this.objects.map((obj) => obj.name),
             aliases: this.aliases.map((alias) => alias.name),
 
@@ -157,13 +168,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,31 +215,37 @@ export class Metadata {
             nullable: meta.nullable,
             functional: meta.functional,
 
-            constants: JSON.parse(JSON.stringify(meta.constants)),
-            atomics: meta.atomics.slice(),
+            constants: $clone(meta.constants),
+            atomics: $clone(meta.atomics),
             templates: meta.templates.map((tpl) =>
                 tpl.map((meta) => this._From(meta, dict)),
             ),
-            resolved: meta.resolved
-                ? MetadataResolved._From(meta.resolved, dict)
+            escaped: meta.escaped
+                ? MetadataEscaped._From(meta.escaped, dict)
                 : 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: $clone(ref.tags),
+                });
             }),
-            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: $clone(t.tags),
+                });
             }),
             objects: meta.objects.map((name) => {
                 const found = dict.objects.get(name);
@@ -271,7 +288,7 @@ export class Metadata {
     public size(): number {
         return (
             (this.any ? 1 : 0) +
-            (this.resolved ? 1 : 0) +
+            (this.escaped ? 1 : 0) +
             (this.functional ? 1 : 0) +
             (this.rest ? this.rest.size() : 0) +
             this.templates.length +
@@ -294,8 +311,8 @@ export class Metadata {
      */
     public binarySize(): number {
         return (
-            new Set([
-                ...this.atomics,
+            new Set<string>([
+                ...this.atomics.map((a) => a.type),
                 ...this.constants.map((c) => c.type),
                 ...(this.templates.length ? ["string"] : []),
             ]).size +
@@ -310,7 +327,7 @@ export class Metadata {
     public bucket(): number {
         return (
             (this.any ? 1 : 0) +
-            (this.resolved ? 1 : 0) +
+            (this.escaped ? 1 : 0) +
             (this.functional ? 1 : 0) +
             (this.templates.length ? 1 : 0) +
             (this.atomics.length ? 1 : 0) +
@@ -403,7 +420,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 +457,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 +466,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 +503,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,
             );
@@ -521,21 +543,21 @@ export namespace Metadata {
             optional: x.optional || y.optional,
             functional: x.functional || y.functional,
 
-            resolved:
-                x.resolved !== null && y.resolved !== null
-                    ? //? merge(x.resolved, y.resolved)
-                      MetadataResolved.create({
+            escaped:
+                x.escaped !== null && y.escaped !== null
+                    ? MetadataEscaped.create({
                           original: merge(
-                              x.resolved.original,
-                              y.resolved.original,
-                          ),
-                          returns: merge(
-                              x.resolved.returns,
-                              y.resolved.returns,
+                              x.escaped.original,
+                              y.escaped.original,
                           ),
+                          returns: merge(x.escaped.returns, y.escaped.returns),
                       })
-                    : x.resolved ?? y.resolved,
-            atomics: [...new Set([...x.atomics, ...y.atomics])],
+                    : x.escaped ?? y.escaped,
+            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(),
 
@@ -543,8 +565,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(),
 
@@ -564,10 +595,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)
@@ -587,8 +614,8 @@ 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.type);
     }
     for (const constant of metadata.constants)
         for (const value of constant.values)
@@ -616,11 +643,11 @@ 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.type.name);
     for (const object of metadata.objects) elements.push(object.name);
     for (const alias of metadata.aliases) elements.push(alias.name);
-    if (metadata.resolved !== null) elements.push(metadata.resolved.getName());
+    if (metadata.escaped !== null) elements.push(metadata.escaped.getName());
 
     // RETURNS
     if (elements.length === 0) return "unknown";
@@ -635,3 +662,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,14 @@ import { ClassProperties } from "../../typings/ClassProperties";
 
 import { IJsDocTagInfo } from "./IJsDocTagInfo";
 import { IMetadataAlias } from "./IMetadataAlias";
-import { IMetadataTag } from "./IMetadataTag";
+import { IMetadataCommentTag } from "./IMetadataCommentTag";
 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 tags: IMetadataCommentTag[];
     public readonly jsDocTags: IJsDocTagInfo[];
     public readonly recursive: boolean;
     public readonly nullables: boolean[];