@discourse/lint-configs 2.43.0 → 2.44.1

package/eslint-rules/deprecated-imports.mjs

@@ -11,7 +11,7 @@ export default {
   create(context) {
     return {
       ImportDeclaration(node) {
-        function denyImporting(symbolName, messageTemplate) {
+        function denyImporting(symbolName, messageTemplate, fixFn) {
           const specifier = node.specifiers.find(
             (spec) => spec.imported && spec.imported.name === symbolName
           );
@@ -20,6 +20,7 @@ export default {
             context.report({
               node: specifier,
               message: messageTemplate(symbolName),
+              fix: fixFn ? (fixer) => fixFn(fixer, specifier) : undefined,
             });
           }
         }
@@ -69,7 +70,7 @@ export default {
             fix(fixer) {
               return fixer.replaceText(
                 node,
-                `import { htmlSafe } from "@ember/template";`
+                `import { trustHTML } from "@ember/template";`
               );
             },
           });
@@ -88,6 +89,38 @@ export default {
               );
             },
           });
+        } else if (node.source.value === "@ember/template") {
+          denyImporting(
+            "htmlSafe",
+            () =>
+              "'htmlSafe' is deprecated. Use 'trustHTML' from '@ember/template' instead.",
+            (fixer, specifier) => {
+              const fixes = [
+                fixer.replaceText(specifier.imported, "trustHTML"),
+              ];
+
+              if (specifier.local.name === specifier.imported.name) {
+                const moduleScope = context.sourceCode.scopeManager.scopes.find(
+                  (s) => s.type === "module"
+                );
+                const variable = moduleScope?.variables.find(
+                  (v) => v.name === specifier.local.name
+                );
+
+                if (variable) {
+                  for (const ref of variable.references) {
+                    if (ref.identifier !== specifier.local) {
+                      fixes.push(
+                        fixer.replaceText(ref.identifier, "trustHTML")
+                      );
+                    }
+                  }
+                }
+              }
+
+              return fixes;
+            }
+          );
         } else if (node.source.value === "@ember/array") {
           const messageTemplate = (symbolName) =>
             `Importing '${symbolName}' from '@ember/array' is deprecated. Use tracked arrays or native JavaScript arrays instead.`;
@@ -107,6 +140,38 @@ export default {
           denyDefaultImport(
             "Importing ArrayProxy (default) from '@ember/array/proxy' is deprecated. Use tracked arrays or native JavaScript arrays instead."
           );
+        } else if (node.source.value === "discourse/lib/tracked-tools") {
+          denyImporting(
+            "trackedArray",
+            () =>
+              "'trackedArray' is deprecated. Use 'autoTrackedArray' from 'discourse/lib/tracked-tools' instead.",
+            (fixer, specifier) => {
+              const fixes = [
+                fixer.replaceText(specifier.imported, "autoTrackedArray"),
+              ];
+
+              if (specifier.local.name === specifier.imported.name) {
+                const moduleScope = context.sourceCode.scopeManager.scopes.find(
+                  (s) => s.type === "module"
+                );
+                const variable = moduleScope?.variables.find(
+                  (v) => v.name === specifier.local.name
+                );
+
+                if (variable) {
+                  for (const ref of variable.references) {
+                    if (ref.identifier !== specifier.local) {
+                      fixes.push(
+                        fixer.replaceText(ref.identifier, "autoTrackedArray")
+                      );
+                    }
+                  }
+                }
+              }
+
+              return fixes;
+            }
+          );
         }
       },
     };

package/eslint-rules/migrate-tracked-built-ins-to-ember-collections.mjs

