typia 8.0.0 → 8.0.1

package/lib/schemas/metadata/Metadata.mjs

@@ -0,0 +1,557 @@
+import { ArrayUtil } from '../../utils/ArrayUtil.mjs';
+import { MetadataAlias } from './MetadataAlias.mjs';
+import { MetadataArray } from './MetadataArray.mjs';
+import { MetadataAtomic } from './MetadataAtomic.mjs';
+import { MetadataConstant } from './MetadataConstant.mjs';
+import { MetadataEscaped } from './MetadataEscaped.mjs';
+import { MetadataFunction } from './MetadataFunction.mjs';
+import { MetadataMap } from './MetadataMap.mjs';
+import { MetadataNative } from './MetadataNative.mjs';
+import { MetadataObject } from './MetadataObject.mjs';
+import { MetadataObjectType } from './MetadataObjectType.mjs';
+import { MetadataSet } from './MetadataSet.mjs';
+import { MetadataTemplate } from './MetadataTemplate.mjs';
+import { MetadataTuple } from './MetadataTuple.mjs';
+
+class Metadata {
+    any;
+    required;
+    optional;
+    nullable;
+    escaped;
+    atomics;
+    constants;
+    templates;
+    rest;
+    aliases;
+    arrays;
+    tuples;
+    objects;
+    functions;
+    natives;
+    sets;
+    maps;
+    /** @internal */ name_;
+    /** @internal */ parent_resolved_ = false;
+    /** @internal */ union_index;
+    /** @internal */ fixed_;
+    /** @internal */ boolean_literal_intersected_;
+    /** @internal */ is_sequence_;
+    /* -----------------------------------------------------------
+      CONSTRUCTORS
+    ----------------------------------------------------------- */
+    /**
+     * @hidden
+     */
+    constructor(props) {
+        this.any = props.any;
+        this.required = props.required;
+        this.optional = props.optional;
+        this.nullable = props.nullable;
+        this.functions = props.functions;
+        this.escaped = props.escaped;
+        this.atomics = props.atomics;
+        this.constants = props.constants;
+        this.templates = props.templates;
+        this.rest = props.rest;
+        this.arrays = props.arrays;
+        this.tuples = props.tuples;
+        this.objects = props.objects;
+        this.aliases = props.aliases;
+        this.natives = props.natives;
+        this.sets = props.sets;
+        this.maps = props.maps;
+    }
+    /**
+     * @internal
+     */
+    static create(props) {
+        return new Metadata(props);
+    }
+    /**
+     * @internal
+     */
+    static initialize(parentResolved = false) {
+        const meta = Metadata.create({
+            any: false,
+            nullable: false,
+            required: true,
+            optional: false,
+            escaped: null,
+            constants: [],
+            atomics: [],
+            templates: [],
+            arrays: [],
+            tuples: [],
+            objects: [],
+            aliases: [],
+            functions: [],
+            rest: null,
+            natives: [],
+            sets: [],
+            maps: [],
+        });
+        meta.parent_resolved_ = parentResolved;
+        return meta;
+    }
+    toJSON() {
+        return {
+            any: this.any,
+            required: this.required,
+            optional: this.optional,
+            nullable: this.nullable,
+            functions: this.functions.map((f) => f.toJSON()),
+            atomics: this.atomics.map((a) => a.toJSON()),
+            constants: this.constants.map((c) => c.toJSON()),
+            templates: this.templates.map((tpl) => tpl.toJSON()),
+            escaped: this.escaped ? this.escaped.toJSON() : null,
+            rest: this.rest ? this.rest.toJSON() : null,
+            arrays: this.arrays.map((array) => array.toJSON()),
+            tuples: this.tuples.map((tuple) => tuple.toJSON()),
+            objects: this.objects.map((obj) => obj.toJSON()),
+            aliases: this.aliases.map((alias) => alias.toJSON()),
+            natives: this.natives.map((native) => native.toJSON()),
+            sets: this.sets.map((set) => set.toJSON()),
+            maps: this.maps.map((map) => map.toJSON()),
+        };
+    }
+    static from(meta, dict) {
+        return Metadata.create({
+            any: meta.any,
+            required: meta.required,
+            optional: meta.optional,
+            nullable: meta.nullable,
+            functions: meta.functions.map((f) => MetadataFunction.from(f, dict)),
+            constants: meta.constants.map(MetadataConstant.from),
+            atomics: meta.atomics.map(MetadataAtomic.from),
+            templates: meta.templates.map((tpl) => MetadataTemplate.from(tpl, dict)),
+            escaped: meta.escaped ? MetadataEscaped.from(meta.escaped, dict) : null,
+            rest: meta.rest ? this.from(meta.rest, dict) : null,
+            arrays: meta.arrays.map((ref) => {
+                const type = dict.arrays.get(ref.name);
+                if (type === undefined)
+                    throw new RangeError(`Error on Metadata.from(): failed to find array "${ref.name}".`);
+                return MetadataArray.create({
+                    type,
+                    tags: ref.tags.map((row) => row.slice()),
+                });
+            }),
+            tuples: meta.tuples.map((t) => {
+                const type = dict.tuples.get(t.name);
+                if (type === undefined)
+                    throw new RangeError(`Error on Metadata.from(): failed to find tuple "${t.name}".`);
+                return MetadataTuple.create({
+                    type,
+                    tags: t.tags.map((r) => r.slice()),
+                });
+            }),
+            objects: meta.objects.map((obj) => {
+                const found = dict.objects.get(obj.name);
+                if (found === undefined)
+                    throw new RangeError(`Error on Metadata.from(): failed to find object "${name}".`);
+                return MetadataObject.create({
+                    type: found,
+                    tags: obj.tags.map((r) => r.slice()),
+                });
+            }),
+            aliases: meta.aliases.map((alias) => {
+                const type = dict.aliases.get(alias.name);
+                if (type === undefined)
+                    throw new RangeError(`Error on Metadata.from(): failed to find alias "${alias}".`);
+                return MetadataAlias.create({
+                    type,
+                    tags: alias.tags.map((r) => r.slice()),
+                });
+            }),
+            natives: meta.natives.map((native) => MetadataNative.create(native)),
+            sets: meta.sets.map((set) => MetadataSet.create({
+                value: Metadata.from(set.value, dict),
+                tags: set.tags.map((r) => r.slice()),
+            })),
+            maps: meta.maps.map((map) => MetadataMap.create({
+                key: this.from(map.key, dict),
+                value: this.from(map.value, dict),
+                tags: map.tags.map((r) => r.slice()),
+            })),
+        });
+    }
+    /* -----------------------------------------------------------
+      ACCESSORS
+    ----------------------------------------------------------- */
+    getName() {
+        return (this.name_ ??= getName(this));
+    }
+    empty() {
+        return this.bucket() === 0 || this.size() === 0;
+    }
+    size() {
+        return ((this.any ? 1 : 0) +
+            (this.escaped ? 1 : 0) +
+            (this.rest ? this.rest.size() : 0) +
+            this.templates.length +
+            this.atomics.length +
+            this.constants.map((c) => c.values.length).reduce((x, y) => x + y, 0) +
+            this.arrays.length +
+            this.tuples.length +
+            this.natives.length +
+            this.maps.length +
+            this.sets.length +
+            this.objects.length +
+            this.functions.length +
+            this.aliases.length);
+    }
+    bucket() {
+        return ((this.any ? 1 : 0) +
+            (this.escaped ? 1 : 0) +
+            (this.templates.length ? 1 : 0) +
+            (this.atomics.length ? 1 : 0) +
+            (this.constants.length ? 1 : 0) +
+            (this.rest ? this.rest.size() : 0) +
+            (this.arrays.length ? 1 : 0) +
+            (this.tuples.length ? 1 : 0) +
+            (this.natives.length ? 1 : 0) +
+            (this.sets.length ? 1 : 0) +
+            (this.maps.length ? 1 : 0) +
+            (this.objects.length ? 1 : 0) +
+            (this.functions.length ? 1 : 0) +
+            (this.aliases.length ? 1 : 0));
+    }
+    /**
+     * @internal
+     */
+    isSequence() {
+        return (this.is_sequence_ ??= (() => {
+            const exists = (tags) => tags.some((row) => {
+                const sequence = row.find((t) => t.kind === "sequence" &&
+                    typeof t.schema?.["x-protobuf-sequence"] === "number");
+                if (sequence === undefined)
+                    return false;
+                const value = Number(sequence.schema["x-protobuf-sequence"]);
+                return !Number.isNaN(value);
+            });
+            return (this.atomics.some((atomic) => exists(atomic.tags)) &&
+                this.constants.some((c) => c.values.some((v) => exists(v.tags ?? []))) &&
+                this.templates.some((tpl) => exists(tpl.tags)) &&
+                this.arrays.some((array) => exists(array.tags)) &&
+                this.objects.some((object) => exists(object.tags)) &&
+                this.natives.some((native) => native.name === "Uint8Array" && exists(native.tags)));
+        })());
+    }
+    isConstant() {
+        return this.bucket() === (this.constants.length ? 1 : 0);
+    }
+    isRequired() {
+        return this.required === true && this.optional === false;
+    }
+    /**
+     * @internal
+     */
+    isUnionBucket() {
+        const size = this.bucket();
+        const emended = !!this.atomics.length && !!this.constants.length ? size - 1 : size;
+        return emended > 1;
+    }
+    /**
+     * @internal
+     */
+    getSoleLiteral() {
+        if (this.size() === 1 &&
+            this.constants.length === 1 &&
+            this.constants[0].type === "string" &&
+            this.constants[0].values.length === 1)
+            return this.constants[0].values[0].value;
+        else
+            return null;
+    }
+    isSoleLiteral() {
+        return this.getSoleLiteral() !== null;
+    }
+    /**
+     * @internal
+     */
+    isParentResolved() {
+        return this.parent_resolved_;
+    }
+}
+(function (Metadata) {
+    Metadata.intersects = (x, y) => {
+        // CHECK ANY & OPTIONAL
+        if (x.any || y.any)
+            return true;
+        if (x.isRequired() === false && false === y.isRequired())
+            return true;
+        if (x.nullable === true && true === y.nullable)
+            return true;
+        if (!!x.functions.length && !!y.functions.length === true)
+            return true;
+        //----
+        // INSTANCES
+        //----
+        // ARRAYS
+        if (x.arrays.length && y.arrays.length)
+            return true;
+        if (x.tuples.length && y.tuples.length)
+            return true;
+        if (x.objects.length && y.objects.length)
+            return true;
+        if (x.aliases.length && y.aliases.length)
+            return true;
+        // NATIVES
+        if (x.natives.length && y.natives.length)
+            if (x.natives.some((xn) => y.natives.some((yn) => xn === yn)))
+                return true;
+        // ESCAPED
+        if (x.escaped && y.escaped)
+            return (Metadata.intersects(x.escaped.original, y.escaped.original) ||
+                Metadata.intersects(x.escaped.returns, y.escaped.returns));
+        //----
+        // VALUES
+        //----
+        // ATOMICS
+        for (const atomic of x.atomics) {
+            if (y.atomics.some((ya) => atomic.type === ya.type))
+                return true;
+            if (y.constants.some((yc) => atomic.type === yc.type))
+                return true;
+        }
+        // CONSTANTS
+        for (const constant of x.constants) {
+            const atomic = y.atomics.find((elem) => elem.type === constant.type);
+            if (atomic !== undefined)
+                return true;
+            const opposite = y.constants.find((elem) => elem.type === constant.type);
+            if (opposite === undefined)
+                continue;
+            const values = new Set([
+                ...constant.values.map((e) => e.value),
+                ...opposite.values.map((e) => e.value),
+            ]);
+            if (values.size !== constant.values.length + opposite.values.length)
+                return true;
+        }
+        // TEMPLATES
+        if (!!x.templates.length && y.atomics.some((ya) => ya.type === "string"))
+            return true;
+        else if (!!y.templates.length &&
+            x.atomics.some((xa) => xa.type === "string"))
+            return true;
+        return false;
+    };
+    Metadata.covers = (x, y, level = 0, escaped = false) => {
+        // CHECK ANY
+        if (x === y)
+            return false;
+        else if (x.any)
+            return true;
+        else if (y.any)
+            return false;
+        if (escaped === false) {
+            if (x.escaped === null && y.escaped !== null)
+                return false;
+            else if (x.escaped !== null &&
+                y.escaped !== null &&
+                (!Metadata.covers(x.escaped.original, y.escaped.original, level, true) ||
+                    !Metadata.covers(x.escaped.returns, y.escaped.returns, level, true)))
+                return false;
+        }
+        //----
+        // INSTANCES
+        //----
+        if (level === 0) {
+            // ARRAYS
+            for (const ya of y.arrays)
+                if (!x.arrays.some((xa) => Metadata.covers(xa.type.value, ya.type.value, level + 1))) {
+                    return false;
+                }
+            // TUPLES
+            for (const yt of y.tuples)
+                if (yt.type.elements.length !== 0 &&
+                    x.tuples.some((xt) => xt.type.elements.length >= yt.type.elements.length &&
+                        xt.type.elements
+                            .slice(yt.type.elements.length)
+                            .every((xv, i) => Metadata.covers(xv, yt.type.elements[i], level + 1))) === false)
+                    return false;
+        }
+        // OBJECTS
+        for (const yo of y.objects)
+            if (x.objects.some((xo) => MetadataObjectType.covers(xo.type, yo.type)) ===
+                false)
+                return false;
+        // ALIASES
+        for (const yd of y.aliases)
+            if (x.aliases.some((xd) => xd.type.name === yd.type.name) === false)
+                return false;
+        // NATIVES
+        for (const yn of y.natives)
+            if (x.natives.some((xn) => xn === yn) === false)
+                return false;
+        // SETS
+        for (const ys of y.sets)
+            if (x.sets.some((xs) => Metadata.covers(xs.value, ys.value)) === false)
+                return false;
+        //----
+        // VALUES
+        //----
+        // ATOMICS
+        if (y.atomics.some((ya) => x.atomics.some((xa) => xa.type === ya.type) === false))
+            return false;
+        // CONSTANTS
+        for (const yc of y.constants) {
+            if (x.atomics.some((atom) => yc.type === atom.type))
+                continue;
+            const xc = x.constants.find((elem) => elem.type === yc.type);
+            if (xc === undefined)
+                return false;
+            else if (yc.values.map((e) => e.value).some((yv) => xc.values.includes(yv) === false))
+                return false;
+        }
+        // FUNCTIONAL
+        if (!!x.functions.length === false && !!y.functions.length)
+            return false;
+        // SUCCESS
+        return true;
+    };
+    /**
+     * @internal
+     */
+    Metadata.merge = (x, y) => {
+        const output = Metadata.create({
+            any: x.any || y.any,
+            nullable: x.nullable || y.nullable,
+            required: x.required && y.required,
+            optional: x.optional || y.optional,
+            functions: x.functions.length ? x.functions : y.functions, // @todo
+            escaped: x.escaped !== null && y.escaped !== null
+                ? MetadataEscaped.create({
+                    original: Metadata.merge(x.escaped.original, y.escaped.original),
+                    returns: Metadata.merge(x.escaped.returns, y.escaped.returns),
+                })
+                : (x.escaped ?? y.escaped),
+            atomics: mergeTaggedTypes({
+                container: x.atomics,
+                equals: (x, y) => x.type === y.type,
+                getter: (x) => x.tags,
+            })(y.atomics),
+            constants: [...x.constants],
+            templates: x.templates.slice(),
+            rest: x.rest !== null && y.rest !== null
+                ? Metadata.merge(x.rest, y.rest)
+                : (x.rest ?? y.rest),
+            arrays: mergeTaggedTypes({
+                container: x.arrays,
+                equals: (x, y) => x.type.name === y.type.name,
+                getter: (x) => x.tags,
+            })(y.arrays),
+            tuples: mergeTaggedTypes({
+                container: x.tuples,
+                equals: (x, y) => x.type.name === y.type.name,
+                getter: (x) => x.tags,
+            })(y.tuples),
+            objects: mergeTaggedTypes({
+                container: x.objects,
+                equals: (x, y) => x.type.name === y.type.name,
+                getter: (x) => x.tags,
+            })(y.objects),
+            aliases: mergeTaggedTypes({
+                container: x.aliases,
+                equals: (x, y) => x.type.name === y.type.name,
+                getter: (x) => x.tags,
+            })(y.aliases),
+            natives: mergeTaggedTypes({
+                container: x.natives,
+                equals: (x, y) => x.name === y.name,
+                getter: (x) => x.tags,
+            })(y.natives),
+            sets: mergeTaggedTypes({
+                container: x.sets,
+                equals: (x, y) => x.value.getName() === y.value.getName(),
+                getter: (x) => x.tags,
+            })(y.sets),
+            maps: mergeTaggedTypes({
+                container: x.maps,
+                equals: (x, y) => x.key.getName() === y.key.getName() &&
+                    x.value.getName() === y.value.getName(),
+                getter: (x) => x.tags,
+            })(y.maps),
+        });
+        for (const constant of y.constants) {
+            const target = ArrayUtil.take(output.constants, (elem) => elem.type === constant.type, () => MetadataConstant.create({
+                type: constant.type,
+                values: [],
+            }));
+            for (const value of constant.values)
+                ArrayUtil.add(target.values, value, (a, b) => a.value === b.value);
+        }
+        return output;
+    };
+})(Metadata || (Metadata = {}));
+const getName = (metadata) => {
+    if (metadata.any === true)
+        return "any";
+    const elements = [];
+    // OPTIONAL
+    if (metadata.nullable === true)
+        elements.push("null");
+    if (metadata.isRequired() === false)
+        elements.push("undefined");
+    // ATOMIC
+    for (const atom of metadata.atomics) {
+        elements.push(atom.getName());
+    }
+    for (const constant of metadata.constants)
+        for (const value of constant.values)
+            elements.push(value.getName());
+    for (const template of metadata.templates)
+        elements.push(template.getName());
+    // NATIVES
+    for (const native of metadata.natives)
+        elements.push(native.getName());
+    for (const set of metadata.sets)
+        elements.push(set.getName());
+    for (const map of metadata.maps)
+        elements.push(map.getName());
+    // INSTANCES
+    if (metadata.rest !== null)
+        elements.push(`...${metadata.rest.getName()}`);
+    for (const tuple of metadata.tuples)
+        elements.push(tuple.type.name);
+    for (const array of metadata.arrays)
+        elements.push(array.getName());
+    for (const object of metadata.objects)
+        elements.push(object.getName());
+    for (const alias of metadata.aliases)
+        elements.push(alias.getName());
+    if (metadata.escaped !== null)
+        elements.push(metadata.escaped.getName());
+    // RETURNS
+    if (elements.length === 0)
+        return "unknown";
+    else if (elements.length === 1)
+        return elements[0];
+    elements.sort();
+    return `(${elements.join(" | ")})`;
+};
+const mergeTaggedTypes = (props) => (opposite) => {
+    const output = [...props.container];
+    for (const elem of opposite) {
+        const equal = props.container.find((x) => props.equals(x, elem));
+        if (equal === undefined) {
+            output.push(elem);
+            continue;
+        }
+        const matrix = props
+            .getter(equal)
+            .map((tags) => tags.map((t) => t.name))
+            .sort();
+        for (const tags of props.getter(elem)) {
+            const names = tags.map((t) => t.name).sort();
+            if (matrix.some((m) => m.length === names.length && m.every((s, i) => s === names[i])))
+                continue;
+            props.getter(equal).push(tags);
+        }
+    }
+    return output;
+};
+
+export { Metadata };
+//# sourceMappingURL=Metadata.mjs.map

