typia 5.0.0-dev.2023084 → 5.0.0

package/src/factories/internal/metadata/iterate_metadata_collection.ts

@@ -1,133 +1,141 @@
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataArray } from "../../../schemas/metadata/MetadataArray";
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
-import { MetadataTuple } from "../../../schemas/metadata/MetadataTuple";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { iterate_metadata_tag } from "./iterate_metadata_tag";
-
-export const iterate_metadata_collection = (
-    collection: MetadataCollection,
-): void => {
-    for (const array of collection.arrays())
-        if (array.recursive === null)
-            collection.setArrayRecursive(
-                array,
-                isArrayRecursive(new Set())(array)(array.value),
-            );
-    for (const tuple of collection.tuples())
-        if (tuple.recursive === null) {
-            const visited: Set<Metadata> = new Set();
-            collection.setTupleRecursive(
-                tuple,
-                tuple.elements.some(isTupleRecursive(visited)(tuple)),
-            );
-        }
-    for (const obj of collection.objects()) {
-        iterate_metadata_tag(obj);
-        if (obj.recursive === null) {
-            const visited: Set<Metadata> = new Set();
-            collection.setObjectRecursive(
-                obj,
-                obj.properties.some((p) =>
-                    isObjectRecursive(visited)(obj)(p.value),
-                ),
-            );
-        }
-    }
-};
-
-const isArrayRecursive =
-    (visited: Set<Metadata>) =>
-    (array: MetadataArray) =>
-    (meta: Metadata): boolean => {
-        if (visited.has(meta)) return false;
-        visited.add(meta);
-
-        return (
-            meta.arrays.some(
-                (a) => a === array || isArrayRecursive(visited)(array)(a.value),
-            ) ||
-            meta.aliases.some((alias) =>
-                isArrayRecursive(visited)(array)(alias.value),
-            ) ||
-            meta.tuples.some(
-                (t) =>
-                    !t.recursive &&
-                    t.elements.some((e) => isArrayRecursive(visited)(array)(e)),
-            ) ||
-            meta.maps.some((m) => isArrayRecursive(visited)(array)(m.value)) ||
-            meta.sets.some((s) => isArrayRecursive(visited)(array)(s)) ||
-            (meta.escaped !== null &&
-                isArrayRecursive(visited)(array)(meta.escaped.returns)) ||
-            (meta.rest !== null && isArrayRecursive(visited)(array)(meta.rest))
-        );
-    };
-
-const isTupleRecursive =
-    (visited: Set<Metadata>) =>
-    (tuple: MetadataTuple) =>
-    (meta: Metadata): boolean => {
-        if (visited.has(meta)) return false;
-        visited.add(meta);
-
-        return (
-            meta.tuples.some(
-                (t) =>
-                    t === tuple ||
-                    t.elements.some((e) => isTupleRecursive(visited)(tuple)(e)),
-            ) ||
-            meta.arrays.some(
-                (a) =>
-                    !a.recursive && isTupleRecursive(visited)(tuple)(a.value),
-            ) ||
-            meta.maps.some((m) => isTupleRecursive(visited)(tuple)(m.value)) ||
-            meta.sets.some((s) => isTupleRecursive(visited)(tuple)(s)) ||
-            meta.aliases.some((alias) =>
-                isTupleRecursive(visited)(tuple)(alias.value),
-            ) ||
-            (meta.escaped !== null &&
-                isTupleRecursive(visited)(tuple)(meta.escaped.returns)) ||
-            (meta.rest !== null && isTupleRecursive(visited)(tuple)(meta.rest))
-        );
-    };
-
-const isObjectRecursive =
-    (visited: Set<Metadata>) =>
-    (obj: MetadataObject) =>
-    (meta: Metadata): boolean => {
-        if (visited.has(meta)) return false;
-
-        visited.add(meta);
-        return (
-            meta.objects.some(
-                (o) =>
-                    obj === o ||
-                    o.properties.some((prop) =>
-                        isObjectRecursive(visited)(obj)(prop.value),
-                    ),
-            ) ||
-            meta.aliases.some((alias) =>
-                isObjectRecursive(visited)(obj)(alias.value),
-            ) ||
-            meta.arrays.some(
-                (array) =>
-                    !array.recursive &&
-                    isObjectRecursive(visited)(obj)(array.value),
-            ) ||
-            meta.tuples.some(
-                (tuple) =>
-                    !tuple.recursive &&
-                    tuple.elements.some((elem) =>
-                        isObjectRecursive(visited)(obj)(elem),
-                    ),
-            ) ||
-            meta.maps.some((map) =>
-                isObjectRecursive(visited)(obj)(map.value),
-            ) ||
-            meta.sets.some((value) => isObjectRecursive(visited)(obj)(value)) ||
-            (meta.escaped !== null &&
-                isObjectRecursive(visited)(obj)(meta.escaped.returns)) ||
-            (meta.rest !== null && isObjectRecursive(visited)(obj)(meta.rest))
-        );
-    };
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
+import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
+import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { iterate_metadata_comment_tags } from "./iterate_metadata_comment_tags";
+
+export const iterate_metadata_collection =
+    (errors: MetadataFactory.IError[]) =>
+    (collection: MetadataCollection): void => {
+        for (const array of collection.arrays())
+            if (array.recursive === null)
+                collection.setArrayRecursive(
+                    array,
+                    isArrayRecursive(new Set())(array)(array.value),
+                );
+        for (const tuple of collection.tuples())
+            if (tuple.recursive === null) {
+                const visited: Set<Metadata> = new Set();
+                collection.setTupleRecursive(
+                    tuple,
+                    tuple.elements.some(isTupleRecursive(visited)(tuple)),
+                );
+            }
+        for (const obj of collection.objects()) {
+            iterate_metadata_comment_tags(errors)(obj);
+            if (obj.recursive === null) {
+                const visited: Set<Metadata> = new Set();
+                collection.setObjectRecursive(
+                    obj,
+                    obj.properties.some((p) =>
+                        isObjectRecursive(visited)(obj)(p.value),
+                    ),
+                );
+            }
+        }
+    };
+
+const isArrayRecursive =
+    (visited: Set<Metadata>) =>
+    (array: MetadataArrayType) =>
+    (meta: Metadata): boolean => {
+        if (visited.has(meta)) return false;
+        visited.add(meta);
+
+        return (
+            meta.arrays.some(
+                (a) =>
+                    a.type === array ||
+                    isArrayRecursive(visited)(array)(a.type.value),
+            ) ||
+            meta.aliases.some((alias) =>
+                isArrayRecursive(visited)(array)(alias.value),
+            ) ||
+            meta.tuples.some(
+                (t) =>
+                    !t.type.recursive &&
+                    t.type.elements.some((e) =>
+                        isArrayRecursive(visited)(array)(e),
+                    ),
+            ) ||
+            meta.maps.some((m) => isArrayRecursive(visited)(array)(m.value)) ||
+            meta.sets.some((s) => isArrayRecursive(visited)(array)(s)) ||
+            (meta.escaped !== null &&
+                isArrayRecursive(visited)(array)(meta.escaped.returns)) ||
+            (meta.rest !== null && isArrayRecursive(visited)(array)(meta.rest))
+        );
+    };
+
+const isTupleRecursive =
+    (visited: Set<Metadata>) =>
+    (tuple: MetadataTupleType) =>
+    (meta: Metadata): boolean => {
+        if (visited.has(meta)) return false;
+        visited.add(meta);
+
+        return (
+            meta.tuples.some(
+                (t) =>
+                    t.type === tuple ||
+                    t.type.elements.some((e) =>
+                        isTupleRecursive(visited)(tuple)(e),
+                    ),
+            ) ||
+            meta.arrays.some(
+                (a) =>
+                    !a.type.recursive &&
+                    isTupleRecursive(visited)(tuple)(a.type.value),
+            ) ||
+            meta.maps.some((m) => isTupleRecursive(visited)(tuple)(m.value)) ||
+            meta.sets.some((s) => isTupleRecursive(visited)(tuple)(s)) ||
+            meta.aliases.some((alias) =>
+                isTupleRecursive(visited)(tuple)(alias.value),
+            ) ||
+            (meta.escaped !== null &&
+                isTupleRecursive(visited)(tuple)(meta.escaped.returns)) ||
+            (meta.rest !== null && isTupleRecursive(visited)(tuple)(meta.rest))
+        );
+    };
+
+const isObjectRecursive =
+    (visited: Set<Metadata>) =>
+    (obj: MetadataObject) =>
+    (meta: Metadata): boolean => {
+        if (visited.has(meta)) return false;
+
+        visited.add(meta);
+        return (
+            meta.objects.some(
+                (o) =>
+                    obj === o ||
+                    o.properties.some((prop) =>
+                        isObjectRecursive(visited)(obj)(prop.value),
+                    ),
+            ) ||
+            meta.aliases.some((alias) =>
+                isObjectRecursive(visited)(obj)(alias.value),
+            ) ||
+            meta.arrays.some(
+                (array) =>
+                    !array.type.recursive &&
+                    isObjectRecursive(visited)(obj)(array.type.value),
+            ) ||
+            meta.tuples.some(
+                (tuple) =>
+                    !tuple.type.recursive &&
+                    tuple.type.elements.some((elem) =>
+                        isObjectRecursive(visited)(obj)(elem),
+                    ),
+            ) ||
+            meta.maps.some((map) =>
+                isObjectRecursive(visited)(obj)(map.value),
+            ) ||
+            meta.sets.some((value) => isObjectRecursive(visited)(obj)(value)) ||
+            (meta.escaped !== null &&
+                isObjectRecursive(visited)(obj)(meta.escaped.returns)) ||
+            (meta.rest !== null && isObjectRecursive(visited)(obj)(meta.rest))
+        );
+    };

