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

package/dist/plugins/webgis/index.js

@@ -1,111 +1,164 @@
-import { m as makeEslintPlugin, e as extractDeclareElementsInterface, g as getComponentDeclaration } from "../../estree-DW92hBTd.js";
+import { m as makeEslintPlugin } from "../../makePlugin-GmKey29v.js";
+import { TSESTree, AST_TOKEN_TYPES, AST_NODE_TYPES, TSESLint } from "@typescript-eslint/utils";
+import path from "node:path";
 import { resolve } from "path/posix";
-import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import globals from "globals";
+import { uncapitalize, kebabToPascal } from "@arcgis/toolkit/string";
+import { e as extractDeclareElementsInterface, g as getComponentDeclaration } from "../../estree-CDc-die8.js";
 const plugin = makeEslintPlugin(
   "webgis",
   (rule) => `https://devtopia.esri.com/WebGIS/arcgis-web-components/tree/main/packages/support-packages/eslint-config/src/plugins/webgis/rules/${rule}.ts`
 );
 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$6 = `Imports of files outside the src/ folder are not-portable and likely to break for consumers of this package.`;
+function hasPublicJsDocTag(sourceCode, node) {
+  const jsDocOwner = node.decorators?.at(0) ?? (node.parent?.type === TSESTree.AST_NODE_TYPES.ExportNamedDeclaration || node.parent?.type === TSESTree.AST_NODE_TYPES.ExportDefaultDeclaration ? node.parent : void 0) ?? node;
+  const commentTarget = jsDocOwner;
+  if (commentTarget === void 0) {
+    return false;
+  }
+  return sourceCode.getCommentsBefore(commentTarget).some((comment) => comment.type === AST_TOKEN_TYPES.Block && sourceCode.getText(comment).includes("* @public"));
+}
 plugin.createRule({
-  name: "no-import-outside-src",
+  name: "consistent-constructor-arguments",
   meta: {
     docs: {
-      description: description$6,
-      defaultLevel: "error"
+      description: "Consistent constructor arguments for Accessor-based classes.",
+      // Disabled by default because the rule is most relevant for autocasting
+      // and only on public classes. We are discouraging autocasting in new
+      // code.
+      defaultLevel: "off"
     },
     messages: {
-      noImportOutsideSrc: description$6
+      name: `By convention, the first parameter on an Accessor-based class must be called "properties". This is needed for autocasting - https://webgis.esri.com/references/api-extractor/api-node-kinds#constructor. If your class has constructors overloads, at least one of them must have a "properties" parameter.`,
+      type: `By convention, the constructor argument type of Accessor-based classes must be called \`{{ expectedName }}\` (found \`{{ actualName }}\` instead).
+
+If you wish to use a loose type like any/object, create a type alias \`type {{ expectedName }}\` and assign such loose type to that.`
     },
-    type: "problem",
+    type: "suggestion",
     schema: []
   },
   defaultOptions: [],
   create(context) {
-    const fileName = context.filename;
-    const srcIndex = fileName.indexOf("/src/");
-    if (srcIndex === -1) {
-      return {};
-    }
-    const basePath = fileName.slice(0, srcIndex + "/src/".length);
-    if (isTestFile(fileName) || isStorybookFile(fileName)) {
+    if (isTestFile(context.filename)) {
       return {};
     }
     return {
-      ImportDeclaration(node) {
-        const specifier = node.source.value;
-        const isRelativeAncestor = specifier.startsWith("../");
-        if (!isRelativeAncestor) {
+      ClassDeclaration(node) {
+        if (!hasPublicJsDocTag(context.sourceCode, node)) {
           return;
         }
-        const relativePath = resolve(fileName, "..", specifier);
-        if (!relativePath.startsWith(basePath) && !relativePath.endsWith(".json")) {
+        const hasSubclassDecorator = node.decorators?.some(
+          (decorator) => decorator.expression.type === TSESTree.AST_NODE_TYPES.CallExpression && decorator.expression.callee.type === TSESTree.AST_NODE_TYPES.Identifier && decorator.expression.callee.name === "subclass"
+        );
+        const className = node.id?.name;
+        const isTopLevelClass = node.parent?.type === TSESTree.AST_NODE_TYPES.Program || node.parent?.type === TSESTree.AST_NODE_TYPES.ExportNamedDeclaration || node.parent?.type === TSESTree.AST_NODE_TYPES.ExportDefaultDeclaration;
+        if (!hasSubclassDecorator || className === void 0 || !isTopLevelClass) {
+          return;
+        }
+        let firstConstructor;
+        let hasPropertiesParameter = false;
+        node.body.body.forEach((element) => {
+          if (element.type !== TSESTree.AST_NODE_TYPES.MethodDefinition || element.kind !== "constructor") {
+            return;
+          }
+          firstConstructor ??= element;
+          const firstParameterNode = element.value.params.at(0);
+          const firstParameter = firstParameterNode?.type === TSESTree.AST_NODE_TYPES.AssignmentPattern ? firstParameterNode.left : firstParameterNode;
+          const isPropertiesParameter = firstParameter?.type === TSESTree.AST_NODE_TYPES.Identifier && firstParameter.name === "properties";
+          hasPropertiesParameter ||= isPropertiesParameter;
+          if (!isPropertiesParameter) {
+            return;
+          }
+          const typeAnnotation = firstParameter.typeAnnotation?.typeAnnotation;
+          const typeAnnotationName = typeAnnotation?.type === TSESTree.AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeName.type === TSESTree.AST_NODE_TYPES.Identifier ? typeAnnotation.typeName.name : void 0;
+          const expectedTypeName = `${className}Properties`;
+          if (typeAnnotationName === expectedTypeName) {
+            return;
+          }
+          const extendsText = node.superClass ? context.sourceCode.getText(node.superClass) : "";
+          const isCollectionClass = extendsText.includes("Collection.ofType") || extendsText.includes("(Collection)") || extendsText === "Collection" || extendsText === "OwningCollection" || context.filename.endsWith(`esri${path.sep}core${path.sep}Collection.ts`);
+          if (isCollectionClass) {
+            return;
+          }
+          const typeIsTypeParameter = node.typeParameters?.params.some(
+            (parameter) => parameter.name.name === typeAnnotationName
+          );
+          if (typeIsTypeParameter) {
+            return;
+          }
           context.report({
-            messageId: "noImportOutsideSrc",
-            node: node.source
+            node: typeAnnotation ?? firstParameter,
+            messageId: "type",
+            data: {
+              actualName: typeAnnotation === void 0 ? "<empty>" : context.sourceCode.getText(firstParameter.typeAnnotation?.typeAnnotation),
+              expectedName: expectedTypeName
+            }
           });
+        });
+        if (firstConstructor === void 0) {
+          return;
+        }
+        if (!hasPropertiesParameter) {
+          context.report({
+            node: firstConstructor,
+            messageId: "name"
+          });
+          return;
         }
       }
     };
   }
 });
-const description$5 = `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$6 = `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: "no-touching-jsdoc",
+  name: "consistent-logging",
   meta: {
     docs: {
-      description: description$5,
-      defaultLevel: "warn"
+      description: description$6,
+      defaultLevel: "off"
     },
     messages: {
-      noTouchingJsDoc: description$5
+      consistentLoggingWarning: `For consistency, use the log utility from @arcgis/toolkit/log instead of console.{{logMethodName}}.`
     },
-    type: "problem",
-    schema: []
+    schema: [],
+    fixable: void 0,
+    type: "suggestion"
   },
   defaultOptions: [],
   create(context) {
+    if (isTestFile(context.filename) || isStorybookFile(context.filename)) {
+      return {};
+    }
     return {
-      Program() {
-        Array.from(context.sourceCode.text.matchAll(reTouchingJsDoc), (match) => {
-          const previousJsDocStart = context.sourceCode.text.slice(0, match.index).lastIndexOf("/**");
-          if (previousJsDocStart === -1) {
-            return void 0;
-          }
-          const previousJsDocContent = context.sourceCode.text.slice(
-            previousJsDocStart + "/**".length,
-            match.index - "*/".length
-          );
-          const containsOtherComments = previousJsDocContent.includes("*/");
-          if (containsOtherComments) {
-            return void 0;
-          }
+      // NOTE: CallExpression is not enough. Use MemberExpression to handle callbacks, e.g. .catch(console.error)
+      MemberExpression(node) {
+        if (node.type === AST_NODE_TYPES.MemberExpression && node.object.type === AST_NODE_TYPES.Identifier && node.object.name === "console" && node.property.type === AST_NODE_TYPES.Identifier) {
+          const logMethodName = node.property.name;
           context.report({
-            messageId: "noTouchingJsDoc",
-            loc: {
-              start: context.sourceCode.getLocFromIndex(match.index),
-              end: context.sourceCode.getLocFromIndex(match.index + match[0].length)
+            node,
+            messageId: "consistentLoggingWarning",
+            data: {
+              logMethodName
             }
           });
-          return void 0;
-        });
+        }
       }
     };
   }
 });
-const reTouchingJsDoc = /\*\/\s+\/\*\*/gu;
-const description$4 = `@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",
+  name: "consistent-mixin-syntax",
   meta: {
     docs: {
-      description: description$4,
-      defaultLevel: "warn"
+      description: "Enforce consistent mixin pattern. See https://webgis.esri.com/sdk/contributing/core/core/mixins",
+      // Enabled by default because the rule targets a very specific pattern
+      // and that pattern is tricky to get right without this rule.
+      defaultLevel: "error"
     },
     messages: {
-      requireJsInCoreImport: description$4
+      updateMixinCode: "Mixin typings need to be updated.",
+      typeAnnotationRequired: "Explicit type annotation is required."
     },
     type: "problem",
     fixable: "code",
@@ -113,43 +166,330 @@ plugin.createRule({
   },
   defaultOptions: [],
   create(context) {
-    if (isTestFile(context.filename)) {
+    const sourceCode = context.sourceCode.getText();
+    const isMixin = sourceCode.includes("TBase");
+    if (!isMixin) {
       return {};
     }
-    function updateSpecifier(node) {
-      if (node.source.type !== AST_NODE_TYPES.Literal) {
-        return;
-      }
-      const specifier = node.source.value;
-      const lastSlashIndex = specifier?.toString().lastIndexOf("/") ?? 0;
-      const dotSearchIndex = lastSlashIndex === -1 ? 0 : lastSlashIndex + 1;
-      if (typeof specifier !== "string" || !packagesToEnforce.some((pkg) => specifier.startsWith(pkg)) || // Already ends with .js or .json
-      specifier.includes(".", dotSearchIndex)) {
-        return;
+    return {
+      VariableDeclarator(node) {
+        if (node.id.type !== AST_NODE_TYPES.Identifier || node.init?.type !== AST_NODE_TYPES.ArrowFunctionExpression) {
+          return;
+        }
+        const body = node.init.body;
+        if (body.type !== AST_NODE_TYPES.BlockStatement) {
+          return;
+        }
+        const firstTypeParameter = node.init.typeParameters?.params[0];
+        if (firstTypeParameter?.name.name !== "TBase") {
+          return;
+        }
+        let baseName = node.id.name;
+        if (baseName.startsWith("Exported")) {
+          baseName = baseName.slice("Exported".length);
+        }
+        if (baseName.endsWith("Mixin")) {
+          baseName = baseName.slice(0, -"Mixin".length);
+        }
+        const restTypeParameters = node.init.typeParameters?.params?.slice(1).map((param) => context.sourceCode.getText(param)).join(", ") ?? "";
+        const formattedRestTypeParameters = restTypeParameters.length === 0 ? "" : `<${restTypeParameters}>`;
+        const restTypeArguments = node.init.typeParameters?.params?.slice(1).map((param) => context.sourceCode.getText(param.name)).join(", ") ?? "";
+        const formattedRestTypeArguments = restTypeArguments.length === 0 ? "" : `<${restTypeArguments}>`;
+        {
+          const returnTypeCode = `typeof Public${baseName}${formattedRestTypeArguments} & TBase`;
+          if (node.init.returnType === void 0) {
+            const closeParenToken = context.sourceCode.getFirstToken(node.init, (token) => token.value === ")");
+            if (closeParenToken !== null) {
+              context.report({
+                node: node.init,
+                messageId: "updateMixinCode",
+                fix: (fixer) => {
+                  const returnTypeText = `: ${returnTypeCode}`;
+                  return fixer.insertTextAfter(closeParenToken, returnTypeText);
+                }
+              });
+            }
+          } else if (context.sourceCode.getText(node.init.returnType.typeAnnotation) !== returnTypeCode) {
+            const typeAnnotation = node.init.returnType.typeAnnotation;
+            context.report({
+              node: typeAnnotation,
+              messageId: "updateMixinCode",
+              fix: (fixer) => fixer.replaceText(typeAnnotation, returnTypeCode)
+            });
+          }
+        }
+        let hadMissingTypeError = false;
+        let hadTypedBaseVariable = false;
+        let privateClassName = baseName;
+        let isAbstract = false;
+        const members = [];
+        for (const statement of body.body) {
+          if (statement.type === AST_NODE_TYPES.VariableDeclaration && statement.declarations.length === 1 && statement.declarations[0].id.type === AST_NODE_TYPES.Identifier && statement.declarations[0].id.name === "TypedBase" && statement.declarations[0].init?.type === AST_NODE_TYPES.TSAsExpression) {
+            hadTypedBaseVariable = true;
+          } else if (statement.type === AST_NODE_TYPES.TSInterfaceDeclaration) {
+            for (const member of statement.body.body) {
+              members.push(context.sourceCode.getText(member));
+            }
+          } else if (statement.type === AST_NODE_TYPES.ClassDeclaration) {
+            privateClassName = statement.id.name;
+            isAbstract = statement.abstract;
+            {
+              const extendsPart = statement.superClass;
+              if (extendsPart === null) {
+                context.report({
+                  node: statement,
+                  messageId: "updateMixinCode",
+                  fix: (fixer) => fixer.insertTextAfter(statement.id, ` extends TypedBase`)
+                });
+              } else if (context.sourceCode.getText(extendsPart) !== "TypedBase") {
+                context.report({
+                  node: statement,
+                  messageId: "updateMixinCode",
+                  fix: (fixer) => fixer.replaceText(extendsPart, "TypedBase")
+                });
+              }
+            }
+            for (const member of statement.body.body) {
+              const isAbstractMethod = member.type === AST_NODE_TYPES.TSAbstractMethodDefinition;
+              const isAbstractProperty = member.type === AST_NODE_TYPES.TSAbstractPropertyDefinition;
+              if (member.type === AST_NODE_TYPES.MethodDefinition || isAbstractMethod) {
+                if (member.key.type === AST_NODE_TYPES.PrivateIdentifier) {
+                  continue;
+                }
+                const memberName = context.sourceCode.getText(member.key);
+                const formattedMemberName = member.computed ? `[${memberName}]` : memberName;
+                if (memberName === "constructor") {
+                  continue;
+                }
+                const modifiers = `${member.static ? "static " : ""}${member.accessibility ? `${member.accessibility} ` : ""}${isAbstractMethod ? "abstract " : ""}`;
+                const kindName = member.kind === "get" || member.kind === "set" ? `${member.kind} ` : "";
+                const functionString = functionToTypeString(
+                  member.value,
+                  context,
+                  member.kind === "set" ? "set" : void 0
+                );
+                if (functionString === void 0) {
+                  hadMissingTypeError = true;
+                  continue;
+                }
+                members.push(`${modifiers}${kindName}${formattedMemberName}${functionString};`);
+              } else if (member.type === AST_NODE_TYPES.PropertyDefinition || isAbstractProperty) {
+                if (member.key.type === AST_NODE_TYPES.PrivateIdentifier) {
+                  continue;
+                }
+                const memberName = context.sourceCode.getText(member.key);
+                const formattedMemberName = member.computed ? `[${memberName}]` : memberName;
+                const typeAnnotation = member.typeAnnotation?.typeAnnotation;
+                let type = typeAnnotation ? context.sourceCode.getText(typeAnnotation) : member.value === null ? void 0 : expressionToTypeString(member.value, context, false);
+                if (type === void 0) {
+                  type = "any";
+                  context.report({
+                    node: member,
+                    messageId: "typeAnnotationRequired"
+                  });
+                  hadMissingTypeError = true;
+                }
+                const modifiers = `${member.static ? "static " : ""}${member.accessibility ? `${member.accessibility} ` : ""}${isAbstractProperty ? "abstract " : ""}${member.readonly ? "readonly " : ""}`;
+                const optionalText = member.optional ? "?" : "";
+                members.push(`${modifiers}${formattedMemberName}${optionalText}: ${type};`);
+              }
+            }
+          } else if (statement.type === AST_NODE_TYPES.ReturnStatement) {
+            const returnText = context.sourceCode.getText(statement);
+            const expectedReturnText = `return ${privateClassName} as typeof Public${baseName}${formattedRestTypeArguments} & TBase;`;
+            if (returnText.replaceAll(reWhiteSpaceOrComma, "") !== expectedReturnText.replaceAll(reWhiteSpaceOrComma, "")) {
+              context.report({
+                node: statement,
+                messageId: "updateMixinCode",
+                fix: (fixer) => fixer.replaceText(statement, expectedReturnText)
+              });
+            }
+          }
+        }
+        const typeConstraint = firstTypeParameter.constraint;
+        const typeConstraintText = typeConstraint === void 0 ? "Constructor<Accessor>" : context.sourceCode.getText(typeConstraint);
+        if (typeConstraint !== void 0) {
+          const typeParameterText = context.sourceCode.getText(firstTypeParameter);
+          context.report({
+            node: typeConstraint,
+            messageId: "updateMixinCode",
+            fix: (fixer) => fixer.replaceText(firstTypeParameter, typeParameterText.split("extends")[0])
+          });
+        }
+        if (!hadTypedBaseVariable) {
+          context.report({
+            loc: body.loc.start,
+            messageId: "updateMixinCode",
+            fix: (fixer) => fixer.insertTextAfterRange(
+              [
+                context.sourceCode.getIndexFromLoc(body.loc.start) + 1,
+                context.sourceCode.getIndexFromLoc(body.loc.start) + 1
+              ],
+              `
+const TypedBase = Base as unknown as ${typeConstraintText};`
+            )
+          });
+        }
+        if (hadMissingTypeError) {
+          return;
+        }
+        const localRegionStart = `${regionStart} ${baseName}`;
+        const abstractString = isAbstract ? "abstract " : "";
+        const autoGeneratedCode = `${localRegionStart}
+declare ${abstractString}class Public${baseName}${formattedRestTypeParameters} {
+  constructor(...args: any[]);
+${members.map((member) => `  ${member}`).join("\n")}
+}
+${regionEnd}`;
+        const regionStartIndex = sourceCode.indexOf(localRegionStart);
+        if (regionStartIndex === -1) {
+          context.report({
+            loc: node.loc.end,
+            messageId: "updateMixinCode",
+            fix: (fixer) => fixer.insertTextAfter(node, `
+
+${autoGeneratedCode}
+`)
+          });
+        } else {
+          let regionEndString = regionEnd;
+          let regionEndIndex = sourceCode.indexOf(regionEndString, regionStartIndex);
+          if (regionEndIndex === -1) {
+            regionEndString = regionEndCrlf;
+            regionEndIndex = sourceCode.indexOf(regionEndString, regionStartIndex);
+          }
+          if (regionEndIndex === -1) {
+            regionEndIndex = sourceCode.length;
+          } else {
+            regionEndIndex += regionEndString.length;
+          }
+          const oldRegionCode = sourceCode.slice(regionStartIndex, regionEndIndex);
+          const oldRegionCodeWithoutWhitespace = oldRegionCode.replaceAll(reWhiteSpaceOrComma, "");
+          const newRegionCodeWithoutWhitespace = autoGeneratedCode.replaceAll(reWhiteSpaceOrComma, "");
+          if (oldRegionCodeWithoutWhitespace === newRegionCodeWithoutWhitespace) {
+            return;
+          }
+          const line = sourceCode.slice(0, regionStartIndex).split("\n").length;
+          context.report({
+            // Region start:
+            loc: {
+              line,
+              column: 0
+            },
+            messageId: "updateMixinCode",
+            fix: (fixer) => fixer.replaceTextRange([regionStartIndex, regionEndIndex], autoGeneratedCode)
+          });
+        }
       }
+    };
+  }
+});
+const reWhiteSpaceOrComma = /[\s,]+/gu;
+const regionStart = "// #region Autogenerated";
+const regionEnd = "// #endregion\n";
+const regionEndCrlf = "// #endregion\r\n";
+function functionToTypeString(definition, context, kind = void 0) {
+  let hadMissingTypeError = false;
+  const parameters = definition.params.map((param, index) => {
+    if (param.type === AST_NODE_TYPES.TSParameterProperty) {
+      throw new Error("Unsupported");
+    }
+    const name = param.type === AST_NODE_TYPES.RestElement && param.argument.type === AST_NODE_TYPES.Identifier ? `...${param.argument.name}` : param.type === AST_NODE_TYPES.Identifier ? param.name : param.type === AST_NODE_TYPES.AssignmentPattern && param.left.type === AST_NODE_TYPES.Identifier ? param.left.name : `_arg${index}`;
+    const optional = "optional" in param && param.optional || param.type === AST_NODE_TYPES.AssignmentPattern ? "?" : "";
+    const typeAnnotation = param.type === AST_NODE_TYPES.AssignmentPattern ? param?.left.typeAnnotation?.typeAnnotation : param.typeAnnotation?.typeAnnotation;
+    let type = typeAnnotation === void 0 ? param.type === AST_NODE_TYPES.AssignmentPattern ? expressionToTypeString(param.right, context, false) : void 0 : context.sourceCode.getText(typeAnnotation);
+    if (type === void 0) {
+      type = "any";
       context.report({
-        node: node.source,
-        messageId: "requireJsInCoreImport",
-        fix: (fixer) => fixer.replaceText(node.source, `"${specifier}.js"`)
+        node: param,
+        messageId: "typeAnnotationRequired"
       });
+      hadMissingTypeError = true;
     }
-    return {
-      ImportDeclaration: updateSpecifier,
-      ImportExpression: updateSpecifier
-    };
+    return `${name}${optional}: ${type}`;
+  }).join(", ");
+  if (hadMissingTypeError) {
+    return;
   }
-});
-const description$3 = "Using .d.ts files is discouraged. Prefer .ts files instead, as they are type-checked and not in global scope.";
+  const returnType = kind === "set" ? "" : definition.returnType?.typeAnnotation === void 0 ? definition.body?.type === AST_NODE_TYPES.BlockStatement && definition.body.body.length === 1 && definition.body.body[0]?.type === AST_NODE_TYPES.ReturnStatement && definition.body.body[0].argument !== null ? expressionToTypeString(definition.body.body[0].argument, context, false) : void 0 : context.sourceCode.getText(definition.returnType.typeAnnotation);
+  if (returnType === void 0) {
+    context.report({
+      node: definition,
+      messageId: "typeAnnotationRequired"
+    });
+    return;
+  }
+  const returnToken = kind === "signature" ? " => " : ": ";
+  const formattedReturnType = returnType === "" ? "" : `${returnToken}${returnType}`;
+  const typeArguments = definition.typeParameters === void 0 ? "" : context.sourceCode.getText(definition.typeParameters);
+  return `${typeArguments}(${parameters})${formattedReturnType}`;
+}
+function expressionToTypeString(expression, context, asConst) {
+  const text = context.sourceCode.getText(expression);
+  if (text === "undefined") {
+    return text;
+  }
+  if (text === "true" || text === "false") {
+    return asConst ? text : "boolean";
+  }
+  if (expression.type === AST_NODE_TYPES.Literal) {
+    return asConst ? typeof expression.value === "string" ? JSON.stringify(expression.value) : expression.value?.toString() ?? "null" : typeof expression.value === "string" ? "string" : typeof expression.value === "number" ? "number" : typeof expression.value === "bigint" ? "bigint" : typeof expression.value === "boolean" ? "boolean" : typeof expression.value === "object" && expression.value !== null ? "RegExp" : "null";
+  }
+  if (expression.type === AST_NODE_TYPES.UnaryExpression && expression.operator === "-" && expression.argument.type === AST_NODE_TYPES.Literal) {
+    const value = expression.argument.value;
+    if (typeof value === "number" || typeof value === "bigint") {
+      return asConst ? `-${value}` : "number";
+    }
+  }
+  if (expression.type === AST_NODE_TYPES.TemplateLiteral) {
+    return "string";
+  }
+  if (expression.type === AST_NODE_TYPES.TSAsExpression || expression.type === AST_NODE_TYPES.TSTypeAssertion) {
+    const typeAnnotation = expression.typeAnnotation;
+    if (typeAnnotation.type === AST_NODE_TYPES.TSTypeReference && typeAnnotation.typeName.type === AST_NODE_TYPES.Identifier) {
+      if (typeAnnotation.typeName.name === "const") {
+        return expressionToTypeString(expression.expression, context, true);
+      }
+    }
+    return context.sourceCode.getText(typeAnnotation);
+  }
+  if (expression.type === AST_NODE_TYPES.TSSatisfiesExpression) {
+    const typeAnnotation = expression.typeAnnotation;
+    return asConst ? expressionToTypeString(expression.expression, context, true) : context.sourceCode.getText(typeAnnotation);
+  }
+  if (expression.type === AST_NODE_TYPES.TSNonNullExpression) {
+    return expressionToTypeString(expression.expression, context, asConst);
+  }
+  if (expression.type === AST_NODE_TYPES.NewExpression && expression.callee.type === AST_NODE_TYPES.Identifier) {
+    return `${expression.callee.name}${expression.typeArguments ? context.sourceCode.getText(expression.typeArguments) : ""}`;
+  }
+  if (expression.type === AST_NODE_TYPES.ConditionalExpression) {
+    const left = expressionToTypeString(expression.consequent, context, asConst);
+    const right = expressionToTypeString(expression.alternate, context, asConst);
+    if (left === void 0 || right === void 0) {
+      return;
+    }
+    return left === right ? left : `${left} | ${right}`;
+  }
+  if (expression.type === AST_NODE_TYPES.Identifier) {
+    return `typeof ${expression.name}`;
+  }
+  if (expression.type === AST_NODE_TYPES.FunctionExpression || expression.type === AST_NODE_TYPES.ArrowFunctionExpression) {
+    return functionToTypeString(expression, context, "signature");
+  }
+  return;
+}
+const description$5 = "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$3,
+      description: description$5,
       defaultLevel: "warn"
     },
     messages: {
-      avoidDtsFiles: description$3
+      avoidDtsFiles: description$5
     },
     type: "suggestion",
     schema: []
@@ -179,44 +519,315 @@ plugin.createRule({
     };
   }
 });
-const description$2 = `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",
+  name: "no-empty-catch",
   meta: {
     docs: {
-      description: description$2,
+      description: "Disallow empty catch calls since empty catch calls in a promise chain don't catch any exceptions",
+      // Enabled by default because this caught real bugs and has autofix
+      defaultLevel: "error"
+    },
+    messages: { emptyCatch: "no empty catch calls" },
+    schema: [],
+    type: "problem",
+    fixable: "code"
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      "CallExpression[callee.property.name='catch'][arguments.length=0]"(node) {
+        const [, rangeEnd] = node.range;
+        context.report({
+          node,
+          messageId: "emptyCatch",
+          fix: (fixer) => fixer.insertTextBeforeRange([rangeEnd - 1, rangeEnd], "() => {}")
+        });
+      }
+    };
+  }
+});
+const description$4 = `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,
+      defaultLevel: "error"
+    },
+    messages: {
+      noImportOutsideSrc: description$4
+    },
+    type: "problem",
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const fileName = context.filename;
+    const srcIndex = fileName.indexOf("/src/");
+    if (srcIndex === -1) {
+      return {};
+    }
+    const basePath = fileName.slice(0, srcIndex + "/src/".length);
+    if (isTestFile(fileName) || isStorybookFile(fileName)) {
+      return {};
+    }
+    return {
+      ImportDeclaration(node) {
+        const specifier = node.source.value;
+        const isRelativeAncestor = specifier.startsWith("../");
+        if (!isRelativeAncestor) {
+          return;
+        }
+        const relativePath = resolve(fileName, "..", specifier);
+        if (!relativePath.startsWith(basePath) && !relativePath.endsWith(".json")) {
+          context.report({
+            messageId: "noImportOutsideSrc",
+            node: node.source
+          });
+        }
+      }
+    };
+  }
+});
+plugin.createRule({
+  name: "no-instanceof",
+  meta: {
+    docs: {
+      description: "Disallow `instanceof` outside an allowlist.",
+      // Disabling by default because this matters for
+      // lower-level libraries more than higher-level libraries or applications.
+      // Also, many false-positives.
       defaultLevel: "off"
-      // NOTE: this is turned on conditionally in root eslint config
     },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          allow: { type: "array", items: { type: "string" }, uniqueItems: true }
+        },
+        additionalProperties: false
+      }
+    ],
     messages: {
-      consistentLoggingWarning: `For consistency, use the log utility from @arcgis/toolkit/log instead of console.{{logMethodName}}.`
+      instanceOf: "Avoid `instanceof` because it statically pulls the module defining the constructor into the bundle. Instead, use a Symbol together with a type guard function."
+    },
+    type: "problem"
+  },
+  defaultOptions: [{}],
+  create(context) {
+    const options = normalizeOptions(context.options[0]);
+    const sourceCode = context.sourceCode;
+    return {
+      "BinaryExpression[operator='instanceof']"(node) {
+        const right = node.right;
+        if (right.type === AST_NODE_TYPES.ThisExpression) {
+          return;
+        }
+        if (right.type !== AST_NODE_TYPES.Identifier) {
+          context.report({ node: right, messageId: "instanceOf" });
+          return;
+        }
+        const scope = sourceCode.getScope(node);
+        if (!isAllowedIdentifier(right.name, scope, options)) {
+          context.report({ node: right, messageId: "instanceOf" });
+        }
+      }
+    };
+  }
+});
+function normalizeOptions(options) {
+  return {
+    allowSet: new Set(options?.allow ?? [])
+  };
+}
+function resolveVariable(scope, name) {
+  for (let current = scope; current; current = current.upper) {
+    const variable = current.variables.find((entry) => entry.name === name);
+    if (variable) {
+      return variable;
+    }
+  }
+  return;
+}
+const builtInTypes = new Set(Object.keys({ ...globals.browser, ...globals.builtin }));
+function isAllowedIdentifier(name, scope, options) {
+  if (options.allowSet.has(name)) {
+    return true;
+  }
+  const variable = resolveVariable(scope, name);
+  if (builtInTypes.has(name) && isUnshadowedBuiltIn(variable)) {
+    return true;
+  }
+  return isClassVariable(variable);
+}
+function isUnshadowedBuiltIn(variable) {
+  if (!variable) {
+    return true;
+  }
+  return variable.scope.type === TSESLint.Scope.ScopeType.global && variable.defs.length === 0;
+}
+function isClassVariable(variable) {
+  return variable?.defs.some((definition) => isClassDefinition(definition)) ?? false;
+}
+function isClassDefinition(definition) {
+  const definitionType = definition.type;
+  if (definitionType === TSESLint.Scope.DefinitionType.ClassName) {
+    return true;
+  }
+  if (definitionType !== TSESLint.Scope.DefinitionType.Variable) {
+    return false;
+  }
+  const variableNode = definition.node;
+  if (variableNode?.type !== AST_NODE_TYPES.VariableDeclarator) {
+    return false;
+  }
+  return variableNode.init?.type === AST_NODE_TYPES.ClassExpression;
+}
+plugin.createRule({
+  name: "no-kebab-case-props",
+  meta: {
+    docs: {
+      description: "Disallow kebab-case props on custom JSX elements.",
+      // Off by default till
+      // https://devtopia.esri.com/WebGIS/arcgis-web-components/issues/5364#issuecomment-6321339
+      // is resolved
+      defaultLevel: "off"
+    },
+    messages: {
+      kebab: "JSX props should use camelCase instead of kebab-case, except for data- or aria- attributes"
     },
     schema: [],
-    fixable: void 0,
-    type: "suggestion"
+    type: "problem",
+    fixable: "code"
   },
   defaultOptions: [],
   create(context) {
-    if (isTestFile(context.filename) || isStorybookFile(context.filename)) {
+    return {
+      // looks for JSXAttributes that have a hyphen in their name
+      "JSXAttribute[name.name=/-/]"(node) {
+        const attrName = node.name.type === AST_NODE_TYPES.JSXIdentifier ? node.name.name : null;
+        if (!attrName || attrName.startsWith("aria-") || attrName.startsWith("data-")) {
+          return;
+        }
+        if (node.parent.name.type === AST_NODE_TYPES.JSXIdentifier) {
+          const tagName = node.parent.name.name;
+          if (isNativeTagName(tagName)) {
+            return;
+          }
+        }
+        context.report({
+          node,
+          messageId: "kebab",
+          fix: (fixer) => fixer.replaceText(node.name, uncapitalize(kebabToPascal(attrName)))
+        });
+      }
+    };
+  }
+});
+function isNativeTagName(tagName) {
+  const normalizedTagName = tagName.toLowerCase();
+  const isCapitalized = /^[A-Z]/u.test(tagName);
+  if (isCapitalized) {
+    return false;
+  }
+  return !normalizedTagName.includes("-") || blockListedCustomElementNames.has(normalizedTagName);
+}
+const blockListedCustomElementNames = /* @__PURE__ */ new Set([
+  "annotation-xml",
+  "color-profile",
+  "font-face",
+  "font-face-src",
+  "font-face-uri",
+  "font-face-format",
+  "font-face-name",
+  "missing-glyph"
+]);
+const description$3 = "In Storybook render functions, let `args` infer from `Meta<T>` or `StoryObj<T>` instead of annotating the render parameter.";
+plugin.createRule({
+  name: "no-story-render-args-type-annotation",
+  meta: {
+    docs: {
+      description: description$3,
+      defaultLevel: "off"
+    },
+    messages: {
+      noStoryRenderArgsTypeAnnotation: "Do not annotate `render(args)` in stories. Type the story with `Meta<T>` or `StoryObj<T>` and let `args` infer from that."
+    },
+    schema: [],
+    type: "suggestion",
+    fixable: "code"
+  },
+  defaultOptions: [],
+  create(context) {
+    if (!isStorybookFile(context.filename)) {
       return {};
     }
     return {
-      // NOTE: CallExpression is not enough. Use MemberExpression to handle callbacks, e.g. .catch(console.error)
-      MemberExpression(node) {
-        if (node.type === AST_NODE_TYPES.MemberExpression && node.object.type === AST_NODE_TYPES.Identifier && node.object.name === "console" && node.property.type === AST_NODE_TYPES.Identifier) {
-          const logMethodName = node.property.name;
+      Property(node) {
+        if (!isRenderProperty(node)) {
+          return;
+        }
+        const [firstParameter] = node.value.params;
+        if (firstParameter?.type !== AST_NODE_TYPES.Identifier || firstParameter.typeAnnotation === void 0) {
+          return;
+        }
+        context.report({
+          node: firstParameter.typeAnnotation,
+          messageId: "noStoryRenderArgsTypeAnnotation",
+          fix: (fixer) => fixer.remove(firstParameter.typeAnnotation)
+        });
+      }
+    };
+  }
+});
+function isRenderProperty(node) {
+  return node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "render" && (node.value.type === AST_NODE_TYPES.ArrowFunctionExpression || node.value.type === AST_NODE_TYPES.FunctionExpression);
+}
+const description$2 = `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$2,
+      defaultLevel: "warn"
+    },
+    messages: {
+      noTouchingJsDoc: description$2
+    },
+    type: "problem",
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      Program() {
+        Array.from(context.sourceCode.text.matchAll(reTouchingJsDoc), (match) => {
+          const previousJsDocStart = context.sourceCode.text.slice(0, match.index).lastIndexOf("/**");
+          if (previousJsDocStart === -1) {
+            return void 0;
+          }
+          const previousJsDocContent = context.sourceCode.text.slice(
+            previousJsDocStart + "/**".length,
+            match.index - "*/".length
+          );
+          const containsOtherComments = previousJsDocContent.includes("*/");
+          if (containsOtherComments) {
+            return void 0;
+          }
           context.report({
-            node,
-            messageId: "consistentLoggingWarning",
-            data: {
-              logMethodName
+            messageId: "noTouchingJsDoc",
+            loc: {
+              start: context.sourceCode.getLocFromIndex(match.index),
+              end: context.sourceCode.getLocFromIndex(match.index + match[0].length)
             }
           });
-        }
+          return void 0;
+        });
       }
     };
   }
 });
