typia 8.0.0 → 8.0.1

package/lib/factories/internal/metadata/iterate_metadata_intersection.mjs

@@ -0,0 +1,185 @@
+import { MetadataTypeTagFactory } from '../../MetadataTypeTagFactory.mjs';
+import { explore_metadata } from './explore_metadata.mjs';
+import { iterate_metadata } from './iterate_metadata.mjs';
+
+const iterate_metadata_intersection = (props) => {
+    if (props.intersected === true)
+        return false;
+    else if (props.type.isIntersection() === false)
+        return false;
+    // CONSTRUCT FAKE METADATA LIST
+    const commit = props.collection.clone();
+    props.collection["options"] = undefined;
+    const fakeErrors = [];
+    const children = props.type.types.map((t) => explore_metadata({
+        ...props,
+        options: {
+            ...props.options,
+            absorb: true,
+            functional: false,
+        },
+        collection: props.collection,
+        errors: fakeErrors,
+        type: t,
+        explore: {
+            ...props.explore,
+            aliased: false,
+        },
+        intersected: false,
+    }));
+    // ERROR OR ANY TYPE CASE
+    const escape = (out) => {
+        Object.assign(props.collection, commit);
+        return out;
+    };
+    if (fakeErrors.length) {
+        props.errors.push(...fakeErrors);
+        return escape(true);
+    }
+    else if (children.length === 0)
+        return escape(false);
+    else if (children.some((m) => m.any === true || m.size() === 0))
+        return escape(false);
+    // PREPARE MEATDATAS AND TAGS
+    const indexes = [];
+    const metadatas = [];
+    const tagObjects = [];
+    children.forEach((child, i) => {
+        if (child.size() === 1 &&
+            child.objects.length === 1 &&
+            MetadataTypeTagFactory.is(child.objects[0].type))
+            tagObjects.push(child.objects[0].type);
+        else {
+            indexes.push(i);
+            metadatas.push(child);
+        }
+    });
+    const nonsensible = () => {
+        props.errors.push({
+            name: children.map((c) => c.getName()).join(" & "),
+            explore: { ...props.explore },
+            messages: ["nonsensible intersection"],
+        });
+        return escape(true);
+    };
+    // NO METADATA CASE
+    if (metadatas.length === 0)
+        if (tagObjects.length !== 0) {
+            props.errors.push({
+                name: children.map((c) => c.getName()).join(" & "),
+                explore: { ...props.explore },
+                messages: ["type tag cannot be standalone"],
+            });
+            return escape(true);
+        }
+        else
+            return escape(false);
+    // ONLY OBJECTS CASE
+    else if (metadatas.every((m) => m.objects.length === 1) &&
+        tagObjects.length === 0)
+        return escape(false);
+    else if (metadatas.length !== 1) {
+        const indexes = metadatas
+            .map((m, i) => m.size() === 1 &&
+            m.objects.length === 1 &&
+            (m.objects[0].type.properties.length === 0 ||
+                m.objects[0].type.properties.every((p) => p.value.optional === true))
+            ? i
+            : null)
+            .filter((i) => i !== null);
+        if (indexes.length && metadatas.length !== indexes.length)
+            for (const i of indexes.reverse())
+                metadatas.splice(i, 1);
+        else
+            return nonsensible();
+    }
+    else if (metadatas.some((m) => m.size() !== 1))
+        return nonsensible();
+    const candidates = new Map();
+    const assigners = [];
+    for (const meta of metadatas) {
+        for (const a of meta.atomics) {
+            candidates.set(a.type, a.type);
+            assigners.push((tags) => props.metadata.atomics
+                .find((atom) => atom.type === a.type)
+                ?.tags.push(tags));
+        }
+        for (const c of meta.constants)
+            for (const v of c.values) {
+                candidates.set(c.type, c.type);
+                assigners.push((tags) => props.metadata.constants
+                    .find((constant) => constant.type === c.type)
+                    ?.values.find((value) => value === v)
+                    ?.tags?.push(tags));
+            }
+        for (const t of meta.templates) {
+            candidates.set("string", "string");
+            assigners.push((tags) => props.metadata.templates
+                .find((tpl) => tpl.getBaseName() === t.getBaseName())
+                ?.tags.push(tags));
+        }
+        if (meta.objects.length) {
+            candidates.set("object", "object");
+            assigners.push((tags) => props.metadata.objects.at(-1)?.tags.push(tags));
+        }
+        if (meta.arrays.length) {
+            candidates.set("array", "array");
+            assigners.push((tags) => props.metadata.arrays.at(-1)?.tags.push(tags));
+        }
+        if (meta.tuples.length)
+            candidates.set("invalid", "tuple");
+        for (const n of meta.natives) {
+            candidates.set(`native::${n.name}`, "object");
+            assigners.push((tags) => props.metadata.natives
+                .find((native) => native.name === n.name)
+                ?.tags.push(tags));
+        }
+        for (const s of meta.sets) {
+            candidates.set(`set::${s.value.getName()}`, "object");
+            assigners.push((tags) => props.metadata.sets
+                .find((set) => set.value.getName() === s.value.getName())
+                ?.tags.push(tags));
+        }
+        for (const e of meta.maps) {
+            candidates.set(`map::${e.key.getName()}::${e.value.getName()}`, "object");
+            assigners.push((tags) => props.metadata.maps
+                .find((map) => map.key.getName() === e.key.getName() &&
+                map.value.getName() === e.value.getName())
+                ?.tags.push(tags));
+        }
+    }
+    if (candidates.size !== 1 ||
+        candidates.has("nonsensible")
+    // ||
+    // (candidates.size !== 1 &&
+    //   Array.from(candidates.keys()).some((v) => v !== "object"))
+    )
+        return nonsensible();
+    const tags = MetadataTypeTagFactory.analyze({
+        errors: props.errors,
+        type: candidates.values().next().value,
+        objects: tagObjects,
+        explore: props.explore,
+    });
+    Object.assign(props.collection, commit);
+    iterate_metadata({
+        ...props,
+        type: props.type.types[indexes[0]],
+        options: {
+            ...props.options,
+            functional: false,
+        },
+        explore: {
+            ...props.explore,
+            aliased: false,
+            escaped: false,
+        },
+        intersected: true,
+    });
+    if (tags.length)
+        assigners.forEach((fn) => fn(tags));
+    return true;
+};
+
+export { iterate_metadata_intersection };
+//# sourceMappingURL=iterate_metadata_intersection.mjs.map

