typia 8.0.0 → 8.0.1

package/lib/programmers/internal/json_schema_boolean.mjs.map

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

package/lib/programmers/internal/json_schema_constant.mjs

@@ -0,0 +1,19 @@
+import { json_schema_description } from './json_schema_description.mjs';
+import { json_schema_plugin } from './json_schema_plugin.mjs';
+import { json_schema_title } from './json_schema_title.mjs';
+
+const json_schema_constant = (constant) => constant.values
+    .map((value) => json_schema_plugin({
+    schema: {
+        const: typeof value.value === "bigint"
+            ? Number(value.value)
+            : value.value,
+        title: json_schema_title(value),
+        description: json_schema_description(value),
+    },
+    tags: value.tags ?? [],
+}))
+    .flat();
+
+export { json_schema_constant };
+//# sourceMappingURL=json_schema_constant.mjs.map

package/lib/programmers/internal/json_schema_constant.mjs.map

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

package/lib/programmers/internal/json_schema_description.mjs

@@ -0,0 +1,9 @@
+const json_schema_description = (props) => props.jsDocTags
+    ?.find((tag) => tag.name === "description")
+    ?.text?.[0]?.text?.split("\r\n")
+    .join("\n") ??
+    props.description ??
+    undefined;
+
+export { json_schema_description };
+//# sourceMappingURL=json_schema_description.mjs.map

package/lib/programmers/internal/json_schema_description.mjs.map

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

package/lib/programmers/internal/json_schema_discriminator.mjs

@@ -0,0 +1,24 @@
+import { UnionPredicator } from '../helpers/UnionPredicator.mjs';
+
+const json_schema_discriminator = (metadata) => {
+    if (metadata.size() === 0 ||
+        metadata.size() !== metadata.objects.length ||
+        metadata.objects.some((o) => o.type.isLiteral()) === true)
+        return undefined;
+    const specialized = UnionPredicator.object(metadata.objects.map((o) => o.type));
+    const meet = specialized.length === metadata.objects.length &&
+        specialized.every((s) => s.property.key.isSoleLiteral() && s.property.value.isSoleLiteral()) &&
+        new Set(specialized.map((s) => s.property.key.getSoleLiteral())).size === 1;
+    if (meet === false)
+        return undefined;
+    return {
+        propertyName: specialized[0].property.key.getSoleLiteral(),
+        mapping: Object.fromEntries(specialized.map((s) => [
+            s.property.value.getSoleLiteral(),
+            `#/components/schemas/${s.object.name}`,
+        ])),
+    };
+};
+
+export { json_schema_discriminator };
+//# sourceMappingURL=json_schema_discriminator.mjs.map

package/lib/programmers/internal/json_schema_discriminator.mjs.map

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

package/lib/programmers/internal/json_schema_escaped.mjs

@@ -0,0 +1,57 @@
+import { OpenApiTypeChecker } from '@samchon/openapi';
+import { json_schema_station } from './json_schema_station.mjs';
+
+/**
+ * @internal
+ */
+const json_schema_escaped = (props) => {
+    const output = json_schema_station({
+        blockNever: false,
+        components: props.components,
+        metadata: props.escaped.returns,
+        attribute: {},
+    });
+    if (output === null)
+        return [];
+    if (is_date({
+        visited: new Set(),
+        metadata: props.escaped.original,
+    })) {
+        const string = OpenApiTypeChecker.isString(output)
+            ? output
+            : OpenApiTypeChecker.isOneOf(output)
+                ? output.oneOf.find(OpenApiTypeChecker.isString)
+                : undefined;
+        if (string !== undefined &&
+            string.format !== "date" &&
+            string.format !== "date-time")
+            string.format = "date-time";
+    }
+    return OpenApiTypeChecker.isOneOf(output)
+        ? output.oneOf
+        : [output];
+};
+/**
+ * @internal
+ */
+const is_date = (props) => {
+    if (props.visited.has(props.metadata))
+        return false;
+    props.visited.add(props.metadata);
+    return (props.metadata.natives.some((native) => native.name === "Date") ||
+        props.metadata.arrays.some((array) => is_date({
+            visited: props.visited,
+            metadata: array.type.value,
+        })) ||
+        props.metadata.tuples.some((tuple) => tuple.type.elements.some((e) => is_date({
+            visited: props.visited,
+            metadata: e,
+        }))) ||
+        props.metadata.aliases.some((alias) => is_date({
+            visited: props.visited,
+            metadata: alias.type.value,
+        })));
+};
+
+export { json_schema_escaped };
+//# sourceMappingURL=json_schema_escaped.mjs.map

