@arcgis/eslint-config 5.1.0-next.6 → 5.1.0-next.60

package/dist/config/index.js

@@ -213,6 +213,18 @@ const defaultConfig = [
       "@typescript-eslint/restrict-plus-operands": ["warn", { allowNumberAndString: true }],
       // We often actually have control characters in our regexes
       "no-control-regex": "off",
+      "@typescript-eslint/no-restricted-imports": [
+        "error",
+        {
+          paths: [
+            {
+              name: "commander",
+              importNames: ["Command"],
+              message: "Import from @commander-js/extra-typings instead."
+            }
+          ]
+        }
+      ],
       // Functions that deal with JSON.stringify/localStorage may have a type
       // parameter as a more readable alternative to a type assertion.
       // Also, this rule is quite complicated/expensive.

package/dist/estree-kBWxXj93.js

@@ -0,0 +1,161 @@
+import { ESLintUtils, AST_NODE_TYPES } from "@typescript-eslint/utils";
+const version = "5.1.0-next.60";
+const packageJson = {
+  version
+};
+function makeEslintPlugin(pluginName, urlCreator) {
+  const rules = [];
+  const creator = ESLintUtils.RuleCreator(urlCreator);
+  return {
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    createRule(rule) {
+      const { meta, name, ...rest } = rule;
+      const docs = { ...meta.docs, name };
+      const ruleModule = creator({ ...rest, meta: { ...meta, docs }, name });
+      rules.push(ruleModule);
+      return ruleModule;
+    },
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    finalize() {
+      const config = {
+        rules: Object.fromEntries(
+          rules.map((rule) => [`${pluginName}/${rule.meta.docs.name}`, rule.meta.docs.defaultLevel])
+        )
+      };
+      const plugin = {
+        meta: { name: `@arcgis/eslint-plugin-${pluginName}`, version: packageJson.version },
+        configs: {
+          recommended: config
+        },
+        rules: Object.fromEntries(rules.map((rule) => [rule.meta.docs.name, rule]))
+      };
+      config.plugins = {
+        [pluginName]: plugin
+      };
+      return plugin;
+    }
+  };
+}
+const unwrapExpression = (expression) => expression.type === AST_NODE_TYPES.TSAsExpression || expression.type === AST_NODE_TYPES.TSNonNullExpression || expression.type === AST_NODE_TYPES.TSSatisfiesExpression ? unwrapExpression(expression.expression) : expression;
+const luminaEntrypointName = "@arcgis/lumina";
+const luminaTestEntrypointName = "@arcgis/lumina-compiler/testing";
+const luminaJsxExportName = "h";
+function checkForLuminaJsx() {
+  const ImportDeclaration = (node) => {
+    if (node.source.value !== luminaEntrypointName) {
+      return;
+    }
+    for (const specifier of node.specifiers) {
+      if (specifier.type === AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES.Identifier && specifier.imported.name === luminaJsxExportName || specifier.imported.type === AST_NODE_TYPES.Literal && specifier.imported.value === luminaJsxExportName)) {
+        withProperty.isLuminaJsx = true;
+        return;
+      }
+    }
+  };
+  const withProperty = ImportDeclaration;
+  return withProperty;
+}
+function hasDecorator(node, decoratorName) {
+  return node.decorators.some(
+    (decorator) => decorator.expression.type === AST_NODE_TYPES.CallExpression && decorator.expression.callee.type === AST_NODE_TYPES.Identifier && decorator.expression.callee.name === decoratorName
+  ) ?? false;
+}
+function extractDeclareElementsInterface(node) {
+  return node.kind === "global" ? node.body.body.find(
+    (node2) => node2.type === AST_NODE_TYPES.TSInterfaceDeclaration && node2.id.name === "DeclareElements"
+  ) : void 0;
+}
+function getComponentDeclaration(node) {
+  for (const member of node.body.body) {
+    if (member.type !== AST_NODE_TYPES.TSPropertySignature) {
+      continue;
+    }
+    const type = member.typeAnnotation?.typeAnnotation;
+    if (type?.type !== AST_NODE_TYPES.TSTypeReference || type.typeName.type !== AST_NODE_TYPES.Identifier) {
+      continue;
+    }
+    if (member.key.type !== AST_NODE_TYPES.Literal) {
+      continue;
+    }
+    return member;
+  }
+  return;
+}
+const sourceCodeDeclaresComponent = (sourceCode) => sourceCode.text.includes("interface DeclareElements");
+function isCreateEvent(node) {
+  return node.value?.type === AST_NODE_TYPES.CallExpression && node.value.callee.type === AST_NODE_TYPES.Identifier && node.value.callee.name === "createEvent" && !node.static;
+}
+const getProperty = (properties, name) => properties?.find(
+  (option) => option.type === AST_NODE_TYPES.Property && option.key.type === AST_NODE_TYPES.Identifier && option.key.name === name
+)?.value;
+function isGetterWithoutSetter(node) {
+  const isGetter = node.type === AST_NODE_TYPES.MethodDefinition && node.kind === "get";
+  if (!isGetter) {
+    return false;
+  }
+  const index = node.parent.body.indexOf(node);
+  const previousNode = node.parent.body.at(index - 1);
+  const nextNode = node.parent.body.at(index + 1);
+  const name = getName(node);
+  if (name === void 0) {
+    return false;
+  }
+  const previousIsSetter = previousNode?.type === AST_NODE_TYPES.MethodDefinition && previousNode.kind === "set" && getName(previousNode) === name;
+  if (previousIsSetter) {
+    return false;
+  }
+  const nextIsSetter = nextNode?.type === AST_NODE_TYPES.MethodDefinition && nextNode.kind === "set" && getName(nextNode) === name;
+  return !nextIsSetter;
+}
+function getName(node) {
+  if (node.key.type === AST_NODE_TYPES.Identifier) {
+    return node.key.name;
+  } else if (node.key.type === AST_NODE_TYPES.Literal && typeof node.key.value === "string") {
+    return node.key.value;
+  } else {
+    return void 0;
+  }
+}
+function parsePropertyDecorator(decorator) {
+  const isPropertyDecorator = decorator.expression.type === AST_NODE_TYPES.CallExpression && decorator.expression.callee.type === AST_NODE_TYPES.Identifier && decorator.expression.callee.name === "property";
+  if (!isPropertyDecorator) {
+    return;
+  }
+  const callExpression = decorator?.expression.type === AST_NODE_TYPES.CallExpression ? decorator.expression : void 0;
+  if (callExpression === void 0) {
+    return;
+  }
+  const options = callExpression.arguments[0]?.type === AST_NODE_TYPES.ObjectExpression ? callExpression.arguments[0] : void 0;
+  const properties = options?.properties;
+  return {
+    callExpression,
+    options,
+    properties
+  };
+}
+function isBindThisCallee(callee) {
+  return callee.type === AST_NODE_TYPES.MemberExpression && // expression.identifier(this)
+  callee.property.type === AST_NODE_TYPES.Identifier && // expression.bind(this)
+  callee.property.name === "bind" && // expression.expression.bind(this)
+  callee.object.type === AST_NODE_TYPES.MemberExpression && // expression.identifier.bind(this)
+  callee.object.property.type === AST_NODE_TYPES.Identifier && // this.identifier.bind(this)
+  callee.object.object.type === AST_NODE_TYPES.ThisExpression;
+}
+export {
+  luminaEntrypointName as a,
+  luminaTestEntrypointName as b,
+  getProperty as c,
+  isCreateEvent as d,
+  extractDeclareElementsInterface as e,
+  getName as f,
+  getComponentDeclaration as g,
+  hasDecorator as h,
+  isGetterWithoutSetter as i,
+  checkForLuminaJsx as j,
+  isBindThisCallee as k,
+  luminaJsxExportName as l,
+  makeEslintPlugin as m,
+  parsePropertyDecorator as p,
+  sourceCodeDeclaresComponent as s,
+  unwrapExpression as u
+};

