@kubb/plugin-oas 3.16.2 → 3.16.4

package/dist/SchemaGenerator-B8Io6kky.js

@@ -0,0 +1,930 @@
+import { isKeyword, schemaKeywords } from "./SchemaMapper-BaZQKrQB.js";
+import { getSchemaFactory, getSchemas } from "./getSchemas-WoSBIxG8.js";
+import { BaseGenerator } from "@kubb/core";
+import transformers, { pascalCase } from "@kubb/core/transformers";
+import { isDeepEqual, isNumber, uniqueWith } from "remeda";
+import { getUniqueName } from "@kubb/core/utils";
+import { isDiscriminator, isNullable, isReference } from "@kubb/oas";
+
+//#region ../../node_modules/.pnpm/yocto-queue@1.2.1/node_modules/yocto-queue/index.js
+var Node = class {
+	value;
+	next;
+	constructor(value) {
+		this.value = value;
+	}
+};
+var Queue = class {
+	#head;
+	#tail;
+	#size;
+	constructor() {
+		this.clear();
+	}
+	enqueue(value) {
+		const node = new Node(value);
+		if (this.#head) {
+			this.#tail.next = node;
+			this.#tail = node;
+		} else {
+			this.#head = node;
+			this.#tail = node;
+		}
+		this.#size++;
+	}
+	dequeue() {
+		const current = this.#head;
+		if (!current) return;
+		this.#head = this.#head.next;
+		this.#size--;
+		return current.value;
+	}
+	peek() {
+		if (!this.#head) return;
+		return this.#head.value;
+	}
+	clear() {
+		this.#head = void 0;
+		this.#tail = void 0;
+		this.#size = 0;
+	}
+	get size() {
+		return this.#size;
+	}
+	*[Symbol.iterator]() {
+		let current = this.#head;
+		while (current) {
+			yield current.value;
+			current = current.next;
+		}
+	}
+	*drain() {
+		while (this.#head) yield this.dequeue();
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/p-limit@7.0.0/node_modules/p-limit/index.js
+function pLimit(concurrency) {
+	validateConcurrency(concurrency);
+	const queue = new Queue();
+	let activeCount = 0;
+	const resumeNext = () => {
+		if (activeCount < concurrency && queue.size > 0) {
+			activeCount++;
+			queue.dequeue()();
+		}
+	};
+	const next = () => {
+		activeCount--;
+		resumeNext();
+	};
+	const run = async (function_, resolve, arguments_) => {
+		const result = (async () => function_(...arguments_))();
+		resolve(result);
+		try {
+			await result;
+		} catch {}
+		next();
+	};
+	const enqueue = (function_, resolve, arguments_) => {
+		new Promise((internalResolve) => {
+			queue.enqueue(internalResolve);
+		}).then(run.bind(void 0, function_, resolve, arguments_));
+		if (activeCount < concurrency) resumeNext();
+	};
+	const generator = (function_, ...arguments_) => new Promise((resolve) => {
+		enqueue(function_, resolve, arguments_);
+	});
+	Object.defineProperties(generator, {
+		activeCount: { get: () => activeCount },
+		pendingCount: { get: () => queue.size },
+		clearQueue: { value() {
+			queue.clear();
+		} },
+		concurrency: {
+			get: () => concurrency,
+			set(newConcurrency) {
+				validateConcurrency(newConcurrency);
+				concurrency = newConcurrency;
+				queueMicrotask(() => {
+					while (activeCount < concurrency && queue.size > 0) resumeNext();
+				});
+			}
+		},
+		map: { async value(array, function_) {
+			const promises = array.map((value) => this(function_, value));
+			return Promise.all(promises);
+		} }
+	});
+	return generator;
+}
+function validateConcurrency(concurrency) {
+	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+}
+
+//#endregion
+//#region src/SchemaGenerator.ts
+var SchemaGenerator = class SchemaGenerator extends BaseGenerator {
+	refs = {};
+	#usedAliasNames = {};
+	/**
+	* Creates a type node from a given schema.
+	* Delegates to getBaseTypeFromSchema internally and
+	* optionally adds a union with null.
+	*/
+	parse(props) {
+		const options = this.#getOptions(props);
+		const defaultSchemas = this.#parseSchemaObject(props);
+		const schemas = options.transformers?.schema?.(props, defaultSchemas) || defaultSchemas || [];
+		return uniqueWith(schemas, isDeepEqual);
+	}
+	deepSearch(tree, keyword) {
+		return SchemaGenerator.deepSearch(tree, keyword);
+	}
+	find(tree, keyword) {
+		return SchemaGenerator.find(tree, keyword);
+	}
+	static deepSearch(tree, keyword) {
+		const foundItems = [];
+		tree?.forEach((schema) => {
+			if (schema.keyword === keyword) foundItems.push(schema);
+			if (isKeyword(schema, schemaKeywords.object)) {
+				Object.values(schema.args?.properties || {}).forEach((entrySchema) => {
+					foundItems.push(...SchemaGenerator.deepSearch(entrySchema, keyword));
+				});
+				Object.values(schema.args?.additionalProperties || {}).forEach((entrySchema) => {
+					foundItems.push(...SchemaGenerator.deepSearch([entrySchema], keyword));
+				});
+			}
+			if (isKeyword(schema, schemaKeywords.array)) schema.args.items.forEach((entrySchema) => {
+				foundItems.push(...SchemaGenerator.deepSearch([entrySchema], keyword));
+			});
+			if (isKeyword(schema, schemaKeywords.and)) schema.args.forEach((entrySchema) => {
+				foundItems.push(...SchemaGenerator.deepSearch([entrySchema], keyword));
+			});
+			if (isKeyword(schema, schemaKeywords.tuple)) schema.args.items.forEach((entrySchema) => {
+				foundItems.push(...SchemaGenerator.deepSearch([entrySchema], keyword));
+			});
+			if (isKeyword(schema, schemaKeywords.union)) schema.args.forEach((entrySchema) => {
+				foundItems.push(...SchemaGenerator.deepSearch([entrySchema], keyword));
+			});
+		});
+		return foundItems;
+	}
+	static findInObject(tree, keyword) {
+		let foundItem;
+		tree?.forEach((schema) => {
+			if (!foundItem && schema.keyword === keyword) foundItem = schema;
+			if (isKeyword(schema, schemaKeywords.object)) {
+				Object.values(schema.args?.properties || {}).forEach((entrySchema) => {
+					if (!foundItem) foundItem = SchemaGenerator.find(entrySchema, keyword);
+				});
+				Object.values(schema.args?.additionalProperties || {}).forEach((entrySchema) => {
+					if (!foundItem) foundItem = SchemaGenerator.find([entrySchema], keyword);
+				});
+			}
+		});
+		return foundItem;
+	}
+	static find(tree, keyword) {
+		let foundItem;
+		tree?.forEach((schema) => {
+			if (!foundItem && schema.keyword === keyword) foundItem = schema;
+			if (isKeyword(schema, schemaKeywords.array)) schema.args.items.forEach((entrySchema) => {
+				if (!foundItem) foundItem = SchemaGenerator.find([entrySchema], keyword);
+			});
+			if (isKeyword(schema, schemaKeywords.and)) schema.args.forEach((entrySchema) => {
+				if (!foundItem) foundItem = SchemaGenerator.find([entrySchema], keyword);
+			});
+			if (isKeyword(schema, schemaKeywords.tuple)) schema.args.items.forEach((entrySchema) => {
+				if (!foundItem) foundItem = SchemaGenerator.find([entrySchema], keyword);
+			});
+			if (isKeyword(schema, schemaKeywords.union)) schema.args.forEach((entrySchema) => {
+				if (!foundItem) foundItem = SchemaGenerator.find([entrySchema], keyword);
+			});
+		});
+		return foundItem;
+	}
+	static combineObjects(tree) {
+		if (!tree) return [];
+		return tree.map((schema) => {
+			if (!isKeyword(schema, schemaKeywords.and)) return schema;
+			let mergedProperties = null;
+			let mergedAdditionalProps = [];
+			const newArgs = [];
+			for (const subSchema of schema.args) if (isKeyword(subSchema, schemaKeywords.object)) {
+				const { properties = {}, additionalProperties = [] } = subSchema.args ?? {};
+				if (!mergedProperties) mergedProperties = {};
+				for (const [key, value] of Object.entries(properties)) mergedProperties[key] = value;
+				if (additionalProperties.length > 0) mergedAdditionalProps = additionalProperties;
+			} else newArgs.push(subSchema);
+			if (mergedProperties) newArgs.push({
+				keyword: schemaKeywords.object,
+				args: {
+					properties: mergedProperties,
+					additionalProperties: mergedAdditionalProps
+				}
+			});
+			return {
+				keyword: schemaKeywords.and,
+				args: newArgs
+			};
+		});
+	}
+	#getUsedEnumNames(props) {
+		const options = this.#getOptions(props);
+		return options.usedEnumNames || {};
+	}
+	#getOptions({ name }) {
+		const { override = [] } = this.context;
+		return {
+			...this.options,
+			...override.find(({ pattern, type }) => {
+				if (name && type === "schemaName") return !!name.match(pattern);
+				return false;
+			})?.options || {}
+		};
+	}
+	#getUnknownType(props) {
+		const options = this.#getOptions(props);
+		if (options.unknownType === "any") return schemaKeywords.any;
+		if (options.unknownType === "void") return schemaKeywords.void;
+		return schemaKeywords.unknown;
+	}
+	#getEmptyType(props) {
+		const options = this.#getOptions(props);
+		if (options.emptySchemaType === "any") return schemaKeywords.any;
+		if (options.emptySchemaType === "void") return schemaKeywords.void;
+		return schemaKeywords.unknown;
+	}
+	/**
+	* Recursively creates a type literal with the given props.
+	*/
+	#parseProperties({ schemaObject, name }) {
+		const properties = schemaObject?.properties || {};
+		const additionalProperties = schemaObject?.additionalProperties;
+		const required = schemaObject?.required;
+		const propertiesSchemas = Object.keys(properties).map((propertyName) => {
+			const validationFunctions = [];
+			const propertySchema = properties[propertyName];
+			const isRequired = Array.isArray(required) ? required?.includes(propertyName) : !!required;
+			const nullable = propertySchema.nullable ?? propertySchema["x-nullable"] ?? false;
+			validationFunctions.push(...this.parse({
+				schemaObject: propertySchema,
+				name: propertyName,
+				parentName: name
+			}));
+			validationFunctions.push({
+				keyword: schemaKeywords.name,
+				args: propertyName
+			});
+			if (!isRequired && nullable) validationFunctions.push({ keyword: schemaKeywords.nullish });
+			else if (!isRequired) validationFunctions.push({ keyword: schemaKeywords.optional });
+			return { [propertyName]: validationFunctions };
+		}).reduce((acc, curr) => ({
+			...acc,
+			...curr
+		}), {});
+		let additionalPropertiesSchemas = [];
+		if (additionalProperties) additionalPropertiesSchemas = additionalProperties === true || !Object.keys(additionalProperties).length ? [{ keyword: this.#getUnknownType({
+			schemaObject,
+			name
+		}) }] : this.parse({
+			schemaObject: additionalProperties,
+			parentName: name
+		});
+		return [{
+			keyword: schemaKeywords.object,
+			args: {
+				properties: propertiesSchemas,
+				additionalProperties: additionalPropertiesSchemas
+			}
+		}];
+	}
+	/**
+	* Create a type alias for the schema referenced by the given ReferenceObject
+	*/
+	#getRefAlias(schemaObject, name) {
+		const { $ref } = schemaObject;
+		const ref = this.refs[$ref];
+		if (ref) {
+			const dereferencedSchema = this.context.oas.dereferenceWithRef(schemaObject);
+			if (dereferencedSchema && isDiscriminator(dereferencedSchema)) {
+				const [key] = Object.entries(dereferencedSchema.discriminator.mapping || {}).find(([_key, value]) => value.replace(/.+\//, "") === name) || [];
+				if (key) return [{
+					keyword: schemaKeywords.and,
+					args: [{
+						keyword: schemaKeywords.ref,
+						args: {
+							name: ref.propertyName,
+							$ref,
+							path: ref.path,
+							isImportable: !!this.context.oas.get($ref)
+						}
+					}, {
+						keyword: schemaKeywords.object,
+						args: { properties: { [dereferencedSchema.discriminator.propertyName]: [{
+							keyword: schemaKeywords.const,
+							args: {
+								name: key,
+								format: "string",
+								value: key
+							}
+						}] } }
+					}]
+				}];
+			}
+			return [{
+				keyword: schemaKeywords.ref,
+				args: {
+					name: ref.propertyName,
+					$ref,
+					path: ref.path,
+					isImportable: !!this.context.oas.get($ref)
+				}
+			}];
+		}
+		const originalName = getUniqueName($ref.replace(/.+\//, ""), this.#usedAliasNames);
+		const propertyName = this.context.pluginManager.resolveName({
+			name: originalName,
+			pluginKey: this.context.plugin.key,
+			type: "function"
+		});
+		const fileName = this.context.pluginManager.resolveName({
+			name: originalName,
+			pluginKey: this.context.plugin.key,
+			type: "file"
+		});
+		const file = this.context.pluginManager.getFile({
+			name: fileName,
+			pluginKey: this.context.plugin.key,
+			extname: ".ts"
+		});
+		this.refs[$ref] = {
+			propertyName,
+			originalName,
+			path: file.path
+		};
+		return this.#getRefAlias(schemaObject, name);
+	}
+	#getParsedSchemaObject(schema) {
+		return getSchemaFactory(this.context.oas)(schema);
+	}
+	#addDiscriminatorToSchema({ schema, schemaObject, discriminator }) {
+		if (!isKeyword(schema, schemaKeywords.union)) return schema;
+		const objectPropertySchema = SchemaGenerator.find(this.parse({ schemaObject }), schemaKeywords.object);
+		return {
+			...schema,
+			args: Object.entries(discriminator.mapping || {}).map(([key, value]) => {
+				const arg = schema.args.find((item) => isKeyword(item, schemaKeywords.ref) && item.args.$ref === value);
+				return {
+					keyword: schemaKeywords.and,
+					args: [arg, {
+						keyword: schemaKeywords.object,
+						args: { properties: {
+							...objectPropertySchema?.args?.properties || {},
+							[discriminator.propertyName]: [{
+								keyword: schemaKeywords.const,
+								args: {
+									name: key,
+									format: "string",
+									value: key
+								}
+							}, ...objectPropertySchema?.args?.properties[discriminator.propertyName] || []].filter((item) => !isKeyword(item, schemaKeywords.enum))
+						} }
+					}]
+				};
+			})
+		};
+	}
+	/**
+	* This is the very core of the OpenAPI to TS conversion - it takes a
+	* schema and returns the appropriate type.
+	*/
+	#parseSchemaObject({ schemaObject: _schemaObject, name, parentName }) {
+		const { schemaObject, version } = this.#getParsedSchemaObject(_schemaObject);
+		const options = this.#getOptions({
+			schemaObject,
+			name
+		});
+		const emptyType = this.#getEmptyType({
+			schemaObject,
+			name
+		});
+		if (!schemaObject) return [{ keyword: emptyType }];
+		const baseItems = [{
+			keyword: schemaKeywords.schema,
+			args: {
+				type: schemaObject.type,
+				format: schemaObject.format
+			}
+		}];
+		const min = schemaObject.minimum ?? schemaObject.minLength ?? schemaObject.minItems ?? void 0;
+		const max = schemaObject.maximum ?? schemaObject.maxLength ?? schemaObject.maxItems ?? void 0;
+		const nullable = isNullable(schemaObject);
+		const defaultNullAndNullable = schemaObject.default === null && nullable;
+		if (schemaObject.default !== void 0 && !defaultNullAndNullable && !Array.isArray(schemaObject.default)) if (typeof schemaObject.default === "string") baseItems.push({
+			keyword: schemaKeywords.default,
+			args: transformers.stringify(schemaObject.default)
+		});
+		else if (typeof schemaObject.default === "boolean") baseItems.push({
+			keyword: schemaKeywords.default,
+			args: schemaObject.default ?? false
+		});
+		else baseItems.push({
+			keyword: schemaKeywords.default,
+			args: schemaObject.default
+		});
+		if (schemaObject.deprecated) baseItems.push({ keyword: schemaKeywords.deprecated });
+		if (schemaObject.description) baseItems.push({
+			keyword: schemaKeywords.describe,
+			args: schemaObject.description
+		});
+		if (max !== void 0) baseItems.unshift({
+			keyword: schemaKeywords.max,
+			args: max
+		});
+		if (min !== void 0) baseItems.unshift({
+			keyword: schemaKeywords.min,
+			args: min
+		});
+		if (nullable) baseItems.push({ keyword: schemaKeywords.nullable });
+		if (schemaObject.type && Array.isArray(schemaObject.type)) {
+			const items = schemaObject.type.filter((value) => value !== "null");
+			const hasNull = schemaObject.type.includes("null");
+			if (hasNull && !nullable) baseItems.push({ keyword: schemaKeywords.nullable });
+			if (items.length > 1) {
+				const parsedItems = [{
+					keyword: schemaKeywords.union,
+					args: items.map((item) => this.parse({
+						schemaObject: {
+							...schemaObject,
+							type: item
+						},
+						name,
+						parentName
+					})[0]).filter(Boolean).filter((item) => !isKeyword(item, schemaKeywords.unknown)).map((item) => isKeyword(item, schemaKeywords.object) ? {
+						...item,
+						args: {
+							...item.args,
+							strict: true
+						}
+					} : item)
+				}];
+				return [...parsedItems, ...baseItems].filter(Boolean);
+			}
+		}
+		if (schemaObject.readOnly) baseItems.push({ keyword: schemaKeywords.readOnly });
+		if (schemaObject.writeOnly) baseItems.push({ keyword: schemaKeywords.writeOnly });
+		if (isReference(schemaObject)) return [
+			...this.#getRefAlias(schemaObject, name),
+			schemaObject.description && {
+				keyword: schemaKeywords.describe,
+				args: schemaObject.description
+			},
+			schemaObject.pattern && schemaObject.type === "string" && {
+				keyword: schemaKeywords.matches,
+				args: schemaObject.pattern
+			},
+			nullable && { keyword: schemaKeywords.nullable },
+			schemaObject.readOnly && { keyword: schemaKeywords.readOnly },
+			schemaObject.writeOnly && { keyword: schemaKeywords.writeOnly },
+			{
+				keyword: schemaKeywords.schema,
+				args: {
+					type: schemaObject.type,
+					format: schemaObject.format
+				}
+			}
+		].filter(Boolean);
+		if (schemaObject.oneOf || schemaObject.anyOf) {
+			const schemaWithoutOneOf = {
+				...schemaObject,
+				oneOf: void 0,
+				anyOf: void 0
+			};
+			const discriminator = this.context.oas.getDiscriminator(schemaObject);
+			const union = {
+				keyword: schemaKeywords.union,
+				args: (schemaObject.oneOf || schemaObject.anyOf).map((item) => {
+					return item && this.parse({
+						schemaObject: item,
+						name,
+						parentName
+					})[0];
+				}).filter(Boolean).filter((item) => !isKeyword(item, schemaKeywords.unknown))
+			};
+			if (discriminator) {
+				if (this.context) return [this.#addDiscriminatorToSchema({
+					schemaObject: schemaWithoutOneOf,
+					schema: union,
+					discriminator
+				}), ...baseItems];
+			}
+			if (schemaWithoutOneOf.properties) {
+				const propertySchemas = this.parse({
+					schemaObject: schemaWithoutOneOf,
+					name,
+					parentName
+				});
+				union.args = [...union.args.map((arg) => {
+					return {
+						keyword: schemaKeywords.and,
+						args: [arg, ...propertySchemas]
+					};
+				})];
+				return [union, ...baseItems];
+			}
+			return [union, ...baseItems];
+		}
+		if (schemaObject.allOf) {
+			const schemaWithoutAllOf = {
+				...schemaObject,
+				allOf: void 0
+			};
+			const and = {
+				keyword: schemaKeywords.and,
+				args: schemaObject.allOf.map((item) => {
+					return item && this.parse({
+						schemaObject: item,
+						name,
+						parentName
+					})[0];
+				}).filter(Boolean).filter((item) => !isKeyword(item, schemaKeywords.unknown))
+			};
+			if (schemaWithoutAllOf.required?.length) {
+				const allOfItems = schemaObject.allOf;
+				const resolvedSchemas = [];
+				for (const item of allOfItems) {
+					const resolved = isReference(item) ? this.context.oas.get(item.$ref) : item;
+					if (resolved) resolvedSchemas.push(resolved);
+				}
+				const existingKeys = schemaWithoutAllOf.properties ? new Set(Object.keys(schemaWithoutAllOf.properties)) : null;
+				const parsedItems = [];
+				for (const key of schemaWithoutAllOf.required) {
+					if (existingKeys?.has(key)) continue;
+					for (const schema of resolvedSchemas) if (schema.properties?.[key]) {
+						parsedItems.push({
+							properties: { [key]: schema.properties[key] },
+							required: [key]
+						});
+						break;
+					}
+				}
+				for (const item of parsedItems) {
+					const parsed = this.parse({
+						schemaObject: item,
+						name,
+						parentName
+					});
+					if (Array.isArray(parsed)) and.args = and.args ? and.args.concat(parsed) : parsed;
+				}
+			}
+			if (schemaWithoutAllOf.properties) and.args = [...and.args || [], ...this.parse({
+				schemaObject: schemaWithoutAllOf,
+				name,
+				parentName
+			})];
+			return SchemaGenerator.combineObjects([and, ...baseItems]);
+		}
+		if (schemaObject.enum) {
+			if (options.enumSuffix === "") this.context.pluginManager.logger.emit("info", "EnumSuffix set to an empty string does not work");
+			const enumName = getUniqueName(pascalCase([
+				parentName,
+				name,
+				options.enumSuffix
+			].join(" ")), this.#getUsedEnumNames({
+				schemaObject,
+				name
+			}));
+			const typeName = this.context.pluginManager.resolveName({
+				name: enumName,
+				pluginKey: this.context.plugin.key,
+				type: "type"
+			});
+			const nullableEnum = schemaObject.enum.includes(null);
+			if (nullableEnum) baseItems.push({ keyword: schemaKeywords.nullable });
+			const filteredValues = schemaObject.enum.filter((value) => value !== null);
+			const extensionEnums = ["x-enumNames", "x-enum-varnames"].filter((extensionKey) => extensionKey in schemaObject).map((extensionKey) => {
+				return [{
+					keyword: schemaKeywords.enum,
+					args: {
+						name,
+						typeName,
+						asConst: false,
+						items: [...new Set(schemaObject[extensionKey])].map((name$1, index) => ({
+							name: transformers.stringify(name$1),
+							value: schemaObject.enum?.[index],
+							format: isNumber(schemaObject.enum?.[index]) ? "number" : "string"
+						}))
+					}
+				}, ...baseItems.filter((item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max && item.keyword !== schemaKeywords.matches)];
+			});
+			if (schemaObject.type === "number" || schemaObject.type === "integer") {
+				const enumNames = extensionEnums[0]?.find((item) => isKeyword(item, schemaKeywords.enum));
+				return [{
+					keyword: schemaKeywords.enum,
+					args: {
+						name: enumName,
+						typeName,
+						asConst: true,
+						items: enumNames?.args?.items ? [...new Set(enumNames.args.items)].map(({ name: name$1, value }) => ({
+							name: name$1,
+							value,
+							format: "number"
+						})) : [...new Set(filteredValues)].map((value) => {
+							return {
+								name: value,
+								value,
+								format: "number"
+							};
+						})
+					}
+				}, ...baseItems.filter((item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max && item.keyword !== schemaKeywords.matches)];
+			}
+			if (schemaObject.type === "boolean") {
+				const enumNames = extensionEnums[0]?.find((item) => isKeyword(item, schemaKeywords.enum));
+				return [{
+					keyword: schemaKeywords.enum,
+					args: {
+						name: enumName,
+						typeName,
+						asConst: true,
+						items: enumNames?.args?.items ? [...new Set(enumNames.args.items)].map(({ name: name$1, value }) => ({
+							name: name$1,
+							value,
+							format: "boolean"
+						})) : [...new Set(filteredValues)].map((value) => {
+							return {
+								name: value,
+								value,
+								format: "boolean"
+							};
+						})
+					}
+				}, ...baseItems.filter((item) => item.keyword !== schemaKeywords.matches)];
+			}
+			if (extensionEnums.length > 0 && extensionEnums[0]) return extensionEnums[0];
+			return [{
+				keyword: schemaKeywords.enum,
+				args: {
+					name: enumName,
+					typeName,
+					asConst: false,
+					items: [...new Set(filteredValues)].map((value) => ({
+						name: transformers.stringify(value),
+						value,
+						format: isNumber(value) ? "number" : "string"
+					}))
+				}
+			}, ...baseItems.filter((item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max && item.keyword !== schemaKeywords.matches)];
+		}
+		if ("prefixItems" in schemaObject) {
+			const prefixItems = schemaObject.prefixItems;
+			const items = "items" in schemaObject ? schemaObject.items : [];
+			const min$1 = schemaObject.minimum ?? schemaObject.minLength ?? schemaObject.minItems ?? void 0;
+			const max$1 = schemaObject.maximum ?? schemaObject.maxLength ?? schemaObject.maxItems ?? void 0;
+			return [{
+				keyword: schemaKeywords.tuple,
+				args: {
+					min: min$1,
+					max: max$1,
+					items: prefixItems.map((item) => {
+						return this.parse({
+							schemaObject: item,
+							name,
+							parentName
+						})[0];
+					}).filter(Boolean),
+					rest: this.parse({
+						schemaObject: items,
+						name,
+						parentName
+					})[0]
+				}
+			}, ...baseItems.filter((item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max)];
+		}
+		if (version === "3.1" && "const" in schemaObject) {
+			if (schemaObject["const"] === null) return [{ keyword: schemaKeywords.null }];
+			if (schemaObject["const"] === void 0) return [{ keyword: schemaKeywords.undefined }];
+			let format = typeof schemaObject["const"];
+			if (format !== "number" && format !== "boolean") format = "string";
+			return [{
+				keyword: schemaKeywords.const,
+				args: {
+					name: schemaObject["const"],
+					format,
+					value: schemaObject["const"]
+				}
+			}, ...baseItems];
+		}
+		/**
+		* > Structural validation alone may be insufficient to allow an application to correctly utilize certain values. The "format"
+		* > annotation keyword is defined to allow schema authors to convey semantic information for a fixed subset of values which are
+		* > accurately described by authoritative resources, be they RFCs or other external specifications.
+		*
+		* In other words: format is more specific than type alone, hence it should override the type value, if possible.
+		*
+		* see also https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-00#rfc.section.7
+		*/
+		if (schemaObject.format) {
+			if (schemaObject.type === "integer" && (schemaObject.format === "int32" || schemaObject.format === "int64")) {
+				baseItems.unshift({ keyword: schemaKeywords.integer });
+				return baseItems;
+			}
+			if (schemaObject.type === "number" && (schemaObject.format === "float" || schemaObject.format === "double")) {
+				baseItems.unshift({ keyword: schemaKeywords.number });
+				return baseItems;
+			}
+			switch (schemaObject.format) {
+				case "binary":
+					baseItems.push({ keyword: schemaKeywords.blob });
+					return baseItems;
+				case "date-time":
+					if (options.dateType) {
+						if (options.dateType === "date") {
+							baseItems.unshift({
+								keyword: schemaKeywords.date,
+								args: { type: "date" }
+							});
+							return baseItems;
+						}
+						if (options.dateType === "stringOffset") {
+							baseItems.unshift({
+								keyword: schemaKeywords.datetime,
+								args: { offset: true }
+							});
+							return baseItems;
+						}
+						if (options.dateType === "stringLocal") {
+							baseItems.unshift({
+								keyword: schemaKeywords.datetime,
+								args: { local: true }
+							});
+							return baseItems;
+						}
+						baseItems.unshift({
+							keyword: schemaKeywords.datetime,
+							args: { offset: false }
+						});
+						return baseItems;
+					}
+					break;
+				case "date":
+					if (options.dateType) {
+						if (options.dateType === "date") {
+							baseItems.unshift({
+								keyword: schemaKeywords.date,
+								args: { type: "date" }
+							});
+							return baseItems;
+						}
+						baseItems.unshift({
+							keyword: schemaKeywords.date,
+							args: { type: "string" }
+						});
+						return baseItems;
+					}
+					break;
+				case "time":
+					if (options.dateType) {
+						if (options.dateType === "date") {
+							baseItems.unshift({
+								keyword: schemaKeywords.time,
+								args: { type: "date" }
+							});
+							return baseItems;
+						}
+						baseItems.unshift({
+							keyword: schemaKeywords.time,
+							args: { type: "string" }
+						});
+						return baseItems;
+					}
+					break;
+				case "uuid":
+					baseItems.unshift({ keyword: schemaKeywords.uuid });
+					return baseItems;
+				case "email":
+				case "idn-email":
+					baseItems.unshift({ keyword: schemaKeywords.email });
+					return baseItems;
+				case "uri":
+				case "ipv4":
+				case "ipv6":
+				case "uri-reference":
+				case "hostname":
+				case "idn-hostname":
+					baseItems.unshift({ keyword: schemaKeywords.url });
+					return baseItems;
+				default: break;
+			}
+		}
+		if (schemaObject.pattern && schemaObject.type === "string") {
+			baseItems.unshift({
+				keyword: schemaKeywords.matches,
+				args: schemaObject.pattern
+			});
+			return baseItems;
+		}
+		if ("items" in schemaObject || schemaObject.type === "array") {
+			const min$1 = schemaObject.minimum ?? schemaObject.minLength ?? schemaObject.minItems ?? void 0;
+			const max$1 = schemaObject.maximum ?? schemaObject.maxLength ?? schemaObject.maxItems ?? void 0;
+			const items = this.parse({
+				schemaObject: "items" in schemaObject ? schemaObject.items : [],
+				name,
+				parentName
+			});
+			const unique = !!schemaObject.uniqueItems;
+			return [{
+				keyword: schemaKeywords.array,
+				args: {
+					items,
+					min: min$1,
+					max: max$1,
+					unique
+				}
+			}, ...baseItems.filter((item) => item.keyword !== schemaKeywords.min && item.keyword !== schemaKeywords.max)];
+		}
+		if (schemaObject.properties || schemaObject.additionalProperties) {
+			if (isDiscriminator(schemaObject)) {
+				const schemaObjectOverriden = Object.keys(schemaObject.properties || {}).reduce((acc, propertyName) => {
+					if (acc.properties?.[propertyName] && propertyName === schemaObject.discriminator.propertyName) return {
+						...acc,
+						properties: {
+							...acc.properties,
+							[propertyName]: {
+								...acc.properties[propertyName] || {},
+								enum: schemaObject.discriminator.mapping ? Object.keys(schemaObject.discriminator.mapping) : void 0
+							}
+						}
+					};
+					return acc;
+				}, schemaObject || {});
+				return [...this.#parseProperties({
+					schemaObject: schemaObjectOverriden,
+					name
+				}), ...baseItems];
+			}
+			return [...this.#parseProperties({
+				schemaObject,
+				name
+			}), ...baseItems];
+		}
+		if (schemaObject.type) {
+			const type = Array.isArray(schemaObject.type) ? schemaObject.type.filter((item) => item !== "null")[0] : schemaObject.type;
+			if (![
+				"boolean",
+				"object",
+				"number",
+				"string",
+				"integer",
+				"null"
+			].includes(type)) this.context.pluginManager.logger.emit("warning", `Schema type '${schemaObject.type}' is not valid for schema ${parentName}.${name}`);
+			return [{ keyword: type }, ...baseItems];
+		}
+		return [{ keyword: emptyType }];
+	}
+	async build(...generators) {
+		const { oas, contentType, include } = this.context;
+		const schemas = getSchemas({
+			oas,
+			contentType,
+			includes: include
+		});
+		const schemaEntries = Object.entries(schemas);
+		const generatorLimit = pLimit(1);
+		const schemaLimit = pLimit(10);
+		const writeTasks = generators.map((generator) => generatorLimit(async () => {
+			const schemaTasks = schemaEntries.map(([name, schemaObject]) => schemaLimit(async () => {
+				const options = this.#getOptions({ name });
+				const tree = this.parse({
+					name,
+					schemaObject
+				});
+				const result = await generator.schema?.({
+					instance: this,
+					schema: {
+						name,
+						value: schemaObject,
+						tree
+					},
+					options: {
+						...this.options,
+						...options
+					}
+				});
+				return result ?? [];
+			}));
+			const schemaResults = await Promise.all(schemaTasks);
+			return schemaResults.flat();
+		}));
+		const nestedResults = await Promise.all(writeTasks);
+		return nestedResults.flat();
+	}
+};
+
+//#endregion
+export { SchemaGenerator, pLimit };
+//# sourceMappingURL=SchemaGenerator-B8Io6kky.js.map