package/lib/programmers/internal/json_schema_escaped.mjs.map

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

package/lib/programmers/internal/json_schema_native.mjs

@@ -0,0 +1,29 @@
+import { json_schema_plugin } from './json_schema_plugin.mjs';
+
+const json_schema_native = (props) => {
+    if (props.native.name === "Blob" || props.native.name === "File")
+        return json_schema_plugin({
+            schema: {
+                type: "string",
+                format: "binary",
+            },
+            tags: props.native.tags,
+        });
+    if (props.components.schemas?.[props.native.name] === undefined) {
+        props.components.schemas ??= {};
+        props.components.schemas[props.native.name] ??= {
+            type: "object",
+            properties: {},
+            required: [],
+        };
+    }
+    return json_schema_plugin({
+        schema: {
+            $ref: `#/components/schemas/${props.native.name}`,
+        },
+        tags: props.native.tags,
+    });
+};
+
+export { json_schema_native };
+//# sourceMappingURL=json_schema_native.mjs.map

package/lib/programmers/internal/json_schema_native.mjs.map

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

package/lib/programmers/internal/json_schema_number.mjs

@@ -0,0 +1,11 @@
+import { json_schema_plugin } from './json_schema_plugin.mjs';
+
+const json_schema_number = (atomic) => json_schema_plugin({
+    schema: {
+        type: "number",
+    },
+    tags: atomic.tags,
+});
+
+export { json_schema_number };
+//# sourceMappingURL=json_schema_number.mjs.map

package/lib/programmers/internal/json_schema_number.mjs.map

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

package/lib/programmers/internal/json_schema_object.mjs

@@ -0,0 +1,122 @@
+import { CommentFactory } from '../../factories/CommentFactory.mjs';
+import { Metadata } from '../../schemas/metadata/Metadata.mjs';
+import { PatternUtil } from '../../utils/PatternUtil.mjs';
+import { json_schema_description } from './json_schema_description.mjs';
+import { json_schema_plugin } from './json_schema_plugin.mjs';
+import { json_schema_station } from './json_schema_station.mjs';
+import { json_schema_title } from './json_schema_title.mjs';
+import { metadata_to_pattern } from './metadata_to_pattern.mjs';
+
+/**
+ * @internal
+ */
+const json_schema_object = (props) => json_schema_plugin({
+    schema: emplace_object(props),
+    tags: props.object.tags,
+});
+const emplace_object = (props) => {
+    if (props.object.type.isLiteral() === true)
+        return create_object_schema(props);
+    const key = props.object.type.name;
+    const $ref = `#/components/schemas/${key}`;
+    if (props.components.schemas?.[key] !== undefined)
+        return { $ref };
+    const lazy = {};
+    props.components.schemas ??= {};
+    props.components.schemas[key] = lazy;
+    Object.assign(lazy, create_object_schema(props));
+    return { $ref };
+};
+/**
+ * @internal
+ */
+const create_object_schema = (props) => {
+    // ITERATE PROPERTIES
+    const properties = {};
+    const extraMeta = {
+        patternProperties: {},
+        additionalProperties: undefined,
+    };
+    const required = [];
+    for (const property of props.object.type.properties) {
+        if (
+        // FUNCTIONAL TYPE
+        property.value.functions.length &&
+            property.value.nullable === false &&
+            property.value.isRequired() === true &&
+            property.value.size() === 0)
+            continue;
+        else if (property.jsDocTags.find((tag) => tag.name === "hidden"))
+            continue; // THE HIDDEN TAG
+        const key = property.key.getSoleLiteral();
+        const schema = json_schema_station({
+            blockNever: true,
+            components: props.components,
+            attribute: {
+                deprecated: property.jsDocTags.some((tag) => tag.name === "deprecated") ||
+                    undefined,
+                title: json_schema_title(property),
+                description: json_schema_description(property),
+            },
+            metadata: property.value,
+        });
+        if (schema === null)
+            continue;
+        if (key !== null) {
+            properties[key] = schema;
+            if (property.value.isRequired() === true)
+                required.push(key);
+        }
+        else {
+            const pattern = metadata_to_pattern({
+                top: true,
+                metadata: property.key,
+            });
+            if (pattern === PatternUtil.STRING)
+                extraMeta.additionalProperties = [property.value, schema];
+            else
+                extraMeta.patternProperties[pattern] = [property.value, schema];
+        }
+    }
+    return {
+        type: "object",
+        properties,
+        required,
+        title: (() => {
+            const info = props.object.type.jsDocTags.find((tag) => tag.name === "title");
+            return info?.text?.length ? CommentFactory.merge(info.text) : undefined;
+        })(),
+        description: json_schema_description(props.object.type),
+        additionalProperties: join({
+            components: props.components,
+            extra: extraMeta,
+        }),
+    };
+};
+/**
+ * @internal
+ */
+const join = (props) => {
+    // LIST UP METADATA
+    const elements = Object.values(props.extra.patternProperties || {});
+    if (props.extra.additionalProperties)
+        elements.push(props.extra.additionalProperties);
+    // SHORT RETURN
+    if (elements.length === 0)
+        return undefined;
+    else if (elements.length === 1)
+        return elements[0][1];
+    // MERGE METADATA AND GENERATE VULNERABLE SCHEMA
+    const metadata = elements
+        .map((tuple) => tuple[0])
+        .reduce((x, y) => Metadata.merge(x, y));
+    return (json_schema_station({
+        blockNever: true,
+        components: props.components,
+        attribute: {},
+        metadata,
+    }) ?? undefined);
+};
+
+export { json_schema_object };
+//# sourceMappingURL=json_schema_object.mjs.map

