typia 3.8.4-dev.20230502 → 4.0.0-dev.20230502

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

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

package/src/factories/internal/metadata/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/metadata/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;
+    };

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

@@ -1,48 +1,48 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../metadata/Metadata";
-
-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 iterate_metadata_tuple =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (meta: Metadata, type: ts.TupleType): boolean => {
-        if (!(checker as any).isTupleType(type)) return false;
-
-        const elementFlags: readonly ts.ElementFlags[] =
-            type.elementFlags ??
-            (type.target as ts.TupleType)?.elementFlags ??
-            [];
-
-        const children: Metadata[] = checker
-            .getTypeArguments(type as ts.TypeReference)
-            .map((elem, i) => {
-                const child: Metadata = explore_metadata(checker)(options)(
-                    collection,
-                )(elem, false);
-
-                // CHECK OPTIONAL
-                const flag: ts.ElementFlags | undefined = elementFlags[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;
-            });
-        ArrayUtil.set(meta.tuples, children, join_tuple_names);
-        return true;
-    };
-
-const join_tuple_names = (metas: Metadata[]): string =>
-    `[${metas.map((m) => m.getName).join(", ")}]`;
+import ts from "typescript";
+
+import { Metadata } from "../../../metadata/Metadata";
+
+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 iterate_metadata_tuple =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (meta: Metadata, type: ts.TupleType): boolean => {
+        if (!(checker as any).isTupleType(type)) return false;
+
+        const elementFlags: readonly ts.ElementFlags[] =
+            type.elementFlags ??
+            (type.target as ts.TupleType)?.elementFlags ??
+            [];
+
+        const children: Metadata[] = checker
+            .getTypeArguments(type as ts.TypeReference)
+            .map((elem, i) => {
+                const child: Metadata = explore_metadata(checker)(options)(
+                    collection,
+                )(elem, false);
+
+                // CHECK OPTIONAL
+                const flag: ts.ElementFlags | undefined = elementFlags[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;
+            });
+        ArrayUtil.set(meta.tuples, children, join_tuple_names);
+        return true;
+    };
+
+const join_tuple_names = (metas: Metadata[]): string =>
+    `[${metas.map((m) => m.getName).join(", ")}]`;