package/dist/plugins/lumina/index.js

@@ -1,4 +1,4 @@
-import { m as makeEslintPlugin } from "../../makePlugin-C3S0T31x.js";
+import { m as makeEslintPlugin, l as luminaJsxExportName, a as luminaEntrypointName, b as luminaTestEntrypointName, s as sourceCodeDeclaresComponent, p as parsePropertyDecorator, c as getProperty, i as isGetterWithoutSetter, e as extractDeclareElementsInterface, d as isCreateEvent, h as hasDecorator, f as getName, j as checkForLuminaJsx, k as isBindThisCallee, g as getComponentDeclaration, u as unwrapExpression } from "../../estree-kBWxXj93.js";
 import { AST_NODE_TYPES, ESLintUtils, AST_TOKEN_TYPES } from "@typescript-eslint/utils";
 import ts from "typescript";
 import { camelToKebab } from "@arcgis/toolkit/string";
@@ -6,105 +6,17 @@ const plugin = makeEslintPlugin(
   "lumina",
   (rule) => `https://devtopia.esri.com/WebGIS/arcgis-web-components/tree/main/packages/support-packages/eslint-config/src/plugins/lumina/rules/${rule}.ts`
 );
-const unwrapExpression = (expression) => expression.type === AST_NODE_TYPES.TSAsExpression || expression.type === AST_NODE_TYPES.TSNonNullExpression || expression.type === AST_NODE_TYPES.TSSatisfiesExpression ? unwrapExpression(expression.expression) : expression;
-const luminaEntrypointName = "@arcgis/lumina";
-const luminaTestEntrypointName = "@arcgis/lumina-compiler/testing";
-const luminaJsxExportName = "h";
-function checkForLuminaJsx() {
-  const ImportDeclaration = (node) => {
-    if (node.source.value !== luminaEntrypointName) {
-      return;
-    }
-    for (const specifier of node.specifiers) {
-      if (specifier.type === AST_NODE_TYPES.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES.Identifier && specifier.imported.name === luminaJsxExportName || specifier.imported.type === AST_NODE_TYPES.Literal && specifier.imported.value === luminaJsxExportName)) {
-        withProperty.isLuminaJsx = true;
-        return;
-      }
-    }
-  };
-  const withProperty = ImportDeclaration;
-  return withProperty;
-}
-function hasDecorator(node, decoratorName) {
-  return node.decorators.some(
-    (decorator) => decorator.expression.type === AST_NODE_TYPES.CallExpression && decorator.expression.callee.type === AST_NODE_TYPES.Identifier && decorator.expression.callee.name === decoratorName
-  ) ?? false;
-}
-function extractDeclareElementsInterface(node) {
-  return node.kind === "global" ? node.body.body.find(
-    (node2) => node2.type === AST_NODE_TYPES.TSInterfaceDeclaration && node2.id.name === "DeclareElements"
-  ) : void 0;
-}
-function isCreateEvent(node) {
-  return node.value?.type === AST_NODE_TYPES.CallExpression && node.value.callee.type === AST_NODE_TYPES.Identifier && node.value.callee.name === "createEvent" && !node.static;
-}
-const getProperty = (properties, name) => properties?.find(
-  (option) => option.type === AST_NODE_TYPES.Property && option.key.type === AST_NODE_TYPES.Identifier && option.key.name === name
-)?.value;
-function isGetterWithoutSetter(node) {
-  const isGetter = node.type === AST_NODE_TYPES.MethodDefinition && node.kind === "get";
-  if (!isGetter) {
-    return false;
-  }
-  const index = node.parent.body.indexOf(node);
-  const previousNode = node.parent.body.at(index - 1);
-  const nextNode = node.parent.body.at(index + 1);
-  const name = getName(node);
-  if (name === void 0) {
-    return false;
-  }
-  const previousIsSetter = previousNode?.type === AST_NODE_TYPES.MethodDefinition && previousNode.kind === "set" && getName(previousNode) === name;
-  if (previousIsSetter) {
-    return false;
-  }
-  const nextIsSetter = nextNode?.type === AST_NODE_TYPES.MethodDefinition && nextNode.kind === "set" && getName(nextNode) === name;
-  return !nextIsSetter;
-}
-function getName(node) {
-  if (node.key.type === AST_NODE_TYPES.Identifier) {
-    return node.key.name;
-  } else if (node.key.type === AST_NODE_TYPES.Literal && typeof node.key.value === "string") {
-    return node.key.value;
-  } else {
-    return void 0;
-  }
-}
-function parsePropertyDecorator(decorator) {
-  const isPropertyDecorator = decorator.expression.type === AST_NODE_TYPES.CallExpression && decorator.expression.callee.type === AST_NODE_TYPES.Identifier && decorator.expression.callee.name === "property";
-  if (!isPropertyDecorator) {
-    return;
-  }
-  const callExpression = decorator?.expression.type === AST_NODE_TYPES.CallExpression ? decorator.expression : void 0;
-  if (callExpression === void 0) {
-    return;
-  }
-  const options = callExpression.arguments[0]?.type === AST_NODE_TYPES.ObjectExpression ? callExpression.arguments[0] : void 0;
-  const properties = options?.properties;
-  return {
-    callExpression,
-    options,
-    properties
-  };
-}
-function isBindThisCallee(callee) {
-  return callee.type === AST_NODE_TYPES.MemberExpression && // expression.identifier(this)
-  callee.property.type === AST_NODE_TYPES.Identifier && // expression.bind(this)
-  callee.property.name === "bind" && // expression.expression.bind(this)
-  callee.object.type === AST_NODE_TYPES.MemberExpression && // expression.identifier.bind(this)
-  callee.object.property.type === AST_NODE_TYPES.Identifier && // this.identifier.bind(this)
-  callee.object.object.type === AST_NODE_TYPES.ThisExpression;
-}
 const importDeclaration = `import { ${luminaJsxExportName} } from "${luminaEntrypointName}";`;
