@kubb/core 5.0.0-alpha.43 → 5.0.0-alpha.44

package/dist/index.js

@@ -1,5 +1,5 @@
-import "./chunk--u3MIqq1.js";
-import { a as definePlugin, c as DEFAULT_BANNER, d as logLevel, f as isValidVarName, i as defineResolver, l as DEFAULT_EXTENSION, n as applyHookResult, o as pLimit, p as camelCase, r as FileManager, s as BARREL_FILENAME, t as PluginDriver, u as DEFAULT_STUDIO_URL } from "./PluginDriver-CgXFtmNP.js";
+import { t as __name } from "./chunk--u3MIqq1.js";
+import { c as DEFAULT_EXTENSION, d as camelCase, i as defineResolver, l as DEFAULT_STUDIO_URL, n as applyHookResult, o as BARREL_FILENAME, r as FileManager, s as DEFAULT_BANNER, t as PluginDriver, u as logLevel } from "./PluginDriver-Bt_UCn7-.js";
 import { EventEmitter } from "node:events";
 import { access, mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import path, { dirname, join, posix, resolve } from "node:path";
@@ -268,6 +268,26 @@ async function clean(path) {
 	});
 }
 //#endregion
+//#region ../../internals/utils/src/reserved.ts
+/**
+* Returns `true` when `name` is a syntactically valid JavaScript variable name.
+*
+* @example
+* ```ts
+* isValidVarName('status')  // true
+* isValidVarName('class')   // false (reserved word)
+* isValidVarName('42foo')   // false (starts with digit)
+* ```
+*/
+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.
@@ -434,6 +454,136 @@ function createAdapter(build) {
 	return (options) => build(options ?? {});
 }
 //#endregion
