typia 4.0.10-dev.20230615 → 4.0.10-dev.20230616

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

@@ -1,37 +1,40 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../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);
-        const out = (meta: Metadata) => {
-            if (options.validate) options.validate(meta);
-            return meta;
-        };
-        if (type === null) return out(meta);
-
-        // ITERATE TYPESCRIPT TYPES
-        iterate_metadata(checker)(options)(collection)(
-            meta,
-            type,
-            parentResolved,
-            aliased,
-        );
-        emend_metadata_atomics(meta);
-        if (meta.resolved) emend_metadata_atomics(meta.resolved);
-        return out(meta);
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../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);
+        const out = (meta: Metadata) => {
+            if (options.validate) options.validate(meta);
+            return meta;
+        };
+        if (type === null) return out(meta);
+
+        // ITERATE TYPESCRIPT TYPES
+        iterate_metadata(checker)(options)(collection)(
+            meta,
+            type,
+            parentResolved,
+            aliased,
+        );
+        emend_metadata_atomics(meta);
+        if (meta.resolved) {
+            emend_metadata_atomics(meta.resolved.original);
+            emend_metadata_atomics(meta.resolved.returns);
+        }
+        return out(meta);
+    };

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

@@ -1,85 +1,85 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../metadata/Metadata";
-
-// import { ArrayUtil } from "../../../utils/ArrayUtil";
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { iterate_metadata_alias } from "./iterate_metadata_alias";
-import { iterate_metadata_array } from "./iterate_metadata_array";
-import { iterate_metadata_atomic } from "./iterate_metadata_atomic";
-import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
-import { iterate_metadata_constant } from "./iterate_metadata_constant";
-import { iterate_metadata_intersection } from "./iterate_metadata_intersection";
-import { iterate_metadata_map } from "./iterate_metadata_map";
-import { iterate_metadata_native } from "./iterate_metadata_native";
-import { iterate_metadata_object } from "./iterate_metadata_object";
-import { iterate_metadata_resolve } from "./iterate_metadata_resolve";
-import { iterate_metadata_set } from "./iterate_metadata_set";
-import { iterate_metadata_template } from "./iterate_metadata_template";
-import { iterate_metadata_tuple } from "./iterate_metadata_tuple";
-import { iterate_metadata_union } from "./iterate_metadata_union";
-
-export const iterate_metadata =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (
-        meta: Metadata,
-        type: ts.Type,
-        resolved: boolean,
-        aliased: boolean,
-    ): void => {
-        if (type.isTypeParameter() === true)
-            throw new Error(
-                `Error on typia.MetadataFactory.generate(): non-specified generic argument on ${meta.getName()}.`,
-            );
-        // CHECK SPECIAL CASES
-        if (
-            (aliased !== true &&
-                iterate_metadata_alias(checker)(options)(collection)(
-                    meta,
-                    type,
-                )) ||
-            iterate_metadata_intersection(checker)(options)(collection)(
-                meta,
-                type,
-                resolved,
-                aliased,
-            ) ||
-            iterate_metadata_union(checker)(options)(collection)(
-                meta,
-                type,
-                resolved,
-            ) ||
-            iterate_metadata_resolve(checker)(options)(collection)(
-                meta,
-                type,
-                resolved,
-                aliased,
-            )
-        )
-            return;
-
-        // ITERATE CASES
-        iterate_metadata_coalesce(meta, type) ||
-            iterate_metadata_constant(checker)(options)(meta, type) ||
-            iterate_metadata_template(checker)(options)(collection)(
-                meta,
-                type,
-            ) ||
-            iterate_metadata_atomic(meta, type) ||
-            iterate_metadata_tuple(checker)(options)(collection)(
-                meta,
-                type as ts.TupleType,
-            ) ||
-            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,
-                resolved,
-            );
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+
+// import { ArrayUtil } from "../../../utils/ArrayUtil";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { iterate_metadata_alias } from "./iterate_metadata_alias";
+import { iterate_metadata_array } from "./iterate_metadata_array";
+import { iterate_metadata_atomic } from "./iterate_metadata_atomic";
+import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
+import { iterate_metadata_constant } from "./iterate_metadata_constant";
+import { iterate_metadata_intersection } from "./iterate_metadata_intersection";
+import { iterate_metadata_map } from "./iterate_metadata_map";
+import { iterate_metadata_native } from "./iterate_metadata_native";
+import { iterate_metadata_object } from "./iterate_metadata_object";
+import { iterate_metadata_resolve } from "./iterate_metadata_resolve";
+import { iterate_metadata_set } from "./iterate_metadata_set";
+import { iterate_metadata_template } from "./iterate_metadata_template";
+import { iterate_metadata_tuple } from "./iterate_metadata_tuple";
+import { iterate_metadata_union } from "./iterate_metadata_union";
+
+export const iterate_metadata =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (
+        meta: Metadata,
+        type: ts.Type,
+        resolved: boolean,
+        aliased: boolean,
+    ): void => {
+        if (type.isTypeParameter() === true)
+            throw new Error(
+                `Error on typia.MetadataFactory.generate(): non-specified generic argument on ${meta.getName()}.`,
+            );
+        // CHECK SPECIAL CASES
+        if (
+            (aliased !== true &&
+                iterate_metadata_alias(checker)(options)(collection)(
+                    meta,
+                    type,
+                )) ||
+            iterate_metadata_intersection(checker)(options)(collection)(
+                meta,
+                type,
+                resolved,
+                aliased,
+            ) ||
+            iterate_metadata_union(checker)(options)(collection)(
+                meta,
+                type,
+                resolved,
+            ) ||
+            iterate_metadata_resolve(checker)(options)(collection)(
+                meta,
+                type,
+                resolved,
+                aliased,
+            )
+        )
+            return;
+
+        // ITERATE CASES
+        iterate_metadata_coalesce(meta, type) ||
+            iterate_metadata_constant(checker)(options)(meta, type) ||
+            iterate_metadata_template(checker)(options)(collection)(
+                meta,
+                type,
+            ) ||
+            iterate_metadata_atomic(meta, type) ||
+            iterate_metadata_tuple(checker)(options)(collection)(
+                meta,
+                type as ts.TupleType,
+            ) ||
+            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,
+                resolved,
+            );
+    };

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

