typia 4.0.0-dev.20230520 → 4.0.0-dev.20230527

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

@@ -1,32 +1,32 @@
-import type ts from "typescript/lib/tsclibrary";
-
-import { Metadata } from "../../../metadata/Metadata";
-
-import { IProject } from "../../../transformers/IProject";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { explore_metadata } from "./explore_metadata";
-
-export const iterate_metadata_array =
-    ({ tsc, checker }: IProject.IModule) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (meta: Metadata) =>
-    (type: ts.Type): boolean => {
-        if (!checker.isArrayType(type) && !checker.isArrayLikeType(type))
-            return false;
-
-        const value: ts.Type | null =
-            checker.getIndexTypeOfType(type, tsc.IndexKind.Number) ?? null;
-        ArrayUtil.set(
-            meta.arrays,
-            explore_metadata({ tsc, checker })(options)(collection)(false)(
-                value,
-            ),
-            (elem) => elem.getName(),
-        );
-        return true;
-    };
+import type ts from "typescript/lib/tsclibrary";
+
+import { Metadata } from "../../../metadata/Metadata";
+
+import { IProject } from "../../../transformers/IProject";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { explore_metadata } from "./explore_metadata";
+
+export const iterate_metadata_array =
+    ({ tsc, checker }: IProject.IModule) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (meta: Metadata) =>
+    (type: ts.Type): boolean => {
+        if (!checker.isArrayType(type) && !checker.isArrayLikeType(type))
+            return false;
+
+        const value: ts.Type | null =
+            checker.getIndexTypeOfType(type, tsc.IndexKind.Number) ?? null;
+        ArrayUtil.set(
+            meta.arrays,
+            explore_metadata({ tsc, checker })(options)(collection)(false)(
+                value,
+            ),
+            (elem) => elem.getName(),
+        );
+        return true;
+    };

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