+const reTouchingJsDoc = /\*\/\s+\/\*\*/gu;
 const description$1 = `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/references/api-extractor/tags-reference#link)`;
 plugin.createRule({
   name: "no-unsafe-hash-links",
@@ -272,47 +883,111 @@ function computeReplacement(declareElementsInterface, anchor) {
   const tagName = declaration.key.value;
   return `components/${tagName}#${anchor}`;
 }
-const description = "In Storybook render functions, let `args` infer from `Meta<T>` or `StoryObj<T>` instead of annotating the render parameter.";
 plugin.createRule({
-  name: "no-story-render-args-type-annotation",
+  name: "require-await-for-async-screenshot-assert",
   meta: {
     docs: {
-      description,
-      defaultLevel: "off"
-    },
-    messages: {
-      noStoryRenderArgsTypeAnnotation: "Do not annotate `render(args)` in stories. Type the story with `Meta<T>` or `StoryObj<T>` and let `args` infer from that."
+      description: "Async tests must await a screenshot assertion.",
+      // Enabled by default because it targets a specific pattern and has autofix
+      defaultLevel: "error"
     },
+    messages: { asyncAssert: "Async tests must await a screenshot assertion." },
     schema: [],
-    type: "suggestion",
+    type: "problem",
     fixable: "code"
   },
   defaultOptions: [],
   create(context) {
-    if (!isStorybookFile(context.filename)) {
+    if (!isTestFile(context.filename)) {
       return {};
     }
     return {
-      Property(node) {
-        if (!isRenderProperty(node)) {
-          return;
-        }
-        const [firstParameter] = node.value.params;
-        if (firstParameter?.type !== AST_NODE_TYPES.Identifier || firstParameter.typeAnnotation === void 0) {
-          return;
-        }
+      "CallExpression[callee.name='test'] > ArrowFunctionExpression[async] ExpressionStatement > CallExpression[callee.object.name='assert'][callee.property.name='screenshot']"(node) {
+        const [rangeStart] = node.range;
         context.report({
-          node: firstParameter.typeAnnotation,
-          messageId: "noStoryRenderArgsTypeAnnotation",
-          fix: (fixer) => fixer.remove(firstParameter.typeAnnotation)
+          node,
+          messageId: "asyncAssert",
+          fix: (fixer) => fixer.insertTextBeforeRange([rangeStart - 1, rangeStart], " await")
         });
       }
     };
   }
 });
-function isRenderProperty(node) {
-  return node.key.type === AST_NODE_TYPES.Identifier && node.key.name === "render" && (node.value.type === AST_NODE_TYPES.ArrowFunctionExpression || node.value.type === AST_NODE_TYPES.FunctionExpression);
-}
+plugin.createRule({
+  name: "require-button-type",
+  meta: {
+    docs: {
+      description: "Prevent usage of button elements without an explicit type attribute.",
+      // Disabling by default for now because it found many cases (that
+      // presumably work correctly today) so enabling it is a bit too disruptive.
+      // We should coordinate enabling it with enabling other lint rules to
+      // announce at once.
+      defaultLevel: "off"
+    },
+    messages: { missingType: "An explicit type attribute is required on buttons" },
+    schema: [],
+    type: "problem",
+    fixable: "code"
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      "JSXOpeningElement[name.name='button']"(node) {
+        if (!node.attributes.some((attr) => attr.type === AST_NODE_TYPES.JSXAttribute && attr.name.name === "type")) {
+          context.report({
+            node,
+            messageId: "missingType",
+            fix: (fixer) => fixer.insertTextAfter(node.name, ' type="button"')
+          });
+        }
+      }
+    };
+  }
+});
+const description = `@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,
+      defaultLevel: "warn"
+    },
+    messages: {
+      requireJsInCoreImport: description
+    },
+    type: "problem",
+    fixable: "code",
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    if (isTestFile(context.filename)) {
+      return {};
+    }
+    function updateSpecifier(node) {
+      if (node.source.type !== AST_NODE_TYPES.Literal) {
+        return;
+      }
+      const specifier = node.source.value;
+      const lastSlashIndex = specifier?.toString().lastIndexOf("/") ?? 0;
+      const dotSearchIndex = lastSlashIndex === -1 ? 0 : lastSlashIndex + 1;
+      if (typeof specifier !== "string" || !packagesToEnforce.some((pkg) => specifier.startsWith(pkg)) || // Already ends with .js or .json
+      specifier.includes(".", dotSearchIndex)) {
+        return;
+      }
+      context.report({
+        node: node.source,
+        messageId: "requireJsInCoreImport",
+        fix: (fixer) => fixer.replaceText(node.source, `"${specifier}.js"`)
+      });
+    }
+    return {
+      ImportDeclaration: updateSpecifier,
+      ImportExpression: updateSpecifier
+    };
+  }
+});
 const webgisPlugin = plugin.finalize();
 export {
   webgisPlugin