@kubb/core 4.3.1 → 4.4.1

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import { a as Mode, i as File, s as ResolvedFile } from "./index-BTe91LHd.js";
-import { n as Logger } from "./logger-BA-za85-.js";
-import { _ as ResolvePathParams, a as InputData, b as UserPluginWithLifeCycle, c as Plugin, d as PluginKey, f as PluginLifecycle, g as ResolveNameParams, h as PluginWithLifeCycle, i as Group, l as PluginContext, m as PluginParameter, n as Config, o as InputPath, p as PluginLifecycleHooks, r as GetPluginFactoryOptions, s as Output, t as BarrelType, u as PluginFactoryOptions, v as UserConfig, x as PluginManager, y as UserPlugin } from "./types-DPeNK0FO.js";
-import { t as PossiblePromise } from "./types-BzI9JlV8.js";
-import { FileManager } from "@kubb/fabric-core";
+import { n as Logger } from "./logger-BwhJWK-H.js";
+import { _ as ResolvePathParams, a as InputData, b as UserPluginWithLifeCycle, c as Plugin, d as PluginKey, f as PluginLifecycle, g as ResolveNameParams, h as PluginWithLifeCycle, i as Group, l as PluginContext, m as PluginParameter, n as Config, o as InputPath, p as PluginLifecycleHooks, r as GetPluginFactoryOptions, s as Output, t as BarrelType, u as PluginFactoryOptions, v as UserConfig, x as PluginManager, y as UserPlugin } from "./types-CyDeSlGF.js";
+import { t as PossiblePromise } from "./types-DCR_QgGt.js";
+import { Fabric } from "@kubb/react-fabric";
+import { KubbFile } from "@kubb/fabric-core/types";
 
 //#region src/BaseGenerator.d.ts
 /**
@@ -25,19 +25,23 @@ type BuildOptions = {
    * @default Logger without the spinner
    */
   logger?: Logger;
-  pluginManager?: PluginManager;
 };
 type BuildOutput = {
-  files: Array<ResolvedFile>;
+  fabric: Fabric;
+  files: Array<KubbFile.ResolvedFile>;
   pluginManager: PluginManager;
   /**
    * Only for safeBuild
    */
   error?: Error;
 };
