@storm-software/eslint-plugin-bun 0.0.6 → 0.0.8

package/dist/helpers/bun-workspace.d.mts

@@ -0,0 +1,49 @@
+//#region src/helpers/bun-workspace.d.ts
+interface BunWorkspacePackageJson {
+  catalog?: Record<string, string>;
+  catalogs?: Record<string, Record<string, string>>;
+  workspaces?: string[] | {
+    packages?: string[];
+    catalog?: Record<string, string>;
+    catalogs?: Record<string, Record<string, string>>;
+  };
+  [key: string]: unknown;
+}
+type CatalogName = "default" | (string & {});
+interface SpecifierConflicts {
+  conflicts: boolean;
+  newCatalogName: string;
+  existingSpecifier?: string;
+}
+interface BunWorkspace {
+  filepath: string;
+  setContent: (content: string) => void;
+  hasChanged: () => boolean;
+  hasQueue: () => boolean;
+  clearQueue: () => void;
+  queueChange: (fn: (workspace: BunWorkspace) => void, order?: "pre" | "post") => void;
+  toJSON: () => BunWorkspacePackageJson;
+  toString: () => string;
+  setPackage: (catalog: CatalogName, packageName: string, specifier: string) => void;
+  setPackageNoConflicts: (catalog: CatalogName, packageName: string, specifier: string) => void;
+  getPackageCatalogs: (packageName: string) => string[];
+  hasSpecifierConflicts: (catalog: CatalogName, packageName: string, specifier: string) => SpecifierConflicts;
+  getCatalogData: () => {
+    catalog?: Record<string, string>;
+    catalogs?: Record<string, Record<string, string>>;
+  };
+  getWorkspacePackagePatterns: () => string[];
+}
+/**
+ * Find and parse the Bun workspace root `package.json` that holds catalogs.
+ *
+ * Catalogs live in root `package.json` (top-level or under `workspaces`), not
+ * `pnpm-workspace.yaml`. See https://bun.com/docs/pm/catalogs
+ */
+declare function readBunWorkspace(cwd?: string): BunWorkspace;
+declare function getBunWorkspace(cwd?: string): BunWorkspace;
+declare function resetBunWorkspaceCache(): void;
+declare function isRootWorkspacePackageJson(filename: string, cwd?: string): boolean;
+declare function collectWorkspacePackageJsonPaths(workspaceRoot: BunWorkspace): string[];
+//#endregion
+export { BunWorkspace, BunWorkspacePackageJson, CatalogName, SpecifierConflicts, collectWorkspacePackageJsonPaths, getBunWorkspace, isRootWorkspacePackageJson, readBunWorkspace, resetBunWorkspaceCache };

package/dist/helpers/bun-workspace.mjs

