typia 5.0.0-dev.20230821 → 5.0.0-dev.20230822

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

@@ -1,50 +1,50 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataTuple } from "../../../schemas/metadata/MetadataTuple";
-
-import { Writable } from "../../../typings/Writable";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { explore_metadata } from "./explore_metadata";
-
-export const emplace_metadata_tuple =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (type: ts.TupleType, nullable: boolean): MetadataTuple => {
-        // CHECK EXISTENCE
-        const [tuple, newbie, closure] = collection.emplaceTuple(checker, type);
-        ArrayUtil.add(tuple.nullables, nullable);
-        if (newbie === false) return tuple;
-
-        // CONSTRUCT ELEMENT TYPES
-        const flagList: readonly ts.ElementFlags[] =
-            type.elementFlags ??
-            (type.target as ts.TupleType)?.elementFlags ??
-            [];
-        const elements: Metadata[] = checker
-            .getTypeArguments(type as ts.TypeReference)
-            .map((elem, i) => {
-                const child: Metadata = explore_metadata(checker)(options)(
-                    collection,
-                )(elem, false, false);
-
-                // CHECK OPTIONAL
-                const flag: ts.ElementFlags | undefined = flagList[i];
-                if (flag === ts.ElementFlags.Optional)
-                    Writable(child).optional = true;
-
-                // REST TYPE
-                if (flag !== ts.ElementFlags.Rest) return child;
-                const wrapper: Metadata = Metadata.initialize();
-                Writable(wrapper).rest = child;
-                return wrapper;
-            });
-        closure(elements);
-
-        return tuple;
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataTuple } from "../../../schemas/metadata/MetadataTuple";
+
+import { Writable } from "../../../typings/Writable";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { explore_metadata } from "./explore_metadata";
+
+export const emplace_metadata_tuple =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (type: ts.TupleType, nullable: boolean): MetadataTuple => {
+        // CHECK EXISTENCE
+        const [tuple, newbie, closure] = collection.emplaceTuple(checker, type);
+        ArrayUtil.add(tuple.nullables, nullable);
+        if (newbie === false) return tuple;
+
+        // CONSTRUCT ELEMENT TYPES
+        const flagList: readonly ts.ElementFlags[] =
+            type.elementFlags ??
+            (type.target as ts.TupleType)?.elementFlags ??
+            [];
+        const elements: Metadata[] = checker
+            .getTypeArguments(type as ts.TypeReference)
+            .map((elem, i) => {
+                const child: Metadata = explore_metadata(checker)(options)(
+                    collection,
+                )(elem, false, false);
+
+                // CHECK OPTIONAL
+                const flag: ts.ElementFlags | undefined = flagList[i];
+                if (flag === ts.ElementFlags.Optional)
+                    Writable(child).optional = true;
+
+                // REST TYPE
+                if (flag !== ts.ElementFlags.Rest) return child;
+                const wrapper: Metadata = Metadata.initialize();
+                Writable(wrapper).rest = child;
+                return wrapper;
+            });
+        closure(elements);
+
+        return tuple;
+    };

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.resolved) {
+            emend_metadata_atomics(meta.resolved.original);
+            emend_metadata_atomics(meta.resolved.returns);
+        }
+        return meta;
+    };

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

@@ -1,81 +1,81 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/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);
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/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);
+    };

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

@@ -1,30 +1,30 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataAlias } from "../../../schemas/metadata/MetadataAlias";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { emplace_metadata_alias } from "./emplace_metadata_alias";
-
-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_alias(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 "../../../schemas/metadata/Metadata";
+import { MetadataAlias } from "../../../schemas/metadata/MetadataAlias";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { emplace_metadata_alias } from "./emplace_metadata_alias";
+
+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_alias(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_array.ts

@@ -1,24 +1,24 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataArray } from "../../../schemas/metadata/MetadataArray";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { emplace_metadata_array } from "./emplace_metadata_array";
-
-export const iterate_metadata_array =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type): 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);
-        return true;
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataArray } from "../../../schemas/metadata/MetadataArray";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { emplace_metadata_array } from "./emplace_metadata_array";
+
+export const iterate_metadata_array =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (meta: Metadata, type: ts.Type): 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);
+        return true;
+    };

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

@@ -1,59 +1,59 @@
-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, 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;
+}

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

@@ -1,33 +1,33 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { Writable } from "../../../typings/Writable";
-
-import { TypeFactory } from "../../TypeFactory";
-
-export const iterate_metadata_coalesce = (
-    meta: Metadata,
-    type: ts.Type,
-): boolean => {
-    const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
-    if (filter(ts.TypeFlags.Unknown) || filter(ts.TypeFlags.Any)) {
-        Writable(meta).any = true;
-        return true;
-    } else if (filter(ts.TypeFlags.Null)) {
-        Writable(meta).nullable = true;
-        return true;
-    } else if (
-        filter(ts.TypeFlags.Undefined) ||
-        filter(ts.TypeFlags.Never) ||
-        filter(ts.TypeFlags.Void) ||
-        filter(ts.TypeFlags.VoidLike)
-    ) {
-        Writable(meta).required = false;
-        return true;
-    } else if (TypeFactory.isFunction(type) === true) {
-        Writable(meta).functional = true;
-        return true;
-    }
-    return false;
-};
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { Writable } from "../../../typings/Writable";
+
+import { TypeFactory } from "../../TypeFactory";
+
+export const iterate_metadata_coalesce = (
+    meta: Metadata,
+    type: ts.Type,
+): boolean => {
+    const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+    if (filter(ts.TypeFlags.Unknown) || filter(ts.TypeFlags.Any)) {
+        Writable(meta).any = true;
+        return true;
+    } else if (filter(ts.TypeFlags.Null)) {
+        Writable(meta).nullable = true;
+        return true;
+    } else if (
+        filter(ts.TypeFlags.Undefined) ||
+        filter(ts.TypeFlags.Never) ||
+        filter(ts.TypeFlags.Void) ||
+        filter(ts.TypeFlags.VoidLike)
+    ) {
+        Writable(meta).required = false;
+        return true;
+    } else if (TypeFactory.isFunction(type) === true) {
+        Writable(meta).functional = true;
+        return true;
+    }
+    return false;
+};