@@ -0,0 +1,395 @@
+import { collectImports } from "./utils/analyze-imports.mjs";
+import { fixImport } from "./utils/fix-import.mjs";
+
+const SPECIFIER_MAPPING = {
+  TrackedArray: "trackedArray",
+  TrackedObject: "trackedObject",
+  TrackedMap: "trackedMap",
+  TrackedSet: "trackedSet",
+  TrackedWeakMap: "trackedWeakMap",
+  TrackedWeakSet: "trackedWeakSet",
+};
+
+const OLD_SOURCES = new Set([
+  "@ember-compat/tracked-built-ins",
+  "tracked-built-ins",
+]);
+const NEW_SOURCE = "@ember/reactive/collections";
+
+function buildImportMessage(specifiersToTransform, oldSource) {
+  const oldNames = specifiersToTransform.map((s) => s.imported.name);
+  const newNames = oldNames.map((n) => SPECIFIER_MAPPING[n]);
+
+  const oldList = oldNames.map((n) => `'${n}'`).join(", ");
+  const newList = newNames.map((n) => `'${n}'`).join(", ");
+
+  const usageNotes = specifiersToTransform
+    .map((s) => {
+      const newName = SPECIFIER_MAPPING[s.imported.name];
+      const localName = s.local.name;
+      const callName = localName === s.imported.name ? newName : localName;
+      return `${callName}() instead of new ${localName}()`;
+    })
+    .join(", ");
+
+  return (
+    `Use ${newList} from '${NEW_SOURCE}' instead of ${oldList} from '${oldSource}'.` +
+    ` Note: use ${usageNotes}.`
+  );
+}
+
+function buildNonNewMessage(specifier) {
+  const oldName = specifier.imported.name;
+  const newName = SPECIFIER_MAPPING[oldName];
+
+  return (
+    `'${oldName}' must be migrated to '${NEW_SOURCE}', but this usage requires manual review.` +
+    ` The new module exports '${newName}' as a factory function, not a class,` +
+    ` so 'instanceof', class references, etc. will not work the same way.`
+  );
+}
+
+function buildNamingConflictMessage(specifier) {
+  const oldName = specifier.imported.name;
+  const newName = SPECIFIER_MAPPING[oldName];
+
+  return (
+    `Use \`${newName}\` from '${NEW_SOURCE}' instead of \`${oldName}\`:` +
+    ` \`${newName}\` conflicts with an existing binding. Rename the conflicting identifier first.`
+  );
+}
+
+function isNewExpression(ref) {
+  const parent = ref.identifier.parent;
+  return parent.type === "NewExpression" && parent.callee === ref.identifier;
+}
+
+function buildNewSpecifier(specifier) {
+  const oldName = specifier.imported.name;
+  const localName = specifier.local.name;
+  const newName = SPECIFIER_MAPPING[oldName] || oldName;
+
+  if (localName === oldName) {
+    return newName;
+  }
+  return `${newName} as ${localName}`;
+}
+
+function buildOldSpecifier(specifier) {
+  const oldName = specifier.imported.name;
+  const localName = specifier.local.name;
+
+  if (localName === oldName) {
+    return oldName;
+  }
+  return `${oldName} as ${localName}`;
+}
+
+/**
+ * Checks whether the new function name for a specifier would conflict with
+ * an existing binding in the module scope (excluding the old import itself).
+ *
+ * @param {import('estree').ImportSpecifier} specifier
+ * @param {import('eslint').Scope.Scope} moduleScope
+ * @returns {boolean}
+ */
+function hasNamingConflict(specifier, moduleScope) {
+  // Aliased imports won't introduce a new name — the alias stays the same
+  if (specifier.local.name !== specifier.imported.name) {
+    return false;
+  }
+
+  const newName = SPECIFIER_MAPPING[specifier.imported.name];
+  const variable = moduleScope?.variables.find((v) => v.name === newName);
+
+  // No variable with that name exists — no conflict
+  if (!variable) {
+    return false;
+  }
+
+  // If the variable's only definition is an import from one of the old sources,
+  // that's the import we're replacing — not a real conflict
+  const isFromOldImport = variable.defs.every(
+    (def) =>
+      def.type === "ImportBinding" && OLD_SOURCES.has(def.parent?.source?.value)
+  );
+
+  return !isFromOldImport;
+}
+
+/**
+ * Looks up the local name already used for a given new specifier name in the
+ * existing import from NEW_SOURCE. Returns the alias if found, or null.
+ *
+ * @param {string} newName - The new imported name (e.g. "trackedArray")
+ * @param {object|undefined} existingImportInfo - From collectImports
+ * @returns {string|null} The local alias, or null if not already imported
+ */
+function getExistingLocalName(newName, existingImportInfo) {
+  if (!existingImportInfo) {
+    return null;
+  }
+
+  const spec = existingImportInfo.specifiers.find(
+    (s) => s.type === "ImportSpecifier" && s.imported.name === newName
+  );
+
+  return spec ? spec.local.name : null;
+}
+
+export default {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description:
+        "Replace imports from '@ember-compat/tracked-built-ins' and 'tracked-built-ins'" +
+        ` with '${NEW_SOURCE}'`,
+    },
+    fixable: "code",
+    schema: [],
+  },
+
+  create(context) {
+    return {
+      ImportDeclaration(node) {
+        const oldSource = node.source.value;
+
+        if (!OLD_SOURCES.has(oldSource)) {
+          return;
+        }
+
+        const specifiersToTransform = node.specifiers.filter(
+          (s) =>
+            s.type === "ImportSpecifier" && SPECIFIER_MAPPING[s.imported.name]
+        );
+
+        // Report on `tracked` import separately — it's likely confused with
+        // @glimmer/tracking's `tracked` decorator. There's no auto-fix since
+        // the replacement depends on usage context.
+        const trackedSpecifier = node.specifiers.find(
+          (s) => s.type === "ImportSpecifier" && s.imported.name === "tracked"
+        );
+
+        if (trackedSpecifier) {
+          context.report({
+            node: trackedSpecifier,
+            message:
+              `'tracked' should not be imported from '${oldSource}'.` +
+              ` Use '@glimmer/tracking' for the @tracked decorator,` +
+              ` or use the specific factory functions from '${NEW_SOURCE}'` +
+              ` (e.g. trackedArray(), trackedMap(), trackedObject()).`,
+          });
+        }
+
+        if (specifiersToTransform.length === 0) {
+          return;
+        }
+
+        const moduleScope = context.sourceCode.scopeManager.scopes.find(
+          (s) => s.type === "module"
+        );
+
+        const imports = collectImports(context.sourceCode);
+        const existingNewSourceImport = imports.get(NEW_SOURCE);
+
+        // Classify each specifier as fixable or unfixable
+        const fixable = [];
+        const unfixable = [];
+        const nonNewRefs = [];
+        const namingConflicts = [];
+
+        for (const specifier of specifiersToTransform) {
+          const variable = moduleScope?.variables.find(
+            (v) => v.name === specifier.local.name
+          );
+
+          let specifierIsFixable = true;
+
+          if (variable) {
+            for (const ref of variable.references) {
+              if (!isNewExpression(ref)) {
+                specifierIsFixable = false;
+                nonNewRefs.push({ ref, specifier });
+              }
+            }
+          }
+
+          // Check naming conflicts only for specifiers that would otherwise
+          // be fixable and that don't already exist in the new source import
+          if (specifierIsFixable) {
+            const newName = SPECIFIER_MAPPING[specifier.imported.name];
+            const alreadyImported = getExistingLocalName(
+              newName,
+              existingNewSourceImport
+            );
+
+            if (!alreadyImported && hasNamingConflict(specifier, moduleScope)) {
+              specifierIsFixable = false;
+              namingConflicts.push(specifier);
+            }
+          }
+
+          if (specifierIsFixable) {
+            fixable.push(specifier);
+          } else {
+            unfixable.push(specifier);
+          }
+        }
+
+        const hasFix = fixable.length > 0;
+
+        // Specifiers not in SPECIFIER_MAPPING (e.g. `tracked`) that must stay
+        // on the old import if we split
+        const unmappedSpecifiers = node.specifiers.filter(
+          (s) =>
+            s.type === "ImportSpecifier" && !SPECIFIER_MAPPING[s.imported.name]
+        );
+
+        // Report on import node
+        context.report({
+          node,
+          message: buildImportMessage(specifiersToTransform, oldSource),
+          fix: hasFix
+            ? (fixer) => {
+                const fixes = [];
+                const keepOnOld = [
+                  ...unfixable.map(buildOldSpecifier),
+                  ...unmappedSpecifiers.map(buildOldSpecifier),
+                ];
+
+                if (existingNewSourceImport) {
+                  // Merge into existing import from NEW_SOURCE
+                  const specifiersToAdd = [];
+
+                  for (const specifier of fixable) {
+                    const newName = SPECIFIER_MAPPING[specifier.imported.name];
+                    const alreadyImported = getExistingLocalName(
+                      newName,
+                      existingNewSourceImport
+                    );
+
+                    if (!alreadyImported) {
+                      specifiersToAdd.push(buildNewSpecifier(specifier));
+                    }
+                  }
+
+                  // Add new specifiers to the existing import
+                  if (specifiersToAdd.length > 0) {
+                    fixes.push(
+                      fixImport(fixer, existingNewSourceImport.node, {
+                        namedImportsToAdd: specifiersToAdd,
+                      })
+                    );
+                  }
+
+                  // Remove or trim the old import
+                  if (keepOnOld.length === 0) {
+                    fixes.push(fixer.remove(node));
+                  } else {
+                    fixes.push(
+                      fixer.replaceText(
+                        node,
+                        `import { ${keepOnOld.join(", ")} } from "${oldSource}";`
+                      )
+                    );
+                  }
+                } else if (keepOnOld.length === 0) {
+                  // All fixable: replace entire import with new source
+                  const newSpecifiers =
+                    specifiersToTransform.map(buildNewSpecifier);
+
+                  fixes.push(
+                    fixer.replaceText(
+                      node,
+                      `import { ${newSpecifiers.join(", ")} } from "${NEW_SOURCE}";`
+                    )
+                  );
+                } else {
+                  // Partial fix: split into two imports
+                  const newSpecifiers = fixable.map(buildNewSpecifier);
+
+                  fixes.push(
+                    fixer.replaceText(
+                      node,
+                      `import { ${keepOnOld.join(", ")} } from "${oldSource}";\n` +
+                        `import { ${newSpecifiers.join(", ")} } from "${NEW_SOURCE}";`
+                    )
+                  );
+                }
+
+                // Fix usage sites for fixable specifiers
+                for (const specifier of fixable) {
+                  const localName = specifier.local.name;
+                  const isAliased = localName !== specifier.imported.name;
+                  const newFunctionName =
+                    SPECIFIER_MAPPING[specifier.imported.name];
+
+                  // Determine the name to use at call sites — if the new
+                  // source already imports this with an alias, use that alias
+                  const existingLocal = getExistingLocalName(
+                    newFunctionName,
+                    existingNewSourceImport
+                  );
+                  const callSiteName = existingLocal || newFunctionName;
+
+                  const variable = moduleScope?.variables.find(
+                    (v) => v.name === localName
+                  );
+                  if (!variable) {
+                    continue;
+                  }
+
+                  for (const ref of variable.references) {
+                    const parent = ref.identifier.parent;
+
+                    if (
+                      parent.type === "NewExpression" &&
+                      parent.callee === ref.identifier
+                    ) {
+                      // Remove `new ` keyword
+                      fixes.push(
+                        fixer.removeRange([
+                          parent.range[0],
+                          parent.callee.range[0],
+                        ])
+                      );
+
+                      // Rename identifier to the correct call-site name
+                      if (existingLocal) {
+                        // Use the alias from the existing import
+                        fixes.push(
+                          fixer.replaceText(ref.identifier, existingLocal)
+                        );
+                      } else if (!isAliased) {
+                        fixes.push(
+                          fixer.replaceText(ref.identifier, callSiteName)
+                        );
+                      }
+                    }
+                  }
+                }
+
+                return fixes;
+              }
+            : null,
+        });
+
+        // Report on each non-new reference
+        for (const { ref, specifier } of nonNewRefs) {
+          context.report({
+            node: ref.identifier,
+            message: buildNonNewMessage(specifier),
+          });
+        }
+
+        // Report on each naming conflict
+        for (const specifier of namingConflicts) {
+          context.report({
+            node: specifier,
+            message: buildNamingConflictMessage(specifier),
+          });
+        }
+      },
+    };
+  },
+};

