typia 5.0.0-dev.2023084 → 5.0.0

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

@@ -7,14 +7,18 @@ import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
-import { MetadataTagFactory } from "../../MetadataTagFactory";
 import { explore_metadata } from "./explore_metadata";
 
 export const emplace_metadata_alias =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (type: ts.Type, nullable: boolean): MetadataAlias => {
+    (errors: MetadataFactory.IError[]) =>
+    (
+        type: ts.Type,
+        nullable: boolean,
+        explore: MetadataFactory.IExplore,
+    ): MetadataAlias => {
         // CHECK EXISTENCE
         const [alias, newbie, closure] = collection.emplaceAlias(
             checker,
@@ -26,15 +30,12 @@ export const emplace_metadata_alias =
 
         // CONSTRUCT VALUE TYPE
         const value: Metadata = explore_metadata(checker)(options)(collection)(
-            type,
-            false,
-            true,
-        );
+            errors,
+        )(type, {
+            ...explore,
+            escaped: false,
+            aliased: true,
+        });
         closure(value);
-        alias.tags.push(
-            ...MetadataTagFactory.generate(value)(alias.jsDocTags)(
-                () => alias.name,
-            ),
-        );
         return alias;
     };

package/src/factories/internal/metadata/{emplace_metadata_array.ts → emplace_metadata_array_type.ts}

@@ -1,7 +1,7 @@
 import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataArray } from "../../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
@@ -9,11 +9,16 @@ import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
 import { explore_metadata } from "./explore_metadata";
 
-export const emplace_metadata_array =
+export const emplace_metadata_array_type =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (type: ts.Type, nullable: boolean): MetadataArray => {
+    (errors: MetadataFactory.IError[]) =>
+    (
+        type: ts.Type,
+        nullable: boolean,
+        explore: MetadataFactory.IExplore,
+    ): MetadataArrayType => {
         // CHECK EXISTENCE
         const [array, newbie, setValue] = collection.emplaceArray(
             checker,
@@ -24,10 +29,12 @@ export const emplace_metadata_array =
 
         // CONSTRUCT VALUE TYPE
         const value: Metadata = explore_metadata(checker)(options)(collection)(
-            type.getNumberIndexType()!,
-            false,
-            false,
-        );
+            errors,
+        )(type.getNumberIndexType()!, {
+            ...explore,
+            escaped: false,
+            aliased: false,
+        });
         setValue(value);
 
         return array;

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

@@ -18,6 +18,7 @@ export const emplace_metadata_object =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
+    (errors: MetadataFactory.IError[]) =>
     (parent: ts.Type, nullable: boolean): MetadataObject => {
         // EMPLACE OBJECT
         const [obj, newbie] = collection.emplace(checker, parent);
@@ -61,7 +62,6 @@ export const emplace_metadata_object =
                     value,
                     description,
                     jsDocTags,
-                    tags: [],
                 });
                 obj.properties.push(property);
                 return property;
@@ -100,7 +100,14 @@ export const emplace_metadata_object =
             const key: Metadata = MetadataHelper.literal_to_metadata(prop.name);
             const value: Metadata = explore_metadata(checker)(options)(
                 collection,
-            )(type, false);
+            )(errors)(type, {
+                top: false,
+                object: obj,
+                property: prop.name,
+                nested: null,
+                escaped: false,
+                aliased: false,
+            });
 
             // OPTIONAL, BUT CAN BE RQUIRED BY `Required<T>` TYPE
             if (node?.questionToken) Writable(value).optional = true;