package/src/factories/internal/metadata/iterate_metadata_comment_tags.ts

@@ -0,0 +1,26 @@
+import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
+
+import { MetadataCommentTagFactory } from "../../MetadataCommentTagFactory";
+import { MetadataFactory } from "../../MetadataFactory";
+
+export const iterate_metadata_comment_tags =
+    (errors: MetadataFactory.IError[]) => (object: MetadataObject) => {
+        if (object.tagged_ === true) return;
+        object.tagged_ = true;
+
+        for (const property of object.properties) {
+            MetadataCommentTagFactory.analyze(errors)(property.value)(
+                property.jsDocTags,
+                {
+                    top: false,
+                    object,
+                    property: property.key.isSoleLiteral()
+                        ? property.key.getSoleLiteral()!
+                        : {},
+                    nested: null,
+                    escaped: false,
+                    aliased: false,
+                },
+            );
+        }
+    };

package/src/factories/internal/metadata/iterate_metadata_intersection.ts

@@ -1,21 +1,27 @@
 import ts from "typescript";
 
+import { IMetadataTypeTag } from "../../../schemas/metadata/IMetadataTypeTag";
 import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataAtomic } from "../../../schemas/metadata/MetadataAtomic";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
+import { MetadataTypeTagFactory } from "../../MetadataTypeTagFactory";
 import { explore_metadata } from "./explore_metadata";
 import { iterate_metadata } from "./iterate_metadata";
