@kubb/agent 5.0.0-alpha.34 → 5.0.0-alpha.36

package/.output/server/node_modules/@kubb/fabric-core/dist/parsers/typescript.js

@@ -0,0 +1,101 @@
+import "../chunk-O_arW02_.js";
+import { n as defineParser, r as trimExtName, t as getRelativePath } from "../getRelativePath-NAm_Y-vp.js";
+import path from "node:path";
+import ts from "typescript";
+//#region src/parsers/typescriptParser.ts
+const { factory } = ts;
+/**
+* Validates TypeScript AST nodes before printing to catch invalid nodes early.
+* Throws an error if any node has SyntaxKind.Unknown which would cause the TypeScript printer to crash.
+*/
+function validateNodes(...nodes) {
+	for (const node of nodes) {
+		if (!node) throw new Error("Attempted to print undefined or null TypeScript node");
+		if (node.kind === ts.SyntaxKind.Unknown) throw new Error(`Invalid TypeScript AST node detected with SyntaxKind.Unknown. This typically indicates a schema pattern that couldn't be properly converted to TypeScript. Node: ${JSON.stringify(node, null, 2)}`);
+	}
+}
+/**
+* Convert AST TypeScript/TSX nodes to a string based on the TypeScript printer.
+*/
+function print(...elements) {
+	const sourceFile = ts.createSourceFile("print.tsx", "", ts.ScriptTarget.ES2022, true, ts.ScriptKind.TSX);
+	const printer = ts.createPrinter({
+		omitTrailingSemicolon: true,
+		newLine: ts.NewLineKind.LineFeed,
+		removeComments: false,
+		noEmitHelpers: true
+	});
+	for (const node of elements) if (node.kind === ts.SyntaxKind.Unknown) console.error("⚠️ Unknown node found:", node);
+	return printer.printList(ts.ListFormat.MultiLine, factory.createNodeArray(elements.filter(Boolean)), sourceFile).replace(/\r\n/g, "\n");
+}
+function safePrint(...elements) {
+	validateNodes(...elements);
+	return print(...elements);
+}
+function createImport({ name, path, root, isTypeOnly = false, isNameSpace = false }) {
+	const resolvePath = root ? getRelativePath(root, path) : path;
+	if (!Array.isArray(name)) {
+		if (isNameSpace) return factory.createImportDeclaration(void 0, factory.createImportClause(isTypeOnly, void 0, factory.createNamespaceImport(factory.createIdentifier(name))), factory.createStringLiteral(resolvePath), void 0);
+		return factory.createImportDeclaration(void 0, factory.createImportClause(isTypeOnly, factory.createIdentifier(name), void 0), factory.createStringLiteral(resolvePath), void 0);
+	}
+	const specifiers = name.map((item) => {
+		if (typeof item === "object") {
+			const { propertyName, name: alias } = item;
+			return factory.createImportSpecifier(false, alias ? factory.createIdentifier(propertyName) : void 0, factory.createIdentifier(alias ?? propertyName));
+		}
+		return factory.createImportSpecifier(false, void 0, factory.createIdentifier(item));
+	});
+	return factory.createImportDeclaration(void 0, factory.createImportClause(isTypeOnly, void 0, factory.createNamedImports(specifiers)), factory.createStringLiteral(resolvePath), void 0);
+}
+function createExport({ path, asAlias, isTypeOnly = false, name }) {
+	if (name && !Array.isArray(name) && !asAlias) console.warn(`When using name as string, asAlias should be true ${name}`);
+	if (!Array.isArray(name)) {
+		const parsedName = name?.match(/^\d/) ? `_${name?.slice(1)}` : name;
+		return factory.createExportDeclaration(void 0, isTypeOnly, asAlias && parsedName ? factory.createNamespaceExport(factory.createIdentifier(parsedName)) : void 0, factory.createStringLiteral(path), void 0);
+	}
+	return factory.createExportDeclaration(void 0, isTypeOnly, factory.createNamedExports(name.map((propertyName) => {
+		return factory.createExportSpecifier(false, void 0, typeof propertyName === "string" ? factory.createIdentifier(propertyName) : propertyName);
+	})), factory.createStringLiteral(path), void 0);
+}
+const typescriptParser = defineParser({
+	name: "typescript",
+	extNames: [".ts", ".js"],
+	install() {},
+	async parse(file, options = { extname: ".ts" }) {
+		const sourceParts = [];
+		for (const item of file.sources) if (item.value) sourceParts.push(item.value);
+		const source = sourceParts.join("\n\n");
+		const importNodes = [];
+		for (const item of file.imports) {
+			const importPath = item.root ? getRelativePath(item.root, item.path) : item.path;
+			const hasExtname = !!path.extname(importPath);
+			importNodes.push(createImport({
+				name: item.name,
+				path: options.extname && hasExtname ? `${trimExtName(importPath)}${options.extname}` : item.root ? trimExtName(importPath) : importPath,
+				isTypeOnly: item.isTypeOnly,
+				isNameSpace: item.isNameSpace
+			}));
+		}
+		const exportNodes = [];
+		for (const item of file.exports) {
+			const exportPath = item.path;
+			const hasExtname = !!path.extname(exportPath);
+			exportNodes.push(createExport({
+				name: item.name,
+				path: options.extname && hasExtname ? `${trimExtName(item.path)}${options.extname}` : trimExtName(item.path),
+				isTypeOnly: item.isTypeOnly,
+				asAlias: item.asAlias
+			}));
+		}
+		return [
+			file.banner,
+			print(...importNodes, ...exportNodes),
+			source,
+			file.footer
+		].filter((segment) => segment != null).join("\n");
+	}
+});
+//#endregion
+export { createExport, createImport, print, safePrint, typescriptParser, validateNodes };
+
+//# sourceMappingURL=typescript.js.map

