@kubb/adapter-oas 5.15.3 → 5.15.4

package/dist/index.js

@@ -19,7 +19,7 @@ var compatibility = {
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.15.3";
+var version = "5.15.4";
 // src/constants.ts
 /**
 * Default parser options applied when no explicit options are provided.
@@ -615,8 +615,10 @@ async function readSource(sourcePath) {
 async function resolveSource(sourcePath) {
 	const data = await readSource(sourcePath);
 	if (sourcePath.toLowerCase().endsWith(".md")) return data;
+	const pathname = urlRegExp.test(sourcePath) ? new URL(sourcePath).pathname : sourcePath;
 	return parseYaml(data, {
 		origin: sourcePath,
+		json: !/\.ya?ml$/i.test(pathname),
 		help: "Fix the syntax at the reported line, or check that `input` points at the spec and not an HTML page."
 	});
 }
@@ -624,11 +626,19 @@ async function resolveSource(sourcePath) {
 * Parses a YAML (or JSON) spec. A syntax error throws `KUBB_INVALID_DOCUMENT` naming `origin`,
 * with the parser message, which keeps the line and column.
 *
-* JSON is valid YAML, so one parser handles both. `js-yaml` parses about ten times faster than
-* `yaml`, and unlike `JSON.parse` it rejects duplicate keys instead of keeping the last one. Its
-* core schema keeps timestamps as strings and `<<` as a plain key, as `yaml` does for YAML 1.2.
+* With `json` (the default), a document that starts with `{` or `[` goes through `JSON.parse`
+* first, about ten times faster than `js-yaml` on a JSON spec. A duplicate key then keeps the last
+* value, as every JSON parser does. YAML flow syntax also starts with `{`, so a parse failure falls
+* through to YAML. Pass `json: false` for a source known to be YAML.
+*
+* `js-yaml` parses about ten times faster than `yaml`, and rejects duplicate keys instead of
+* keeping the last one. Its core schema keeps timestamps as strings and `<<` as a plain key, as
+* `yaml` does for YAML 1.2.
 */
-function parseYaml(data, { origin, help }) {
+function parseYaml(data, { origin, help, json = true }) {
+	if (json && /^\s*[[{]/.test(data)) try {
+		return JSON.parse(data);
+	} catch {}
 	try {
 		const document = load(data, { schema: CORE_SCHEMA });
 		if (document !== void 0) return document;
@@ -2233,6 +2243,34 @@ function getNumericConstraints(schema) {
 	};
 }
 /**
+* Whether an enum value fits the schema's numeric bounds.
+*/
+function isWithinBounds({ value, schema }) {
+	if (typeof value !== "number") return true;
+	const { min, max, exclusiveMinimum, exclusiveMaximum, multipleOf } = getNumericConstraints(schema);
+	if (min !== void 0 && value < min) return false;
+	if (max !== void 0 && value > max) return false;
+	if (exclusiveMinimum !== void 0 && value <= exclusiveMinimum) return false;
+	if (exclusiveMaximum !== void 0 && value >= exclusiveMaximum) return false;
+	if (multipleOf !== void 0 && Math.abs(value / multipleOf - Math.round(value / multipleOf)) > 1e-9) return false;
+	return true;
+}
+/**
+* Builds the test for which `enum` entries stay: not `null`, and within the numeric bounds. `enum` and the bounds
+* apply together, so a value outside them is never valid. Bounds that exclude every value are a spec error, so
+* they are ignored rather than leaving an empty enum.
+*/
+function createEnumMemberFilter(schema) {
+	const boundsApply = schema.enum.some((value) => value !== null && isWithinBounds({
+		value,
+		schema
+	}));
+	return (value) => value !== null && (!boundsApply || isWithinBounds({
+		value,
+		schema
+	}));
+}
+/**
 * Builds a `null` scalar node carrying the schema's documentation. Shared by the `const: null`
 * and the drf-spectacular `NullEnum` (`{ enum: [null] }`) branches, which render identically.
 */
@@ -2313,7 +2351,8 @@ function convertEnum({ schema, name, nullable, type, parse }) {
 		name
 	});
 	const nullInEnum = schema.enum.includes(null);
-	const filteredValues = nullInEnum ? schema.enum.filter((v) => v !== null) : schema.enum;
+	const isMember = createEnumMemberFilter(schema);
+	const filteredValues = schema.enum.filter(isMember);
 	if (nullInEnum && filteredValues.length === 0) return createNullNode(schema, name);
 	const enumNullable = nullable || nullInEnum || void 0;
 	const enumDefault = schema.default === null && enumNullable ? void 0 : schema.default;
@@ -2332,8 +2371,9 @@ function convertEnum({ schema, name, nullable, type, parse }) {
 		primitive,
 		enumValues: uniqueValues
 	});
-	const rawEnumNames = extensionKey ? schema[extensionKey] : void 0;
-	const rawEnumDescriptions = descriptionKey ? schema[descriptionKey] : void 0;
+	const memberSlots = (list) => Array.isArray(list) ? list.filter((_, index) => isMember(schema.enum[index])) : void 0;
+	const rawEnumNames = extensionKey ? memberSlots(schema[extensionKey]) : void 0;
+	const rawEnumDescriptions = descriptionKey ? memberSlots(schema[descriptionKey]) : void 0;
 	const seenNames = /* @__PURE__ */ new Set();
 	return createNode(ctx, {
 		type: "enum",
@@ -2351,6 +2391,25 @@ function convertEnum({ schema, name, nullable, type, parse }) {
 	});
 }
 /**
+* Converts an `enum` with a handled `format` into a union of its literal values. A named enum node would rename
+* the exported type (`Status` becomes `StatusKey`), so the union keeps the name the format type had.
+*/
+function convertFormattedEnum(context) {
+	const { schema, nullable } = context;
+	const values = [...new Set(schema.enum.filter(createEnumMemberFilter(schema)))];
+	return createNode({
+		...context,
+		nullable: nullable || schema.enum.includes(null) || void 0
+	}, {
+		type: "union",
+		members: values.map((value) => ast.factory.createSchema({
+			type: "enum",
+			primitive: getPrimitiveType(typeof value),
+			enumValues: [value]
+		}))
+	});
+}
+/**
 * Converts a `type: 'string'` schema into a `StringSchemaNode`.
 */
 function convertString(context) {
@@ -2527,6 +2586,24 @@ function convertArray({ schema, name, nullable, defaultValue, options, parse })
 }
 // src/emit/parseSchema.ts
 /**
+* Whether the `format` rule owns the schema: a handled format, and for a date format a `dateType` that is not `false`.
+*/
+function matchesFormat({ schema, options }) {
+	if (!schema.format) return false;
+	if (schema.format === "date-time" || schema.format === "date" || schema.format === "time") return resolveDateTypeValue(options.dateType, schema.format) !== false;
+	return isHandledFormat(schema.format);
+}
+/**
+* Whether the format prints as a plain `string` or `number`, so narrowing it to literal values cannot break callers.
+* `Date`, `bigint` and `Blob` outputs keep the format.
+*/
+function formatPrintsPlainType({ schema, options, type }) {
+	const format = schema.format;
+	if (format === "date-time" || format === "date" || format === "time") return resolveDateTypeValue(options.dateType, format) !== "date";
+	if ((format === "int64" || format === "uint64") && type !== "string") return options.integerType !== "bigint";
+	return formatMap[format] !== "blob";
+}
+/**
 * Ordered schema rule table. Order is significant: composition keywords (`not`, `$ref`, `allOf`,
 * `oneOf`/`anyOf`) take precedence over `const` (except a `$ref` with a sibling `const`, where the
 * `const` wins), which takes precedence over a genuine OAS 3.1 multi-type array (more than one
@@ -2564,11 +2641,11 @@ const schemaRules = [
 		convert: convertMultiType
 	},
 	{
-		match: ({ schema, options }) => {
-			if (!schema.format) return false;
-			if (schema.format === "date-time" || schema.format === "date" || schema.format === "time") return resolveDateTypeValue(options.dateType, schema.format) !== false;
-			return isHandledFormat(schema.format);
-		},
+		match: (ctx) => ctx.type !== "array" && !!ctx.schema.enum?.some((value) => value !== null) && matchesFormat(ctx) && formatPrintsPlainType(ctx),
+		convert: convertFormattedEnum
+	},
+	{
+		match: matchesFormat,
 		convert: convertFormat
 	},
 	{