typia 5.0.0-dev.20230824 → 5.0.0-dev.20230828

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

@@ -13,7 +13,12 @@ export const iterate_metadata_alias =
     (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 => {
         if (options.absorb !== false || type.aliasSymbol === undefined)
             return false;
 
@@ -24,7 +29,7 @@ export const iterate_metadata_alias =
         // CONSTRUCT DEFINITION
         const alias: MetadataAlias = emplace_metadata_alias(checker)(options)(
             collection,
-        )(type, meta.nullable);
+        )(errors)(type, meta.nullable, explore);
         ArrayUtil.add(meta.aliases, alias, (elem) => elem.name === alias.name);
         return true;
     };

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

@@ -14,12 +14,17 @@ export const iterate_metadata_array =
     (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 => {
         if (!checker.isArrayType(type)) return false;
 
         const arrayType: MetadataArrayType = emplace_metadata_array_type(
             checker,
-        )(options)(collection)(type, meta.nullable);
+        )(options)(collection)(errors)(type, meta.nullable, explore);
         ArrayUtil.add(
             meta.arrays,
             MetadataArray.create({

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

@@ -1,6 +1,7 @@
 import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataAtomic } from "../../../schemas/metadata/MetadataAtomic";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
@@ -19,7 +20,7 @@ export const iterate_metadata_atomic = (
         if (filter(info.atomic) || filter(info.literal)) {
             ArrayUtil.add(
                 meta.atomics,
-                { type: info.name, tags: [] },
+                MetadataAtomic.create({ type: info.name, tags: [] }),
                 (x, y) => x.type === y.type,
             );
             return true;

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

@@ -4,38 +4,39 @@ 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 = (
-    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(obj);
-        if (obj.recursive === null) {
-            const visited: Set<Metadata> = new Set();
-            collection.setObjectRecursive(
-                obj,
-                obj.properties.some((p) =>
-                    isObjectRecursive(visited)(obj)(p.value),
-                ),
-            );
+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>) =>

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

@@ -1,31 +1,26 @@
 import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
 
-import { Writable } from "../../../typings/Writable";
+import { MetadataCommentTagFactory } from "../../MetadataCommentTagFactory";
+import { MetadataFactory } from "../../MetadataFactory";
 
-import { Escaper } from "../../../utils/Escaper";
+export const iterate_metadata_comment_tags =
+    (errors: MetadataFactory.IError[]) => (object: MetadataObject) => {
+        if (object.tagged_ === true) return;
+        object.tagged_ = true;
 
-import { MetadataTagFactory } from "../../MetadataTagFactory";
-
-export const iterate_metadata_comment_tags = (obj: MetadataObject) => {
-    if (obj.tagged_ === true) return;
-    obj.tagged_ = true;
-
-    for (const prop of obj.properties) {
-        const key: string = prop.key.getName();
-        const variable: string | null =
-            key.length >= 3 &&
-            key[0] === '"' &&
-            key[key.length - 1] === '"' &&
-            Escaper.variable(key.slice(1, -1))
-                ? key.slice(1, -1)
-                : null;
-
-        Writable(prop).tags = MetadataTagFactory.generate(prop.value)(
-            prop.jsDocTags,
-        )(
-            variable !== null
-                ? () => `${obj.name}.${variable}`
-                : () => `${obj.name}[${key}]`,
-        );
-    }
-};
+        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,28 +1,27 @@
 import ts from "typescript";
 
-import { $clone } from "../../../functional/$clone";
-
 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";
-import { iterate_metadata_type_tags } from "./iterate_metadata_type_tags";
 
 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 (
@@ -37,28 +36,39 @@ 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;
 
         // VALIDATE EACH TYPES
         const individuals: (readonly [Metadata, number])[] = children
@@ -99,9 +109,18 @@ export const iterate_metadata_intersection =
             atomics.size + arrays.size > 1 ||
             individuals.length + objects.length + constants.length !==
                 children.length
-        )
-            throw new Error(message(children));
-        else if (atomics.size === 0 && arrays.size === 0 && constants.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(
@@ -122,7 +141,7 @@ export const iterate_metadata_intersection =
                                 elem,
                                 (a, b) => a === b,
                             );
-                    else meta.constants.push($clone(c));
+                    else meta.constants.push({ ...c });
                 }
             }
             return true;
@@ -139,29 +158,34 @@ export const iterate_metadata_intersection =
         )
             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)(
+                iterate_metadata_array(checker)(options)(collection)(errors)(
                     meta,
                     type.types[
                         individuals.find((i) => i[0].arrays.length === 1)![1]
                     ]!,
+                    {
+                        ...explore,
+                        aliased: false,
+                        escaped: false,
+                    },
                 );
             }
         }
 
         // ASSIGN TAGS
         if (objects.length && target !== "boolean") {
-            const tags: IMetadataTypeTag[] = iterate_metadata_type_tags(target)(
-                objects.map((om) => om.objects).flat(),
-            );
+            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
@@ -171,8 +195,3 @@ export const iterate_metadata_intersection =
         }
         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()}>`,

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

@@ -13,6 +13,7 @@ export const iterate_metadata_object =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
+    (errors: MetadataFactory.IError[]) =>
     (meta: Metadata, type: ts.Type, ensure: boolean = false): boolean => {
         if (ensure === false) {
             const filter = (flag: ts.TypeFlags) =>
@@ -37,7 +38,7 @@ export const iterate_metadata_object =
 
         const obj: MetadataObject = emplace_metadata_object(checker)(options)(
             collection,
-        )(type, meta.nullable);
+        )(errors)(type, meta.nullable);
         ArrayUtil.add(meta.objects, obj, (elem) => elem.name === obj.name);
         return true;
     };

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

@@ -10,21 +10,20 @@ import { MetadataFactory } from "../../MetadataFactory";
 import { TypeFactory } from "../../TypeFactory";
 import { iterate_metadata } from "./iterate_metadata";
 
-// import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
-
 export const iterate_metadata_resolve =
     (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 (options.escape === false || resolved === true) return false;
+        if (options.escape === false || explore.escaped === true) return false;
 
-        const escaped: ts.Type | null = TypeFactory.resolve(checker)(type);
+        const escaped: ts.Type | null =
+            TypeFactory.getReturnType(checker)(type)("toJSON");
         if (escaped === null) return false;
 
         if (meta.escaped === null) {
@@ -33,17 +32,21 @@ export const iterate_metadata_resolve =
                 returns: Metadata.initialize(),
             });
         }
-        iterate_metadata(checker)(options)(collection)(
+        iterate_metadata(checker)(options)(collection)(errors)(
             meta.escaped!.original,
             type,
-            true,
-            aliased,
+            {
+                ...explore,
+                escaped: true,
+            },
         );
-        iterate_metadata(checker)(options)(collection)(
+        iterate_metadata(checker)(options)(collection)(errors)(
             meta.escaped!.returns,
             escaped,
-            true,
-            aliased,
+            {
+                ...explore,
+                escaped: true,
+            },
         );
         return true;
     };

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

@@ -13,7 +13,12 @@ export const iterate_metadata_set =
     (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());
@@ -26,7 +31,11 @@ export const iterate_metadata_set =
         const key: ts.Type = generic[0]!;
         ArrayUtil.set(
             meta.sets,
-            explore_metadata(checker)(options)(collection)(key, false),
+            explore_metadata(checker)(options)(collection)(errors)(key, {
+                ...explore,
+                escaped: false,
+                aliased: false,
+            }),
             (elem) => elem.getName(),
         );
         return true;

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

@@ -11,7 +11,12 @@ export const iterate_metadata_template =
     (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 => {
         const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
         if (!filter(ts.TypeFlags.TemplateLiteral)) return false;
 
@@ -26,9 +31,13 @@ export const iterate_metadata_template =
             const binded: ts.Type | undefined = template.types[i];
             if (binded)
                 row.push(
-                    explore_metadata(checker)(options)(collection)(
+                    explore_metadata(checker)(options)(collection)(errors)(
                         binded,
-                        false,
+                        {
+                            ...explore,
+                            escaped: false,
+                            aliased: false,
+                        },
                     ),
                 );
         });

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

@@ -14,12 +14,17 @@ export const iterate_metadata_tuple =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.TupleType): boolean => {
+    (errors: MetadataFactory.IError[]) =>
+    (
+        meta: Metadata,
+        type: ts.TupleType,
+        explore: MetadataFactory.IExplore,
+    ): boolean => {
         if (!checker.isTupleType(type)) return false;
 
         const tupleType: MetadataTupleType = emplace_metadata_tuple(checker)(
             options,
-        )(collection)(type, meta.nullable);
+        )(collection)(errors)(type, meta.nullable, explore);
         ArrayUtil.add(
             meta.tuples,
             MetadataTuple.create({

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

@@ -10,15 +10,18 @@ export const iterate_metadata_union =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type, parentResolved: boolean): boolean => {
+    (errors: MetadataFactory.IError[]) =>
+    (
+        meta: Metadata,
+        type: ts.Type,
+        explore: MetadataFactory.IExplore,
+    ): boolean => {
         if (!type.isUnion()) return false;
         type.types.forEach((t) =>
-            iterate_metadata(checker)(options)(collection)(
-                meta,
-                t,
-                parentResolved,
-                false,
-            ),
+            iterate_metadata(checker)(options)(collection)(errors)(meta, t, {
+                ...explore,
+                aliased: false,
+            }),
         );
         return true;
     };

package/src/functional/Namespace.ts

@@ -9,14 +9,6 @@ import { $any } from "./$any";
 import { $every } from "./$every";
 import { $guard } from "./$guard";
 import { $is_between } from "./$is_between";
-import { $is_custom } from "./$is_custom";
-import { $is_date } from "./$is_date";
-import { $is_datetime } from "./$is_datetime";
-import { $is_email } from "./$is_email";
-import { $is_ipv4 } from "./$is_ipv4";
-import { $is_ipv6 } from "./$is_ipv6";
-import { $is_url } from "./$is_url";
-import { $is_uuid } from "./$is_uuid";
 import { $join } from "./$join";
 import { $number } from "./$number";
 import { $report } from "./$report";
@@ -30,15 +22,7 @@ import { $tail } from "./$tail";
  */
 export namespace Namespace {
     export const is = () => ({
-        is_uuid: $is_uuid,
-        is_email: $is_email,
-        is_url: $is_url,
-        is_ipv4: $is_ipv4,
-        is_ipv6: $is_ipv6,
         is_between: $is_between,
-        is_date: $is_date,
-        is_datetime: $is_datetime,
-        is_custom: $is_custom,
     });
 
     export const assert = (method: string) => ({