@discourse/lint-configs 2.45.0 → 3.0.0

package/README.md

@@ -33,9 +33,3 @@ export default {
   extends: ["@discourse/lint-configs/stylelint"],
 };
 ```
-
-### .template-lintrc.cjs
-
-```js
-module.exports = require("@discourse/lint-configs/template-lint");
-```

package/eslint-rules/no-at-class.mjs

@@ -0,0 +1,46 @@
+const AFFECTED_COMPONENTS = new Set([
+  "DButton",
+  "DModal",
+  "TableHeaderToggle",
+  "Textarea",
+  "TextArea",
+]);
+
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Disallow `@class` on Discourse components that own their root element.",
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      noAtClass: "Use `class` instead of `@class` for {{tag}}.",
+    },
+  },
+
+  create(context) {
+    return {
+      GlimmerElementNode(node) {
+        if (!AFFECTED_COMPONENTS.has(node.tag) || !node.attributes) {
+          return;
+        }
+        for (const attribute of node.attributes) {
+          if (attribute.name !== "@class") {
+            continue;
+          }
+          context.report({
+            node: attribute,
+            messageId: "noAtClass",
+            data: { tag: node.tag },
+            fix(fixer) {
+              const [start] = attribute.range;
+              return fixer.replaceTextRange([start, start + 1], "");
+            },
+          });
+        }
+      },
+    };
+  },
+};

package/eslint-rules/no-template-lint-directives.mjs

@@ -0,0 +1,103 @@
+const DIRECTIVE_COMMENT =
+  /^(?<open>\{\{!(?:--)?)\s*template-lint-(?<action>disable|enable)(?<rules>\s+[^]*?)?\s*(?:--)?\}\}$/;
+
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Convert `{{! template-lint-disable }}` comments to `{{! eslint-disable }}` equivalents.",
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      convert: "Use `eslint-{{action}}` instead of `template-lint-{{action}}`.",
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode;
+    // Glimmer parks comments that appear inside an element's opening tag
+    // (between attributes) on `element.comments`, not in the children. We
+    // collect them so the Program:exit pass can lift a converted directive
+    // to before its enclosing element — ESLint scopes line-based directives
+    // from where they appear, and the violation typically lives on the
+    // element's start line, not on the in-attribute line.
+    const elementByCommentStart = new Map();
+
+    return {
+      GlimmerElementNode(node) {
+        for (const c of node.comments || []) {
+          if (c.range) {
+            elementByCommentStart.set(c.range[0], node);
+          }
+        }
+      },
+
+      "Program:exit"() {
+        for (const comment of sourceCode.getAllComments()) {
+          const raw = sourceCode.text.slice(...comment.range);
+          const converted = convertComment(raw);
+          if (!converted) {
+            continue;
+          }
+          const enclosingElement = elementByCommentStart.get(comment.range[0]);
+          context.report({
+            node: comment,
+            messageId: "convert",
+            data: { action: converted.action },
+            fix: (fixer) =>
+              enclosingElement
+                ? liftBeforeElement(
+                    fixer,
+                    comment,
+                    converted.newComment,
+                    enclosingElement,
+                    sourceCode
+                  )
+                : fixer.replaceTextRange(comment.range, converted.newComment),
+          });
+        }
+      },
+    };
+  },
+};
+
+function convertComment(rawComment) {
+  const match = rawComment.match(DIRECTIVE_COMMENT);
+  if (!match) {
+    return null;
+  }
+  const { open, action, rules: rulesPart } = match.groups;
+  // ESLint directives use comma-separated rule names; template-lint uses
+  // whitespace. Prefix each with `ember/template-` to land in the namespace
+  // where the ports live.
+  const rules = (rulesPart || "")
+    .trim()
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((r) => `ember/template-${r}`)
+    .join(", ");
+  const body = rules ? `eslint-${action} ${rules}` : `eslint-${action}`;
+  // Emit symmetric markers regardless of what the source did.
+  const close = open.length === 5 ? "--}}" : "}}";
+  return {
+    action,
+    newComment: `${open} ${body} ${close}`,
+  };
+}
+
+// Strip the in-attribute comment line entirely (leading indent through
+// trailing newline) and re-emit the converted directive on its own line at
+// the element's indent, just above the element.
+function liftBeforeElement(fixer, comment, newComment, element, sourceCode) {
+  const text = sourceCode.text;
+  const lineStart = comment.range[0] - comment.loc.start.column;
+  const lineEnd =
+    text[comment.range[1]] === "\n" ? comment.range[1] + 1 : comment.range[1];
+  const indent = " ".repeat(element.loc.start.column);
+  return [
+    fixer.removeRange([lineStart, lineEnd]),
+    fixer.insertTextBeforeRange(element.range, `${newComment}\n${indent}`),
+  ];
+}

package/eslint-rules/no-unnecessary-tracked.mjs

@@ -4,16 +4,24 @@ const MUTATING_COMPONENTS = {
   "@value": [
     "Input",
     "Textarea",
+    "DTextarea",
     "TextField",
+    "DTextField",
     "DatePicker",
+    "DDatePicker",
     "ChatChannelChooser",
   ],
   "@checked": ["Input", "PreferenceCheckbox"],
-  "@selection": ["RadioButton", "InstallThemeItem", "ChatToTopicSelector"],
+  "@selection": [
+    "RadioButton",
+    "DRadioButton",
+    "InstallThemeItem",
+    "ChatToTopicSelector",
+  ],
   "@postAction": ["AdminPenaltyPostAction"],
   "@reason": ["AdminPenaltyReason"],
   "@tags": ["TagChooser", "ChatToTopicSelector"],
-  "@capsLockOn": ["PasswordField"],
+  "@capsLockOn": ["PasswordField", "DPasswordField"],
   "@message": ["FlagActionType"],
   "@isConfirmed": ["FlagActionType"],
   "@topicTitle": ["ChatToTopicSelector"],

package/eslint-rules/plugin-outlet-lazy-hash.mjs

@@ -0,0 +1,43 @@
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Require `{{lazyHash}}` instead of `{{hash}}` for `@outletArgs` on `<PluginOutlet>`.",
+    },
+    schema: [],
+    messages: {
+      useLazyHash:
+        "Use {{lazyHash}} instead of {{hash}} for @outletArgs in <PluginOutlet>.",
+    },
+  },
+
+  create(context) {
+    return {
+      GlimmerElementNode(node) {
+        if (node.tag !== "PluginOutlet" || !node.attributes) {
+          return;
+        }
+        const outletArgsAttr = node.attributes.find(
+          (attr) => attr.name === "@outletArgs"
+        );
+        if (!outletArgsAttr || !outletArgsAttr.value) {
+          return;
+        }
+        const value = outletArgsAttr.value;
+        if (
+          value.type === "GlimmerMustacheStatement" &&
+          value.path?.type === "GlimmerPathExpression" &&
+          value.path.head?.type === "VarHead" &&
+          value.path.head.name === "hash" &&
+          !value.path.tail?.length
+        ) {
+          context.report({
+            node: value,
+            messageId: "useLazyHash",
+          });
+        }
+      },
+    };
+  },
+};

package/eslint-rules/template-tag-no-self-this.mjs

@@ -1,3 +1,21 @@
+const THIS_BINDING_TYPES = new Set([
+  "ClassDeclaration",
+  "ClassExpression",
+  "FunctionDeclaration",
+  "FunctionExpression",
+]);
+
+function findThisBindingAncestor(target) {
+  let current = target.parent;
+  while (current) {
+    if (THIS_BINDING_TYPES.has(current.type)) {
+      return current;
+    }
+    current = current.parent;
+  }
+  return null;
+}
+
 export default {
   meta: {
     type: "suggestion",
@@ -24,16 +42,15 @@ export default {
           (ref) => ref.identifier.parent !== node
         );
 
+        const declarationThisBinding = findThisBindingAncestor(node);
+
         const referencedOnlyInAdjacentTemplateTag = references.every((ref) => {
           if (ref.identifier.type !== "VarHead") {
             return false;
           }
-
-          const hasSameVariableScope =
-            context.sourceCode.getScope(ref.identifier).variableScope ===
-            context.sourceCode.getScope(node).variableScope;
-
-          return hasSameVariableScope;
+          return (
+            findThisBindingAncestor(ref.identifier) === declarationThisBinding
+          );
         });
 
         if (referencedOnlyInAdjacentTemplateTag) {

package/eslint-rules/ui-kit-imports.mjs

@@ -0,0 +1,543 @@
+/**
+ * Converts a kebab-case string to PascalCase.
+ * @param {string} str - e.g. "d-async-content"
+ * @returns {string} - e.g. "DAsyncContent"
+ */
+function kebabToPascal(str) {
+  return str
+    .split("-")
+    .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+    .join("");
+}
+
+/**
+ * Converts a kebab-case string to camelCase.
+ * @param {string} str - e.g. "d-age-with-tooltip"
+ * @returns {string} - e.g. "dAgeWithTooltip"
+ */
+function kebabToCamel(str) {
+  return str
+    .split("-")
+    .map((part, i) =>
+      i === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)
+    )
+    .join("");
+}
+
+/**
+ * Returns true if the old import path is for a component (not a helper or modifier).
+ * @param {string} oldPath
+ * @returns {boolean}
+ */
+function isComponentPath(oldPath) {
+  return !oldPath.includes("/helpers/") && !oldPath.includes("/modifiers/");
+}
+
+/**
+ * Computes the canonical identifier name for a given new import path.
+ * Components use PascalCase, helpers/modifiers use camelCase.
+ * @param {string} oldPath - The old import path (to determine component vs helper/modifier)
+ * @param {string} newPath - The new import path
+ * @returns {string}
+ */
+function canonicalName(oldPath, newPath) {
+  const basename = newPath.split("/").pop();
+  return isComponentPath(oldPath)
+    ? kebabToPascal(basename)
+    : kebabToCamel(basename);
+}
+
+const USE_UI_KIT = "Use `{{newSource}}` instead of `{{oldSource}}`";
+
+const messages = {
+  pathOnly: `${USE_UI_KIT}.`,
+  rename: `${USE_UI_KIT}. Rename \`{{localName}}\` to \`{{newName}}\`.`,
+  conflict: `${USE_UI_KIT}: \`{{newName}}\` conflicts with an existing identifier. Rename manually.`,
+};
+
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "migrate imports to discourse/ui-kit/ paths and rename identifiers to match the d- prefix convention",
+    },
+    fixable: "code",
+    messages,
+    schema: [],
+  },
+
+  create(context) {
+    // Collect all pending reports so we can emit a single combined fix in
+    // Program:exit. This avoids overlapping composite-fix ranges when
+    // multiple imports are fixed in the same file (ESLint merges all fix
+    // operations from a single report into one range, and when that range
+    // spans from an import to a closing tag deep in the template, it blocks
+    // other imports' fixes from being applied in the same pass).
+    const pendingReports = [];
+
+    return {
+      ImportDeclaration(node) {
+        const oldSource = node.source.value;
+        const newSource = MAPPINGS[oldSource];
+
+        if (!newSource) {
+          return;
+        }
+
+        const defaultSpecifier = node.specifiers.find(
+          (s) => s.type === "ImportDefaultSpecifier"
+        );
+
+        // No default import (namespace or named-only) — just fix the path
+        if (!defaultSpecifier) {
+          pendingReports.push({
+            node,
+            messageId: "pathOnly",
+            data: { oldSource, newSource },
+            fixable: true,
+            kind: "pathOnly",
+          });
+          return;
+        }
+
+        const localName = defaultSpecifier.local.name;
+        const newName = canonicalName(oldSource, newSource);
+
+        // Local name already matches canonical new name — just fix the path
+        if (localName === newName) {
+          pendingReports.push({
+            node,
+            messageId: "pathOnly",
+            data: { oldSource, newSource },
+            fixable: true,
+            kind: "pathOnly",
+          });
+          return;
+        }
+
+        // Rename needed — check for naming conflicts
+        const moduleScope = context.sourceCode.scopeManager.scopes.find(
+          (s) => s.type === "module"
+        );
+
+        const hasConflict = moduleScope?.variables.some(
+          (v) => v.name === newName && v.defs[0]?.node !== defaultSpecifier
+        );
+
+        if (hasConflict) {
+          pendingReports.push({
+            node,
+            messageId: "conflict",
+            data: { oldSource, newSource, localName, newName },
+            fixable: false,
+            kind: "conflict",
+          });
+          return;
+        }
+
+        const variable = moduleScope?.variables.find(
+          (v) => v.name === localName
+        );
+
+        pendingReports.push({
+          node,
+          messageId: "rename",
+          data: { oldSource, newSource, localName, newName },
+          fixable: true,
+          kind: "rename",
+          defaultSpecifier,
+          variable,
+        });
+      },
+
+      ExportNamedDeclaration(node) {
+        if (!node.source) {
+          return;
+        }
+
+        const oldSource = node.source.value;
+        const newSource = MAPPINGS[oldSource];
+
+        if (!newSource) {
+          return;
+        }
+
+        pendingReports.push({
+          node,
+          messageId: "pathOnly",
+          data: { oldSource, newSource },
+          fixable: true,
+          kind: "pathOnly",
+        });
+      },
+
+      // Handle importSync("discourse/components/...") calls, but only when
+      // importSync is imported from "@embroider/macros".
+      "CallExpression[callee.name='importSync']"(node) {
+        const arg = node.arguments[0];
+        if (!arg || arg.type !== "Literal" || typeof arg.value !== "string") {
+          return;
+        }
+
+        const oldSource = arg.value;
+        const newSource = MAPPINGS[oldSource];
+
+        if (!newSource) {
+          return;
+        }
+
+        // Verify importSync comes from @embroider/macros
+        const moduleScope = context.sourceCode.scopeManager.scopes.find(
+          (s) => s.type === "module"
+        );
+        const importSyncVar = moduleScope?.variables.find(
+          (v) => v.name === "importSync"
+        );
+        const importDef = importSyncVar?.defs.find(
+          (d) =>
+            d.type === "ImportBinding" &&
+            d.parent?.source?.value === "@embroider/macros"
+        );
+        if (!importDef) {
+          return;
+        }
+
+        pendingReports.push({
+          node,
+          messageId: "pathOnly",
+          data: { oldSource, newSource },
+          fixable: true,
+          kind: "importSync",
+          importSyncArg: arg,
+        });
+      },
+
+      "Program:exit"() {
+        // Scan JSDoc comments for import("discourse/...") type references.
+        // These aren't AST nodes, so we use regex over comment text.
+        const JSDOC_IMPORT_RE = /import\(["']([^"']+)["']\)/g;
+        const EXTENSION_RE = /\.(gjs|js|ts|gts)$/;
+
+        for (const comment of context.sourceCode.getAllComments()) {
+          let match;
+          while ((match = JSDOC_IMPORT_RE.exec(comment.value)) !== null) {
+            const rawPath = match[1];
+            const stripped = rawPath.replace(EXTENSION_RE, "");
+            const newSource = MAPPINGS[stripped];
+
+            if (!newSource) {
+              continue;
+            }
+
+            const ext = rawPath.match(EXTENSION_RE)?.[0] || "";
+            const fullNewSource = newSource + ext;
+
+            // Compute the range of the path string inside the comment.
+            // comment.range[0] points to /* or //, add 2 to skip the
+            // opening delimiter, then match.index is relative to comment.value.
+            const pathStart =
+              comment.range[0] + 2 + match.index + match[0].indexOf(rawPath);
+            const pathEnd = pathStart + rawPath.length;
+
+            pendingReports.push({
+              node: context.sourceCode.ast,
+              messageId: "pathOnly",
+              data: { oldSource: rawPath, newSource: fullNewSource },
+              fixable: true,
+              kind: "jsdoc",
+              jsdocRange: [pathStart, pathEnd],
+              jsdocNewSource: fullNewSource,
+            });
+          }
+        }
+
+        if (pendingReports.length === 0) {
+          return;
+        }
+
+        const sourceText = context.sourceCode.getText();
+        const fixableReports = pendingReports.filter((r) => r.fixable);
+
+        // Emit all reports. Attach a single combined fix to the first
+        // fixable report — this avoids overlapping composite ranges.
+        let fixAttached = false;
+
+        for (const report of pendingReports) {
+          const reportObj = {
+            node: report.node,
+            messageId: report.messageId,
+            data: report.data,
+          };
+
+          if (report.fixable && !fixAttached) {
+            fixAttached = true;
+            reportObj.fix = (fixer) =>
+              buildCombinedFix(fixer, fixableReports, sourceText);
+          }
+
+          context.report(reportObj);
+        }
+      },
+    };
+  },
+};
+
+/**
+ * Builds a single array of fix operations covering ALL fixable imports.
+ * Having one combined fix avoids overlapping composite ranges.
+ */
+function buildCombinedFix(fixer, reports, sourceText) {
+  const fixes = [];
+  const fixedRanges = new Set();
+
+  function addFix(fix) {
+    const range = fix.range;
+    const key = `${range[0]}:${range[1]}`;
+    if (!fixedRanges.has(key)) {
+      fixedRanges.add(key);
+      fixes.push(fix);
+    }
+  }
+
+  for (const report of reports) {
+    if (report.kind === "jsdoc") {
+      addFix(fixer.replaceTextRange(report.jsdocRange, report.jsdocNewSource));
+      continue;
+    }
+
+    if (report.kind === "importSync") {
+      addFix(
+        fixer.replaceText(report.importSyncArg, `"${report.data.newSource}"`)
+      );
+      continue;
+    }
+
+    if (report.kind === "pathOnly") {
+      addFix(
+        fixer.replaceText(report.node.source, `"${report.data.newSource}"`)
+      );
+      continue;
+    }
+
+    // kind === "rename"
+    const { node, defaultSpecifier, variable, data } = report;
+    const { newSource, localName, newName } = data;
+
+    addFix(fixer.replaceText(node.source, `"${newSource}"`));
+    addFix(fixer.replaceText(defaultSpecifier, newName));
+
+    if (variable) {
+      for (const ref of variable.references) {
+        if (ref.identifier !== defaultSpecifier.local) {
+          // When a renamed identifier is used as a shorthand property
+          // (e.g. { basePath }), naively renaming it to { dBasePath }
+          // changes both the key and value. Instead, expand to explicit
+          // key-value form: { basePath: dBasePath }.
+          const parent = ref.identifier.parent;
+          if (
+            parent?.type === "Property" &&
+            parent.shorthand &&
+            parent.value === ref.identifier
+          ) {
+            addFix(fixer.replaceText(parent, `${localName}: ${newName}`));
+          } else {
+            addFix(fixer.replaceText(ref.identifier, newName));
+          }
+
+          // For component elements with closing tags (e.g. <NavItem>...</NavItem>),
+          // variable.references only covers the opening tag. We must also
+          // fix the closing tag to avoid a Glimmer parse error.
+          // Walk up the parent chain to find the GlimmerElementNode — it may
+          // be the direct parent (GlimmerElementNodePart → GlimmerElementNode)
+          // or deeper when inside {{#if}}/{{#each}} blocks.
+          let elementNode = ref.identifier.parent;
+          while (elementNode && elementNode.type !== "GlimmerElementNode") {
+            elementNode = elementNode.parent;
+          }
+          if (elementNode && !elementNode.selfClosing) {
+            const closingTag = `</${localName}>`;
+            const searchStart = elementNode.range[0];
+            const searchEnd = elementNode.range[1];
+            const idx = sourceText.lastIndexOf(closingTag, searchEnd - 1);
+            if (idx >= searchStart) {
+              const nameStart = idx + 2; // skip "</"
+              const nameEnd = nameStart + localName.length;
+              addFix(fixer.replaceTextRange([nameStart, nameEnd], newName));
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return fixes;
+}
+
+// Mapping from old import paths to new ui-kit paths.
+// Extracted from discourse/discourse PR #38703 (ui-kit-shims.js).
+const MAPPINGS = {
+  // Components — already d-prefixed (path change only)
+  "discourse/components/d-autocomplete-results":
+    "discourse/ui-kit/d-autocomplete-results",
+  "discourse/components/d-breadcrumbs-container":
+    "discourse/ui-kit/d-breadcrumbs-container",
+  "discourse/components/d-breadcrumbs-item":
+    "discourse/ui-kit/d-breadcrumbs-item",
+  "discourse/components/d-button": "discourse/ui-kit/d-button",
+  "discourse/components/d-combo-button": "discourse/ui-kit/d-combo-button",
+  "discourse/components/d-icon-grid-picker":
+    "discourse/ui-kit/d-icon-grid-picker",
+  "discourse/components/d-editor": "discourse/ui-kit/d-editor",
+  "discourse/components/d-modal": "discourse/ui-kit/d-modal",
+  "discourse/components/d-modal-cancel": "discourse/ui-kit/d-modal-cancel",
+  "discourse/components/d-multi-select": "discourse/ui-kit/d-multi-select",
+  "discourse/components/d-navigation-item":
+    "discourse/ui-kit/d-navigation-item",
+  "discourse/components/d-otp": "discourse/ui-kit/d-otp",
+  "discourse/components/d-page-action-button":
+    "discourse/ui-kit/d-page-action-button",
+  "discourse/components/d-page-header": "discourse/ui-kit/d-page-header",
+  "discourse/components/d-page-subheader": "discourse/ui-kit/d-page-subheader",
+  "discourse/components/d-select": "discourse/ui-kit/d-select",
+  "discourse/components/d-stat-tiles": "discourse/ui-kit/d-stat-tiles",
+  "discourse/components/d-textarea": "discourse/ui-kit/d-textarea",
+  "discourse/components/d-toggle-switch": "discourse/ui-kit/d-toggle-switch",
+
+  // Components — renamed (old unprefixed → new d-prefixed)
+  "discourse/components/async-content": "discourse/ui-kit/d-async-content",
+  "discourse/components/avatar-flair": "discourse/ui-kit/d-avatar-flair",
+  "discourse/components/badge-button": "discourse/ui-kit/d-badge-button",
+  "discourse/components/badge-card": "discourse/ui-kit/d-badge-card",
+  "discourse/components/calendar-date-time-input":
+    "discourse/ui-kit/d-calendar-date-time-input",
+  "discourse/components/cdn-img": "discourse/ui-kit/d-cdn-img",
+  "discourse/components/char-counter": "discourse/ui-kit/d-char-counter",
+  "discourse/components/color-picker": "discourse/ui-kit/d-color-picker",
+  "discourse/components/color-picker-choice":
+    "discourse/ui-kit/d-color-picker-choice",
+  "discourse/components/conditional-in-element":
+    "discourse/ui-kit/d-conditional-in-element",
+  "discourse/components/conditional-loading-section":
+    "discourse/ui-kit/d-conditional-loading-section",
+  "discourse/components/conditional-loading-spinner":
+    "discourse/ui-kit/d-conditional-loading-spinner",
+  "discourse/components/cook-text": "discourse/ui-kit/d-cook-text",
+  "discourse/components/copy-button": "discourse/ui-kit/d-copy-button",
+  "discourse/components/count-i18n": "discourse/ui-kit/d-count-i18n",
+  "discourse/components/custom-html": "discourse/ui-kit/d-custom-html",
+  "discourse/components/date-input": "discourse/ui-kit/d-date-input",
+  "discourse/components/date-picker": "discourse/ui-kit/d-date-picker",
+  "discourse/components/date-time-input": "discourse/ui-kit/d-date-time-input",
+  "discourse/components/date-time-input-range":
+    "discourse/ui-kit/d-date-time-input-range",
+  "discourse/components/decorated-html": "discourse/ui-kit/d-decorated-html",
+  "discourse/components/dropdown-menu": "discourse/ui-kit/d-dropdown-menu",
+  "discourse/components/empty-state": "discourse/ui-kit/d-empty-state",
+  "discourse/components/expanding-text-area":
+    "discourse/ui-kit/d-expanding-text-area",
+  "discourse/components/filter-input": "discourse/ui-kit/d-filter-input",
+  "discourse/components/flash-message": "discourse/ui-kit/d-flash-message",
+  "discourse/components/future-date-input":
+    "discourse/ui-kit/d-future-date-input",
+  "discourse/components/highlighted-code":
+    "discourse/ui-kit/d-highlighted-code",
+  "discourse/components/horizontal-overflow-nav":
+    "discourse/ui-kit/d-horizontal-overflow-nav",
+  "discourse/components/html-with-links": "discourse/ui-kit/d-html-with-links",
+  "discourse/components/input-tip": "discourse/ui-kit/d-input-tip",
+  "discourse/components/interpolated-translation":
+    "discourse/ui-kit/d-interpolated-translation",
+  "discourse/components/light-dark-img": "discourse/ui-kit/d-light-dark-img",
+  "discourse/components/load-more": "discourse/ui-kit/d-load-more",
+  "discourse/components/nav-item": "discourse/ui-kit/d-nav-item",
+  "discourse/components/number-field": "discourse/ui-kit/d-number-field",
+  "discourse/components/password-field": "discourse/ui-kit/d-password-field",
+  "discourse/components/pick-files-button":
+    "discourse/ui-kit/d-pick-files-button",
+  "discourse/components/popup-input-tip": "discourse/ui-kit/d-popup-input-tip",
+  "discourse/components/radio-button": "discourse/ui-kit/d-radio-button",
+  "discourse/components/relative-date": "discourse/ui-kit/d-relative-date",
+  "discourse/components/relative-time-picker":
+    "discourse/ui-kit/d-relative-time-picker",
+  "discourse/components/responsive-table":
+    "discourse/ui-kit/d-responsive-table",
+  "discourse/components/save-controls": "discourse/ui-kit/d-save-controls",
+  "discourse/components/second-factor-input":
+    "discourse/ui-kit/d-second-factor-input",
+  "discourse/components/small-user-list": "discourse/ui-kit/d-small-user-list",
+  "discourse/components/table-header-toggle":
+    "discourse/ui-kit/d-table-header-toggle",
+  "discourse/components/tap-tile": "discourse/ui-kit/d-tap-tile",
+  "discourse/components/tap-tile-grid": "discourse/ui-kit/d-tap-tile-grid",
+  "discourse/components/text-field": "discourse/ui-kit/d-text-field",
+  "discourse/components/textarea": "discourse/ui-kit/d-textarea",
+  "discourse/components/time-input": "discourse/ui-kit/d-time-input",
+  "discourse/components/time-shortcut-picker":
+    "discourse/ui-kit/d-time-shortcut-picker",
+  "discourse/components/toggle-password-mask":
+    "discourse/ui-kit/d-toggle-password-mask",
+  "discourse/components/user-avatar": "discourse/ui-kit/d-user-avatar",
+  "discourse/components/user-avatar-flair":
+    "discourse/ui-kit/d-user-avatar-flair",
+  "discourse/components/user-info": "discourse/ui-kit/d-user-info",
+  "discourse/components/user-link": "discourse/ui-kit/d-user-link",
+  "discourse/components/user-stat": "discourse/ui-kit/d-user-stat",
+  "discourse/components/user-status-message":
+    "discourse/ui-kit/d-user-status-message",
+
+  // Helpers — already d-prefixed
+  "discourse/helpers/d-icon": "discourse/ui-kit/helpers/d-icon",
+
+  // Helpers — renamed
+  "discourse/helpers/age-with-tooltip":
+    "discourse/ui-kit/helpers/d-age-with-tooltip",
+  "discourse/helpers/avatar": "discourse/ui-kit/helpers/d-avatar",
+  "discourse/helpers/base-path": "discourse/ui-kit/helpers/d-base-path",
+  "discourse/helpers/bound-avatar": "discourse/ui-kit/helpers/d-bound-avatar",
+  "discourse/helpers/bound-avatar-template":
+    "discourse/ui-kit/helpers/d-bound-avatar-template",
+  "discourse/helpers/bound-category-link":
+    "discourse/ui-kit/helpers/d-bound-category-link",
+  "discourse/helpers/category-badge":
+    "discourse/ui-kit/helpers/d-category-badge",
+  "discourse/helpers/category-link": "discourse/ui-kit/helpers/d-category-link",
+  "discourse/helpers/concat-class": "discourse/ui-kit/helpers/d-concat-class",
+  "discourse/helpers/dasherize": "discourse/ui-kit/helpers/d-dasherize",
+  "discourse/helpers/dir-span": "discourse/ui-kit/helpers/d-dir-span",
+  "discourse/helpers/discourse-tag": "discourse/ui-kit/helpers/d-discourse-tag",
+  "discourse/helpers/discourse-tags":
+    "discourse/ui-kit/helpers/d-discourse-tags",
+  "discourse/helpers/element": "discourse/ui-kit/helpers/d-element",
+  "discourse/helpers/emoji": "discourse/ui-kit/helpers/d-emoji",
+  "discourse/helpers/format-date": "discourse/ui-kit/helpers/d-format-date",
+  "discourse/helpers/format-duration":
+    "discourse/ui-kit/helpers/d-format-duration",
+  "discourse/helpers/icon-or-image": "discourse/ui-kit/helpers/d-icon-or-image",
+  "discourse/helpers/loading-spinner":
+    "discourse/ui-kit/helpers/d-loading-spinner",
+  "discourse/helpers/number": "discourse/ui-kit/helpers/d-number",
+  "discourse/helpers/replace-emoji": "discourse/ui-kit/helpers/d-replace-emoji",
+  "discourse/helpers/topic-link": "discourse/ui-kit/helpers/d-topic-link",
+  "discourse/helpers/unique-id": "discourse/ui-kit/helpers/d-unique-id",
+  "discourse/helpers/user-avatar": "discourse/ui-kit/helpers/d-user-avatar",
+
+  // Modifiers — already d-prefixed
+  "discourse/modifiers/d-autocomplete":
+    "discourse/ui-kit/modifiers/d-autocomplete",
+
+  // Modifiers — renamed
+  "discourse/modifiers/auto-focus": "discourse/ui-kit/modifiers/d-auto-focus",
+  "discourse/modifiers/close-on-click-outside":
+    "discourse/ui-kit/modifiers/d-close-on-click-outside",
+  "discourse/modifiers/draggable": "discourse/ui-kit/modifiers/d-draggable",
+  "discourse/modifiers/observe-intersection":
+    "discourse/ui-kit/modifiers/d-observe-intersection",
+  "discourse/modifiers/on-resize": "discourse/ui-kit/modifiers/d-on-resize",
+  "discourse/modifiers/scroll-into-view":
+    "discourse/ui-kit/modifiers/d-scroll-into-view",
+  "discourse/modifiers/swipe": "discourse/ui-kit/modifiers/d-swipe",
+  "discourse/modifiers/tab-to-sibling":
+    "discourse/ui-kit/modifiers/d-tab-to-sibling",
+  "discourse/modifiers/trap-tab": "discourse/ui-kit/modifiers/d-trap-tab",
+};

package/eslint.mjs

@@ -1,9 +1,9 @@
 import BabelParser from "@babel/eslint-parser";
 import js from "@eslint/js";
-import EmberESLintParser from "ember-eslint-parser";
 import DecoratorPosition from "eslint-plugin-decorator-position";
 import EmberPlugin from "eslint-plugin-ember";
 import EmberRecommended from "eslint-plugin-ember/configs/recommended";
+import EmberTemplateLintMigration from "eslint-plugin-ember/configs/template-lint-migration";
 import ImportPlugin from "eslint-plugin-import";
 import QUnitPlugin from "eslint-plugin-qunit";
 import QUnitRecommended from "eslint-plugin-qunit/configs/recommended";
@@ -23,20 +23,24 @@ import lineBeforeDefaultExport from "./eslint-rules/line-before-default-export.m
 import linesBetweenClassMembers from "./eslint-rules/lines-between-class-members.mjs";
 import migrateTrackedBuiltInsToEmberCollections from "./eslint-rules/migrate-tracked-built-ins-to-ember-collections.mjs";
 import movedPackagesImportPaths from "./eslint-rules/moved-packages-import-paths.mjs";
+import noAtClass from "./eslint-rules/no-at-class.mjs";
 import noComputedMacros from "./eslint-rules/no-computed-macros.mjs";
 import noCurlyComponents from "./eslint-rules/no-curly-components.mjs";
 import noDiscourseComputed from "./eslint-rules/no-discourse-computed.mjs";
 import noOnclick from "./eslint-rules/no-onclick.mjs";
 import noRouteTemplate from "./eslint-rules/no-route-template.mjs";
 import noSimpleQuerySelector from "./eslint-rules/no-simple-query-selector.mjs";
+import noTemplateLintDirectives from "./eslint-rules/no-template-lint-directives.mjs";
 import noUnnecessaryTracked from "./eslint-rules/no-unnecessary-tracked.mjs";
 import noUnusedServices from "./eslint-rules/no-unused-services.mjs";
 import pluginApiNoVersion from "./eslint-rules/plugin-api-no-version.mjs";
+import pluginOutletLazyHash from "./eslint-rules/plugin-outlet-lazy-hash.mjs";
 import serviceInjectImport from "./eslint-rules/service-inject-import.mjs";
 import templateTagNoSelfThis from "./eslint-rules/template-tag-no-self-this.mjs";
 import testFilenameSuffix from "./eslint-rules/test-filename-suffix.mjs";
 import themeImports from "./eslint-rules/theme-imports.mjs";
 import truthHelpersImports from "./eslint-rules/truth-helpers-imports.mjs";
+import uiKitImports from "./eslint-rules/ui-kit-imports.mjs";
 
 let decoratorsPluginPath = import.meta
   .resolve("@babel/plugin-proposal-decorators")
@@ -49,14 +53,25 @@ export default [
   js.configs.recommended,
   QUnitRecommended,
   ...EmberRecommended,
+  ...EmberTemplateLintMigration,
   {
     ignores: ["assets/vendor/**/*", "public/**/*"],
   },
+  {
+    // Scope the Babel parser to non-template JS so it doesn't clobber the
+    // ember-eslint-parser that the upstream `base` config sets up for
+    // .gjs/.gts files. The parserOptions live in the main block below so
+    // they also flow through to ember-eslint-parser, which delegates the JS
+    // portion of gjs/gts to @babel/eslint-parser internally.
+    files: ["**/*.{js,mjs,cjs}"],
+    languageOptions: {
+      parser: BabelParser,
+    },
+  },
   {
     languageOptions: {
       ecmaVersion: 2022,
       sourceType: "module",
-      parser: BabelParser,
       parserOptions: {
         useBabel: true,
         requireConfigFile: false,
@@ -65,7 +80,6 @@ export default [
           plugins: [[decoratorsPluginPath, { legacy: true }]],
         },
       },
-
       globals: {
         ...globals.browser,
         ...globals.node,
@@ -153,6 +167,10 @@ export default [
           "no-unnecessary-tracked": noUnnecessaryTracked,
           "migrate-tracked-built-ins-to-ember-collections":
             migrateTrackedBuiltInsToEmberCollections,
+          "ui-kit-imports": uiKitImports,
+          "no-at-class": noAtClass,
+          "plugin-outlet-lazy-hash": pluginOutletLazyHash,
+          "no-template-lint-directives": noTemplateLintDirectives,
         },
       },
     },
@@ -221,6 +239,39 @@ export default [
       "ember/no-unnecessary-service-injection-argument": "error",
       "ember/no-replace-test-comments": "error",
       "ember/route-path-style": "error",
+
+      // Intentionally disabled template rules
+      "ember/template-no-autofocus-attribute": "off",
+      "ember/template-no-positive-tabindex": "off",
+      "ember/template-require-mandatory-role-attributes": "off",
+      "ember/template-require-media-caption": "off",
+      "ember/template-builtin-component-arguments": "off",
+      "ember/template-no-builtin-form-components": "off",
+      "ember/template-no-unknown-arguments-for-builtin-components": "off",
+
+      // Pending default template rules
+      "ember/template-link-href-attributes": "off",
+      "ember/template-no-at-ember-render-modifiers": "off",
+      "ember/template-no-curly-component-invocation": "off",
+      "ember/template-no-duplicate-landmark-elements": "off",
+      "ember/template-no-inline-styles": "off",
+      "ember/template-no-link-to-tagname": "off",
+      "ember/template-no-passed-in-event-handlers": "off",
+      "ember/template-no-route-action": "off",
+      "ember/template-require-input-label": "off",
+      "ember/template-require-presentational-children": "off",
+      "ember/template-require-valid-alt-text": "off",
+
+      // Non-default rules
+      "ember/template-no-chained-this": "error",
+      "ember/template-require-strict-mode": "error",
+
+      // From `ember-template-lint`'s old `stylistic` preset
+      "ember/template-linebreak-style": "error",
+      "ember/template-no-multiple-empty-lines": "error",
+      "ember/template-no-trailing-spaces": "error",
+      "ember/template-no-unnecessary-concat": "error",
+
       "qunit/no-loose-assertions": "error",
       "qunit/no-identical-names": "off", // the rule doesn't consider that tests might be in different `acceptance` modules
       "sort-class-members/sort-class-members": [
@@ -320,12 +371,10 @@ export default [
       "discourse/keep-array-sorted": ["error"],
       "discourse/no-unnecessary-tracked": ["warn"],
       "discourse/migrate-tracked-built-ins-to-ember-collections": ["error"],
-    },
-  },
-  {
-    files: ["**/*.gjs", "**/*.gts"],
-    languageOptions: {
-      parser: EmberESLintParser,
+      "discourse/ui-kit-imports": ["error"],
+      "discourse/no-at-class": ["error"],
+      "discourse/plugin-outlet-lazy-hash": ["error"],
+      "discourse/no-template-lint-directives": ["error"],
     },
   },
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@discourse/lint-configs",
-  "version": "2.45.0",
+  "version": "3.0.0",
   "description": "Shareable lint configs for Discourse core, plugins, and themes",
   "author": "Discourse",
   "license": "MIT",
@@ -22,22 +22,16 @@
     "./prettier": {
       "require": "./.prettierrc.cjs"
     },
-    "./stylelint": "./stylelint.mjs",
-    "./template-lint": {
-      "require": "./template-lint.config.cjs"
-    },
-    "./template-lint-rules": "./template-lint-rules/index.mjs"
+    "./stylelint": "./stylelint.mjs"
   },
   "dependencies": {
     "@babel/core": "^7.29.0",
     "@babel/eslint-parser": "^7.28.6",
     "@babel/plugin-proposal-decorators": "^7.29.0",
     "@eslint/js": "^9.39.2",
-    "ember-eslint-parser": "^0.5.13",
-    "ember-template-lint": "^7.9.3",
     "eslint": "^9.39.2",
     "eslint-plugin-decorator-position": "^6.0.0",
-    "eslint-plugin-ember": "^12.7.5",
+    "eslint-plugin-ember": "^13.2.1",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-qunit": "^8.2.6",
     "eslint-plugin-simple-import-sort": "^12.1.1",
@@ -52,7 +46,6 @@
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "ember-template-lint": "7.9.3",
     "eslint": "9.39.2",
     "prettier": "3.8.1",
     "stylelint": "17.5.0"

package/template-lint-rules/index.mjs

@@ -1,15 +0,0 @@
-import NoAtClass from "./no-at-class.mjs";
-import NoImplicitThis from "./no-implicit-this.mjs";
-import PluginOutletLazyHash from "./plugin-outlet-lazy-hash.mjs";
-
-export default {
-  // Name of plugin
-  name: "discourse",
-
-  // Define rules for this plugin. Each path should map to a plugin rule
-  rules: {
-    "discourse/no-at-class": NoAtClass,
-    "discourse/no-implicit-this": NoImplicitThis,
-    "discourse/plugin-outlet-lazy-hash": PluginOutletLazyHash,
-  },
-};

package/template-lint-rules/no-at-class.mjs

@@ -1,33 +0,0 @@
-import { Rule } from "ember-template-lint";
-
-const AFFECTED_COMPONENTS = [
-  "DButton",
-  "DModal",
-  "TableHeaderToggle",
-  "Textarea",
-  "TextArea",
-];
-
-export default class NoAtClass extends Rule {
-  visitor() {
-    return {
-      ElementNode(node) {
-        if (AFFECTED_COMPONENTS.includes(node.tag) && node.attributes) {
-          node.attributes.forEach((attribute) => {
-            if (attribute.name === "@class") {
-              if (this.mode === "fix") {
-                attribute.name = "class";
-              } else {
-                this.log({
-                  message: `Use 'class' instead of '@class' for ${node.tag}.`,
-                  node,
-                  isFixable: true,
-                });
-              }
-            }
-          });
-        }
-      },
-    };
-  }
-}

package/template-lint-rules/no-implicit-this.mjs

@@ -1,174 +0,0 @@
-// Adapted from https://github.com/ember-template-lint/ember-template-lint/blob/master/docs/rule/no-implicit-this.md
-// With the addition of autofix
-
-import { Rule } from "ember-template-lint";
-
-function createErrorMessage(ruleName, lines, config) {
-  return [
-    `The ${ruleName} rule accepts one of the following values.`,
-    lines,
-    `You specified \`${JSON.stringify(config)}\``,
-  ].join("\n");
-}
-
-function message(original) {
-  return (
-    `Ambiguous path '${original}' is not allowed. ` +
-    `Use '@${original}' if it is a named argument ` +
-    `or 'this.${original}' if it is a property on 'this'. ` +
-    "If it is a helper or component that has no arguments, " +
-    "you must either convert it to an angle bracket invocation " +
-    "or manually add it to the 'no-implicit-this' rule configuration, e.g. " +
-    `'no-implicit-this': { allow: ['${original}'] }.`
-  );
-}
-
-function isString(value) {
-  return typeof value === "string";
-}
-
-function isRegExp(value) {
-  return value instanceof RegExp;
-}
-
-function allowedFormat(value) {
-  return isString(value) || isRegExp(value);
-}
-
-// Allow Ember's builtin argless syntaxes
-export const ARGLESS_BUILTIN_HELPERS = [
-  "array",
-  "concat",
-  "debugger",
-  "has-block",
-  "hasBlock",
-  "has-block-params",
-  "hasBlockParams",
-  "hash",
-  "input",
-  "log",
-  "outlet",
-  "query-params",
-  "textarea",
-  "yield",
-  "unique-id",
-];
-
-// arg'less Components / Helpers in default ember-cli blueprint
-const ARGLESS_DEFAULT_BLUEPRINT = [
-  "welcome-page",
-  /* from app/index.html and tests/index.html */
-  "rootURL",
-];
-
-export default class NoImplicitThis extends Rule {
-  parseConfig(config) {
-    if (config === false || config === undefined || this.isStrictMode) {
-      return false;
-    }
-
-    switch (typeof config) {
-      case "undefined": {
-        return false;
-      }
-
-      case "boolean": {
-        if (config) {
-          return {
-            allow: [...ARGLESS_BUILTIN_HELPERS, ...ARGLESS_DEFAULT_BLUEPRINT],
-          };
-        } else {
-          return false;
-        }
-      }
-
-      case "object": {
-        if (Array.isArray(config.allow) && config.allow.every(allowedFormat)) {
-          return {
-            allow: [
-              ...ARGLESS_BUILTIN_HELPERS,
-              ...ARGLESS_DEFAULT_BLUEPRINT,
-              ...config.allow,
-            ],
-          };
-        }
-        break;
-      }
-    }
-
-    let errorMessage = createErrorMessage(
-      this.ruleName,
-      [
-        "  * boolean - `true` to enable / `false` to disable",
-        "  * object -- An object with the following keys:",
-        "    * `allow` -- An array of component / helper names for that may be called without arguments",
-      ],
-      config
-    );
-
-    throw new Error(errorMessage);
-  }
-
-  // The way this visitor works is a bit sketchy. We need to lint the PathExpressions
-  // in the callee position differently those in an argument position.
-  //
-  // Unfortunately, the current visitor API doesn't give us a good way to differentiate
-  // these two cases. Instead, we rely on the fact that the _first_ PathExpression that
-  // we enter after entering a MustacheStatement/BlockStatement/... will be the callee
-  // and we track this using a flag called `nextPathIsCallee`.
-  visitor() {
-    let nextPathIsCallee = false;
-
-    return {
-      PathExpression(path) {
-        if (nextPathIsCallee) {
-          // All paths are valid callees so there's nothing to check.
-        } else {
-          let valid =
-            path.data ||
-            path.this ||
-            this.isLocal(path) ||
-            this.config.allow.some((item) => {
-              return isRegExp(item)
-                ? item.test(path.original)
-                : item === path.original;
-            });
-
-          if (!valid) {
-            if (this.mode === "fix") {
-              path.original = `this.${path.original}`;
-            } else {
-              this.log({
-                message: message(path.original),
-                node: path,
-                isFixable: true,
-              });
-            }
-          }
-        }
-
-        nextPathIsCallee = false;
-      },
-
-      SubExpression() {
-        nextPathIsCallee = true;
-      },
-
-      ElementModifierStatement() {
-        nextPathIsCallee = true;
-      },
-
-      MustacheStatement(node) {
-        let isCall = node.params.length > 0 || node.hash.pairs.length > 0;
-
-        nextPathIsCallee = isCall;
-      },
-
-      BlockStatement: {
-        enter() {
-          nextPathIsCallee = true;
-        },
-      },
-    };
-  }
-}

package/template-lint-rules/plugin-outlet-lazy-hash.mjs

@@ -1,27 +0,0 @@
-import { Rule } from "ember-template-lint";
-
-export default class PluginOutletLazyHash extends Rule {
-  visitor() {
-    return {
-      ElementNode(node) {
-        if (node.tag === "PluginOutlet") {
-          const outletArgsAttr = node.attributes.find(
-            (attr) => attr.name === "@outletArgs"
-          );
-
-          if (
-            outletArgsAttr &&
-            outletArgsAttr.value.type === "MustacheStatement" &&
-            outletArgsAttr.value.path.original === "hash"
-          ) {
-            this.log({
-              message:
-                "Use {{lazyHash}} instead of {{hash}} for @outletArgs in <PluginOutlet>.",
-              node: outletArgsAttr.value,
-            });
-          }
-        }
-      },
-    };
-  }
-}

package/template-lint.config.cjs

@@ -1,65 +0,0 @@
-module.exports = {
-  extends: ["recommended", "stylistic"],
-  plugins: ["@discourse/lint-configs/template-lint-rules"],
-  ignore: ["**/*.js"],
-  rules: {
-    // Intentionally disabled default rules
-    "no-autofocus-attribute": false,
-    "no-positive-tabindex": false,
-    "require-mandatory-role-attributes": false,
-    "require-media-caption": false,
-
-    // Pending default rules
-    "link-href-attributes": false,
-    "no-at-ember-render-modifiers": false,
-    "no-curly-component-invocation": false,
-    "no-duplicate-landmark-elements": false,
-    "no-implicit-this": false,
-    "no-inline-styles": false,
-    "no-link-to-tagname": false,
-    "no-passed-in-event-handlers": false,
-    "no-route-action": false,
-    "require-input-label": false,
-    "require-presentational-children": false,
-    "require-valid-alt-text": false,
-
-    // Non-default rules
-    "no-unnecessary-curly-parens": true,
-    "no-unnecessary-curly-strings": true,
-    "simple-modifiers": true,
-    "no-chained-this": true,
-    "require-strict-mode": true,
-
-    // Pending non-default rules
-    "attribute-order": false,
-    "inline-link-to": false,
-    "no-builtin-form-components": false,
-    "no-this-in-template-only-components": false, // emits false-positives in gjs
-
-    // GJS compatibility
-    "modifier-name-case": false,
-
-    // Prettier compatibility
-    "block-indentation": false,
-    "eol-last": false,
-    quotes: false,
-    "self-closing-void-elements": false,
-
-    // Discourse custom
-    "discourse/no-at-class": true,
-    "discourse/no-implicit-this": {
-      allow: [
-        /-/, // kebab-case, probably a component or helper
-      ],
-    },
-    "discourse/plugin-outlet-lazy-hash": true,
-  },
-  overrides: [
-    {
-      files: ["**/*.gjs", "**/*.gts"],
-      rules: {
-        "discourse/no-implicit-this": false,
-      },
-    },
-  ],
-};