typia 8.0.0 → 8.0.1

package/lib/schemas/metadata/MetadataArray.mjs

@@ -0,0 +1,42 @@
+class MetadataArray {
+    type;
+    tags;
+    name_;
+    /**
+     * @hidden
+     */
+    constructor(props) {
+        this.type = props.type;
+        this.tags = props.tags;
+    }
+    static create(props) {
+        return new MetadataArray(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.map((row) => row.slice()),
+        };
+    }
+}
+
+export { MetadataArray };
+//# sourceMappingURL=MetadataArray.mjs.map

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

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

package/lib/schemas/metadata/MetadataArrayType.mjs

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

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

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

package/lib/schemas/metadata/MetadataAtomic.mjs

@@ -0,0 +1,71 @@
+class MetadataAtomic {
+    type;
+    tags;
+    name_;
+    /**
+     * @internal
+     */
+    constructor(props) {
+        this.type = props.type;
+        this.tags = props.tags;
+    }
+    static create(props) {
+        return new MetadataAtomic(props);
+    }
+    static from(json) {
+        return MetadataAtomic.create({
+            type: json.type,
+            tags: json.tags.map((row) => row.map((tag) => ({
+                target: tag.target,
+                name: tag.name,
+                kind: tag.kind,
+                value: typeof tag.value === "object" &&
+                    tag.value?.type === "bigint" &&
+                    typeof tag.value.value === "string"
+                    ? BigInt(tag.value.value)
+                    : tag.value,
+                validate: tag.validate,
+                exclusive: tag.exclusive,
+                schema: tag.schema,
+            }))),
+        });
+    }
+    getName() {
+        return (this.name_ ??= getName(this));
+    }
+    toJSON() {
+        return {
+            type: this.type,
+            tags: this.tags.map((row) => row.map((tag) => ({
+                target: tag.target,
+                name: tag.name,
+                kind: tag.kind,
+                value: typeof tag.value === "bigint"
+                    ? {
+                        type: "bigint",
+                        value: tag.value.toString(),
+                    }
+                    : tag.value,
+                validate: tag.validate,
+                exclusive: tag.exclusive,
+                schema: tag.schema,
+            }))),
+        };
+    }
+}
+const getName = (obj) => {
+    if (obj.tags.length === 0)
+        return obj.type;
+    else if (obj.tags.length === 1) {
+        const str = [obj.type, ...obj.tags[0].map((t) => t.name)].join(" & ");
+        return `(${str})`;
+    }
+    const rows = obj.tags.map((row) => {
+        const str = row.map((t) => t.name).join(" & ");
+        return row.length === 1 ? str : `(${str})`;
+    });
+    return `(${obj.type} & (${rows.join(" | ")}))`;
+};
+
+export { MetadataAtomic };
+//# sourceMappingURL=MetadataAtomic.mjs.map

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

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

package/lib/schemas/metadata/MetadataComponents.mjs

