@ethlete/eslint-plugin 1.0.0-next.23 → 1.0.0-next.25

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # Changelog
 
+## 1.0.0-next.25
+
+### Minor Changes
+
+- The `@angular-eslint/*` output rules moved from `recommendedTs` into a new `recommendedAngularTs` config, which `recommended` includes, so NestJS and other non-Angular projects can use `recommendedTs` without the `@angular-eslint` plugin.
+- `recommendedTs` now uses `ethlete/consistent-type-definitions` instead of `@typescript-eslint/consistent-type-definitions`, so `--fix` no longer turns an interface inside `declare module` or `declare global` (such as the theme-name registry the `@ethlete/core` generators emit) into a type alias that merges into nothing.
+- New `no-csp-unsafe` rule (error in `recommendedTs` and `recommendedTemplate`) flags style attributes, un-nonced `<script>`/`<style>` elements, `eval` and string timers that a strict CSP blocks.
+- `et update` turns the type aliases the old `consistent-type-definitions` fix left in `declare module` and `declare global` blocks back into interfaces, and renames the rule in `eslint-disable` directives.
+- `prefer-linked-signal` now also reports an `effect()` that only calls `.set()` behind an `if`/`else`.
+
+### Patch Changes
+
+- `ethlete/no-csp-unsafe` fixes a static template `style="…"` attribute. It rewrites `style="width: 40%; margin-top: 4px"` to `[style]="{ width: '40%', 'margin-top': '4px' }"`, which a strict CSP allows. A value with a quote, `url(`, `!important` or a comment stays a manual fix.
+
+## 1.0.0-next.24
+
+### Minor Changes
+
+- Add `take-until-destroyed-last` to the recommended config: `takeUntilDestroyed()` must be the last operator in a `.pipe()`, since an operator after it can keep the subscription alive.
+
+### Patch Changes
+
+- `class-member-order` now fixes classes with `static` members or index signatures and keeps a trailing comment with its member, and `prefer-concise-angular-host-directives` no longer drops or misplaces comments.
+- Angular and RxJS rules now resolve `Component`, `inject`, `input`, `effect` and friends through their imports, `document` and `setTimeout` match only the globals, and import bans also report re-exports and dynamic imports.
+- Several fixers no longer emit broken code (a dangling `other._value`, a duplicate `styleUrl`, a dropped `host` spread), `no-trivial-return-type` checks function declarations, `no-screaming-case-local` reports a function once, and `standalone` sorts after `selector`.
+
 ## 1.0.0-next.23
 
 ### Minor Changes

package/migrations.json

@@ -0,0 +1,12 @@
+{
+  "migrations": [
+    {
+      "name": "module-augmentation-interfaces",
+      "version": "1.0.0-next.25",
+      "kind": "auto",
+      "description": "Turn the type aliases the old consistent-type-definitions fix left in declare module / declare global blocks back into interfaces, and rename its eslint-disable directives to ethlete/consistent-type-definitions.",
+      "generator": "@ethlete/eslint-plugin:restore-module-augmentation-interfaces",
+      "docs": "/eslint/rules"
+    }
+  ]
+}

package/package.json

@@ -1,14 +1,24 @@
 {
   "name": "@ethlete/eslint-plugin",
-  "version": "1.0.0-next.23",
+  "version": "1.0.0-next.25",
   "license": "MIT",
   "type": "commonjs",
   "main": "./src/index.js",
   "peerDependencies": {
     "@angular-eslint/eslint-plugin-template": ">=21.0.0",
     "@angular/core": ">=21.0.0",
+    "@nx/devkit": ">=21.0.0",
     "@typescript-eslint/eslint-plugin": ">=8.0.0",
     "eslint": ">=9.0.0",
     "typescript": ">=5.9.0"
-  }
-}
+  },
+  "peerDependenciesMeta": {
+    "@nx/devkit": {
+      "optional": true
+    }
+  },
+  "ethlete": {
+    "migrations": "./migrations.json"
+  },
+  "generators": "./src/generators/generators.json"
+}

package/src/configs/recommended.js