package/eslint.mjs

@@ -21,6 +21,7 @@ import keepArraySorted from "./eslint-rules/keep-array-sorted.mjs";
 import lineAfterImports from "./eslint-rules/line-after-imports.mjs";
 import lineBeforeDefaultExport from "./eslint-rules/line-before-default-export.mjs";
 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 noCurlyComponents from "./eslint-rules/no-curly-components.mjs";
 import noDiscourseComputed from "./eslint-rules/no-discourse-computed.mjs";
@@ -148,6 +149,8 @@ export default [
           "no-discourse-computed": noDiscourseComputed,
           "test-filename-suffix": testFilenameSuffix,
           "no-unnecessary-tracked": noUnnecessaryTracked,
+          "migrate-tracked-built-ins-to-ember-collections":
+            migrateTrackedBuiltInsToEmberCollections,
         },
       },
     },
@@ -278,14 +281,7 @@ export default [
               "",
               // Internal
               "^discourse/",
-              "^discourse-common/",
               "^discourse-.+",
-              "^admin/",
-              "^wizard/",
-              "^I18n$",
-              "^select-kit/",
-              "^float-kit/",
-              "^truth-helpers/",
               // Plugins
               "^discourse/plugins/",
               // Relative
@@ -320,6 +316,7 @@ export default [
       "discourse/keep-array-sorted": ["error"],
       "discourse/no-discourse-computed": ["error"],
       "discourse/no-unnecessary-tracked": ["warn"],
+      "discourse/migrate-tracked-built-ins-to-ember-collections": ["error"],
     },
   },
   {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@discourse/lint-configs",
-  "version": "2.43.0",
+  "version": "2.44.1",
   "description": "Shareable lint configs for Discourse core, plugins, and themes",
   "author": "Discourse",
   "license": "MIT",
@@ -45,7 +45,7 @@
     "globals": "^17.4.0",
     "prettier": "^3.8.1",
     "prettier-plugin-ember-template-tag": "^2.1.3",
-    "stylelint": "^17.4.0",
+    "stylelint": "^17.5.0",
     "stylelint-config-standard": "^40.0.0",
     "stylelint-config-standard-scss": "^17.0.0",
     "stylelint-scss": "^7.0.0",
@@ -55,7 +55,7 @@
     "ember-template-lint": "7.9.3",
     "eslint": "9.39.2",
     "prettier": "3.8.1",
-    "stylelint": "17.4.0"
+    "stylelint": "17.5.0"
   },
   "scripts": {
     "lint": "eslint --no-error-on-unmatched-pattern \"**/*.{cjs,mjs,js}\" && pnpm prettier --check \"**/*.{cjs,mjs,js}\"",

package/stylelint.mjs

@@ -33,6 +33,12 @@ export default {
       true,
       { ignoreKeywords: ["break-word"] },
     ],
+    "value-keyword-case": [
+      "lower",
+      {
+        ignoreProperties: ["/^\\$/", "font", "font-family"],
+      },
+    ],
 
     "discourse/no-breakpoint-mixin": true,
   },