@@ -0,0 +1,74 @@
+import { Writable } from '../../typings/Writable.mjs';
+import { Metadata } from './Metadata.mjs';
+import { MetadataAliasType } from './MetadataAliasType.mjs';
+import { MetadataArrayType } from './MetadataArrayType.mjs';
+import { MetadataObjectType } from './MetadataObjectType.mjs';
+import { MetadataProperty } from './MetadataProperty.mjs';
+import { MetadataTupleType } from './MetadataTupleType.mjs';
+
+class MetadataComponents {
+    aliases;
+    objects;
+    arrays;
+    tuples;
+    dictionary;
+    constructor(props) {
+        this.aliases = props.aliases;
+        this.objects = props.objects;
+        this.arrays = props.arrays;
+        this.tuples = props.tuples;
+        this.dictionary = props.dictionary;
+    }
+    static from(json) {
+        // INITIALIZE COMPONENTS
+        const dictionary = {
+            objects: new Map(json.objects.map((obj) => [
+                obj.name,
+                MetadataObjectType._From_without_properties(obj),
+            ])),
+            aliases: new Map(json.aliases.map((alias) => [
+                alias.name,
+                MetadataAliasType._From_without_value(alias),
+            ])),
+            arrays: new Map(json.arrays.map((arr) => [
+                arr.name,
+                MetadataArrayType._From_without_value(arr),
+            ])),
+            tuples: new Map(json.tuples.map((tpl) => [
+                tpl.name,
+                MetadataTupleType._From_without_elements(tpl),
+            ])),
+        };
+        // CONSTRUCT METADATA OF THEM
+        for (const obj of json.objects)
+            dictionary.objects
+                .get(obj.name)
+                .properties.push(...obj.properties.map((prop) => MetadataProperty.from(prop, dictionary)));
+        for (const alias of json.aliases)
+            Writable(dictionary.aliases.get(alias.name)).value = Metadata.from(alias.value, dictionary);
+        for (const array of json.arrays)
+            Writable(dictionary.arrays.get(array.name)).value = Metadata.from(array.value, dictionary);
+        for (const tuple of json.tuples)
+            Writable(dictionary.tuples.get(tuple.name)).elements =
+                tuple.elements.map((elem) => Metadata.from(elem, dictionary));
+        // FINALIZE
+        return new MetadataComponents({
+            aliases: [...dictionary.aliases.values()],
+            objects: [...dictionary.objects.values()],
+            arrays: [...dictionary.arrays.values()],
+            tuples: [...dictionary.tuples.values()],
+            dictionary,
+        });
+    }
+    toJSON() {
+        return {
+            aliases: this.aliases.map((alias) => alias.toJSON()),
+            objects: this.objects.map((object) => object.toJSON()),
+            arrays: this.arrays.map((array) => array.toJSON()),
+            tuples: this.tuples.map((tuple) => tuple.toJSON()),
+        };
+    }
+}
+
+export { MetadataComponents };
+//# sourceMappingURL=MetadataComponents.mjs.map

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

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

package/lib/schemas/metadata/MetadataConstant.mjs

@@ -0,0 +1,28 @@
+import { MetadataConstantValue } from './MetadataConstantValue.mjs';
+
+class MetadataConstant {
+    type;
+    values;
+    constructor(props) {
+        this.type = props.type;
+        this.values = props.values.map(MetadataConstantValue.create);
+    }
+    static create(props) {
+        return new MetadataConstant(props);
+    }
+    static from(json) {
+        return MetadataConstant.create({
+            type: json.type,
+            values: json.values.map(MetadataConstantValue.from),
+        });
+    }
+    toJSON() {
+        return {
+            type: this.type,
+            values: this.values.map((value) => value.toJSON()),
+        };
+    }
+}
+
+export { MetadataConstant };
+//# sourceMappingURL=MetadataConstant.mjs.map

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

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

package/lib/schemas/metadata/MetadataConstantValue.mjs

@@ -0,0 +1,50 @@
+class MetadataConstantValue {
+    value;
+    tags;
+    description;
+    jsDocTags;
+    name_;
+    constructor(props) {
+        this.value = props.value;
+        this.tags = props.tags;
+        this.description = props.description;
+        this.jsDocTags = props.jsDocTags;
+    }
+    static create(props) {
+        return new MetadataConstantValue(props);
+    }
+    static from(json) {
+        return MetadataConstantValue.create({
+            value: typeof json.value === "bigint" ? BigInt(json.value) : json.value,
+            tags: json.tags,
+            description: json.description,
+            jsDocTags: json.jsDocTags,
+        });
+    }
+    getName() {
+        return (this.name_ ??= getName(this));
+    }
+    toJSON() {
+        return {
+            value: typeof this.value === "bigint" ? this.value.toString() : this.value,
+            tags: this.tags,
+            description: this.description,
+            jsDocTags: this.jsDocTags,
+        };
+    }
+}
+const getName = (obj) => {
+    const base = typeof obj.value === "string"
+        ? JSON.stringify(obj.value)
+        : obj.value.toString();
+    if (!obj.tags?.length)
+        return base;
+    const rows = obj.tags.map((row) => {
+        const str = row.map((t) => t.name).join(" & ");
+        return row.length === 1 ? str : `(${str})`;
+    });
+    return `(${base} & (${rows.join(" | ")}))`;
+};
+
+export { MetadataConstantValue };
+//# sourceMappingURL=MetadataConstantValue.mjs.map

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

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