@@ -15,8 +15,8 @@ const recommendedTs = {
   rules: {
     // ── TypeScript ──────────────────────────────────────────────────────────
 
-    // No interface — use type
-    '@typescript-eslint/consistent-type-definitions': ['error', 'type'],
+    // No interface — use type (owned by ethlete/consistent-type-definitions)
+    '@typescript-eslint/consistent-type-definitions': 'off',
 
     // No any
     '@typescript-eslint/no-explicit-any': 'error',
@@ -239,12 +239,18 @@ const recommendedTs = {
     // No .subscribe() inside a .pipe() callback
     'ethlete/no-subscribe-in-pipe': 'error',
 
+    // takeUntilDestroyed() is the last operator in a .pipe()
+    'ethlete/take-until-destroyed-last': 'error',
+
     // No async/await — asynchronous work is modelled as cold Observables
     'ethlete/no-async-await': 'error',
 
     // No enum / const enum — use a const object with `as const` plus a derived union type
     'ethlete/no-enum': 'error',
 
+    // No interface — use type; an interface augmenting a module or the global scope is exempt
+    'ethlete/consistent-type-definitions': 'error',
+
     // No .subscribe() inside effect() or computed()
     'ethlete/no-rxjs-in-effect': 'error',
 
@@ -308,6 +314,10 @@ const recommendedTs = {
     // — use getCookie / setCookie / hasCookie / deleteCookie from '@ethlete/core' instead
     'ethlete/no-document-cookie': 'error',
 
+    // No code a strict CSP (no 'unsafe-inline' / 'unsafe-eval') blocks: style attributes,
+    // un-nonced <script>/<style> elements, eval / new Function / string timers
+    'ethlete/no-csp-unsafe': 'error',
+
     // Injected providers must be private by default, and protected only when
     // referenced from an Angular template or host binding.
     'ethlete/inject-member-accessibility': 'error',
@@ -347,14 +357,6 @@ const recommendedTs = {
     // Angular language service completions for the rest of the file
     'ethlete/no-template-literal-before-inline-template': 'error',
 
-    // ── Angular outputs ─────────────────────────────────────────────────────
-
-    // No on-prefixed outputs (onSelectDate → selectDate)
-    '@angular-eslint/no-output-on-prefix': 'error',
-
-    // No outputs named after native DOM events (change, click, etc.)
-    '@angular-eslint/no-output-native': 'error',
-
     // ── Angular components ──────────────────────────────────────────────────
 
     // Require ChangeDetectionStrategy.OnPush on Angular <= 21, where it is opt-in
@@ -399,6 +401,23 @@ const recommendedTs = {
   },
 };
 
+/**
+ * `@angular-eslint/*` rules for TypeScript files in Angular projects; the base config must register
+ * the `@angular-eslint` plugin.
+ *
+ * @type {import('eslint').Linter.Config}
+ */
+const recommendedAngularTs = {
+  files: ['**/*.ts'],
+  rules: {
+    // No on-prefixed outputs (onSelectDate → selectDate)
+    '@angular-eslint/no-output-on-prefix': 'error',
+
+    // No outputs named after native DOM events (change, click, etc.)
+    '@angular-eslint/no-output-native': 'error',
+  },
+};
+
 /**
  * Flat config entries for Angular HTML template files.
  * @type {import('eslint').Linter.Config}
@@ -416,6 +435,8 @@ const recommendedTemplate = {
     'ethlete/prefer-static-boolean-properties': 'warn',
     // A form must handle its own submission
     'ethlete/require-form-submit': 'error',
+    // No static style attribute or [attr.style] binding - a strict CSP blocks both
+    'ethlete/no-csp-unsafe': 'error',
   },
 };
 
@@ -429,6 +450,7 @@ const recommendedSpec = {
     '@typescript-eslint/no-non-null-assertion': 'off',
     'no-restricted-globals': 'off',
     'ethlete/no-async-await': 'off',
+    'ethlete/no-csp-unsafe': 'off',
     'ethlete/no-direct-dom-manipulation': 'off',
     'ethlete/no-document-cookie': 'off',
     'ethlete/no-dom-query': 'off',
@@ -441,4 +463,4 @@ const recommendedSpec = {
   },
 };
 
-module.exports = { recommendedTs, recommendedTemplate, recommendedSpec };
+module.exports = { recommendedTs, recommendedAngularTs, recommendedTemplate, recommendedSpec };

package/src/generators/generators.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://json.schemastore.org/nx-generators",
+  "generators": {
+    "restore-module-augmentation-interfaces": {
+      "implementation": "./restore-module-augmentation-interfaces/migration",
+      "schema": "./restore-module-augmentation-interfaces/schema.json",
+      "description": "Turn type aliases in declare module / declare global blocks back into interfaces, and rename consistent-type-definitions eslint directives"
+    }
+  }
+}

package/src/generators/restore-module-augmentation-interfaces/migration.js

@@ -0,0 +1,50 @@
+// @ts-check
+'use strict';
+
+const { formatFiles, visitNotIgnoredFiles } = require('@nx/devkit');
+const { restoreModuleAugmentationInterfaces } = require('./restore-module-augmentation-interfaces');
+
+const SOURCE_FILE = /\.(?:[cm]?ts|tsx|[cm]?js|jsx)$/;
+
+/**
+ * @param {import('@nx/devkit').Tree} tree
+ * @param {{ skipFormat?: boolean }} schema
+ */
+const migrateModuleAugmentationInterfaces = async (tree, schema) => {
+  console.log('\n🔄 Restoring module augmentation interfaces...');
+
+  let filesChanged = 0;
+  let reviewCount = 0;
+
+  visitNotIgnoredFiles(tree, '', (filePath) => {
+    if (!SOURCE_FILE.test(filePath)) return;
+
+    const before = tree.read(filePath, 'utf-8');
+
+    if (!before) return;
+
+    const result = restoreModuleAugmentationInterfaces(filePath, before);
+
+    for (const entry of result.review) {
+      reviewCount++;
+      console.warn(
+        `   ⚠ ${filePath}:${entry.line}: type ${entry.name} in a module augmentation is not an object literal, so it was left alone. An augmentation only merges as an interface.`,
+      );
+    }
+
+    if (!result.changed) return;
+
+    tree.write(filePath, result.content);
+    filesChanged++;
+    console.log(`   ✓ ${filePath}`);
+  });
+
+  console.log(filesChanged === 0 ? '   Nothing to migrate.\n' : `\n✅ Migrated ${filesChanged} file(s).\n`);
+
+  if (reviewCount > 0) console.warn(`   Review ${reviewCount} type alias(es) in module augmentations manually.\n`);
+
+  if (!schema.skipFormat) await formatFiles(tree);
+};
+
+module.exports = migrateModuleAugmentationInterfaces;
+module.exports.default = migrateModuleAugmentationInterfaces;

package/src/generators/restore-module-augmentation-interfaces/restore-module-augmentation-interfaces.js

@@ -0,0 +1,103 @@
+// @ts-check
+'use strict';
+
+const ts = require('typescript');
+
+const OLD_RULE = '@typescript-eslint/consistent-type-definitions';
+const NEW_RULE = 'ethlete/consistent-type-definitions';
+
+const LINE_DIRECTIVE = /\/\/[ \t]*eslint-(?:disable|enable)(?:-next-line|-line)?\b[^\n]*/g;
+const BLOCK_DIRECTIVE = /\/\*[ \t]*eslint-(?:disable|enable)(?:-next-line|-line)?\b(?:(?!\*\/)[\s\S])*\*\//g;
+
+const AUGMENTATION = /\bdeclare\s+(?:module|global)\b/;
+
+const renameInDirective = (/** @type {string} */ directive) => directive.split(OLD_RULE).join(NEW_RULE);
+
+/** Renames `@typescript-eslint/consistent-type-definitions` in every eslint-disable/enable directive. */
+const renameDirectives = (/** @type {string} */ content) =>
+  content.replace(LINE_DIRECTIVE, renameInDirective).replace(BLOCK_DIRECTIVE, renameInDirective);
+
+const isAugmentation = (/** @type {ts.Statement} */ statement) =>
+  ts.isModuleDeclaration(statement) &&
+  (ts.isStringLiteral(statement.name) || (statement.flags & ts.NodeFlags.GlobalAugmentation) !== 0) &&
+  statement.body !== undefined &&
+  ts.isModuleBlock(statement.body);
+
+/**
+ * @param {readonly ts.Statement[]} statements
+ * @param {ts.TypeAliasDeclaration[]} found
+ */
+const collectAugmentationAliases = (statements, found) => {
+  for (const statement of statements) {
+    if (!isAugmentation(statement)) continue;
+
+    const body = /** @type {ts.ModuleBlock} */ (/** @type {ts.ModuleDeclaration} */ (statement).body);
+
+    for (const member of body.statements) {
+      if (ts.isTypeAliasDeclaration(member)) found.push(member);
+    }
+
+    collectAugmentationAliases(body.statements, found);
+  }
+
+  return found;
+};
+
+/**
+ * Turns every object-literal `type X = { … }` directly inside a `declare module '…'` or
+ * `declare global` block back into `interface X { … }`, and renames
+ * `@typescript-eslint/consistent-type-definitions` in eslint directives to
+ * `ethlete/consistent-type-definitions`. Aliases of any other shape are returned in `review`.
+ *
+ * @param {string} filePath
+ * @param {string} content
+ * @returns {{ content: string; changed: boolean; review: { name: string; line: number }[] }}
+ */
+const restoreModuleAugmentationInterfaces = (filePath, content) => {
+  if (!AUGMENTATION.test(content)) {
+    const renamed = renameDirectives(content);
+
+    return { content: renamed, changed: renamed !== content, review: [] };
+  }
+
+  const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  const aliases = collectAugmentationAliases(sourceFile.statements, []);
+
+  /** @type {{ name: string; line: number }[]} */
+  const review = [];
+  /** @type {{ start: number; end: number; text: string }[]} */
+  const edits = [];
+
+  for (const alias of aliases) {
+    const name = alias.name.text;
+
+    if (!ts.isTypeLiteralNode(alias.type)) {
+      review.push({ name, line: sourceFile.getLineAndCharacterOfPosition(alias.getStart(sourceFile)).line + 1 });
+      continue;
+    }
+
+    const modifiers = (alias.modifiers ?? []).map((modifier) => `${modifier.getText(sourceFile)} `).join('');
+    const typeParameters = content
+      .slice(alias.name.end, alias.type.pos)
+      .replace(/\s*=\s*$/, '')
+      .trim();
+
+    edits.push({
+      start: alias.modifiers?.[0]?.getStart(sourceFile) ?? alias.getStart(sourceFile),
+      end: alias.end,
+      text: `${modifiers}interface ${name}${typeParameters} ${alias.type.getText(sourceFile)}`,
+    });
+  }
+
+  let next = content;
+
+  for (const edit of edits.sort((left, right) => right.start - left.start)) {
+    next = next.slice(0, edit.start) + edit.text + next.slice(edit.end);
+  }
+
+  next = renameDirectives(next);
+
+  return { content: next, changed: next !== content, review };
+};
+
+module.exports = { restoreModuleAugmentationInterfaces };

package/src/generators/restore-module-augmentation-interfaces/schema.json

@@ -0,0 +1,14 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "restore-module-augmentation-interfaces",
+  "title": "Restore module augmentation interfaces",
+  "type": "object",
+  "properties": {
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Skip formatting files after migration",
+      "default": false
+    }
+  },
+  "required": []
+}

package/src/index.js

@@ -30,6 +30,7 @@ const noLegacyAngularDecorators = require('./rules/no-legacy-angular-decorators'
 const noAngularSeoServices = require('./rules/no-angular-seo-services');
 const preferCloneEqual = require('./rules/prefer-clone-equal');
 const noDocumentCookie = require('./rules/no-document-cookie');
+const noCspUnsafe = require('./rules/no-csp-unsafe');
 const injectMemberAccessibility = require('./rules/inject-member-accessibility');
 const noRedundantInternal = require('./rules/no-redundant-internal');
 const templateMemberAccessibility = require('./rules/template-member-accessibility');
@@ -60,7 +61,9 @@ const noCdkImport = require('./rules/no-cdk-import');
 const noLegacyQueryImport = require('./rules/no-legacy-query-import');
 const noAsyncAwait = require('./rules/no-async-await');
 const noEnum = require('./rules/no-enum');
-const { recommendedTs, recommendedTemplate, recommendedSpec } = require('./configs/recommended');
+const consistentTypeDefinitions = require('./rules/consistent-type-definitions');
+const takeUntilDestroyedLast = require('./rules/take-until-destroyed-last');
+const { recommendedTs, recommendedAngularTs, recommendedTemplate, recommendedSpec } = require('./configs/recommended');
 const { version } = require('../package.json');
 
 /** @type {import('eslint').ESLint.Plugin} */
@@ -74,6 +77,7 @@ const plugin = {
     'no-legacy-prepare-without-injector': noLegacyPrepareWithoutInjector,
     'no-trivial-return-type': noTrivialReturnType,
     'no-subscribe-in-pipe': noSubscribeInPipe,
+    'take-until-destroyed-last': takeUntilDestroyedLast,
     'no-rxjs-in-effect': noRxjsInEffect,
     'no-effect-cleanup-return': noEffectCleanupReturn,
     'no-readonly-signal': noReadonlySignal,
@@ -100,6 +104,7 @@ const plugin = {
     'no-angular-seo-services': noAngularSeoServices,
     'prefer-clone-equal': preferCloneEqual,
     'no-document-cookie': noDocumentCookie,
+    'no-csp-unsafe': noCspUnsafe,
     'inject-member-accessibility': injectMemberAccessibility,
     'no-redundant-internal': noRedundantInternal,
     'template-member-accessibility': templateMemberAccessibility,
@@ -129,6 +134,7 @@ const plugin = {
     'no-legacy-query-import': noLegacyQueryImport,
     'no-async-await': noAsyncAwait,
     'no-enum': noEnum,
+    'consistent-type-definitions': consistentTypeDefinitions,
   },
 };
 
@@ -148,6 +154,8 @@ const recommendedTemplateWithPlugin = {
 const configs = {
   /** TypeScript rules (merged into a files: ['**\/*.ts'] block) */
   recommendedTs: recommendedTsWithPlugin,
+  /** `@angular-eslint/*` rules for TypeScript files (files: ['**\/*.ts']) */
+  recommendedAngularTs,
   /** Angular template rules (merged into a files: ['**\/*.html'] block) */
   recommendedTemplate: recommendedTemplateWithPlugin,
   /** Relaxed rules for spec files (files: ['**\/*.spec.ts']) */
@@ -156,7 +164,7 @@ const configs = {
    * Both together as a flat array — the most common usage:
    *   export default [...baseConfig, ...ethlete.configs.recommended]
    */
-  recommended: [recommendedTsWithPlugin, recommendedTemplateWithPlugin, recommendedSpec],
+  recommended: [recommendedTsWithPlugin, recommendedAngularTs, recommendedTemplateWithPlugin, recommendedSpec],
 };
 
 const ethletePlugin = { ...plugin, configs };

package/src/rules/angular-decorator-property-order.js

@@ -1,6 +1,8 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./internals/import-resolution');
+
 /** @typedef {'Component' | 'Directive'} TDecoratorName */
 /** @typedef {{ order: string[]; orderText: string }} TDecoratorConfig */
 /** @typedef {{ range: [number, number] }} TNodeWithRange */
@@ -14,11 +16,13 @@ const DECORATOR_CONFIG = {
   Component: {
     order: [
       'selector',
+      'standalone',
       'template',
       'styleUrl',
       'encapsulation',
       'changeDetection',
       'imports',
+      'deferredImports',
       'providers',
       'viewProviders',
       'animations',
@@ -29,16 +33,28 @@ const DECORATOR_CONFIG = {
       'outputs',
       'queries',
       'preserveWhitespaces',
+      'interpolation',
       'schemas',
       'jit',
       'exportAs',
     ],
     orderText:
-      'selector, template/templateUrl, styleUrl/styleUrls, encapsulation, changeDetection, imports, providers, viewProviders, animations, hostDirectives, host, styles, inputs, outputs, queries, preserveWhitespaces, schemas, jit, exportAs',
+      'selector, standalone, template/templateUrl, styleUrl/styleUrls, encapsulation, changeDetection, imports, deferredImports, providers, viewProviders, animations, hostDirectives, host, styles, inputs, outputs, queries, preserveWhitespaces, interpolation, schemas, jit, exportAs',
   },
   Directive: {
-    order: ['selector', 'exportAs', 'providers', 'inputs', 'outputs', 'queries', 'hostDirectives', 'host', 'jit'],
-    orderText: 'selector, exportAs, providers, inputs, outputs, queries, hostDirectives, host, jit',
+    order: [
+      'selector',
+      'standalone',
+      'exportAs',
+      'providers',
+      'inputs',
+      'outputs',
+      'queries',
+      'hostDirectives',
+      'host',
+      'jit',
+    ],
+    orderText: 'selector, standalone, exportAs, providers, inputs, outputs, queries, hostDirectives, host, jit',
   },
 };
 
@@ -66,22 +82,6 @@ const getOrderKey = (decoratorName, propertyName) => {
   return propertyName;
 };
 
-/**
- * @param {import('eslint').Rule.Node} node
- * @returns {TDecoratorName | null}
- */
-const getDecoratorName = (node) => {
-  const decorator = /** @type {any} */ (node);
-  if (decorator.type !== 'Decorator') return null;
-
-  const expression = decorator.expression;
-  if (expression.type === 'CallExpression') {
-    return expression.callee.type === 'Identifier' ? expression.callee.name : null;
-  }
-
-  return expression.type === 'Identifier' ? expression.name : null;
-};
-
 /** @type {import('eslint').Rule.RuleModule} */
 const angularDecoratorPropertyOrder = {
   meta: {
@@ -101,7 +101,7 @@ const angularDecoratorPropertyOrder = {
     return {
       /** @param {import('eslint').Rule.Node} node */
       Decorator(node) {
-        const decoratorName = getDecoratorName(node);
+        const decoratorName = getAngularDecoratorName(context.sourceCode, node);
         if (decoratorName !== 'Component' && decoratorName !== 'Directive') return;
 
         const decorator = /** @type {any} */ (node);

package/src/rules/class-constant-property.js

@@ -1,24 +1,18 @@
 // @ts-check
 'use strict';
 
+const { getAngularDecoratorName } = require('./internals/import-resolution');
+
 const SCREAMING_CASE_RE = /^[A-Z][A-Z0-9_]*$/;
 
 /**
+ * @param {import('eslint').SourceCode} sourceCode
  * @param {any} classNode
  */
-const hasPipeDecorator = (classNode) => {
-  const decorators = classNode.decorators ?? [];
-  return decorators.some((/** @type {any} */ dec) => {
-    const expr = dec.expression;
-    if (expr.type === 'CallExpression') {
-      return expr.callee.type === 'Identifier' && expr.callee.name === 'Pipe';
-    }
-    if (expr.type === 'Identifier') {
-      return expr.name === 'Pipe';
-    }
-    return false;
-  });
-};
+const hasPipeDecorator = (sourceCode, classNode) =>
+  (classNode.decorators ?? []).some(
+    (/** @type {any} */ decorator) => getAngularDecoratorName(sourceCode, decorator) === 'Pipe',
+  );
 
 const REACTIVE_APIS = new Set([
   'signal',
@@ -353,7 +347,7 @@ const classConstantProperty = {
             continue;
           }
 
-          if (memberName === 'transform' && hasPipeDecorator(node.parent)) {
+          if (memberName === 'transform' && hasPipeDecorator(context.sourceCode, node.parent)) {
             continue;
           }