+import { iterate_metadata_array } from "./iterate_metadata_array";
 
 export const iterate_metadata_intersection =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
+    (errors: MetadataFactory.IError[]) =>
     (
         meta: Metadata,
         type: ts.Type,
-        resolved: boolean,
-        aliased: boolean,
+        explore: MetadataFactory.IExplore,
     ): boolean => {
         if (!type.isIntersection()) return false;
         else if (
@@ -30,55 +36,162 @@ export const iterate_metadata_intersection =
 
         // COSTRUCT FAKE METADATA LIST
         const fakeCollection: MetadataCollection = new MetadataCollection();
+        const fakeErrors: MetadataFactory.IError[] = [];
         const children: Metadata[] = [
             ...new Map(
                 type.types.map((t) => {
                     const m: Metadata = explore_metadata(checker)({
                         ...options,
                         absorb: true,
-                    })(fakeCollection)(t, resolved);
+                    })(fakeCollection)(fakeErrors)(t, {
+                        ...explore,
+                        aliased: false,
+                    });
                     return [m.getName(), m] as const;
                 }),
             ).values(),
         ];
+        if (fakeErrors.length) {
+            errors.push(...fakeErrors);
+            return true;
+        }
 
         // ONLY ONE CHILD AFTER REMOVING DUPLICATES
         if (children.length === 1) {
-            iterate_metadata(checker)(options)(collection)(
+            iterate_metadata(checker)(options)(collection)(errors)(
                 meta,
                 type.types[0]!,
-                resolved,
-                aliased,
+                explore,
             );
             return true;
-        }
+        } else if (
+            // ONLY OBJECT TYPES -> SPECIAL LOGIC FOR TS V5.2
+            children.every((c) => c.objects.length === 1 && c.size() === 1)
+        )
+            return false;
 