@@ -1,265 +1,218 @@
-import fs from 'node:fs';
-import process from 'node:process';
-import { findUpSync } from 'find-up-simple';
-import { dirname, normalize, resolve } from 'pathe';
-import { globSync } from 'tinyglobby';
-
-// src/helpers/bun-workspace.ts
+import fs from "node:fs";
+import process from "node:process";
+import { findUpSync } from "find-up-simple";
+import { dirname, normalize, resolve } from "pathe";
+import { globSync } from "tinyglobby";
+//#region src/helpers/bun-workspace.ts
 function isWorkspaceObject(workspaces) {
-  return Boolean(workspaces) && typeof workspaces === "object" && !Array.isArray(workspaces);
+	return Boolean(workspaces) && typeof workspaces === "object" && !Array.isArray(workspaces);
 }
 function detectCatalogRoot(data) {
-  if (data.catalog || data.catalogs) {
-    return "top";
-  }
-  if (isWorkspaceObject(data.workspaces) && (data.workspaces.catalog || data.workspaces.catalogs)) {
-    return "workspaces";
-  }
-  return isWorkspaceObject(data.workspaces) ? "workspaces" : "top";
+	if (data.catalog || data.catalogs) return "top";
+	if (isWorkspaceObject(data.workspaces) && (data.workspaces.catalog || data.workspaces.catalogs)) return "workspaces";
+	return isWorkspaceObject(data.workspaces) ? "workspaces" : "top";
 }
 function normalizeCatalogName(name) {
-  return name.replace(/\^/g, "h").replace(/~/g, "t").replace(/\./g, "_").replace(/</g, "l").replace(/>/g, "g").replace(/=/g, "e").replace(/\*/g, "s").replace(/@/g, "a").replace(/\|/g, "p").replace(/&/g, "n").replace(/-/g, "m").replace(/\+/g, "u").replace(/\s/g, "_");
+	return name.replace(/\^/g, "h").replace(/~/g, "t").replace(/\./g, "_").replace(/</g, "l").replace(/>/g, "g").replace(/=/g, "e").replace(/\*/g, "s").replace(/@/g, "a").replace(/\|/g, "p").replace(/&/g, "n").replace(/-/g, "m").replace(/\+/g, "u").replace(/\s/g, "_");
 }
 function sortObjectKeys(input) {
-  return Object.fromEntries(
-    Object.entries(input).sort(([left], [right]) => left.localeCompare(right))
-  );
+	return Object.fromEntries(Object.entries(input).sort(([left], [right]) => left.localeCompare(right)));
 }
 function isWorkspaceRootPackageJson(data) {
-  return Boolean(
-    data.workspaces || data.catalog || data.catalogs
-  );
+	return Boolean(data.workspaces || data.catalog || data.catalogs);
 }