@@ -1,30 +1,30 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../metadata/Metadata";
-import { MetadataAlias } from "../../../metadata/MetadataAlias";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { emplace_metadata_definition } from "./emplace_metadata_definition";
-
-export const iterate_metadata_alias =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type): boolean => {
-        if (options.absorb !== false || type.aliasSymbol === undefined)
-            return false;
-
-        const node: ts.Declaration | undefined =
-            type.aliasSymbol.declarations?.[0];
-        if (node === undefined) return false;
-
-        // CONSTRUCT DEFINITION
-        const alias: MetadataAlias = emplace_metadata_definition(checker)(
-            options,
-        )(collection)(type, meta.nullable);
-        ArrayUtil.add(meta.aliases, alias, (elem) => elem.name === alias.name);
-        return true;
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataAlias } from "../../../metadata/MetadataAlias";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { emplace_metadata_definition } from "./emplace_metadata_definition";
+
+export const iterate_metadata_alias =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (meta: Metadata, type: ts.Type): boolean => {
+        if (options.absorb !== false || type.aliasSymbol === undefined)
+            return false;
+
+        const node: ts.Declaration | undefined =
+            type.aliasSymbol.declarations?.[0];
+        if (node === undefined) return false;
+
+        // CONSTRUCT DEFINITION
+        const alias: MetadataAlias = emplace_metadata_definition(checker)(
+            options,
+        )(collection)(type, meta.nullable);
+        ArrayUtil.add(meta.aliases, alias, (elem) => elem.name === alias.name);
+        return true;
+    };

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

