typia 3.4.13 → 3.4.14

package/src/factories/internal/iterate_metadata_native.ts

@@ -1,227 +1,227 @@
-import ts from "typescript";
-
-import { Metadata } from "../../metadata/Metadata";
-
-import { ArrayUtil } from "../../utils/ArrayUtil";
-
-import { TypeFactory } from "../TypeFactory";
-
-export const iterate_metadata_native =
-    (checker: ts.TypeChecker) =>
-    (meta: Metadata, type: ts.Type): boolean => {
-        const validator = validate(checker)(type);
-        const name: string = TypeFactory.getFullName(
-            checker,
-            type,
-            type.getSymbol(),
-        );
-
-        const simple = SIMPLES.get(name);
-        if (simple && validator(simple)) {
-            if (FORBIDDEN.has(name))
-                throw new Error(
-                    `Error on typia.metadata(): typia does not allow "${name}" class type. Use "${name.toLowerCase()}" type instead.`,
-                );
-            ArrayUtil.set(meta.natives, name, (str) => str);
-            return true;
-        }
-
-        const complicate = COMPLICATES.get(name);
-        if (complicate && validator(complicate)) {
-            ArrayUtil.set(meta.natives, complicate.name ?? name, (str) => str);
-            return true;
-        }
-
-        for (const generic of GENERICS)
-            if (
-                name.substring(0, generic.name.length) === generic.name &&
-                validator(generic)
-            ) {
-                ArrayUtil.set(meta.natives, generic.name ?? name, (str) => str);
-                return true;
-            }
-        return false;
-    };
-
-const validate =
-    (checker: ts.TypeChecker) => (type: ts.Type) => (info: IClassInfo) =>
-        (info.methods ?? []).every((method) => {
-            const returnType = TypeFactory.getReturnType(
-                checker,
-                type,
-                method.name,
-            );
-            return (
-                returnType !== null &&
-                checker.typeToString(returnType) === method.return
-            );
-        }) &&
-        (info.properties ?? []).every((property) => {
-            const prop = checker.getPropertyOfType(type, property.name);
-            const propType = prop?.valueDeclaration
-                ? checker.getTypeAtLocation(prop?.valueDeclaration)
-                : undefined;
-            return (
-                propType !== undefined &&
-                checker.typeToString(propType) === property.type
-            );
-        });
-
-const getBinaryProps = (className: string): IClassInfo => ({
-    name: className,
-    methods: [
-        ...["indexOf", "lastIndexOf"].map((name) => ({
-            name,
-            return: "number",
-        })),
-        ...["some", "every"].map((name) => ({
-            name,
-            return: "boolean",
-        })),
-        ...["join", "toLocaleString"].map((name) => ({
-            name,
-            return: "string",
-        })),
-        ...["reverse", "slice", "subarray"].map((name) => ({
-            name,
-            return: className,
-        })),
-    ],
-    properties: ["BYTES_PER_ELEMENT", "length", "byteLength", "byteOffset"].map(
-        (name) => ({
-            name,
-            type: "number",
-        }),
-    ),
-});
-const SIMPLES: Map<string, IClassInfo> = new Map([
-    [
-        "Date",
-        {
-            methods: ["getTime", "getFullYear", "getMonth", "getMinutes"].map(
-                (name) => ({
-                    name,
-                    return: "number",
-                }),
-            ),
-        },
-    ],
-    [
-        "Boolean",
-        {
-            methods: [
-                {
-                    name: "valueOf",
-                    return: "boolean",
-                },
-            ],
-        },
-    ],
-    [
-        "Number",
-        {
-            methods: [
-                ...["toFixed", "toExponential", "toPrecision"].map((name) => ({
-                    name,
-                    return: "string",
-                })),
-                {
-                    name: "valueOf",
-                    return: "number",
-                },
-            ],
-        },
-    ],
-    [
-        "String",
-        {
-            methods: [
-                "charAt",
-                "concat",
-                "valueOf",
-                "trim",
-                "replace",
-                "substring",
-            ].map((name) => ({
-                name,
-                return: "string",
-            })),
-        },
-    ],
-    ...[
-        "Uint8Array",
-        "Uint8ClampedArray",
-        "Uint16Array",
-        "Uint32Array",
-        "BigUint64Array",
-        "Int8Array",
-        "Int16Array",
-        "Int32Array",
-        "BigInt64Array",
-        "Float32Array",
-        "Float64Array",
-    ].map((name) => [name, getBinaryProps(name)] as const),
-    ...["ArrayBuffer", "SharedArrayBuffer"].map((className) => {
-        const info: IClassInfo = {
-            methods: [
-                {
-                    name: "slice",
-                    return: className,
-                },
-            ],
-            properties: [
-                {
-                    name: "byteLength",
-                    type: "number",
-                },
-            ],
-        };
-        return [className, info] as const;
-    }),
-    [
-        "DataView",
-        {
-            methods: [
-                "getFloat32",
-                "getFloat64",
-                "getInt8",
-                "getInt16",
-                "getInt32",
-                "getUint8",
-                "getUint16",
-                "getUint32",
-            ].map((name) => ({
-                name,
-                return: "number",
-            })),
-        },
-    ],
-]);
-const COMPLICATES: Map<string, IClassInfo> = new Map([
-    [`'buffer'.global.Buffer`, getBinaryProps("Buffer")],
-]);
-const GENERICS: Array<IClassInfo & { name: string }> = [
-    "WeakMap",
-    "WeakSet",
-].map((name) => ({
-    name,
-    methods: ["has", "delete"].map((name) => ({
-        name,
-        return: "boolean",
-    })),
-}));
-const FORBIDDEN: Set<string> = new Set(["Bolean", "Number", "String"]);
-
-interface IClassInfo {
-    name?: string;
-    methods?: IMethod[];
-    properties?: IProperty[];
-}
-interface IProperty {
-    name: string;
-    type: string;
-}
-interface IMethod {
-    name: string;
-    return: string;
-}
+import ts from "typescript";
+
+import { Metadata } from "../../metadata/Metadata";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+
+import { TypeFactory } from "../TypeFactory";
+
+export const iterate_metadata_native =
+    (checker: ts.TypeChecker) =>
+    (meta: Metadata, type: ts.Type): boolean => {
+        const validator = validate(checker)(type);
+        const name: string = TypeFactory.getFullName(
+            checker,
+            type,
+            type.getSymbol(),
+        );
+
+        const simple = SIMPLES.get(name);
+        if (simple && validator(simple)) {
+            if (FORBIDDEN.has(name))
+                throw new Error(
+                    `Error on typia.metadata(): typia does not allow "${name}" class type. Use "${name.toLowerCase()}" type instead.`,
+                );
+            ArrayUtil.set(meta.natives, name, (str) => str);
+            return true;
+        }
+
+        const complicate = COMPLICATES.get(name);
+        if (complicate && validator(complicate)) {
+            ArrayUtil.set(meta.natives, complicate.name ?? name, (str) => str);
+            return true;
+        }
+
+        for (const generic of GENERICS)
+            if (
+                name.substring(0, generic.name.length) === generic.name &&
+                validator(generic)
+            ) {
+                ArrayUtil.set(meta.natives, generic.name ?? name, (str) => str);
+                return true;
+            }
+        return false;
+    };
+
+const validate =
+    (checker: ts.TypeChecker) => (type: ts.Type) => (info: IClassInfo) =>
+        (info.methods ?? []).every((method) => {
+            const returnType = TypeFactory.getReturnType(
+                checker,
+                type,
+                method.name,
+            );
+            return (
+                returnType !== null &&
+                checker.typeToString(returnType) === method.return
+            );
+        }) &&
+        (info.properties ?? []).every((property) => {
+            const prop = checker.getPropertyOfType(type, property.name);
+            const propType = prop?.valueDeclaration
+                ? checker.getTypeAtLocation(prop?.valueDeclaration)
+                : undefined;
+            return (
+                propType !== undefined &&
+                checker.typeToString(propType) === property.type
+            );
+        });
+
+const getBinaryProps = (className: string): IClassInfo => ({
+    name: className,
+    methods: [
+        ...["indexOf", "lastIndexOf"].map((name) => ({
+            name,
+            return: "number",
+        })),
+        ...["some", "every"].map((name) => ({
+            name,
+            return: "boolean",
+        })),
+        ...["join", "toLocaleString"].map((name) => ({
+            name,
+            return: "string",
+        })),
+        ...["reverse", "slice", "subarray"].map((name) => ({
+            name,
+            return: className,
+        })),
+    ],
+    properties: ["BYTES_PER_ELEMENT", "length", "byteLength", "byteOffset"].map(
+        (name) => ({
+            name,
+            type: "number",
+        }),
+    ),
+});
+const SIMPLES: Map<string, IClassInfo> = new Map([
+    [
+        "Date",
+        {
+            methods: ["getTime", "getFullYear", "getMonth", "getMinutes"].map(
+                (name) => ({
+                    name,
+                    return: "number",
+                }),
+            ),
+        },
+    ],
+    [
+        "Boolean",
+        {
+            methods: [
+                {
+                    name: "valueOf",
+                    return: "boolean",
+                },
+            ],
+        },
+    ],
+    [
+        "Number",
+        {
+            methods: [
+                ...["toFixed", "toExponential", "toPrecision"].map((name) => ({
+                    name,
+                    return: "string",
+                })),
+                {
+                    name: "valueOf",
+                    return: "number",
+                },
+            ],
+        },
+    ],
+    [
+        "String",
+        {
+            methods: [
+                "charAt",
+                "concat",
+                "valueOf",
+                "trim",
+                "replace",
+                "substring",
+            ].map((name) => ({
+                name,
+                return: "string",
+            })),
+        },
+    ],
+    ...[
+        "Uint8Array",
+        "Uint8ClampedArray",
+        "Uint16Array",
+        "Uint32Array",
+        "BigUint64Array",
+        "Int8Array",
+        "Int16Array",
+        "Int32Array",
+        "BigInt64Array",
+        "Float32Array",
+        "Float64Array",
+    ].map((name) => [name, getBinaryProps(name)] as const),
+    ...["ArrayBuffer", "SharedArrayBuffer"].map((className) => {
+        const info: IClassInfo = {
+            methods: [
+                {
+                    name: "slice",
+                    return: className,
+                },
+            ],
+            properties: [
+                {
+                    name: "byteLength",
+                    type: "number",
+                },
+            ],
+        };
+        return [className, info] as const;
+    }),
+    [
+        "DataView",
+        {
+            methods: [
+                "getFloat32",
+                "getFloat64",
+                "getInt8",
+                "getInt16",
+                "getInt32",
+                "getUint8",
+                "getUint16",
+                "getUint32",
+            ].map((name) => ({
+                name,
+                return: "number",
+            })),
+        },
+    ],
+]);
+const COMPLICATES: Map<string, IClassInfo> = new Map([
+    [`'buffer'.global.Buffer`, getBinaryProps("Buffer")],
+]);
+const GENERICS: Array<IClassInfo & { name: string }> = [
+    "WeakMap",
+    "WeakSet",
+].map((name) => ({
+    name,
+    methods: ["has", "delete"].map((name) => ({
+        name,
+        return: "boolean",
+    })),
+}));
+const FORBIDDEN: Set<string> = new Set(["Bolean", "Number", "String"]);
+
+interface IClassInfo {
+    name?: string;
+    methods?: IMethod[];
+    properties?: IProperty[];
+}
+interface IProperty {
+    name: string;
+    type: string;
+}
+interface IMethod {
+    name: string;
+    return: string;
+}

