@kubb/core 4.11.3 → 4.12.1

package/dist/index.js

@@ -1,20 +1,17 @@
-import { c as Queue, i as getMode, l as getRelativePath, n as URLPath, r as PluginManager, s as PromiseManager, t as getBarrelFiles } from "./getBarrelFiles-DQ0hksqD.js";
-import { a as write, n as createLogger } from "./logger-CQn6sdC0.js";
-import "./transformers-CjdbeLAK.js";
+import { a as exists, i as readSync, n as getRelativePath, o as clean, r as read, t as write } from "./fs-ph1OdgEr.js";
+import { a as getMode, c as PromiseManager, i as PluginManager, l as Queue, n as URLPath, r as AsyncEventEmitter, t as getBarrelFiles } from "./getBarrelFiles-ClyWjO0d.js";
+import "./transformers-C481fXH-.js";
 import mod from "node:module";
-import path, { join, relative, resolve } from "node:path";
+import path, { join, resolve } from "node:path";
 import { performance } from "node:perf_hooks";
 import { createFabric } from "@kubb/react-fabric";
 import { typescriptParser } from "@kubb/react-fabric/parsers";
 import { fsPlugin } from "@kubb/react-fabric/plugins";
-import pc from "picocolors";
 import { isDeepEqual } from "remeda";
-import fs from "fs-extra";
-import { switcher } from "js-runtime";
-import g$1, { version } from "node:process";
+import process$1, { version } from "node:process";
 import os from "node:os";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import fs$1, { promises } from "node:fs";
+import fs, { promises } from "node:fs";
 import { coerce, satisfies } from "semver";
 
 //#region src/BaseGenerator.ts
@@ -70,62 +67,9 @@ function isInputPath(config) {
 	return typeof config?.input === "object" && config.input !== null && "path" in config.input;
 }
 
-//#endregion
-//#region src/fs/clean.ts
-async function clean(path$1) {
-	return fs.remove(path$1);
-}
-
-//#endregion
-//#region src/fs/exists.ts
-const reader$1 = switcher({
-	node: async (path$1) => {
-		return fs.pathExists(path$1);
-	},
-	bun: async (path$1) => {
-		return Bun.file(path$1).exists();
-	}
-}, "node");
-const syncReader$1 = switcher({
-	node: (path$1) => {
-		return fs.pathExistsSync(path$1);
-	},
-	bun: () => {
-		throw new Error("Bun cannot read sync");
-	}
-}, "node");
-async function exists(path$1) {
-	return reader$1(path$1);
-}
-
-//#endregion
-//#region src/fs/read.ts
-const reader = switcher({
-	node: async (path$1) => {
-		return fs.readFile(path$1, { encoding: "utf8" });
-	},
-	bun: async (path$1) => {
-		return Bun.file(path$1).text();
-	}
-}, "node");
-const syncReader = switcher({
-	node: (path$1) => {
-		return fs.readFileSync(path$1, { encoding: "utf8" });
-	},
-	bun: () => {
-		throw new Error("Bun cannot read sync");
-	}
-}, "node");
-async function read(path$1) {
-	return reader(path$1);
-}
-function readSync(path$1) {
-	return syncReader(path$1);
-}
-
 //#endregion
 //#region package.json
-var version$1 = "4.11.3";
+var version$1 = "4.12.1";
 
 //#endregion
 //#region src/utils/diagnostics.ts