package/lib/programmers/internal/json_schema_object.mjs.map

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

package/lib/programmers/internal/json_schema_plugin.mjs

@@ -0,0 +1,16 @@
+const json_schema_plugin = (props) => {
+    const plugins = props.tags
+        .map((row) => row.filter((t) => t.schema !== undefined))
+        .filter((row) => row.length !== 0);
+    if (plugins.length === 0)
+        return [props.schema];
+    return plugins.map((row) => {
+        const base = { ...props.schema };
+        for (const tag of row)
+            Object.assign(base, tag.schema);
+        return base;
+    });
+};
+
+export { json_schema_plugin };
+//# sourceMappingURL=json_schema_plugin.mjs.map

package/lib/programmers/internal/json_schema_plugin.mjs.map

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

package/lib/programmers/internal/json_schema_station.mjs

@@ -0,0 +1,157 @@
+import { MetadataAtomic } from '../../schemas/metadata/MetadataAtomic.mjs';
+import { MetadataNative } from '../../schemas/metadata/MetadataNative.mjs';
+import { AtomicPredicator } from '../helpers/AtomicPredicator.mjs';
+import { json_schema_alias } from './json_schema_alias.mjs';
+import { json_schema_array } from './json_schema_array.mjs';
+import { json_schema_bigint } from './json_schema_bigint.mjs';
+import { json_schema_boolean } from './json_schema_boolean.mjs';
+import { json_schema_constant } from './json_schema_constant.mjs';
+import { json_schema_discriminator } from './json_schema_discriminator.mjs';
+import { json_schema_escaped } from './json_schema_escaped.mjs';
+import { json_schema_native } from './json_schema_native.mjs';
+import { json_schema_number } from './json_schema_number.mjs';
+import { json_schema_object } from './json_schema_object.mjs';
+import { json_schema_string } from './json_schema_string.mjs';
+import { json_schema_templates } from './json_schema_template.mjs';
+import { json_schema_tuple } from './json_schema_tuple.mjs';
+
+const json_schema_station = (props) => {
+    if (props.metadata.any === true)
+        return {
+            ...props.attribute,
+            type: undefined,
+        };
+    //----
+    // GATHER UNION SCHEMAS
+    //----
+    const union = [];
+    const insert = (schema) => union.push(schema);
+    // NULLABLE
+    if (props.metadata.nullable === true)
+        insert({
+            type: "null",
+        });
+    // toJSON() METHOD
+    if (props.metadata.escaped !== null)
+        json_schema_escaped({
+            components: props.components,
+            escaped: props.metadata.escaped,
+        }).forEach(insert);
+    // ATOMIC TYPES
+    if (props.metadata.templates.length &&
+        AtomicPredicator.template(props.metadata))
+        json_schema_templates(props.metadata).forEach(insert);
+    for (const constant of props.metadata.constants)
+        if (AtomicPredicator.constant({
+            metadata: props.metadata,
+            name: constant.type,
+        }) === false)
+            continue;
+        else
+            json_schema_constant(constant).forEach(insert);
+    for (const a of props.metadata.atomics)
+        if (a.type === "boolean")
+            json_schema_boolean(a).forEach(insert);
+        else if (a.type === "bigint")
+            json_schema_bigint(a).forEach(insert);
+        else if (a.type === "number")
+            json_schema_number(a).forEach(insert);
+        else if (a.type === "string")
+            json_schema_string(a).forEach(insert);
+    // ARRAY
+    for (const array of props.metadata.arrays)
+        json_schema_array({
+            components: props.components,
+            array,
+        }).forEach(insert);
+    // TUPLE
+    for (const tuple of props.metadata.tuples)
+        insert(json_schema_tuple({
+            components: props.components,
+            tuple,
+        }));
+    // NATIVES
+    for (const native of props.metadata.natives)
+        if (AtomicPredicator.native(native.name)) {
+            const type = native.name.toLowerCase();
+            if (props.metadata.atomics.some((a) => a.type === type))
+                continue;
+            else if (type === "boolean")
+                json_schema_boolean(MetadataAtomic.create({
+                    type: "boolean",
+                    tags: [],
+                })).map(insert);
+            else if (type === "bigint")
+                json_schema_bigint(MetadataAtomic.create({
+                    type: "bigint",
+                    tags: [],
+                })).map(insert);
+            else if (type === "number")
+                json_schema_number(MetadataAtomic.create({
+                    type: "number",
+                    tags: [],
+                })).map(insert);
+            else if (type === "string")
+                json_schema_string(MetadataAtomic.create({
+                    type: "string",
+                    tags: [],
+                })).map(insert);
+        }
+        else
+            json_schema_native({
+                components: props.components,
+                native,
+            }).forEach(insert);
+    if (props.metadata.sets.length)
+        json_schema_native({
+            native: MetadataNative.create({
+                name: "Set",
+                tags: [],
+            }),
+            components: props.components,
+        }).forEach(insert);
+    if (props.metadata.maps.length)
+        json_schema_native({
+            native: MetadataNative.create({
+                name: "Map",
+                tags: [],
+            }),
+            components: props.components,
+        }).forEach(insert);
+    // OBJECT
+    for (const object of props.metadata.objects)
+        json_schema_object({
+            components: props.components,
+            object,
+        }).forEach(insert);
+    // ALIASES
+    for (const alias of props.metadata.aliases)
+        json_schema_alias({
+            alias,
+            blockNever: props.blockNever,
+            components: props.components,
+        }).forEach(insert);
+    //----
+    // RETURNS
+    //----
+    if (union.length === 0 && props.blockNever === true)
+        return null;
+    const schema = union.length === 0
+        ? { type: undefined }
+        : union.length === 1
+            ? union[0]
+            : {
+                oneOf: union,
+                discriminator: json_schema_discriminator(props.metadata),
+            };
+    return {
+        ...schema,
+        ...props.attribute,
+        title: props.attribute.title ?? schema.title,
+        description: props.attribute.description ?? schema.description,
+        deprecated: props.attribute.deprecated ?? schema.deprecated,
+    };
+};
+
+export { json_schema_station };
+//# sourceMappingURL=json_schema_station.mjs.map