-        // ABSORB TO ATOMIC (OR CONSTANT) TYPE
-        const atomics: Metadata[] = children.filter(
-            (c) =>
-                (c.atomics.length ? 1 : 0 + c.constants.length ? 1 : 0) ===
-                c.bucket(),
+        // VALIDATE EACH TYPES
+        const individuals: (readonly [Metadata, number])[] = children
+            .map((child, i) => [child, i] as const)
+            .filter(
+                ([c]) =>
+                    c.size() === 1 &&
+                    (c.atomics.length === 1 || c.arrays.length === 1),
+            );
+        const constants: Metadata[] = children.filter(
+            (m) =>
+                m.size() ===
+                m.constants
+                    .map((c) => c.values.length)
+                    .reduce((a, b) => a + b, 0) +
+                    m.templates.length,
         );
         const objects: Metadata[] = children.filter(
-            (c) => c.objects.length && c.objects.length === c.size(),
+            (c) =>
+                c.nullable === false &&
+                c.isRequired() === true &&
+                c.objects.length &&
+                c.objects.length === c.size() &&
+                c.objects.every((o) =>
+                    o.properties.every((p) => p.value.optional),
+                ),
+        );
+        const atomics: Set<"boolean" | "bigint" | "number" | "string"> =
+            new Set(
+                individuals.map(([c]) => c.atomics.map((a) => a.type)).flat(),
+            );
+        const arrays: Set<string> = new Set(
+            individuals.map(([c]) => c.arrays.map((a) => a.type.name)).flat(),
         );
+
+        // ESCAPE WHEN ONLY CONSTANT TYPES EXIST
+        if (
+            atomics.size + arrays.size > 1 ||
+            individuals.length + objects.length + constants.length !==
+                children.length
+        ) {
+            errors.push({
+                name: children.map((c) => c.getName()).join(" & "),
+                explore: { ...explore },
+                messages: ["nonsensible intersection"],
+            });
+            return true;
+        } else if (
+            atomics.size === 0 &&
+            arrays.size === 0 &&
+            constants.length
+        ) {
+            for (const m of constants) {
+                for (const tpl of m.templates)
+                    ArrayUtil.add(
+                        meta.templates,
+                        tpl,
+                        (a, b) =>
+                            a.map((ab) => ab.getName()).join(" | ") ===
+                            b.map((bb) => bb.getName()).join(" | "),
+                    );
+                for (const c of m.constants) {
+                    const oldbie = meta.constants.find(
+                        (o) => o.type === c.type,
+                    );
+                    if (oldbie)
+                        for (const elem of c.values)
+                            ArrayUtil.add(
+                                oldbie.values,
+                                elem,
+                                (a, b) => a === b,
+                            );
+                    else meta.constants.push({ ...c });
+                }
+            }
+            return true;
+        }
+
+        // RE-GENERATE TYPE
+        const target: "boolean" | "bigint" | "number" | "string" | "array" =
+            atomics.size ? atomics.values().next().value : "array";
         if (
-            atomics.length === 0 ||
-            atomics.length + objects.length !== children.length
+            target === "boolean" ||
+            target === "bigint" ||
+            target === "number" ||
+            target === "string"
         )
-            throw new Error(message(children));
+            ArrayUtil.add(
+                meta.atomics,
+                MetadataAtomic.create({
+                    type: atomics.values().next().value as "string",
+                    tags: [],
+                }),
+                (a, b) => a.type === b.type,
+            );
+        else if (target === "array") {
+            const name: string = arrays.values().next().value;
+            if (!meta.arrays.some((a) => a.type.name === name)) {
+                iterate_metadata_array(checker)(options)(collection)(errors)(
+                    meta,
+                    type.types[
+                        individuals.find((i) => i[0].arrays.length === 1)![1]
+                    ]!,
+                    {
+                        ...explore,
+                        aliased: false,
+                        escaped: false,
+                    },
+                );
+            }
+        }
 
-        const least: Metadata = atomics.reduce((x, y) => {
-            if (Metadata.covers(x, y)) return y;
-            else if (Metadata.covers(y, x)) return x;
-            throw new Error(message(children));
-        });
-        Object.assign(meta, Metadata.merge(meta, least));
-        collection.entire_.add(least);
+        // ASSIGN TAGS
+        if (objects.length && target !== "boolean") {
+            const tags: IMetadataTypeTag[] = MetadataTypeTagFactory.analyze(
+                errors,
+            )(target)(objects.map((om) => om.objects).flat(), explore);
+            if (tags.length)
+                if (target === "array") meta.arrays.at(-1)!.tags.push(tags);
+                else
+                    meta.atomics
+                        .find((a) => a.type === target)!
+                        .tags.push(tags);
+        }
         return true;
     };