-const description$k = `To use Lumina's JSX, you need to ${importDeclaration}`;
+const description$l = `To use Lumina's JSX, you need to ${importDeclaration}`;
 plugin.createRule({
   name: "add-missing-jsx-import",
   meta: {
     docs: {
-      description: description$k,
+      description: description$l,
       defaultLevel: "error"
     },
     messages: {
-      addMissingJsxImport: description$k
+      addMissingJsxImport: description$l
     },
     type: "problem",
     schema: [],
@@ -161,12 +73,12 @@ plugin.createRule({
     };
   }
 });
-const description$j = "Auto add { type: Boolean } or { type: Number } where necessary";
+const description$k = "Auto add { type: Boolean } or { type: Number } where necessary";
 plugin.createRule({
   name: "auto-add-type",
   meta: {
     docs: {
-      description: description$j,
+      description: description$k,
       defaultLevel: "warn"
     },
     messages: {
@@ -184,6 +96,9 @@ More information: https://devtopia.esri.com/WebGIS/arcgis-web-components/issues/
   },
   defaultOptions: [],
   create(context) {
+    if (!sourceCodeDeclaresComponent(context.sourceCode)) {
+      return {};
+    }
     const services = ESLintUtils.getParserServices(context);
     return {
       Decorator(decorator) {
@@ -362,6 +277,9 @@ plugin.createRule({
     type: "problem"
   },
   create(context) {
+    if (!sourceCodeDeclaresComponent(context.sourceCode)) {
+      return {};
+    }
     const bannedEventToMessageLookup = /* @__PURE__ */ new Map();
     context.options.forEach((option) => {
       const event = typeof option === "string" ? option : option.event;
@@ -382,32 +300,24 @@ plugin.createRule({
         });
       }
     }
-    const luminaJsxCheck = checkForLuminaJsx();
     return {
-      "ImportDeclaration": luminaJsxCheck,
       "CallExpression:matches([callee.property.name=addEventListener], [callee.property.name=removeEventListener]), CallExpression[callee.object.type=ThisExpression][callee.property.name=listen]"(node) {
-        if (!luminaJsxCheck.isLuminaJsx) {
-          return;
-        }
         const eventName = node.arguments[0].value;
         checkEvent(node, eventName);
       },
       "CallExpression[callee.object.type=ThisExpression][callee.property.name=listenOn]"(node) {
-        if (!luminaJsxCheck.isLuminaJsx) {
-          return;
-        }
         const eventName = node.arguments[1].value;
         checkEvent(node, eventName);
       }
     };
   }
 });
-const description$i = `Lumina component must be declared in a TSX file with a matching folder name located inside of src/components folder.`;
+const description$j = `Lumina component must be declared in a TSX file with a matching folder name located inside of src/components folder.`;
 plugin.createRule({
   name: "component-placement-rules",
   meta: {
     docs: {
-      description: description$i,
+      description: description$j,
       defaultLevel: "error"
     },
     messages: {
@@ -446,7 +356,7 @@ plugin.createRule({
     };
   }
 });
-const description$h = `Enforce consistent event naming.`;
+const description$i = `Enforce consistent event naming.`;
 const defaultOptions$1 = [
   {
     eventNamespaces: ["arcgis"],
@@ -457,7 +367,7 @@ plugin.createRule({
   name: "consistent-event-naming",
   meta: {
     docs: {
-      description: description$h,
+      description: description$i,
       defaultLevel: "warn"
     },
     messages: {
@@ -558,12 +468,12 @@ Discussion: https://devtopia.esri.com/WebGIS/arcgis-web-components/discussions/3
   }
 });
 const capitalAfterLower = /(?<=[a-z\d])[A-Z]/u;
-const description$g = `Enforce consistent usage of ? for marking property as nullable, rather than |null, |undefined or |Nil.`;
+const description$h = `Enforce consistent usage of ? for marking property as nullable, rather than |null, |undefined or |Nil.`;
 plugin.createRule({
   name: "consistent-nullability",
   meta: {
     docs: {
-      description: description$g,
+      description: description$h,
       // TODO: enable this by default
       defaultLevel: "off"
     },
@@ -639,12 +549,12 @@ plugin.createRule({
     };
   }
 });
-const description$f = `Enforce that @property(), @method() and createEvent() members are used in the correct context.`;
+const description$g = `Enforce that @property(), @method() and createEvent() members are used in the correct context.`;
 plugin.createRule({
   name: "decorators-context",
   meta: {
     docs: {
-      description: description$f,
+      description: description$g,
       defaultLevel: "error"
     },
     messages: {
@@ -662,6 +572,9 @@ If you wish to hide this member from public documentation, use @private or @prot
   },
   defaultOptions: [],
   create(context) {
+    if (!sourceCodeDeclaresComponent(context.sourceCode)) {
+      return {};
+    }
     return {
       PropertyDefinition(node) {
         const hasPropertyDecorator = hasDecorator(node, "property");
@@ -738,7 +651,7 @@ function isLuminaJsxType(type) {
 }
 const hasTypeFlag = (type, flag) => type.flags & flag ? true : (type.flags & ts.TypeFlags.Union) !== 0 && type.types.some((t) => hasTypeFlag(t, flag));
 const literalTypeFlag = ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike | ts.TypeFlags.BooleanLike;
-const description$e = `Need to add explicit type annotation: {{ setterType }}
+const description$f = `Need to add explicit type annotation: {{ setterType }}
 
 Explanation:
 Lumina automatically creates an attribute for a property if property type includes a literal type (string|number|boolean).
@@ -749,11 +662,11 @@ plugin.createRule({
   name: "explicit-setter-type",
   meta: {
     docs: {
-      description: description$e,
+      description: description$f,
       defaultLevel: "error"
     },
     messages: {
-      explicitSetterType: description$e,
+      explicitSetterType: description$f,
       addExplicitSetterType: `Add {{ setterType }} type annotation`
     },
     type: "problem",
@@ -1299,16 +1212,16 @@ function isCreateElementComponent(node) {
   }
   return false;
 }
-const description$d = `Use @internal or @private JSDoc tag over @ignore. See https://webgis.esri.com/references/lumina/documenting-components#excluding-api-from-public-documentation`;
+const description$e = `Use @internal or @private JSDoc tag over @ignore. See https://webgis.esri.com/references/lumina/documenting-components#excluding-api-from-public-documentation`;
 plugin.createRule({
   name: "no-ignore-jsdoc-tag",
   meta: {
     docs: {
-      description: description$d,
+      description: description$e,
       defaultLevel: "error"
     },
     messages: {
-      noIgnoreJsDocTag: description$d
+      noIgnoreJsDocTag: description$e
     },
     type: "problem",
     schema: []
@@ -1337,12 +1250,12 @@ plugin.createRule({
   }
 });
 const reIgnore = /\* @ignore/gu;
-const description$c = `Detect incorrect usage of dynamic JSX tag name`;
+const description$d = `Detect incorrect usage of dynamic JSX tag name`;
 plugin.createRule({
   name: "no-incorrect-dynamic-tag-name",
   meta: {
     docs: {
-      description: description$c,
+      description: description$d,
       defaultLevel: "error"
     },
     messages: {
@@ -1385,18 +1298,18 @@ plugin.createRule({
     };
   }
 });
-const description$b = `If inline arrow function is passed to ref, it will be called again on each render.
+const description$c = `If inline arrow function is passed to ref, it will be called again on each render.
 
 If this is not desirable, see alternatives: https://webgis.esri.com/references/lumina/jsx#refs`;
 plugin.createRule({
   name: "no-inline-arrow-in-ref",
   meta: {
     docs: {
-      description: description$b,
+      description: description$c,
       defaultLevel: "warn"
     },
     messages: {
-      errorInlineArrow: description$b
+      errorInlineArrow: description$c
     },
     type: "problem",
     schema: []
@@ -1422,6 +1335,44 @@ plugin.createRule({
     };
   }
 });
+const description$b = `Put @internal and @private on their own JSDoc line, not inline.`;
+plugin.createRule({
+  name: "no-inline-exposure-jsdoc-tag",
+  meta: {
+    docs: {
+      description: description$b,
+      defaultLevel: "error"
+    },
+    messages: {
+      inlineExposure: description$b
+    },
+    type: "problem",
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      "Program:exit"() {
+        const source = context.sourceCode.text;
+        for (const match of source.matchAll(/@(?:internal|private)\b/gu)) {
+          const idx = match.index;
+          const lineStart = source.lastIndexOf("\n", idx - 1) + 1;
+          const before = source.slice(lineStart, idx).trim();
+          if (before === "*" || before === "/**") {
+            continue;
+          }
+          context.report({
+            messageId: "inlineExposure",
+            loc: {
+              start: context.sourceCode.getLocFromIndex(idx - 1),
+              end: context.sourceCode.getLocFromIndex(idx + match[0].length)
+            }
+          });
+        }
+      }
+    };
+  }
+});
 const description$a = `directives={} prop value must be an array literal. Documentation: https://webgis.esri.com/references/lumina/jsx#lit-directives`;
 plugin.createRule({
   name: "no-invalid-directives-prop",
@@ -1575,28 +1526,20 @@ plugin.createRule({
   },
   defaultOptions: [],
   create(context) {
-    const declaredComponents = /* @__PURE__ */ new Set();
-    const hasLuminaDeclarations = context.sourceCode.text.includes("interface DeclareElements");
+    if (!sourceCodeDeclaresComponent(context.sourceCode)) {
+      return {};
+    }
+    let className;
     return {
       TSModuleDeclaration(node) {
         const luminaDeclarationInterface = extractDeclareElementsInterface(node);
         if (luminaDeclarationInterface === void 0) {
           return;
         }
-        luminaDeclarationInterface.body.body.forEach((member) => {
-          if (member.type !== AST_NODE_TYPES.TSPropertySignature || member.computed) {
-            return;
-          }
-          const type = member.typeAnnotation?.typeAnnotation;
-          if (type?.type !== AST_NODE_TYPES.TSTypeReference || type.typeName.type !== AST_NODE_TYPES.Identifier) {
-            return;
-          }
-          const className = type.typeName.name;
-          declaredComponents.add(className);
-        });
+        className = getComponentDeclaration(luminaDeclarationInterface)?.typeAnnotation?.typeAnnotation.typeName.name;
       },
       ExportNamedDeclaration(node) {
-        if (!hasLuminaDeclarations && declaredComponents.size === 0) {
+        if (className === void 0) {
           return;
         }
         if (node.exportKind === "type") {
@@ -1620,7 +1563,7 @@ plugin.createRule({
         ) {
           return;
         } else if (node.declaration?.type === AST_NODE_TYPES.ClassDeclaration) {
-          const isComponent = declaredComponents.has(node.declaration.id?.name ?? "");
+          const isComponent = node.declaration.id?.name === className;
           if (isComponent) {
             return;
           }
@@ -1631,7 +1574,7 @@ plugin.createRule({
         });
       },
       ExportDefaultDeclaration(node) {
-        if (!hasLuminaDeclarations && declaredComponents.size === 0) {
+        if (className === void 0) {
           return;
         }
         context.report({
@@ -1640,7 +1583,7 @@ plugin.createRule({
         });
       },
       ExportAllDeclaration(node) {
-        if (!hasLuminaDeclarations && declaredComponents.size === 0) {
+        if (className === void 0) {
           return;
         }
         if (node.exportKind === "type") {

package/dist/plugins/lumina/rules/no-inline-exposure-jsdoc-tag.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('@typescript-eslint/utils/ts-eslint').RuleModule<"inlineExposure", [], import('../../utils/makePlugin.ts').CommonDocs, import('@typescript-eslint/utils/ts-eslint').RuleListener>;
+export default _default;

package/dist/plugins/lumina/utils/estree.d.ts

@@ -9,6 +9,17 @@ export declare function checkForLuminaJsx(): LuminaJsxCheck & {
 };
 export declare function hasDecorator(node: Pick<TSESTree.PropertyDefinitionNonComputedName, "decorators">, decoratorName: string): boolean;
 export declare function extractDeclareElementsInterface(node: TSESTree.TSModuleDeclaration): TSESTree.TSInterfaceDeclaration | undefined;
+export declare function getComponentDeclaration(node: TSESTree.TSInterfaceDeclaration): {
+    key: TSESTree.Literal;
+    typeAnnotation: {
+        typeAnnotation: {
+            typeName: TSESTree.Identifier;
+        };
+    };
+} | undefined;
+export declare const sourceCodeDeclaresComponent: (sourceCode: {
+    readonly text: string;
+}) => boolean;
 export declare function isCreateEvent(node: TSESTree.PropertyDefinition): boolean;
 export declare const getProperty: (properties: TSESTree.ObjectLiteralElement[] | undefined, name: string) => TSESTree.Property["value"] | undefined;
 export declare function isGetterWithoutSetter(node: TSESTree.MethodDefinition | TSESTree.PropertyDefinition): boolean;

package/dist/plugins/webgis/index.js

@@ -1,4 +1,4 @@
-import { m as makeEslintPlugin } from "../../makePlugin-C3S0T31x.js";
+import { m as makeEslintPlugin, e as extractDeclareElementsInterface, g as getComponentDeclaration } from "../../estree-kBWxXj93.js";
 import { resolve } from "path/posix";
 import { AST_NODE_TYPES } from "@typescript-eslint/utils";
 const plugin = makeEslintPlugin(
@@ -7,16 +7,16 @@ const plugin = makeEslintPlugin(
 );
 const isTestFile = (filePath) => filePath.includes("/test") || filePath.includes(".test") || filePath.includes(".spec") || filePath.includes("e2e") || filePath.includes("__") || filePath.includes("/.");
 const isStorybookFile = (filePath) => filePath.includes(".stories");
-const description$4 = `Imports of files outside the src/ folder are not-portable and likely to break for consumers of this package.`;
+const description$5 = `Imports of files outside the src/ folder are not-portable and likely to break for consumers of this package.`;
 plugin.createRule({
   name: "no-import-outside-src",
   meta: {
     docs: {
-      description: description$4,
+      description: description$5,
       defaultLevel: "error"
     },
     messages: {
-      noImportOutsideSrc: description$4
+      noImportOutsideSrc: description$5
     },
     type: "problem",
     schema: []
@@ -50,16 +50,16 @@ plugin.createRule({
     };
   }
 });
-const description$3 = `Having two JSDoc comments next to each other is most likely a mistake - consider combining them into one, or separating them for clarity.`;
+const description$4 = `Having two JSDoc comments next to each other is most likely a mistake - consider combining them into one, or separating them for clarity.`;
 plugin.createRule({
   name: "no-touching-jsdoc",
   meta: {
     docs: {
-      description: description$3,
+      description: description$4,
       defaultLevel: "warn"
     },
     messages: {
-      noTouchingJsDoc: description$3
+      noTouchingJsDoc: description$4
     },
     type: "problem",
     schema: []
@@ -95,17 +95,17 @@ plugin.createRule({
   }
 });
 const reTouchingJsDoc = /\*\/\s+\/\*\*/gu;
-const description$2 = `@arcgis/core imports need to end with .js for better compatibility with ESM CDN builds for @arcgis/core and other packages.`;
+const description$3 = `@arcgis/core imports need to end with .js for better compatibility with ESM CDN builds for @arcgis/core and other packages.`;
 const packagesToEnforce = ["@arcgis/core/", "@amcharts/amcharts4/", "@amcharts/amcharts5/"];
 plugin.createRule({
   name: "require-js-in-imports",
   meta: {
     docs: {
-      description: description$2,
+      description: description$3,
       defaultLevel: "warn"
     },
     messages: {
-      requireJsInCoreImport: description$2
+      requireJsInCoreImport: description$3
     },
     type: "problem",
     fixable: "code",
@@ -117,7 +117,7 @@ plugin.createRule({
       return {};
     }
     function updateSpecifier(node) {
-      if (node.source.type !== AST_NODE_TYPES.Literal || node.importKind === "type") {
+      if (node.source.type !== AST_NODE_TYPES.Literal) {
         return;
       }
       const specifier = node.source.value;
@@ -139,17 +139,17 @@ plugin.createRule({
     };
   }
 });
-const description$1 = "Using .d.ts files is discouraged. Prefer .ts files instead, as they are type-checked and not in global scope.";
+const description$2 = "Using .d.ts files is discouraged. Prefer .ts files instead, as they are type-checked and not in global scope.";
 const allowedNames = /* @__PURE__ */ new Set(["vite-env.d.ts", "components.d.ts"]);
 plugin.createRule({
   name: "no-dts-files",
   meta: {
     docs: {
-      description: description$1,
+      description: description$2,
       defaultLevel: "warn"
     },
     messages: {
-      avoidDtsFiles: description$1
+      avoidDtsFiles: description$2
     },
     type: "suggestion",
     schema: []
@@ -179,12 +179,12 @@ plugin.createRule({
     };
   }
 });
-const description = `Enforce consistent logging so that ArcGIS developers can easily debug errors or warnings logged by our web components, which may lack a meaningful context in compiled code. See [our documentation on @arcgis/toolkit/log](https://webgis.esri.com/references/toolkit/log).`;
+const description$1 = `Enforce consistent logging so that ArcGIS developers can easily debug errors or warnings logged by our web components, which may lack a meaningful context in compiled code. See [our documentation on @arcgis/toolkit/log](https://webgis.esri.com/references/toolkit/log).`;
 plugin.createRule({
   name: "consistent-logging",
   meta: {
     docs: {
-      description,
+      description: description$1,
       defaultLevel: "off"
       // NOTE: this is turned on conditionally in root eslint config
     },
@@ -217,6 +217,61 @@ plugin.createRule({
     };
   }
 });
+const description = `Do not use links like [](#something) as they are not portable across .d.ts, and are not validated at build time. Use {@link } syntax, or absolute links. See https://webgis.esri.com/webgis/core/core/documenting-api#link`;
+plugin.createRule({
+  name: "no-unsafe-hash-links",
+  meta: {
+    docs: {
+      description,
+      defaultLevel: "warn"
+    },
+    messages: {
+      error: description
+    },
+    type: "problem",
+    schema: [],
+    fixable: "code"
+  },
+  defaultOptions: [],
+  create(context) {
+    let declareElementsInterface;
+    return {
+      "TSModuleDeclaration"(node) {
+        declareElementsInterface = extractDeclareElementsInterface(node);
+      },
+      "Program:exit"() {
+        if (declareElementsInterface === void 0 && !context.sourceCode.text.includes("@public") && !context.sourceCode.text.includes("@internal")) {
+          return;
+        }
+        for (const match of context.sourceCode.text.matchAll(reHashLink)) {
+          const fullMatch = match[0];
+          const anchor = match[2];
+          const replacement = computeReplacement(declareElementsInterface, anchor);
+          context.report({
+            messageId: "error",
+            loc: {
+              start: context.sourceCode.getLocFromIndex(match.index),
+              end: context.sourceCode.getLocFromIndex(match.index + fullMatch.length)
+            },
+            fix: replacement === void 0 ? void 0 : (fixer) => fixer.replaceTextRange([match.index, match.index + fullMatch.length], `{@link ${replacement}}`)
+          });
+        }
+      }
+    };
+  }
+});
+const reHashLink = /\[([^\]\n]+)\]\(#([^)]+)\)/gu;
+function computeReplacement(declareElementsInterface, anchor) {
+  if (declareElementsInterface === void 0) {
+    return;
+  }
+  const declaration = getComponentDeclaration(declareElementsInterface);
+  if (declaration === void 0) {
+    return;
+  }
+  const tagName = declaration.key.value;
+  return `components/${tagName}#${anchor}`;
+}
 const webgisPlugin = plugin.finalize();
 export {
   webgisPlugin

package/dist/plugins/webgis/rules/no-unsafe-hash-links.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('@typescript-eslint/utils/ts-eslint').RuleModule<"error", [], import('../../utils/makePlugin.ts').CommonDocs, import('@typescript-eslint/utils/ts-eslint').RuleListener>;
+export default _default;

package/dist/utils/disable-rules.d.ts

@@ -0,0 +1,24 @@
+import { TSESLint } from '@typescript-eslint/utils';
+/**
+ * A utility for temporary running ESLint with only specific rules enabled.
+ *
+ * @param config flat config
+ * @param enabledRules exceptions
+ * @param disableTypeChecking make ESLint much faster by temporary disabling
+ * type-aware linting.
+ * @returns a new flat config array where every rule is disabled,
+ * except for rules explicitly listed in `enabledRules`.
+ *
+ * @example
+ * const config = [
+ *  // Your ESLint flat config
+ * ];
+ * export default disableAllRulesExcept(
+ *   config,
+ *   {
+ *     "rule-name-1": "error",
+ *   },
+ *   true,
+ * );
+ */
+export declare function disableAllRulesExcept(config: TSESLint.FlatConfig.ConfigArray, enabledRules: Record<string, TSESLint.FlatConfig.RuleLevel>, disableTypeChecking: boolean): TSESLint.FlatConfig.ConfigArray;

package/dist/utils/disable-rules.js

@@ -0,0 +1,47 @@
+function disableAllRulesExcept(config, enabledRules, disableTypeChecking) {
+  return config.map((entry) => applyRulesAndOptions(entry, enabledRules, disableTypeChecking));
+}
+function applyRulesAndOptions(entry, enabledRules, disableTypeChecking) {
+  if (!entry || typeof entry !== "object") {
+    return entry;
+  }
+  const nextEntry = entry.rules ? {
+    ...entry,
+    rules: Object.fromEntries(
+      Object.keys(entry.rules).map((ruleName) => {
+        const override = enabledRules[ruleName];
+        return [ruleName, override ?? "off"];
+      })
+    )
+  } : entry;
+  return tweakOptions(nextEntry, disableTypeChecking);
+}
+function tweakOptions(entry, disableTypeChecking) {
+  if (entry.linterOptions !== void 0) {
+    entry = {
+      ...entry,
+      linterOptions: {
+        ...entry.linterOptions,
+        reportUnusedDisableDirectives: "off",
+        reportUnusedInlineConfigs: "off"
+      }
+    };
+  }
+  if (disableTypeChecking && entry.languageOptions?.parserOptions) {
+    entry = {
+      ...entry,
+      languageOptions: {
+        ...entry.languageOptions,
+        parserOptions: {
+          ...entry.languageOptions.parserOptions,
+          project: void 0,
+          projectService: void 0
+        }
+      }
+    };
+  }
+  return entry;
+}
+export {
+  disableAllRulesExcept
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcgis/eslint-config",
-  "version": "5.1.0-next.6",
+  "version": "5.1.0-next.60",
   "description": "ESLint configuration for arcgis-web-components",
   "type": "module",
   "main": "index.js",
@@ -8,11 +8,14 @@
   "types": "dist/index.d.ts",
   "exports": {
     ".": "./dist/config/index.js",
+    "./ts": "./src/config/index.ts",
     "./application": "./dist/config/applications.js",
     "./extra": "./dist/config/extra.js",
     "./lumina": "./dist/config/lumina.js",
+    "./lumina/ts": "./src/config/lumina.ts",
     "./plugins/webgis": "./dist/plugins/webgis/index.js",
     "./plugins/lumina": "./dist/plugins/lumina/index.js",
+    "./utils/disable-rules": "./dist/utils/disable-rules.js",
     "./package.json": "./package.json"
   },
   "files": [
@@ -32,7 +35,7 @@
     "tslib": "^2.8.1",
     "typescript": "~5.9.3",
     "typescript-eslint": "^8.46.3",
-    "@arcgis/toolkit": "5.1.0-next.6"
+    "@arcgis/toolkit": "5.1.0-next.60"
   },
   "peerDependencies": {
     "eslint": "^9.39.1"

package/dist/makePlugin-C3S0T31x.js

@@ -1,41 +0,0 @@
-import { ESLintUtils } from "@typescript-eslint/utils";
-const version = "5.1.0-next.6";
-const packageJson = {
-  version
-};
-function makeEslintPlugin(pluginName, urlCreator) {
-  const rules = [];
-  const creator = ESLintUtils.RuleCreator(urlCreator);
-  return {
-    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-    createRule(rule) {
-      const { meta, name, ...rest } = rule;
-      const docs = { ...meta.docs, name };
-      const ruleModule = creator({ ...rest, meta: { ...meta, docs }, name });
-      rules.push(ruleModule);
-      return ruleModule;
-    },
-    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-    finalize() {
-      const config = {
-        rules: Object.fromEntries(
-          rules.map((rule) => [`${pluginName}/${rule.meta.docs.name}`, rule.meta.docs.defaultLevel])
-        )
-      };
-      const plugin = {
-        meta: { name: `@arcgis/eslint-plugin-${pluginName}`, version: packageJson.version },
-        configs: {
-          recommended: config
-        },
-        rules: Object.fromEntries(rules.map((rule) => [rule.meta.docs.name, rule]))
-      };
-      config.plugins = {
-        [pluginName]: plugin
-      };
-      return plugin;
-    }
-  };
-}
-export {
-  makeEslintPlugin as m
-};