@kubb/oas 4.32.4 → 4.33.1

package/dist/index.d.ts

@@ -32,6 +32,12 @@ type ResponseObject = ResponseObject$1;
 type MediaTypeObject = MediaTypeObject$1;
 //#endregion
 //#region src/Oas.d.ts
+/**
+ * Prefix used to create synthetic `$ref` values for anonymous (inline) discriminator schemas.
+ * The suffix is the schema index within the discriminator's `oneOf`/`anyOf` array.
+ * @example `#kubb-inline-0`
+ */
+declare const KUBB_INLINE_REF_PREFIX = "#kubb-inline-";
 type OasOptions = {
   contentType?: contentType;
   discriminator?: 'strict' | 'inherit';
@@ -71,6 +77,23 @@ declare class Oas extends BaseOas {
   };
 }
 //#endregion
+//#region src/resolveServerUrl.d.ts
+type ServerVariable = {
+  default?: string | number;
+  enum?: (string | number)[];
+};
+type ServerObject = {
+  url: string;
+  variables?: Record<string, ServerVariable>;
+};
+/**
+ * Resolves an OpenAPI server URL by substituting `{variable}` placeholders
+ * with values from `overrides` (user-provided) or the spec-defined defaults.
+ *
+ * Throws if an override value is not in the variable's `enum` list.
+ */
+declare function resolveServerUrl(server: ServerObject, overrides?: Record<string, string>): string;
+//#endregion
 //#region src/utils.d.ts
 declare function isOpenApiV3_1Document(doc: any): doc is OpenAPIV3_1$1.Document;
 declare function isParameterObject(obj: ParameterObject | SchemaObject$1): obj is ParameterObject;
@@ -130,5 +153,5 @@ declare function parseFromConfig(config: Config, oasClass?: typeof Oas): Promise
  */
 declare function validate(document: Document): Promise<_readme_openapi_parser0.ValidationResult>;
 //#endregion
-export { DiscriminatorObject, Document, HttpMethod, HttpMethods, MediaTypeObject, Oas, type OasTypes, type OpenAPIV3, type OpenAPIV3_1, Operation, ReferenceObject, ResponseObject, SchemaObject, contentType, getDefaultValue, isAllOptional, isDiscriminator, isNullable, isOpenApiV3_1Document, isOptional, isParameterObject, isReference, isRequired, merge, parse, parseFromConfig, validate };
+export { DiscriminatorObject, Document, HttpMethod, HttpMethods, KUBB_INLINE_REF_PREFIX, MediaTypeObject, Oas, type OasTypes, type OpenAPIV3, type OpenAPIV3_1, Operation, ReferenceObject, ResponseObject, SchemaObject, contentType, getDefaultValue, isAllOptional, isDiscriminator, isNullable, isOpenApiV3_1Document, isOptional, isParameterObject, isReference, isRequired, merge, parse, parseFromConfig, resolveServerUrl, validate };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -4,13 +4,182 @@ import BaseOas from "oas";
 import { matchesMimeType } from "oas/utils";
 import fs from "node:fs";
 import path from "node:path";
-import { pascalCase } from "@kubb/core/transformers";
-import { URLPath } from "@kubb/core/utils";
 import { bundle } from "@readme/openapi-parser";
 import { isRef } from "oas/types";
 import OASNormalize from "oas-normalize";
 import { isPlainObject, mergeDeep } from "remeda";
 import swagger2openapi from "swagger2openapi";