+/**
+* Find and parse the Bun workspace root `package.json` that holds catalogs.
+*
+* Catalogs live in root `package.json` (top-level or under `workspaces`), not
+* `pnpm-workspace.yaml`. See https://bun.com/docs/pm/catalogs
+*/
 function readBunWorkspace(cwd = process.cwd()) {
-  const filepath = findUpSync("package.json", {
-    cwd,
-    type: "file"
-  });
-  if (!filepath) {
-    throw new Error("package.json not found");
-  }
-  let current = filepath;
-  let content = fs.readFileSync(current, "utf8");
-  let data = JSON.parse(content);
-  while (!isWorkspaceRootPackageJson(data)) {
-    const searchFrom = dirname(dirname(current));
-    const next = findUpSync("package.json", {
-      cwd: searchFrom,
-      type: "file"
-    });
-    if (!next || normalize(next) === normalize(current)) {
-      break;
-    }
-    current = next;
-    content = fs.readFileSync(current, "utf8");
-    data = JSON.parse(content);
-  }
-  if (!isWorkspaceRootPackageJson(data)) {
-    throw new Error(
-      "Bun workspace root package.json with workspaces/catalog not found"
-    );
-  }
-  let hasChanged = false;
-  let queueTimer;
-  const queue = [];
-  let catalogRoot = detectCatalogRoot(data);
-  const write = () => {
-    if (!fs.existsSync(current)) {
-      return;
-    }
-    fs.writeFileSync(current, `${JSON.stringify(data, null, 2)}
-`);
-  };
-  const clearQueue = () => {
-    if (queueTimer != null) {
-      clearTimeout(queueTimer);
-      queueTimer = void 0;
-    }
-    queue.length = 0;
-  };
-  const getCatalogContainer = () => {
-    if (catalogRoot === "workspaces") {
-      if (!isWorkspaceObject(data.workspaces)) {
-        data.workspaces = {
-          packages: Array.isArray(data.workspaces) ? data.workspaces : [],
-          catalog: {},
-          catalogs: {}
-        };
-      }
-      return data.workspaces;
-    }
-    return data;
-  };
-  const getCatalogData = () => {
-    const container = getCatalogContainer();
-    return {
-      catalog: container.catalog,
-      catalogs: container.catalogs
-    };
-  };
-  const setPackage = (catalogName, packageName, specifier) => {
-    const container = getCatalogContainer();
-    if (catalogName === "default") {
-      container.catalog ??= {};
-      if (container.catalog[packageName] !== specifier) {
-        container.catalog[packageName] = specifier;
-        container.catalog = sortObjectKeys(container.catalog);
-        hasChanged = true;
-      }
-      return;
-    }
-    container.catalogs ??= {};
-    container.catalogs[catalogName] ??= {};
-    if (container.catalogs[catalogName][packageName] !== specifier) {
-      container.catalogs[catalogName][packageName] = specifier;
-      container.catalogs[catalogName] = sortObjectKeys(
-        container.catalogs[catalogName]
-      );
-      container.catalogs = sortObjectKeys(container.catalogs);
-      hasChanged = true;
-    }
-  };
-  const hasSpecifierConflicts = (catalogName, packageName, specifier) => {
-    const { catalog, catalogs } = getCatalogData();
-    const existingSpecifier = catalogName === "default" ? catalog?.[packageName] : catalogs?.[catalogName]?.[packageName];
-    if (existingSpecifier === specifier) {
-      return {
-        conflicts: false,
-        newCatalogName: catalogName,
-        existingSpecifier
-      };
-    }
-    if (existingSpecifier) {
-      const versionSuffix = normalizeCatalogName(specifier);
-      const newCatalogName = catalogName === "default" ? `conflicts_${packageName}_${versionSuffix}` : `conflicts_${catalogName}_${versionSuffix}`;
-      return {
-        conflicts: true,
-        existingSpecifier,
-        newCatalogName
-      };
-    }
-    return {
-      conflicts: false,
-      newCatalogName: catalogName
-    };
-  };
-  const getPackageCatalogs = (packageName) => {
-    const found = [];
-    const { catalog, catalogs } = getCatalogData();
-    if (catalogs) {
-      for (const name of Object.keys(catalogs)) {
-        if (catalogs[name]?.[packageName]) {
-          found.push(name);
-        }
-      }
-    }
-    if (catalog?.[packageName]) {
-      found.push("default");
-    }
-    return found;
-  };
-  const workspace2 = {
-    filepath: current,
-    setContent(newContent) {
-      content = newContent;
-      data = JSON.parse(newContent);
-      catalogRoot = detectCatalogRoot(data);
-      hasChanged = false;
-    },
-    hasChanged: () => hasChanged,
-    hasQueue: () => queueTimer != null,
-    clearQueue,
-    queueChange(fn, order) {
-      if (order === "pre") {
-        queue.unshift(fn);
-      } else {
-        queue.push(fn);
-      }
-      if (queueTimer != null) {
-        clearTimeout(queueTimer);
-      }
-      queueTimer = setTimeout(() => {
-        queueTimer = void 0;
-        const clone = [...queue];
-        queue.length = 0;
-        for (const queued of clone) {
-          queued(workspace2);
-        }
-        if (hasChanged) {
-          write();
-        }
-      }, 1e3);
-    },
-    toJSON: () => data,
-    toString: () => `${JSON.stringify(data, null, 2)}
-`,
-    setPackage,
-    setPackageNoConflicts(catalogName, packageName, specifier) {
-      const { newCatalogName } = hasSpecifierConflicts(
-        catalogName,
-        packageName,
-        specifier
-      );
-      setPackage(newCatalogName, packageName, specifier);
-    },
-    getPackageCatalogs,
-    hasSpecifierConflicts,
-    getCatalogData,
-    getWorkspacePackagePatterns() {
-      if (Array.isArray(data.workspaces)) {
-        return data.workspaces;
-      }
-      if (isWorkspaceObject(data.workspaces) && data.workspaces.packages) {
-        return data.workspaces.packages;
-      }
-      return [];
-    }
-  };
-  return workspace2;
+	const filepath = findUpSync("package.json", {
+		cwd,
+		type: "file"
+	});
+	if (!filepath) throw new Error("package.json not found");
+	let current = filepath;
+	let content = fs.readFileSync(current, "utf8");
+	let data = JSON.parse(content);
+	while (!isWorkspaceRootPackageJson(data)) {
+		const searchFrom = dirname(dirname(current));
+		const next = findUpSync("package.json", {
+			cwd: searchFrom,
+			type: "file"
+		});
+		if (!next || normalize(next) === normalize(current)) break;
+		current = next;
+		content = fs.readFileSync(current, "utf8");
+		data = JSON.parse(content);
+	}
+	if (!isWorkspaceRootPackageJson(data)) throw new Error("Bun workspace root package.json with workspaces/catalog not found");
+	let hasChanged = false;
+	let queueTimer;
+	const queue = [];
+	let catalogRoot = detectCatalogRoot(data);
+	const write = () => {
+		if (!fs.existsSync(current)) return;
+		fs.writeFileSync(current, `${JSON.stringify(data, null, 2)}\n`);
+	};
+	const clearQueue = () => {
+		if (queueTimer != null) {
+			clearTimeout(queueTimer);
+			queueTimer = void 0;
+		}
+		queue.length = 0;
+	};
+	const getCatalogContainer = () => {
+		if (catalogRoot === "workspaces") {
+			if (!isWorkspaceObject(data.workspaces)) data.workspaces = {
+				packages: Array.isArray(data.workspaces) ? data.workspaces : [],
+				catalog: {},
+				catalogs: {}
+			};
+			return data.workspaces;
+		}
+		return data;
+	};
+	const getCatalogData = () => {
+		const container = getCatalogContainer();
+		return {
+			catalog: container.catalog,
+			catalogs: container.catalogs
+		};
+	};
+	const setPackage = (catalogName, packageName, specifier) => {
+		const container = getCatalogContainer();
+		if (catalogName === "default") {
+			container.catalog ??= {};
+			if (container.catalog[packageName] !== specifier) {
+				container.catalog[packageName] = specifier;
+				container.catalog = sortObjectKeys(container.catalog);
+				hasChanged = true;
+			}
+			return;
+		}
+		container.catalogs ??= {};
+		container.catalogs[catalogName] ??= {};
+		if (container.catalogs[catalogName][packageName] !== specifier) {
+			container.catalogs[catalogName][packageName] = specifier;
+			container.catalogs[catalogName] = sortObjectKeys(container.catalogs[catalogName]);
+			container.catalogs = sortObjectKeys(container.catalogs);
+			hasChanged = true;
+		}
+	};
+	const hasSpecifierConflicts = (catalogName, packageName, specifier) => {
+		const { catalog, catalogs } = getCatalogData();
+		const existingSpecifier = catalogName === "default" ? catalog?.[packageName] : catalogs?.[catalogName]?.[packageName];
+		if (existingSpecifier === specifier) return {
+			conflicts: false,
+			newCatalogName: catalogName,
+			existingSpecifier
+		};
+		if (existingSpecifier) {
+			const versionSuffix = normalizeCatalogName(specifier);
+			return {
+				conflicts: true,
+				existingSpecifier,
+				newCatalogName: catalogName === "default" ? `conflicts_${packageName}_${versionSuffix}` : `conflicts_${catalogName}_${versionSuffix}`
+			};
+		}
+		return {
+			conflicts: false,
+			newCatalogName: catalogName
+		};
+	};
+	const getPackageCatalogs = (packageName) => {
+		const found = [];
+		const { catalog, catalogs } = getCatalogData();
+		if (catalogs) {
+			for (const name of Object.keys(catalogs)) if (catalogs[name]?.[packageName]) found.push(name);
+		}
+		if (catalog?.[packageName]) found.push("default");
+		return found;
+	};
+	const workspace = {
+		filepath: current,
+		setContent(newContent) {
+			content = newContent;
+			data = JSON.parse(newContent);
+			catalogRoot = detectCatalogRoot(data);
+			hasChanged = false;
+		},
+		hasChanged: () => hasChanged,
+		hasQueue: () => queueTimer != null,
+		clearQueue,
+		queueChange(fn, order) {
+			if (order === "pre") queue.unshift(fn);
+			else queue.push(fn);
+			if (queueTimer != null) clearTimeout(queueTimer);
+			queueTimer = setTimeout(() => {
+				queueTimer = void 0;
+				const clone = [...queue];
+				queue.length = 0;
+				for (const queued of clone) queued(workspace);
+				if (hasChanged) write();
+			}, 1e3);
+		},
+		toJSON: () => data,
+		toString: () => `${JSON.stringify(data, null, 2)}\n`,
+		setPackage,
+		setPackageNoConflicts(catalogName, packageName, specifier) {
+			const { newCatalogName } = hasSpecifierConflicts(catalogName, packageName, specifier);
+			setPackage(newCatalogName, packageName, specifier);
+		},
+		getPackageCatalogs,
+		hasSpecifierConflicts,
+		getCatalogData,
+		getWorkspacePackagePatterns() {
+			if (Array.isArray(data.workspaces)) return data.workspaces;
+			if (isWorkspaceObject(data.workspaces) && data.workspaces.packages) return data.workspaces.packages;
+			return [];
+		}
+	};
+	return workspace;
 }
