@discourse/lint-configs 2.9.0 → 2.11.0

package/eslint-rules/deprecated-lookups.mjs

@@ -18,12 +18,11 @@ export default {
     docs: {
       description:
         "replace deprecated resolver 'lookup' calls and modifyClass arguments with modern equivalents",
-      category: "Best Practices",
-      recommended: true,
     },
     fixable: "code",
     schema: [], // no options
   },
+
   create(context) {
     return {
       CallExpression(node) {

package/eslint-rules/discourse-common-imports.mjs

@@ -4,12 +4,11 @@ export default {
     docs: {
       description:
         "disallow imports from 'discourse-common' and replace with modern equivalents",
-      category: "Best Practices",
-      recommended: false,
     },
     fixable: "code",
     schema: [], // no options
   },
+
   create(context) {
     return {
       ImportDeclaration(node) {

package/eslint-rules/i18n-import-location.mjs

@@ -6,12 +6,11 @@ export default {
     docs: {
       description:
         "disallow imports from 'i18n' and replace with 'discourse-i18n'",
-      category: "Best Practices",
-      recommended: false,
     },
     fixable: "code",
     schema: [], // no options
   },
+
   create(context) {
     return {
       ImportDeclaration(node) {
@@ -27,12 +26,12 @@ export default {
         }
 
         if (
-          node.source.value.toLowerCase() === "discourse-common/helpers/i18n"
+          node.source.value.toLowerCase() === "discourse-common/helpers/i18n" ||
+          node.source.value.toLowerCase() === "discourse/helpers/i18n"
         ) {
           context.report({
             node,
-            message:
-              "Import from 'discourse-common/helpers/i18n' is not allowed. Use 'discourse-i18n' instead.",
+            message: `Import from '${node.source.value}' is not allowed. Use 'discourse-i18n' instead.`,
             fix(fixer) {
               const existingImport = context
                 .getSourceCode()

package/eslint-rules/i18n-t.mjs

@@ -5,12 +5,11 @@ export default {
     type: "suggestion",
     docs: {
       description: "Use i18n(...) instead of 'I18n.t(...)'.",
-      category: "Best Practices",
-      recommended: false,
     },
     fixable: "code",
     schema: [], // no options
   },
+
   create(context) {
     const sourceCode = context.sourceCode ?? context.getSourceCode();
     let alreadyFixedImport = false;
@@ -53,7 +52,7 @@ export default {
             const fixes = [];
 
             // Replace I18n.t with i18n
-            fixes.push(fixer.replaceText(node, `i18n`));
+            fixes.push(fixer.replaceText(node, "i18n"));
 
             if (!alreadyFixedImport) {
               const importDeclaration = i18nDefaultImport.node.parent;

package/eslint-rules/line-after-imports.mjs

@@ -0,0 +1,91 @@
+import {
+  findFirstConsecutiveTokenBefore,
+  findLastConsecutiveTokenAfter,
+  getBoundaryTokens,
+  hasTokenOrCommentBetween,
+} from "./utils/tokens.mjs";
+
+function findLastIndexOfType(nodes, type) {
+  return nodes.findLastIndex((node) => node.type === type);
+}
+
+export default {
+  meta: {
+    type: "layout",
+    docs: {
+      description: "Require an empty line after the imports block",
+    },
+    fixable: "whitespace",
+    schema: [], // no options
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    return {
+      Program(node) {
+        const body = node.body;
+        const index = findLastIndexOfType(body, "ImportDeclaration");
+
+        if (index === -1) {
+          // No imports
+          return;
+        }
+
+        if (!body[index + 1]) {
+          // Nothing after imports
+          return;
+        }
+
+        const { curLast, nextFirst } = getBoundaryTokens(
+          sourceCode,
+          body[index],
+          body[index + 1]
+        );
+
+        const beforePadding = findLastConsecutiveTokenAfter(
+          sourceCode,
+          curLast,
+          nextFirst,
+          1
+        );
+        const afterPadding = findFirstConsecutiveTokenBefore(
+          sourceCode,
+          nextFirst,
+          curLast,
+          1
+        );
+        const isPadded =
+          afterPadding.loc.start.line - beforePadding.loc.end.line > 1;
+        const hasTokenInPadding = hasTokenOrCommentBetween(
+          sourceCode,
+          beforePadding,
+          afterPadding
+        );
+        const curLineLastToken = findLastConsecutiveTokenAfter(
+          sourceCode,
+          curLast,
+          nextFirst,
+          0
+        );
+
+        if (isPadded) {
+          return;
+        }
+
+        context.report({
+          node: body[index],
+          message: "Expected blank line after imports.",
+
+          fix(fixer) {
+            if (hasTokenInPadding) {
+              return null;
+            }
+
+            return fixer.insertTextAfter(curLineLastToken, "\n");
+          },
+        });
+      },
+    };
+  },
+};

package/eslint-rules/lines-between-class-members.mjs

@@ -0,0 +1,171 @@
+// Based on `@stylistic/js/lines-between-class-members`
+// See: https://github.com/eslint-stylistic/eslint-stylistic/blob/d6809c910510a4477e01ea248071f0701d0af4ed/packages/eslint-plugin/rules/lines-between-class-members/lines-between-class-members._js_.ts
+
+import {
+  findFirstConsecutiveTokenBefore,
+  findLastConsecutiveTokenAfter,
+  getBoundaryTokens,
+  hasTokenOrCommentBetween,
+  isTokenOnSameLine,
+} from "./utils/tokens.mjs";
+
+export default {
+  meta: {
+    type: "layout",
+    docs: {
+      description: "Require an empty line between class members",
+    },
+    fixable: "whitespace",
+    schema: [], // no options
+    messages: {
+      never: "Unexpected blank line between class members.",
+      always: "Expected blank line between class members.",
+    },
+  },
+
+  create(context) {
+    const configureList = [
+      { blankLine: "always", prev: "service", next: "*" },
+      { blankLine: "always", prev: "*", next: "method" },
+      { blankLine: "always", prev: "method", next: "*" },
+      { blankLine: "always", prev: "*", next: "template" },
+    ];
+    const sourceCode = context.sourceCode;
+
+    /**
+     * Returns the type of the node.
+     * @param node The class member node to check.
+     * @returns The type string (see `configureList`)
+     * @private
+     */
+    function nodeType(node) {
+      if (
+        node.type === "PropertyDefinition" &&
+        ["service", "optionalService", "controller"].includes(
+          node.decorators?.[0]?.expression?.name ||
+            node.decorators?.[0]?.expression?.callee?.name
+        )
+      ) {
+        return "service";
+      } else if (node.type === "PropertyDefinition") {
+        return "field";
+      } else if (node.type === "MethodDefinition") {
+        return "method";
+      } else if (node.type === "GlimmerTemplate") {
+        return "template";
+      } else {
+        return "other";
+      }
+    }
+
+    /**
+     * Checks whether the given node matches the given type.
+     * @param node The class member node to check.
+     * @param type The class member type to check.
+     * @returns `true` if the class member node matched the type.
+     * @private
+     */
+    function match(node, type) {
+      if (type === "*") {
+        return true;
+      }
+
+      return nodeType(node) === type;
+    }
+
+    /**
+     * Finds the last matched configuration from the configureList.
+     * @param prevNode The previous node to match.
+     * @param nextNode The current node to match.
+     * @returns Padding type or `null` if no matches were found.
+     * @private
+     */
+    function getPaddingType(prevNode, nextNode) {
+      for (let i = configureList.length - 1; i >= 0; --i) {
+        const configure = configureList[i];
+        const matched =
+          match(prevNode, configure.prev) && match(nextNode, configure.next);
+
+        if (matched) {
+          return configure.blankLine;
+        }
+      }
+      return null;
+    }
+
+    return {
+      ClassBody(node) {
+        const body = node.body;
+
+        for (let i = 0; i < body.length - 1; i++) {
+          const curFirst = sourceCode.getFirstToken(body[i]);
+          const { curLast, nextFirst } = getBoundaryTokens(
+            sourceCode,
+            body[i],
+            body[i + 1]
+          );
+          const singleLine = isTokenOnSameLine(curFirst, curLast);
+          const skip =
+            singleLine && nodeType(body[i]) === nodeType(body[i + 1]);
+          const beforePadding = findLastConsecutiveTokenAfter(
+            sourceCode,
+            curLast,
+            nextFirst,
+            1
+          );
+          const afterPadding = findFirstConsecutiveTokenBefore(
+            sourceCode,
+            nextFirst,
+            curLast,
+            1
+          );
+          const isPadded =
+            afterPadding.loc.start.line - beforePadding.loc.end.line > 1;
+          const hasTokenInPadding = hasTokenOrCommentBetween(
+            sourceCode,
+            beforePadding,
+            afterPadding
+          );
+          const curLineLastToken = findLastConsecutiveTokenAfter(
+            sourceCode,
+            curLast,
+            nextFirst,
+            0
+          );
+          const paddingType = getPaddingType(body[i], body[i + 1]);
+
+          if (paddingType === "never" && isPadded) {
+            context.report({
+              node: body[i + 1],
+              messageId: "never",
+
+              fix(fixer) {
+                if (hasTokenInPadding) {
+                  return null;
+                }
+
+                return fixer.replaceTextRange(
+                  [beforePadding.range[1], afterPadding.range[0]],
+                  "\n"
+                );
+              },
+            });
+          } else if (paddingType === "always" && !skip && !isPadded) {
+            context.report({
+              node: body[i + 1],
+              messageId: "always",
+
+              fix(fixer) {
+                if (hasTokenInPadding) {
+                  return null;
+                }
+
+                return fixer.insertTextAfter(curLineLastToken, "\n");
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/eslint-rules/{no-simple-queryselector.mjs → no-simple-query-selector.mjs}

@@ -1,16 +1,14 @@
-// no-queryselector-body-html.mjs
 export default {
   meta: {
     type: "problem",
     docs: {
       description:
         'disallow document.querySelector("body") and document.querySelector("html")',
-      category: "Best Practices",
-      recommended: false,
     },
     fixable: "code",
     schema: [], // no options
   },
+
   create(context) {
     return {
       CallExpression(node) {

package/eslint-rules/service-inject-import.mjs

@@ -3,12 +3,11 @@ export default {
     type: "suggestion",
     docs: {
       description: "Convert 'inject as service' to 'service'",
-      category: "Best Practices",
-      recommended: false,
     },
     fixable: "code",
     schema: [], // no options
   },
+
   create(context) {
     return {
       ImportDeclaration(node) {

package/eslint-rules/utils/tokens.mjs

@@ -0,0 +1,128 @@
+export function isTokenOnSameLine(left, right) {
+  return left?.loc?.end.line === right?.loc?.start.line;
+}
+
+export function isSemicolonToken(token) {
+  return token.value === ";" && token.type === "Punctuator";
+}
+
+/**
+ * Gets a pair of tokens that should be used to check lines between two class member nodes.
+ *
+ * In most cases, this returns the very last token of the current node and
+ * the very first token of the next node.
+ * For example:
+ *
+ *     class C {
+ *         x = 1;   // curLast: `;` nextFirst: `in`
+ *         in = 2
+ *     }
+ *
+ * There is only one exception. If the given node ends with a semicolon, and it looks like
+ * a semicolon-less style's semicolon - one that is not on the same line as the preceding
+ * token, but is on the line where the next class member starts - this returns the preceding
+ * token and the semicolon as boundary tokens.
+ * For example:
+ *
+ *     class C {
+ *         x = 1    // curLast: `1` nextFirst: `;`
+ *         ;in = 2
+ *     }
+ * When determining the desired layout of the code, we should treat this semicolon as
+ * a part of the next class member node instead of the one it technically belongs to.
+ * @param curNode Current class member node.
+ * @param nextNode Next class member node.
+ * @returns The actual last token of `node`.
+ * @private
+ */
+export function getBoundaryTokens(sourceCode, curNode, nextNode) {
+  const lastToken = sourceCode.getLastToken(curNode);
+  const prevToken = sourceCode.getTokenBefore(lastToken);
+  const nextToken = sourceCode.getFirstToken(nextNode); // skip possible lone `;` between nodes
+
+  const isSemicolonLessStyle =
+    isSemicolonToken(lastToken) &&
+    !isTokenOnSameLine(prevToken, lastToken) &&
+    isTokenOnSameLine(lastToken, nextToken);
+
+  return isSemicolonLessStyle
+    ? { curLast: prevToken, nextFirst: lastToken }
+    : { curLast: lastToken, nextFirst: nextToken };
+}
+
+/**
+ * Return the last token among the consecutive tokens that have no exceed max line difference in between, before the first token in the next member.
+ * @param prevLastToken The last token in the previous member node.
+ * @param nextFirstToken The first token in the next member node.
+ * @param maxLine The maximum number of allowed line difference between consecutive tokens.
+ * @returns  The last token among the consecutive tokens.
+ */
+export function findLastConsecutiveTokenAfter(
+  sourceCode,
+  prevLastToken,
+  nextFirstToken,
+  maxLine
+) {
+  const after = sourceCode.getTokenAfter(prevLastToken, {
+    includeComments: true,
+  });
+
+  if (
+    after !== nextFirstToken &&
+    after.loc.start.line - prevLastToken.loc.end.line <= maxLine
+  ) {
+    return findLastConsecutiveTokenAfter(
+      sourceCode,
+      after,
+      nextFirstToken,
+      maxLine
+    );
+  }
+
+  return prevLastToken;
+}
+
+/**
+ * Return the first token among the consecutive tokens that have no exceed max line difference in between, after the last token in the previous member.
+ * @param nextFirstToken The first token in the next member node.
+ * @param prevLastToken The last token in the previous member node.
+ * @param maxLine The maximum number of allowed line difference between consecutive tokens.
+ * @returns The first token among the consecutive tokens.
+ */
+export function findFirstConsecutiveTokenBefore(
+  sourceCode,
+  nextFirstToken,
+  prevLastToken,
+  maxLine
+) {
+  const before = sourceCode.getTokenBefore(nextFirstToken, {
+    includeComments: true,
+  });
+
+  if (
+    before !== prevLastToken &&
+    nextFirstToken.loc.start.line - before.loc.end.line <= maxLine
+  ) {
+    return findFirstConsecutiveTokenBefore(
+      sourceCode,
+      before,
+      prevLastToken,
+      maxLine
+    );
+  }
+
+  return nextFirstToken;
+}
+
+/**
+ * Checks if there is a token or comment between two tokens.
+ * @param before The token before.
+ * @param after The token after.
+ * @returns True if there is a token or comment between two tokens.
+ */
+export function hasTokenOrCommentBetween(sourceCode, before, after) {
+  return (
+    sourceCode.getTokensBetween(before, after, { includeComments: true })
+      .length !== 0
+  );
+}

package/eslint.config.mjs

@@ -1,2 +1,3 @@
 import DiscourseRecommended from "./eslint.mjs";
+
 export default DiscourseRecommended;

package/eslint.mjs

@@ -2,11 +2,11 @@ import { createConfigItem } from "@babel/core";
 import BabelParser from "@babel/eslint-parser";
 import PluginProposalDecorators from "@babel/plugin-proposal-decorators";
 import js from "@eslint/js";
-import stylisticJs from "@stylistic/eslint-plugin-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 ImportPlugin from "eslint-plugin-import";
 import QUnitPlugin from "eslint-plugin-qunit";
 import QUnitRecommended from "eslint-plugin-qunit/configs/recommended";
 import SimpleImportSort from "eslint-plugin-simple-import-sort";
@@ -16,7 +16,9 @@ import deprecatedLookups from "./eslint-rules/deprecated-lookups.mjs";
 import discourseCommonImports from "./eslint-rules/discourse-common-imports.mjs";
 import i18nImport from "./eslint-rules/i18n-import-location.mjs";
 import i18nT from "./eslint-rules/i18n-t.mjs";
-import noSimpleQueryselector from "./eslint-rules/no-simple-queryselector.mjs";
+import lineAfterImports from "./eslint-rules/line-after-imports.mjs";
+import linesBetweenClassMembers from "./eslint-rules/lines-between-class-members.mjs";
+import noSimpleQuerySelector from "./eslint-rules/no-simple-query-selector.mjs";
 import serviceInjectImport from "./eslint-rules/service-inject-import.mjs";
 
 // Copied from "ember-template-imports/lib/utils"
@@ -95,20 +97,22 @@ export default [
       },
     },
     plugins: {
-      "@stylistic/js": stylisticJs,
       ember: EmberPlugin,
       "sort-class-members": SortClassMembers,
       "decorator-position": DecoratorPosition,
       "simple-import-sort": SimpleImportSort,
       qunit: QUnitPlugin,
+      import: ImportPlugin,
       discourse: {
         rules: {
           "i18n-import-location": i18nImport,
           "i18n-t": i18nT,
           "service-inject-import": serviceInjectImport,
-          "no-simple-queryselector": noSimpleQueryselector,
+          "no-simple-query-selector": noSimpleQuerySelector,
           "deprecated-lookups": deprecatedLookups,
           "discourse-common-imports": discourseCommonImports,
+          "lines-between-class-members": linesBetweenClassMembers,
+          "line-after-imports": lineAfterImports,
         },
       },
     },
@@ -156,19 +160,9 @@ export default [
       "valid-typeof": "error",
       "wrap-iife": ["error", "inside"],
       curly: "error",
-      "no-duplicate-imports": "error",
+      "import/no-duplicates": "error",
       "object-shorthand": ["error", "properties"],
       "no-dupe-class-members": "error",
-      "@stylistic/js/lines-between-class-members": [
-        "error",
-        {
-          enforce: [
-            { blankLine: "always", prev: "*", next: "method" },
-            { blankLine: "always", prev: "method", next: "*" },
-          ],
-        },
-        { exceptAfterSingleLine: true },
-      ],
       "ember/no-classic-components": "off",
       "ember/no-component-lifecycle-hooks": "off",
       "ember/require-tagless-components": "off",
@@ -191,7 +185,6 @@ export default [
       "ember/classic-decorator-hooks": "off",
       "ember/classic-decorator-no-classic-methods": "off",
       "ember/no-actions-hash": "off",
-      "ember/no-classic-classes": "off",
       "ember/no-tracked-properties-from-args": "off",
       "ember/no-jquery": "off",
       "ember/no-runloop": "off",
@@ -287,9 +280,11 @@ export default [
       "discourse/i18n-import-location": ["error"],
       "discourse/i18n-t": ["error"],
       "discourse/service-inject-import": ["error"],
-      "discourse/no-simple-queryselector": ["error"],
+      "discourse/no-simple-query-selector": ["error"],
       "discourse/deprecated-lookups": ["error"],
       "discourse/discourse-common-imports": ["error"],
+      "discourse/lines-between-class-members": ["error"],
+      "discourse/line-after-imports": ["error"],
     },
   },
   {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@discourse/lint-configs",
-  "version": "2.9.0",
+  "version": "2.11.0",
   "description": "Shareable lint configs for Discourse core, plugins, and themes",
   "author": "Discourse",
   "license": "MIT",
@@ -33,11 +33,11 @@
     "@babel/core": "^7.26.9",
     "@babel/eslint-parser": "^7.26.8",
     "@babel/plugin-proposal-decorators": "^7.25.9",
-    "@stylistic/eslint-plugin-js": "^4.2.0",
-    "ember-template-lint": "^7.0.0",
-    "eslint": "^9.21.0",
+    "ember-template-lint": "^7.0.1",
+    "eslint": "^9.22.0",
     "eslint-plugin-decorator-position": "^6.0.0",
     "eslint-plugin-ember": "^12.5.0",
+    "eslint-plugin-import": "^2.31.0",
     "eslint-plugin-qunit": "^8.1.2",
     "eslint-plugin-simple-import-sort": "^12.1.1",
     "eslint-plugin-sort-class-members": "^1.21.0",
@@ -50,8 +50,8 @@
     "typescript": "^5.8.2"
   },
   "peerDependencies": {
-    "ember-template-lint": "7.0.0",
-    "eslint": "9.21.0",
+    "ember-template-lint": "7.0.1",
+    "eslint": "9.22.0",
     "prettier": "3.5.3",
     "stylelint": "16.15.0"
   }