package/lib/programmers/internal/json_schema_station.mjs.map

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

package/lib/programmers/internal/json_schema_string.mjs

@@ -0,0 +1,11 @@
+import { json_schema_plugin } from './json_schema_plugin.mjs';
+
+const json_schema_string = (atomic) => json_schema_plugin({
+    schema: {
+        type: "string",
+    },
+    tags: atomic.tags,
+});
+
+export { json_schema_string };
+//# sourceMappingURL=json_schema_string.mjs.map

package/lib/programmers/internal/json_schema_string.mjs.map

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

package/lib/programmers/internal/json_schema_template.mjs

@@ -0,0 +1,40 @@
+import { Metadata } from '../../schemas/metadata/Metadata.mjs';
+import { json_schema_plugin } from './json_schema_plugin.mjs';
+import { metadata_to_pattern } from './metadata_to_pattern.mjs';
+
+const json_schema_templates = (metadata) => {
+    const pureTemplates = metadata.templates.filter((t) => isPure(t.tags ?? []) === true);
+    const taggedTemplates = metadata.templates.filter((t) => isPure(t.tags ?? []) === false);
+    const output = [];
+    if (pureTemplates.length)
+        output.push({
+            type: "string",
+            pattern: metadata_to_pattern({
+                top: true,
+                metadata: Metadata.create({
+                    ...Metadata.initialize(),
+                    templates: pureTemplates,
+                }),
+            }),
+        });
+    for (const tpl of taggedTemplates)
+        output.push(...json_schema_plugin({
+            schema: {
+                type: "string",
+                pattern: metadata_to_pattern({
+                    top: false,
+                    metadata: Metadata.create({
+                        ...Metadata.initialize(),
+                        templates: [tpl],
+                    }),
+                }),
+            },
+            tags: tpl.tags ?? [],
+        }));
+    return output;
+};
+const isPure = (matrix) => matrix.every((tags) => filter(tags).length === 0);
+const filter = (tags) => tags.filter((t) => t.schema !== undefined);
+
+export { json_schema_templates };
+//# sourceMappingURL=json_schema_template.mjs.map