-var WORKSPACE_CACHE_TIME = 1e4;
-var workspaceLastRead;
-var workspace;
+const WORKSPACE_CACHE_TIME = 1e4;
+let workspaceLastRead;
+let workspace;
 function getBunWorkspace(cwd = process.cwd()) {
-  if (workspaceLastRead && workspace && !workspace.hasQueue() && Date.now() - workspaceLastRead > WORKSPACE_CACHE_TIME) {
-    workspace = void 0;
-  }
-  if (!workspace) {
-    workspace = readBunWorkspace(cwd);
-    workspaceLastRead = Date.now();
-  }
-  return workspace;
+	if (workspaceLastRead && workspace && !workspace.hasQueue() && Date.now() - workspaceLastRead > WORKSPACE_CACHE_TIME) workspace = void 0;
+	if (!workspace) {
+		workspace = readBunWorkspace(cwd);
+		workspaceLastRead = Date.now();
+	}
+	return workspace;
 }
 function resetBunWorkspaceCache() {
-  workspace?.clearQueue();
-  workspace = void 0;
-  workspaceLastRead = void 0;
+	workspace?.clearQueue();
+	workspace = void 0;
+	workspaceLastRead = void 0;
 }
 function isRootWorkspacePackageJson(filename, cwd = process.cwd()) {
-  try {
-    const root = getBunWorkspace(cwd);
-    return normalize(root.filepath) === normalize(filename);
-  } catch {
-    return false;
-  }
+	try {
+		const root = getBunWorkspace(cwd);
+		return normalize(root.filepath) === normalize(filename);
+	} catch {
+		return false;
+	}
 }
 function collectWorkspacePackageJsonPaths(workspaceRoot) {
-  const root = resolve(dirname(workspaceRoot.filepath));
-  const patterns = workspaceRoot.getWorkspacePackagePatterns();
-  const dirs = patterns.length ? globSync(patterns, {
-    cwd: root,
-    dot: false,
-    ignore: [
-      "**/node_modules/**",
-      "**/dist/**",
-      "**/build/**"
-    ],
-    absolute: true,
-    expandDirectories: false,
-    onlyDirectories: true
-  }) : [];
-  dirs.push(root);
-  return dirs.map((dir) => resolve(dir, "package.json")).filter((path) => fs.existsSync(path)).sort();
+	const root = resolve(dirname(workspaceRoot.filepath));
+	const patterns = workspaceRoot.getWorkspacePackagePatterns();
+	const dirs = patterns.length ? globSync(patterns, {
+		cwd: root,
+		dot: false,
+		ignore: [
+			"**/node_modules/**",
+			"**/dist/**",
+			"**/build/**"
+		],
+		absolute: true,
+		expandDirectories: false,
+		onlyDirectories: true
+	}) : [];
+	dirs.push(root);
+	return dirs.map((dir) => resolve(dir, "package.json")).filter((path) => fs.existsSync(path)).sort();
 }