package/lib/factories/internal/metadata/iterate_metadata_intersection.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterate_metadata_intersection.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/factories/internal/metadata/iterate_metadata_map.mjs

@@ -0,0 +1,47 @@
+import { MetadataMap } from '../../../schemas/metadata/MetadataMap.mjs';
+import { ArrayUtil } from '../../../utils/ArrayUtil.mjs';
+import { TypeFactory } from '../../TypeFactory.mjs';
+import { explore_metadata } from './explore_metadata.mjs';
+
+const iterate_metadata_map = (props) => {
+    const type = props.checker.getApparentType(props.type);
+    const name = TypeFactory.getFullName({
+        checker: props.checker,
+        type,
+        symbol: type.getSymbol(),
+    });
+    const generic = type.aliasSymbol
+        ? type.aliasTypeArguments
+        : props.checker.getTypeArguments(type);
+    if (name.substring(0, 4) !== "Map<" || generic?.length !== 2)
+        return false;
+    const key = generic[0];
+    const value = generic[1];
+    ArrayUtil.set(props.metadata.maps, MetadataMap.create({
+        key: explore_metadata({
+            ...props,
+            type: key,
+            explore: {
+                ...props.explore,
+                escaped: false,
+                aliased: false,
+            },
+            intersected: false,
+        }),
+        value: explore_metadata({
+            ...props,
+            type: value,
+            explore: {
+                ...props.explore,
+                escaped: false,
+                aliased: false,
+            },
+            intersected: false,
+        }),
+        tags: [],
+    }), (elem) => `Map<${elem.key.getName()}, ${elem.value.getName()}>`);
+    return true;
+};
+
+export { iterate_metadata_map };
+//# sourceMappingURL=iterate_metadata_map.mjs.map

package/lib/factories/internal/metadata/iterate_metadata_map.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterate_metadata_map.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/factories/internal/metadata/iterate_metadata_native.mjs

