@storm-software/eslint 0.144.1 → 0.144.3

package/dist/preset.js

@@ -350,7 +350,7 @@ async function formatters(options = {}, stylistic2 = {}) {
     useTabs: indent === "tab"
   }, options.dprintOptions ?? {});
   const pluginFormat = await interopDefault(import("eslint-plugin-format"));
-  const configs2 = [
+  const configs3 = [
     {
       name: "storm/formatter/setup",
       plugins: {
@@ -359,7 +359,7 @@ async function formatters(options = {}, stylistic2 = {}) {
     }
   ];
   if (options.css) {
-    configs2.push({
+    configs3.push({
       files: [
         GLOB_CSS,
         GLOB_POSTCSS
@@ -411,7 +411,7 @@ async function formatters(options = {}, stylistic2 = {}) {
     });
   }
   if (options.html) {
-    configs2.push({
+    configs3.push({
       files: [
         GLOB_HTML
       ],
@@ -430,7 +430,7 @@ async function formatters(options = {}, stylistic2 = {}) {
     });
   }
   if (options.xml) {
-    configs2.push({
+    configs3.push({
       files: [
         GLOB_XML
       ],
@@ -455,7 +455,7 @@ async function formatters(options = {}, stylistic2 = {}) {
     });
   }
   if (options.svg) {
-    configs2.push({
+    configs3.push({
       files: [
         GLOB_SVG
       ],
@@ -481,7 +481,7 @@ async function formatters(options = {}, stylistic2 = {}) {
   }
   if (options.markdown) {
     const formater = options.markdown === true ? "prettier" : options.markdown;
-    configs2.push({
+    configs3.push({
       files: [
         GLOB_MARKDOWN
       ],
@@ -504,7 +504,7 @@ async function formatters(options = {}, stylistic2 = {}) {
     });
   }
   if (options.astro) {
-    configs2.push({
+    configs3.push({
       files: [
         GLOB_ASTRO
       ],
@@ -524,7 +524,7 @@ async function formatters(options = {}, stylistic2 = {}) {
         ]
       }
     });
-    configs2.push({
+    configs3.push({
       files: [
         GLOB_ASTRO,
         GLOB_ASTRO_TS
@@ -542,7 +542,7 @@ async function formatters(options = {}, stylistic2 = {}) {
     });
   }
   if (options.graphql) {
-    configs2.push({
+    configs3.push({
       files: [
         GLOB_GRAPHQL
       ],
@@ -560,7 +560,7 @@ async function formatters(options = {}, stylistic2 = {}) {
       }
     });
   }
-  return configs2;
+  return configs3;
 }
 __name(formatters, "formatters");
 
@@ -810,6 +810,704 @@ import * as pluginImport from "eslint-plugin-import-x";
 import { default as default4 } from "eslint-plugin-n";
 import { default as default5 } from "eslint-plugin-no-secrets";
 import { default as default6 } from "eslint-plugin-perfectionist";
+
+// ../../node_modules/.pnpm/eslint-plugin-pnpm@0.3.0_patch_hash=72dcde755c336eeca3e6170de1106fd85ecb66171e060788f80_167ca0fed09ad05248614e7080eb405f/node_modules/eslint-plugin-pnpm/dist/index.mjs
+import * as jsoncParser from "jsonc-eslint-parser";
+import * as yamlParser from "yaml-eslint-parser";
+import fs, { existsSync, readFileSync } from "node:fs";
+import process from "node:process";
+import { findUpSync } from "find-up-simple";
+import { parsePnpmWorkspaceYaml } from "pnpm-workspace-yaml";
+import { basename, normalize, resolve, dirname } from "pathe";
+import { globSync } from "tinyglobby";
+var name = "eslint-plugin-pnpm";
+var version = "0.3.0";
+var blobUrl = "https://github.com/antfu/eslint-plugin-pnpm/blob/main/src/rules/";
+function RuleCreator(urlCreator) {
+  return /* @__PURE__ */ __name(function createNamedRule({
+    name: name2,
+    meta,
+    ...rule
+  }) {
+    return createRule({
+      meta: {
+        ...meta,
+        docs: {
+          ...meta.docs,
+          url: urlCreator(name2)
+        }
+      },
+      ...rule
+    });
+  }, "createNamedRule");
+}
+__name(RuleCreator, "RuleCreator");
+function createRule({
+  create,
+  defaultOptions,
+  meta
+}) {
+  return {
+    create: /* @__PURE__ */ __name((context) => {
+      const optionsWithDefault = context.options.map((options, index) => {
+        return {
+          ...defaultOptions[index] || {},
+          ...options || {}
+        };
+      });
+      return create(context, optionsWithDefault);
+    }, "create"),
+    defaultOptions,
+    meta
+  };
+}
+__name(createRule, "createRule");
+var createEslintRule = RuleCreator(
+  (ruleName) => `${blobUrl}${ruleName}.test.ts`
+);
+function getPackageJsonRootNode(context) {
+  if (!context.filename.endsWith("package.json"))
+    return;
+  const ast = context.sourceCode.ast;
+  const root = ast.body[0];
+  if (root.expression.type === "JSONObjectExpression")
+    return root.expression;
+}
+__name(getPackageJsonRootNode, "getPackageJsonRootNode");
+function* iterateDependencies(context, fields) {
+  const root = getPackageJsonRootNode(context);
+  if (!root)
+    return;
+  for (const fieldName of fields) {
+    const path = fieldName.split(".");
+    let node2 = root;
+    for (let i = 0; i < path.length; i++) {
+      const item = node2.properties.find((property) => property.key.type === "JSONLiteral" && property.key.value === path[i]);
+      if (!item?.value || item.value.type !== "JSONObjectExpression") {
+        node2 = void 0;
+        break;
+      }
+      node2 = item.value;
+    }
+    if (!node2 || node2 === root)
+      continue;
+    for (const property of node2.properties) {
+      if (property.value.type !== "JSONLiteral" || property.key.type !== "JSONLiteral")
+        continue;
+      if (typeof property.value.value !== "string")
+        continue;
+      const packageName = String(property.key.value);
+      const specifier = String(property.value.value);
+      yield {
+        packageName,
+        specifier,
+        property
+      };
+    }
+  }
+}
+__name(iterateDependencies, "iterateDependencies");
+function readPnpmWorkspace() {
+  const filepath = findUpSync("pnpm-workspace.yaml", { cwd: process.cwd() });
+  if (!filepath)
+    throw new Error("pnpm-workspace.yaml not found");
+  const content = fs.readFileSync(filepath, "utf-8");
+  const workspace2 = parsePnpmWorkspaceYaml(content);
+  let queueTimer;
+  const queue = [];
+  const write = /* @__PURE__ */ __name(() => {
+    fs.writeFileSync(filepath, workspace2.toString());
+  }, "write");
+  const hasQueue = /* @__PURE__ */ __name(() => queueTimer != null, "hasQueue");
+  const queueChange = /* @__PURE__ */ __name((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 fn2 of clone)
+        fn2(workspace2);
+      if (workspace2.hasChanged())
+        write();
+    }, 1e3);
+  }, "queueChange");
+  return {
+    filepath,
+    ...workspace2,
+    hasQueue,
+    queueChange
+  };
+}
+__name(readPnpmWorkspace, "readPnpmWorkspace");
+var WORKSPACE_CACHE_TIME = 1e4;
+var workspaceLastRead;
+var workspace;
+function getPnpmWorkspace() {
+  if (workspaceLastRead && workspace && !workspace.hasQueue() && Date.now() - workspaceLastRead > WORKSPACE_CACHE_TIME) {
+    workspace = void 0;
+  }
+  if (!workspace) {
+    workspace = readPnpmWorkspace();
+    workspaceLastRead = Date.now();
+  }
+  return workspace;
+}
+__name(getPnpmWorkspace, "getPnpmWorkspace");
+var RULE_NAME$4 = "json-enforce-catalog";
+var DEFAULT_FIELDS$1 = [
+  "dependencies",
+  "devDependencies"
+];
+var IGNORED_DEPENDENCIES = [
+  "typescript"
+];
+var enforceCatalog = createEslintRule({
+  name: RULE_NAME$4,
+  meta: {
+    type: "layout",
+    docs: {
+      description: 'Enforce using "catalog:" in `package.json`'
+    },
+    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$1
+          },
+          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$1,
+      ignore = IGNORED_DEPENDENCIES
+    } = options || {};
+    for (const { packageName, specifier, property } of iterateDependencies(context, fields)) {
+      if (ignore?.some((i) => i === packageName))
+        continue;
+      if (specifier.startsWith("catalog:"))
+        continue;
+      if (allowedProtocols?.some((p) => specifier.startsWith(p)))
+        continue;
+      const workspace2 = getPnpmWorkspace();
+      if (!workspace2)
+        return {};
+      let targetCatalog = reuseExistingCatalog ? workspace2.getPackageCatalogs(packageName)[0] || defaultCatalog : defaultCatalog;
+      const resolvedConflicts = workspace2.hasSpecifierConflicts(
+        targetCatalog,
+        packageName,
+        specifier
+      );
+      let shouldFix = autofix;
+      if (conflicts === "error") {
+        if (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 {};
+  }
+});
+var RULE_NAME$3 = "json-prefer-workspace-settings";
+var preferWorkspaceSettings = createEslintRule({
+  name: RULE_NAME$3,
+  meta: {
+    type: "layout",
+    docs: {
+      description: "Prefer having pnpm settings in `pnpm-workspace.yaml` instead of `package.json`. This would requires pnpm v10.6+, see https://github.com/orgs/pnpm/discussions/9037."
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          autofix: {
+            type: "boolean",
+            description: "Whether to autofix the linting error",
+            default: true
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      unexpectedPnpmSettings: "Unexpected pnpm settings in package.json, should move to pnpm-workspace.yaml"
+    }
+  },
+  defaultOptions: [{}],
+  create(context, [options = {}]) {
+    const {
+      autofix = true
+    } = options || {};
+    const root = getPackageJsonRootNode(context);
+    if (!root)
+      return {};
+    const pnpmNode = root.properties.find((property) => property.key.type === "JSONLiteral" && property.key.value === "pnpm");
+    if (!pnpmNode)
+      return {};
+    const workspace2 = getPnpmWorkspace();
+    if (!workspace2)
+      return {};
+    context.report({
+      node: pnpmNode,
+      messageId: "unexpectedPnpmSettings",
+      fix: autofix ? (fixer) => {
+        const json = JSON.parse(context.sourceCode.text);
+        const pnpmSettings = json.pnpm;
+        const flatValueParis = [];
+        function traverse(value, paths) {
+          if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+            for (const key in value) {
+              traverse(value[key], [...paths, key]);
+            }
+          } else {
+            flatValueParis.push([paths, value]);
+          }
+        }
+        __name(traverse, "traverse");
+        traverse(pnpmSettings, []);
+        workspace2.queueChange(() => {
+          for (const [paths, value] of flatValueParis) {
+            workspace2.setPath(paths, value);
+          }
+        });
+        let start = pnpmNode.range[0];
+        let end = pnpmNode.range[1];
+        const before = context.sourceCode.getTokenBefore(pnpmNode);
+        if (before)
+          start = before.range[1];
+        const after = context.sourceCode.getTokenAfter(pnpmNode);
+        if (after?.type === "Punctuator" && after.value === ",")
+          end = after.range[1];
+        return fixer.removeRange([start, end]);
+      } : void 0
+    });
+    return {};
+  }
+});
+var RULE_NAME$2 = "json-valid-catalog";
+var DEFAULT_FIELDS = [
+  "dependencies",
+  "devDependencies",
+  "optionalDependencies",
+  "peerDependencies",
+  "resolutions",
+  "overrides",
+  "pnpm.overrides"
+];
+var validCatalog = createEslintRule({
+  name: RULE_NAME$2,
+  meta: {
+    type: "layout",
+    docs: {
+      description: "Enforce using valid catalog 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
+          },
+          enforceNoConflict: {
+            type: "boolean",
+            description: "Whether to enforce no conflicts when adding packages to catalogs (will create version-specific catalogs)",
+            default: true
+          },
+          fields: {
+            type: "array",
+            description: "Fields to check for catalog",
+            default: DEFAULT_FIELDS
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      invalidCatalog: 'Catalog "{{specifier}}" for package "{{packageName}}" is not defined in `pnpm-workspace.yaml`.'
+    }
+  },
+  defaultOptions: [{}],
+  create(context, [options = {}]) {
+    const {
+      autoInsert = true,
+      autofix = true,
+      autoInsertDefaultSpecifier = "^0.0.0",
+      fields = DEFAULT_FIELDS
+    } = options || {};
+    for (const { packageName, specifier, property } of iterateDependencies(context, fields)) {
+      if (!specifier.startsWith("catalog:"))
+        continue;
+      const workspace2 = getPnpmWorkspace();
+      if (!workspace2)
+        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 {};
+  }
+});
+var rules$2 = {
+  "json-enforce-catalog": enforceCatalog,
+  "json-valid-catalog": validCatalog,
+  "json-prefer-workspace-settings": preferWorkspaceSettings
+};
+var RULE_NAME$1 = "yaml-no-duplicate-catalog-item";
+var noDuplicateCatalogItem = createEslintRule({
+  name: RULE_NAME$1,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow unused catalogs in `pnpm-workspace.yaml`"
+    },
+    fixable: "code",
+    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 (basename(context.filename) !== "pnpm-workspace.yaml")
+      return {};
+    const workspace2 = getPnpmWorkspace();
+    if (!workspace2 || normalize(workspace2.filepath) !== normalize(context.filename))
+      return {};
+    if (workspace2.hasChanged() || workspace2.hasQueue())
+      return {};
+    const { allow = [] } = options;
+    workspace2.setContent(context.sourceCode.text);
+    const json = workspace2.toJSON() || {};
+    const exists = /* @__PURE__ */ new Map();
+    const catalogs = {
+      ...json.catalogs,
+      default: json.catalog
+    };
+    const doc = workspace2.getDocument();
+    for (const [catalog, object] of Object.entries(catalogs)) {
+      if (!object)
+        continue;
+      for (const key of Object.keys(object)) {
+        if (allow.includes(key))
+          continue;
+        if (exists.has(key)) {
+          const existingCatalog = exists.get(key);
+          const node2 = doc.getIn(catalog === "default" ? ["catalog", key] : ["catalogs", catalog, key], true);
+          const start = context.sourceCode.getLocFromIndex(node2.range[0]);
+          const end = context.sourceCode.getLocFromIndex(node2.range[1]);
+          context.report({
+            loc: {
+              start,
+              end
+            },
+            messageId: "duplicateCatalogItem",
+            data: {
+              name: key,
+              currentCatalog: catalog,
+              existingCatalog
+            }
+          });
+        } else {
+          exists.set(key, catalog);
+        }
+      }
+    }
+    return {};
+  }
+});
+var RULE_NAME = "yaml-no-unused-catalog-item";
+var noUnusedCatalogItem = createEslintRule({
+  name: RULE_NAME,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow unused catalogs in `pnpm-workspace.yaml`"
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      unusedCatalogItem: 'Catalog item "{{catalogItem}}" is not used in any package.json.'
+    }
+  },
+  defaultOptions: [],
+  create(context) {
+    if (basename(context.filename) !== "pnpm-workspace.yaml")
+      return {};
+    const workspace2 = getPnpmWorkspace();
+    if (!workspace2 || normalize(workspace2.filepath) !== normalize(context.filename))
+      return {};
+    if (workspace2.hasChanged() || workspace2.hasQueue())
+      return {};
+    workspace2.setContent(context.sourceCode.text);
+    const parsed = workspace2.toJSON() || {};
+    const root = resolve(dirname(context.filename));
+    const entries = /* @__PURE__ */ new Map();
+    const doc = workspace2.getDocument();
+    const catalogs = {
+      default: doc.getIn(["catalog"])
+    };
+    for (const item of doc.getIn(["catalogs"])?.items || [])
+      catalogs[String(item.key)] = item.value;
+    for (const [catalog, map] of Object.entries(catalogs)) {
+      if (!map)
+        continue;
+      for (const item of map.items) {
+        entries.set(`${String(item.key)}:${catalog}`, item);
+      }
+    }
+    if (entries.size === 0)
+      return {};
+    const dirs = parsed.packages ? globSync(parsed.packages, {
+      cwd: root,
+      dot: false,
+      ignore: [
+        "**/node_modules/**",
+        "**/dist/**",
+        "**/build/**",
+        "**/dist/**",
+        "**/dist/**"
+      ],
+      absolute: true,
+      expandDirectories: false,
+      onlyDirectories: true
+    }) : [];
+    dirs.push(root);
+    const packages = dirs.map((dir) => resolve(dir, "package.json")).filter((x) => existsSync(x)).sort();
+    const FIELDS = [
+      "dependencies",
+      "devDependencies",
+      "peerDependencies",
+      "optionalDependencies",
+      "overrides",
+      "resolutions",
+      "pnpm.overrides"
+    ];
+    for (const path of packages) {
+      const pkg = JSON.parse(readFileSync(path, "utf-8"));
+      for (const field of FIELDS) {
+        const map = getObjectPath(pkg, field.split("."));
+        if (!map)
+          continue;
+        for (const [name2, value] of Object.entries(map)) {
+          if (!value.startsWith("catalog:"))
+            continue;
+          const catalog = value.slice(8) || "default";
+          const key = `${name2}:${catalog}`;
+          entries.delete(key);
+        }
+      }
+    }
+    if (entries.size > 0) {
+      for (const [key, value] of Array.from(entries.entries()).sort((a, b) => a[0].localeCompare(b[0]))) {
+        const start = context.sourceCode.getLocFromIndex(value.key.range[0]);
+        const end = context.sourceCode.getLocFromIndex(value.value.range.at(-1));
+        context.report({
+          loc: {
+            start,
+            end
+          },
+          messageId: "unusedCatalogItem",
+          data: { catalogItem: key }
+        });
+      }
+    }
+    return {};
+  }
+});
+function getObjectPath(obj, path) {
+  let current = obj;
+  for (const key of path) {
+    current = current[key];
+    if (!current)
+      return void 0;
+  }
+  return current;
+}
+__name(getObjectPath, "getObjectPath");
+var rules$1 = {
+  "yaml-no-unused-catalog-item": noUnusedCatalogItem,
+  "yaml-no-duplicate-catalog-item": noDuplicateCatalogItem
+};
+var rules = {
+  ...rules$2,
+  ...rules$1
+};
+var plugin = {
+  meta: {
+    name,
+    version
+  },
+  rules
+};
+var configsJson = [
+  {
+    name: "pnpm/package.json",
+    files: [
+      "package.json",
+      "**/package.json"
+    ],
+    languageOptions: {
+      parser: jsoncParser
+    },
+    plugins: {
+      pnpm: plugin
+    },
+    rules: {
+      "pnpm/json-enforce-catalog": "error",
+      "pnpm/json-valid-catalog": "error",
+      "pnpm/json-prefer-workspace-settings": "error"
+    }
+  }
+];
+var configsYaml = [
+  {
+    name: "pnpm/pnpm-workspace-yaml",
+    files: ["pnpm-workspace.yaml"],
+    languageOptions: {
+      parser: yamlParser
+    },
+    plugins: {
+      pnpm: plugin
+    },
+    rules: {
+      "pnpm/yaml-no-unused-catalog-item": "error",
+      "pnpm/yaml-no-duplicate-catalog-item": "error"
+    }
+  }
+];
+var configs = {
+  recommended: [
+    ...configsJson
+    // Yaml support is still experimental
+    // ...configsYaml,
+  ],
+  json: configsJson,
+  yaml: configsYaml
+};
+plugin.configs = configs;
+
+// src/plugins.ts
 import { default as default7 } from "eslint-plugin-prettier";
 import { default as default8 } from "eslint-plugin-unicorn";
 import { default as default9 } from "eslint-plugin-unused-imports";
@@ -2705,19 +3403,26 @@ __name(perfectionist, "perfectionist");
 
 // src/configs/pnpm.ts
 async function pnpm(options = {}) {
-  const { overrides = {}, skipPackages = [
+  const { overrides = {}, ignore = [
     "typescript"
   ] } = options;
-  const [pluginPnpm, parserJsonc] = await Promise.all([
-    interopDefault(import("./dist-JAA754SN.js")),
-    interopDefault(import("jsonc-eslint-parser"))
+  await ensurePackages([
+    "jsonc-eslint-parser",
+    "yaml-eslint-parser"
+  ]);
+  const [parserJsonc, parserYaml] = await Promise.all([
+    interopDefault(import("jsonc-eslint-parser")),
+    interopDefault(import("yaml-eslint-parser"))
   ]);
   return [
     {
-      name: "storm/pnpm",
+      name: "storm/pnpm/setup",
       plugins: {
-        pnpm: pluginPnpm
-      },
+        pnpm: plugin
+      }
+    },
+    {
+      name: "storm/pnpm/package-json",
       ignores: [
         "**/node_modules/**",
         "**/dist/**"
@@ -2730,14 +3435,46 @@ async function pnpm(options = {}) {
         parser: parserJsonc
       },
       rules: {
-        "pnpm/enforce-catalog": [
+        "pnpm/json-enforce-catalog": [
           "error",
           {
-            skipPackages
+            ignore,
+            autofix: true,
+            allowedProtocols: [
+              "workspace",
+              "link",
+              "file"
+            ],
+            defaultCatalog: "default",
+            reuseExistingCatalog: true,
+            conflicts: "new-catalog",
+            fields: [
+              "dependencies",
+              "devDependencies"
+            ]
           }
         ],
-        "pnpm/valid-catalog": "error",
-        "pnpm/prefer-workspace-settings": "error",
+        "pnpm/json-valid-catalog": "error",
+        "pnpm/json-prefer-workspace-settings": "error",
+        ...overrides
+      }
+    },
+    {
+      name: "storm/pnpm/pnpm-workspace-yaml",
+      ignores: [
+        "**/node_modules/**",
+        "**/dist/**"
+      ],
+      files: [
+        "pnpm-workspace.yaml",
+        "**/pnpm-workspace.yaml"
+      ],
+      languageOptions: {
+        parser: parserYaml
+      },
+      rules: {
+        "pnpm/yaml-no-unused-catalog-item": "error",
+        "pnpm/yaml-no-duplicate-catalog-item": "error",
         ...overrides
       }
     }
@@ -2975,15 +3712,15 @@ async function reactNative(options = {}) {
 __name(reactNative, "reactNative");
 
 // src/configs/regexp.ts
-import { configs } from "eslint-plugin-regexp";
+import { configs as configs2 } from "eslint-plugin-regexp";
 async function regexp(options = {}) {
-  const config2 = configs["flat/recommended"];
-  const rules = {
+  const config2 = configs2["flat/recommended"];
+  const rules2 = {
     ...config2.rules
   };
   if (options.level === "warn") {
-    for (const key in rules) {
-      if (rules[key] === "error") rules[key] = "warn";
+    for (const key in rules2) {
+      if (rules2[key] === "error") rules2[key] = "warn";
     }
   }
   return [
@@ -2991,7 +3728,7 @@ async function regexp(options = {}) {
       ...config2,
       name: "storm/regexp/rules",
       rules: {
-        ...rules,
+        ...rules2,
         "regexp/no-unused-capturing-group": [
           "error",
           {
@@ -3910,17 +4647,17 @@ function getStormConfig(options, ...userConfigs) {
   }
   const stylisticOptions = !options.stylistic ? false : typeof options.stylistic === "object" ? options.stylistic : {};
   if (stylisticOptions && !("jsx" in stylisticOptions)) stylisticOptions.jsx = enableJsx;
-  const configs2 = [];
+  const configs3 = [];
   if (enableGitignore) {
     if (typeof enableGitignore !== "boolean") {
-      configs2.push(interopDefault(import("eslint-config-flat-gitignore")).then((r) => [
+      configs3.push(interopDefault(import("eslint-config-flat-gitignore")).then((r) => [
         r({
           name: "storm/gitignore",
           ...enableGitignore
         })
       ]));
     } else {
-      configs2.push(interopDefault(import("eslint-config-flat-gitignore")).then((r) => [
+      configs3.push(interopDefault(import("eslint-config-flat-gitignore")).then((r) => [
         r({
           name: "storm/gitignore",
           strict: false
@@ -3933,7 +4670,7 @@ function getStormConfig(options, ...userConfigs) {
   if (!tsconfigPath) {
     tsconfigPath = getTsConfigPath();
   }
-  configs2.push(ignores(options.ignores), javascript({
+  configs3.push(ignores(options.ignores), javascript({
     repositoryName,
     globals,
     lineEndings,
@@ -3947,19 +4684,19 @@ function getStormConfig(options, ...userConfigs) {
     json: options.jsonc !== false
   }));
   if (!stylisticOptions) {
-    configs2.push(prettier());
+    configs3.push(prettier());
   }
   if (enableCSpell) {
-    configs2.push(cspell(resolveSubOptions(options, "cspell")));
+    configs3.push(cspell(resolveSubOptions(options, "cspell")));
   }
   if (enableUnicorn) {
-    configs2.push(unicorn(enableUnicorn === true ? {} : enableUnicorn));
+    configs3.push(unicorn(enableUnicorn === true ? {} : enableUnicorn));
   }
   if (enableJsx) {
-    configs2.push(jsx());
+    configs3.push(jsx());
   }
   if (enableTypeScript) {
-    configs2.push(typescript({
+    configs3.push(typescript({
       ...typescriptOptions,
       componentExts,
       overrides: getOverrides(options, "typescript"),
@@ -3967,7 +4704,7 @@ function getStormConfig(options, ...userConfigs) {
     }));
   }
   if (stylisticOptions) {
-    configs2.push(stylistic({
+    configs3.push(stylistic({
       ...stylisticOptions,
       lineEndings,
       lessOpinionated: options.lessOpinionated,
@@ -3975,90 +4712,90 @@ function getStormConfig(options, ...userConfigs) {
     }));
   }
   if (enableRegexp) {
-    configs2.push(regexp(typeof enableRegexp === "boolean" ? {} : enableRegexp));
+    configs3.push(regexp(typeof enableRegexp === "boolean" ? {} : enableRegexp));
   }
   if (options.test ?? true) {
-    configs2.push(test({
+    configs3.push(test({
       isInEditor,
       overrides: getOverrides(options, "test")
     }));
   }
   if (enableGraphQL) {
-    configs2.push(graphql(resolveSubOptions(options, "graphql")));
+    configs3.push(graphql(resolveSubOptions(options, "graphql")));
   }
   if (enableReact) {
-    configs2.push(react({
+    configs3.push(react({
       ...typescriptOptions,
       overrides: getOverrides(options, "react"),
       tsconfigPath
     }));
   }
   if (enableReactNative) {
-    configs2.push(reactNative({
+    configs3.push(reactNative({
       ...resolveSubOptions(options, "react-native"),
       overrides: getOverrides(options, "react-native")
     }));
   }
   if (enableNext) {
-    configs2.push(next(resolveSubOptions(options, "next")));
+    configs3.push(next(resolveSubOptions(options, "next")));
   }
   if (enableStorybook) {
-    configs2.push(storybook(resolveSubOptions(options, "storybook")));
+    configs3.push(storybook(resolveSubOptions(options, "storybook")));
   }
   if (enableUnoCSS) {
-    configs2.push(unocss({
+    configs3.push(unocss({
       ...resolveSubOptions(options, "unocss"),
       overrides: getOverrides(options, "unocss")
     }));
   }
   if (enableAstro) {
-    configs2.push(astro({
+    configs3.push(astro({
       overrides: getOverrides(options, "astro"),
       stylistic: stylisticOptions
     }));
   }
   if (options.pnpm ?? true) {
-    configs2.push(pnpm({
+    configs3.push(pnpm({
       overrides: getOverrides(options, "pnpm"),
-      skipPackages: typeof options.pnpm !== "boolean" ? options.pnpm?.skipPackages : void 0
+      ignore: typeof options.pnpm !== "boolean" ? options.pnpm?.ignore : void 0
     }));
   }
   if (options.jsonc ?? true) {
-    configs2.push(jsonc({
+    configs3.push(jsonc({
       overrides: getOverrides(options, "jsonc"),
       stylistic: stylisticOptions
     }), sortTsconfig());
     if (stylisticOptions) {
-      configs2.push(sortPackageJson());
+      configs3.push(sortPackageJson());
     }
   }
   if (options.yaml ?? true) {
-    configs2.push(yaml({
+    configs3.push(yaml({
       overrides: getOverrides(options, "yaml"),
       stylistic: stylisticOptions
     }));
   }
   if (options.toml ?? true) {
-    configs2.push(toml({
+    configs3.push(toml({
       overrides: getOverrides(options, "toml"),
       stylistic: stylisticOptions
     }));
   }
   if (options.markdown ?? true) {
-    configs2.push(markdown({
+    configs3.push(markdown({
       componentExts,
       overrides: getOverrides(options, "markdown")
     }));
   }
   if (options.mdx ?? true) {
-    configs2.push(mdx({
+    configs3.push(mdx({
       overrides: getOverrides(options, "mdx")
     }));
   }
   if (options.formatters) {
-    configs2.push(formatters(options.formatters, typeof stylisticOptions === "boolean" ? {} : stylisticOptions));
+    configs3.push(formatters(options.formatters, typeof stylisticOptions === "boolean" ? {} : stylisticOptions));
   }
-  configs2.push(disables());
+  configs3.push(disables());
   if ("files" in options) {
     throw new Error('[@storm-software/eslint] The first argument should not contain the "files" property as the options are supposed to be global. Place it in the second or later config instead.');
   }
@@ -4068,11 +4805,11 @@ function getStormConfig(options, ...userConfigs) {
     }
     return acc;
   }, {});
-  if (Object.keys(fusedConfig).length) configs2.push([
+  if (Object.keys(fusedConfig).length) configs3.push([
     fusedConfig
   ]);
   let composer = new FlatConfigComposer();
-  composer = composer.append(...configs2, ...userConfigs);
+  composer = composer.append(...configs3, ...userConfigs);
   if (autoRenamePlugins) {
     composer = composer.renamePlugins(defaultPluginRenaming);
   }