@kubb/agent 4.28.1 → 4.29.1

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

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/react-fabric",
-  "version": "0.12.11",
+  "version": "0.13.1",
   "description": "React integration for Kubb's fabric - JSX runtime and component-based code generation with React reconciler for building type-safe generators",
   "keywords": [
     "react",
@@ -19,7 +19,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/kubb-labs/fabric.git",
+    "url": "git+https://github.com/kubb-labs/fabric.git",
     "directory": "packages/react-fabric"
   },
   "license": "MIT",
@@ -62,7 +62,7 @@
   },
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
-  "types": "./dist/index.d.cts",
+  "types": "./dist/index.d.ts",
   "typesVersions": {
     "*": {
       "globals": [
@@ -102,16 +102,13 @@
     }
   ],
   "dependencies": {
-    "execa": "^9.6.1",
-    "natural-orderby": "^5.0.0",
     "react-devtools-core": "6.1.5",
-    "remeda": "^2.33.5",
-    "signal-exit": "^4.1.0",
+    "remeda": "^2.33.6",
     "ws": "8.18.0",
-    "@kubb/fabric-core": "0.12.11"
+    "@kubb/fabric-core": "0.13.1"
   },
   "devDependencies": {
-    "@types/react": "^19.2.13",
+    "@types/react": "^19.2.14",
     "@types/react-reconciler": "0.32.0",
     "@types/ws": "^8.18.1",
     "react": "19.2.3",
@@ -126,12 +123,12 @@
   },
   "scripts": {
     "build": "tsdown && size-limit",
-    "start": "tsdown --watch ./src",
-    "clean": "npx rimraf ./dist",
+    "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 -tag canary",
+    "start": "tsdown --watch ./src",
     "start:devtools": "npx react-devtools",
     "test": "vitest --passWithNoTests",
     "test:devtools": "node ./dist/runner.cjs",

package/.output/server/node_modules/empathic/access.js

@@ -0,0 +1,39 @@
+// re-export existsSync?
+const { accessSync, constants } = require("node:fs");
+/**
+* Does the current process have {@link mode} access?
+* By default, checks if the path is visible to the proccess.
+*
+* @param mode A `fs.constants` value; default `F_OK`
+*/
+function ok(path, mode) {
+	try {
+		accessSync(path, mode);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Can the current process write to this path?
+*/
+function writable(path) {
+	return ok(path, constants.W_OK);
+}
+/**
+* Can the current process read this path?
+*/
+function readable(path) {
+	return ok(path, constants.R_OK);
+}
+/**
+* Can the current process execute this path?
+*/
+function executable(path) {
+	return ok(path, constants.X_OK);
+}
+
+exports.ok = ok;
+exports.writable = writable;
+exports.readable = readable;
+exports.executable = executable;

package/.output/server/node_modules/empathic/access.mjs

@@ -0,0 +1,34 @@
+// re-export existsSync?
+import { accessSync, constants } from "node:fs";
+/**
+* Does the current process have {@link mode} access?
+* By default, checks if the path is visible to the proccess.
+*
+* @param mode A `fs.constants` value; default `F_OK`
+*/
+export function ok(path, mode) {
+	try {
+		accessSync(path, mode);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Can the current process write to this path?
+*/
+export function writable(path) {
+	return ok(path, constants.W_OK);
+}
+/**
+* Can the current process read this path?
+*/
+export function readable(path) {
+	return ok(path, constants.R_OK);
+}
+/**
+* Can the current process execute this path?
+*/
+export function executable(path) {
+	return ok(path, constants.X_OK);
+}

package/.output/server/node_modules/empathic/find.js

@@ -0,0 +1,81 @@
+const { join } = require("node:path");
+const { existsSync, statSync } = require("node:fs");
+const walk = require("empathic/walk");
+/**
+* Find an item by name, walking parent directories until found.
+*
+* @param name The item name to find.
+* @returns The absolute path to the item, if found.
+*/
+function up(name, options) {
+	let dir, tmp;
+	let start = options && options.cwd || "";
+	for (dir of walk.up(start, options)) {
+		tmp = join(dir, name);
+		if (existsSync(tmp)) return tmp;
+	}
+}
+/**
+* Get the first path that matches any of the names provided.
+*
+* > [NOTE]
+* > The order of {@link names} is respected.
+*
+* @param names The item names to find.
+* @returns The absolute path of the first item found, if any.
+*/
+function any(names, options) {
+	let dir, start = options && options.cwd || "";
+	let j = 0, len = names.length, tmp;
+	for (dir of walk.up(start, options)) {
+		for (j = 0; j < len; j++) {
+			tmp = join(dir, names[j]);
+			if (existsSync(tmp)) return tmp;
+		}
+	}
+}
+/**
+* Find a file by name, walking parent directories until found.
+*
+* > [NOTE]
+* > This function only returns a value for file matches.
+* > A directory match with the same name will be ignored.
+*
+* @param name The file name to find.
+* @returns The absolute path to the file, if found.
+*/
+function file(name, options) {
+	let dir, tmp;
+	let start = options && options.cwd || "";
+	for (dir of walk.up(start, options)) {
+		try {
+			tmp = join(dir, name);
+			if (statSync(tmp).isFile()) return tmp;
+		} catch {}
+	}
+}
+/**
+* Find a directory by name, walking parent directories until found.
+*
+* > [NOTE]
+* > This function only returns a value for directory matches.
+* > A file match with the same name will be ignored.
+*
+* @param name The directory name to find.
+* @returns The absolute path to the file, if found.
+*/
+function dir(name, options) {
+	let dir, tmp;
+	let start = options && options.cwd || "";
+	for (dir of walk.up(start, options)) {
+		try {
+			tmp = join(dir, name);
+			if (statSync(tmp).isDirectory()) return tmp;
+		} catch {}
+	}
+}
+
+exports.up = up;
+exports.any = any;
+exports.file = file;
+exports.dir = dir;

package/.output/server/node_modules/empathic/find.mjs

@@ -0,0 +1,76 @@
+import { join } from "node:path";
+import { existsSync, statSync } from "node:fs";
+import * as walk from "empathic/walk";
+/**
+* Find an item by name, walking parent directories until found.
+*
+* @param name The item name to find.
+* @returns The absolute path to the item, if found.
+*/
+export function up(name, options) {
+	let dir, tmp;
+	let start = options && options.cwd || "";
+	for (dir of walk.up(start, options)) {
+		tmp = join(dir, name);
+		if (existsSync(tmp)) return tmp;
+	}
+}
+/**
+* Get the first path that matches any of the names provided.
+*
+* > [NOTE]
+* > The order of {@link names} is respected.
+*
+* @param names The item names to find.
+* @returns The absolute path of the first item found, if any.
+*/
+export function any(names, options) {
+	let dir, start = options && options.cwd || "";
+	let j = 0, len = names.length, tmp;
+	for (dir of walk.up(start, options)) {
+		for (j = 0; j < len; j++) {
+			tmp = join(dir, names[j]);
+			if (existsSync(tmp)) return tmp;
+		}
+	}
+}
+/**
+* Find a file by name, walking parent directories until found.
+*
+* > [NOTE]
+* > This function only returns a value for file matches.
+* > A directory match with the same name will be ignored.
+*
+* @param name The file name to find.
+* @returns The absolute path to the file, if found.
+*/
+export function file(name, options) {
+	let dir, tmp;
+	let start = options && options.cwd || "";
+	for (dir of walk.up(start, options)) {
+		try {
+			tmp = join(dir, name);
+			if (statSync(tmp).isFile()) return tmp;
+		} catch {}
+	}
+}
+/**
+* Find a directory by name, walking parent directories until found.
+*
+* > [NOTE]
+* > This function only returns a value for directory matches.
+* > A file match with the same name will be ignored.
+*
+* @param name The directory name to find.
+* @returns The absolute path to the file, if found.
+*/
+export function dir(name, options) {
+	let dir, tmp;
+	let start = options && options.cwd || "";
+	for (dir of walk.up(start, options)) {
+		try {
+			tmp = join(dir, name);
+			if (statSync(tmp).isDirectory()) return tmp;
+		} catch {}
+	}
+}

package/.output/server/node_modules/empathic/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "empathic",
+  "version": "2.0.0",
+  "repository": "lukeed/empathic",
+  "description": "A set of small and fast Node.js utilities to understand your pathing needs.",
+  "license": "MIT",
+  "author": {
+    "name": "Luke Edwards",
+    "email": "luke.edwards05@gmail.com",
+    "url": "https://lukeed.com"
+  },
+  "exports": {
+    "./access": {
+      "types": "./access.d.ts",
+      "import": "./access.mjs",
+      "require": "./access.js"
+    },
+    "./find": {
+      "types": "./find.d.ts",
+      "import": "./find.mjs",
+      "require": "./find.js"
+    },
+    "./package": {
+      "types": "./package.d.ts",
+      "import": "./package.mjs",
+      "require": "./package.js"
+    },
+    "./resolve": {
+      "types": "./resolve.d.ts",
+      "import": "./resolve.mjs",
+      "require": "./resolve.js"
+    },
+    "./walk": {
+      "types": "./walk.d.ts",
+      "import": "./walk.mjs",
+      "require": "./walk.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "test": "uvu"
+  },
+  "engines": {
+    "node": ">=14"
+  },
+  "devDependencies": {
+    "uvu": "0.5"
+  }
+}

package/.output/server/node_modules/empathic/package.mjs

@@ -0,0 +1,52 @@
+import { env } from "node:process";
+import { dirname, join } from "node:path";
+import { existsSync, mkdirSync } from "node:fs";
+import { writable } from "empathic/access";
+import * as find from "empathic/find";
+/**
+* Find the closest "package.json" file while walking parent directories.
+* @returns The absolute path to a "package.json", if found.
+*/
+export function up(options) {
+	return find.up("package.json", options);
+}
+/**
+* Construct a path to a `node_modules/.cache/<name>` directory.
+*
+* This may return `undefined` if:
+*   1. no "package.json" could be found
+*   2. the nearest "node_modules" directory is not writable
+*   3. the "node_modules" parent directory is not writable
+*
+* > [NOTE]
+* > You may define a `CACHE_DIR` environment variable, which will be
+* > used (as defined) instead of traversing the filesystem for the
+* > closest "package.json" and inferring a "node_modules" location.
+*
+* @see find-cache-dir for more information.
+*
+* @param name The name of your module/cache.
+* @returns The absolute path of the cache directory, if found.
+*/
+export function cache(name, options) {
+	options = options || {};
+	let dir = env.CACHE_DIR;
+	if (!dir || /^(1|0|true|false)$/.test(dir)) {
+		let pkg = up(options);
+		if (dir = pkg && dirname(pkg)) {
+			let mods = join(dir, "node_modules");
+			let exists = existsSync(mods);
+			// exit cuz exists but not writable
+			// or cuz missing but parent not writable
+			if (!writable(exists ? mods : dir)) return;
+			dir = join(mods, ".cache");
+		}
+	}
+	if (dir) {
+		dir = join(dir, name);
+		if (options.create && !existsSync(dir)) {
+			mkdirSync(dir, { recursive: true });
+		}
+		return dir;
+	}
+}

package/.output/server/node_modules/empathic/resolve.js

@@ -0,0 +1,31 @@
+const { createRequire } = require("node:module");
+const { isAbsolute, join, resolve } = require("node:path");
+const { fileURLToPath } = require("node:url");
+/**
+* Resolve an absolute path from {@link root}, but only
+* if {@link input} isn't already absolute.
+*
+* @param input The path to resolve.
+* @param root The base path; default = process.cwd()
+* @returns The resolved absolute path.
+*/
+function absolute(input, root) {
+	return isAbsolute(input) ? input : resolve(root || ".", input);
+}
+function from(root, ident, silent) {
+	try {
+		// NOTE: dirs need a trailing "/" OR filename. With "/" route,
+		// Node adds "noop.js" as main file, so just do "noop.js" anyway.
+		let r = root instanceof URL || root.startsWith("file://") ? join(fileURLToPath(root), "noop.js") : join(absolute(root), "noop.js");
+		return createRequire(r).resolve(ident);
+	} catch (err) {
+		if (!silent) throw err;
+	}
+}
+function cwd(ident, silent) {
+	return from(resolve(), ident, silent);
+}
+
+exports.absolute = absolute;
+exports.from = from;
+exports.cwd = cwd;

package/.output/server/node_modules/empathic/resolve.mjs

@@ -0,0 +1,27 @@
+import { createRequire } from "node:module";
+import { isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+* Resolve an absolute path from {@link root}, but only
+* if {@link input} isn't already absolute.
+*
+* @param input The path to resolve.
+* @param root The base path; default = process.cwd()
+* @returns The resolved absolute path.
+*/
+export function absolute(input, root) {
+	return isAbsolute(input) ? input : resolve(root || ".", input);
+}
+export function from(root, ident, silent) {
+	try {
+		// NOTE: dirs need a trailing "/" OR filename. With "/" route,
+		// Node adds "noop.js" as main file, so just do "noop.js" anyway.
+		let r = root instanceof URL || root.startsWith("file://") ? join(fileURLToPath(root), "noop.js") : join(absolute(root), "noop.js");
+		return createRequire(r).resolve(ident);
+	} catch (err) {
+		if (!silent) throw err;
+	}
+}
+export function cwd(ident, silent) {
+	return from(resolve(), ident, silent);
+}

package/.output/server/node_modules/empathic/walk.js

@@ -0,0 +1,22 @@
+const { dirname } = require("node:path");
+const { absolute } = require("empathic/resolve");
+/**
+* Get all parent directories of {@link base}.
+* Stops after {@link Options['last']} is processed.
+*
+* @returns An array of absolute paths of all parent directories.
+*/
+function up(base, options) {
+	let { last, cwd } = options || {};
+	let tmp = absolute(base, cwd);
+	let root = absolute(last || "/", cwd);
+	let prev, arr = [];
+	while (prev !== root) {
+		arr.push(tmp);
+		tmp = dirname(prev = tmp);
+		if (tmp === prev) break;
+	}
+	return arr;
+}
+
+exports.up = up;

package/.output/server/node_modules/empathic/walk.mjs

@@ -0,0 +1,20 @@
+import { dirname } from "node:path";
+import { absolute } from "empathic/resolve";
+/**
+* Get all parent directories of {@link base}.
+* Stops after {@link Options['last']} is processed.
+*
+* @returns An array of absolute paths of all parent directories.
+*/
+export function up(base, options) {
+	let { last, cwd } = options || {};
+	let tmp = absolute(base, cwd);
+	let root = absolute(last || "/", cwd);
+	let prev, arr = [];
+	while (prev !== root) {
+		arr.push(tmp);
+		tmp = dirname(prev = tmp);
+		if (tmp === prev) break;
+	}
+	return arr;
+}