@@ -56,7 +56,7 @@ const isArrayRecursive =
             meta.maps.some((m) => isArrayRecursive(visited)(array)(m.value)) ||
             meta.sets.some((s) => isArrayRecursive(visited)(array)(s)) ||
             (meta.resolved !== null &&
-                isArrayRecursive(visited)(array)(meta.resolved)) ||
+                isArrayRecursive(visited)(array)(meta.resolved.returns)) ||
             (meta.rest !== null && isArrayRecursive(visited)(array)(meta.rest))
         );
     };
@@ -84,7 +84,7 @@ const isTupleRecursive =
                 isTupleRecursive(visited)(tuple)(d.value),
             ) ||
             (meta.resolved !== null &&
-                isTupleRecursive(visited)(tuple)(meta.resolved)) ||
+                isTupleRecursive(visited)(tuple)(meta.resolved.returns)) ||
             (meta.rest !== null && isTupleRecursive(visited)(tuple)(meta.rest))
         );
     };
@@ -124,7 +124,7 @@ const isObjectRecursive =
             ) ||
             meta.sets.some((value) => isObjectRecursive(visited)(obj)(value)) ||
             (meta.resolved !== null &&
-                isObjectRecursive(visited)(obj)(meta.resolved)) ||
+                isObjectRecursive(visited)(obj)(meta.resolved.returns)) ||
             (meta.rest !== null && isObjectRecursive(visited)(obj)(meta.rest))
         );
     };

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

@@ -1,87 +1,87 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../metadata/Metadata";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { explore_metadata } from "./explore_metadata";
-import { iterate_metadata } from "./iterate_metadata";
-import { iterate_metadata_object } from "./iterate_metadata_object";
-
-export const iterate_metadata_intersection =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (
-        meta: Metadata,
-        type: ts.Type,
-        resolved: boolean,
-        aliased: boolean,
-    ): boolean => {
-        if (!type.isIntersection()) return false;
-
-        // COSTRUCT FAKE METADATA LIST
-        const fakeCollection: MetadataCollection = new MetadataCollection();
-        const children: Metadata[] = [
-            ...new Map(
-                type.types.map((t) => {
-                    const m: Metadata = explore_metadata(checker)({
-                        ...options,
-                        absorb: true,
-                    })(fakeCollection)(t, resolved);
-                    return [m.getName(), m] as const;
-                }),
-            ).values(),
-        ];
-
-        // ONLY ONE CHILD AFTER REMOVING DUPLICATES
-        if (children.length === 1) {
-            iterate_metadata(checker)(options)(collection)(
-                meta,
-                type.types[0]!,
-                resolved,
-                aliased,
-            );
-            return true;
-        }
-
-        // ONLY OBJECT TYPES -> MERGE
-        const object: boolean = children.every(
-            (c) => c.objects.length && c.objects.length === c.size(),
-        );
-        if (object)
-            return iterate_metadata_object(checker)(options)(collection)(
-                meta,
-                type,
-                resolved,
-                true,
-            );
-
-        // ABSORB TO ATOMIC (OR CONSTANT) TYPE
-        const atomics: Metadata[] = children.filter(
-            (c) =>
-                (c.atomics.length ? 1 : 0 + c.constants.length ? 1 : 0) ===
-                c.bucket(),
-        );
-        const objects: Metadata[] = children.filter(
-            (c) => c.objects.length && c.objects.length === c.size(),
-        );
-        if (
-            atomics.length === 0 ||
-            atomics.length + objects.length !== children.length
-        )
-            throw new Error(message(children));
-
-        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));
-        return true;
-    };
-
-const message = (children: Metadata[]) =>
-    `Error on typia.MetadataFactory.analyze(): nonsensible intersection type detected - ${children
-        .map((c) => c.getName())
-        .join(" & ")}.`;
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { explore_metadata } from "./explore_metadata";
+import { iterate_metadata } from "./iterate_metadata";
+import { iterate_metadata_object } from "./iterate_metadata_object";
+
+export const iterate_metadata_intersection =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (
+        meta: Metadata,
+        type: ts.Type,
+        resolved: boolean,
+        aliased: boolean,
+    ): boolean => {
+        if (!type.isIntersection()) return false;
+
+        // COSTRUCT FAKE METADATA LIST
+        const fakeCollection: MetadataCollection = new MetadataCollection();
+        const children: Metadata[] = [
+            ...new Map(
+                type.types.map((t) => {
+                    const m: Metadata = explore_metadata(checker)({
+                        ...options,
+                        absorb: true,
+                    })(fakeCollection)(t, resolved);
+                    return [m.getName(), m] as const;
+                }),
+            ).values(),
+        ];
+
+        // ONLY ONE CHILD AFTER REMOVING DUPLICATES
+        if (children.length === 1) {
+            iterate_metadata(checker)(options)(collection)(
+                meta,
+                type.types[0]!,
+                resolved,
+                aliased,
+            );
+            return true;
+        }
+
+        // ONLY OBJECT TYPES -> MERGE
+        const object: boolean = children.every(
+            (c) => c.objects.length && c.objects.length === c.size(),
+        );
+        if (object)
+            return iterate_metadata_object(checker)(options)(collection)(
+                meta,
+                type,
+                resolved,
+                true,
+            );
+
+        // ABSORB TO ATOMIC (OR CONSTANT) TYPE
+        const atomics: Metadata[] = children.filter(
+            (c) =>
+                (c.atomics.length ? 1 : 0 + c.constants.length ? 1 : 0) ===
+                c.bucket(),
+        );
+        const objects: Metadata[] = children.filter(
+            (c) => c.objects.length && c.objects.length === c.size(),
+        );
+        if (
+            atomics.length === 0 ||
+            atomics.length + objects.length !== children.length
+        )
+            throw new Error(message(children));
+
+        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));
+        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_resolve.ts