@@ -0,0 +1,203 @@
+import { MetadataNative } from '../../../schemas/metadata/MetadataNative.mjs';
+import { ArrayUtil } from '../../../utils/ArrayUtil.mjs';
+import { TypeFactory } from '../../TypeFactory.mjs';
+
+const iterate_metadata_native = (props) => {
+    const name = TypeFactory.getFullName({
+        checker: props.checker,
+        type: props.type,
+        symbol: props.type.getSymbol(),
+    }).split("<")?.[0] ?? "";
+    const simple = SIMPLES.get(name);
+    if (simple !== undefined &&
+        validate({
+            checker: props.checker,
+            type: props.type,
+            info: simple,
+        })) {
+        ArrayUtil.take(props.metadata.natives, (native) => native.name === name, () => MetadataNative.create({
+            name,
+            tags: [],
+        }));
+        return true;
+    }
+    for (const generic of GENERICS)
+        if (name.substring(0, generic.name.length) === generic.name &&
+            validate({
+                checker: props.checker,
+                type: props.type,
+                info: generic,
+            })) {
+            ArrayUtil.take(props.metadata.natives, (native) => native.name === name, () => MetadataNative.create({
+                name: generic.name ?? name,
+                tags: [],
+            }));
+            return true;
+        }
+    return false;
+};
+const validate = (props) => (props.info.methods ?? []).every((method) => {
+    const returnType = TypeFactory.getReturnTypeOfClassMethod({
+        checker: props.checker,
+        class: props.type,
+        function: method.name,
+    });
+    return (returnType !== null &&
+        props.checker.typeToString(returnType).split("<")?.[0] === method.return);
+}) &&
+    (props.info.properties ?? []).every((property) => {
+        const prop = props.checker.getPropertyOfType(props.type, property.name);
+        const propType = prop?.valueDeclaration
+            ? props.checker.getTypeAtLocation(prop?.valueDeclaration)
+            : undefined;
+        return (propType !== undefined &&
+            props.checker.typeToString(propType).split("<")?.[0] === property.type);
+    });
+const getBinaryProps = (className) => ({
+    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 = 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)]),
+    ...["ArrayBuffer", "SharedArrayBuffer"].map((className) => {
+        const info = {
+            methods: [{ name: "slice", return: className }],
+            properties: [{ name: "byteLength", type: "number" }],
+        };
+        return [className, info];
+    }),
+    ...["Blob", "File"].map((className) => [
+        className,
+        {
+            methods: [
+                { name: "arrayBuffer", return: "Promise" },
+                { name: "slice", return: "Blob" },
+                { name: "text", return: "Promise" },
+            ],
+            properties: [
+                { name: "size", type: "number" },
+                { name: "type", type: "string" },
+            ],
+        },
+    ]),
+    [
+        "DataView",
+        {
+            methods: [
+                "getFloat32",
+                "getFloat64",
+                "getInt8",
+                "getInt16",
+                "getInt32",
+                "getUint8",
+                "getUint16",
+                "getUint32",
+            ].map((name) => ({
+                name,
+                return: "number",
+            })),
+        },
+    ],
+    [
+        "RegExp",
+        {
+            methods: [
+                {
+                    name: "test",
+                    return: "boolean",
+                },
+            ],
+        },
+    ],
+]);
+const GENERICS = [
+    "WeakMap",
+    "WeakSet",
+].map((name) => ({
+    name,
+    methods: ["has", "delete"].map((name) => ({
+        name,
+        return: "boolean",
+    })),
+}));
+
+export { iterate_metadata_native };
+//# sourceMappingURL=iterate_metadata_native.mjs.map

package/lib/factories/internal/metadata/iterate_metadata_native.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterate_metadata_native.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/factories/internal/metadata/iterate_metadata_object.mjs