package/lib/schemas/metadata/MetadataEscaped.mjs

@@ -0,0 +1,40 @@
+import { Metadata } from './Metadata.mjs';
+
+class MetadataEscaped {
+    original;
+    returns;
+    /**
+     * @hidden
+     */
+    constructor(props) {
+        this.original = props.original;
+        this.returns = props.returns;
+    }
+    /**
+     * @internal
+     */
+    static from(props, dict) {
+        return MetadataEscaped.create({
+            original: Metadata.from(props.original, dict),
+            returns: Metadata.from(props.returns, dict),
+        });
+    }
+    /**
+     * @internal
+     */
+    static create(props) {
+        return new MetadataEscaped(props);
+    }
+    getName() {
+        return this.returns.getName();
+    }
+    toJSON() {
+        return {
+            original: this.original.toJSON(),
+            returns: this.returns.toJSON(),
+        };
+    }
+}
+
+export { MetadataEscaped };
+//# sourceMappingURL=MetadataEscaped.mjs.map

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

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

package/lib/schemas/metadata/MetadataFunction.mjs

@@ -0,0 +1,39 @@
+import { Metadata } from './Metadata.mjs';
+import { MetadataParameter } from './MetadataParameter.mjs';
+
+class MetadataFunction {
+    parameters;
+    output;
+    async;
+    /**
+     * @hidden
+     */
+    constructor(props) {
+        this.parameters = props.parameters;
+        this.output = props.output;
+        this.async = props.async;
+    }
+    /**
+     * @internal
+     */
+    static create(props) {
+        return new MetadataFunction(props);
+    }
+    static from(json, dict) {
+        return MetadataFunction.create({
+            parameters: json.parameters.map((p) => MetadataParameter.from(p, dict)),
+            output: Metadata.from(json.output, dict),
+            async: json.async,
+        });
+    }
+    toJSON() {
+        return {
+            parameters: this.parameters.map((p) => p.toJSON()),
+            output: this.output.toJSON(),
+            async: this.async,
+        };
+    }
+}
+
+export { MetadataFunction };
+//# sourceMappingURL=MetadataFunction.mjs.map

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

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

package/lib/schemas/metadata/MetadataMap.mjs

