@dsivd/prestations-ng 19.0.6 → 19.0.8-beta.1

package/CHANGELOG.md

@@ -6,14 +6,48 @@
 
 ---
 
-## [Unreleased]
+## [19.0.8]
+
+### Changed
+
+- ESLint rule [`no-direct-signal-mutation`](ESLINT_PLUGIN.md#no-direct-signal-mutation) now
+  covers much more than the plain assignment it started with. 🚨 Expect new errors on
+  `npm update`; each can be turned off from your own `rules` block.
+    - **in-place mutators** are reported as well, since they notify nothing either: those of
+      `Array` (`splice`, `push`, `pop`, `shift`, `unshift`, `sort`, `reverse`, `fill`,
+      `copyWithin`) and of `Map` / `Set` (`set`, `add`, `delete`, `clear`)
+    - so are `delete model().users[0]` and `Object.assign(model(), …)`, and
+      `items()["push"](x)` counts as `items().push(x)`
+    - the value is **followed through the bindings that can be resolved exactly**: a
+      variable written once, the element parameter of an iteration callback, a `@for` item
+      and a `@let`. `@for (user of model().users)` then `user.done = true` is reported
+    - 🚨 **no signal is mutable**, whatever its kind: `signal()`, `model()`,
+      `linkedSignal()`, `computed()`, `input()` and `toSignal()` are all reported, each with
+      the fix that applies to it. A **view query** is the single exception —
+      `viewChild()`, `contentChildren()` and their `.required` variants hand out a DOM
+      element or a component instance, which is there to be mutated
+    - only the signals the class really declares are inspected, resolved through the whole
+      inheritance chain, so a plain method (`this.getConfig().items.push(x)`) is never
+      reported
+    - a signal inherited from a published package and known by its type only (`Signal<T>`)
+      is left alone: a declaration file no longer says whether it was a `computed()` or a
+      view query
+
+## [19.0.7]
 
 ### Added
 
 - ESLint plugin: **shareable configs**, documented in [ESLINT_PLUGIN.md](ESLINT_PLUGIN.md)
     - add `configs.tsRecommended` and `configs.templateRecommended` to the `extends` of your
-      `**/*.ts` and `**/*.html` blocks — see [UPGRADING_V19.md](UPGRADING_V19.md). Nothing
-      else is needed: no `plugins` declaration, no rule list.
+      `**/*.ts` and `**/*.html` blocks — see [UPGRADING_V19.md](UPGRADING_V19.md). They carry
+      the whole shared setup: the `eslint`, `typescript-eslint` and `angular-eslint`
+      baselines, the house conventions, and the rules below. Nothing else is needed: no
+      `plugins` declaration, no rule list.
+    - `configs.tsRules` and `configs.templateRules` enable only the rules written here, for a
+      project that supplies its own style
+    - 🚨 do **not** also spread `angular.configs.tsRecommended` or
+      `angular.configs.templateRecommended`: they are already included, and declaring the
+      same plugin twice makes ESLint fail outright
     - 🚨 **Prerequisite**: `lintFilePatterns` in your `angular.json` must include
       `src/**/*.html`, otherwise the template rules never run
     - 🚨 **A rule added to these configs makes your lint fail on `npm update`.** This is
@@ -37,7 +71,6 @@
 - [recaptcha.service.ts](projects/prestations-ng/src/sdk-recaptcha/recaptcha.service.ts)
     - fixed recaptcha called infinitely when backend says that it must be revalidated
 
-
 ## [19.0.0] - should be aligned with prestations-be 19.0.x
 
 ### Added

package/CONTRIBUTING.md

@@ -131,8 +131,9 @@ below mandatory:
 
 1. Write the rule in `projects/prestations-ng/src/eslint/rules/<rule-name>.mjs`
 2. Register it in `rules/index.mjs`, keyed by its public kebab-case name
-3. Enable it in `configs/ts-recommended.mjs`, `configs/template-recommended.mjs`, or both
-   depending on what it inspects
+3. Enable it in `configs/ts-rules.mjs`, `configs/template-rules.mjs`, or both depending on
+   what it inspects — the `*-recommended.mjs` presets pick those layers up. A change to a
+   shared convention rather than to a rule of ours goes into `configs/ts-recommended.mjs`.
 4. Test it in `rules/__tests__/<rule-name>.test.mjs` — use the `@angular-eslint/template-parser`
    for a template rule
 5. Run `npm run test:eslint`, then `npm run lint:js` on the whole repository: a rule that

package/ESLINT_PLUGIN.md

@@ -1,8 +1,9 @@
 # ESLint plugin
 
 `@dsivd/prestations-ng` ships an ESLint plugin with rules that catch signal misuses the
-Angular compiler lets through. It is published as a subpath of the library, so the rules
-follow the version of the library.
+Angular compiler lets through, plus the lint setup shared by every project built on the
+library. It is published as a subpath of the library, so both follow the version of the
+library.
 
 ## Setup
 
@@ -17,18 +18,18 @@ import prestationsNg from '@dsivd/prestations-ng/eslint';
 export default tseslint.config(
     {
         files: ['**/*.ts'],
-        extends: [
-            ...angular.configs.tsRecommended,
-            ...prestationsNg.configs.tsRecommended,
-        ],
+        extends: [...prestationsNg.configs.tsRecommended],
+        languageOptions: {
+            parserOptions: {
+                projectService: true,
+                tsconfigRootDir: import.meta.dirname,
+            },
+        },
         processor: angular.processInlineTemplates,
     },
     {
         files: ['**/*.html'],
-        extends: [
-            ...angular.configs.templateRecommended,
-            ...prestationsNg.configs.templateRecommended,
-        ],
+        extends: [...prestationsNg.configs.templateRecommended],
     },
 );
 ```
@@ -37,17 +38,38 @@ That is all. You do **not** declare `plugins`, and you do **not** list the rules
 from the config. Inline templates written in a `@Component` are covered too, through
 `angular.processInlineTemplates`.
 
+> 🚨 **Do not spread `angular.configs.tsRecommended` or `angular.configs.templateRecommended`
+> alongside these configs.** They already include them. Declaring the same plugin twice from
+> two different copies makes ESLint fail outright, before linting anything.
+
 > 🚨 **Prerequisite**: `lintFilePatterns` in your `angular.json` must include
 > `src/**/*.html`. Without it `ng lint` never opens your templates, and the template rules
 > silently never run.
 
-| Config                        | Target      | Rules                                                          |
+## The configs
+
+| Config                        | Target      | Contents                                                       |
 | ----------------------------- | ----------- | -------------------------------------------------------------- |
-| `configs.tsRecommended`       | `**/*.ts`   | `no-direct-signal-mutation`                                    |
-| `configs.templateRecommended` | `**/*.html` | `no-direct-signal-mutation`, `no-uninvoked-signal-in-template` |
+| `configs.tsRecommended`       | `**/*.ts`   | the baselines, the house style, and `tsRules`                  |
+| `configs.templateRecommended` | `**/*.html` | the baselines, the house style, and `templateRules`            |
+| `configs.tsRules`             | `**/*.ts`   | `no-direct-signal-mutation`                                    |
+| `configs.templateRules`       | `**/*.html` | `no-direct-signal-mutation`, `no-uninvoked-signal-in-template` |
+
+The `*Recommended` presets are what a project normally extends. On top of the rules written
+here they bring:
 
-`no-direct-signal-mutation` appears in both: the rule carries one visitor for TypeScript
-and one for the Angular template AST, and each fires on its own kind of file.
+- the baselines — `eslint.configs.recommended`, `typescript-eslint` recommended and
+  stylistic, `angular-eslint` recommended, and for templates its accessibility set;
+- the house style — naming and selector conventions, import ordering
+  (`simple-import-sort`, `import-x`), rxjs conventions, and the signal rules of
+  `angular-eslint` (`no-uncalled-signals`, `prefer-signals`, `prefer-signal-model`).
+
+Use `tsRules` / `templateRules` instead when a project supplies its own style and only wants
+the rules of this library. They register the plugin and nothing else, so you keep control of
+the baselines — and stay responsible for keeping them aligned.
+
+`no-direct-signal-mutation` appears in both targets: the rule carries one visitor for
+TypeScript and one for the Angular template AST, and each fires on its own kind of file.
 
 ## What happens when you update the library
 
@@ -62,10 +84,7 @@ your own `rules` block. It is applied after the shared config, so it wins:
 ```ts
 {
     files: ['**/*.html'],
-    extends: [
-        ...angular.configs.templateRecommended,
-        ...prestationsNg.configs.templateRecommended,
-    ],
+    extends: [...prestationsNg.configs.templateRecommended],
     rules: {
         // decided by this project, survives library updates
         '@dsivd/prestations-ng/no-direct-signal-mutation': ['off'],
@@ -77,8 +96,9 @@ your own `rules` block. It is applied after the shared config, so it wins:
 
 ### `no-direct-signal-mutation`
 
-Reports an assignment into a member of a signal's value. Mutating the object held by a
-signal does not notify its dependents, so the view is not refreshed.
+Reports a mutation of the value held by a signal, in either of its two forms: an
+assignment into one of its members, or a call to an in-place mutator. Mutating that value
+does not notify the signal's dependents, so the view is not refreshed.
 
 Applies to **TypeScript files and templates**, including the case where the mutation hides
 in a two-way binding.
@@ -86,14 +106,20 @@ in a two-way binding.
 ```ts
 // ✗ mutates the object inside the signal, no notification
 this.model().property = value;
+this.model().items.splice(index, 1);
 
 // ✓
 this.model.update((current) => ({ ...current, property: value }));
+this.model.update((current) => ({
+    ...current,
+    items: current.items.filter((_, i) => i !== index),
+}));
 ```
 
 ```html
 <!-- ✗ -->
 <button (click)="model().property = value">…</button>
+<button (click)="model().items.splice(index, 1)">…</button>
 <input [(ngModel)]="model().property" />
 
 <!-- ✓ -->
@@ -103,23 +129,130 @@ this.model.update((current) => ({ ...current, property: value }));
 All the assignment operators accepted by the Angular expression parser are covered: `=`,
 `+=`, `-=`, `*=`, `/=`, `%=`, `**=`, `&&=`, `||=`, `??=`.
 
-**Not reported**, because the call is not assumed to be a signal read:
+The in-place mutators covered are those of `Array` — `push`, `pop`, `shift`, `unshift`,
+`splice`, `sort`, `reverse`, `fill`, `copyWithin` — and of `Map` / `Set` — `set`, `add`,
+`delete`, `clear`. Their non-mutating counterparts, `toSorted`, `toReversed`, `filter`,
+`concat`, `with`, are never reported: they return a new value. `items()["push"](x)` is the
+same call as `items().push(x)` and is reported alike.
 
-| Expression                                          | Why                                                               |
-| --------------------------------------------------- | ----------------------------------------------------------------- |
-| `map.get(key).files = []`                           | the call takes arguments                                          |
-| `component.inputElement().nativeElement.value = ''` | reached through a foreign receiver, not `this`                    |
-| `obj.getter().property = value`                     | idem                                                              |
-| `viewChild(…)` / `viewChild.required(…)` accessors  | a view query signal is read-only, there is no `.set()` to suggest |
+Two other ways of writing into the value are covered, in TypeScript — the Angular template
+parser accepts neither:
+
+```ts
+delete this.model().users[0];
+Object.assign(this.model(), { property: value });
+```
+
+#### Names bound to the value
+
+A mutation is rarely written on the signal read itself. The rule follows the value through
+the bindings it can resolve exactly, and only those:
+
+```ts
+// ✗ a variable written once
+const users = this.model().users;
+users.push(user);
+
+// ✗ the element parameter of an iteration callback
+this.model().users.forEach((user) => (user.done = true));
+```
+
+```angular-html
+<!-- ✗ a @for item, bound only inside its own block -->
+@for (user of model().users; track user.id) {
+    <input [(ngModel)]="user.done" />
+    <button (click)="user.tags.push(tag)">…</button>
+}
+
+<!-- ✗ a @let -->
+@let users = model().users;
+<button (click)="users.push(user)">…</button>
+```
+
+In TypeScript these come from ESLint's scope analysis, in templates from the block that
+introduces the name — nothing is inferred from a naming convention. A variable that is
+**reassigned** is dropped: the name may hold something else by the time it is mutated. Same
+for `reduce`, whose first parameter is the accumulator and not an element.
+
+**What it cannot follow** is a value crossing a function boundary — handed to a method,
+stored in a class field, returned and mutated elsewhere:
+
+```ts
+// not reported: the rule cannot know what `sortInto` does
+this.sortInto(this.model().users);
+```
+
+That needs interprocedural analysis, which ESLint does not provide; a full type checker
+would be required. It is the one remaining gap in detection.
+
+#### Only real signals are inspected
+
+The rule does not guess from the shape of a call. It reads the declaring class — the linted
+file itself, or the component a template belongs to — and resolves its signal members
+through the whole inheritance chain, the way TypeScript would: relative paths,
+`node_modules`, `paths` mappings, and the flattened `.d.ts` of a published library. Nothing
+has to be declared by hand.
+
+**No signal's value is to be mutated, whatever its kind** — a mutation notifies none of its
+dependents. The kinds differ only in the advice the message carries, since none but the
+first has a `.set()`:
+
+| Declared as                             | On a mutation of its value                                  |
+| --------------------------------------- | ----------------------------------------------------------- |
+| `signal()`, `model()`, `linkedSignal()` | use `.set()` / `.update()`                                  |
+| `computed()`                            | the value is derived: mutate the signal it is computed from |
+| `input()`                               | the value belongs to the parent: ask through an `output()`  |
+| `toSignal()`                            | the value comes from the observable: change it upstream     |
+| `viewChild()`, `contentChildren()`, …   | **the one exception**, left alone: see below                |
+
+A view query is the exception because it hands out a DOM element or a component instance,
+and mutating that is the reason for asking for it: `rows().nativeElement.hidden = true` is
+the normal way to use one. `.required` variants included.
+
+Anything that is not a declared signal is left alone as well:
+
+| Expression                           | Why                                                          |
+| ------------------------------------ | ------------------------------------------------------------ |
+| `this.getConfig().items.push(item)`  | `getConfig()` is a plain method, not a signal                |
+| `map.get(key).files.push(file)`      | the call takes arguments, so it is not a signal read         |
+| `component.model().items.push(item)` | reached through a foreign receiver, not the component itself |
+
+Because the rule knows a real signal from an ordinary method, `set` / `add` / `delete` are
+safe to report: `byId().set(k, v)` mutates the `Map` inside the signal, while `byId.set(m)`
+replaces the signal's value and is correct.
+
+**One accepted false positive.** A `computed()` may legitimately hand out a live mutable
+object, and no type information is available to tell that apart from a derived value:
+
+```ts
+readonly items = computed(() => this.form.get('items') as FormArray);
+this.items().push(control); // reported, though this is the FormArray API
+```
+
+**One accepted gap, and it is forced.** A published declaration file spells a `computed()`,
+a `toSignal()` and a view query alike, `Signal<T>` — the factory name is gone. A signal
+**inherited from a package** and known by its type only is therefore left alone:
+
+```ts
+// in the published .d.ts, indistinguishable from one another
+readonly fieldId: Signal<string>; // was a computed()
+readonly inputElement: Signal<ElementRef>; // was a viewChild()
+```
+
+Reporting that group would break the lint of every project extending a component of this
+library: `prestations-ng` publishes 54 view queries, `AbstractPageComponent` and
+`FoehnInputComponent` among them, and touching the element they queried is normal code. So
+a mutation of an inherited `computed()` goes unreported — the narrower harm of the two.
+Signals declared in your own project, base classes included, are unaffected: their factory
+call is right there to be read.
 
 The rule has no autofix: the correct rewrite depends on what you meant.
 
-**Known limitation.** The view query exclusion needs the component class, which a template
-AST does not carry. A mutation reached through a view query **from a template** is therefore
-still reported, with a message suggesting a `.update()` that does not exist on a read-only
-signal. It is rare — mutating the DOM from a template expression — but if you hit it, turn
-the rule off for that file. The same imprecision applies to `computed()` in TypeScript,
-which is read-only as well.
+**When the declaring class cannot be read** — an unsaved buffer, a template with no twin
+`.ts` — its signals are unknown, and the rule falls back to treating any argument-less
+accessor on the component as a signal. It may then report a plain method. That direction is
+deliberate: a false positive costs one `eslint-disable-next-line`, a missed mutation is a
+silent bug.
 
 ### `no-uninvoked-signal-in-template`
 
@@ -162,13 +295,15 @@ found without declaring anything.
 | `[(value)]="mySignal"`                                       | a writable signal is two-way bound **without** parentheses, Angular calls `.set()` itself |
 | `#ref`, `@for` items, `@if … as`, `@let`, `let-x`, `$index`… | template-local names shadow the class members                                             |
 
-## Also worth enabling
+## The TypeScript counterpart
 
 `@angular-eslint/no-uncalled-signals` covers the same class of bug **in TypeScript**, using
 the real type checker — far more reliable than what a template rule can do. It cannot run on
 templates: it requires type information, which a `.html` file has no program for. The two
 are complementary, not redundant.
 
+`configs.tsRecommended` already enables it. With `configs.tsRules` you enable it yourself:
+
 ```ts
 '@angular-eslint/no-uncalled-signals': 'error',
 ```

package/UPGRADING_V19.md

@@ -1085,13 +1085,10 @@ rm .eslintrc.json
 
 ```ts
 // @ts-check
-import eslint from '@eslint/js';
+import prettier from 'eslint-config-prettier';
 import tseslint from 'typescript-eslint';
 import angular from 'angular-eslint';
-import rxjs from '@smarttools/eslint-plugin-rxjs';
-import simpleImportSort from 'eslint-plugin-simple-import-sort';
-import prettier from 'eslint-config-prettier';
-import importX from 'eslint-plugin-import-x';
+
 import prestationsNg from '@dsivd/prestations-ng/eslint';
 
 export default tseslint.config(
@@ -1102,152 +1099,20 @@ export default tseslint.config(
     // ─── TypeScript ────────────────────────────────────────────────────────────
     {
         files: ['**/*.ts'],
-        extends: [
-            eslint.configs.recommended,
-            ...tseslint.configs.recommended, // covers: no-explicit-any, ban-ts-comment,
-            //   no-unused-expressions, no-var, no-unused-vars…
-            ...tseslint.configs.stylistic, // covers: array-type, consistent-type-assertions,
-            //   dot-notation, no-inferrable-types (default options),
-            //   no-empty-function (error), prefer-for-of,
-            //   prefer-function-type…
-            ...angular.configs.tsRecommended, // covers: prefer-inject, no-empty-lifecycle-method,
-            //   use-lifecycle-interface…
-            ...prestationsNg.configs.tsRecommended, // covers: no-direct-signal-mutation
-        ],
+        extends: [...prestationsNg.configs.tsRecommended],
         languageOptions: {
             parserOptions: {
                 projectService: true,
                 tsconfigRootDir: import.meta.dirname,
             },
         },
-        plugins: {
-            rxjs,
-            'simple-import-sort': simpleImportSort,
-            'import-x': importX,
-        },
         processor: angular.processInlineTemplates,
-        rules: {
-            // ── @angular-eslint ──────────────────────────────────────────────
-            '@angular-eslint/component-selector': [
-                'error',
-                {
-                    type: 'element',
-                    prefix: 'app',
-                    style: 'kebab-case',
-                },
-            ],
-            '@angular-eslint/directive-selector': [
-                'error',
-                {
-                    type: 'attribute',
-                    prefix: 'app',
-                    style: 'camelCase',
-                },
-            ],
-            '@angular-eslint/no-uncalled-signals': ['error'],
-            '@angular-eslint/prefer-signal-model': ['error'],
-            '@angular-eslint/prefer-signals': ['error'],
-
-            // ── @typescript-eslint ───────────────────────────────────────────
-            '@typescript-eslint/explicit-function-return-type': [
-                'error',
-                {
-                    allowExpressions: true,
-                    allowTypedFunctionExpressions: true,
-                    allowHigherOrderFunctions: true,
-                    allowDirectConstAssertionInArrowFunctions: true,
-                },
-            ],
-            '@typescript-eslint/explicit-member-accessibility': [
-                'error',
-                { accessibility: 'no-public' },
-            ],
-            '@typescript-eslint/member-delimiter-style': 'error',
-            '@typescript-eslint/member-ordering': 'error',
-            '@typescript-eslint/no-base-to-string': 'warn',
-            // stylistic enables no-inferrable-types with default options (ignoreParameters: false);
-            // override here to allow typed parameters explicitly
-            '@typescript-eslint/no-inferrable-types': [
-                'error',
-                { ignoreParameters: true },
-            ],
-            // stylistic sets no-empty-function to error; downgrade to warn
-            '@typescript-eslint/no-empty-function': 'warn',
-            '@typescript-eslint/prefer-includes': 'warn',
-            '@typescript-eslint/return-await': ['error', 'never'],
-            '@typescript-eslint/typedef': ['error', { parameter: true }],
-            '@typescript-eslint/unified-signatures': 'error',
-            // off here — @typescript-eslint/no-shadow handles it correctly for TS
-            'no-shadow': 'off',
-            '@typescript-eslint/no-shadow': ['error', { hoist: 'all' }],
-            '@typescript-eslint/no-unused-vars': [
-                'error',
-                {
-                    varsIgnorePattern: '^_',
-                    argsIgnorePattern: '^_',
-                    caughtErrorsIgnorePattern: '^_',
-                },
-            ],
-
-            // ── eslint core ──────────────────────────────────────────────────
-            'arrow-body-style': 'error',
-            'arrow-parens': ['error', 'as-needed'],
-            curly: 'error',
-            eqeqeq: ['error', 'always'],
-            'guard-for-in': 'error',
-            'no-bitwise': 'error',
-            'no-caller': 'error',
-            'no-console': ['error', { allow: ['log', 'warn', 'error'] }],
-            'no-eval': 'error',
-            'no-extra-boolean-cast': 'off',
-            'no-multiple-empty-lines': 'error',
-            'no-new-wrappers': 'error',
-            'no-restricted-imports': [
-                'error',
-                { paths: ['rxjs/Rx', 'primeng/primeng', 'primeng'] },
-            ],
-            'no-return-assign': 'error',
-            'no-throw-literal': 'error',
-            'no-undef-init': 'error',
-            'no-useless-concat': 'error',
-            'object-shorthand': ['error', 'always', { avoidQuotes: true }],
-            'one-var': ['error', 'never'],
-            'prefer-arrow-callback': 'error',
-            'prefer-template': 'error',
-            radix: 'error',
-
-            // ── rxjs ─────────────────────────────────────────────────────────
-            'rxjs/no-implicit-any-catch': ['error', { allowExplicitAny: true }],
-            'rxjs/no-sharereplay': 'off',
-
-            // ── import-x ─────────────────────────────────────────────────────
-            'import-x/no-cycle': [
-                'warn',
-                { maxDepth: 3, ignoreExternal: true },
-            ],
-            'import-x/no-deprecated': 'warn',
-            'import-x/first': 'error',
-            'import-x/newline-after-import': 'error',
-            'import-x/no-duplicates': 'error',
-
-            // ── simple-import-sort ───────────────────────────────────────────
-            'simple-import-sort/imports': 'error',
-            'simple-import-sort/exports': 'error',
-        },
     },
 
     // ─── HTML templates ────────────────────────────────────────────────────────
     {
         files: ['**/*.html'],
-        extends: [
-            ...angular.configs.templateRecommended,
-            ...angular.configs.templateAccessibility,
-            ...prestationsNg.configs.templateRecommended, // covers no-direct-signal-mutation, no-uninvoked-signal-in-template
-        ],
-        rules: {
-            '@angular-eslint/template/no-negated-async': 'off',
-            '@angular-eslint/template/button-has-type': 'error',
-        },
+        extends: [...prestationsNg.configs.templateRecommended],
     },
 
     // ─── Prettier (must be last — disables formatting rules) ───────────────────
@@ -1255,19 +1120,31 @@ export default tseslint.config(
 );
 ```
 
+That is the whole file. The two `*Recommended` configs come from the library and carry
+everything: the `eslint`, `typescript-eslint` and `angular-eslint` baselines, the template
+accessibility set, the naming and import conventions, and the rules written by the library
+itself. You declare no `plugins` and list no rule.
+
+The packages installed above are still required — the library's config imports them from your
+`node_modules` rather than shipping its own copies. For the same reason, do **not** spread
+`angular.configs.tsRecommended` or `angular.configs.templateRecommended` yourself: they are
+already included, and declaring the same plugin twice from two different copies makes ESLint
+fail outright.
+
 #### prestations-ng ESLint rules
 
 The library ships **shareable custom configs** that are auto-updatable with the library version. Two
 rules are enabled today — `no-direct-signal-mutation` and `no-uninvoked-signal-in-template` — and both
-are documented in [the plugin guide](ESLINT_PLUGIN.md).
+are documented in [the plugin guide](ESLINT_PLUGIN.md), alongside the leaner `tsRules` / `templateRules`
+configs for a project that supplies its own style.
 
 One consequence to keep in mind:
 
-- A rule added in a later version of the library lands in the config, so `npm update` **will
-  make your lint fail** on the offending code. That is the point — it is how a practice is
-  rolled out to every project. Each addition is listed in the [CHANGELOG](CHANGELOG.md), and
-  a rule you cannot fix right away can be turned off in your own `rules` block, which is
-  applied after the shared config:
+- A rule added — or tightened — in a later version of the library lands in the config, so
+  `npm update` **will make your lint fail** on the offending code. That is the point — it is
+  how a practice is rolled out to every project. Each addition is listed in the
+  [CHANGELOG](CHANGELOG.md), and a rule you cannot fix right away can be turned off in your
+  own `rules` block, which is applied after the shared config:
 
     ```ts
     rules: {

package/eslint/component-path.mjs

@@ -0,0 +1,15 @@
+// Path of the component a linted template belongs to, `undefined` when the file is not a
+// template.
+//
+// An inline template is a virtual block whose path is derived from the `.ts`, and whose
+// name ends with `.html` too: `foo.component.ts/1_inline-template-….component.html`.
+// It has to be matched BEFORE the external template, otherwise it resolves to garbage.
+export function resolveComponentPath(filename) {
+  const inlineMatch = filename.match(/^(.*\.ts)(?:[/\\]|$)/);
+  if (inlineMatch) {
+    return inlineMatch[1];
+  }
+  return filename.endsWith(".html")
+    ? `${filename.slice(0, -".html".length)}.ts`
+    : undefined;
+}

package/eslint/configs/template-base.mjs

@@ -1,6 +1,6 @@
 // Registers the plugin without enabling any rule. Meant to be used through
-// `templateRecommended`, inside the `extends` of a block that already targets
-// `**/*.html` and sets the Angular template parser.
+// `templateRules` or `templateRecommended`, inside the `extends` of a block that
+// already targets `**/*.html` and sets the Angular template parser.
 const templateBase = (plugin) => ({
     name: 'prestations-ng/template-base',
     plugins: {

package/eslint/configs/template-recommended.mjs

@@ -1,14 +1,23 @@
-import templateBase from './template-base.mjs';
+import angular from 'angular-eslint';
 
+import templateRules from './template-rules.mjs';
+
+/**
+ * The house Angular template preset: the recommended and accessibility baselines, this
+ * library's own rules, and the conventions every prestations-ng project follows.
+ *
+ * Meant for the `extends` of a `**\/*.html` block. It brings its own parser and plugins,
+ * so do not spread `angular.configs.templateRecommended` alongside it.
+ */
 const templateRecommended = (plugin) => [
-    templateBase(plugin),
+    ...angular.configs.templateRecommended,
+    ...angular.configs.templateAccessibility,
+    ...templateRules(plugin),
     {
         name: 'prestations-ng/template-recommended',
         rules: {
-            // Also in `tsRecommended`: the rule carries both an ESTree and an Angular
-            // template visitor, and each fires on its own kind of file.
-            '@dsivd/prestations-ng/no-direct-signal-mutation': 'error',
-            '@dsivd/prestations-ng/no-uninvoked-signal-in-template': 'error',
+            '@angular-eslint/template/no-negated-async': 'off',
+            '@angular-eslint/template/button-has-type': 'error',
         },
     },
 ];

package/eslint/configs/template-rules.mjs

@@ -0,0 +1,17 @@
+import templateBase from './template-base.mjs';
+
+// Only the rules written by this library. `templateRecommended` includes it, alongside
+// the house style; use this layer directly to opt out of the latter.
+const templateRules = (plugin) => [
+    templateBase(plugin),
+    {
+        name: 'prestations-ng/template-rules',
+        rules: {
+            // Also in `tsRules`: the rule carries both an ESTree and an Angular
+            // template visitor, and each fires on its own kind of file.
+            '@dsivd/prestations-ng/no-direct-signal-mutation': 'error',
+            '@dsivd/prestations-ng/no-uninvoked-signal-in-template': 'error',
+        },
+    },
+];
+export default templateRules;