typia 5.0.0-dev.20230823-2 → 5.0.0-dev.2023084

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

@@ -1,210 +1,210 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/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;
-        }
-
-        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 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 "../../../schemas/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;
+        }
+
+        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 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,49 +1,49 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataEscaped } from "../../../schemas/metadata/MetadataEscaped";
-
-import { Writable } from "../../../typings/Writable";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { TypeFactory } from "../../TypeFactory";
-import { iterate_metadata } from "./iterate_metadata";
-
-// import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
-
-export const iterate_metadata_resolve =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (
-        meta: Metadata,
-        type: ts.Type,
-        resolved: boolean,
-        aliased: boolean,
-    ): boolean => {
-        if (options.escape === false || resolved === true) return false;
-
-        const escaped: ts.Type | null = TypeFactory.resolve(checker)(type);
-        if (escaped === null) return false;
-
-        if (meta.escaped === null) {
-            Writable(meta).escaped = MetadataEscaped.create({
-                original: Metadata.initialize(),
-                returns: Metadata.initialize(),
-            });
-        }
-        iterate_metadata(checker)(options)(collection)(
-            meta.escaped!.original,
-            type,
-            true,
-            aliased,
-        );
-        iterate_metadata(checker)(options)(collection)(
-            meta.escaped!.returns,
-            escaped,
-            true,
-            aliased,
-        );
-        return true;
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataEscaped } from "../../../schemas/metadata/MetadataEscaped";
+
+import { Writable } from "../../../typings/Writable";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { TypeFactory } from "../../TypeFactory";
+import { iterate_metadata } from "./iterate_metadata";
+
+// import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
+
+export const iterate_metadata_resolve =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (
+        meta: Metadata,
+        type: ts.Type,
+        resolved: boolean,
+        aliased: boolean,
+    ): boolean => {
+        if (options.escape === false || resolved === true) return false;
+
+        const escaped: ts.Type | null = TypeFactory.resolve(checker)(type);
+        if (escaped === null) return false;
+
+        if (meta.escaped === null) {
+            Writable(meta).escaped = MetadataEscaped.create({
+                original: Metadata.initialize(),
+                returns: Metadata.initialize(),
+            });
+        }
+        iterate_metadata(checker)(options)(collection)(
+            meta.escaped!.original,
+            type,
+            true,
+            aliased,
+        );
+        iterate_metadata(checker)(options)(collection)(
+            meta.escaped!.returns,
+            escaped,
+            true,
+            aliased,
+        );
+        return true;
+    };

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

@@ -1,69 +1,69 @@
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
-
-import { MetadataCollection } from "../../MetadataCollection";
-
-export const iterate_metadata_sort =
-    (collection: MetadataCollection) => (meta: Metadata) => {
-        const visited: Set<Metadata> = new Set();
-        for (const array of collection.arrays())
-            iterate(visited)(collection)(array.value);
-        for (const tuple of collection.tuples())
-            for (const element of tuple.elements)
-                iterate(visited)(collection)(element);
-        for (const object of collection.objects())
-            for (const property of object.properties)
-                iterate(visited)(collection)(property.value);
-        iterate(visited)(collection)(meta);
-    };
-
-const iterate =
-    (visited: Set<Metadata>) =>
-    (collection: MetadataCollection) =>
-    (meta: Metadata) => {
-        if (visited.has(meta)) return;
-        visited.add(meta);
-
-        // ITERATE CHILDREN
-        for (const map of meta.maps) iterate(visited)(collection)(map.value);
-        for (const set of meta.sets) iterate(visited)(collection)(set);
-        if (meta.escaped !== null)
-            iterate(visited)(collection)(meta.escaped.returns);
-        if (meta.rest !== null) iterate(visited)(collection)(meta.rest);
-
-        // SORT OBJECTS
-        if (meta.objects.length > 1) {
-            meta.objects.sort((x, y) =>
-                MetadataObject.covers(x, y)
-                    ? -1
-                    : MetadataObject.covers(y, x)
-                    ? 1
-                    : 0,
-            );
-            meta.union_index = collection.getUnionIndex(meta);
-        }
-
-        // SORT ARRAYS AND TUPLES
-        if (meta.arrays.length > 1)
-            meta.arrays.sort((x, y) =>
-                Metadata.covers(x.value, y.value)
-                    ? -1
-                    : Metadata.covers(y.value, x.value)
-                    ? 1
-                    : 0,
-            );
-        if (meta.tuples.length > 1)
-            meta.tuples.sort((x, y) => {
-                const xt = Metadata.initialize();
-                const yt = Metadata.initialize();
-
-                xt.tuples.push(x);
-                yt.tuples.push(y);
-
-                return Metadata.covers(xt, yt)
-                    ? -1
-                    : Metadata.covers(yt, xt)
-                    ? 1
-                    : 0;
-            });
-    };
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
+
+import { MetadataCollection } from "../../MetadataCollection";
+
+export const iterate_metadata_sort =
+    (collection: MetadataCollection) => (meta: Metadata) => {
+        const visited: Set<Metadata> = new Set();
+        for (const array of collection.arrays())
+            iterate(visited)(collection)(array.value);
+        for (const tuple of collection.tuples())
+            for (const element of tuple.elements)
+                iterate(visited)(collection)(element);
+        for (const object of collection.objects())
+            for (const property of object.properties)
+                iterate(visited)(collection)(property.value);
+        iterate(visited)(collection)(meta);
+    };
+
+const iterate =
+    (visited: Set<Metadata>) =>
+    (collection: MetadataCollection) =>
+    (meta: Metadata) => {
+        if (visited.has(meta)) return;
+        visited.add(meta);
+
+        // ITERATE CHILDREN
+        for (const map of meta.maps) iterate(visited)(collection)(map.value);
+        for (const set of meta.sets) iterate(visited)(collection)(set);
+        if (meta.escaped !== null)
+            iterate(visited)(collection)(meta.escaped.returns);
+        if (meta.rest !== null) iterate(visited)(collection)(meta.rest);
+
+        // SORT OBJECTS
+        if (meta.objects.length > 1) {
+            meta.objects.sort((x, y) =>
+                MetadataObject.covers(x, y)
+                    ? -1
+                    : MetadataObject.covers(y, x)
+                    ? 1
+                    : 0,
+            );
+            meta.union_index = collection.getUnionIndex(meta);
+        }
+
+        // SORT ARRAYS AND TUPLES
+        if (meta.arrays.length > 1)
+            meta.arrays.sort((x, y) =>
+                Metadata.covers(x.value, y.value)
+                    ? -1
+                    : Metadata.covers(y.value, x.value)
+                    ? 1
+                    : 0,
+            );
+        if (meta.tuples.length > 1)
+            meta.tuples.sort((x, y) => {
+                const xt = Metadata.initialize();
+                const yt = Metadata.initialize();
+
+                xt.tuples.push(x);
+                yt.tuples.push(y);
+
+                return Metadata.covers(xt, yt)
+                    ? -1
+                    : Metadata.covers(yt, xt)
+                    ? 1
+                    : 0;
+            });
+    };