@@ -1,38 +1,49 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../metadata/Metadata";
-
-import { Writable } from "../../../typings/Writable";
-
-import { MetadataCollection } from "../../MetadataCollection";
-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) =>
-    (
-        meta: Metadata,
-        type: ts.Type,
-        resolved: boolean,
-        aliased: boolean,
-    ): boolean => {
-        if (options.resolve === false || resolved === true) return false;
-
-        const escaped: ts.Type | null = TypeFactory.resolve(checker)(type);
-        if (escaped === null) return false;
-
-        if (meta.resolved === null)
-            Writable(meta).resolved = Metadata.initialize();
-        iterate_metadata(checker)(options)(collection)(
-            meta.resolved!,
-            escaped,
-            true,
-            aliased,
-        );
-        return true;
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataResolved } from "../../../metadata/MetadataResolved";
+
+import { Writable } from "../../../typings/Writable";
+
+import { MetadataCollection } from "../../MetadataCollection";
+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) =>
+    (
+        meta: Metadata,
+        type: ts.Type,
+        resolved: boolean,
+        aliased: boolean,
+    ): boolean => {
+        if (options.resolve === false || resolved === true) return false;
+
+        const escaped: ts.Type | null = TypeFactory.resolve(checker)(type);
+        if (escaped === null) return false;
+
+        if (meta.resolved === null) {
+            Writable(meta).resolved = MetadataResolved.create({
+                original: Metadata.initialize(),
+                returns: Metadata.initialize(),
+            });
+        }
+        iterate_metadata(checker)(options)(collection)(
+            meta.resolved!.original,
+            type,
+            true,
+            aliased,
+        );
+        iterate_metadata(checker)(options)(collection)(
+            meta.resolved!.returns,
+            escaped,
+            true,
+            aliased,
+        );
+        return true;
+    };

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

@@ -27,7 +27,8 @@ const iterate =
         // ITERATE CHILDREN
         for (const map of meta.maps) iterate(visited)(collection)(map.value);
         for (const set of meta.sets) iterate(visited)(collection)(set);
-        if (meta.resolved !== null) iterate(visited)(collection)(meta.resolved);
+        if (meta.resolved !== null)
+            iterate(visited)(collection)(meta.resolved.returns);
         if (meta.rest !== null) iterate(visited)(collection)(meta.rest);
 
         // SORT OBJECTS