@@ -0,0 +1,23 @@
+import ts from 'typescript';
+import { MetadataObject } from '../../../schemas/metadata/MetadataObject.mjs';
+import { ArrayUtil } from '../../../utils/ArrayUtil.mjs';
+import { emplace_metadata_object } from './emplace_metadata_object.mjs';
+
+const iterate_metadata_object = (props, ensure = false) => {
+    if (ensure === false) {
+        const filter = (flag) => (props.type.getFlags() & flag) !== 0;
+        if (!filter(ts.TypeFlags.Object) &&
+            !props.type.isIntersection() &&
+            props.type.intrinsicName !== "object")
+            return false;
+    }
+    const obj = emplace_metadata_object(props);
+    ArrayUtil.add(props.metadata.objects, MetadataObject.create({
+        type: obj,
+        tags: [],
+    }), (elem) => elem.type.name === obj.name);
+    return true;
+};
+
+export { iterate_metadata_object };
+//# sourceMappingURL=iterate_metadata_object.mjs.map

package/lib/factories/internal/metadata/iterate_metadata_object.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterate_metadata_object.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/factories/internal/metadata/iterate_metadata_set.mjs

@@ -0,0 +1,46 @@
+import { MetadataSet } from '../../../schemas/metadata/MetadataSet.mjs';
+import { ArrayUtil } from '../../../utils/ArrayUtil.mjs';
+import { TypeFactory } from '../../TypeFactory.mjs';
+import { explore_metadata } from './explore_metadata.mjs';
+
+const iterate_metadata_set = (props) => {
+    const type = props.checker.getApparentType(props.type);
+    const name = TypeFactory.getFullName({
+        checker: props.checker,
+        type: type,
+        symbol: type.getSymbol(),
+    });
+    const generic = type.aliasSymbol
+        ? type.aliasTypeArguments
+        : props.checker.getTypeArguments(type);
+    if (name.substring(0, 4) !== "Set<" || generic?.length !== 1)
+        return false;
+    const key = generic[0];
+    const value = explore_metadata({
+        ...props,
+        type: key,
+        explore: {
+            ...props.explore,
+            escaped: false,
+            aliased: false,
+        },
+        intersected: false,
+    });
+    ArrayUtil.take(props.metadata.sets, (elem) => elem.value.getName() === value.getName(), () => MetadataSet.create({
+        value: explore_metadata({
+            ...props,
+            type: key,
+            explore: {
+                ...props.explore,
+                escaped: false,
+                aliased: false,
+            },
+            intersected: false,
+        }),
+        tags: [],
+    }));
+    return true;
+};
+
+export { iterate_metadata_set };
+//# sourceMappingURL=iterate_metadata_set.mjs.map

package/lib/factories/internal/metadata/iterate_metadata_set.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterate_metadata_set.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/factories/internal/metadata/iterate_metadata_sort.mjs

@@ -0,0 +1,75 @@
+import { Metadata } from '../../../schemas/metadata/Metadata.mjs';
+import { MetadataObjectType } from '../../../schemas/metadata/MetadataObjectType.mjs';
+
+const iterate_metadata_sort = (props) => {
+    const visited = new Set();
+    const next = (metadata) => iterate({
+        visited,
+        collection: props.collection,
+        metadata,
+    });
+    for (const array of props.collection.arrays())
+        next(array.value);
+    for (const tuple of props.collection.tuples())
+        for (const element of tuple.elements)
+            next(element);
+    for (const object of props.collection.objects())
+        for (const property of object.properties)
+            next(property.value);
+    next(props.metadata);
+};
+const iterate = (props) => {
+    if (props.visited.has(props.metadata))
+        return;
+    props.visited.add(props.metadata);
+    const next = (metadata) => iterate({
+        ...props,
+        metadata,
+    });
+    // ITERATE CHILDREN
+    for (const map of props.metadata.maps)
+        next(map.value);
+    for (const set of props.metadata.sets)
+        next(set.value);
+    if (props.metadata.escaped !== null)
+        next(props.metadata.escaped.returns);
+    if (props.metadata.rest !== null)
+        next(props.metadata.rest);
+    // SORT OBJECTS
+    if (props.metadata.objects.length > 1) {
+        props.metadata.objects.sort((x, y) => MetadataObjectType.covers(x.type, y.type)
+            ? -1
+            : MetadataObjectType.covers(y.type, x.type)
+                ? 1
+                : 0);
+        props.metadata.union_index = props.collection.getUnionIndex(props.metadata);
+    }
+    // SORT ARRAYS AND TUPLES
+    if (props.metadata.arrays.length > 1)
+        props.metadata.arrays.sort((x, y) => Metadata.covers(x.type.value, y.type.value)
+            ? -1
+            : Metadata.covers(y.type.value, x.type.value)
+                ? 1
+                : 0);
+    if (props.metadata.tuples.length > 1)
+        props.metadata.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;
+        });
+    // SORT CONSTANT VALUES
+    for (const constant of props.metadata.constants)
+        if (constant.type === "string")
+            constant.values.sort();
+        else if (constant.type === "number")
+            constant.values.sort((a, b) => a.value - b.value);
+        else if (constant.type === "bigint")
+            constant.values.sort((a, b) => a.value < b.value ? -1 : 1);
+        else
+            constant.values.sort((a, _b) => (a.value === false ? -1 : 1));
+};
+
+export { iterate_metadata_sort };
+//# sourceMappingURL=iterate_metadata_sort.mjs.map