package/lib/schemas/metadata/Metadata.mjs.map

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

package/lib/schemas/metadata/MetadataAlias.mjs

@@ -0,0 +1,40 @@
+class MetadataAlias {
+    type;
+    tags;
+    name_;
+    constructor(props) {
+        this.type = props.type;
+        this.tags = props.tags;
+        this.type = props.type;
+    }
+    static create(props) {
+        return new MetadataAlias(props);
+    }
+    getName() {
+        return (this.name_ ??= (() => {
+            if (this.tags.length === 0)
+                return this.type.name;
+            else if (this.tags.length === 1) {
+                const str = [
+                    this.type.name,
+                    ...this.tags[0].map((t) => t.name),
+                ].join(" & ");
+                return `(${str})`;
+            }
+            const rows = this.tags.map((row) => {
+                const str = row.map((t) => t.name).join(" & ");
+                return row.length === 1 ? str : `(${str})`;
+            });
+            return `(${this.type.name} & (${rows.join(" | ")}))`;
+        })());
+    }
+    toJSON() {
+        return {
+            name: this.type.name,
+            tags: this.tags,
+        };
+    }
+}
+
+export { MetadataAlias };
+//# sourceMappingURL=MetadataAlias.mjs.map

package/lib/schemas/metadata/MetadataAlias.mjs.map

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