@@ -0,0 +1,40 @@
+class MetadataMap {
+    key;
+    value;
+    tags;
+    name_;
+    constructor(props) {
+        this.key = props.key;
+        this.value = props.value;
+        this.tags = props.tags;
+    }
+    static create(props) {
+        return new MetadataMap(props);
+    }
+    getName() {
+        return (this.name_ ??= (() => {
+            const symbol = `Map<${this.key.getName()}, ${this.value.getName()}>`;
+            if (this.tags.length === 0)
+                return symbol;
+            else if (this.tags.length === 1) {
+                const str = [symbol, ...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 `(${symbol} & (${rows.join(" | ")}))`;
+        })());
+    }
+    toJSON() {
+        return {
+            key: this.key.toJSON(),
+            value: this.value.toJSON(),
+            tags: this.tags,
+        };
+    }
+}
+
+export { MetadataMap };
+//# sourceMappingURL=MetadataMap.mjs.map

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

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

package/lib/schemas/metadata/MetadataNative.mjs

@@ -0,0 +1,39 @@
+class MetadataNative {
+    name;
+    tags;
+    typeName_;
+    constructor(props) {
+        this.name = props.name;
+        this.tags = props.tags;
+    }
+    static create(props) {
+        return new MetadataNative(props);
+    }
+    getName() {
+        return (this.typeName_ ??= (() => {
+            if (this.tags.length === 0)
+                return this.name;
+            else if (this.tags.length === 1) {
+                const str = [
+                    this.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.name} & (${rows.join(" | ")}))`;
+        })());
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            tags: this.tags,
+        };
+    }
+}
+
+export { MetadataNative };
+//# sourceMappingURL=MetadataNative.mjs.map

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

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

package/lib/schemas/metadata/MetadataObject.mjs

@@ -0,0 +1,42 @@
+class MetadataObject {
+    type;
+    tags;
+    name_;
+    /**
+     * @hidden
+     */
+    constructor(props) {
+        this.type = props.type;
+        this.tags = props.tags;
+    }
+    static create(props) {
+        return new MetadataObject(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.map((row) => row.slice()),
+        };
+    }
+}
+
+export { MetadataObject };
+//# sourceMappingURL=MetadataObject.mjs.map

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

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

package/lib/schemas/metadata/MetadataObjectType.mjs

@@ -0,0 +1,101 @@
+class MetadataObjectType {
+    name;
+    properties;
+    description;
+    jsDocTags;
+    index;
+    validated;
+    recursive;
+    nullables = [];
+    /**
+     * @internal
+     */
+    tagged_ = false;
+    /**
+     * @internal
+     */
+    literal_;
+    /* -----------------------------------------------------------
+          CONSTRUCTORS
+      ----------------------------------------------------------- */
+    /**
+     * @hidden
+     */
+    constructor(props) {
+        this.name = props.name;
+        this.properties = props.properties;
+        this.description = props.description;
+        this.jsDocTags = props.jsDocTags;
+        this.index = props.index;
+        this.validated = props.validated;
+        this.recursive = props.recursive;
+        this.nullables = props.nullables.slice();
+        this.tagged_ = false;
+    }
+    /**
+     * @internal
+     */
+    static create(props) {
+        return new MetadataObjectType(props);
+    }
+    /**
+     * @internal
+     */
+    static _From_without_properties(obj) {
+        return MetadataObjectType.create({
+            name: obj.name,
+            properties: [],
+            description: obj.description,
+            jsDocTags: obj.jsDocTags,
+            index: obj.index,
+            validated: false,
+            recursive: obj.recursive,
+            nullables: obj.nullables.slice(),
+        });
+    }
+    isPlain(level = 0) {
+        return (this.recursive === false &&
+            this.properties.length < 10 &&
+            this.properties.every((property) => property.key.isSoleLiteral() &&
+                property.value.size() === 1 &&
+                property.value.isRequired() === true &&
+                property.value.nullable === false &&
+                (property.value.atomics.length === 1 ||
+                    (level < 1 &&
+                        property.value.objects.length === 1 &&
+                        property.value.objects[0].type.isPlain(level + 1)))));
+    }
+    isLiteral() {
+        return (this.literal_ ??= (() => {
+            if (this.recursive === true)
+                return false;
+            return (this.name === "__type" ||
+                this.name === "__object" ||
+                this.name.startsWith("__type.") ||
+                this.name.startsWith("__object.") ||
+                this.name.includes("readonly ["));
+        })());
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            properties: this.properties.map((property) => property.toJSON()),
+            description: this.description,
+            jsDocTags: this.jsDocTags,
+            index: this.index,
+            recursive: this.recursive,
+            nullables: this.nullables.slice(),
+        };
+    }
+}
+/**
+ * @internal
+ */
+(function (MetadataObjectType) {
+    MetadataObjectType.intersects = (x, y) => x.properties.some((prop) => y.properties.find((oppo) => prop.key.getName() === oppo.key.getName()) !== undefined);
+    MetadataObjectType.covers = (x, y) => x.properties.length >= y.properties.length &&
+        x.properties.every((prop) => y.properties.find((oppo) => prop.key.getName() === oppo.key.getName()) !== undefined);
+})(MetadataObjectType || (MetadataObjectType = {}));
+
+export { MetadataObjectType };
+//# sourceMappingURL=MetadataObjectType.mjs.map

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

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