typia 4.3.2 → 4.3.3

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

@@ -1,133 +1,133 @@
-import { Metadata } from "../../../metadata/Metadata";
-import { MetadataArray } from "../../../metadata/MetadataArray";
-import { MetadataObject } from "../../../metadata/MetadataObject";
-import { MetadataTuple } from "../../../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.resolved !== null &&
-                isArrayRecursive(visited)(array)(meta.resolved.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.resolved !== null &&
-                isTupleRecursive(visited)(tuple)(meta.resolved.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.resolved !== null &&
-                isObjectRecursive(visited)(obj)(meta.resolved.returns)) ||
-            (meta.rest !== null && isObjectRecursive(visited)(obj)(meta.rest))
-        );
-    };
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataArray } from "../../../metadata/MetadataArray";
+import { MetadataObject } from "../../../metadata/MetadataObject";
+import { MetadataTuple } from "../../../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.resolved !== null &&
+                isArrayRecursive(visited)(array)(meta.resolved.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.resolved !== null &&
+                isTupleRecursive(visited)(tuple)(meta.resolved.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.resolved !== null &&
+                isObjectRecursive(visited)(obj)(meta.resolved.returns)) ||
+            (meta.rest !== null && isObjectRecursive(visited)(obj)(meta.rest))
+        );
+    };

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

@@ -1,58 +1,58 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../metadata/Metadata";
-import { MetadataConstant } from "../../../metadata/MetadataConstant";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { MetadataFactory } from "../../MetadataFactory";
-
-export const iterate_metadata_constant =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (meta: Metadata, type: ts.Type): boolean => {
-        if (!options.constant) return false;
-
-        const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
-        if (type.isLiteral()) {
-            const value: string | number | bigint =
-                typeof type.value === "object"
-                    ? BigInt(
-                          `${type.value.negative ? "-" : ""}${
-                              type.value.base10Value
-                          }`,
-                      )
-                    : type.value;
-            const constant: MetadataConstant = ArrayUtil.take(
-                meta.constants,
-                (elem) => elem.type === typeof value,
-                () => ({
-                    type: typeof value as "number",
-                    values: [],
-                }),
-            );
-            ArrayUtil.add(
-                constant.values as Array<any>,
-                value,
-                (a, b) => a === b,
-            );
-            return true;
-        } else if (filter(ts.TypeFlags.BooleanLiteral)) {
-            const value: boolean = checker.typeToString(type) === "true";
-            const constant: MetadataConstant = ArrayUtil.take(
-                meta.constants,
-                (elem) => elem.type === "boolean",
-                () => ({
-                    type: "boolean",
-                    values: [],
-                }),
-            );
-            ArrayUtil.add(
-                constant.values as boolean[],
-                value,
-                (a, b) => a === b,
-            );
-            return true;
-        }
-        return false;
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataConstant } from "../../../metadata/MetadataConstant";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataFactory } from "../../MetadataFactory";
+
+export const iterate_metadata_constant =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (meta: Metadata, type: ts.Type): boolean => {
+        if (!options.constant) return false;
+
+        const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+        if (type.isLiteral()) {
+            const value: string | number | bigint =
+                typeof type.value === "object"
+                    ? BigInt(
+                          `${type.value.negative ? "-" : ""}${
+                              type.value.base10Value
+                          }`,
+                      )
+                    : type.value;
+            const constant: MetadataConstant = ArrayUtil.take(
+                meta.constants,
+                (elem) => elem.type === typeof value,
+                () => ({
+                    type: typeof value as "number",
+                    values: [],
+                }),
+            );
+            ArrayUtil.add(
+                constant.values as Array<any>,
+                value,
+                (a, b) => a === b,
+            );
+            return true;
+        } else if (filter(ts.TypeFlags.BooleanLiteral)) {
+            const value: boolean = checker.typeToString(type) === "true";
+            const constant: MetadataConstant = ArrayUtil.take(
+                meta.constants,
+                (elem) => elem.type === "boolean",
+                () => ({
+                    type: "boolean",
+                    values: [],
+                }),
+            );
+            ArrayUtil.add(
+                constant.values as boolean[],
+                value,
+                (a, b) => a === b,
+            );
+            return true;
+        }
+        return false;
+    };

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

@@ -1,84 +1,88 @@
-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";
-
-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;
-        else if (
-            type.types.every(
-                (child) =>
-                    (child.getFlags() & ts.TypeFlags.Object) !== 0 &&
-                    !checker.isArrayType(child) &&
-                    !checker.isTupleType(child),
-            )
-        )
-            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;
-        }
-
-        // 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));
-        collection.entire_.add(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";
+
+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;
+        else if (
+            type.types.every(
+                (child) =>
+                    (child.getFlags() & ts.TypeFlags.Object) !== 0 &&
+                    !checker.isArrayType(child) &&
+                    !checker.isTupleType(child),
+            )
+        )
+            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;
+        } 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(),
+        );
+        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));
+        collection.entire_.add(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_map.ts

@@ -1,41 +1,41 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../metadata/Metadata";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { TypeFactory } from "../../TypeFactory";
-import { explore_metadata } from "./explore_metadata";
-
-export const iterate_metadata_map =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type): boolean => {
-        type = checker.getApparentType(type);
-
-        const name = TypeFactory.getFullName(checker)(type, type.getSymbol());
-        const generic = type.aliasSymbol
-            ? type.aliasTypeArguments
-            : checker.getTypeArguments(type as ts.TypeReference);
-        if (name.substring(0, 4) !== "Map<" || generic?.length !== 2)
-            return false;
-
-        const key: ts.Type = generic[0]!;
-        const value: ts.Type = generic[1]!;
-
-        ArrayUtil.set(
-            meta.maps,
-            {
-                key: explore_metadata(checker)(options)(collection)(key, false),
-                value: explore_metadata(checker)(options)(collection)(
-                    value,
-                    false,
-                ),
-            },
-            (elem) => `Map<${elem.key.getName()}, ${elem.value.getName()}>`,
-        );
-        return true;
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { TypeFactory } from "../../TypeFactory";
+import { explore_metadata } from "./explore_metadata";
+
+export const iterate_metadata_map =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (meta: Metadata, type: ts.Type): boolean => {
+        type = checker.getApparentType(type);
+
+        const name = TypeFactory.getFullName(checker)(type, type.getSymbol());
+        const generic = type.aliasSymbol
+            ? type.aliasTypeArguments
+            : checker.getTypeArguments(type as ts.TypeReference);
+        if (name.substring(0, 4) !== "Map<" || generic?.length !== 2)
+            return false;
+
+        const key: ts.Type = generic[0]!;
+        const value: ts.Type = generic[1]!;
+
+        ArrayUtil.set(
+            meta.maps,
+            {
+                key: explore_metadata(checker)(options)(collection)(key, false),
+                value: explore_metadata(checker)(options)(collection)(
+                    value,
+                    false,
+                ),
+            },
+            (elem) => `Map<${elem.key.getName()}, ${elem.value.getName()}>`,
+        );
+        return true;
+    };