@arcgis/eslint-config 4.32.0-next.73 → 4.32.0-next.75

package/dist/{chunk-ANTZSLIJ.js → chunk-2NFXJSOF.js}

@@ -1,6 +1,6 @@
 import {
   makeEslintPlugin
-} from "./chunk-2QEPVXNZ.js";
+} from "./chunk-7G6OXZK7.js";
 
 // src/plugins/lumina/rules/add-missing-jsx-import.ts
 import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/utils";
@@ -100,7 +100,8 @@ var addMissingJsxImport = createRule({
   name: "add-missing-jsx-import",
   meta: {
     docs: {
-      description
+      description,
+      defaultLevel: "error"
     },
     messages: {
       addMissingJsxImport: description
@@ -165,7 +166,8 @@ var autoAddType = createRule({
   name: "auto-add-type",
   meta: {
     docs: {
-      description: description2
+      description: description2,
+      defaultLevel: "warn"
     },
     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.
@@ -368,7 +370,8 @@ var componentPlacementRules = createRule({
   name: "component-placement-rules",
   meta: {
     docs: {
-      description: description3
+      description: description3,
+      defaultLevel: "error"
     },
     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.",
@@ -421,7 +424,8 @@ var consistentEventNaming = createRule({
   name: "consistent-event-naming",
   meta: {
     docs: {
-      description: description4
+      description: description4,
+      defaultLevel: "warn"
     },
     messages: {
       eventNamespaceError: `Custom event name must start with one of the following prefixes: {{ prefixes }}.
@@ -528,7 +532,8 @@ var decoratorsContext = createRule({
   name: "decorators-context",
   meta: {
     docs: {
-      description: description5
+      description: description5,
+      defaultLevel: "error"
     },
     messages: {
       publicApiMustBePublic: `@property(), @method() and createEvent() members must not have private or protected modifier.
@@ -594,13 +599,425 @@ If you wish to hide this member from public documentation, use @private or @prot
   }
 });
 
+// src/plugins/lumina/rules/member-ordering.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES7 } from "@typescript-eslint/utils";
+
+// src/plugins/lumina/rules/member-ordering/config.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES5 } from "@typescript-eslint/utils";
+var ordering = [
+  /*
+   * Putting static before instance members is a common OOP convention.
+   * Static members are always evaluated before instance members.
+   */
+  "Static Members",
+  /**
+   * Put private properties before public, because private properties are
+   * often used as a default value for public properties.
+   */
+  "Private Properties",
+  /**
+   * Put private properties before public, because private properties are often
+   * used as a default value for public properties.
+   */
+  "State Properties",
+  /*
+   * Properties are the key component API. Also, since default values of
+   * properties evaluate before the constructor, they should logically be before
+   * the constructor.
+   */
+  "Public Properties",
+  /*
+   * Methods should be a supplementary component API, not primary, so are listed
+   * after properties. At the same time, it is nice to keep public component API
+   * all in one place.
+   */
+  "Public Methods",
+  /*
+   * Put events near properties and methods to keep all public component API in
+   * one place.
+   */
+  "Events",
+  /*
+   * Lifecycle methods like constructor and connectedCallback are executed
+   * after all properties have default values, but before any render functions.
+   */
+  "Lifecycle",
+  /*
+   * Private methods in between lifecycles and rendering as they are often
+   * called by either of them.
+   */
+  "Private Methods",
+  /*
+   * Fred:
+   * The reason rendering methods are at the bottom of my modules because I can
+   * quickly jump to the bottom find the rendering method and work on it. Less
+   * scrolling.
+   * Once a module has been implemented, most of the bugs/enhancements occur in
+   * the rendering methods.
+   */
+  "Rendering"
+];
+var getWireframe = () => new Map(ordering.map((region) => [region, []]));
+var entries = Object.entries;
+var regionMatchers = entries({
+  "Static Members": (node) => node.type === AST_NODE_TYPES5.StaticBlock || "static" in node && node.static,
+  "Lifecycle": (_node, name) => lifecyclesSet.has(name),
+  "Public Methods": (node) => "decorators" in node && hasDecorator(node, "method"),
+  "Public Properties": (node) => "decorators" in node && hasDecorator(node, "property"),
+  "State Properties": (node) => "decorators" in node && hasDecorator(node, "state"),
+  "Events": isEvent,
+  "Rendering": (_node, name) => name.startsWith("render") || name.startsWith("_render"),
+  "Private Properties": (node) => (
+    // We don't yet support public accessor properties
+    node.type === AST_NODE_TYPES5.PropertyDefinition || node.type === AST_NODE_TYPES5.AccessorProperty
+  ),
+  "Private Methods": () => true
+});
+var definitelyComponentRegions = /* @__PURE__ */ new Set([
+  "Rendering",
+  "State Properties",
+  "Public Methods",
+  "Events"
+]);
+var regionsArray = regionMatchers.map(([key]) => key);
+function isEvent(node, name) {
+  if (node.type !== AST_NODE_TYPES5.PropertyDefinition) {
+    return false;
+  }
+  if (name === "arcgisPropertyChange") {
+    return true;
+  }
+  const initializer = node.value;
+  if (initializer?.type !== AST_NODE_TYPES5.CallExpression) {
+    return false;
+  }
+  const callExpression = initializer.callee;
+  const functionName = callExpression.type === AST_NODE_TYPES5.Identifier ? callExpression.name : callExpression.type === AST_NODE_TYPES5.CallExpression && callExpression.callee.type === AST_NODE_TYPES5.Identifier ? callExpression.callee.name : void 0;
+  return functionName === "createEvent" || functionName === "reEmitEvent" || functionName === "usePropertyChange";
+}
+var lifecycles = [
+  "constructor",
+  "connectedCallback",
+  "load",
+  "shouldUpdate",
+  // Not an actual lifecycle method, but can be temporary inserted by the codemod
+  "_shouldUpdate",
+  "willUpdate",
+  "update",
+  "firstUpdated",
+  "updated",
+  "loaded",
+  "disconnectedCallback"
+];
+var lifecyclesSet = new Set(lifecycles);
+var supportedNodeTypes = {
+  MethodDefinition: true,
+  PropertyDefinition: true,
+  AccessorProperty: true,
+  StaticBlock: true,
+  // These should not be present in non-abstract Lumina component classes
+  TSAbstractAccessorProperty: false,
+  TSAbstractMethodDefinition: false,
+  TSAbstractPropertyDefinition: false,
+  TSIndexSignature: false
+};
+
+// src/plugins/lumina/rules/member-ordering/comments.ts
+import { AST_TOKEN_TYPES } from "@typescript-eslint/utils";
+function categorizeComments(membersData, sourceCode) {
+  const categorized = {
+    header: [],
+    regionFooter: /* @__PURE__ */ new Map(),
+    memberLineEnd: /* @__PURE__ */ new Map(),
+    footer: [],
+    membersByName: /* @__PURE__ */ new Map()
+  };
+  let regionName;
+  membersData.forEach((memberData, index) => {
+    const nameNodes = categorized.membersByName.get(memberData.name);
+    if (nameNodes !== void 0) {
+      nameNodes.push(memberData);
+    } else {
+      categorized.membersByName.set(memberData.name, [memberData]);
+    }
+    memberData.comments = handleLineEndComment(memberData.comments, membersData.at(index - 1), categorized);
+    let newRegionName;
+    const lastRegionStart = memberData.comments.findLastIndex((comment) => {
+      const match = parseRegionComment(comment);
+      const isRegionStart = match !== void 0 && match.end === void 0;
+      newRegionName = match?.name;
+      return isRegionStart;
+    });
+    if (lastRegionStart !== -1) {
+      const commentsBeforeNewRegionStart = memberData.comments.slice(0, lastRegionStart);
+      const previousMember = membersData.at(index - 1);
+      handleCommentsAroundEndRegion(
+        commentsBeforeNewRegionStart,
+        false,
+        previousMember ?? memberData,
+        categorized,
+        regionName
+      );
+      memberData.comments = memberData.comments.slice(lastRegionStart + 1);
+      regionName = newRegionName;
+    }
+    const isLastNode = index === membersData.length - 1;
+    if (isLastNode) {
+      const trailingComments = sourceCode.getCommentsAfter(memberData.member);
+      const remainingTrailingComments = handleLineEndComment(trailingComments, memberData, categorized);
+      const previousMember = membersData.at(index - 1);
+      handleCommentsAroundEndRegion(
+        remainingTrailingComments,
+        true,
+        previousMember ?? memberData,
+        categorized,
+        regionName
+      );
+    }
+  });
+  return categorized;
+}
+function handleLineEndComment(comments, previousNode, categorized) {
+  if (comments.at(0)?.loc.start.line === previousNode?.member.loc.end.line) {
+    categorized.memberLineEnd.set(previousNode, comments.slice(0, 1));
+    return comments.slice(1);
+  }
+  return comments;
+}
+function handleCommentsAroundEndRegion(commentsBeforeNewRegionStart, isFooter, lastMember, categorized, regionName) {
+  if (regionName === void 0) {
+    const destination = isFooter ? categorized.footer : categorized.header;
+    destination.push(...commentsBeforeNewRegionStart);
+  } else {
+    const firstEndRegion = commentsBeforeNewRegionStart.findIndex(
+      (comment) => parseRegionComment(comment)?.end !== void 0
+    );
+    let previousRegionComments = commentsBeforeNewRegionStart;
+    if (firstEndRegion !== -1) {
+      categorized.footer.push(...commentsBeforeNewRegionStart.slice(firstEndRegion + 1));
+      previousRegionComments = commentsBeforeNewRegionStart.slice(0, firstEndRegion);
+    }
+    const existingFooter = categorized.regionFooter.get(regionName);
+    if (existingFooter === void 0) {
+      categorized.regionFooter.set(regionName, { comments: Array.from(previousRegionComments), lastMember });
+    } else {
+      existingFooter.comments.push(...previousRegionComments);
+    }
+  }
+}
+var normalizeComments = (comments = [], sourceCode, indent = "  ") => comments.filter((comment) => parseRegionComment(comment) === void 0).map((comment) => `${indent}${sourceCode.getText(comment)}`).join("\n").replaceAll(reJsApiSectionComment, "");
+var join = (left, right, joiner = "\n\n") => left === "" || right === "" ? right || left : `${left}${joiner}${right}`;
+var reRegionComment = /^ ?#(?<end>end)?region ?(?<name>[^\n]*)$/u;
+var parseRegionComment = (comment) => comment.type === AST_TOKEN_TYPES.Line ? reRegionComment.exec(comment.value)?.groups : void 0;
+var reJsApiSectionComment = /^  \/\/ ?-{4,}\n(?:  \/\/\s*\n)?  \/\/\s+[^\s][^\n]+\n(?:  \/\/\s*\n)?  \/\/ ?-{4,}/gmu;
+
+// src/plugins/lumina/rules/member-ordering/normalize.ts
+import { AST_NODE_TYPES as AST_NODE_TYPES6 } from "@typescript-eslint/utils";
+function getNormalizedRegions(membersByName) {
+  const regions = getWireframe();
+  membersByName.values().forEach((members) => {
+    const lowestRegionIndex = members.reduce(
+      (min, { region }) => Math.min(min, regionsArray.indexOf(region)),
+      Number.POSITIVE_INFINITY
+    );
+    if (members.length === 2 && members[0].member.type === AST_NODE_TYPES6.MethodDefinition && members[0].member.kind === "set") {
+      members.reverse();
+    }
+    const regionName = regionsArray[lowestRegionIndex];
+    regions.get(regionName).push(...members);
+  });
+  const normalizedRegions = Array.from(regions).filter(([_region, members]) => members.length > 0).map(
+    ([region, members]) => [region, sortableRegions.has(region) ? members.sort(sortFunction.bind(void 0, region)) : members]
+  );
+  return normalizedRegions;
+}
+var sortableRegions = /* @__PURE__ */ new Set(["Public Methods", "Events", "Lifecycle"]);
+function sortFunction(region, leftMember, rightMember) {
+  let leftName = leftMember.name;
+  let rightName = rightMember.name;
+  if (region === "Lifecycle") {
+    const compare = lifecycles.indexOf(leftName) - lifecycles.indexOf(rightName);
+    return compare < 0 ? -1 : 1;
+  }
+  if (leftName.startsWith("_")) {
+    leftName = leftName.slice(1);
+  }
+  if (rightName.startsWith("_")) {
+    rightName = rightName.slice(1);
+  }
+  if (leftName < rightName) {
+    return -1;
+  } else if (leftName > rightName) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+function reParentOrphanFooterComments(normalizedRegions, regionFooter) {
+  const finalRegions = new Set(normalizedRegions.map(([region]) => region));
+  regionFooter.forEach(({ comments, lastMember }, originalRegionName) => {
+    const regionStillExists = finalRegions.has(originalRegionName);
+    if (regionStillExists) {
+      return;
+    }
+    const newFooterCommentsParent = lastMember.region;
+    const existingParentFooter = regionFooter.get(newFooterCommentsParent);
+    if (existingParentFooter === void 0) {
+      regionFooter.set(newFooterCommentsParent, { comments, lastMember });
+    } else {
+      existingParentFooter.comments.push(...comments);
+    }
+  });
+}
+
+// src/plugins/lumina/rules/member-ordering/build.ts
+function buildNewBody(normalizedRegions, strayComments, sourceCode) {
+  const newRegions = normalizedRegions.map(([region, members]) => {
+    const memberLines = members.map((memberData, index) => {
+      const { member, comments, name } = memberData;
+      const commentsString = normalizeComments(comments, sourceCode);
+      const code = sourceCode.getText(member);
+      const lineEndComment = normalizeComments(strayComments.memberLineEnd.get(memberData), sourceCode, " ");
+      const memberString = `  ${code}${lineEndComment}`;
+      const fullMemberString = join(commentsString, memberString, "\n");
+      const nextMember = members.at(index + 1);
+      const isLast = nextMember === void 0;
+      const isNextSameName = name.length > 0 && name === nextMember?.name;
+      const separator = isLast ? "" : isNextSameName ? "\n" : "\n\n";
+      return `${fullMemberString}${separator}`;
+    });
+    const footerComments = normalizeComments(strayComments.regionFooter.get(region)?.comments, sourceCode);
+    const footer2 = join(footerComments, "  //#endregion", "\n\n");
+    return [`  //#region ${region}`, memberLines.join(""), footer2].join("\n\n");
+  });
+  const header = normalizeComments(strayComments.header, sourceCode);
+  const footer = normalizeComments(strayComments.footer, sourceCode);
+  const newBodyContent = join(join(header, newRegions.join("\n\n")), footer);
+  const newBody = `{
+${newBodyContent}
+}`;
+  return newBody;
+}
+
+// src/plugins/lumina/rules/member-ordering.ts
+var baseDescription = `Consistently sort component members`;
+var memberOrdering = createRule({
+  name: "member-ordering",
+  meta: {
+    docs: {
+      description: baseDescription,
+      defaultLevel: "warn"
+    },
+    messages: {
+      memberOrdering: "Component member ordering is not consistent. Run ESLint autofix to sort members.",
+      unsupportedElementType: "Unsupported class element type: {{ type }}"
+    },
+    type: "layout",
+    schema: [],
+    fixable: "whitespace"
+  },
+  defaultOptions: [],
+  create: (context) => ({
+    ClassDeclaration(component) {
+      const isNamedExport = component.parent?.type === AST_NODE_TYPES7.ExportNamedDeclaration;
+      if (!isNamedExport || component.abstract) {
+        return;
+      }
+      const hasExtends = component.superClass !== null;
+      if (!hasExtends) {
+        return;
+      }
+      const sourceCode = context.sourceCode;
+      const seenNames = /* @__PURE__ */ new Set();
+      let currentRegion = "";
+      let hasWrongOrdering = false;
+      let isDefinitelyComponent = false;
+      let hadError = false;
+      const membersData = component.body.body.map((member) => {
+        const isSupportedType = supportedNodeTypes[member.type];
+        if (!isSupportedType) {
+          hadError = true;
+          context.report({ node: member, messageId: "unsupportedElementType", data: { type: member.type } });
+        }
+        const name = "key" in member ? getName(member) ?? "" : "";
+        const newRegion = regionMatchers.find(([, rules]) => rules(member, name))[0];
+        const comments = sourceCode.getCommentsBefore(member);
+        if (!hasWrongOrdering) {
+          let wrongOrdering = false;
+          const previousRegion = currentRegion;
+          for (const comment of comments) {
+            const region = parseRegionComment(comment);
+            if (region === void 0 || region.end !== void 0) {
+              continue;
+            }
+            currentRegion = region.name;
+            wrongOrdering ||= currentRegion !== newRegion;
+          }
+          if (
+            /*
+             * The @property()/@method() decorator might be missing from this
+             * node in case of getter/setter or method overload, while still
+             * being in correct ordering.
+             * The logic in rule body is lightweight compared to more
+             * comprehensive in the autofix to keep common case fast, so we
+             * ignore possible errors in getter/setters (but those errors would
+             * still be fixed as long as there is any other error in the file).
+             */
+            !seenNames.has(name) && (member.type !== AST_NODE_TYPES7.MethodDefinition || member.kind !== "get" && member.kind !== "set")
+          ) {
+            wrongOrdering ||= currentRegion !== newRegion;
+            wrongOrdering ||= previousRegion !== currentRegion && ordering.indexOf(previousRegion) > ordering.indexOf(currentRegion);
+            hasWrongOrdering = wrongOrdering;
+          }
+          seenNames.add(name);
+        }
+        isDefinitelyComponent ||= definitelyComponentRegions.has(newRegion);
+        return { member, name, comments, region: newRegion };
+      });
+      if (!isDefinitelyComponent) {
+        return;
+      }
+      if (hadError) {
+        return;
+      }
+      if (!hasWrongOrdering) {
+        return;
+      }
+      context.report({
+        /**
+         * Since this rule is autofixable and stylistic, to be less obtrusive,
+         * report the error for a single character only, rather than entire
+         * component
+         */
+        loc: {
+          start: component.loc.end,
+          end: component.loc.end
+        },
+        messageId: "memberOrdering",
+        /*
+         * We delay as much work as possible till the autofixer is run because
+         * most of the time the rule will be run without need for autofixing.
+         */
+        fix(fixer) {
+          const { membersByName, ...strayComments } = categorizeComments(membersData, sourceCode);
+          const normalizedRegions = getNormalizedRegions(membersByName);
+          reParentOrphanFooterComments(normalizedRegions, strayComments.regionFooter);
+          const newBody = buildNewBody(normalizedRegions, strayComments, sourceCode);
+          return fixer.replaceText(component.body, newBody);
+        }
+      });
+    }
+  })
+});
+
 // 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
+      description: description6,
+      defaultLevel: "error"
     },
     messages: {
       noIgnoreJsDocTag: description6
@@ -633,14 +1050,15 @@ var noIgnoreJsDocTag = createRule({
 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 { AST_NODE_TYPES as AST_NODE_TYPES8, 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
+      description: description7,
+      defaultLevel: "error"
     },
     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`
@@ -658,7 +1076,7 @@ var noIncorrectDynamicTagName = createRule({
         if (!luminaJsxCheck.isLuminaJsx) {
           return;
         }
-        const isInTagName = node.parent?.type !== AST_NODE_TYPES5.JSXAttribute;
+        const isInTagName = node.parent?.type !== AST_NODE_TYPES8.JSXAttribute;
         if (!isInTagName) {
           return;
         }
@@ -684,16 +1102,17 @@ var noIncorrectDynamicTagName = createRule({
 });
 
 // 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}
+import { AST_NODE_TYPES as AST_NODE_TYPES9 } from "@typescript-eslint/utils";
+var baseDescription2 = `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 = `${baseDescription2}
 
 Alternatives: https://qawebgis.esri.com/components/lumina/jsx#refs`;
 var noInlineArrowInRef = createRule({
   name: "no-inline-arrow-in-ref",
   meta: {
     docs: {
-      description: baseDescription
+      description: baseDescription2,
+      defaultLevel: "error"
     },
     messages: {
       errorInlineArrow: description8
@@ -707,11 +1126,11 @@ var noInlineArrowInRef = createRule({
     return {
       ImportDeclaration: luminaJsxCheck,
       JSXAttribute(node) {
-        if (!luminaJsxCheck.isLuminaJsx || node.name.name !== "ref" || node.value?.type !== AST_NODE_TYPES6.JSXExpressionContainer) {
+        if (!luminaJsxCheck.isLuminaJsx || node.name.name !== "ref" || node.value?.type !== AST_NODE_TYPES9.JSXExpressionContainer) {
           return;
         }
         const initializer = node.value.expression;
-        if (initializer.type !== AST_NODE_TYPES6.ArrowFunctionExpression && initializer.type !== AST_NODE_TYPES6.FunctionExpression) {
+        if (initializer.type !== AST_NODE_TYPES9.ArrowFunctionExpression && initializer.type !== AST_NODE_TYPES9.FunctionExpression) {
           return;
         }
         context.report({
@@ -724,13 +1143,14 @@ var noInlineArrowInRef = createRule({
 });
 
 // src/plugins/lumina/rules/no-invalid-directives-prop.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES7 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES10 } from "@typescript-eslint/utils";
 var description9 = `directives={} prop value must be an array literal. Documentation: https://qawebgis.esri.com/components/lumina/jsx#lit-directives`;
 var noInvalidDirectivesProp = createRule({
   name: "no-invalid-directives-prop",
   meta: {
     docs: {
-      description: description9
+      description: description9,
+      defaultLevel: "error"
     },
     messages: {
       noInvalidDirectivesProp: description9
@@ -750,7 +1170,7 @@ var noInvalidDirectivesProp = createRule({
         if (node.name.name !== "directives") {
           return;
         }
-        const array = node.value?.type === AST_NODE_TYPES7.JSXExpressionContainer && node.value.expression.type === AST_NODE_TYPES7.ArrayExpression ? node.value.expression : void 0;
+        const array = node.value?.type === AST_NODE_TYPES10.JSXExpressionContainer && node.value.expression.type === AST_NODE_TYPES10.ArrayExpression ? node.value.expression : void 0;
         if (array === void 0 || array.elements.includes(null)) {
           context.report({
             messageId: "noInvalidDirectivesProp",
@@ -759,7 +1179,7 @@ var noInvalidDirectivesProp = createRule({
           return;
         }
         array.elements.forEach((element) => {
-          if (element?.type === AST_NODE_TYPES7.SpreadElement) {
+          if (element?.type === AST_NODE_TYPES10.SpreadElement) {
             context.report({
               messageId: "noInvalidDirectivesProp",
               node: element
@@ -772,13 +1192,14 @@ var noInvalidDirectivesProp = createRule({
 });
 
 // src/plugins/lumina/rules/no-jsx-spread.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES8 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES11 } from "@typescript-eslint/utils";
 var description10 = `This spread syntax is not supported. Alternatives: https://qawebgis.esri.com/components/lumina/jsx#spread-attributes`;
 var noJsxSpread = createRule({
   name: "no-jsx-spread",
   meta: {
     docs: {
-      description: description10
+      description: description10,
+      defaultLevel: "error"
     },
     messages: {
       noJsxSpread: description10
@@ -798,7 +1219,7 @@ var noJsxSpread = createRule({
         const name = node.parent.name;
         if (
           // Spread syntax is allowed in function calls like <this.render {...props} />
-          name.type === AST_NODE_TYPES8.JSXIdentifier && // Spread syntax is allowed in functions
+          name.type === AST_NODE_TYPES11.JSXIdentifier && // Spread syntax is allowed in functions
           (name.name.toLowerCase() === name.name || name.name === "DynamicHtmlTag" || name.name === "DynamicSvgTag")
         ) {
           context.report({
@@ -812,9 +1233,9 @@ var noJsxSpread = createRule({
 });
 
 // src/plugins/lumina/rules/no-listen-in-connected-callback.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES9 } from "@typescript-eslint/utils";
-var baseDescription2 = `Do not call this.listen()/this.listenOn() in connectedCallback.`;
-var description11 = `${baseDescription2}
+import { AST_NODE_TYPES as AST_NODE_TYPES12 } from "@typescript-eslint/utils";
+var baseDescription3 = `Do not call this.listen()/this.listenOn() in connectedCallback.`;
+var description11 = `${baseDescription3}
 
 Instead, call this.listen()/this.listenOn() in constructor(), load() or loaded().
 
@@ -825,7 +1246,8 @@ var noListenInConnectedCallback = createRule({
   name: "no-listen-in-connected-callback",
   meta: {
     docs: {
-      description: baseDescription2
+      description: baseDescription3,
+      defaultLevel: "error"
     },
     messages: {
       errorListenInConnectedCallback: description11
@@ -837,15 +1259,15 @@ var noListenInConnectedCallback = createRule({
   create(context) {
     return {
       CallExpression(node) {
-        const isListenCall = node.callee.type === AST_NODE_TYPES9.MemberExpression && node.callee.object.type === AST_NODE_TYPES9.ThisExpression && node.callee.property.type === AST_NODE_TYPES9.Identifier && (node.callee.property.name === "listen" || node.callee.property.name === "listenOn");
+        const isListenCall = node.callee.type === AST_NODE_TYPES12.MemberExpression && node.callee.object.type === AST_NODE_TYPES12.ThisExpression && node.callee.property.type === AST_NODE_TYPES12.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_TYPES9.MethodDefinition) {
-            if (currentParent.key.type === AST_NODE_TYPES9.Identifier && currentParent.key.name === "connectedCallback") {
+          if (currentParent.type === AST_NODE_TYPES12.MethodDefinition) {
+            if (currentParent.key.type === AST_NODE_TYPES12.Identifier && currentParent.key.name === "connectedCallback") {
               hasConnectedCallbackParent = true;
             }
             break;
@@ -865,13 +1287,14 @@ var noListenInConnectedCallback = createRule({
 });
 
 // src/plugins/lumina/rules/no-non-component-exports.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES10 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES13 } from "@typescript-eslint/utils";
 var description12 = `To ensure Hot Module Replacement (HMR) works correctly, the file that defines the Lumina component must not export anything other than the component. Exceptions: type-only exports, and the \`exportsForTests\` object for exposing additional things for usages in tests only`;
 var noNonComponentExports = createRule({
   name: "no-non-component-exports",
   meta: {
     docs: {
-      description: description12
+      description: description12,
+      defaultLevel: "warn"
     },
     messages: {
       noNonComponentExports: description12,
@@ -892,11 +1315,11 @@ var noNonComponentExports = createRule({
           return;
         }
         luminaDeclarationInterface.body.body.forEach((member) => {
-          if (member.type !== AST_NODE_TYPES10.TSPropertySignature || member.computed) {
+          if (member.type !== AST_NODE_TYPES13.TSPropertySignature || member.computed) {
             return;
           }
           const type = member.typeAnnotation?.typeAnnotation;
-          if (type?.type !== AST_NODE_TYPES10.TSTypeReference || type.typeName.type !== AST_NODE_TYPES10.Identifier) {
+          if (type?.type !== AST_NODE_TYPES13.TSTypeReference || type.typeName.type !== AST_NODE_TYPES13.Identifier) {
             return;
           }
           const className = type.typeName.name;
@@ -910,24 +1333,24 @@ var noNonComponentExports = createRule({
         if (node.exportKind === "type") {
           return;
         }
-        if (node.declaration?.type === AST_NODE_TYPES10.VariableDeclaration) {
+        if (node.declaration?.type === AST_NODE_TYPES13.VariableDeclaration) {
           const isExportsForTests = node.declaration.declarations.every(
-            (declaration) => declaration.id.type === AST_NODE_TYPES10.Identifier && declaration.id.name === "exportsForTests"
+            (declaration) => declaration.id.type === AST_NODE_TYPES13.Identifier && declaration.id.name === "exportsForTests"
           );
           if (isExportsForTests) {
             return;
           }
-        } else if (node.declaration?.type === AST_NODE_TYPES10.FunctionDeclaration) {
+        } else if (node.declaration?.type === AST_NODE_TYPES13.FunctionDeclaration) {
           const isExportsForTests = node.declaration.id?.name === "exportsForTests";
           if (isExportsForTests) {
             return;
           }
         } else if (
           // Type-only constructs
-          node.declaration?.type === AST_NODE_TYPES10.TSDeclareFunction || node.declaration?.type === AST_NODE_TYPES10.TSInterfaceDeclaration || node.declaration?.type === AST_NODE_TYPES10.TSTypeAliasDeclaration
+          node.declaration?.type === AST_NODE_TYPES13.TSDeclareFunction || node.declaration?.type === AST_NODE_TYPES13.TSInterfaceDeclaration || node.declaration?.type === AST_NODE_TYPES13.TSTypeAliasDeclaration
         ) {
           return;
-        } else if (node.declaration?.type === AST_NODE_TYPES10.ClassDeclaration) {
+        } else if (node.declaration?.type === AST_NODE_TYPES13.ClassDeclaration) {
           const isComponent = declaredComponents.has(node.declaration.id?.name ?? "");
           if (isComponent) {
             return;
@@ -964,13 +1387,14 @@ var noNonComponentExports = createRule({
 });
 
 // src/plugins/lumina/rules/no-property-name-start-with-on.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES11 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES14 } from "@typescript-eslint/utils";
 var description13 = `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: description13
+      description: description13,
+      defaultLevel: "error"
     },
     messages: {
       noPropertyNameStartWithOn: description13
@@ -986,7 +1410,7 @@ var noPropertyNameStartWithOn = createRule({
         if (!isPublicProperty) {
           return;
         }
-        const propertyName = node.key.type === AST_NODE_TYPES11.Identifier ? node.key.name : node.key.type === AST_NODE_TYPES11.Literal ? node.key.value : void 0;
+        const propertyName = node.key.type === AST_NODE_TYPES14.Identifier ? node.key.name : node.key.type === AST_NODE_TYPES14.Literal ? node.key.value : void 0;
         if (typeof propertyName !== "string") {
           return;
         }
@@ -1008,7 +1432,7 @@ var noPropertyNameStartWithOn = createRule({
 });
 
 // src/plugins/lumina/rules/no-render-false.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES12, ESLintUtils as ESLintUtils4 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES15, ESLintUtils as ESLintUtils4 } from "@typescript-eslint/utils";
 
 // src/plugins/lumina/utils/checker.ts
 import ts3 from "typescript";
@@ -1041,15 +1465,16 @@ function isLuminaJsxType(type) {
 }
 
 // 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 description14 = `${baseDescription3}
+var baseDescription4 = `Avoid accidentally rendering "false" to the screen (Lit stringifies booleans, rather than drop them like React/Stencil).`;
+var description14 = `${baseDescription4}
 
 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
+      description: baseDescription4,
+      defaultLevel: "warn"
     },
     messages: {
       errorFalseRendered: description14
@@ -1070,14 +1495,14 @@ var noRenderFalse = createRule({
         if (!isLuminaJsxType(type)) {
           return;
         }
-        if (node.parent.type === AST_NODE_TYPES12.JSXExpressionContainer) {
+        if (node.parent.type === AST_NODE_TYPES15.JSXExpressionContainer) {
           return;
         }
         const right = unwrapExpression(node.right);
-        if (right.type === AST_NODE_TYPES12.JSXElement) {
+        if (right.type === AST_NODE_TYPES15.JSXElement) {
           return;
         }
-        if (node.parent.type === AST_NODE_TYPES12.LogicalExpression) {
+        if (node.parent.type === AST_NODE_TYPES15.LogicalExpression) {
           return;
         }
         context.report({
@@ -1096,14 +1521,15 @@ var noRenderFalse = createRule({
 });
 
 // src/plugins/lumina/rules/no-unnecessary-attribute-name.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES13 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES16 } from "@typescript-eslint/utils";
 import { camelToKebab } from "@arcgis/components-utils";
 var description15 = 'There is no need for { attribute: "name" } in @property() when attribute name is trivially inferrable from the property name';
 var noUnnecessaryAttributeName = createRule({
   name: "no-unnecessary-attribute-name",
   meta: {
     docs: {
-      description: description15
+      description: description15,
+      defaultLevel: "warn"
     },
     messages: {
       noUnnecessaryAttributeName: description15
@@ -1122,11 +1548,11 @@ var noUnnecessaryAttributeName = createRule({
         }
         const { properties } = part;
         const property = decorator.parent;
-        if (property?.type !== AST_NODE_TYPES13.MethodDefinition && property?.type !== AST_NODE_TYPES13.PropertyDefinition) {
+        if (property?.type !== AST_NODE_TYPES16.MethodDefinition && property?.type !== AST_NODE_TYPES16.PropertyDefinition) {
           return;
         }
         const attributeOption = getProperty(properties, "attribute");
-        const attributeValue = attributeOption?.type === AST_NODE_TYPES13.Literal && typeof attributeOption.value === "string" ? attributeOption.value : void 0;
+        const attributeValue = attributeOption?.type === AST_NODE_TYPES16.Literal && typeof attributeOption.value === "string" ? attributeOption.value : void 0;
         if (attributeOption === void 0 || attributeValue === void 0) {
           return;
         }
@@ -1152,13 +1578,14 @@ var noUnnecessaryAttributeName = createRule({
 });
 
 // src/plugins/lumina/rules/no-unnecessary-bind-this.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES14 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES17 } from "@typescript-eslint/utils";
 var description16 = `.bind(this) is not necessary in Lit's event listener callbacks and ref callbacks as it is handled automatically.`;
 var noUnnecessaryBindThis = createRule({
   name: "no-unnecessary-bind-this",
   meta: {
     docs: {
-      description: description16
+      description: description16,
+      defaultLevel: "warn"
     },
     messages: {
       noUnnecessaryBindThis: description16
@@ -1173,7 +1600,7 @@ var noUnnecessaryBindThis = createRule({
     return {
       ImportDeclaration: luminaJsxCheck,
       JSXExpressionContainer(node) {
-        if (!luminaJsxCheck.isLuminaJsx || node.parent.type !== AST_NODE_TYPES14.JSXAttribute || node.parent.name.type !== AST_NODE_TYPES14.JSXIdentifier) {
+        if (!luminaJsxCheck.isLuminaJsx || node.parent.type !== AST_NODE_TYPES17.JSXAttribute || node.parent.name.type !== AST_NODE_TYPES17.JSXIdentifier) {
           return;
         }
         const name = node.parent.name.name;
@@ -1181,12 +1608,12 @@ var noUnnecessaryBindThis = createRule({
         if (!isAutoBindable) {
           return;
         }
-        const expression = node.expression.type === AST_NODE_TYPES14.ChainExpression ? node.expression.expression : node.expression;
+        const expression = node.expression.type === AST_NODE_TYPES17.ChainExpression ? node.expression.expression : node.expression;
         const isCallWithThis = (
           // expression(...)
-          expression.type === AST_NODE_TYPES14.CallExpression && // expression(expression)
+          expression.type === AST_NODE_TYPES17.CallExpression && // expression(expression)
           expression.arguments.length === 1 && // expression(this)
-          expression.arguments[0].type === AST_NODE_TYPES14.ThisExpression
+          expression.arguments[0].type === AST_NODE_TYPES17.ThisExpression
         );
         if (!isCallWithThis) {
           return;
@@ -1194,18 +1621,18 @@ var noUnnecessaryBindThis = createRule({
         const callee = expression.callee;
         const isBindThisCall = (
           // expression.expression(this)
-          callee.type === AST_NODE_TYPES14.MemberExpression && // expression.identifier(this)
-          callee.property.type === AST_NODE_TYPES14.Identifier && // expression.bind(this)
+          callee.type === AST_NODE_TYPES17.MemberExpression && // expression.identifier(this)
+          callee.property.type === AST_NODE_TYPES17.Identifier && // expression.bind(this)
           callee.property.name === "bind" && // expression.expression.bind(this)
-          callee.object.type === AST_NODE_TYPES14.MemberExpression && // expression.identifier.bind(this)
-          callee.object.property.type === AST_NODE_TYPES14.Identifier && // this.identifier.bind(this)
-          callee.object.object.type === AST_NODE_TYPES14.ThisExpression
+          callee.object.type === AST_NODE_TYPES17.MemberExpression && // expression.identifier.bind(this)
+          callee.object.property.type === AST_NODE_TYPES17.Identifier && // this.identifier.bind(this)
+          callee.object.object.type === AST_NODE_TYPES17.ThisExpression
         );
         if (!isBindThisCall) {
           return;
         }
-        const tagName = context.sourceCode.getAncestors(node.parent).find((ancestor) => ancestor.type === AST_NODE_TYPES14.JSXOpeningElement)?.name;
-        const tagNameString = tagName?.type === AST_NODE_TYPES14.JSXIdentifier ? tagName.name : void 0;
+        const tagName = context.sourceCode.getAncestors(node.parent).find((ancestor) => ancestor.type === AST_NODE_TYPES17.JSXOpeningElement)?.name;
+        const tagNameString = tagName?.type === AST_NODE_TYPES17.JSXIdentifier ? tagName.name : void 0;
         if (tagNameString === void 0) {
           return;
         }
@@ -1226,13 +1653,14 @@ var noUnnecessaryBindThis = createRule({
 });
 
 // src/plugins/lumina/rules/no-unnecessary-key.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES15 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES18 } from "@typescript-eslint/utils";
 var description17 = `In most cases, key={index} is not necessary in Lumina in .map(). Details: https://qawebgis.esri.com/components/lumina/jsx#key-prop`;
 var noUnnecessaryKey = createRule({
   name: "no-unnecessary-key",
   meta: {
     docs: {
-      description: description17
+      description: description17,
+      defaultLevel: "warn"
     },
     messages: {
       noUnnecessaryKey: description17
@@ -1251,21 +1679,21 @@ var noUnnecessaryKey = createRule({
           return;
         }
         const keyValue = node.expression;
-        if (keyValue.type !== AST_NODE_TYPES15.Identifier) {
+        if (keyValue.type !== AST_NODE_TYPES18.Identifier) {
           return;
         }
         const keyAttribute = node.parent;
-        if (keyAttribute?.type !== AST_NODE_TYPES15.JSXAttribute || keyAttribute.name.type !== AST_NODE_TYPES15.JSXIdentifier || keyAttribute.name.name !== "key") {
+        if (keyAttribute?.type !== AST_NODE_TYPES18.JSXAttribute || keyAttribute.name.type !== AST_NODE_TYPES18.JSXIdentifier || keyAttribute.name.name !== "key") {
           return;
         }
         const mapArrowFunction = context.sourceCode.getAncestors(keyAttribute).find(
-          (ancestor) => ancestor.type === AST_NODE_TYPES15.ArrowFunctionExpression && ancestor.parent?.type === AST_NODE_TYPES15.CallExpression && ancestor.parent?.callee.type === AST_NODE_TYPES15.MemberExpression && ancestor.parent?.callee.property.type === AST_NODE_TYPES15.Identifier && ancestor.parent?.callee.property.name === "map"
+          (ancestor) => ancestor.type === AST_NODE_TYPES18.ArrowFunctionExpression && ancestor.parent?.type === AST_NODE_TYPES18.CallExpression && ancestor.parent?.callee.type === AST_NODE_TYPES18.MemberExpression && ancestor.parent?.callee.property.type === AST_NODE_TYPES18.Identifier && ancestor.parent?.callee.property.name === "map"
         );
         if (mapArrowFunction === void 0) {
           return;
         }
         const keyParameter = mapArrowFunction.params.at(1);
-        if (keyParameter?.type !== AST_NODE_TYPES15.Identifier || keyParameter.name !== keyValue.name) {
+        if (keyParameter?.type !== AST_NODE_TYPES18.Identifier || keyParameter.name !== keyValue.name) {
           return;
         }
         context.report({
@@ -1289,7 +1717,7 @@ var noUnnecessaryKey = createRule({
 });
 
 // src/plugins/lumina/rules/tag-name-rules.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES16 } from "@typescript-eslint/utils";
+import { AST_NODE_TYPES as AST_NODE_TYPES19 } from "@typescript-eslint/utils";
 var description18 = `Validate component tag name`;
 var defaultOptions2 = [
   {
@@ -1300,7 +1728,8 @@ var tagNameRules = createRule({
   name: "tag-name-rules",
   meta: {
     docs: {
-      description: description18
+      description: description18,
+      defaultLevel: "error"
     },
     messages: {
       requireNamespace: "Custom element tag names in this project must start with one of the following namespaces: {{namespaces}}",
@@ -1363,7 +1792,7 @@ declare global {
         }
         seenDeclareGlobal = true;
         luminaDeclarationInterface.body.body.forEach((member) => {
-          if (member.type !== AST_NODE_TYPES16.TSPropertySignature) {
+          if (member.type !== AST_NODE_TYPES19.TSPropertySignature) {
             context.report({
               messageId: "unexpectedDeclareElementsEntry",
               node: member
@@ -1377,7 +1806,7 @@ declare global {
             });
             return;
           }
-          if (member.key.type === AST_NODE_TYPES16.Identifier) {
+          if (member.key.type === AST_NODE_TYPES19.Identifier) {
             context.report({
               messageId: "noTagNameIdentifier",
               node: member.key
@@ -1441,7 +1870,7 @@ declare global {
             return;
           }
           const type = member.typeAnnotation?.typeAnnotation;
-          if (type?.type !== AST_NODE_TYPES16.TSTypeReference || type.typeName.type !== AST_NODE_TYPES16.Identifier) {
+          if (type?.type !== AST_NODE_TYPES19.TSTypeReference || type.typeName.type !== AST_NODE_TYPES19.Identifier) {
             context.report({
               messageId: "unexpectedDeclarationType",
               node: type ?? member
@@ -1488,7 +1917,7 @@ declare global {
               messageId: "mustSubclass",
               node
             });
-          } else if (node.superClass.type === AST_NODE_TYPES16.Identifier && node.superClass.name.startsWith("HTML") && node.superClass.name.endsWith("Element")) {
+          } else if (node.superClass.type === AST_NODE_TYPES19.Identifier && node.superClass.name.startsWith("HTML") && node.superClass.name.endsWith("Element")) {
             context.report({
               messageId: "mustNotSubclassHtmlElement",
               node
@@ -1527,6 +1956,7 @@ var lumina_default = makeEslintPlugin("lumina", {
   "component-placement-rules": componentPlacementRules,
   "consistent-event-naming": consistentEventNaming,
   "decorators-context": decoratorsContext,
+  "member-ordering": memberOrdering,
   "no-ignore-jsdoc-tag": noIgnoreJsDocTag,
   "no-incorrect-dynamic-tag-name": noIncorrectDynamicTagName,
   "no-inline-arrow-in-ref": noInlineArrowInRef,