@arcgis/eslint-config 4.32.0-next.67

package/dist/chunk-D7HD47IC.js

@@ -0,0 +1,974 @@
+import {
+  makeEslintPlugin
+} from "./chunk-C2D6KHIP.js";
+
+// src/plugins/lumina/rules/add-missing-jsx-import.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/utils";
+
+// src/plugins/lumina/utils/creator.ts
+import { ESLintUtils } from "@typescript-eslint/utils";
+var createRule = ESLintUtils.RuleCreator(
+  (rule) => `https://devtopia.esri.com/WebGIS/arcgis-web-components/tree/main/packages/support-packages/eslint-config/src/plugins/lumina/rules/${rule}.ts`
+);
+
+// src/plugins/lumina/utils/estree.ts
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+var unwrapExpression = (expression) => expression.type === AST_NODE_TYPES.TSAsExpression || expression.type === AST_NODE_TYPES.TSNonNullExpression || expression.type === AST_NODE_TYPES.TSSatisfiesExpression ? unwrapExpression(expression.expression) : expression;
+var luminaEntrypointName = "@arcgis/lumina";
+var 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;
+}
+var 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;
+  }
+}
+
+// src/plugins/lumina/rules/add-missing-jsx-import.ts
+var importDeclaration = `import { ${luminaJsxExportName} } from "${luminaEntrypointName}";`;
+var description = `To use Lumina's JSX, you need to ${importDeclaration}`;
+var addMissingJsxImport = createRule({
+  name: "add-missing-jsx-import",
+  meta: {
+    docs: {
+      description
+    },
+    messages: {
+      addMissingJsxImport: description
+    },
+    type: "problem",
+    schema: [],
+    fixable: "code"
+  },
+  defaultOptions: [],
+  create(context) {
+    let errorAlreadyReported = false;
+    let isUsingLumina = false;
+    let lastImportDeclaration;
+    let lastLuminaImportClause;
+    let hasLuminaJsxImport = false;
+    return {
+      ImportDeclaration(node) {
+        lastImportDeclaration = node;
+        if (node.source.value !== luminaEntrypointName) {
+          return;
+        }
+        isUsingLumina = true;
+        const isTypeOnly = node.importKind === "type";
+        for (const specifier of node.specifiers) {
+          if (!isTypeOnly) {
+            lastLuminaImportClause = specifier;
+          }
+          if (specifier.type === AST_NODE_TYPES2.ImportSpecifier && (specifier.imported.type === AST_NODE_TYPES2.Identifier && specifier.imported.name === luminaJsxExportName || specifier.imported.type === AST_NODE_TYPES2.Literal && specifier.imported.value === luminaJsxExportName)) {
+            hasLuminaJsxImport = true;
+            return;
+          }
+        }
+      },
+      JSXIdentifier(node) {
+        if (isUsingLumina && !hasLuminaJsxImport && !errorAlreadyReported) {
+          errorAlreadyReported = true;
+          context.report({
+            messageId: "addMissingJsxImport",
+            node,
+            fix(fixer) {
+              if (lastLuminaImportClause !== void 0) {
+                return fixer.insertTextAfter(lastLuminaImportClause, `, ${luminaJsxExportName}`);
+              }
+              if (lastImportDeclaration !== void 0) {
+                return fixer.insertTextAfter(lastImportDeclaration, importDeclaration);
+              } else {
+                return fixer.insertTextBefore(context.sourceCode.ast, importDeclaration);
+              }
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/plugins/lumina/rules/auto-add-type.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES3, ESLintUtils as ESLintUtils2 } from "@typescript-eslint/utils";
+import ts from "typescript";
+var description2 = "Auto add { type: Boolean } or { type: Number } where necessary";
+var autoAddType = createRule({
+  name: "auto-add-type",
+  meta: {
+    docs: {
+      description: description2
+    },
+    messages: {
+      addType: `This property is of {{ type }} type, yet the type is not trivially inferrable from the AST without type-checking. Such properties require a { type: {{ type }} } annotation.
+
+More information: https://devtopia.esri.com/WebGIS/arcgis-web-components/issues/1991`
+    },
+    type: "problem",
+    schema: [],
+    fixable: "code"
+  },
+  defaultOptions: [],
+  create(context) {
+    const services = ESLintUtils2.getParserServices(context);
+    function checkProperty(node) {
+      const propertyDecorator = node.decorators.find(
+        (decorator) => decorator.expression.type === AST_NODE_TYPES3.CallExpression && decorator.expression.callee.type === AST_NODE_TYPES3.Identifier && decorator.expression.callee.name === "property"
+      );
+      const callExpression = propertyDecorator?.expression.type === AST_NODE_TYPES3.CallExpression ? propertyDecorator.expression : void 0;
+      if (callExpression === void 0) {
+        return;
+      }
+      const trivialType = inferTrivialType(node);
+      if (trivialType === "Number" || trivialType === "Boolean") {
+        return;
+      }
+      const options = callExpression.arguments[0]?.type === AST_NODE_TYPES3.ObjectExpression ? callExpression.arguments[0] : void 0;
+      const properties = options?.properties;
+      const attributeOption = getProperty(properties, "attribute");
+      const isAttributeFalse = attributeOption?.type === AST_NODE_TYPES3.Literal && attributeOption.value === false;
+      if (isAttributeFalse) {
+        return;
+      }
+      const typeProperty = getProperty(properties, "type");
+      if (typeProperty !== void 0) {
+        return;
+      }
+      const type = services.getTypeAtLocation(node);
+      const typeFlags = (type.flags & ts.TypeFlags.Union ? type.types : [type]).reduce(
+        (flags, type2) => flags | type2.flags,
+        0
+      );
+      const isNotCastable = typeFlags & (ts.TypeFlags.String | ts.TypeFlags.Any | ts.TypeFlags.Unknown);
+      if (isNotCastable) {
+        return;
+      }
+      const isNumberType = typeFlags & ts.TypeFlags.NumberLike;
+      const isBooleanType = typeFlags & ts.TypeFlags.BooleanLike;
+      if (!isNumberType && !isBooleanType) {
+        return;
+      }
+      if (isNumberType && isBooleanType) {
+        return;
+      }
+      const comments = context.sourceCode.getCommentsBefore(node);
+      const isDocsOnlyReadOnly = comments.some((comment) => comment.value.includes("@readonly"));
+      const readOnlyProperty = getProperty(properties, "readOnly");
+      const hasReadOnlyFlag = readOnlyProperty?.type === AST_NODE_TYPES3.Literal && readOnlyProperty.value === true;
+      const isReadOnly = isDocsOnlyReadOnly || hasReadOnlyFlag || isGetterWithoutSetter(node);
+      const reflectsProperty = getProperty(properties, "reflects");
+      if (isReadOnly && (!isBooleanType || reflectsProperty?.type !== AST_NODE_TYPES3.Literal || reflectsProperty.value !== true)) {
+        return;
+      }
+      context.report({
+        messageId: "addType",
+        data: {
+          type: isNumberType ? "Number" : "Boolean"
+        },
+        node,
+        fix(fixer) {
+          const sourceCode = context.sourceCode;
+          if (options === void 0) {
+            const token = sourceCode.getTokenAfter(callExpression.callee, {
+              filter: (token2) => token2.value === "("
+            });
+            return fixer.insertTextAfterRange(token.range, `{ type: ${isNumberType ? "Number" : "Boolean"} }`);
+          } else if (options.properties.length === 0) {
+            return fixer.replaceTextRange(options.range, `{ type: ${isNumberType ? "Number" : "Boolean"} }`);
+          } else {
+            return fixer.insertTextBefore(options.properties[0], `type: ${isNumberType ? "Number" : "Boolean"}, `);
+          }
+        }
+      });
+    }
+    return {
+      PropertyDefinition(node) {
+        checkProperty(node);
+      },
+      MethodDefinition(node) {
+        checkProperty(node);
+      }
+    };
+  }
+});
+function inferTrivialType(member) {
+  const type = member.type === AST_NODE_TYPES3.PropertyDefinition ? member.typeAnnotation?.typeAnnotation : member.type === AST_NODE_TYPES3.MethodDefinition && member.kind === "set" ? member.value.params[0]?.typeAnnotation?.typeAnnotation : member.type === AST_NODE_TYPES3.MethodDefinition && member.kind === "get" ? member.value.returnType?.typeAnnotation : void 0;
+  if (type === void 0) {
+    if (member.value?.type === AST_NODE_TYPES3.Literal && typeof member.value.value === "number" || member.value?.type === AST_NODE_TYPES3.UnaryExpression && member.value.argument.type === AST_NODE_TYPES3.Literal && typeof member.value.argument.value === "number" && member.value.operator === "-") {
+      return "Number";
+    }
+    if (member.value?.type === AST_NODE_TYPES3.Literal && typeof member.value.value === "boolean") {
+      return "Boolean";
+    }
+  } else if (type.type === AST_NODE_TYPES3.TSNumberKeyword) {
+    return "Number";
+  } else if (type.type === AST_NODE_TYPES3.TSBooleanKeyword) {
+    return "Boolean";
+  }
+  return "Other";
+}
+
+// src/plugins/lumina/rules/component-placement-rules.ts
+var description3 = `Lumina component must be declared in a TSX file with a matching folder name located inside of src/components folder.`;
+var componentPlacementRules = createRule({
+  name: "component-placement-rules",
+  meta: {
+    docs: {
+      description: description3
+    },
+    messages: {
+      fileFolderNameMismatch: "Lumina component must be declared in a file whose name (without extension) matches the parent folder name.\n\nCreating components in nested folders is supported as long as the file name matches the immediate parent folder name.",
+      extensionNotTsx: "Lumina component must be declared in a .tsx file.",
+      noComponentOutsideSrcComponents: "All lumina components must be declared within the src/components folder. Inside that folder, you can create sub-folders for structuring component files."
+    },
+    type: "problem",
+    schema: [],
+    fixable: "code"
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      TSModuleDeclaration(node) {
+        const luminaDeclarationInterface = extractDeclareElementsInterface(node);
+        if (luminaDeclarationInterface === void 0) {
+          return;
+        }
+        const filePath = context.filename;
+        const containsSrcComponents = filePath.includes("/src/components/");
+        if (!containsSrcComponents) {
+          context.report({ messageId: "noComponentOutsideSrcComponents", node: luminaDeclarationInterface });
+        }
+        const isFileExtensionTsx = filePath.endsWith(".tsx");
+        if (!isFileExtensionTsx) {
+          context.report({ messageId: "extensionNotTsx", node: luminaDeclarationInterface });
+          return;
+        }
+        const pathParts = filePath.split("/");
+        const folderName = pathParts.at(-2);
+        const fileName = pathParts.at(-1).slice(0, -".tsx".length);
+        if (folderName !== fileName) {
+          context.report({ messageId: "fileFolderNameMismatch", node: luminaDeclarationInterface });
+        }
+      }
+    };
+  }
+});
+
+// src/plugins/lumina/rules/consistent-event-naming.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES4 } from "@typescript-eslint/utils";
+var description4 = `Enforce consistent event naming.`;
+var defaultOptions = [
+  {
+    eventNamespaces: ["arcgis"],
+    includeComponentNameInEventName: false
+  }
+];
+var consistentEventNaming = createRule({
+  name: "consistent-event-naming",
+  meta: {
+    docs: {
+      description: description4
+    },
+    messages: {
+      eventNamespaceError: `Custom event name must start with one of the following prefixes: {{ prefixes }}.
+
+Details: https://qawebgis.esri.com/components/lumina/events#best-practices-around-emitting-events`,
+      componentNameInEventError: `For consistency, event name should not start with component name.
+
+Discussion: https://devtopia.esri.com/WebGIS/arcgis-web-components/discussions/307`,
+      noComponentNameInEventError: `For consistency, event name should include component name.`,
+      missingPrivateJsDocTag: `Internal and private events must be marked with @internal or @private JSDoc tag.`
+    },
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          eventNamespaces: {
+            type: "array",
+            items: {
+              type: "string"
+            }
+          },
+          includeComponentNameInEventName: {
+            type: "boolean"
+          }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  defaultOptions,
+  create(context, options) {
+    const eventNamespaces = options[0].eventNamespaces;
+    const includeComponentNameInEventName = options[0].includeComponentNameInEventName;
+    return {
+      PropertyDefinition(node) {
+        const isLuminaEvent = isCreateEvent(node);
+        if (!isLuminaEvent) {
+          return;
+        }
+        const comments = context.sourceCode.getCommentsBefore(node);
+        const isDeprecated = comments.some((comment) => comment.value.includes("@deprecated"));
+        if (isDeprecated) {
+          return;
+        }
+        const componentName = context.sourceCode.getAncestors(node).find((ancestor) => ancestor.type === AST_NODE_TYPES4.ClassDeclaration)?.id?.name;
+        if (componentName === void 0) {
+          return;
+        }
+        const propertyName = node.key.type === AST_NODE_TYPES4.Identifier ? node.key.name : node.key.type === AST_NODE_TYPES4.Literal ? node.key.value : void 0;
+        if (typeof propertyName !== "string") {
+          return;
+        }
+        let eventName = propertyName;
+        if (eventNamespaces.length > 0) {
+          const currentNamespace = eventNamespaces.find((namespace) => eventName.startsWith(namespace));
+          if (currentNamespace === void 0) {
+            context.report({
+              messageId: "eventNamespaceError",
+              data: {
+                prefixes: eventNamespaces.join(", ")
+              },
+              node: node.key
+            });
+            return;
+          }
+          eventName = eventName.slice(currentNamespace.length);
+        }
+        const startsWithInternal = eventName.toLowerCase().startsWith("internal");
+        if (startsWithInternal || eventName.toLowerCase().startsWith("private")) {
+          const hasInternalJsDocTag = comments.some((comment) => comment.value.includes("@internal"));
+          const hasPrivateJsDocTag = comments.some((comment) => comment.value.includes("@private"));
+          if (!hasInternalJsDocTag && !hasPrivateJsDocTag) {
+            context.report({
+              messageId: "missingPrivateJsDocTag",
+              node: node.key
+            });
+          }
+          eventName = startsWithInternal ? eventName.slice("internal".length) : eventName.slice("private".length);
+        }
+        const capitalIndex = capitalAfterLower.exec(componentName)?.index;
+        const unNamespacedComponentName = capitalIndex === void 0 ? void 0 : componentName.slice(capitalIndex) || void 0;
+        const includesComponentName = eventName.startsWith(componentName) || unNamespacedComponentName !== void 0 && eventName.startsWith(unNamespacedComponentName);
+        if (includeComponentNameInEventName && !includesComponentName) {
+          context.report({
+            messageId: "noComponentNameInEventError",
+            node: node.key
+          });
+        } else if (!includeComponentNameInEventName && includesComponentName) {
+          context.report({
+            messageId: "componentNameInEventError",
+            node: node.key
+          });
+        }
+      }
+    };
+  }
+});
+var capitalAfterLower = /(?<=[a-z\d])[A-Z]/u;
+
+// src/plugins/lumina/rules/decorators-context.ts
+var description5 = `Enforce that @property(), @method() and createEvent() members are used in the correct context.`;
+var decoratorsContext = createRule({
+  name: "decorators-context",
+  meta: {
+    docs: {
+      description: description5
+    },
+    messages: {
+      publicApiMustBePublic: `@property(), @method() and createEvent() members must not have private or protected modifier.
+      
+If you wish to hide this member from public documentation, use @private or @protected JSDoc tags instead. Documentation: https://qawebgis.esri.com/components/lumina/documenting-components#excluding-api-from-public-documentation`,
+      noPropertyDecoratorOnMethods: `Methods must not have @property() nor @state() decorator. Did you mean @property() instead?`,
+      noCombinedPropertyEvent: `Property may either be an event (initialized with createEvent()) or a property (has @property() decorator), but not both`
+    },
+    type: "problem",
+    schema: [],
+    fixable: "code"
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      PropertyDefinition(node) {
+        const hasPropertyDecorator = hasDecorator(node, "property");
+        const isPrivateOrProtected = node.accessibility === "private" || node.accessibility === "protected";
+        if (hasPropertyDecorator && isPrivateOrProtected) {
+          context.report({ messageId: "publicApiMustBePublic", node });
+        }
+        const isLuminaEvent = isCreateEvent(node);
+        if (isLuminaEvent && isPrivateOrProtected) {
+          context.report({ messageId: "publicApiMustBePublic", node });
+        }
+        if (isLuminaEvent && hasPropertyDecorator) {
+          context.report({ messageId: "noCombinedPropertyEvent", node });
+        }
+      },
+      MethodDefinition(node) {
+        const hasMethodDecorator = hasDecorator(node, "method");
+        const hasPropertyDecorator = hasDecorator(node, "property");
+        const hasStateDecorator = hasDecorator(node, "state");
+        const isPrivateOrProtected = node.accessibility === "private" || node.accessibility === "protected";
+        if (hasMethodDecorator && isPrivateOrProtected) {
+          context.report({ messageId: "publicApiMustBePublic", node });
+        }
+        const isRealMethod = node.kind === "method";
+        if (isRealMethod && (hasPropertyDecorator || hasStateDecorator)) {
+          context.report({ messageId: "noPropertyDecoratorOnMethods", node });
+        }
+      }
+    };
+  }
+});
+
+// src/plugins/lumina/rules/no-ignore-jsdoc-tag.ts
+var description6 = `Use @internal or @private JSDoc tag over @ignore. See https://qawebgis.esri.com/components/lumina/documenting-components#excluding-api-from-public-documentation`;
+var noIgnoreJsDocTag = createRule({
+  name: "no-ignore-jsdoc-tag",
+  meta: {
+    docs: {
+      description: description6
+    },
+    messages: {
+      noIgnoreJsDocTag: description6
+    },
+    type: "problem",
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const luminaJsxCheck = checkForLuminaJsx();
+    return {
+      "ImportDeclaration": luminaJsxCheck,
+      "Program:exit"() {
+        if (!luminaJsxCheck.isLuminaJsx) {
+          return;
+        }
+        Array.from(context.sourceCode.text.matchAll(reIgnore), (match) => {
+          context.report({
+            messageId: "noIgnoreJsDocTag",
+            loc: {
+              start: context.sourceCode.getLocFromIndex(match.index + "* ".length),
+              end: context.sourceCode.getLocFromIndex(match.index + match[0].length)
+            }
+          });
+        });
+      }
+    };
+  }
+});
+var reIgnore = /\* @ignore/gu;
+
+// src/plugins/lumina/rules/no-incorrect-dynamic-tag-name.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES5, ESLintUtils as ESLintUtils3 } from "@typescript-eslint/utils";
+import ts2 from "typescript";
+var description7 = `Detect incorrect usage of dynamic JSX tag name`;
+var noIncorrectDynamicTagName = createRule({
+  name: "no-incorrect-dynamic-tag-name",
+  meta: {
+    docs: {
+      description: description7
+    },
+    messages: {
+      incorrectDynamicTagName: `This is using incorrect dynamic tag name syntax. See documentation on how to use dynamic tag in Lumina's JSX: https://qawebgis.esri.com/components/lumina/jsx#dynamic-tag-name`
+    },
+    type: "problem",
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const services = ESLintUtils3.getParserServices(context);
+    const luminaJsxCheck = checkForLuminaJsx();
+    return {
+      ImportDeclaration: luminaJsxCheck,
+      JSXIdentifier(node) {
+        if (!luminaJsxCheck.isLuminaJsx) {
+          return;
+        }
+        const isInTagName = node.parent?.type !== AST_NODE_TYPES5.JSXAttribute;
+        if (!isInTagName) {
+          return;
+        }
+        const isCapitalized = !node.name.startsWith(node.name.charAt(0).toLowerCase());
+        if (!isCapitalized) {
+          return;
+        }
+        const isCorrectDynamicTagName = node.name === "DynamicHtmlTag" || node.name === "DynamicSvgTag";
+        if (isCorrectDynamicTagName) {
+          return;
+        }
+        const type = services.getTypeAtLocation(node);
+        const isStringType = type.flags & ts2.TypeFlags.StringLike;
+        if (isStringType) {
+          context.report({
+            messageId: "incorrectDynamicTagName",
+            node
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/plugins/lumina/rules/no-inline-arrow-in-ref.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES6 } from "@typescript-eslint/utils";
+var baseDescription = `Do not pass an inline arrow function to a ref prop - such syntax creates a new function on each render, which makes Lit call ref callback again on each render.`;
+var description8 = `${baseDescription}
+
+Alternatives: https://qawebgis.esri.com/components/lumina/jsx#refs`;
+var noInlineArrowInRef = createRule({
+  name: "no-inline-arrow-in-ref",
+  meta: {
+    docs: {
+      description: baseDescription
+    },
+    messages: {
+      errorInlineArrow: description8
+    },
+    type: "problem",
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const luminaJsxCheck = checkForLuminaJsx();
+    return {
+      ImportDeclaration: luminaJsxCheck,
+      JSXAttribute(node) {
+        if (!luminaJsxCheck.isLuminaJsx || node.name.name !== "ref" || node.value?.type !== AST_NODE_TYPES6.JSXExpressionContainer) {
+          return;
+        }
+        const initializer = node.value.expression;
+        if (initializer.type !== AST_NODE_TYPES6.ArrowFunctionExpression && initializer.type !== AST_NODE_TYPES6.FunctionExpression) {
+          return;
+        }
+        context.report({
+          messageId: "errorInlineArrow",
+          node: initializer
+        });
+      }
+    };
+  }
+});
+
+// src/plugins/lumina/rules/no-listen-in-connected-callback.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES7 } from "@typescript-eslint/utils";
+var baseDescription2 = `Do not call this.listen()/this.listenOn() in connectedCallback.`;
+var description9 = `${baseDescription2}
+
+Instead, call this.listen()/this.listenOn() in constructor(), load() or loaded().
+
+Reason:
+this.listen() automatically creates and cleanups the listener on connect/disconnect.
+Since connectedCallback can be called multiple times, duplicate listeners may be created.`;
+var noListenInConnectedCallback = createRule({
+  name: "no-listen-in-connected-callback",
+  meta: {
+    docs: {
+      description: baseDescription2
+    },
+    messages: {
+      errorListenInConnectedCallback: description9
+    },
+    type: "problem",
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      CallExpression(node) {
+        const isListenCall = node.callee.type === AST_NODE_TYPES7.MemberExpression && node.callee.object.type === AST_NODE_TYPES7.ThisExpression && node.callee.property.type === AST_NODE_TYPES7.Identifier && (node.callee.property.name === "listen" || node.callee.property.name === "listenOn");
+        if (!isListenCall) {
+          return;
+        }
+        let hasConnectedCallbackParent = false;
+        let currentParent = node.parent;
+        while (currentParent) {
+          if (currentParent.type === AST_NODE_TYPES7.MethodDefinition) {
+            if (currentParent.key.type === AST_NODE_TYPES7.Identifier && currentParent.key.name === "connectedCallback") {
+              hasConnectedCallbackParent = true;
+            }
+            break;
+          }
+          currentParent = currentParent.parent;
+        }
+        if (!hasConnectedCallbackParent) {
+          return;
+        }
+        context.report({
+          messageId: "errorListenInConnectedCallback",
+          node
+        });
+      }
+    };
+  }
+});
+
+// src/plugins/lumina/rules/no-needless-bind-this.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES8 } from "@typescript-eslint/utils";
+var description10 = `.bind(this) is not necessary in Lit's event listener callbacks and ref callbacks as it is handled automatically.`;
+var noNeedlessBindThis = createRule({
+  name: "no-needless-bind-this",
+  meta: {
+    docs: {
+      description: description10
+    },
+    messages: {
+      noNeedlessBindThis: description10
+    },
+    type: "problem",
+    schema: [],
+    fixable: "code"
+  },
+  defaultOptions: [],
+  create(context) {
+    const luminaJsxCheck = checkForLuminaJsx();
+    return {
+      ImportDeclaration: luminaJsxCheck,
+      JSXExpressionContainer(node) {
+        if (!luminaJsxCheck.isLuminaJsx || node.parent.type !== AST_NODE_TYPES8.JSXAttribute || node.parent.name.type !== AST_NODE_TYPES8.JSXIdentifier) {
+          return;
+        }
+        const name = node.parent.name.name;
+        const isAutoBindable = name.startsWith("on") || name === "ref";
+        if (!isAutoBindable) {
+          return;
+        }
+        const expression = node.expression.type === AST_NODE_TYPES8.ChainExpression ? node.expression.expression : node.expression;
+        const isCallWithThis = (
+          // expression(...)
+          expression.type === AST_NODE_TYPES8.CallExpression && // expression(expression)
+          expression.arguments.length === 1 && // expression(this)
+          expression.arguments[0].type === AST_NODE_TYPES8.ThisExpression
+        );
+        if (!isCallWithThis) {
+          return;
+        }
+        const callee = expression.callee;
+        const isBindThisCall = (
+          // expression.expression(this)
+          callee.type === AST_NODE_TYPES8.MemberExpression && // expression.identifier(this)
+          callee.property.type === AST_NODE_TYPES8.Identifier && // expression.bind(this)
+          callee.property.name === "bind" && // expression.expression.bind(this)
+          callee.object.type === AST_NODE_TYPES8.MemberExpression && // expression.identifier.bind(this)
+          callee.object.property.type === AST_NODE_TYPES8.Identifier && // this.identifier.bind(this)
+          callee.object.object.type === AST_NODE_TYPES8.ThisExpression
+        );
+        if (!isBindThisCall) {
+          return;
+        }
+        const tagName = context.sourceCode.getAncestors(node.parent).find((ancestor) => ancestor.type === AST_NODE_TYPES8.JSXOpeningElement)?.name;
+        const tagNameString = tagName?.type === AST_NODE_TYPES8.JSXIdentifier ? tagName.name : void 0;
+        if (tagNameString === void 0) {
+          return;
+        }
+        const isHtmlElement = tagNameString.startsWith(tagNameString.charAt(0).toLowerCase()) || tagNameString === "DynamicHtmlTag" || tagNameString === "DynamicSvgTag";
+        if (!isHtmlElement) {
+          return;
+        }
+        context.report({
+          messageId: "noNeedlessBindThis",
+          node: callee.property,
+          fix(fixer) {
+            return fixer.replaceText(expression, context.sourceCode.getText(callee.object));
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/plugins/lumina/rules/no-property-name-start-with-on.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES9 } from "@typescript-eslint/utils";
+var description11 = `Do not start public property names with "on" as that can confuse frameworks into thinking this property is an event`;
+var noPropertyNameStartWithOn = createRule({
+  name: "no-property-name-start-with-on",
+  meta: {
+    docs: {
+      description: description11
+    },
+    messages: {
+      noPropertyNameStartWithOn: description11
+    },
+    type: "problem",
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      PropertyDefinition(node) {
+        const isPublicProperty = hasDecorator(node, "property");
+        if (!isPublicProperty) {
+          return;
+        }
+        const propertyName = node.key.type === AST_NODE_TYPES9.Identifier ? node.key.name : node.key.type === AST_NODE_TYPES9.Literal ? node.key.value : void 0;
+        if (typeof propertyName !== "string") {
+          return;
+        }
+        if (!propertyName.startsWith("on")) {
+          return;
+        }
+        const comments = context.sourceCode.getCommentsBefore(node);
+        const isDeprecated = comments.some((comment) => comment.value.includes("@deprecated"));
+        if (isDeprecated) {
+          return;
+        }
+        context.report({
+          messageId: "noPropertyNameStartWithOn",
+          node: node.key
+        });
+      }
+    };
+  }
+});
+
+// src/plugins/lumina/rules/no-render-false.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES10, ESLintUtils as ESLintUtils4 } from "@typescript-eslint/utils";
+
+// src/plugins/lumina/utils/checker.ts
+import ts3 from "typescript";
+var litTemplateResult = "TemplateResult";
+var explicitJsxTypeName = "JsxNode";
+var implicitJsxTypeName = "Element";
+var implicitJsxParentName = "LuminaJsx";
+function isLuminaJsxType(type) {
+  for (const declaration of type.aliasSymbol?.declarations ?? []) {
+    if (!ts3.isTypeAliasDeclaration(declaration)) {
+      continue;
+    }
+    const typeName = declaration.name.escapedText;
+    if (typeName === litTemplateResult || typeName === explicitJsxTypeName) {
+      return true;
+    }
+    if (typeName !== implicitJsxTypeName) {
+      continue;
+    }
+    const grandParent = declaration.parent?.parent;
+    if (!ts3.isModuleDeclaration(grandParent)) {
+      continue;
+    }
+    const symbol = grandParent.symbol;
+    if (symbol?.escapedName === implicitJsxParentName) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// src/plugins/lumina/rules/no-render-false.ts
+var baseDescription3 = `Avoid accidentally rendering "false" to the screen (Lit stringifies booleans, rather than drop them like React/Stencil).`;
+var description12 = `${baseDescription3}
+
+Lumina automatically handles some cases where "false" may get rendered to the screen, but the pattern this code is using is not handled.`;
+var noRenderFalse = createRule({
+  name: "no-render-false",
+  meta: {
+    docs: {
+      description: baseDescription3
+    },
+    messages: {
+      errorFalseRendered: description12
+    },
+    type: "problem",
+    schema: [],
+    fixable: "code"
+  },
+  defaultOptions: [],
+  create(context) {
+    const services = ESLintUtils4.getParserServices(context);
+    return {
+      LogicalExpression(node) {
+        if (node.operator !== "&&") {
+          return;
+        }
+        const type = services.getTypeAtLocation(node.right);
+        if (!isLuminaJsxType(type)) {
+          return;
+        }
+        if (node.parent.type === AST_NODE_TYPES10.JSXExpressionContainer) {
+          return;
+        }
+        const right = unwrapExpression(node.right);
+        if (right.type === AST_NODE_TYPES10.JSXElement) {
+          return;
+        }
+        if (node.parent.type === AST_NODE_TYPES10.LogicalExpression) {
+          return;
+        }
+        context.report({
+          messageId: "errorFalseRendered",
+          node,
+          fix(fixer) {
+            const leftText = context.sourceCode.getText(node.left);
+            const rightText = context.sourceCode.getText(node.right);
+            const replacement = `${leftText} ? ${rightText} : ""`;
+            return fixer.replaceText(node, replacement);
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/plugins/lumina/rules/tag-name-rules.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES11 } from "@typescript-eslint/utils";
+var description13 = `Require tag names to start with a given namespace`;
+var defaultOptions2 = [
+  {
+    namespaces: ["arcgis-"]
+  }
+];
+var tagNameRules = createRule({
+  name: "tag-name-rules",
+  meta: {
+    docs: {
+      description: description13
+    },
+    messages: {
+      requireNamespace: "Custom element tag names in this project must start with one of the following namespaces: {{namespaces}}",
+      noComputedTagName: "Computed tag names are not allowed",
+      noNonStringTagName: 'Tag names must be strings like "arcgis-click" rather than numbers',
+      noTagNameIdentifier: "Tag name must include a dash",
+      unexpectedDeclareElementsEntry: "Unexpected entry in declare elements interface. Expected a property signature"
+    },
+    type: "problem",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          namespaces: {
+            type: "array",
+            items: {
+              type: "string"
+            }
+          }
+        },
+        additionalProperties: false
+      }
+    ],
+    fixable: "code"
+  },
+  defaultOptions: defaultOptions2,
+  create(context, options) {
+    return {
+      TSModuleDeclaration(node) {
+        const luminaDeclarationInterface = extractDeclareElementsInterface(node);
+        if (luminaDeclarationInterface === void 0) {
+          return;
+        }
+        luminaDeclarationInterface.body.body.forEach((member) => {
+          if (member.type !== AST_NODE_TYPES11.TSPropertySignature) {
+            context.report({
+              messageId: "unexpectedDeclareElementsEntry",
+              node: member
+            });
+            return;
+          }
+          if (member.computed) {
+            context.report({
+              messageId: "noComputedTagName",
+              node: member.key
+            });
+            return;
+          }
+          if (member.key.type === AST_NODE_TYPES11.Identifier) {
+            context.report({
+              messageId: "noTagNameIdentifier",
+              node: member.key
+            });
+            return;
+          }
+          if (typeof member.key.value !== "string") {
+            context.report({
+              messageId: "noNonStringTagName",
+              node: member.key
+            });
+            return;
+          }
+          const tagName = member.key.value;
+          const namespaces = options[0].namespaces;
+          if (namespaces.length > 0 && !namespaces.some((ns) => tagName.startsWith(ns))) {
+            context.report({
+              messageId: "requireNamespace",
+              node: member.key,
+              data: {
+                namespaces: namespaces.join(", ")
+              }
+            });
+          }
+        });
+      }
+    };
+  }
+});
+
+// src/plugins/lumina/index.ts
+var lumina_default = makeEslintPlugin("lumina", {
+  "add-missing-jsx-import": addMissingJsxImport,
+  "auto-add-type": autoAddType,
+  "component-placement-rules": componentPlacementRules,
+  "consistent-event-naming": consistentEventNaming,
+  "decorators-context": decoratorsContext,
+  "no-ignore-jsdoc-tag": noIgnoreJsDocTag,
+  "no-incorrect-dynamic-tag-name": noIncorrectDynamicTagName,
+  "no-inline-arrow-in-ref": noInlineArrowInRef,
+  "no-listen-in-connected-callback": noListenInConnectedCallback,
+  "no-needless-bind-this": noNeedlessBindThis,
+  "no-property-name-start-with-on": noPropertyNameStartWithOn,
+  "no-render-false": noRenderFalse,
+  "tag-name-rules": tagNameRules
+});
+
+export {
+  lumina_default
+};