+//#region ../../internals/utils/src/casing.ts
+/**
+* Shared implementation for camelCase and PascalCase conversion.
+* Splits on common word boundaries (spaces, hyphens, underscores, dots, slashes, colons)
+* and capitalizes each word according to `pascal`.
+*
+* When `pascal` is `true` the first word is also capitalized (PascalCase), otherwise only subsequent words are.
+*/
+function toCamelOrPascal(text, pascal) {
+	return text.trim().replace(/([a-z\d])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").replace(/(\d)([a-z])/g, "$1 $2").split(/[\s\-_./\\:]+/).filter(Boolean).map((word, i) => {
+		if (word.length > 1 && word === word.toUpperCase()) return word;
+		if (i === 0 && !pascal) return word.charAt(0).toLowerCase() + word.slice(1);
+		return word.charAt(0).toUpperCase() + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Splits `text` on `.` and applies `transformPart` to each segment.
+* The last segment receives `isLast = true`, all earlier segments receive `false`.
+* Segments are joined with `/` to form a file path.
+*/
+function applyToFileParts(text, transformPart) {
+	const parts = text.split(".");
+	return parts.map((part, i) => transformPart(part, i === parts.length - 1)).join("/");
+}
+/**
+* Converts `text` to camelCase.
+* When `isFile` is `true`, dot-separated segments are each cased independently and joined with `/`.
+*
+* @example
+* camelCase('hello-world')                   // 'helloWorld'
+* camelCase('pet.petId', { isFile: true })   // 'pet/petId'
+*/
+function camelCase(text, { isFile, prefix = "", suffix = "" } = {}) {
+	if (isFile) return applyToFileParts(text, (part, isLast) => camelCase(part, isLast ? {
+		prefix,
+		suffix
+	} : {}));
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+/**
+* Converts `text` to PascalCase.
+* When `isFile` is `true`, the last dot-separated segment is PascalCased and earlier segments are camelCased.
+*
+* @example
+* pascalCase('hello-world')                  // 'HelloWorld'
+* pascalCase('pet.petId', { isFile: true })  // 'pet/PetId'
+*/
+function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
+	if (isFile) return applyToFileParts(text, (part, isLast) => isLast ? pascalCase(part, {
+		prefix,
+		suffix
+	}) : camelCase(part));
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, true);
+}
+//#endregion
+//#region ../../internals/utils/src/reserved.ts
+/**
+* Returns `true` when `name` is a syntactically valid JavaScript variable name.
+*/
+function isValidVarName(name) {
+	try {
+		new Function(`var ${name}`);
+	} catch {
+		return false;
+	}
+	return true;
+}
+//#endregion
+//#region ../../internals/utils/src/urlPath.ts
+/**
+* Parses and transforms an OpenAPI/Swagger path string into various URL formats.
+*
+* @example
+* const p = new URLPath('/pet/{petId}')
+* p.URL      // '/pet/:petId'
+* p.template // '`/pet/${petId}`'
+*/
+var URLPath = class {
+	/** The raw OpenAPI/Swagger path string, e.g. `/pet/{petId}`. */
+	path;
+	#options;
+	constructor(path, options = {}) {
+		this.path = path;
+		this.#options = options;
+	}
+	/** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+	get URL() {
+		return this.toURLPath();
+	}
+	/** Returns `true` when `path` is a fully-qualified URL (e.g. starts with `https://`). */
+	get isURL() {
+		try {
+			return !!new URL(this.path).href;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Converts the OpenAPI path to a TypeScript template literal string.
+	*
+	* @example
+	* new URLPath('/pet/{petId}').template              // '`/pet/${petId}`'
+	* new URLPath('/account/monetary-accountID').template // '`/account/${monetaryAccountId}`'
+	*/
+	get template() {
+		return this.toTemplateString();
+	}
+	/** Returns the path and its extracted params as a structured `URLObject`, or as a stringified expression when `stringify` is set. */
+	get object() {
+		return this.toObject();
+	}
+	/** Returns a map of path parameter names, or `undefined` when the path has no parameters. */
+	get params() {
+		return this.getParams();
+	}
+	#transformParam(raw) {
+		const param = isValidVarName(raw) ? raw : camelCase(raw);
+		return this.#options.casing === "camelcase" ? camelCase(param) : param;
+	}
+	/** Iterates over every `{param}` token in `path`, calling `fn` with the raw token and transformed name. */
+	#eachParam(fn) {
+		for (const match of this.path.matchAll(/\{([^}]+)\}/g)) {
+			const raw = match[1];
+			fn(raw, this.#transformParam(raw));
+		}
+	}
+	toObject({ type = "path", replacer, stringify } = {}) {
+		const object = {
+			url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
+			params: this.getParams()
+		};
+		if (stringify) {
+			if (type === "template") return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
+			if (object.params) return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
+			return `{ url: '${object.url}' }`;
+		}
+		return object;
+	}
+	/**
+	* Converts the OpenAPI path to a TypeScript template literal string.
+	* An optional `replacer` can transform each extracted parameter name before interpolation.
+	*
+	* @example
+	* new URLPath('/pet/{petId}').toTemplateString() // '`/pet/${petId}`'
+	*/
+	toTemplateString({ prefix = "", replacer } = {}) {
+		return `\`${prefix}${this.path.split(/\{([^}]+)\}/).map((part, i) => {
+			if (i % 2 === 0) return part;
+			const param = this.#transformParam(part);
+			return `\${${replacer ? replacer(param) : param}}`;
+		}).join("")}\``;
+	}
+	/**
+	* Extracts all `{param}` segments from the path and returns them as a key-value map.
+	* An optional `replacer` transforms each parameter name in both key and value positions.
+	* Returns `undefined` when no path parameters are found.
+	*/
+	getParams(replacer) {
+		const params = {};
+		this.#eachParam((_raw, param) => {
+			const key = replacer ? replacer(param) : param;
+			params[key] = key;
+		});
+		return Object.keys(params).length > 0 ? params : void 0;
+	}
+	/** Converts the OpenAPI path to Express-style colon syntax, e.g. `/pet/{petId}` → `/pet/:petId`. */
+	toURLPath() {
+		return this.path.replace(/\{([^}]+)\}/g, ":$1");
+	}
+};
+//#endregion
 //#region ../../node_modules/.pnpm/tslib@2.8.1/node_modules/tslib/tslib.es6.mjs
 var tslib_es6_exports = /* @__PURE__ */ __exportAll({
 	__addDisposableResource: () => __addDisposableResource,
@@ -4610,6 +4779,12 @@ function resolveCollisions(schemasWithMeta) {
 }
 //#endregion
 //#region src/Oas.ts
+/**
+* Prefix used to create synthetic `$ref` values for anonymous (inline) discriminator schemas.
+* The suffix is the schema index within the discriminator's `oneOf`/`anyOf` array.
+* @example `#kubb-inline-0`
+*/
+const KUBB_INLINE_REF_PREFIX = "#kubb-inline-";
 var Oas = class extends BaseOas {
 	#options = { discriminator: "strict" };
 	document;
@@ -4708,7 +4883,7 @@ var Oas = class extends BaseOas {
 					}
 				} else {
 					const discriminatorValue = getDiscriminatorValue(schemaItem);
-					if (discriminatorValue) existingMapping[discriminatorValue] = `#kubb-inline-${index}`;
+					if (discriminatorValue) existingMapping[discriminatorValue] = `${KUBB_INLINE_REF_PREFIX}${index}`;
 				}
 			});
 		};