package/.output/server/node_modules/@kubb/fabric-core/dist/parsers.js

@@ -0,0 +1,17 @@
+import "./chunk-O_arW02_.js";
+import { n as defineParser } from "./getRelativePath-NAm_Y-vp.js";
+import { t as defaultParser } from "./defaultParser-iCpMSYCp.js";
+import { typescriptParser } from "./parsers/typescript.js";
+//#region src/parsers/tsxParser.ts
+const tsxParser = defineParser({
+	name: "tsx",
+	extNames: [".tsx", ".jsx"],
+	install() {},
+	async parse(file, options = { extname: ".tsx" }) {
+		return typescriptParser.parse(file, options);
+	}
+});
+//#endregion
+export { defaultParser, defineParser, tsxParser, typescriptParser };
+
+//# sourceMappingURL=parsers.js.map

package/.output/server/node_modules/@kubb/fabric-core/dist/plugins.js

@@ -0,0 +1,375 @@
+import "./chunk-O_arW02_.js";
+import { c as createFile, i as TreeNode, n as Root, t as onProcessExit } from "./onProcessExit-Cput7j2c.js";
+import { t as getRelativePath } from "./getRelativePath-NAm_Y-vp.js";
+import path, { dirname, relative, resolve } from "node:path";
+import { rmSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { styleText } from "node:util";
+import * as clack from "@clack/prompts";
+//#region src/plugins/definePlugin.ts
+/**
+* Defines a Fabric plugin with type safety.
+*
+* Use this function to create plugins that hook into Fabric's lifecycle
+* events and extend its functionality.
+*
+* @param plugin - The plugin configuration object
+* @returns A typed plugin ready to use with Fabric
+*
+* @example
+* ```ts
+* import { definePlugin } from '@kubb/fabric-core'
+*
+* export const myPlugin = definePlugin({
+*   name: 'my-plugin',
+*   async setup(fabric) {
+*     fabric.context.on('write:start', (files) => {
+*       console.log(`Writing ${files.length} files`)
+*     })
+*   }
+* })
+* ```
+*/
+function definePlugin(plugin) {
+	return {
+		type: "plugin",
+		...plugin
+	};
+}
+//#endregion
+//#region src/plugins/barrelPlugin.ts
+/** biome-ignore-all lint/suspicious/useIterableCallbackReturn: not needed */
+function getBarrelFiles({ files, root, mode }) {
+	if (mode === "propagate" || mode === false) return [];
+	const indexableSourcesMap = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		const indexableSources = [];
+		for (const source of file.sources || []) if (source.isIndexable && source.name) indexableSources.push(source);
+		if (indexableSources.length > 0) indexableSourcesMap.set(file, indexableSources);
+	}
+	const cachedFiles = /* @__PURE__ */ new Map();
+	const dedupe = /* @__PURE__ */ new Map();
+	const treeNode = TreeNode.fromFiles(files, root);
+	if (!treeNode) return [];
+	treeNode.forEach((node) => {
+		if (!node?.children || !node.parent?.data.path) return;
+		const parentPath = node.parent.data.path;
+		const barrelPath = path.join(parentPath, "index.ts");
+		let barrelFile = cachedFiles.get(barrelPath);
+		if (!barrelFile) {
+			barrelFile = createFile({
+				path: barrelPath,
+				baseName: "index.ts",
+				imports: [],
+				exports: [],
+				sources: []
+			});
+			cachedFiles.set(barrelPath, barrelFile);
+			dedupe.set(barrelPath, /* @__PURE__ */ new Set());
+		}
+		const seen = dedupe.get(barrelPath);
+		for (const leaf of node.leaves) {
+			const file = leaf.data.file;
+			if (!file || !file.path) continue;
+			const indexableSources = indexableSourcesMap.get(file);
+			if (!indexableSources) continue;
+			for (const source of indexableSources) {
+				const key = `${source.name}|${source.isTypeOnly ? "1" : "0"}`;
+				if (seen.has(key)) continue;
+				seen.add(key);
+				barrelFile.exports.push({
+					name: [source.name],
+					path: getRelativePath(parentPath, file.path),
+					isTypeOnly: source.isTypeOnly
+				});
+				barrelFile.sources.push({
+					name: source.name,
+					isTypeOnly: source.isTypeOnly,
+					value: "",
+					isExportable: mode === "all" || mode === "named",
+					isIndexable: mode === "all" || mode === "named"
+				});
+			}
+		}
+	});
+	const result = [...cachedFiles.values()];
+	if (mode === "all") return result.map((file) => ({
+		...file,
+		exports: file.exports?.map((e) => ({
+			...e,
+			name: void 0
+		}))
+	}));
+	return result;
+}
+const barrelPlugin = definePlugin({
+	name: "barrel",
+	install(ctx, options) {
+		if (!options) throw new Error("Barrel plugin requires options.root and options.mode");
+		if (!options.mode) return;
+		ctx.on("files:writing:start", async (files) => {
+			const root = options.root;
+			const barrelFiles = getBarrelFiles({
+				files,
+				root,
+				mode: options.mode
+			});
+			await ctx.fileManager.add(...barrelFiles);
+		});
+	},
+	inject(ctx, options) {
+		if (!options) throw new Error("Barrel plugin requires options.root and options.mode");
+		return { async writeEntry({ root, mode }) {
+			if (!mode || mode === "propagate") return;
+			const rootPath = path.resolve(root, "index.ts");
+			const barrelFiles = [];
+			for (const file of ctx.files) for (const source of file.sources) if (source.isIndexable) {
+				barrelFiles.push(file);
+				break;
+			}
+			const fileTypeCache = /* @__PURE__ */ new Map();
+			for (const file of barrelFiles) fileTypeCache.set(file, file.sources.every((source) => source.isTypeOnly));
+			const exports = [];
+			for (const file of barrelFiles) {
+				const containsOnlyTypes = fileTypeCache.get(file) ?? false;
+				for (const source of file.sources) {
+					if (!file.path || !source.isIndexable) continue;
+					exports.push({
+						name: mode === "all" ? void 0 : [source.name],
+						path: getRelativePath(rootPath, file.path),
+						isTypeOnly: mode === "all" ? containsOnlyTypes : source.isTypeOnly
+					});
+				}
+			}
+			const entryFile = createFile({
+				path: rootPath,
+				baseName: "index.ts",
+				imports: [],
+				exports,
+				sources: []
+			});
+			await ctx.addFile(entryFile);
+			await ctx.fileManager.write({
+				mode: ctx.config.mode,
+				dryRun: options.dryRun,
+				parsers: ctx.installedParsers
+			});
+		} };
+	}
+});
+//#endregion
+//#region src/plugins/fsPlugin.ts
+async function write(path, data, options = {}) {
+	if (typeof Bun !== "undefined") {
+		if (!data || data?.trim() === "") return;
+		await Bun.write(resolve(path), data.trim());
+		if (options?.sanity) {
+			const savedData = await Bun.file(resolve(path)).text();
+			if (savedData?.toString() !== data?.toString()) throw new Error(`Sanity check failed for ${path}\n\nData[${data.length}]:\n${data}\n\nSaved[${savedData.length}]:\n${savedData}\n`);
+			return savedData;
+		}
+		return data;
+	}
+	if (!data || data?.trim() === "") return;
+	try {
+		if ((await readFile(resolve(path), { encoding: "utf-8" }))?.toString() === data?.toString()) return;
+	} catch (_err) {}
+	await mkdir(dirname(resolve(path)), { recursive: true });
+	await writeFile(resolve(path), data.trim(), { encoding: "utf-8" });
+	if (options?.sanity) {
+		const savedData = await readFile(resolve(path), { encoding: "utf-8" });
+		if (savedData?.toString() !== data?.toString()) throw new Error(`Sanity check failed for ${path}\n\nData[${data.length}]:\n${data}\n\nSaved[${savedData.length}]:\n${savedData}\n`);
+		return savedData;
+	}
+	return data;
+}
+const fsPlugin = definePlugin({
+	name: "fs",
+	install(ctx, options = {}) {
+		if (options.clean) rmSync(options.clean.path, {
+			recursive: true,
+			force: true
+		});
+		ctx.on("file:processing:update", async ({ file, source }) => {
+			if (options.onBeforeWrite) await options.onBeforeWrite(file.path, source);
+			await write(file.path, source, { sanity: false });
+		});
+	},
+	inject(ctx, { dryRun } = {}) {
+		return { async write(options = { extension: { ".ts": ".ts" } }) {
+			await ctx.fileManager.write({
+				mode: ctx.config.mode,
+				extension: options.extension,
+				dryRun,
+				parsers: ctx.installedParsers
+			});
+			await ctx.emit("lifecycle:end");
+		} };
+	}
+});
+//#endregion
+//#region src/plugins/fsxPlugin/Runtime.ts
+var Runtime = class {
+	#options;
+	exitPromise;
+	constructor(options) {
+		this.#options = options;
+		this.unsubscribeExit = onProcessExit((code) => {
+			this.unmount(code);
+		});
+	}
+	get fileManager() {
+		return this.#options.fileManager;
+	}
+	#renderPromise = Promise.resolve();
+	resolveExitPromise = () => {};
+	rejectExitPromise = () => {};
+	unsubscribeExit = () => {};
+	onError(error) {
+		throw error;
+	}
+	onExit(error) {
+		setTimeout(() => {
+			this.unmount(error);
+		}, 0);
+	}
+	async render(node) {
+		const treeNode = this.#options.treeNode || new TreeNode({
+			type: "Root",
+			props: {}
+		});
+		const props = {
+			fileManager: this.fileManager,
+			treeNode,
+			onExit: this.onExit.bind(this),
+			onError: this.onError.bind(this)
+		};
+		try {
+			treeNode.data.props = props;
+			const element = Root({
+				...props,
+				children: node
+			});
+			await this.#renderPromise;
+			return element()?.toString() || "";
+		} catch (e) {
+			props.onError(e);
+			return "";
+		}
+	}
+	unmount(error) {
+		if (this.#options?.debug) console.log("Unmount", error);
+		this.unsubscribeExit();
+		if (error instanceof Error) {
+			this.rejectExitPromise(error);
+			return;
+		}
+		this.resolveExitPromise();
+	}
+	async waitUntilExit() {
+		if (!this.exitPromise) this.exitPromise = new Promise((resolve, reject) => {
+			this.resolveExitPromise = resolve;
+			this.rejectExitPromise = reject;
+		});
+		return this.exitPromise;
+	}
+};
+//#endregion
+//#region src/plugins/fsxPlugin/fsxPlugin.ts
+const fsxPlugin = definePlugin({
+	name: "fsx",
+	install() {},
+	inject(ctx, options = {}) {
+		const runtime = new Runtime({
+			fileManager: ctx.fileManager,
+			...options
+		});
+		return {
+			async render(Fabric) {
+				await ctx.emit("lifecycle:start");
+				return runtime.render(Fabric);
+			},
+			async waitUntilExit() {
+				await runtime.waitUntilExit();
+			}
+		};
+	}
+});
+//#endregion
+//#region src/plugins/loggerPlugin.ts
+function pluralize(word, count) {
+	return `${count} ${word}${count === 1 ? "" : "s"}`;
+}
+const DEFAULT_PROGRESS_BAR_SIZE = 30;
+const loggerPlugin = definePlugin({
+	name: "logger",
+	install(ctx, options = {}) {
+		const { progress = true } = options;
+		const state = {
+			spinner: clack.spinner(),
+			isSpinning: false,
+			progressBar: void 0
+		};
+		function formatPath(path) {
+			return relative(process.cwd(), path);
+		}
+		ctx.on("lifecycle:start", async () => {
+			clack.intro(`${styleText("blue", "Fabric")} ${styleText("dim", "Starting run")}`);
+		});
+		ctx.on("lifecycle:render", async () => {
+			clack.log.info(`${styleText("blue", "ℹ")} Rendering application graph`);
+		});
+		ctx.on("files:added", async (files) => {
+			if (!files.length) return;
+			clack.log.info(`${styleText("blue", "ℹ")} Queued ${pluralize("file", files.length)}`);
+		});
+		ctx.on("file:resolve:path", async (file) => {
+			clack.log.step(`Resolving path for ${styleText("dim", formatPath(file.path))}`);
+		});
+		ctx.on("file:resolve:name", async (file) => {
+			clack.log.step(`Resolving name for ${styleText("dim", formatPath(file.path))}`);
+		});
+		ctx.on("files:processing:start", async (files) => {
+			clack.log.step(`Processing ${styleText("green", pluralize("file", files.length))}`);
+			if (progress) {
+				state.progressBar = clack.progress({
+					style: "block",
+					max: files.length,
+					size: DEFAULT_PROGRESS_BAR_SIZE
+				});
+				state.progressBar.start(`Processing ${files.length} files`);
+			}
+		});
+		ctx.on("file:processing:start", async (file, index, total) => {
+			if (!state.progressBar) clack.log.step(`Processing ${styleText("dim", `[${index + 1}/${total}]`)} ${formatPath(file.path)}`);
+		});
+		ctx.on("file:processing:update", async ({ processed, total, percentage, file }) => {
+			if (state.progressBar) state.progressBar.advance(void 0, `Writing ${formatPath(file.path)}`);
+			else {
+				const formattedPercentage = Number.isFinite(percentage) ? percentage.toFixed(1) : "0.0";
+				clack.log.step(`Progress ${styleText("green", `${formattedPercentage}%`)} ${styleText("dim", `(${processed}/${total})`)} → ${formatPath(file.path)}`);
+			}
+		});
+		ctx.on("file:processing:end", async (file, index, total) => {
+			if (state.progressBar) state.progressBar.message(`${styleText("green", "✓")} Finished ${styleText("dim", `[${index + 1}/${total}]`)} ${formatPath(file.path)}`);
+			else clack.log.success(`${styleText("green", "✓")} Finished ${styleText("dim", `[${index + 1}/${total}]`)} ${formatPath(file.path)}`);
+		});
+		ctx.on("files:processing:end", async (files) => {
+			if (state.progressBar) {
+				state.progressBar.stop(`${styleText("green", "✓")} Processed ${pluralize("file", files.length)}`);
+				state.progressBar = void 0;
+			} else clack.log.success(`${styleText("green", "✓")} Processed ${pluralize("file", files.length)}`);
+		});
+		ctx.on("lifecycle:end", async () => {
+			if (state.progressBar) {
+				state.progressBar.stop();
+				state.progressBar = void 0;
+			}
+			clack.outro(`${styleText("blue", "Fabric")} ${styleText("dim", "completed")}`);
+		});
+	}
+});
+//#endregion
+export { barrelPlugin, definePlugin, fsPlugin, fsxPlugin, loggerPlugin };
+
+//# sourceMappingURL=plugins.js.map