+//#region ../../node_modules/.pnpm/yocto-queue@1.2.2/node_modules/yocto-queue/index.js
+var Node$1 = class {
+	static {
+		__name(this, "Node");
+	}
+	value;
+	next;
+	constructor(value) {
+		this.value = value;
+	}
+};
+var Queue = class {
+	#head;
+	#tail;
+	#size;
+	constructor() {
+		this.clear();
+	}
+	enqueue(value) {
+		const node = new Node$1(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--;
+		if (!this.#head) this.#tail = void 0;
+		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.3.0/node_modules/p-limit/index.js
+function pLimit(concurrency) {
+	let rejectOnClear = false;
+	if (typeof concurrency === "object") ({concurrency, rejectOnClear = false} = concurrency);
+	validateConcurrency(concurrency);
+	if (typeof rejectOnClear !== "boolean") throw new TypeError("Expected `rejectOnClear` to be a boolean");
+	const queue = new Queue();
+	let activeCount = 0;
+	const resumeNext = () => {
+		if (activeCount < concurrency && queue.size > 0) {
+			activeCount++;
+			queue.dequeue().run();
+		}
+	};
+	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, reject, arguments_) => {
+		const queueItem = { reject };
+		new Promise((internalResolve) => {
+			queueItem.run = internalResolve;
+			queue.enqueue(queueItem);
+		}).then(run.bind(void 0, function_, resolve, arguments_));
+		if (activeCount < concurrency) resumeNext();
+	};
+	const generator = (function_, ...arguments_) => new Promise((resolve, reject) => {
+		enqueue(function_, resolve, reject, arguments_);
+	});
+	Object.defineProperties(generator, {
+		activeCount: { get: () => activeCount },
+		pendingCount: { get: () => queue.size },
+		clearQueue: { value() {
+			if (!rejectOnClear) {
+				queue.clear();
+				return;
+			}
+			const abortError = AbortSignal.abort().reason;
+			while (queue.size > 0) queue.dequeue().reject(abortError);
+		} },
+		concurrency: {
+			get: () => concurrency,
+			set(newConcurrency) {
+				validateConcurrency(newConcurrency);
+				concurrency = newConcurrency;
+				queueMicrotask(() => {
+					while (activeCount < concurrency && queue.size > 0) resumeNext();
+				});
+			}
+		},
+		map: { async value(iterable, function_) {
+			const promises = Array.from(iterable, (value, index) => this(function_, value, index));
+			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/FileProcessor.ts
 function joinSources(file) {
 	return file.sources.map((item) => extractStringsFromNodes(item.nodes)).filter(Boolean).join("\n\n");
@@ -441,6 +591,8 @@ function joinSources(file) {
 /**
 * Converts a single file to a string using the registered parsers.
 * Falls back to joining source values when no matching parser is found.
+*
+* @internal
 */
 var FileProcessor = class {
 	#limit = pLimit(100);
@@ -585,7 +737,7 @@ const fsStorage = createStorage(() => ({
 }));
 //#endregion
 //#region package.json
-var version$1 = "5.0.0-alpha.43";
+var version$1 = "5.0.0-alpha.44";
 //#endregion
 //#region src/utils/diagnostics.ts
 /**
@@ -769,8 +921,8 @@ function getBarrelFilesByRoot(root, files) {
 	TreeNode.build(files, root)?.forEach((treeNode) => {
 		if (!treeNode?.children || !treeNode.parent?.data.path) return;
 		const barrelFile = createFile({
-			path: join(treeNode.parent?.data.path, "index.ts"),
-			baseName: "index.ts",
+			path: join(treeNode.parent?.data.path, BARREL_FILENAME),
+			baseName: BARREL_FILENAME,
 			exports: [],
 			imports: [],
 			sources: []
@@ -906,10 +1058,7 @@ async function setup(userConfig, options = {}) {
 		});
 		await storage?.clear(resolve(config.root, config.output.path));
 	}
-	const driver = new PluginDriver(config, {
-		hooks,
-		concurrency: 15
-	});
+	const driver = new PluginDriver(config, { hooks });
 	const adapter = config.adapter;
 	if (!adapter) throw new Error("No adapter configured. Please provide an adapter in your kubb.config.ts.");
 	const source = inputToAdapterSource(config);
@@ -1032,7 +1181,6 @@ async function safeBuild(setupResult) {
 					date: timestamp,
 					logs: ["Starting plugin...", `  • Plugin Name: ${plugin.name}`]
 				});
-				await plugin.buildStart.call(context);
 				if (plugin.generators?.length || driver.hasRegisteredGenerators(plugin.name)) await runPluginAstHooks(plugin, context);
 				if (output) {
 					const barrelFiles = await getBarrelFiles(driver.fileManager.files, {
@@ -1153,10 +1301,6 @@ async function safeBuild(setupResult) {
 				});
 			}
 		});
-		for (const plugin of driver.plugins.values()) if (plugin.buildEnd) {
-			const context = driver.getContext(plugin);
-			await plugin.buildEnd.call(context);
-		}
 		await hooks.emit("kubb:build:end", {
 			files,
 			config,
@@ -1371,6 +1515,34 @@ function defineParser(parser) {
 	return parser;
 }
 //#endregion
+//#region src/definePlugin.ts
+/**
+* Creates a plugin factory using the hook-style (`hooks:`) API.
+*
+* The returned factory is called with optional options and produces a `Plugin`
+* that coexists with plugins created via the legacy `createPlugin` API in the same
+* `kubb.config.ts`.
+*
+* Lifecycle handlers are registered on the `PluginDriver`'s `AsyncEventEmitter`, enabling
+* both the plugin's own handlers and external tooling (CLI, devtools) to observe every event.
+*
+* @example
+* ```ts
+* // With PluginFactoryOptions (recommended for real plugins)
+* export const pluginTs = definePlugin<PluginTs>((options) => ({
+*   name: 'plugin-ts',
+*   hooks: {
+*     'kubb:plugin:setup'(ctx) {
+*       ctx.setResolver(resolverTs)  // typed as Partial<ResolverTs>
+*     },
+*   },
+* }))
+* ```
+*/
+function definePlugin(factory) {
+	return (options) => factory(options ?? {});
+}
+//#endregion
 //#region src/storages/memoryStorage.ts
 /**
 * In-memory storage driver. Useful for testing and dry-run scenarios where