package/src/factories/internal/iterate_metadata_object.ts

@@ -1,45 +1,48 @@
-import ts from "typescript";
-
-import { Metadata } from "../../metadata/Metadata";
-import { MetadataObject } from "../../metadata/MetadataObject";
-
-import { ArrayUtil } from "../../utils/ArrayUtil";
-
-import { MetadataCollection } from "../MetadataCollection";
-import { MetadataFactory } from "../MetadataFactory";
-import { emplace_metadata_object } from "./emplace_metadata_object";
-import { iterate_metadata } from "./iterate_metadata";
-
-export const iterate_metadata_object =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type, parentResolved: boolean): boolean => {
-        const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
-        if (!filter(ts.TypeFlags.Object) && !type.isIntersection())
-            return false;
-
-        if (type.isIntersection()) {
-            const fakeCollection = new MetadataCollection();
-            const fakeSchema: Metadata = Metadata.initialize();
-
-            type.types.forEach((t) =>
-                iterate_metadata(checker)(options)(fakeCollection)(
-                    fakeSchema,
-                    t,
-                    parentResolved,
-                ),
-            );
-            if (
-                fakeSchema.objects.length === 0 ||
-                fakeSchema.objects.length !== fakeSchema.size()
-            )
-                return true;
-        }
-
-        const obj: MetadataObject = emplace_metadata_object(checker)(options)(
-            collection,
-        )(type, meta.nullable);
-        ArrayUtil.add(meta.objects, obj, (elem) => elem.name === obj.name);
-        return true;
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../metadata/Metadata";
+import { MetadataObject } from "../../metadata/MetadataObject";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../MetadataCollection";
+import { MetadataFactory } from "../MetadataFactory";
+import { emplace_metadata_object } from "./emplace_metadata_object";
+import { iterate_metadata } from "./iterate_metadata";
+
+export const iterate_metadata_object =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (meta: Metadata, type: ts.Type, parentResolved: boolean): boolean => {
+        const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+        if (
+            !filter(ts.TypeFlags.Object) &&
+            !type.isIntersection() &&
+            (type as any).intrinsicName !== "object"
+        )
+            return false;
+        else if (type.isIntersection()) {
+            const fakeCollection = new MetadataCollection();
+            const fakeSchema: Metadata = Metadata.initialize();
+
+            type.types.forEach((t) =>
+                iterate_metadata(checker)(options)(fakeCollection)(
+                    fakeSchema,
+                    t,
+                    parentResolved,
+                ),
+            );
+            if (
+                fakeSchema.objects.length === 0 ||
+                fakeSchema.objects.length !== fakeSchema.size()
+            )
+                return true;
+        }
+
+        const obj: MetadataObject = emplace_metadata_object(checker)(options)(
+            collection,
+        )(type, meta.nullable);
+        ArrayUtil.add(meta.objects, obj, (elem) => elem.name === obj.name);
+        return true;
+    };

package/src/factories/internal/iterate_metadata_resolve.ts

@@ -1,27 +1,27 @@
-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 { explore_metadata } from "./explore_metadata";
-
-export const iterate_metadata_resolve =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.Type, parentResolved: boolean): boolean => {
-        if (options.resolve === true && parentResolved === false) {
-            const resolved: ts.Type | null = TypeFactory.resolve(checker, type);
-            if (resolved !== null) {
-                Writable(meta).resolved = explore_metadata(checker)(options)(
-                    collection,
-                )(resolved, true);
-                return true;
-            }
-        }
-        return false;
-    };
+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 { explore_metadata } from "./explore_metadata";
+
+export const iterate_metadata_resolve =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (meta: Metadata, type: ts.Type, parentResolved: boolean): boolean => {
+        if (options.resolve === true && parentResolved === false) {
+            const resolved: ts.Type | null = TypeFactory.resolve(checker, type);
+            if (resolved !== null) {
+                Writable(meta).resolved = explore_metadata(checker)(options)(
+                    collection,
+                )(resolved, true);
+                return true;
+            }
+        }
+        return false;
+    };

package/src/factories/internal/iterate_metadata_set.ts

@@ -1,33 +1,33 @@
-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_set =
-    (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) !== "Set<" || generic?.length !== 1)
-            return false;
-
-        const key: ts.Type = generic[0]!;
-        ArrayUtil.set(
-            meta.sets,
-            explore_metadata(checker)(options)(collection)(key, false),
-            (elem) => elem.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_set =
+    (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) !== "Set<" || generic?.length !== 1)
+            return false;
+
+        const key: ts.Type = generic[0]!;
+        ArrayUtil.set(
+            meta.sets,
+            explore_metadata(checker)(options)(collection)(key, false),
+            (elem) => elem.getName(),
+        );
+        return true;
+    };