@arcgis/eslint-config 5.2.0-next.2 → 5.2.0-next.21

package/dist/plugins/core/index.js

@@ -0,0 +1,702 @@
+import { m as makeEslintPlugin } from "../../makePlugin-GmKey29v.js";
+import { AST_NODE_TYPES, AST_TOKEN_TYPES } from "@typescript-eslint/utils";
+import { generateDifferences, showInvisibles } from "prettier-linter-helpers";
+import path, { relative, win32, posix, normalize } from "path";
+import { execSync } from "child_process";
+const plugin = makeEslintPlugin(
+  "core",
+  (rule) => `https://devtopia.esri.com/WebGIS/arcgis-web-components/tree/main/packages/support-packages/eslint-config/src/plugins/core/rules/${rule}.ts`
+);
+plugin.createRule({
+  name: "glsl-whitespace",
+  meta: {
+    docs: {
+      description: "Checks that glsl tagged template strings don't have extra whitespace.",
+      defaultLevel: "error"
+    },
+    messages: {
+      delete: "Delete `{{ deleteText }}`",
+      unexpectedDiff: "Unexpected diff operation while processing GLSL whitespace."
+    },
+    schema: [],
+    type: "layout",
+    fixable: "code"
+  },
+  defaultOptions: [],
+  create(context) {
+    if (!context.filename.endsWith(".glsl.ts")) {
+      return {};
+    }
+    return {
+      "TaggedTemplateExpression[tag.name='glsl']"(node) {
+        const quasis = node.quasi.quasis;
+        if (quasis.length > 1) {
+          processFixes(
+            context,
+            quasis[0],
+            (text) => removeLeadingBlankLines(removeMultipleBlankLines(removeTrailingWhitespace(text)))
+          );
+          for (let i = 1; i < quasis.length - 1; i++) {
+            processFixes(context, quasis[i], (text) => removeMultipleBlankLines(removeTrailingWhitespace(text)));
+          }
+          processFixes(
+            context,
+            quasis[quasis.length - 1],
+            (text) => removeTrailingBlankLines(removeMultipleBlankLines(removeTrailingWhitespace(text)))
+          );
+        } else {
+          processFixes(
+            context,
+            quasis[0],
+            (text) => removeTrailingBlankLines(removeLeadingBlankLines(removeMultipleBlankLines(removeTrailingWhitespace(text))))
+          );
+        }
+      }
+    };
+  }
+});
+function processFixes(context, node, fix) {
+  const sourceCode = context.sourceCode;
+  const text = sourceCode.getText(node);
+  const fixed = fix(text);
+  if (text === fixed) {
+    return;
+  }
+  const diffs = generateDifferences(text, fixed);
+  for (const diff of diffs) {
+    const { operation, offset } = diff;
+    const deleteText = "deleteText" in diff ? diff.deleteText : "";
+    const absOffset = node.range[0] + offset;
+    const range = [absOffset, absOffset + deleteText.length];
+    const [start, end] = range.map((index) => sourceCode.getLocFromIndex(index));
+    if (operation === generateDifferences.DELETE) {
+      context.report({
+        loc: { start, end },
+        messageId: "delete",
+        data: { deleteText: showInvisibles(deleteText) },
+        fix: (fixer) => fixer.removeRange(range)
+      });
+    } else {
+      context.report({ loc: { start, end }, messageId: "unexpectedDiff" });
+    }
+  }
+}
+function removeTrailingWhitespace(text) {
+  return text.replace(/[\t ]+(\r?\n)/gu, "$1");
+}
+function removeMultipleBlankLines(text) {
+  return text.replace(/(\r?\n\r?\n)(\r?\n)*/gu, "$1");
+}
+function removeLeadingBlankLines(text) {
+  return text.replace(/`(\r?\n)(\r?\n)*/gu, "`$1");
+}
+function removeTrailingBlankLines(text) {
+  return text.replace(/(\r?\n)(\r?\n)*([ \t]*)`$/gu, "$1$3`");
+}
+function findProjectRoot(filename) {
+  const normalized = filename.replaceAll("\\", "/");
+  let minimumIndex = Number.POSITIVE_INFINITY;
+  for (const marker of ["src/", "tests/", "test-apps/", "esri/"]) {
+    const index = normalized.indexOf(marker);
+    if (index === 0) {
+      return ".";
+    } else if (index > 0 && normalized.charCodeAt(index - 1) === slashCharCode) {
+      minimumIndex = Math.min(minimumIndex, index);
+    }
+  }
+  return minimumIndex === Number.POSITIVE_INFINITY ? void 0 : normalized.slice(0, minimumIndex);
+}
+const slashCharCode = 47;
+const isWindows = process.platform === "win32";
+const collator = new Intl.Collator("en-US");
+plugin.createRule({
+  name: "imports-format",
+  meta: {
+    docs: {
+      description: "Checks that imports are sorted and grouped",
+      defaultLevel: "error"
+    },
+    messages: {
+      importFormat: "Imports are incorrectly sorted and/or grouped",
+      missingProjectRoot: "Unable to locate project root for this file."
+    },
+    schema: [],
+    type: "layout",
+    fixable: "code"
+  },
+  defaultOptions: [],
+  create(context) {
+    const filePath = context.filename;
+    const sourceCode = context.sourceCode;
+    const basePath = findProjectRoot(filePath);
+    if (!basePath) {
+      return {
+        Program(node) {
+          context.report({ node, messageId: "missingProjectRoot" });
+        }
+      };
+    }
+    const absImportPath = path.dirname(relative(basePath, filePath));
+    const newLine = detectLineEnding(sourceCode);
+    const allStatements = [];
+    return {
+      "Program > :statement"(node) {
+        allStatements.push(node);
+      },
+      "Program:exit"() {
+        const importStatements = allStatements.filter(isImportDeclaration);
+        if (importStatements.length === 0) {
+          return;
+        }
+        const firstImport = importStatements[0];
+        const lastImport = importStatements[importStatements.length - 1];
+        const firstIndex = allStatements.indexOf(firstImport);
+        const lastIndex = allStatements.indexOf(lastImport);
+        const statements = allStatements.slice(firstIndex, lastIndex + 1);
+        const formatted = formatImports(sourceCode, statements, absImportPath, basePath, newLine);
+        const start = getAttachedCommentStart(sourceCode, firstImport);
+        const end = lastImport.range[1];
+        const original = sourceCode.text.slice(start, end);
+        const originalNormalized = normalizeLineEndings(original);
+        if (originalNormalized.trim() !== normalizeLineEndings(formatted)) {
+          const reducedFixRange = reduceFixRange(original, formatted);
+          const absRange = {
+            start: start + reducedFixRange.start,
+            end: start + reducedFixRange.end
+          };
+          context.report({
+            loc: { start: sourceCode.getLocFromIndex(absRange.start), end: sourceCode.getLocFromIndex(absRange.end) },
+            messageId: "importFormat",
+            fix: (fixer) => fixer.replaceTextRange([absRange.start, absRange.end], reducedFixRange.replacement)
+          });
+        }
+      }
+    };
+  }
+});
+function detectLineEnding(sourceCode) {
+  const hasWindowsLineEndings = sourceCode.text.includes("\r\n");
+  const hasSaneLineEndings = sourceCode.text.includes("\n");
+  if (hasWindowsLineEndings || !hasSaneLineEndings && isWindows) {
+    return "\r\n";
+  } else {
+    return "\n";
+  }
+}
+function isImportDeclaration(statement) {
+  return statement.type === AST_NODE_TYPES.ImportDeclaration;
+}
+function formatImports(sourceCode, statements, absImportPath, basePath, newLine) {
+  const imports = [];
+  const others = [];
+  for (const stmt of statements) {
+    if (isImportDeclaration(stmt)) {
+      imports.push(stmt);
+    } else {
+      others.push(stmt);
+    }
+  }
+  const grouped = groupImportsByPath(imports, absImportPath, basePath);
+  const importBlocks = grouped.map((groupedImports) => formatGroupedImports(sourceCode, groupedImports, newLine));
+  const otherBlocks = others.map((other) => sourceCode.getText(other));
+  const blocks = importBlocks.concat(otherBlocks);
+  return blocks.join(newLine + newLine);
+}
+function groupImportsByPath(imports, absImportPath, basePath) {
+  const perPath = {};
+  for (const importStatement of imports) {
+    const importPath = importStatementPathName(importStatement, absImportPath, basePath);
+    let groupedImports = perPath[importPath];
+    if (!groupedImports) {
+      groupedImports = { path: importPath, imports: [] };
+      perPath[importPath] = groupedImports;
+    }
+    groupedImports.imports.push(importStatement);
+  }
+  const groups = Object.keys(perPath);
+  groups.sort(collator.compare);
+  return groups.map((groupName) => {
+    const group = perPath[groupName];
+    group.imports.sort((a, b) => {
+      const pa = importStatementPathString(a);
+      const pb = importStatementPathString(b);
+      return collator.compare(pa, pb);
+    });
+    return group;
+  });
+}
+function importStatementPathName(importStatement, absImportPath, basePath) {
+  return importPathName(importStatementPathString(importStatement), absImportPath, basePath);
+}
+function importStatementPathString(importStatement) {
+  return importStatement.source.value;
+}
+function importPathName(importPath, absImportPath, basePath) {
+  importPath = importPath.replace(/!.*/gu, "");
+  if (!importPath.startsWith(".")) {
+    const importDir = path.dirname(importPath);
+    if (importDir === ".") {
+      return importPath;
+    }
+    return importDir;
+  }
+  importPath = path.join(absImportPath, importPath);
+  if (!path.isAbsolute(importPath)) {
+    importPath = path.join(basePath, importPath);
+  }
+  importPath = path.resolve(path.normalize(importPath));
+  return path.dirname(relative(basePath, importPath));
+}
+function formatGroupedImports(sourceCode, groupedImports, newLine) {
+  const importHeader = `// ${groupedImports.path.replace(/[\\/]/gu, ".")}`;
+  const imports = groupedImports.imports.map((importDeclaration) => sourceCode.getText(importDeclaration).trim()).join(newLine).trim();
+  return `${importHeader}${newLine}${imports}`;
+}
+function getAttachedCommentStart(sourceCode, statement) {
+  const comments = sourceCode.getCommentsBefore(statement);
+  let start = statement.range[0];
+  if (comments.length > 0) {
+    const comment = comments[comments.length - 1];
+    if (comment.type === AST_TOKEN_TYPES.Line && comment.loc.start.line === statement.loc.start.line - 1) {
+      start = comment.range[0];
+    }
+  }
+  return start;
+}
+function normalizeLineEndings(s) {
+  return s.replace(/\r\n/gu, "\n");
+}
+function reduceFixRange(original, formatted) {
+  let originalPos = 0;
+  let formattedPos = 0;
+  let originalStart = 0;
+  let formattedStart = 0;
+  const isWhitespace = (s) => s === " " || s === "\n" || s === "\r" || s === "	";
+  while (isWhitespace(original[originalPos])) {
+    ++originalPos;
+  }
+  while (true) {
+    if (original[originalPos] === "\r") {
+      ++originalPos;
+    }
+    if (formatted[formattedPos] === "\r") {
+      ++formattedPos;
+    }
+    if (original[originalPos] !== formatted[originalPos]) {
+      break;
+    }
+    if (original[originalPos] === "\n") {
+      originalStart = originalPos + 1;
+      formattedStart = formattedPos + 1;
+    }
+    ++originalPos;
+    ++formattedPos;
+  }
+  originalPos = original.length - 1;
+  formattedPos = formatted.length - 1;
+  let originalEnd = originalPos;
+  let formattedEnd = formattedPos;
+  while (isWhitespace(original[originalPos])) {
+    --originalPos;
+  }
+  while (true) {
+    if (original[originalPos] === "\r") {
+      --originalPos;
+    }
+    if (formatted[formattedPos] === "\r") {
+      --formattedPos;
+    }
+    if (original[originalPos] === "\n") {
+      originalEnd = originalPos;
+      formattedEnd = formattedPos;
+    }
+    if (original[originalPos] !== formatted[formattedPos] || originalPos === originalStart || formattedPos === formattedStart) {
+      return {
+        start: originalStart,
+        end: originalEnd + 1,
+        replacement: formatted.slice(formattedStart, formattedEnd + 1)
+      };
+    }
+    --originalPos;
+    --formattedPos;
+  }
+}
+plugin.createRule({
+  name: "no-duplicate-import-comments",
+  meta: {
+    docs: {
+      description: "Checks for duplicate comments before the first import declaration.",
+      defaultLevel: "error"
+    },
+    messages: { duplicate: "Delete duplicate comment" },
+    schema: [],
+    type: "problem",
+    fixable: "code"
+  },
+  defaultOptions: [],
+  create(context) {
+    const sourceCode = context.sourceCode;
+    let firstImport;
+    return {
+      ImportDeclaration(node) {
+        if (firstImport) {
+          return;
+        }
+        firstImport = node;
+        const comments = sourceCode.getCommentsBefore(firstImport);
+        if (comments.length > 1) {
+          let previousComment = comments[0];
+          for (let i = 1; i < comments.length; i++) {
+            const comment = comments[i];
+            if (previousComment.value === comment.value) {
+              context.report({
+                node: previousComment,
+                messageId: "duplicate",
+                fix: (fixer) => fixer.remove(previousComment)
+              });
+            }
+            previousComment = comment;
+          }
+        }
+      }
+    };
+  }
+});
+const emptyTodoTagRe = /^[\s*]*@todo\s*$/mu;
+plugin.createRule({
+  name: "no-empty-jsdoc-todo",
+  meta: {
+    docs: {
+      description: "Checks for `todo` JSDoc tags with missing descriptions.",
+      defaultLevel: "error"
+    },
+    messages: { empty: "JSDoc `todo` tag description required" },
+    schema: [],
+    type: "problem"
+  },
+  defaultOptions: [],
+  create(context) {
+    const allComments = context.sourceCode.getAllComments();
+    return {
+      Program() {
+        for (const comment of allComments) {
+          if (comment.type === AST_TOKEN_TYPES.Block && comment.value.startsWith("*") && emptyTodoTagRe.test(comment.value)) {
+            context.report({ loc: comment.loc, messageId: "empty" });
+          }
+        }
+      }
+    };
+  }
+});
+plugin.createRule({
+  name: "no-invalid-declared-class",
+  meta: {
+    docs: {
+      description: "Enforces the declared class name passed to the @subclass() decorator",
+      defaultLevel: "error"
+    },
+    messages: {
+      invalidPath: "Invalid path passed to @subclass(). It should be a string literal matching the file path, without the extension and with path separators replaced with `.`"
+    },
+    fixable: "code",
+    schema: [],
+    type: "problem"
+  },
+  defaultOptions: [],
+  create(context) {
+    const entries = /* @__PURE__ */ new Set();
+    return {
+      "ClassDeclaration"(node) {
+        for (const { expression } of node.decorators) {
+          if (expression.type !== AST_NODE_TYPES.CallExpression) {
+            continue;
+          }
+          const callee = expression.callee;
+          if (callee.type !== AST_NODE_TYPES.Identifier || callee.name !== "subclass") {
+            continue;
+          }
+          const arg = expression.arguments.at(0);
+          if (arg == null) {
+            continue;
+          }
+          if (arg.type !== AST_NODE_TYPES.Literal || typeof arg.value !== "string") {
+            context.report({ node: arg, messageId: "invalidPath" });
+            return;
+          }
+          entries.add({ arg, className: node.id?.name ?? "" });
+        }
+      },
+      "Program:exit"() {
+        const hasMultipleClasses = entries.size > 1;
+        for (const { arg, className } of entries) {
+          const relativePath = getDeclaredClass(context.filename);
+          const actual = arg.value;
+          let expected = relativePath;
+          if (hasMultipleClasses && !relativePath?.endsWith(`.${className}`)) {
+            expected = `${relativePath}.${className}`;
+          }
+          if (expected != null && actual !== expected) {
+            context.report({
+              node: arg,
+              messageId: "invalidPath",
+              fix: (fixer) => fixer.replaceText(arg, `"${expected}"`)
+            });
+          }
+        }
+      }
+    };
+  }
+});
+function getDeclaredClass(filename) {
+  const root = findProjectRoot(filename);
+  if (!root) {
+    return;
+  }
+  const relativePath = relative(root, filename).replaceAll(win32.sep, ".").replaceAll(posix.sep, ".").replace(/\.[^/.]+$/u, "");
+  return relativePath;
+}
+const tsRe = /\.tsx?$/u;
+let gitIndexFiles;
+function getGitIndexFiles(cwd) {
+  if (gitIndexFiles) {
+    return gitIndexFiles;
+  }
+  gitIndexFiles = /* @__PURE__ */ new Set();
+  const gitStdOut = execSync("git ls-files", { cwd, encoding: "utf-8" });
+  for (let file of gitStdOut.split("\n")) {
+    file = file.trim();
+    if (file.endsWith(".js") || file.endsWith(".d.ts")) {
+      gitIndexFiles.add(normalize(file));
+    }
+  }
+  return gitIndexFiles;
+}
+plugin.createRule({
+  name: "no-redundant-checked-in-files",
+  meta: {
+    docs: {
+      description: "Checks that files redundant to TypeScript implementation files are not checked in.",
+      defaultLevel: "error"
+    },
+    messages: {
+      js: "Redundant JavaScript file detected. Please `git rm -f {{file}}`",
+      dts: "Redundant declaration file detected. Please `git rm -f {{file}}`",
+      missingProjectRoot: "Unable to locate project root for this file."
+    },
+    schema: [],
+    type: "problem"
+  },
+  defaultOptions: [],
+  create(context) {
+    let filePath = context.filename;
+    return {
+      Program(node) {
+        if (!filePath.endsWith(".d.ts") && tsRe.test(filePath)) {
+          const projectRoot = findProjectRoot(filePath);
+          if (!projectRoot) {
+            context.report({ node, messageId: "missingProjectRoot" });
+            return;
+          }
+          const gitIndexFiles2 = getGitIndexFiles(projectRoot);
+          if (!gitIndexFiles2) {
+            return;
+          }
+          filePath = relative(projectRoot, filePath);
+          const jsFilename = filePath.replace(tsRe, ".js");
+          if (gitIndexFiles2.has(jsFilename)) {
+            context.report({ node, messageId: "js", data: { file: jsFilename } });
+          }
+          const dtsFilename = filePath.replace(tsRe, ".d.ts");
+          if (gitIndexFiles2.has(dtsFilename)) {
+            context.report({ node, messageId: "dts", data: { file: dtsFilename } });
+          }
+        }
+      }
+    };
+  }
+});
+plugin.createRule({
+  name: "prefer-relative-imports",
+  meta: {
+    docs: {
+      description: "Checks that whenever possible import and export paths are relative instead of absolute.",
+      defaultLevel: "error"
+    },
+    messages: {
+      importFormat: 'Prefer relative ("{{relPath}}") over absolute path',
+      missingProjectRoot: "Unable to locate project root for this file."
+    },
+    schema: [],
+    type: "problem",
+    fixable: "code"
+  },
+  defaultOptions: [],
+  create(context) {
+    const filePath = context.filename;
+    const basePath = findProjectRoot(filePath);
+    if (!basePath) {
+      return {
+        Program(node) {
+          context.report({ node, messageId: "missingProjectRoot" });
+        }
+      };
+    }
+    const absImportPath = path.dirname(relative(basePath, filePath));
+    const importRoot = pathRoot(absImportPath);
+    return {
+      "ExportAllDeclaration[source.type='Literal']"(node) {
+        verifyRelativeImport(context, node.source, absImportPath, basePath, importRoot);
+      },
+      "ExportNamedDeclaration[source.type='Literal']"(node) {
+        verifyRelativeImport(context, node.source, absImportPath, basePath, importRoot);
+      },
+      "ImportDeclaration"(node) {
+        verifyRelativeImport(context, node.source, absImportPath, basePath, importRoot);
+      },
+      "ImportExpression[source.type='Literal']"(node) {
+        if (node.source.type === AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
+          verifyRelativeImport(context, node.source, absImportPath, basePath, importRoot);
+        }
+      }
+    };
+  }
+});
+function pathRoot(p) {
+  const dirName = path.dirname(p);
+  return dirName === "." ? p : pathRoot(dirName);
+}
+function verifyRelativeImport(context, node, absImportPath, basePath, importRoot) {
+  const modulePath = node.value;
+  if (modulePath.startsWith(".")) {
+    return;
+  }
+  if (pathRoot(modulePath) === importRoot) {
+    let relPath = path.relative(path.join(basePath, absImportPath), path.join(basePath, modulePath));
+    if (!relPath.startsWith(".")) {
+      relPath = `./${relPath}`;
+    }
+    if (isWindows) {
+      relPath = relPath.replaceAll(win32.sep, posix.sep);
+    }
+    context.report({
+      node,
+      messageId: "importFormat",
+      data: { relPath },
+      fix: (fixer) => fixer.replaceTextRange([node.range[0] + 1, node.range[1] - 1], relPath)
+    });
+  }
+}
+plugin.createRule({
+  name: "require-calcite-import",
+  meta: {
+    docs: {
+      description: "Checks that the corresponding calcite component import exists for each calcite component tag used.  It also checks that there are no extra unnecessary imports.",
+      defaultLevel: "error"
+    },
+    messages: {
+      missingImport: 'Import missing: import("@esri/calcite-components/dist/components/{{tag}}")',
+      needlessImport: "Import is unnecessary since no matching calcite component tag found"
+    },
+    schema: [],
+    type: "problem"
+  },
+  defaultOptions: [],
+  create(context) {
+    const tags = [];
+    const imports = [];
+    return {
+      "JSXOpeningElement[name.name=/^calcite-/]"(node) {
+        if (node.name.type === AST_NODE_TYPES.JSXIdentifier) {
+          const name = node.name.name;
+          tags.push([name, node]);
+        }
+      },
+      "ImportExpression[source.type='Literal']"(node) {
+        if (node.source.type === AST_NODE_TYPES.Literal && typeof node.source.value === "string") {
+          const importString = node.source.value;
+          if (importString.startsWith("@esri/calcite-components/")) {
+            const importModule = importString.slice(importString.lastIndexOf("/") + 1);
+            imports.push([importModule, node]);
+          }
+        }
+      },
+      "Program:exit"() {
+        for (const [tag, node] of tags) {
+          if (!imports.some(([importModule]) => tag === importModule)) {
+            context.report({ node, messageId: "missingImport", data: { tag } });
+          }
+        }
+        for (const [importModule, node] of imports) {
+          if (!tags.some(([tag]) => importModule === tag)) {
+            context.report({ node, messageId: "needlessImport" });
+          }
+        }
+      }
+    };
+  }
+});
+plugin.createRule({
+  name: "spec-suite-filename",
+  meta: {
+    docs: {
+      description: "Enforce filenames to be part of spec (test) top-level suites.",
+      defaultLevel: "error"
+    },
+    messages: {
+      name: "Suite name must be the name of the spec file",
+      duplicateSuite: "There can only be one top level suite",
+      unresolved: "Could not determine expected suite name for this spec file"
+    },
+    schema: [],
+    type: "problem",
+    fixable: "code"
+  },
+  defaultOptions: [],
+  create(context) {
+    const filename = context.filename;
+    if (!filename.endsWith(".spec.ts")) {
+      return {};
+    }
+    const toplevelSuiteName = getToplevelSuiteName(filename);
+    if (!toplevelSuiteName) {
+      return {
+        Program(node) {
+          context.report({ node, messageId: "unresolved" });
+        }
+      };
+    }
+    let numToplevel = 0;
+    return {
+      "Program > ExpressionStatement > CallExpression[callee.name='suite']"(node) {
+        ++numToplevel;
+        if (numToplevel > 1) {
+          context.report({ node, messageId: "duplicateSuite" });
+          return;
+        }
+        const first = node.arguments[0];
+        if (!first) {
+          return;
+        }
+        if (first.type !== AST_NODE_TYPES.Literal || typeof first.value !== "string" || first.value !== toplevelSuiteName) {
+          context.report({
+            node: first,
+            messageId: "name",
+            fix: (fixer) => fixer.replaceText(first, `"${toplevelSuiteName}"`)
+          });
+        }
+      }
+    };
+  }
+});
+function getToplevelSuiteName(filename) {
+  const root = findProjectRoot(filename);
+  if (!root) {
+    return;
+  }
+  const relativePath = relative(root, filename).replaceAll(win32.sep, posix.sep);
+  return relativePath.replace(/^tests\/(.*)\.spec\.ts/u, "$1");
+}
+const corePlugin = plugin.finalize();
+export {
+  corePlugin
+};

package/dist/plugins/lumina/index.d.ts

@@ -1,5 +1,4 @@
-export declare const luminaPlugin: import("typescript-eslint").FlatConfig.Plugin & {
-    configs: {
-        recommended: import("typescript-eslint").FlatConfig.Config;
-    };
-};
+import type { EslintPlugin } from "../utils/makePlugin.js";
+
+/** Plugin that provides rules that are widely applicable for Lumina projects. */
+export const luminaPlugin: EslintPlugin;