package/lib/schemas/metadata/MetadataAliasType.mjs

@@ -0,0 +1,54 @@
+class MetadataAliasType {
+    name;
+    value;
+    description;
+    jsDocTags;
+    recursive;
+    nullables;
+    /* -----------------------------------------------------------
+          CONSTRUCTORS
+      ----------------------------------------------------------- */
+    /**
+     * @hidden
+     */
+    constructor(props) {
+        this.name = props.name;
+        this.value = props.value;
+        this.description = props.description;
+        this.jsDocTags = props.jsDocTags;
+        this.recursive = props.recursive;
+        this.nullables = props.nullables;
+    }
+    /**
+     * @internal
+     */
+    static create(props) {
+        return new MetadataAliasType(props);
+    }
+    /**
+     * @internal
+     */
+    static _From_without_value(props) {
+        return MetadataAliasType.create({
+            name: props.name,
+            value: null,
+            description: props.description,
+            recursive: props.recursive,
+            jsDocTags: props.jsDocTags.slice(),
+            nullables: props.nullables.slice(),
+        });
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            value: this.value.toJSON(),
+            description: this.description,
+            recursive: this.recursive,
+            jsDocTags: this.jsDocTags.slice(),
+            nullables: this.nullables.slice(),
+        };
+    }
+}
+
+export { MetadataAliasType };
+//# sourceMappingURL=MetadataAliasType.mjs.map

package/lib/schemas/metadata/MetadataAliasType.mjs.map

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

package/lib/schemas/metadata/MetadataApplication.mjs

@@ -0,0 +1,34 @@
+import { Metadata } from './Metadata.mjs';
+import { MetadataComponents } from './MetadataComponents.mjs';
+
+class MetadataApplication {
+    metadatas;
+    components;
+    /**
+     * @hidden
+     */
+    constructor(props) {
+        this.metadatas = props.metadatas;
+        this.components = props.components;
+    }
+    /**
+     * @internal
+     */
+    static create(props) {
+        return new MetadataApplication(props);
+    }
+    static from(app) {
+        const components = MetadataComponents.from(app.components);
+        const metadatas = app.metadatas.map((metadata) => Metadata.from(metadata, components.dictionary));
+        return MetadataApplication.create({ metadatas, components });
+    }
+    toJSON() {
+        return {
+            metadatas: this.metadatas.map((metadata) => metadata.toJSON()),
+            components: this.components.toJSON(),
+        };
+    }
+}
+
+export { MetadataApplication };
+//# sourceMappingURL=MetadataApplication.mjs.map

package/lib/schemas/metadata/MetadataApplication.mjs.map

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