-
+//#endregion
 export { collectWorkspacePackageJsonPaths, getBunWorkspace, isRootWorkspacePackageJson, readBunWorkspace, resetBunWorkspaceCache };

package/dist/helpers/{create-rule.d.ts → create-rule.d.mts}

@@ -1,9 +1,9 @@
-import { RuleWithMetaAndName } from '@typescript-eslint/utils/eslint-utils';
-import { Rule } from 'eslint';
-
+import { Rule } from "eslint";
+import { RuleWithMetaAndName } from "@typescript-eslint/utils/eslint-utils";
+//#region src/helpers/create-rule.d.ts
 type RuleModule<T extends readonly unknown[]> = Rule.RuleModule & {
-    defaultOptions: T;
+  defaultOptions: T;
 };
 declare const createRule: <TOptions extends readonly unknown[], TMessageIds extends string>({ name, meta, ...rule }: Readonly<RuleWithMetaAndName<TOptions, TMessageIds>>) => RuleModule<TOptions>;
-
-export { type RuleModule, createRule };
+//#endregion
+export { RuleModule, createRule };

package/dist/helpers/create-rule.mjs

@@ -1,42 +1,41 @@
-import defu from 'defu';
-
-// src/helpers/create-rule.ts
+import defu from "defu";
+//#region src/helpers/create-rule.ts
+/**
+* Creates reusable function to create rules with default options and docs URLs.
+*
+* @param urlCreator - Creates a documentation URL for a given rule name.
+* @returns Function to create a rule with the docs URL format.
+*/
 function RuleCreator(urlCreator) {
-  return function createNamedRule({
-    name,
-    meta,
-    ...rule
-  }) {
-    return createRuleInfo({
-      meta: {
-        ...meta,
-        docs: {
-          ...meta.docs,
-          url: urlCreator(name)
-        }
-      },
-      ...rule
-    });
-  };
+	return function createNamedRule({ name, meta, ...rule }) {
+		return createRuleInfo({
+			meta: {
+				...meta,
+				docs: {
+					...meta.docs,
+					url: urlCreator(name)
+				}
+			},
+			...rule
+		});
+	};
 }
