typia 3.6.3 → 3.6.4

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_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;
+    };

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

@@ -1,222 +1,222 @@
-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)) {
-            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",
-    })),
-}));
-
-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)) {
+            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",
+    })),
+}));
+
+interface IClassInfo {
+    name?: string;
+    methods?: IMethod[];
+    properties?: IProperty[];
+}
+interface IProperty {
+    name: string;
+    type: string;
+}
+interface IMethod {
+    name: string;
+    return: string;
+}