typia 5.0.0-dev.20230823 → 5.0.0-dev.2023084

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

@@ -1,38 +1,38 @@
-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.resolved) {
-            emend_metadata_atomics(meta.resolved.original);
-            emend_metadata_atomics(meta.resolved.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) =>
+    (
+        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;
+    };

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

@@ -1,59 +1,63 @@
-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, info.name);
-            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 { 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;
+}

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

@@ -1,133 +1,133 @@
-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.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 "../../../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))
+        );
+    };