package/lib/factories/internal/metadata/iterate_metadata_sort.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterate_metadata_sort.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/factories/internal/metadata/iterate_metadata_template.mjs

@@ -0,0 +1,35 @@
+import ts from 'typescript';
+import { MetadataTemplate } from '../../../schemas/metadata/MetadataTemplate.mjs';
+import { MetadataHelper } from './MetadataHelper.mjs';
+import { explore_metadata } from './explore_metadata.mjs';
+
+const iterate_metadata_template = (props) => {
+    const filter = (flag) => (props.type.getFlags() & flag) !== 0;
+    if (!filter(ts.TypeFlags.TemplateLiteral))
+        return false;
+    const template = props.type;
+    const row = [];
+    template.texts.forEach((text, i) => {
+        // TEXT LITERAL TYPE
+        if (text !== "")
+            row.push(MetadataHelper.literal_to_metadata(text));
+        // BINDED TEMPLATE TYPE
+        const binded = template.types[i];
+        if (binded)
+            row.push(explore_metadata({
+                ...props,
+                type: binded,
+                explore: {
+                    ...props.explore,
+                    escaped: false,
+                    aliased: false,
+                },
+                intersected: false,
+            }));
+    });
+    props.metadata.templates.push(MetadataTemplate.create({ row, tags: [] }));
+    return true;
+};
+
+export { iterate_metadata_template };
+//# sourceMappingURL=iterate_metadata_template.mjs.map

package/lib/factories/internal/metadata/iterate_metadata_template.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterate_metadata_template.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/factories/internal/metadata/iterate_metadata_tuple.mjs

@@ -0,0 +1,17 @@
+import { MetadataTuple } from '../../../schemas/metadata/MetadataTuple.mjs';
+import { ArrayUtil } from '../../../utils/ArrayUtil.mjs';
+import { emplace_metadata_tuple } from './emplace_metadata_tuple.mjs';
+
+const iterate_metadata_tuple = (props) => {
+    if (!props.checker.isTupleType(props.type))
+        return false;
+    const tupleType = emplace_metadata_tuple(props);
+    ArrayUtil.add(props.metadata.tuples, MetadataTuple.create({
+        type: tupleType,
+        tags: [],
+    }), (elem) => elem.type.name === tupleType.name);
+    return true;
+};
+
+export { iterate_metadata_tuple };
+//# sourceMappingURL=iterate_metadata_tuple.mjs.map

package/lib/factories/internal/metadata/iterate_metadata_tuple.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterate_metadata_tuple.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/lib/factories/internal/metadata/iterate_metadata_union.mjs

@@ -0,0 +1,18 @@
+import { iterate_metadata } from './iterate_metadata.mjs';
+
+const iterate_metadata_union = (props) => {
+    if (!props.type.isUnion())
+        return false;
+    props.type.types.forEach((t) => iterate_metadata({
+        ...props,
+        type: t,
+        explore: {
+            ...props.explore,
+            aliased: false,
+        },
+    }));
+    return true;
+};
+
+export { iterate_metadata_union };
+//# sourceMappingURL=iterate_metadata_union.mjs.map

package/lib/factories/internal/metadata/iterate_metadata_union.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iterate_metadata_union.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}