@@ -1,59 +1,59 @@
-import type ts from "typescript/lib/tsclibrary";
-
-import { Metadata } from "../../../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.flags & flag) !== 0;
-};
-
-export const iterate_metadata_atomic =
-    (tsc: typeof ts) =>
-    (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(tsc).some((info) => check(info));
-    };
-
-const ATOMICS = (tsc: typeof ts): IAtomicInfo[] => [
-    {
-        name: "boolean",
-        atomic: tsc.TypeFlags.BooleanLike,
-        literal: tsc.TypeFlags.BooleanLiteral,
-    },
-    {
-        name: "number",
-        atomic: tsc.TypeFlags.NumberLike,
-        literal: tsc.TypeFlags.NumberLiteral,
-    },
-    {
-        name: "bigint",
-        atomic: tsc.TypeFlags.BigInt,
-        literal: tsc.TypeFlags.BigIntLiteral,
-    },
-    {
-        name: "string",
-        atomic: tsc.TypeFlags.StringLike,
-        literal: tsc.TypeFlags.StringLiteral,
-    },
-];
-
-interface IAtomicInfo {
-    name: Atomic.Literal;
-    atomic: ts.TypeFlags;
-    literal: ts.TypeFlags;
-}
+import type ts from "typescript/lib/tsclibrary";
+
+import { Metadata } from "../../../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.flags & flag) !== 0;
+};
+
+export const iterate_metadata_atomic =
+    (tsc: typeof ts) =>
+    (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(tsc).some((info) => check(info));
+    };
+
+const ATOMICS = (tsc: typeof ts): IAtomicInfo[] => [
+    {
+        name: "boolean",
+        atomic: tsc.TypeFlags.BooleanLike,
+        literal: tsc.TypeFlags.BooleanLiteral,
+    },
+    {
+        name: "number",
+        atomic: tsc.TypeFlags.NumberLike,
+        literal: tsc.TypeFlags.NumberLiteral,
+    },
+    {
+        name: "bigint",
+        atomic: tsc.TypeFlags.BigInt,
+        literal: tsc.TypeFlags.BigIntLiteral,
+    },
+    {
+        name: "string",
+        atomic: tsc.TypeFlags.StringLike,
+        literal: tsc.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 type ts from "typescript/lib/tsclibrary";
-
-import { Metadata } from "../../../metadata/Metadata";
-
-import { Writable } from "../../../typings/Writable";
-
-import { TypeFactory } from "../../TypeFactory";
-
-export const iterate_metadata_coalesce =
-    (tsc: typeof ts) =>
-    (meta: Metadata) =>
-    (type: ts.Type): boolean => {
-        const filter = (flag: ts.TypeFlags) => (type.flags & flag) !== 0;
-        if (filter(tsc.TypeFlags.Unknown) || filter(tsc.TypeFlags.Any)) {
-            Writable(meta).any = true;
-            return true;
-        } else if (filter(tsc.TypeFlags.Null)) {
-            Writable(meta).nullable = true;
-            return true;
-        } else if (
-            filter(tsc.TypeFlags.Undefined) ||
-            filter(tsc.TypeFlags.Never) ||
-            filter(tsc.TypeFlags.Void) ||
-            filter(tsc.TypeFlags.VoidLike)
-        ) {
-            Writable(meta).required = false;
-            return true;
-        } else if (TypeFactory.isFunction(tsc)(type) === true) {
-            Writable(meta).functional = true;
-            return true;
-        }
-        return false;
-    };
+import type ts from "typescript/lib/tsclibrary";
+
+import { Metadata } from "../../../metadata/Metadata";
+
+import { Writable } from "../../../typings/Writable";
+
+import { TypeFactory } from "../../TypeFactory";
+
+export const iterate_metadata_coalesce =
+    (tsc: typeof ts) =>
+    (meta: Metadata) =>
+    (type: ts.Type): boolean => {
+        const filter = (flag: ts.TypeFlags) => (type.flags & flag) !== 0;
+        if (filter(tsc.TypeFlags.Unknown) || filter(tsc.TypeFlags.Any)) {
+            Writable(meta).any = true;
+            return true;
+        } else if (filter(tsc.TypeFlags.Null)) {
+            Writable(meta).nullable = true;
+            return true;
+        } else if (
+            filter(tsc.TypeFlags.Undefined) ||
+            filter(tsc.TypeFlags.Never) ||
+            filter(tsc.TypeFlags.Void) ||
+            filter(tsc.TypeFlags.VoidLike)
+        ) {
+            Writable(meta).required = false;
+            return true;
+        } else if (TypeFactory.isFunction(tsc)(type) === true) {
+            Writable(meta).functional = true;
+            return true;
+        }
+        return false;
+    };

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

@@ -1,62 +1,62 @@
-import type ts from "typescript/lib/tsclibrary";
-
-import { Metadata } from "../../../metadata/Metadata";
-import { MetadataConstant } from "../../../metadata/MetadataConstant";
-
-import { IProject } from "../../../transformers/IProject";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-import { TsTypeUtil } from "../../../utils/TsTypeUtil";
-
-import { MetadataFactory } from "../../MetadataFactory";
-
-export const iterate_metadata_constant =
-    ({ tsc, checker }: IProject.IModule) =>
-    (options: MetadataFactory.IOptions) =>
-    (meta: Metadata) =>
-    (type: ts.Type): boolean => {
-        if (!options.constant) return false;
-
-        const filter = (flag: ts.TypeFlags) => (type.flags & flag) !== 0;
-        if (TsTypeUtil.isLiteral(tsc)(type)) {
-            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(tsc.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 type ts from "typescript/lib/tsclibrary";
+
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataConstant } from "../../../metadata/MetadataConstant";
+
+import { IProject } from "../../../transformers/IProject";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+import { TsTypeUtil } from "../../../utils/TsTypeUtil";
+
+import { MetadataFactory } from "../../MetadataFactory";
+
+export const iterate_metadata_constant =
+    ({ tsc, checker }: IProject.IModule) =>
+    (options: MetadataFactory.IOptions) =>
+    (meta: Metadata) =>
+    (type: ts.Type): boolean => {
+        if (!options.constant) return false;
+
+        const filter = (flag: ts.TypeFlags) => (type.flags & flag) !== 0;
+        if (TsTypeUtil.isLiteral(tsc)(type)) {
+            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(tsc.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_map.ts

@@ -1,41 +1,41 @@
-import type ts from "typescript/lib/tsclibrary";
-
-import { Metadata } from "../../../metadata/Metadata";
-
-import { IProject } from "../../../transformers/IProject";
-
-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 =
-    (p: IProject.IModule) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (meta: Metadata) =>
-    (type: ts.Type): boolean => {
-        type = p.checker.getApparentType(type);
-
-        const name = TypeFactory.getFullName(p)(type, type.symbol);
-        const generic = type.aliasSymbol
-            ? type.aliasTypeArguments
-            : p.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(p)(options)(collection)(false)(key),
-                value: explore_metadata(p)(options)(collection)(false)(value),
-            },
-            (elem) => `Map<${elem.key.getName()}, ${elem.value.getName()}>`,
-        );
-        return true;
-    };
+import type ts from "typescript/lib/tsclibrary";
+
+import { Metadata } from "../../../metadata/Metadata";
+
+import { IProject } from "../../../transformers/IProject";
+
+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 =
+    (p: IProject.IModule) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (meta: Metadata) =>
+    (type: ts.Type): boolean => {
+        type = p.checker.getApparentType(type);
+
+        const name = TypeFactory.getFullName(p)(type, type.symbol);
+        const generic = type.aliasSymbol
+            ? type.aliasTypeArguments
+            : p.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(p)(options)(collection)(false)(key),
+                value: explore_metadata(p)(options)(collection)(false)(value),
+            },
+            (elem) => `Map<${elem.key.getName()}, ${elem.value.getName()}>`,
+        );
+        return true;
+    };