package/.output/server/node_modules/@kubb/fabric-core/package.json

@@ -0,0 +1,111 @@
+{
+  "name": "@kubb/fabric-core",
+  "version": "0.14.0",
+  "description": "Core functionality for Kubb's fabric - A language-agnostic toolkit providing the foundation for plugin-based code generation with TypeScript support",
+  "keywords": [
+    "codegen",
+    "code-generator",
+    "typescript",
+    "file-system",
+    "ast",
+    "parser",
+    "plugin-system",
+    "plugins",
+    "fabric",
+    "openapi",
+    "swagger",
+    "kubb"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kubb-labs/fabric.git",
+    "directory": "packages/fabric-core"
+  },
+  "license": "MIT",
+  "author": "stijnvanhulle",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./parsers": {
+      "import": "./dist/parsers.js",
+      "require": "./dist/parsers.cjs"
+    },
+    "./parsers/typescript": {
+      "import": "./dist/parsers/typescript.js",
+      "require": "./dist/parsers/typescript.cjs"
+    },
+    "./plugins": {
+      "import": "./dist/plugins.js",
+      "require": "./dist/plugins.cjs"
+    },
+    "./types": {
+      "import": "./dist/types.js",
+      "require": "./dist/types.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "parsers": [
+        "./dist/parsers.d.ts"
+      ],
+      "parsers/typescript": [
+        "./dist/parsers/typescript.d.ts"
+      ],
+      "plugins": [
+        "./dist/plugins.d.ts"
+      ],
+      "types": [
+        "./dist/types.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "src",
+    "dist",
+    "*.d.ts",
+    "*.d.cts",
+    "!/**/**.test.**",
+    "!/**/__tests__/**",
+    "!/**/__snapshots__/**"
+  ],
+  "size-limit": [
+    {
+      "path": "./dist/*.js",
+      "limit": "510 KiB",
+      "gzip": true
+    }
+  ],
+  "dependencies": {
+    "@clack/prompts": "^1.1.0",
+    "p-limit": "^7.3.0",
+    "remeda": "^2.33.6",
+    "typescript": "5.9.3"
+  },
+  "devDependencies": {},
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsdown && size-limit",
+    "clean": "node -e \"require('fs').rmSync('./dist', {recursive:true,force:true})\"",
+    "lint": "pnpm biome lint .",
+    "lint:fix": "pnpm biome lint --fix --unsafe .",
+    "release": "pnpm publish --no-git-check",
+    "release:canary": "bash ../../.github/canary.sh && node ../../scripts/build.js canary && pnpm publish --no-git-check",
+    "start": "tsdown --watch ./src",
+    "test": "vitest --passWithNoTests",
+    "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false"
+  }
+}

package/.output/server/node_modules/@kubb/oas/dist/chunk--u3MIqq1.js

@@ -0,0 +1,8 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", {
+	value,
+	configurable: true
+});
+//#endregion
+export { __name as t };