@@ -4915,6 +5090,25 @@ var Oas = class extends BaseOas {
 	}
 };
 //#endregion
+//#region src/resolveServerUrl.ts
+/**
+* Resolves an OpenAPI server URL by substituting `{variable}` placeholders
+* with values from `overrides` (user-provided) or the spec-defined defaults.
+*
+* Throws if an override value is not in the variable's `enum` list.
+*/
+function resolveServerUrl(server, overrides) {
+	if (!server.variables) return server.url;
+	let url = server.url;
+	for (const [key, variable] of Object.entries(server.variables)) {
+		const value = overrides?.[key] ?? (variable.default != null ? String(variable.default) : void 0);
+		if (value === void 0) continue;
+		if (variable.enum?.length && !variable.enum.some((e) => String(e) === value)) throw new Error(`Invalid server variable value '${value}' for '${key}' when resolving ${server.url}. Valid values are: ${variable.enum.join(", ")}.`);
+		url = url.replaceAll(`{${key}}`, value);
+	}
+	return url;
+}
+//#endregion
 //#region src/types.ts
 const HttpMethods = {
 	GET: "get",
@@ -4927,6 +5121,6 @@ const HttpMethods = {
 	TRACE: "trace"
 };
 //#endregion
-export { HttpMethods, Oas, getDefaultValue, isAllOptional, isDiscriminator, isNullable, isOpenApiV3_1Document, isOptional, isParameterObject, isReference, isRequired, merge, parse, parseFromConfig, validate };
+export { HttpMethods, KUBB_INLINE_REF_PREFIX, Oas, getDefaultValue, isAllOptional, isDiscriminator, isNullable, isOpenApiV3_1Document, isOptional, isParameterObject, isReference, isRequired, merge, parse, parseFromConfig, resolveServerUrl, validate };
 
 //# sourceMappingURL=index.js.map