package/lib/programmers/internal/json_schema_template.mjs.map

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

package/lib/programmers/internal/json_schema_title.mjs

@@ -0,0 +1,15 @@
+import { CommentFactory } from '../../factories/CommentFactory.mjs';
+
+const json_schema_title = (schema) => {
+    const info = schema.jsDocTags?.find((tag) => tag.name === "title");
+    if (info?.text?.length)
+        return CommentFactory.merge(info.text);
+    else if (!schema.description?.length)
+        return undefined;
+    const index = schema.description.indexOf("\n");
+    const top = (index === -1 ? schema.description : schema.description.substring(0, index)).trim();
+    return top.endsWith(".") ? top.substring(0, top.length - 1) : undefined;
+};
+
+export { json_schema_title };
+//# sourceMappingURL=json_schema_title.mjs.map

package/lib/programmers/internal/json_schema_title.mjs.map

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

package/lib/programmers/internal/json_schema_tuple.mjs

@@ -0,0 +1,28 @@
+import { json_schema_station } from './json_schema_station.mjs';
+
+const json_schema_tuple = (props) => {
+    const tail = props.tuple.type.elements.at(-1)?.rest ?? null;
+    const prefixItems = props.tuple.type.isRest()
+        ? props.tuple.type.elements.slice(0, -1)
+        : props.tuple.type.elements;
+    return {
+        type: "array",
+        prefixItems: prefixItems.map((metadata) => json_schema_station({
+            blockNever: false,
+            components: props.components,
+            metadata,
+            attribute: {},
+        })),
+        additionalItems: tail
+            ? json_schema_station({
+                blockNever: false,
+                components: props.components,
+                metadata: tail,
+                attribute: {},
+            })
+            : false,
+    };
+};
+
+export { json_schema_tuple };
+//# sourceMappingURL=json_schema_tuple.mjs.map

package/lib/programmers/internal/json_schema_tuple.mjs.map

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

package/lib/programmers/internal/metadata_to_pattern.mjs

@@ -0,0 +1,34 @@
+import { PatternUtil } from '../../utils/PatternUtil.mjs';
+import { template_to_pattern } from './template_to_pattern.mjs';
+
+/**
+ * @internal
+ */
+const metadata_to_pattern = (props) => {
+    if (props.metadata.atomics.find((a) => a.type === "string") !== undefined)
+        return "(.*)";
+    const values = props.metadata.constants
+        .map((c) => {
+        if (c.type !== "string")
+            return c.values.map((v) => v.toString());
+        return c.values.map((v) => v.value).map((str) => PatternUtil.escape(str));
+    })
+        .flat();
+    for (const a of props.metadata.atomics)
+        if (a.type === "number" || a.type === "bigint")
+            values.push(PatternUtil.NUMBER);
+        else if (a.type === "boolean")
+            values.push(PatternUtil.BOOLEAN);
+    for (const { row } of props.metadata.templates)
+        values.push("(" +
+            template_to_pattern({
+                top: false,
+                template: row,
+            }) +
+            ")");
+    const pattern = values.length === 1 ? values[0] : "(" + values.join("|") + ")";
+    return props.top ? PatternUtil.fix(pattern) : pattern;
+};
+
+export { metadata_to_pattern };
+//# sourceMappingURL=metadata_to_pattern.mjs.map

package/lib/programmers/internal/metadata_to_pattern.mjs.map

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

package/lib/programmers/internal/postfix_of_tuple.mjs

@@ -0,0 +1,7 @@
+/**
+ * @internal
+ */
+const postfix_of_tuple = (str) => str.endsWith('"') ? str.slice(0, -1) : `${str} + "`;
+
+export { postfix_of_tuple };
+//# sourceMappingURL=postfix_of_tuple.mjs.map

package/lib/programmers/internal/postfix_of_tuple.mjs.map

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