typia 8.0.0 → 8.0.2-dev.20250314

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":""}

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":""}