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

package/dist/configs/recommended.mjs

@@ -1,939 +1,33 @@
-import parserJsonc from 'jsonc-eslint-parser';
-import defu from 'defu';
-import fs from 'node:fs';
-import process from 'node:process';
-import { findUpSync } from 'find-up-simple';
-import { normalize, resolve, dirname } from 'pathe';
-import { globSync } from 'tinyglobby';
-
-// ../package-constants/src/globs.ts
-var GLOB_EXCLUDE = [
-  "**/.git",
-  "**/node_modules",
-  "**/dist",
-  "**/tmp",
-  "**/coverage",
-  "**/bench",
-  "**/__snapshots__",
-  "**/__test__",
-  "**/__mocks__",
-  "**/__generated__",
-  "**/.wrangler",
-  "**/.rolldown",
-  "**/.docusaurus",
-  "**/.tamagui",
-  "**/tamagui.css",
-  "**/.nx",
-  "**/.next",
-  "**/.storm",
-  "**/.powerlines",
-  "**/.shell-shock",
-  "**/.earthquake",
-  "**/.aftershock",
-  "**/workbox*.js",
-  "**/sw*.js",
-  "**/service-worker.js",
-  "**/fallback*.js",
-  "**/ios",
-  "**/.android",
-  "**/.DS_Store",
-  "**/Thumbs.db",
-  "**/.cspellcache",
-  "**/package-lock.*",
-  "**/npm-lock.*",
-  "**/pnpm-lock.*",
-  "**/bun.lockb",
-  "**/cargo.lock",
-  "**/next-env.d.ts",
-  "**/CODEOWNERS",
-  "**/yarn.lock",
-  "**/jest.preset.{js,ts,cjs,cts,mjs,mts,json}",
-  "**/vitest.preset.{js,ts,cjs,cts,mjs,mts,json}",
-  "**/jest.config.{js,ts,cjs,cts,mjs,mts,json}",
-  "**/vitest.config.{js,ts,cjs,cts,mjs,mts,json}",
-  "**/vitest.workspace.{js,ts,cjs,cts,mjs,mts,json}",
-  "**/*.spec.{ts,tsx}",
-  "**/*.test.{ts,tsx}",
-  "**/temp",
-  "**/.temp",
-  "**/.output",
-  "**/.history",
-  "**/.vitepress/cache",
-  "**/.nuxt",
-  "**/.svelte-kit",
-  "**/.vercel",
-  "**/.changeset",
-  "**/.idea",
-  "**/.cache",
-  "**/.vite-inspect",
-  "**/.yarn",
-  "**/*.min.*",
-  "**/CHANGELOG*.md",
-  "**/CONTRIBUTING.md",
-  "**/SECURITY.md",
-  "**/CODE_OF_CONDUCT.md",
-  "**/PULL_REQUEST_TEMPLATE.md",
-  "**/LICENSE*",
-  "**/auto-import?(s).d.ts",
-  "**/components.d.ts",
-  "**/vite.config.*.timestamp-*",
-  "**/webpack.config.*.timestamp-*",
-  "**/rollup.config.*.timestamp-*",
-  "**/nx/**/schema.d.ts",
-  "**/nx/**/schema.json",
-  "**/nx/**/schema.md",
-  "**/nx/**/*.schema.d.ts",
-  "**/nx/**/*.schema.json",
-  "**/nx/**/*.schema.md",
-  "**/nx/**/generators/**/files",
-  ".agents/**/*",
-  "**/.agents/**/*",
-  ".claude/**/*",
-  "**/.claude/**/*",
-  ".codex/**/*",
-  "**/.codex/**/*",
-  ".cursor/**/*",
-  "**/.cursor/**/*",
-  ".opencode/**/*",
-  "**/.opencode/**/*",
-  ".nx/**/*",
-  "**/.nx/**/*"
-];
-
-// package.json
-var package_default = {
-  version: "0.0.5"};
-function RuleCreator(urlCreator) {
-  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
-  };
-}
-var createRule = RuleCreator(
-  (ruleName) => `https://docs.stormsoftware.com/projects/storm-ops/eslint-plugin-bun/rules/${ruleName}.md`
-);
-function isWorkspaceObject(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";
-}
-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, "_");
-}
-function sortObjectKeys(input) {
-  return Object.fromEntries(
-    Object.entries(input).sort(([left], [right]) => left.localeCompare(right))
-  );
-}
-function isWorkspaceRootPackageJson(data) {
-  return Boolean(
-    data.workspaces || data.catalog || data.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;
-}
-var WORKSPACE_CACHE_TIME = 1e4;
-var workspaceLastRead;
-var 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;
-}
-function isRootWorkspacePackageJson(filename, cwd = process.cwd()) {
-  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();
-}
-
-// src/helpers/iterate-dependencies.ts
-function getPackageJsonRootNode(context) {
-  if (!context.filename.endsWith("package.json")) {
-    return void 0;
-  }
-  const ast = context.sourceCode.ast;
-  const root = ast.body[0];
-  if (root?.expression?.type === "JSONObjectExpression") {
-    return root.expression;
-  }
-  return void 0;
-}
-function* iterateDependencies(context, fields) {
-  const root = getPackageJsonRootNode(context);
-  if (!root) {
-    return;
-  }
-  for (const fieldName of fields) {
-    const path = fieldName.split(".");
-    let node = root;
-    for (const segment of path) {
-      const item = node.properties?.find(
-        (property) => property.key.type === "JSONLiteral" && property.key.value === segment
-      );
-      if (!item?.value || item.value.type !== "JSONObjectExpression") {
-        node = void 0;
-        break;
-      }
-      node = item.value;
-    }
-    if (!node || node === root || !node.properties) {
-      continue;
-    }
-    for (const property of node.properties) {
-      if (property.value.type !== "JSONLiteral" || property.key.type !== "JSONLiteral") {
-        continue;
-      }
-      if (typeof property.value.value !== "string") {
-        continue;
-      }
-      yield {
-        packageName: String(property.key.value),
-        specifier: String(property.value.value),
-        property
-      };
-    }
-  }
-}
-function getObjectPath(obj, path) {
-  let current = obj;
-  for (const key of path) {
-    if (!current || typeof current !== "object") {
-      return void 0;
-    }
-    current = current[key];
-    if (!current) {
-      return void 0;
-    }
-  }
-  return current;
-}
-
-// src/rules/json-enforce-catalog.ts
-var RULE_NAME = "json-enforce-catalog";
-var DEFAULT_FIELDS = ["dependencies", "devDependencies"];
-var IGNORED_DEPENDENCIES = ["typescript"];
-var json_enforce_catalog_default = createRule({
-  name: RULE_NAME,
-  meta: {
-    type: "layout",
-    docs: {
-      description: 'Enforce using "catalog:" in `package.json` and write versions to the Bun workspace root catalog'
-    },
-    fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          allowedProtocols: {
-            type: "array",
-            description: "Allowed protocols in specifier to not be converted to catalog",
-            items: { type: "string" }
-          },
-          autofix: {
-            type: "boolean",
-            description: "Whether to autofix the linting error",
-            default: true
-          },
-          defaultCatalog: {
-            type: "string",
-            description: "Default catalog to use when moving version to catalog with autofix"
-          },
-          reuseExistingCatalog: {
-            type: "boolean",
-            description: "Whether to reuse existing catalog when moving version to catalog with autofix",
-            default: true
-          },
-          conflicts: {
-            type: "string",
-            description: "Strategy to handle conflicts when adding packages to catalogs",
-            enum: ["new-catalog", "overrides", "error"],
-            default: "new-catalog"
-          },
-          fields: {
-            type: "array",
-            description: "Fields to check for catalog",
-            items: { type: "string" },
-            default: DEFAULT_FIELDS
-          },
-          ignore: {
-            type: "array",
-            description: "A list of dependencies to ignore",
-            items: { type: "string" },
-            default: IGNORED_DEPENDENCIES
-          }
-        },
-        additionalProperties: false
-      }
-    ],
-    messages: {
-      expectCatalog: 'Expect to use catalog instead of plain specifier, got "{{specifier}}" for package "{{packageName}}".'
-    }
-  },
-  defaultOptions: [{}],
-  create(context, [options]) {
-    const {
-      allowedProtocols = ["workspace", "link", "file"],
-      defaultCatalog = "default",
-      autofix = true,
-      reuseExistingCatalog = true,
-      conflicts = "new-catalog",
-      fields = DEFAULT_FIELDS,
-      ignore = IGNORED_DEPENDENCIES
-    } = options || {};
-    for (const { packageName, specifier, property } of iterateDependencies(
-      context,
-      fields
-    )) {
-      if (ignore?.some((name) => name === packageName)) {
-        continue;
-      }
-      if (specifier.startsWith("catalog:")) {
-        continue;
-      }
-      if (allowedProtocols?.some((protocol) => specifier.startsWith(protocol))) {
-        continue;
-      }
-      let workspace2;
-      try {
-        workspace2 = getBunWorkspace();
-      } catch {
-        return {};
-      }
-      let targetCatalog = reuseExistingCatalog ? workspace2.getPackageCatalogs(packageName)[0] || defaultCatalog : defaultCatalog;
-      const resolvedConflicts = workspace2.hasSpecifierConflicts(
-        targetCatalog,
-        packageName,
-        specifier
-      );
-      let shouldFix = autofix;
-      if (conflicts === "error" && resolvedConflicts.conflicts) {
-        shouldFix = false;
-      }
-      if (conflicts === "new-catalog" && resolvedConflicts.conflicts) {
-        targetCatalog = resolvedConflicts.newCatalogName;
-      }
-      context.report({
-        node: property.value,
-        messageId: "expectCatalog",
-        data: {
-          specifier,
-          packageName
-        },
-        fix: shouldFix ? (fixer) => {
-          workspace2.queueChange(() => {
-            workspace2.setPackage(targetCatalog, packageName, specifier);
-          });
-          return fixer.replaceText(
-            property.value,
-            targetCatalog === "default" ? JSON.stringify("catalog:") : JSON.stringify(`catalog:${targetCatalog}`)
-          );
-        } : void 0
-      });
-    }
-    return {};
-  }
-});
-
-// src/rules/json-no-duplicate-catalog-item.ts
-var RULE_NAME2 = "json-no-duplicate-catalog-item";
-function getProperty(node, key) {
-  return node?.properties?.find(
-    (property) => property.key.type === "JSONLiteral" && property.key.value === key
-  );
-}
-var json_no_duplicate_catalog_item_default = createRule({
-  name: RULE_NAME2,
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow duplicate catalog items in the Bun workspace root `package.json`"
-    },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          allow: {
-            type: "array",
-            items: { type: "string" }
-          }
-        },
-        additionalProperties: false
-      }
-    ],
-    messages: {
-      duplicateCatalogItem: 'Catalog item "{{name}}" is already defined in the "{{existingCatalog}}" catalog. You may want to remove one of them.'
-    }
-  },
-  defaultOptions: [{}],
-  create(context, [options = {}]) {
-    if (!isRootWorkspacePackageJson(context.filename)) {
-      return {};
-    }
-    let workspace2;
-    try {
-      workspace2 = getBunWorkspace();
-    } catch {
-      return {};
-    }
-    if (workspace2.hasChanged() || workspace2.hasQueue()) {
-      return {};
-    }
-    workspace2.setContent(context.sourceCode.text);
-    const root = getPackageJsonRootNode(context);
-    if (!root) {
-      return {};
-    }
-    const { allow = [] } = options;
-    const topCatalog = getProperty(root, "catalog");
-    const topCatalogs = getProperty(root, "catalogs");
-    const workspaces = getProperty(root, "workspaces");
-    const workspacesCatalog = workspaces?.value?.type === "JSONObjectExpression" ? getProperty(workspaces.value, "catalog") : void 0;
-    const workspacesCatalogs = workspaces?.value?.type === "JSONObjectExpression" ? getProperty(workspaces.value, "catalogs") : void 0;
-    const catalogNode = topCatalog ?? workspacesCatalog;
-    const catalogsNode = topCatalogs ?? workspacesCatalogs;
-    const exists = /* @__PURE__ */ new Map();
-    const catalogEntries = [];
-    if (catalogNode?.value?.type === "JSONObjectExpression") {
-      for (const property of catalogNode.value.properties || []) {
-        catalogEntries.push({ catalogName: "default", property });
-      }
-    }
-    if (catalogsNode?.value?.type === "JSONObjectExpression") {
-      for (const named of catalogsNode.value.properties || []) {
-        if (named.value.type !== "JSONObjectExpression") {
-          continue;
-        }
-        const catalogName = String(named.key.value);
-        for (const property of named.value.properties || []) {
-          catalogEntries.push({ catalogName, property });
-        }
-      }
-    }
-    for (const { catalogName, property } of catalogEntries) {
-      const key = String(property.key.value);
-      if (allow.includes(key)) {
-        continue;
-      }
-      if (exists.has(key)) {
-        context.report({
-          node: property.value,
-          messageId: "duplicateCatalogItem",
-          data: {
-            name: key,
-            currentCatalog: catalogName,
-            existingCatalog: exists.get(key)
-          }
-        });
-      } else {
-        exists.set(key, catalogName);
-      }
-    }
-    return {};
-  }
-});
-var RULE_NAME3 = "json-no-unused-catalog-item";
-var FIELDS = [
-  "dependencies",
-  "devDependencies",
-  "peerDependencies",
-  "optionalDependencies",
-  "overrides",
-  "resolutions"
-];
-function getProperty2(node, key) {
-  return node?.properties?.find(
-    (property) => property.key.type === "JSONLiteral" && property.key.value === key
-  );
-}
-var json_no_unused_catalog_item_default = createRule({
-  name: RULE_NAME3,
-  meta: {
-    type: "problem",
-    docs: {
-      description: "Disallow unused catalog items in the Bun workspace root `package.json`"
-    },
-    schema: [],
-    messages: {
-      unusedCatalogItem: 'Catalog item "{{catalogItem}}" is not used in any package.json.'
-    }
-  },
-  defaultOptions: [],
-  create(context) {
-    if (!isRootWorkspacePackageJson(context.filename)) {
-      return {};
-    }
-    let workspace2;
-    try {
-      workspace2 = getBunWorkspace();
-    } catch {
-      return {};
-    }
-    if (workspace2.hasChanged() || workspace2.hasQueue()) {
-      return {};
-    }
-    workspace2.setContent(context.sourceCode.text);
-    const root = getPackageJsonRootNode(context);
-    if (!root) {
-      return {};
-    }
-    const topCatalog = getProperty2(root, "catalog");
-    const topCatalogs = getProperty2(root, "catalogs");
-    const workspaces = getProperty2(root, "workspaces");
-    const workspacesCatalog = workspaces?.value?.type === "JSONObjectExpression" ? getProperty2(workspaces.value, "catalog") : void 0;
-    const workspacesCatalogs = workspaces?.value?.type === "JSONObjectExpression" ? getProperty2(workspaces.value, "catalogs") : void 0;
-    const catalogNode = topCatalog ?? workspacesCatalog;
-    const catalogsNode = topCatalogs ?? workspacesCatalogs;
-    const entries = /* @__PURE__ */ new Map();
-    if (catalogNode?.value?.type === "JSONObjectExpression") {
-      for (const property of catalogNode.value.properties || []) {
-        entries.set(`${String(property.key.value)}:default`, property);
-      }
-    }
-    if (catalogsNode?.value?.type === "JSONObjectExpression") {
-      for (const named of catalogsNode.value.properties || []) {
-        if (named.value.type !== "JSONObjectExpression") {
-          continue;
-        }
-        const catalogName = String(named.key.value);
-        for (const property of named.value.properties || []) {
-          entries.set(`${String(property.key.value)}:${catalogName}`, property);
-        }
-      }
-    }
-    if (entries.size === 0) {
-      return {};
-    }
-    const packages = collectWorkspacePackageJsonPaths(workspace2);
-    for (const path of packages) {
-      const pkg = JSON.parse(fs.readFileSync(path, "utf8"));
-      for (const field of FIELDS) {
-        const map = getObjectPath(pkg, field.split("."));
-        if (!map) {
-          continue;
-        }
-        for (const [name, value] of Object.entries(map)) {
-          if (typeof value !== "string" || !value.startsWith("catalog:")) {
-            continue;
-          }
-          const catalogName = value.slice(8) || "default";
-          entries.delete(`${name}:${catalogName}`);
-        }
-      }
-    }
-    if (entries.size > 0) {
-      for (const [key, property] of Array.from(entries.entries()).sort(
-        (a, b) => a[0].localeCompare(b[0])
-      )) {
-        context.report({
-          node: property.value,
-          messageId: "unusedCatalogItem",
-          data: { catalogItem: key }
-        });
-      }
-    }
-    return {};
-  }
-});
-
-// src/rules/json-valid-catalog.ts
-var RULE_NAME4 = "json-valid-catalog";
-var DEFAULT_FIELDS2 = [
-  "dependencies",
-  "devDependencies",
-  "optionalDependencies",
-  "peerDependencies",
-  "resolutions",
-  "overrides"
-];
-var json_valid_catalog_default = createRule({
-  name: RULE_NAME4,
-  meta: {
-    type: "layout",
-    docs: {
-      description: "Enforce using valid Bun catalog references in `package.json`"
-    },
-    fixable: "code",
-    schema: [
-      {
-        type: "object",
-        properties: {
-          autoInsert: {
-            type: "boolean",
-            description: "Whether to auto insert to catalog if missing",
-            default: true
-          },
-          autoInsertDefaultSpecifier: {
-            type: "string",
-            description: "Default specifier to use when auto inserting to catalog",
-            default: "^0.0.0"
-          },
-          autofix: {
-            type: "boolean",
-            description: "Whether to autofix the linting error",
-            default: true
-          },
-          fields: {
-            type: "array",
-            description: "Fields to check for catalog",
-            default: DEFAULT_FIELDS2
-          }
-        },
-        additionalProperties: false
-      }
-    ],
-    messages: {
-      invalidCatalog: 'Catalog "{{specifier}}" for package "{{packageName}}" is not defined in the workspace root `package.json`.'
-    }
-  },
-  defaultOptions: [{}],
-  create(context, [options = {}]) {
-    const {
-      autoInsert = true,
-      autofix = true,
-      autoInsertDefaultSpecifier = "^0.0.0",
-      fields = DEFAULT_FIELDS2
-    } = options || {};
-    for (const { packageName, specifier, property } of iterateDependencies(
-      context,
-      fields
-    )) {
-      if (!specifier.startsWith("catalog:")) {
-        continue;
-      }
-      let workspace2;
-      try {
-        workspace2 = getBunWorkspace();
-      } catch {
-        return {};
-      }
-      const currentCatalog = specifier.replace(/^catalog:/, "").trim() || "default";
-      const existingCatalogs = workspace2.getPackageCatalogs(packageName);
-      if (!existingCatalogs.includes(currentCatalog)) {
-        context.report({
-          node: property.value,
-          messageId: "invalidCatalog",
-          data: {
-            specifier,
-            packageName
-          },
-          fix: !autofix || !autoInsert && !existingCatalogs.length ? void 0 : (fixer) => {
-            let catalog = existingCatalogs[0];
-            if (!catalog && autoInsert) {
-              catalog = currentCatalog;
-              workspace2.queueChange(() => {
-                workspace2.setPackage(
-                  catalog,
-                  packageName,
-                  autoInsertDefaultSpecifier
-                );
-              }, "pre");
-            }
-            return fixer.replaceText(
-              property.value,
-              catalog === "default" ? JSON.stringify("catalog:") : JSON.stringify(`catalog:${catalog}`)
-            );
-          }
-        });
-      }
-    }
-    return {};
-  }
-});
-
-// src/plugin.ts
-var plugin = {
-  meta: {
-    name: "bun",
-    version: package_default.version
-  },
-  rules: {
-    "json-enforce-catalog": json_enforce_catalog_default,
-    "json-valid-catalog": json_valid_catalog_default,
-    "json-no-unused-catalog-item": json_no_unused_catalog_item_default,
-    "json-no-duplicate-catalog-item": json_no_duplicate_catalog_item_default
-  }
-};
-
-// src/configs/recommended.ts
-var config = [
-  {
-    name: "bun/recommended/setup",
-    plugins: {
-      bun: plugin
-    }
-  },
-  {
-    name: "bun/recommended/package-json",
-    ignores: GLOB_EXCLUDE,
-    files: ["package.json", "**/package.json"],
-    languageOptions: {
-      parser: parserJsonc
-    },
-    rules: {
-      "bun/json-enforce-catalog": [
-        "error",
-        {
-          autofix: true,
-          allowedProtocols: ["workspace", "link", "file"],
-          defaultCatalog: "default",
-          reuseExistingCatalog: true,
-          conflicts: "overrides",
-          fields: ["dependencies", "devDependencies"],
-          ignore: ["typescript"]
-        }
-      ],
-      "bun/json-valid-catalog": "error",
-      "bun/json-no-unused-catalog-item": "error",
-      "bun/json-no-duplicate-catalog-item": "error"
-    }
-  }
-];
-var recommended_default = config;
-
-export { recommended_default as default };
+import { t as plugin } from "../plugin-DfH7W_YX.mjs";
+import { GLOB_EXCLUDE } from "@storm-software/package-constants/globs";
+import parserJsonc from "jsonc-eslint-parser";
+//#region src/configs/recommended.ts
+const config = [{
+	name: "bun/recommended/setup",
+	plugins: { bun: plugin }
+}, {
+	name: "bun/recommended/package-json",
+	ignores: GLOB_EXCLUDE,
+	files: ["package.json", "**/package.json"],
+	languageOptions: { parser: parserJsonc },
+	rules: {
+		"bun/json-enforce-catalog": ["error", {
+			autofix: true,
+			allowedProtocols: [
+				"workspace",
+				"link",
+				"file"
+			],
+			defaultCatalog: "default",
+			reuseExistingCatalog: true,
+			conflicts: "overrides",
+			fields: ["dependencies", "devDependencies"],
+			ignore: ["typescript"]
+		}],
+		"bun/json-valid-catalog": "error",
+		"bun/json-no-unused-catalog-item": "error",
+		"bun/json-no-duplicate-catalog-item": "error"
+	}
+}];
+//#endregion
+export { config as default };