@storm-software/eslint 0.170.147 → 0.170.148

package/dist/src-UCLM7J4T.js

@@ -0,0 +1,779 @@
+import { GLOB_EXCLUDE } from './chunk-23MHL5A5.js';
+import { init_esm_shims } from './chunk-V2FABXKB.js';
+import * as jsoncParser from 'jsonc-eslint-parser';
+import jsoncParser__default from 'jsonc-eslint-parser';
+import * as yamlParser from 'yaml-eslint-parser';
+import yamlParser__default 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';
+
+// ../eslint-plugin-pnpm/src/index.ts
+init_esm_shims();
+
+// ../eslint-plugin-pnpm/src/configs/index.ts
+init_esm_shims();
+
+// ../eslint-plugin-pnpm/src/configs/recommended.ts
+init_esm_shims();
+
+// ../eslint-plugin-pnpm/src/plugin.ts
+init_esm_shims();
+
+// ../../node_modules/.pnpm/eslint-plugin-pnpm@0.3.0_patch_hash=72dcde755c336eeca3e6170de1106fd85ecb66171e060788f80_f126904b94a1635d882631163ea19421/node_modules/eslint-plugin-pnpm/dist/index.mjs
+init_esm_shims();
+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 function createNamedRule({
+    name: name2,
+    meta,
+    ...rule
+  }) {
+    return createRule({
+      meta: {
+        ...meta,
+        docs: {
+          ...meta.docs,
+          url: urlCreator(name2)
+        }
+      },
+      ...rule
+    });
+  };
+}
+function createRule({
+  create,
+  defaultOptions,
+  meta
+}) {
+  return {
+    create: (context) => {
+      const optionsWithDefault = context.options.map((options, index) => {
+        return {
+          ...defaultOptions[index] || {},
+          ...options || {}
+        };
+      });
+      return create(context, optionsWithDefault);
+    },
+    defaultOptions,
+    meta
+  };
+}
+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;
+}
+function* iterateDependencies(context, fields) {
+  const root = getPackageJsonRootNode(context);
+  if (!root)
+    return;
+  for (const fieldName of fields) {
+    const path = fieldName.split(".");
+    let node = root;
+    for (let i = 0; i < path.length; i++) {
+      const item = node.properties.find((property) => property.key.type === "JSONLiteral" && property.key.value === path[i]);
+      if (!item?.value || item.value.type !== "JSONObjectExpression") {
+        node = void 0;
+        break;
+      }
+      node = item.value;
+    }
+    if (!node || node === root)
+      continue;
+    for (const property of node.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
+      };
+    }
+  }
+}
+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 = () => {
+    fs.writeFileSync(filepath, workspace2.toString());
+  };
+  const hasQueue = () => queueTimer != null;
+  const 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 fn2 of clone)
+        fn2(workspace2);
+      if (workspace2.hasChanged())
+        write();
+    }, 1e3);
+  };
+  return {
+    filepath,
+    ...workspace2,
+    hasQueue,
+    queueChange
+  };
+}
+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;
+}
+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]);
+          }
+        }
+        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 node = doc.getIn(catalog === "default" ? ["catalog", key] : ["catalogs", catalog, key], true);
+          const start = context.sourceCode.getLocFromIndex(node.range[0]);
+          const end = context.sourceCode.getLocFromIndex(node.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;
+}
+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;
+
+// ../eslint-plugin-pnpm/package.json
+var package_default = {
+  version: "0.0.76"};
+
+// ../eslint-plugin-pnpm/src/plugin.ts
+var plugin2 = {
+  ...plugin,
+  meta: {
+    name: "pnpm",
+    version: package_default.version
+  }
+};
+
+// ../eslint-plugin-pnpm/src/configs/recommended.ts
+var config = [
+  {
+    name: "pnpm/recommended/setup",
+    plugins: {
+      pnpm: plugin2
+    }
+  },
+  {
+    name: "pnpm/recommended/package-json",
+    ignores: GLOB_EXCLUDE,
+    files: ["package.json", "**/package.json"],
+    languageOptions: {
+      parser: jsoncParser__default
+    },
+    rules: {
+      "pnpm/json-enforce-catalog": [
+        "error",
+        {
+          autofix: true,
+          allowedProtocols: ["workspace", "link", "file"],
+          defaultCatalog: "default",
+          reuseExistingCatalog: true,
+          conflicts: "overrides",
+          fields: ["dependencies", "devDependencies"]
+        }
+      ],
+      "pnpm/json-valid-catalog": "error",
+      "pnpm/json-prefer-workspace-settings": "error"
+    }
+  },
+  {
+    name: "pnpm/recommended/pnpm-workspace",
+    ignores: GLOB_EXCLUDE,
+    files: ["pnpm-workspace.yaml", "**/pnpm-workspace.yaml"],
+    languageOptions: {
+      parser: yamlParser__default
+    },
+    rules: {
+      "pnpm/yaml-no-unused-catalog-item": "error",
+      "pnpm/yaml-no-duplicate-catalog-item": "error"
+    }
+  }
+];
+var recommended_default = config;
+
+// ../eslint-plugin-pnpm/src/configs/index.ts
+var configs2 = {
+  recommended: recommended_default
+};
+
+// ../eslint-plugin-pnpm/src/index.ts
+var eslintPlugin = {
+  ...plugin2,
+  configs: configs2
+};
+var src_default = eslintPlugin;
+var rules2 = plugin2.rules;
+
+export { configs2 as configs, src_default as default, rules2 as rules };