-declare function setup(options: BuildOptions): Promise<PluginManager>;
-declare function build(options: BuildOptions): Promise<BuildOutput>;
-declare function safeBuild(options: BuildOptions): Promise<BuildOutput>;
+type SetupResult = {
+  fabric: Fabric;
+  pluginManager: PluginManager;
+};
+declare function setup(options: BuildOptions): Promise<SetupResult>;
+declare function build(options: BuildOptions, overrides?: SetupResult): Promise<BuildOutput>;
+declare function safeBuild(options: BuildOptions, overrides?: SetupResult): Promise<BuildOutput>;
 //#endregion
 //#region src/config.d.ts
 type Args = {
@@ -95,14 +99,14 @@ type AddIndexesProps = {
   logger?: Logger;
   meta?: FileMetaBase;
 };
-declare function getMode(path: string | undefined | null): Mode;
-declare function getBarrelFiles(files: Array<ResolvedFile>, {
+declare function getMode(path: string | undefined | null): KubbFile.Mode;
+declare function getBarrelFiles(files: Array<KubbFile.ResolvedFile>, {
   type,
   meta,
   root,
   output,
   logger
-}: AddIndexesProps): Promise<File[]>;
+}: AddIndexesProps): Promise<KubbFile.File[]>;
 //#endregion
 //#region src/PackageManager.d.ts
 type PackageJSON = {
@@ -130,24 +134,24 @@ declare class PackageManager {
 //#endregion
 //#region src/utils/executeStrategies.d.ts
 type PromiseFunc$1<T = unknown, T2 = never> = (state?: T) => T2 extends never ? Promise<T> : Promise<T> | T2;
-type ValueOfPromiseFuncArray<TInput$1 extends Array<unknown>> = TInput$1 extends Array<PromiseFunc$1<infer X, infer Y>> ? X | Y : never;
-type SeqOutput<TInput$1 extends Array<PromiseFunc$1<TValue$1, null>>, TValue$1> = Promise<Array<Awaited<ValueOfPromiseFuncArray<TInput$1>>>>;
+type ValueOfPromiseFuncArray<TInput extends Array<unknown>> = TInput extends Array<PromiseFunc$1<infer X, infer Y>> ? X | Y : never;
+type SeqOutput<TInput extends Array<PromiseFunc$1<TValue, null>>, TValue> = Promise<Array<Awaited<ValueOfPromiseFuncArray<TInput>>>>;
 /**
  * Chains promises
  */
 
-type HookFirstOutput<TInput$1 extends Array<PromiseFunc$1<TValue$1, null>>, TValue$1 = unknown> = ValueOfPromiseFuncArray<TInput$1>;
+type HookFirstOutput<TInput extends Array<PromiseFunc$1<TValue, null>>, TValue = unknown> = ValueOfPromiseFuncArray<TInput>;
 /**
  * Chains promises, first non-null result stops and returns
  */
 
-type HookParallelOutput<TInput$1 extends Array<PromiseFunc$1<TValue$1, null>>, TValue$1> = Promise<PromiseSettledResult<Awaited<ValueOfPromiseFuncArray<TInput$1>>>[]>;
+type HookParallelOutput<TInput extends Array<PromiseFunc$1<TValue, null>>, TValue> = Promise<PromiseSettledResult<Awaited<ValueOfPromiseFuncArray<TInput>>>[]>;
 /**
  * Runs an array of promise functions with optional concurrency limit.
  */
 
 type Strategy = 'seq' | 'first' | 'parallel';
-type StrategySwitch<TStrategy$1 extends Strategy, TInput$1 extends Array<PromiseFunc$1<TValue$1, null>>, TValue$1> = TStrategy$1 extends 'first' ? HookFirstOutput<TInput$1, TValue$1> : TStrategy$1 extends 'seq' ? SeqOutput<TInput$1, TValue$1> : TStrategy$1 extends 'parallel' ? HookParallelOutput<TInput$1, TValue$1> : never;
+type StrategySwitch<TStrategy extends Strategy, TInput extends Array<PromiseFunc$1<TValue, null>>, TValue> = TStrategy extends 'first' ? HookFirstOutput<TInput, TValue> : TStrategy extends 'seq' ? SeqOutput<TInput, TValue> : TStrategy extends 'parallel' ? HookParallelOutput<TInput, TValue> : never;
 //#endregion
 //#region src/PromiseManager.d.ts
 type PromiseFunc<T = unknown, T2 = never> = () => T2 extends never ? Promise<T> : Promise<T> | T2;

package/dist/index.js

@@ -1,19 +1,19 @@
-import { a as read, c as clean, o as readSync, r as getRelativePath, s as exists, t as trimExtName } from "./fs-BIPMUfpW.js";
-import { t as write } from "./write-CxO1CDML.js";
-import { a as EventEmitter, n as createLogger } from "./logger-CDxSrFkR.js";
-import { h as trim, v as transformReservedWord } from "./transformers-DzHGqYO2.js";
-import { r as setUniqueName, t as URLPath } from "./URLPath-BYceu_vY.js";
-import "./casing-BSeq_teY.js";
+import { a as EventEmitter, n as createLogger, o as write } from "./logger-Bxe022ug.js";
+import { g as trim, y as transformReservedWord } from "./transformers-CeNW0G32.js";
+import { r as setUniqueName, t as URLPath } from "./URLPath-DbWtfVa1.js";
 import mod from "node:module";
-import path, { extname, join, relative, resolve } from "node:path";
-import { typescriptParser } from "@kubb/react";
+import path, { extname, join, normalize, relative, resolve } from "node:path";
+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 from "node:process";
-import { FileManager } from "@kubb/fabric-core";
 import os from "node:os";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import fs, { promises } from "node:fs";
+import fs$1, { promises } from "node:fs";
 import { coerce, satisfies } from "semver";
 
 //#region src/BaseGenerator.ts
@@ -55,6 +55,74 @@ function isInputPath(result) {
 	return !!result && "path" in result?.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 src/fs/utils.ts
+function slash(path$1, platform = "linux") {
+	const isWindowsPath = /^\\\\\?\\/.test(path$1);
+	const normalizedPath = normalize(path$1);
+	if (["linux", "mac"].includes(platform) && !isWindowsPath) return normalizedPath.replaceAll(/\\/g, "/").replace("../", "");
+	return normalizedPath.replaceAll(/\\/g, "/").replace("../", "");
+}
+function getRelativePath(rootDir, filePath, platform = "linux") {
+	if (!rootDir || !filePath) throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ""} ${filePath || ""}`);
+	const slashedPath = slash(relative(rootDir, filePath), platform);
+	if (slashedPath.startsWith("../")) return slashedPath;
+	return `./${slashedPath}`;
+}
+
 //#endregion
 //#region src/errors.ts
 var ValidationPluginError = class extends Error {};
@@ -238,13 +306,16 @@ function createPlugin(factory) {
 	};
 }
 const pluginCore = createPlugin((options) => {
-	const { fileManager, pluginManager, resolvePath, resolveName, logger } = options;
+	const { fabric, pluginManager, resolvePath, resolveName, logger } = options;
 	return {
 		name: "core",
 		options,
 		key: ["core"],
 		context() {
 			return {
+				get fabric() {
+					return fabric;
+				},
 				get config() {
 					return options.config;
 				},
@@ -255,10 +326,12 @@ const pluginCore = createPlugin((options) => {
 					return options.plugin;
 				},
 				logger,
-				fileManager,
+				get fileManager() {
+					return fabric.context.fileManager;
+				},
 				pluginManager,
 				async addFile(...files) {
-					const resolvedFiles = await fileManager.add(...files);
+					const resolvedFiles = await fabric.context.fileManager.add(...files);
 					if (!Array.isArray(resolvedFiles)) return [resolvedFiles];
 					return resolvedFiles;
 				},
@@ -280,10 +353,6 @@ const pluginCore = createPlugin((options) => {
 //#region src/PluginManager.ts
 var PluginManager = class {
 	plugins = /* @__PURE__ */ new Set();
-	/**
-	* @deprecated do not use from pluginManager
-	*/
-	fileManager;
 	events = new EventEmitter();
 	config;
 	executed = [];
@@ -296,13 +365,12 @@ var PluginManager = class {
 		this.config = config;
 		this.options = options;
 		this.logger = options.logger;
-		this.fileManager = new FileManager();
 		this.#promiseManager = new PromiseManager({ nullCheck: (state) => !!state?.result });
 		const core = pluginCore({
+			fabric: options.fabric,
 			config,
 			logger: this.logger,
 			pluginManager: this,
-			fileManager: this.fileManager,
 			resolvePath: this.resolvePath.bind(this),
 			resolveName: this.resolveName.bind(this),
 			getPlugins: this.#getSortedPlugins.bind(this)
@@ -724,7 +792,6 @@ var PluginManager = class {
 //#endregion
 //#region src/build.ts
 async function setup(options) {
-	if (options.pluginManager) return options.pluginManager;
 	const { config: userConfig, logger = createLogger() } = options;
 	if (Array.isArray(userConfig.input)) console.warn(pc.yellow("This feature is still under development — use with caution"));
 	try {
@@ -748,36 +815,32 @@ async function setup(options) {
 		await clean(definedConfig.output.path);
 		await clean(join(definedConfig.root, ".kubb"));
 	}
-	return new PluginManager(definedConfig, {
-		logger,
-		concurrency: 5
-	});
+	const fabric = createFabric();
+	fabric.use(fsPlugin, { dryRun: !definedConfig.output.write });
+	fabric.use(typescriptParser);
+	return {
+		fabric,
+		pluginManager: new PluginManager(definedConfig, {
+			fabric,
+			logger,
+			concurrency: 5
+		})
+	};
 }
-async function build(options) {
-	const { files, pluginManager, error } = await safeBuild(options);
+async function build(options, overrides) {
+	const { fabric, files, pluginManager, error } = await safeBuild(options, overrides);
 	if (error) throw error;
 	return {
+		fabric,
 		files,
 		pluginManager,
 		error
 	};
 }
-async function safeBuild(options) {
-	const pluginManager = await setup(options);
+async function safeBuild(options, overrides) {
+	const { fabric, pluginManager } = overrides ? overrides : await setup(options);
 	const config = pluginManager.config;
 	try {
-		pluginManager.events.on("executing", ({ plugin, message }) => {
-			pluginManager.logger.emit("debug", {
-				date: /* @__PURE__ */ new Date(),
-				logs: [`Executing pluginKey ${plugin.key?.join(".")} | ${message}`]
-			});
-		});
-		pluginManager.events.on("executed", ({ plugin, message, output }) => {
-			pluginManager.logger.emit("debug", {
-				date: /* @__PURE__ */ new Date(),
-				logs: [`Executed pluginKey ${plugin.key?.join(".")} | ${message} |  ${JSON.stringify(output, void 0, 2)}`]
-			});
-		});
 		await pluginManager.hookParallel({
 			hookName: "buildStart",
 			parameters: [config],
@@ -788,7 +851,7 @@ async function safeBuild(options) {
 			const rootFile = {
 				path: rootPath,
 				baseName: "index.ts",
-				exports: (await pluginManager.fileManager.files).filter((file) => {
+				exports: fabric.files.filter((file) => {
 					return file.sources.some((source) => source.isIndexable);
 				}).flatMap((file) => {
 					const containsOnlyTypes = file.sources?.every((source) => source.isTypeOnly);
@@ -809,16 +872,16 @@ async function safeBuild(options) {
 				sources: [],
 				meta: {}
 			};
-			await pluginManager.fileManager.add(rootFile);
+			await fabric.addFile(rootFile);
 		}
-		pluginManager.fileManager.processor.events.on("process:start", ({ files: files$1 }) => {
+		fabric.context.events.on("process:start", ({ files: files$1 }) => {
 			pluginManager.logger.emit("progress_start", {
 				id: "files",
 				size: files$1.length,
 				message: "Writing files ..."
 			});
 		});
-		pluginManager.fileManager.processor.events.on("process:progress", async ({ file, source }) => {
+		fabric.context.events.on("process:progress", async ({ file, source }) => {
 			const message = file ? `Writing ${relative(config.root, file.path)}` : "";
 			pluginManager.logger.emit("progressed", {
 				id: "files",
@@ -826,26 +889,23 @@ async function safeBuild(options) {
 			});
 			if (source) await write(file.path, source, { sanity: false });
 		});
-		pluginManager.fileManager.processor.events.on("process:end", () => {
+		fabric.context.events.on("process:end", () => {
 			pluginManager.logger.emit("progress_stop", { id: "files" });
 		});
-		const parsers = new Set([typescriptParser]);
-		const files = await pluginManager.fileManager.write({
-			extension: config.output.extension,
-			dryRun: !config.output.write,
-			parsers
-		});
+		const files = [...fabric.files];
+		await fabric.write({ extension: config.output.extension });
 		await pluginManager.hookParallel({
 			hookName: "buildEnd",
 			message: `Build stopped for ${config.name}`
 		});
-		await pluginManager.fileManager.clear();
 		return {
+			fabric,
 			files,
 			pluginManager
 		};
 	} catch (e) {
 		return {
+			fabric,
 			files: [],
 			pluginManager,
 			error: e
@@ -1038,6 +1098,9 @@ function getMode(path$1) {
 	if (!path$1) return "split";
 	return extname(path$1) ? "single" : "split";
 }
+function trimExtName(text) {
+	return text.replace(/\.[^/.]+$/, "");
+}
 async function getBarrelFiles(files, { type, meta = {}, root, output, logger }) {
 	if (!type || type === "propagate") return [];
 	const barrelManager = new BarrelManager({ logger });
@@ -1165,7 +1228,7 @@ async function locatePath(paths, { cwd = g$1.cwd(), type = "file", allowSymlinks
 function locatePathSync(paths, { cwd = g$1.cwd(), type = "file", allowSymlinks = true } = {}) {
 	checkType(type);
 	cwd = toPath$1(cwd);
-	const statFunction = allowSymlinks ? fs.statSync : fs.lstatSync;
+	const statFunction = allowSymlinks ? fs$1.statSync : fs$1.lstatSync;
 	for (const path_ of paths) try {
 		const stat = statFunction(path.resolve(cwd, path_), { throwIfNoEntry: false });
 		if (!stat) continue;