-function createRuleInfo({
-  create,
-  defaultOptions,
-  meta
-}) {
-  return {
-    create: ((context) => {
-      const optionsWithDefault = context.options.map((options, index) => {
-        return defu(defaultOptions?.[index] ?? {}, options);
-      });
-      return create(context, optionsWithDefault);
-    }),
-    defaultOptions: defaultOptions ?? {},
-    meta
-  };
+/**
+* Creates a well-typed TSESLint custom ESLint rule without a docs URL.
+*
+* @returns Well-typed TSESLint custom ESLint rule.
+*/
+function createRuleInfo({ create, defaultOptions, meta }) {
+	return {
+		create: ((context) => {
+			return create(context, context.options.map((options, index) => {
+				return defu(defaultOptions?.[index] ?? {}, options);
+			}));
+		}),
+		defaultOptions: defaultOptions ?? {},
+		meta
+	};
 }
-var createRule = RuleCreator(
-  (ruleName) => `https://docs.stormsoftware.com/projects/storm-ops/eslint-plugin-bun/rules/${ruleName}.md`
-);
-
+const createRule = RuleCreator((ruleName) => `https://docs.stormsoftware.com/projects/storm-ops/eslint-plugin-bun/rules/${ruleName}.md`);
+//#endregion
 export { createRule };

package/dist/helpers/{iterate-dependencies.d.ts → iterate-dependencies.d.mts}

@@ -1,11 +1,11 @@
-import { RuleContext } from '@typescript-eslint/utils/ts-eslint';
-
+import { RuleContext } from "@typescript-eslint/utils/ts-eslint";
+//#region src/helpers/iterate-dependencies.d.ts
 declare function getPackageJsonRootNode(context: RuleContext<string, unknown[]>): any | undefined;
 declare function iterateDependencies(context: RuleContext<string, unknown[]>, fields: string[]): Generator<{
-    packageName: string;
-    specifier: string;
-    property: any;
+  packageName: string;
+  specifier: string;
+  property: any;
 }, void, unknown>;
 declare function getObjectPath(obj: Record<string, unknown>, path: string[]): Record<string, string> | undefined;
-
-export { getObjectPath, getPackageJsonRootNode, iterateDependencies };
+//#endregion
+export { getObjectPath, getPackageJsonRootNode, iterateDependencies };