@@ -145,12 +89,11 @@ function getDiagnosticInfo() {
 //#endregion
 //#region src/build.ts
 async function setup(options) {
-	const { config: userConfig, logger = createLogger() } = options;
+	const { config: userConfig, events = new AsyncEventEmitter() } = options;
 	const diagnosticInfo = getDiagnosticInfo();
-	if (Array.isArray(userConfig.input)) console.warn(pc.yellow("This feature is still under development — use with caution"));
-	logger.emit("debug", {
+	if (Array.isArray(userConfig.input)) await events.emit("warn", "This feature is still under development — use with caution");
+	await events.emit("debug", {
 		date: /* @__PURE__ */ new Date(),
-		category: "setup",
 		logs: [
 			"Configuration:",
 			`  • Name: ${userConfig.name || "unnamed"}`,
@@ -168,9 +111,8 @@ async function setup(options) {
 	try {
 		if (isInputPath(userConfig) && !new URLPath(userConfig.input.path).isURL) {
 			await exists(userConfig.input.path);
-			logger.emit("debug", {
+			await events.emit("debug", {
 				date: /* @__PURE__ */ new Date(),
-				category: "setup",
 				logs: [`✓ Input file validated: ${userConfig.input.path}`]
 			});
 		}
@@ -193,9 +135,8 @@ async function setup(options) {
 		plugins: userConfig.plugins
 	};
 	if (definedConfig.output.clean) {
-		logger.emit("debug", {
+		await events.emit("debug", {
 			date: /* @__PURE__ */ new Date(),
-			category: "setup",
 			logs: [
 				"Cleaning output directories",
 				`  • Output: ${definedConfig.output.path}`,
@@ -208,123 +149,45 @@ async function setup(options) {
 	const fabric = createFabric();
 	fabric.use(fsPlugin, { dryRun: !definedConfig.output.write });
 	fabric.use(typescriptParser);
-	fabric.context.on("process:start", ({ files }) => {
-		logger.emit("progress_start", {
-			id: "files",
-			size: files.length,
-			message: "Writing files ..."
-		});
-		logger.emit("debug", {
+	fabric.context.on("files:processing:start", (files) => {
+		events.emit("files:processing:start", files);
+		events.emit("debug", {
 			date: /* @__PURE__ */ new Date(),
-			category: "file",
 			logs: [`Writing ${files.length} files...`]
 		});
 	});
-	fabric.context.on("process:progress", async ({ file, source }) => {
-		const message = file ? `Writing ${relative(definedConfig.root, file.path)}` : "";
-		logger.emit("progressed", {
-			id: "files",
-			message
+	fabric.context.on("file:processing:update", async (params) => {
+		const { file, source } = params;
+		await events.emit("file:processing:update", {
+			...params,
+			config: definedConfig,
+			source
 		});
 		if (source) await write(file.path, source, { sanity: false });
 	});
-	fabric.context.on("process:end", () => {
-		logger.emit("progress_stop", { id: "files" });
-		logger.emit("debug", {
+	fabric.context.on("files:processing:end", async (files) => {
+		await events.emit("files:processing:end", files);
+		await events.emit("debug", {
 			date: /* @__PURE__ */ new Date(),
-			category: "file",
 			logs: ["✓ File write process completed"]
 		});
 	});
-	logger.emit("debug", {
+	await events.emit("debug", {
 		date: /* @__PURE__ */ new Date(),
-		category: "setup",
 		logs: [
 			"✓ Fabric initialized",
 			`  • File writing: ${definedConfig.output.write ? "enabled" : "disabled (dry-run)"}`,
 			`  • Barrel type: ${definedConfig.output.barrelType || "none"}`
 		]
 	});
-	const pluginManager = new PluginManager(definedConfig, {
-		fabric,
-		logger,
-		concurrency: 5
-	});
-	pluginManager.on("executing", ({ plugin, hookName, strategy, parameters }) => {
-		logger.emit("debug", {
-			date: /* @__PURE__ */ new Date(),
-			category: "hook",
-			pluginName: plugin.name,
-			logs: [
-				`Executing hook: ${hookName}`,
-				`  • Strategy: ${strategy}`,
-				"  • Parameters:",
-				JSON.stringify(parameters, null, 2)
-			]
-		});
-	});
-	pluginManager.on("executed", ({ plugin, hookName, duration, parameters }) => {
-		let message = "";
-		if (hookName === "resolvePath") {
-			const [path$1] = parameters || [];
-			message = `Resolving path '${path$1}'`;
-		}
-		if (hookName === "resolveName") {
-			const [name, type] = parameters || [];
-			message = `Resolving name '${name}' and type '${type}'`;
-		}
-		logger.emit("progressed", {
-			id: hookName,
-			message: `${plugin.name}: ${message}`
-		});
-		logger.emit("debug", {
-			date: /* @__PURE__ */ new Date(),
-			category: "hook",
-			pluginName: plugin.name,
-			logs: [`✓ Completed in ${duration}ms`]
-		});
-	});
-	pluginManager.on("progress_start", ({ hookName, plugins }) => {
-		logger.emit("progress_start", {
-			id: hookName,
-			size: plugins.length,
-			message: "Running plugins..."
-		});
-	});
-	pluginManager.on("progress_stop", ({ hookName }) => {
-		logger.emit("progress_stop", { id: hookName });
-	});
-	pluginManager.on("error", (error, { plugin, strategy, duration, parameters, hookName }) => {
-		const text = `${error.message} (plugin: ${plugin?.name || "unknown"}, hook: ${hookName || "unknown"})`;
-		logger.emit("error", text, error);
-		logger.emit("debug", {
-			date: /* @__PURE__ */ new Date(),
-			category: "error",
-			pluginName: plugin.name,
-			logs: [
-				`✗ Hook '${hookName}' failed after ${duration}ms`,
-				`  • Strategy: ${strategy}`,
-				`  • Error: ${error.constructor.name} - ${error.message}`,
-				"  • Stack Trace:",
-				error.stack || "No stack trace available",
-				"  • Parameters:",
-				JSON.stringify(parameters, null, 2)
-			]
-		});
-	});
-	logger.emit("debug", {
-		date: /* @__PURE__ */ new Date(),
-		category: "setup",
-		logs: [
-			"✓ PluginManager initialized",
-			"  • Concurrency: 5",
-			`  • Total plugins: ${pluginManager.plugins.length}`
-		]
-	});
 	return {
-		logger,
+		events,
 		fabric,
-		pluginManager
+		pluginManager: new PluginManager(definedConfig, {
+			fabric,
+			events,
+			concurrency: 5
+		})
 	};
 }
 async function build(options, overrides) {
@@ -340,7 +203,7 @@ async function build(options, overrides) {
 	};
 }
 async function safeBuild(options, overrides) {
-	const { fabric, pluginManager, logger } = overrides ? overrides : await setup(options);
+	const { fabric, pluginManager, events } = overrides ? overrides : await setup(options);
 	const failedPlugins = /* @__PURE__ */ new Set();
 	const pluginTimings = /* @__PURE__ */ new Map();
 	const config = pluginManager.config;
@@ -351,40 +214,24 @@ async function safeBuild(options, overrides) {
 			try {
 				const startTime = performance.now();
 				const timestamp = /* @__PURE__ */ new Date();
-				logger.emit("debug", {
-					date: timestamp,
-					pluginGroupMarker: "start",
-					pluginName: plugin.name,
-					logs: []
-				});
-				logger.emit("debug", {
+				await events.emit("plugin:start", plugin);
+				await events.emit("debug", {
 					date: timestamp,
-					category: "plugin",
-					pluginName: plugin.name,
 					logs: ["Installing plugin...", `  • Plugin Key: ${JSON.stringify(plugin.key)}`]
 				});
 				await installer(context);
 				const duration = Math.round(performance.now() - startTime);
 				pluginTimings.set(plugin.name, duration);
-				logger.emit("debug", {
+				await events.emit("plugin:end", plugin, duration);
+				await events.emit("debug", {
 					date: /* @__PURE__ */ new Date(),
-					category: "plugin",
-					pluginName: plugin.name,
 					logs: [`✓ Plugin installed successfully (${duration}ms)`]
 				});
-				logger.emit("debug", {
-					date: /* @__PURE__ */ new Date(),
-					pluginGroupMarker: "end",
-					pluginName: plugin.name,
-					logs: []
-				});
 			} catch (e) {
 				const error = e;
 				const errorTimestamp = /* @__PURE__ */ new Date();
-				logger.emit("debug", {
+				await events.emit("debug", {
 					date: errorTimestamp,
-					category: "error",
-					pluginName: plugin.name,
 					logs: [
 						"✗ Plugin installation failed",
 						`  • Plugin Key: ${JSON.stringify(plugin.key)}`,
@@ -393,12 +240,6 @@ async function safeBuild(options, overrides) {
 						error.stack || "No stack trace available"
 					]
 				});
-				logger.emit("debug", {
-					date: errorTimestamp,
-					pluginGroupMarker: "end",
-					pluginName: plugin.name,
-					logs: []
-				});
 				failedPlugins.add({
 					plugin,
 					error
@@ -407,7 +248,7 @@ async function safeBuild(options, overrides) {
 		}
 		if (config.output.barrelType) {
 			const rootPath = resolve(resolve(config.root), config.output.path, "index.ts");
-			logger.emit("debug", {
+			await events.emit("debug", {
 				date: /* @__PURE__ */ new Date(),
 				logs: [
 					"Generating barrel file",
@@ -418,7 +259,7 @@ async function safeBuild(options, overrides) {
 			const barrelFiles = fabric.files.filter((file) => {
 				return file.sources.some((source) => source.isIndexable);
 			});
-			logger.emit("debug", {
+			await events.emit("debug", {
 				date: /* @__PURE__ */ new Date(),
 				logs: [`Found ${barrelFiles.length} indexable files for barrel export`]
 			});
@@ -445,9 +286,8 @@ async function safeBuild(options, overrides) {
 				meta: {}
 			};
 			await fabric.upsertFile(rootFile);
-			logger.emit("debug", {
+			await events.emit("debug", {
 				date: /* @__PURE__ */ new Date(),
-				category: "file",
 				logs: [`✓ Generated barrel file (${rootFile.exports?.length || 0} exports)`]
 			});
 		}
@@ -472,6 +312,12 @@ async function safeBuild(options, overrides) {
 	}
 }
 
+//#endregion
+//#region src/defineLogger.ts
+function defineLogger(logger) {
+	return { ...logger };
+}
+
 //#endregion
 //#region src/definePlugin.ts
 /**
@@ -558,7 +404,7 @@ function checkType(type) {
 }
 const matchType = (type, stat) => stat[typeMappings[type]]();
 const toPath$1 = (urlOrPath) => urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
-async function locatePath(paths, { cwd = g$1.cwd(), type = "file", allowSymlinks = true, concurrency, preserveOrder } = {}) {
+async function locatePath(paths, { cwd = process$1.cwd(), type = "file", allowSymlinks = true, concurrency, preserveOrder } = {}) {
 	checkType(type);
 	cwd = toPath$1(cwd);
 	const statFunction = allowSymlinks ? promises.stat : promises.lstat;
@@ -573,10 +419,10 @@ async function locatePath(paths, { cwd = g$1.cwd(), type = "file", allowSymlinks
 		preserveOrder
 	});
 }
-function locatePathSync(paths, { cwd = g$1.cwd(), type = "file", allowSymlinks = true } = {}) {
+function locatePathSync(paths, { cwd = process$1.cwd(), type = "file", allowSymlinks = true } = {}) {
 	checkType(type);
 	cwd = toPath$1(cwd);
-	const statFunction = allowSymlinks ? fs$1.statSync : fs$1.lstatSync;
+	const statFunction = allowSymlinks ? fs.statSync : fs.lstatSync;
 	for (const path_ of paths) try {
 		const stat = statFunction(path.resolve(cwd, path_), { throwIfNoEntry: false });
 		if (!stat) continue;
@@ -747,5 +593,16 @@ var PackageManager = class PackageManager {
 };
 
 //#endregion
-export { BaseGenerator, PackageManager, PluginManager, PromiseManager, build, build as default, defineConfig, definePlugin, getBarrelFiles, getMode, isInputPath, safeBuild, setup };
+//#region src/types.ts
+const LogLevel = {
+	silent: Number.NEGATIVE_INFINITY,
+	error: 0,
+	warn: 1,
+	info: 3,
+	verbose: 4,
+	debug: 5
+};
+
+//#endregion
+export { BaseGenerator, LogLevel, PackageManager, PluginManager, PromiseManager, build, build as default, defineConfig, defineLogger, definePlugin, getBarrelFiles, getMode, isInputPath, safeBuild, setup };
 //# sourceMappingURL=index.js.map