@kubb/core 5.0.0-beta.9 → 5.0.0-beta.93

package/dist/usingCtx-eyNeehd2.cjs

@@ -0,0 +1,679 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let _kubb_ast = require("@kubb/ast");
+let node_events = require("node:events");
+//#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;
+		return (i === 0 && !pascal ? word.charAt(0).toLowerCase() : word.charAt(0).toUpperCase()) + word.slice(1);
+	}).join("").replace(/[^a-zA-Z0-9]/g, "");
+}
+/**
+* Converts `text` to camelCase.
+*
+* @example Word boundaries
+* `camelCase('hello-world') // 'helloWorld'`
+*
+* @example With a prefix
+* `camelCase('tag', { prefix: 'create' }) // 'createTag'`
+*/
+function camelCase(text, { prefix = "", suffix = "" } = {}) {
+	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
+}
+//#endregion
+//#region ../../internals/utils/src/errors.ts
+/**
+* Thrown when one or more errors occur during a Kubb build.
+* Carries the full list of underlying errors on `errors`.
+*
+* @example
+* ```ts
+* throw new BuildError('Build failed', { errors: [err1, err2] })
+* ```
+*/
+var BuildError = class extends Error {
+	errors;
+	constructor(message, options) {
+		super(message, { cause: options.cause });
+		this.name = "BuildError";
+		this.errors = options.errors;
+	}
+};
+/**
+* Coerces an unknown thrown value to an `Error` instance.
+* Returns the value as-is when it is already an `Error`; otherwise wraps it with `String(value)`.
+*
+* @example
+* ```ts
+* try { ... } catch(err) {
+*   throw new BuildError('Build failed', { cause: toError(err), errors: [] })
+* }
+* ```
+*/
+function toError(value) {
+	return value instanceof Error ? value : new Error(String(value));
+}
+/**
+* Extracts a human-readable message from any thrown value.
+*
+* @example
+* ```ts
+* getErrorMessage(new Error('oops')) // 'oops'
+* getErrorMessage('plain string')    // 'plain string'
+* ```
+*/
+function getErrorMessage(value) {
+	return value instanceof Error ? value.message : String(value);
+}
+//#endregion
+//#region ../../internals/utils/src/runtime.ts
+/**
+* Detects the JavaScript runtime executing the current process and exposes its name and version.
+*
+* Prefer the shared {@link runtime} instance over constructing your own.
+*/
+var Runtime = class {
+	/**
+	* `true` when the current process is running under Bun.
+	*
+	* Detection keys off the global `Bun` object rather than `process.versions`,
+	* because Bun polyfills `process.versions.node` for Node compatibility and would
+	* otherwise look like Node.
+	*
+	* @example
+	* ```ts
+	* if (runtime.isBun) {
+	*   await Bun.write(path, data)
+	* }
+	* ```
+	*/
+	get isBun() {
+		return typeof Bun !== "undefined";
+	}
+	/**
+	* `true` when the current process is running under Deno.
+	*/
+	get isDeno() {
+		return typeof globalThis.Deno !== "undefined";
+	}
+	/**
+	* `true` when the current process is running under Node.
+	*
+	* Bun and Deno are excluded first so a polyfilled `process` does not register as Node.
+	*/
+	get isNode() {
+		return !this.isBun && !this.isDeno && typeof process !== "undefined" && process.versions?.node != null;
+	}
+	/**
+	* Name of the runtime executing the current process.
+	*
+	* @example
+	* ```ts
+	* runtime.name // 'bun' when run with `bun kubb`, 'node' otherwise
+	* ```
+	*/
+	get name() {
+		if (this.isBun) return "bun";
+		if (this.isDeno) return "deno";
+		return "node";
+	}
+	/**
+	* Version of the active runtime, or an empty string when it cannot be read.
+	*
+	* @example
+	* ```ts
+	* runtime.version // '1.3.11' under Bun, '22.22.2' under Node
+	* ```
+	*/
+	get version() {
+		if (this.isBun) return process.versions.bun ?? "";
+		if (this.isDeno) return globalThis.Deno?.version?.deno ?? "";
+		return process.versions?.node ?? "";
+	}
+};
+/**
+* Shared {@link Runtime} instance describing the JavaScript runtime executing the current process.
+*/
+const runtime = new Runtime();
+//#endregion
+//#region ../../internals/utils/src/fs.ts
+/**
+* Reads the file at `path` as a UTF-8 string.
+* Uses `Bun.file().text()` when running under Bun, `fs.readFile` otherwise.
+*
+* @example
+* ```ts
+* const source = await read('./src/Pet.ts')
+* ```
+*/
+async function read(path) {
+	if (runtime.isBun) return Bun.file(path).text();
+	return (0, node_fs_promises.readFile)(path, { encoding: "utf8" });
+}
+/**
+* Writes `data` to `path`, trimming leading/trailing whitespace before saving.
+* Skips the write when the trimmed content is empty or identical to what is already on disk.
+* Creates any missing parent directories automatically.
+* When `sanity` is `true`, re-reads the file after writing and throws if the content does not match.
+*
+* @example
+* ```ts
+* await write('./src/Pet.ts', source)         // writes and returns trimmed content
+* await write('./src/Pet.ts', source)         // null — file unchanged
+* await write('./src/Pet.ts', '  ')           // null — empty content skipped
+* ```
+*/
+async function write(path, data, options = {}) {
+	const trimmed = data.trim();
+	if (trimmed === "") return null;
+	const resolved = (0, node_path.resolve)(path);
+	if (runtime.isBun) {
+		const file = Bun.file(resolved);
+		if ((await file.exists() ? await file.text() : null) === trimmed) return null;
+		await Bun.write(resolved, trimmed);
+		return trimmed;
+	}
+	try {
+		if (await (0, node_fs_promises.readFile)(resolved, { encoding: "utf-8" }) === trimmed) return null;
+	} catch {}
+	await (0, node_fs_promises.mkdir)((0, node_path.dirname)(resolved), { recursive: true });
+	await (0, node_fs_promises.writeFile)(resolved, trimmed, { encoding: "utf-8" });
+	if (options.sanity) {
+		const savedData = await (0, node_fs_promises.readFile)(resolved, { encoding: "utf-8" });
+		if (savedData !== trimmed) throw new Error(`Sanity check failed for ${path}\n\nData[${data.length}]:\n${data}\n\nSaved[${savedData.length}]:\n${savedData}\n`);
+		return savedData;
+	}
+	return trimmed;
+}
+/**
+* Recursively removes `path`. Silently succeeds when `path` does not exist.
+*
+* @example
+* ```ts
+* await clean('./dist')
+* ```
+*/
+async function clean(path) {
+	return (0, node_fs_promises.rm)(path, {
+		recursive: true,
+		force: true
+	});
+}
+/**
+* Converts a filesystem path to use POSIX (`/`) separators.
+*
+* Most of the codebase compares and composes paths as strings (prefix matching, joining for
+* import specifiers, splitting on `/`). On POSIX `path.resolve` already returns `/`-separated
+* paths, but on Windows it returns `\`-separated paths, which breaks every such comparison.
+*
+* Routing every path that crosses a module boundary through `toPosixPath` keeps the rest of the
+* code platform-agnostic. The conversion runs unconditionally so Windows-specific behavior is
+* exercisable from POSIX CI.
+*
+* @example
+* toPosixPath('C:\\repo\\src\\pet.ts') // 'C:/repo/src/pet.ts'
+*/
+function toPosixPath(filePath) {
+	return filePath.replaceAll("\\", "/");
+}
+/**
+* Builds a nested file path from a dotted name. Splits on dots that precede a letter
+* (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases
+* every earlier segment, applies `caseLast` to the final segment, and joins with `/`.
+*
+* Empty segments are dropped before joining. They arise when the name starts with a dot
+* followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to
+* an empty string). Without this a leading `/` would form, which `path.resolve` reads as an
+* absolute path, letting generated files escape the configured output directory.
+*
+* @example Nested path from a dotted name
+* `toFilePath('pet.petId') // 'pet/petId'`
+*
+* @example PascalCase the final segment
+* `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`
+*
+* @example Suffix applied to the final segment only
+* `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
+*/
+function toFilePath(name, caseLast = camelCase) {
+	const parts = name.split(/\.(?=[a-zA-Z])/);
+	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
+}
+//#endregion
+//#region src/Hookable.ts
+/**
+* Typed hook emitter that awaits all async listeners before resolving.
+* Wraps Node's `EventEmitter` with full TypeScript hook-map inference.
+*
+* @example
+* ```ts
+* const hooks = new Hookable<{ build: [name: string] }>()
+* hooks.hook('build', async (name) => { console.log(name) })
+* await hooks.callHook('build', 'petstore') // all listeners awaited
+* ```
+*/
+var Hookable = class {
+	/**
+	* Maximum number of listeners per hook before Node emits a memory-leak warning.
+	* @default 10
+	*/
+	constructor(maxListener = 10) {
+		this.#emitter.setMaxListeners(maxListener);
+	}
+	#emitter = new node_events.EventEmitter();
+	/**
+	* Calls `hookName` and awaits all registered listeners sequentially.
+	* Throws if any listener rejects, wrapping the cause with the hook name and serialized arguments.
+	*
+	* @example
+	* ```ts
+	* await hooks.callHook('build', 'petstore')
+	* ```
+	*/
+	callHook(hookName, ...hookArgs) {
+		const listeners = this.#emitter.listeners(hookName);
+		if (listeners.length === 0) return;
+		return this.#emitAll(hookName, listeners, hookArgs);
+	}
+	async #emitAll(hookName, listeners, hookArgs) {
+		for (const listener of listeners) try {
+			await listener(...hookArgs);
+		} catch (err) {
+			let serializedArgs;
+			try {
+				serializedArgs = JSON.stringify(hookArgs);
+			} catch {
+				serializedArgs = String(hookArgs);
+			}
+			throw new Error(`Error in async listener for "${hookName}" with hookArgs ${serializedArgs}`, { cause: toError(err) });
+		}
+	}
+	/**
+	* Registers a persistent listener for `hookName` and returns a function that removes it.
+	*
+	* @example
+	* ```ts
+	* const unhook = hooks.hook('build', async (name) => { console.log(name) })
+	* unhook() // removes it
+	* ```
+	*/
+	hook(hookName, handler) {
+		this.#emitter.on(hookName, handler);
+		return () => this.removeHook(hookName, handler);
+	}
+	/**
+	* Registers every handler in `configHooks` at once and returns a function that removes them
+	* all. Undefined entries are skipped, so a partial hook object registers only its present keys.
+	*
+	* @example
+	* ```ts
+	* const unhook = hooks.addHooks({ build: onBuild, done: onDone })
+	* unhook() // removes both
+	* ```
+	*/
+	addHooks(configHooks) {
+		const unhooks = Object.keys(configHooks).filter((name) => configHooks[name]).map((name) => this.hook(name, configHooks[name]));
+		return () => {
+			for (const unhook of unhooks) unhook();
+		};
+	}
+	/**
+	* Removes a previously registered listener.
+	*
+	* @example
+	* ```ts
+	* hooks.removeHook('build', handler)
+	* ```
+	*/
+	removeHook(hookName, handler) {
+		this.#emitter.off(hookName, handler);
+	}
+	/**
+	* Returns the number of listeners registered for `hookName`.
+	*
+	* @example
+	* ```ts
+	* hooks.hook('build', handler)
+	* hooks.listenerCount('build') // 1
+	* ```
+	*/
+	listenerCount(hookName) {
+		return this.#emitter.listenerCount(hookName);
+	}
+	/**
+	* Raises or lowers the per-hook listener ceiling before Node warns about a memory leak.
+	* Set this above the expected listener count when many listeners attach by design.
+	*
+	* @example
+	* ```ts
+	* hooks.setMaxListeners(40)
+	* ```
+	*/
+	setMaxListeners(max) {
+		this.#emitter.setMaxListeners(max);
+	}
+	/**
+	* Removes all listeners from every hook channel.
+	*
+	* @example
+	* ```ts
+	* hooks.removeAllHooks()
+	* ```
+	*/
+	removeAllHooks() {
+		this.#emitter.removeAllListeners();
+	}
+};
+//#endregion
+//#region src/FileManager.ts
+function joinSources(file) {
+	return file.sources.map((source) => (0, _kubb_ast.extractStringsFromNodes)(source.nodes)).filter(Boolean).join("\n\n");
+}
+async function parseCopy(file) {
+	let content;
+	try {
+		content = await read(file.copy);
+	} catch (err) {
+		throw new Error(`[kubb] Could not copy file into output: ${file.copy}`, { cause: err });
+	}
+	return [
+		file.banner,
+		content,
+		file.footer
+	].filter((segment) => Boolean(segment)).map((segment) => segment.trimEnd()).join("\n");
+}
+function mergeFile(a, b) {
+	return {
+		...a,
+		banner: b.banner,
+		footer: b.footer,
+		copy: b.copy ?? a.copy,
+		sources: a.sources.length ? b.sources.length ? [...a.sources, ...b.sources] : a.sources : b.sources,
+		imports: a.imports.length ? b.imports.length ? [...a.imports, ...b.imports] : a.imports : b.imports,
+		exports: a.exports.length ? b.exports.length ? [...a.exports, ...b.exports] : a.exports : b.exports
+	};
+}
+function isIndexPath(path) {
+	return path.endsWith("/index.ts") || path === "index.ts";
+}
+function compareFiles(a, b) {
+	const lenDiff = a.path.length - b.path.length;
+	if (lenDiff !== 0) return lenDiff;
+	const aIsIndex = isIndexPath(a.path);
+	const bIsIndex = isIndexPath(b.path);
+	if (aIsIndex && !bIsIndex) return 1;
+	if (!aIsIndex && bIsIndex) return -1;
+	return 0;
+}
+/**
+* In-memory file store for generated files, and the writer that turns them into source
+* strings on `storage`. Files sharing a `path` are merged (sources/imports/exports
+* concatenated). The `files` getter is sorted by path length (barrel `index.ts` last
+* within a bucket).
+*
+* @example
+* ```ts
+* const manager = new FileManager()
+* manager.upsert(myFile)
+* manager.files // sorted view
+* await manager.write(manager.files, { storage: fsStorage() })
+* ```
+*/
+var FileManager = class {
+	hooks = new Hookable();
+	#cache = /* @__PURE__ */ new Map();
+	#sorted = null;
+	add(...files) {
+		return this.#store(files, false);
+	}
+	upsert(...files) {
+		return this.#store(files, true);
+	}
+	#store(files, mergeExisting) {
+		const batch = files.length > 1 ? this.#dedupe(files) : files;
+		const resolved = [];
+		for (const file of batch) {
+			const existing = this.#cache.get(file.path);
+			const merged = existing && mergeExisting ? _kubb_ast.ast.factory.createFile(mergeFile(existing, file)) : _kubb_ast.ast.factory.createFile(file);
+			this.#cache.set(merged.path, merged);
+			resolved.push(merged);
+		}
+		if (resolved.length > 0) this.#sorted = null;
+		return resolved;
+	}
+	#dedupe(files) {
+		const seen = /* @__PURE__ */ new Map();
+		for (const file of files) {
+			const prev = seen.get(file.path);
+			seen.set(file.path, prev ? mergeFile(prev, file) : file);
+		}
+		return [...seen.values()];
+	}
+	clear() {
+		this.#cache.clear();
+		this.#sorted = null;
+	}
+	/**
+	* Releases all stored files and clears every `hooks` listener. Called by the core after
+	* `kubb:build:end`.
+	*/
+	dispose() {
+		this.clear();
+		this.hooks.removeAllHooks();
+	}
+	/**
+	* All stored files in stable sort order (shortest path first, barrel files
+	* last within a length bucket). Returns a cached view, do not mutate.
+	*/
+	get files() {
+		return this.#sorted ??= [...this.#cache.values()].sort(compareFiles);
+	}
+	/**
+	* Converts a file's AST sources (or its `copy` source) into the final on-disk string.
+	*/
+	async parse(file, { parsers } = {}) {
+		if (file.copy) return parseCopy(file);
+		if (!parsers || !file.extname) return joinSources(file);
+		const parser = parsers.get(file.extname);
+		if (!parser) return joinSources(file);
+		return parser.parse(file);
+	}
+	/**
+	* Converts and writes every file at once, letting `storage.setItem` decide how much of
+	* that runs concurrently.
+	*/
+	async write(files, { storage, parsers }) {
+		if (files.length === 0) return;
+		await this.hooks.callHook("start", files);
+		const total = files.length;
+		let processed = 0;
+		await Promise.all(files.map(async (file) => {
+			const source = await this.parse(file, { parsers });
+			processed++;
+			await this.hooks.callHook("update", {
+				file,
+				source,
+				processed,
+				total,
+				percentage: processed / total * 100
+			});
+			if (source) await storage.setItem(file.path, source);
+		}));
+		await this.hooks.callHook("end", files);
+	}
+};
+//#endregion
+//#region \0@oxc-project+runtime@0.138.0/helpers/esm/usingCtx.js
+function _usingCtx() {
+	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
+		var n = Error();
+		return n.name = "SuppressedError", n.error = r, n.suppressed = e, n;
+	};
+	var e = {};
+	var n = [];
+	function using(r, e) {
+		if (null != e) {
+			if (Object(e) !== e) throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
+			if (r) var o = e[Symbol.asyncDispose || Symbol["for"]("Symbol.asyncDispose")];
+			if (void 0 === o && (o = e[Symbol.dispose || Symbol["for"]("Symbol.dispose")], r)) var t = o;
+			if ("function" != typeof o) throw new TypeError("Object is not disposable.");
+			t && (o = function o() {
+				try {
+					t.call(e);
+				} catch (r) {
+					return Promise.reject(r);
+				}
+			}), n.push({
+				v: e,
+				d: o,
+				a: r
+			});
+		} else r && n.push({
+			d: e,
+			a: r
+		});
+		return e;
+	}
+	return {
+		e,
+		u: using.bind(null, !1),
+		a: using.bind(null, !0),
+		d: function d() {
+			var o;
+			var t = this.e;
+			var s = 0;
+			function next() {
+				for (; o = n.pop();) try {
+					if (!o.a && 1 === s) return s = 0, n.push(o), Promise.resolve().then(next);
+					if (o.d) {
+						var r = o.d.call(o.v);
+						if (o.a) return s |= 2, Promise.resolve(r).then(next, err);
+					} else s |= 1;
+				} catch (r) {
+					return err(r);
+				}
+				if (1 === s) return t !== e ? Promise.reject(t) : Promise.resolve();
+				if (t !== e) throw t;
+			}
+			function err(n) {
+				return t = t !== e ? new r(n, t) : n, next();
+			}
+			return next();
+		}
+	};
+}
+//#endregion
+Object.defineProperty(exports, "BuildError", {
+	enumerable: true,
+	get: function() {
+		return BuildError;
+	}
+});
+Object.defineProperty(exports, "FileManager", {
+	enumerable: true,
+	get: function() {
+		return FileManager;
+	}
+});
+Object.defineProperty(exports, "Hookable", {
+	enumerable: true,
+	get: function() {
+		return Hookable;
+	}
+});
+Object.defineProperty(exports, "__name", {
+	enumerable: true,
+	get: function() {
+		return __name;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "_usingCtx", {
+	enumerable: true,
+	get: function() {
+		return _usingCtx;
+	}
+});
+Object.defineProperty(exports, "camelCase", {
+	enumerable: true,
+	get: function() {
+		return camelCase;
+	}
+});
+Object.defineProperty(exports, "clean", {
+	enumerable: true,
+	get: function() {
+		return clean;
+	}
+});
+Object.defineProperty(exports, "getErrorMessage", {
+	enumerable: true,
+	get: function() {
+		return getErrorMessage;
+	}
+});
+Object.defineProperty(exports, "toError", {
+	enumerable: true,
+	get: function() {
+		return toError;
+	}
+});
+Object.defineProperty(exports, "toFilePath", {
+	enumerable: true,
+	get: function() {
+		return toFilePath;
+	}
+});
+Object.defineProperty(exports, "toPosixPath", {
+	enumerable: true,
+	get: function() {
+		return toPosixPath;
+	}
+});
+Object.defineProperty(exports, "write", {
+	enumerable: true,
+	get: function() {
+		return write;
+	}
+});
+
+//# sourceMappingURL=usingCtx-eyNeehd2.cjs.map