-
-const message = (children: Metadata[]) =>
-    `Error on typia.MetadataFactory.analyze(): nonsensible intersection type detected - ${children
-        .map((c) => c.getName())
-        .join(" & ")}.`;

package/src/factories/internal/metadata/iterate_metadata_map.ts

@@ -13,7 +13,12 @@ export const iterate_metadata_map =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type): boolean => {
+    (errors: MetadataFactory.IError[]) =>
+    (
+        meta: Metadata,
+        type: ts.Type,
+        explore: MetadataFactory.IExplore,
+    ): boolean => {
         type = checker.getApparentType(type);
 
         const name = TypeFactory.getFullName(checker)(type, type.getSymbol());
@@ -29,10 +34,21 @@ export const iterate_metadata_map =
         ArrayUtil.set(
             meta.maps,
             {
-                key: explore_metadata(checker)(options)(collection)(key, false),
-                value: explore_metadata(checker)(options)(collection)(
+                key: explore_metadata(checker)(options)(collection)(errors)(
+                    key,
+                    {
+                        ...explore,
+                        escaped: false,
+                        aliased: false,
+                    },
+                ),
+                value: explore_metadata(checker)(options)(collection)(errors)(
                     value,
-                    false,
+                    {
+                        ...explore,
+                        escaped: false,
+                        aliased: false,
+                    },
                 ),
             },
             (elem) => `Map<${elem.key.getName()}, ${elem.value.getName()}>`,