@@ -112,10 +119,17 @@ export const emplace_metadata_object =
         //----
         for (const index of checker.getIndexInfosOfType(parent)) {
             // GET EXACT TYPE
-            const analyzer = (type: ts.Type) =>
-                explore_metadata(checker)(options)(collection)(type, false);
-            const key: Metadata = analyzer(index.keyType);
-            const value: Metadata = analyzer(index.type);
+            const analyzer = (type: ts.Type) => (property: {} | null) =>
+                explore_metadata(checker)(options)(collection)(errors)(type, {
+                    top: false,
+                    object: obj,
+                    property,
+                    nested: null,
+                    escaped: false,
+                    aliased: false,
+                });
+            const key: Metadata = analyzer(index.keyType)(null);
+            const value: Metadata = analyzer(index.type)({});
 
             // INSERT WITH REQUIRED CONFIGURATION
             insert(key)(value)(

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

@@ -1,7 +1,7 @@
 import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataTuple } from "../../../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
 
 import { Writable } from "../../../typings/Writable";
 
@@ -15,7 +15,12 @@ export const emplace_metadata_tuple =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (type: ts.TupleType, nullable: boolean): MetadataTuple => {
+    (errors: MetadataFactory.IError[]) =>
+    (
+        type: ts.TupleType,
+        nullable: boolean,
+        explore: MetadataFactory.IExplore,
+    ): MetadataTupleType => {
         // CHECK EXISTENCE
         const [tuple, newbie, closure] = collection.emplaceTuple(checker, type);
         ArrayUtil.add(tuple.nullables, nullable);
@@ -31,7 +36,12 @@ export const emplace_metadata_tuple =
             .map((elem, i) => {
                 const child: Metadata = explore_metadata(checker)(options)(
                     collection,
-                )(elem, false, false);
+                )(errors)(elem, {
+                    ...explore,
+                    nested: tuple,
+                    aliased: false,
+                    escaped: false,
+                });
 
                 // CHECK OPTIONAL
                 const flag: ts.ElementFlags | undefined = flagList[i];

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

@@ -1,38 +1,32 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { emend_metadata_atomics } from "./emend_metadata_atomics";
-import { iterate_metadata } from "./iterate_metadata";
-
-export const explore_metadata =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (
-        type: ts.Type | null,
-        parentResolved: boolean,
-        aliased: boolean = false,
-    ): Metadata => {
-        // CONSTRUCT METADATA
-        const meta: Metadata = Metadata.initialize(parentResolved);
-        collection.entire_.add(meta);
-
-        if (type === null) return meta;
-
-        // ITERATE TYPESCRIPT TYPES
-        iterate_metadata(checker)(options)(collection)(
-            meta,
-            type,
-            parentResolved,
-            aliased,
-        );
-        emend_metadata_atomics(meta);
-        if (meta.escaped) {
-            emend_metadata_atomics(meta.escaped.original);
-            emend_metadata_atomics(meta.escaped.returns);
-        }
-        return meta;
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { emend_metadata_atomics } from "./emend_metadata_atomics";
+import { iterate_metadata } from "./iterate_metadata";
+
+export const explore_metadata =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (errors: MetadataFactory.IError[]) =>
+    (type: ts.Type | null, explore: MetadataFactory.IExplore): Metadata => {
+        // CONSTRUCT METADATA
+        const meta: Metadata = Metadata.initialize(explore.escaped);
+        if (type === null) return meta;
+
+        // ITERATE TYPESCRIPT TYPES
+        iterate_metadata(checker)(options)(collection)(errors)(
+            meta,
+            type,
+            explore,
+        );
+        emend_metadata_atomics(meta);
+        if (meta.escaped) {
+            emend_metadata_atomics(meta.escaped.original);
+            emend_metadata_atomics(meta.escaped.returns);
+        }
+        return meta;
+    };

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

@@ -2,9 +2,9 @@ import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
 
-// import { ArrayUtil } from "../../../utils/ArrayUtil";
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
+import { TypeFactory } from "../../TypeFactory";
 import { iterate_metadata_alias } from "./iterate_metadata_alias";
 import { iterate_metadata_array } from "./iterate_metadata_array";
 import { iterate_metadata_atomic } from "./iterate_metadata_atomic";
@@ -24,39 +24,42 @@ export const iterate_metadata =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
+    (errors: MetadataFactory.IError[]) =>
     (
         meta: Metadata,
         type: ts.Type,
-        resolved: boolean,
-        aliased: boolean,
+        explore: MetadataFactory.IExplore,
     ): void => {
-        if (type.isTypeParameter() === true)
-            throw new Error(
-                `Error on typia.MetadataFactory.generate(): non-specified generic argument on ${meta.getName()}.`,
-            );
+        if (type.isTypeParameter() === true) {
+            errors.push({
+                name: TypeFactory.getFullName(checker)(type),
+                explore: { ...explore },
+                messages: ["non-specified generic argument found."],
+            });
+            return;
+        }
         // CHECK SPECIAL CASES
-        if (
-            (aliased !== true &&
-                iterate_metadata_alias(checker)(options)(collection)(
+        else if (
+            (explore.aliased !== true &&
+                iterate_metadata_alias(checker)(options)(collection)(errors)(
                     meta,
                     type,
+                    explore,
                 )) ||
-            iterate_metadata_intersection(checker)(options)(collection)(
+            iterate_metadata_intersection(checker)(options)(collection)(errors)(
                 meta,
                 type,
-                resolved,
-                aliased,
+                explore,
             ) ||
-            iterate_metadata_union(checker)(options)(collection)(
+            iterate_metadata_union(checker)(options)(collection)(errors)(
                 meta,
                 type,
-                resolved,
+                explore,
             ) ||
-            iterate_metadata_resolve(checker)(options)(collection)(
+            iterate_metadata_resolve(checker)(options)(collection)(errors)(
                 meta,
                 type,
-                resolved,
-                aliased,
+                explore,
             )
         )
             return;
@@ -64,18 +67,35 @@ export const iterate_metadata =
         // ITERATE CASES
         iterate_metadata_coalesce(meta, type) ||
             iterate_metadata_constant(checker)(options)(meta, type) ||
-            iterate_metadata_template(checker)(options)(collection)(
+            iterate_metadata_template(checker)(options)(collection)(errors)(
                 meta,
                 type,
+                explore,
             ) ||
             iterate_metadata_atomic(meta, type) ||
-            iterate_metadata_tuple(checker)(options)(collection)(
+            iterate_metadata_tuple(checker)(options)(collection)(errors)(
                 meta,
                 type as ts.TupleType,
+                explore,
+            ) ||
+            iterate_metadata_array(checker)(options)(collection)(errors)(
+                meta,
+                type,
+                explore,
             ) ||
-            iterate_metadata_array(checker)(options)(collection)(meta, type) ||
             iterate_metadata_native(checker)(meta, type) ||
-            iterate_metadata_map(checker)(options)(collection)(meta, type) ||
-            iterate_metadata_set(checker)(options)(collection)(meta, type) ||
-            iterate_metadata_object(checker)(options)(collection)(meta, type);
+            iterate_metadata_map(checker)(options)(collection)(errors)(
+                meta,
+                type,
+                explore,
+            ) ||
+            iterate_metadata_set(checker)(options)(collection)(errors)(
+                meta,
+                type,
+                explore,
+            ) ||
+            iterate_metadata_object(checker)(options)(collection)(errors)(
+                meta,
+                type,
+            );
     };

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

@@ -2,23 +2,36 @@ import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
-import { emplace_metadata_array } from "./emplace_metadata_array";
+import { emplace_metadata_array_type } from "./emplace_metadata_array_type";
 
 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 array: MetadataArray = emplace_metadata_array(checker)(options)(
-            collection,
-        )(type, meta.nullable);
-        ArrayUtil.add(meta.arrays, array, (elem) => elem.name === array.name);
+        const arrayType: MetadataArrayType = emplace_metadata_array_type(
+            checker,
+        )(options)(collection)(errors)(type, meta.nullable, explore);
+        ArrayUtil.add(
+            meta.arrays,
+            MetadataArray.create({
+                type: arrayType,
+                tags: [],
+            }),
+            (elem) => elem.type.name === arrayType.name,
+        );
         return true;
     };

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

@@ -1,63 +1,62 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { Atomic } from "../../../typings/Atomic";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-const same = (type: ts.Type | null) => {
-    if (type === null) return () => false;
-    return (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
-};
-
-export const iterate_metadata_atomic = (
-    meta: Metadata,
-    type: ts.Type,
-): boolean => {
-    // PREPARE INTERNAL FUNCTIONS
-    const filter = same(type);
-    const check = (info: IAtomicInfo) => {
-        if (filter(info.atomic) || filter(info.literal)) {
-            ArrayUtil.add(
-                meta.atomics,
-                { type: info.name, tags: [] },
-                (x, y) => x.type === y.type,
-            );
-            return true;
-        }
-        return false;
-    };
-
-    // CHECK EACH TYPES
-    return ATOMICS.some((info) => check(info));
-};
-
-const ATOMICS: IAtomicInfo[] = [
-    {
-        name: "boolean",
-        atomic: ts.TypeFlags.BooleanLike,
-        literal: ts.TypeFlags.BooleanLiteral,
-    },
-    {
-        name: "number",
-        atomic: ts.TypeFlags.NumberLike,
-        literal: ts.TypeFlags.NumberLiteral,
-    },
-    {
-        name: "bigint",
-        atomic: ts.TypeFlags.BigInt,
-        literal: ts.TypeFlags.BigIntLiteral,
-    },
-    {
-        name: "string",
-        atomic: ts.TypeFlags.StringLike,
-        literal: ts.TypeFlags.StringLiteral,
-    },
-];
-
-interface IAtomicInfo {
-    name: Atomic.Literal;
-    atomic: ts.TypeFlags;
-    literal: ts.TypeFlags;
-}
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataAtomic } from "../../../schemas/metadata/MetadataAtomic";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+const same = (type: ts.Type | null) => {
+    if (type === null) return () => false;
+    return (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+};
+
+export const iterate_metadata_atomic = (
+    meta: Metadata,
+    type: ts.Type,
+): boolean => {
+    // PREPARE INTERNAL FUNCTIONS
+    const filter = same(type);
+    const check = (info: IAtomicInfo) => {
+        if (filter(info.atomic) || filter(info.literal)) {
+            ArrayUtil.add(
+                meta.atomics,
+                MetadataAtomic.create({ type: info.name, tags: [] }),
+                (x, y) => x.type === y.type,
+            );
+            return true;
+        }
+        return false;
+    };
+
+    // CHECK EACH TYPES
+    return ATOMICS.some((info) => check(info));
+};
+
+const ATOMICS: IAtomicInfo[] = [
+    {
+        name: "boolean",
+        atomic: ts.TypeFlags.BooleanLike,
+        literal: ts.TypeFlags.BooleanLiteral,
+    },
+    {
+        name: "number",
+        atomic: ts.TypeFlags.NumberLike,
+        literal: ts.TypeFlags.NumberLiteral,
+    },
+    {
+        name: "bigint",
+        atomic: ts.TypeFlags.BigInt,
+        literal: ts.TypeFlags.BigIntLiteral,
+    },
+    {
+        name: "string",
+        atomic: ts.TypeFlags.StringLike,
+        literal: ts.TypeFlags.StringLiteral,
+    },
+];
+
+interface IAtomicInfo {
+    name: "boolean" | "number" | "bigint" | "string";
+    atomic: ts.TypeFlags;
+    literal: ts.TypeFlags;
+}