@dsivd/prestations-ng 19.0.7 → 19.0.8

package/package.json

@@ -40,7 +40,7 @@
   "ng-update": {
     "migrations": "./schematics/migration-collection.json"
   },
-  "version": "19.0.7",
+  "version": "19.0.8",
   "module": "fesm2022/dsivd-prestations-ng.mjs",
   "typings": "types/dsivd-prestations-ng.d.ts",
   "exports": {

package/src/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/src/eslint/rules/__tests__/no-direct-signal-mutation.test.mjs

@@ -1,98 +1,257 @@
+import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import * as templateParser from '@angular-eslint/template-parser';
-import { describe, it } from 'vitest';
 import { RuleTester } from 'eslint';
+import { beforeAll, describe, it } from 'vitest';
 import rule from '../no-direct-signal-mutation.mjs';
 
 describe('no-direct-signal-mutation', () => {
-  const ruleTester = new RuleTester({
-    languageOptions: {
-      ecmaVersion: 2020,
-      sourceType: 'module',
-    },
+  // The rule only reports the signals a class really declares, resolved through its
+  // inheritance chain, so the fixtures have to exist on disk. They are laid out like a
+  // real project — the base class package under `node_modules` — so that module
+  // resolution is exercised.
+  let componentPath;
+  let templatePath;
+  let inlineTemplatePath;
+  let unknownTemplatePath;
+
+  const write = (path, content) => {
+    mkdirSync(join(path, '..'), { recursive: true });
+    writeFileSync(path, content, 'utf8');
+  };
+
+  beforeAll(() => {
+    const root = mkdtempSync(join(tmpdir(), 'no-direct-signal-mutation-'));
+
+    // A flattened declaration bundle, as published by ng-packagr: several classes in a
+    // single file, signal types qualified by the namespace they were imported under.
+    write(
+      join(root, 'node_modules', '@fake', 'kit', 'package.json'),
+      JSON.stringify({ name: '@fake/kit', types: 'index.d.ts' }),
+    );
+    write(
+      join(root, 'node_modules', '@fake', 'kit', 'index.d.ts'),
+      `import * as _angular_core from '@angular/core';
+       declare class KitInputComponent {
+         readonly inherited: _angular_core.ModelSignal<{ users: string[] }>;
+         readonly inheritedLabel: _angular_core.InputSignal<{ users: string[] }>;
+         readonly inheritedId: _angular_core.Signal<{ users: string[] }>;
+       }
+       declare class KitFieldComponent extends KitInputComponent {}
+       export { KitFieldComponent, KitInputComponent };`,
+    );
+
+    componentPath = join(root, 'src', 'sample.component.ts');
+    write(
+      componentPath,
+      `import { Component, computed, contentChildren, input, model, signal, viewChild } from '@angular/core';
+       import { toSignal } from '@angular/core/rxjs-interop';
+       import { KitFieldComponent } from '@fake/kit';
+
+       @Component({ selector: 'app-sample', templateUrl: './sample.component.html' })
+       export class SampleComponent extends KitFieldComponent {
+         readonly partenaire = signal({ name: '', users: [] });
+         readonly items = signal<string[]>([]);
+         readonly byId = signal(new Map<string, string>());
+         readonly tags = signal(new Set<string>());
+         readonly comment = model<string>('');
+
+         readonly double = computed(() => ({ users: [] }));
+         readonly formArray = computed(() => new FormArray([]));
+         readonly title = input.required<{ users: string[] }>();
+         readonly rows = viewChild('rows');
+         readonly slots = contentChildren('slot');
+         readonly fromStream = toSignal(this.source$);
+
+         getConfig() { return { users: [] }; }
+       }`,
+    );
+
+    templatePath = join(root, 'src', 'sample.component.html');
+    // Virtual block name produced by `angular.processInlineTemplates`.
+    inlineTemplatePath = join(
+      root,
+      'src',
+      'sample.component.ts',
+      '1_inline-template-sample.component.ts-1.component.html',
+    );
+    unknownTemplatePath = join(root, 'src', 'orphan.component.html');
+  });
+
+  const tsRuleTester = new RuleTester({
+    // 2021 at least: the rule covers `??=`, and the Angular parser accepts it too.
+    languageOptions: { ecmaVersion: 2022, sourceType: 'module' },
   });
 
+  const ts = (code) => ({ code, filename: componentPath });
+  const invalidTs = (code, messageId) => ({ ...ts(code), errors: [{ messageId }] });
+
   it('should validate signal mutation rule', () => {
-    ruleTester.run('no-direct-signal-mutation', rule, {
+    tsRuleTester.run('no-direct-signal-mutation', rule, {
       valid: [
-        // Using .update()
-        'model.update((current) => ({ ...current, property: value }))',
-        'this.model.update((current) => ({ ...current, property: value }))',
-        'getSignal().update((current) => ({ ...current, property: value }))',
-
-        // Using .set()
-        'model.set({ property: value })',
-        'this.model.set({ property: value })',
-        'getSignal().set({ property: value })',
+        // Going through the signal API
+        ts('this.partenaire.update((current) => ({ ...current, name: value }))'),
+        ts('this.partenaire.set({ name: value })'),
+        ts('this.comment.set(value)'),
 
         // Regular property assignments
-        'this.property = value',
-        'obj.property = value',
-        'this.obj.property = value',
-
-        // Reading from function calls (no assignment)
-        'model().property',
-        'this.model().property',
-        'getSignal().property',
-
-        // Method calls on function results
-        'model().someMethod()',
-        'this.model().someMethod()',
-        'getSignal().doSomething()',
-
-        // Assignments to non-function results
-        'let x = value',
-        'const obj = { prop: value }',
-        'array[0] = value',
-        'pendingFilesByFormKey.get(formKey).files = []',
-        'this.pendingFilesByFormKey.get(formKey).url = baseUrl',
-        'const autocompleteComponent = viewChild("auto"); autocompleteComponent().inputElement().nativeElement.hidden = true',
-        'component.inputElement().nativeElement.value = ""',
-        // A view query signal is read-only: there is no `.set()`/`.update()` to suggest,
-        // so `viewChild.required(…)` has to be excluded like `viewChild(…)`.
-        'const requiredChild = viewChild.required("req"); requiredChild().nativeElement.hidden = true',
-        'const requiredRows = contentChildren.required("row"); requiredRows()[0].hidden = true',
-
-        // Method chaining without assignment
-        'model().update((v) => v).subscribe()',
+        ts('this.property = value'),
+        ts('obj.property = value'),
+        ts('this.obj.property = value'),
+
+        // Reading from a signal, without mutating it
+        ts('this.partenaire().name'),
+        ts('this.items().toSorted()'),
+        ts('this.items().filter((x) => x.active)'),
+        ts('this.items().concat(other)'),
+        ts('[...this.items()].push(item)'),
+
+        // A plain method is not a signal, whatever it returns. This is what the
+        // inheritance-aware resolution buys: no guessing from the call shape.
+        ts('this.getConfig().users.push(user)'),
+        ts('this.getConfig().name = value'),
+        ts('this.notDeclaredAnywhere().name = value'),
+
+        // A view query is the one signal whose value is there to be mutated: it hands out
+        // a DOM element or a component instance.
+        ts('this.rows().nativeElement.hidden = true'),
+        ts('this.rows().items.push(item)'),
+        ts('const query = viewChild("rows"); query().items.push(item)'),
+        ts('const query = viewChild.required("rows"); query().items.push(item)'),
+        ts('const query = contentChildren("row"); query()[0].items.push(item)'),
+
+        // A published declaration spells a computed, a toSignal and a view query
+        // alike, `Signal<T>`. It has to be tolerated: this library publishes 54 view
+        // queries, on base classes every consumer extends.
+        ts('this.inheritedId().users.push(user)'),
+        ts('this.inheritedId().name = value'),
+
+        // A call taking arguments, or reached through a foreign receiver, is not a
+        // signal read.
+        ts('pendingFilesByFormKey.get(formKey).files = []'),
+        ts('pendingFilesByFormKey.get(formKey).files.push(file)'),
+        ts('component.partenaire().name = value'),
+        ts('component.partenaire().users.push(user)'),
+
+        // A local variable that holds no signal
+        ts('const plain = { users: [] }; plain.users.push(user)'),
+        ts('const viewQuery = viewChild("rows"); viewQuery().items.push(item)'),
+
+        // A chain reaching the mutation through a call designates a value of its own:
+        // `filter` and `slice` return a new array, so sorting THAT is nobody's business.
+        ts('this.items().filter((item) => item.active).sort()'),
+        ts('this.items().slice().sort()'),
+        ts('this.items().map((item) => item).push(item)'),
+        ts('this.items().concat(other).reverse()'),
+        ts('this.items().filter((item) => item.active)[0].name = value'),
+
+        // A name bound to a copy, not to the value itself
+        ts('const copy = [...this.items()]; copy.push(item)'),
+        ts('const copy = this.getConfig().users; copy.push(item)'),
+        // Reassigned: the name may hold something else by the time it is mutated
+        ts('let users = this.partenaire().users; users = other; users.push(item)'),
+        // A self reference must not send the resolution in circles
+        ts('const users = users; users.push(item)'),
+
+        // Following the callback parameter must not report on its own: the spread builds
+        // a new object instead of writing into `item`. Compare with the invalid twin,
+        // `map((item) => { item.done = true })`.
+        ts('this.items().map((item) => ({ ...item, done: true }))'),
+        ts('this.items().map((item) => item.done)'),
+        ts('this.items().reduce((acc, item) => acc.concat(item), [])'),
+        // Iterating something that is not a signal
+        ts('this.getConfig().users.forEach((user) => { user.done = true; })'),
+        ts('other.users.forEach((user) => { user.done = true; })'),
+        // `reduce` hands the accumulator first: mutating it is not mutating the signal
+        ts('this.items().reduce((acc, item) => { acc.push(item); return acc; }, [])'),
+
+        // `delete` and `Object.assign` on something that is not a signal
+        ts('delete this.plainObject.property'),
+        ts('delete this.getConfig().users[0]'),
+        ts('Object.assign({}, this.partenaire())'),
+        ts('Object.assign(target, this.partenaire())'),
+
+        // A computed member whose method does not mutate
+        ts('this.items()["toSorted"]()'),
       ],
 
       invalid: [
-        {
-          code: "model().property = value",
-          errors: [{ messageId: 'directMutation' }],
-        },
-        {
-          code: "this.model().property = value",
-          errors: [{ messageId: 'directMutation' }],
-        },
-        {
-          code: "getSignal().property = value",
-          errors: [{ messageId: 'directMutation' }],
-        },
-        {
-          code: "model().nested.property = value",
-          errors: [{ messageId: 'directMutation' }],
-        },
-        {
-          code: "this.model().deeply.nested.property = value",
-          errors: [{ messageId: 'directMutation' }],
-        },
-        {
-          code: "model().property += value",
-          errors: [{ messageId: 'directMutation' }],
-        },
-        {
-          code: "model().property -= value",
-          errors: [{ messageId: 'directMutation' }],
-        },
-        {
-          code: "model().property *= value",
-          errors: [{ messageId: 'directMutation' }],
-        },
-        {
-          code: "model().array[0] = value",
-          errors: [{ messageId: 'directMutation' }],
-        },
+        invalidTs('this.partenaire().name = value', 'directMutation'),
+        invalidTs('this.partenaire().deeply.nested.name = value', 'directMutation'),
+        invalidTs('this.partenaire().users[0] = value', 'directMutation'),
+        invalidTs('this.partenaire().users.length = 0', 'directMutation'),
+        invalidTs('this.partenaire().name += value', 'directMutation'),
+        invalidTs('this.partenaire().name ??= value', 'directMutation'),
+
+        // An in-place mutator changes the value without notifying the signal, exactly
+        // like an assignment does.
+        invalidTs('this.partenaire().users.splice(index, 1)', 'inPlaceMutation'),
+        invalidTs('this.items().push(item)', 'inPlaceMutation'),
+        invalidTs('this.items().sort((a, b) => a - b)', 'inPlaceMutation'),
+        invalidTs('this.partenaire().deeply.nested.users.reverse()', 'inPlaceMutation'),
+        // Map and Set mutators: safe to report now that only real signals are inspected.
+        invalidTs('this.byId().set(key, value)', 'inPlaceMutation'),
+        invalidTs('this.byId().delete(key)', 'inPlaceMutation'),
+        invalidTs('this.tags().add(tag)', 'inPlaceMutation'),
+        invalidTs('this.tags().clear()', 'inPlaceMutation'),
+
+        // A writable signal inherited from a published declaration bundle
+        invalidTs('this.inherited().users.push(user)', 'inPlaceMutation'),
+        invalidTs('this.inherited().name = value', 'directMutation'),
+
+        // A signal held by a plain variable of the file
+        invalidTs('const local = signal({ users: [] }); local().name = value', 'directMutation'),
+        invalidTs('const local = signal({ users: [] }); local().users.push(u)', 'inPlaceMutation'),
+        invalidTs('const local = model({ users: [] }); local().users.splice(i, 1)', 'inPlaceMutation'),
+
+        // `delete` drops an entry of the value, notifying nothing
+        invalidTs('delete this.partenaire().users[0]', 'inPlaceMutation'),
+        invalidTs('delete this.partenaire().name', 'inPlaceMutation'),
+        // `Object.assign` writes into its first argument
+        invalidTs('Object.assign(this.partenaire(), { name: value })', 'inPlaceMutation'),
+        invalidTs('Object.assign(this.partenaire().users, other)', 'inPlaceMutation'),
+        // A computed member is the same call written differently
+        invalidTs('this.partenaire().users["push"](user)', 'inPlaceMutation'),
+        invalidTs('this.partenaire().users["splice"](index, 1)', 'inPlaceMutation'),
+
+        // A name bound once to the value, or to a part of it
+        invalidTs('const users = this.partenaire().users; users.push(user)', 'inPlaceMutation'),
+        invalidTs('const users = this.partenaire().users; users[0].name = value', 'directMutation'),
+        invalidTs('const users = this.partenaire().users; delete users[0]', 'inPlaceMutation'),
+        invalidTs('const value = this.partenaire(); value.name = other', 'directMutation'),
+        invalidTs('const deep = this.partenaire().a.b.c; deep.push(item)', 'inPlaceMutation'),
+
+        // The element parameter of an iteration callback is a part of the value
+        invalidTs('this.items().forEach((item) => { item.done = true; })', 'directMutation'),
+        invalidTs('this.items().map((item) => { item.done = true; })', 'directMutation'),
+        invalidTs('this.items().forEach(function (item) { item.done = true; })', 'directMutation'),
+        invalidTs('this.items().filter((item) => item.tags.push(tag))', 'inPlaceMutation'),
+        invalidTs('this.partenaire().users.forEach((u) => u.tags.splice(0, 1))', 'inPlaceMutation'),
+        invalidTs('this.items().map((item) => Object.assign(item, { done: true }))', 'inPlaceMutation'),
+        invalidTs('this.items().map((item) => delete item.done)', 'inPlaceMutation'),
+        // A mutation hidden inside an otherwise honest spread
+        invalidTs('this.items().map((item) => ({ ...item, tags: item.tags.push(tag) }))', 'inPlaceMutation'),
+
+        // No signal's value is to be mutated, whatever its kind. Those without a `.set()`
+        // share one message, which names the kind and the fix that applies.
+        invalidTs('this.double().users.push(user)', 'readOnlyMutation'),
+        invalidTs('this.double().name = value', 'readOnlyMutation'),
+        invalidTs('delete this.double().users[0]', 'readOnlyMutation'),
+        invalidTs('const users = this.double().users; users.push(user)', 'readOnlyMutation'),
+        invalidTs('this.double().users.forEach((u) => { u.done = true; })', 'readOnlyMutation'),
+        invalidTs('const derived = computed(() => ({ users: [] })); derived().users.push(u)', 'readOnlyMutation'),
+        // An input's value belongs to the parent: mutating it corrupts the parent's state
+        // and notifies nothing either.
+        invalidTs('this.title().users.push(user)', 'readOnlyMutation'),
+        invalidTs('this.title().name = value', 'readOnlyMutation'),
+        invalidTs('this.fromStream().users.push(user)', 'readOnlyMutation'),
+        // Inherited from a published declaration bundle: `InputSignal` names its factory,
+        // while a bare `Signal<T>` only says read-only.
+        invalidTs('this.inheritedLabel().users.push(user)', 'readOnlyMutation'),
+        // The accepted false positive: a computed may legitimately hand out a live
+        // mutable object, and no type information is available to tell.
+        invalidTs('this.formArray().push(control)', 'readOnlyMutation'),
       ],
     });
   });
@@ -101,78 +260,156 @@ describe('no-direct-signal-mutation', () => {
     languageOptions: { parser: templateParser },
   });
 
+  const template = (code) => ({ code, filename: templatePath });
+  const invalidTemplate = (code, messageId) => ({
+    ...template(code),
+    errors: [{ messageId }],
+  });
+
   it('should validate signal mutation rule in templates', () => {
     templateRuleTester.run('no-direct-signal-mutation', rule, {
       valid: [
         // Reads only
-        '{{ model().property }}',
-        '<div [value]="model().property"></div>',
-        '<div [value]="model().deeply.nested.property"></div>',
-        '<div [value]="model().array[0]"></div>',
+        template('{{ partenaire().name }}'),
+        template('<div [value]="partenaire().deeply.nested.name"></div>'),
+        template('<div [value]="partenaire().users[0]"></div>'),
+        template('<div [value]="items().filter((x) => x.active)"></div>'),
+        template('<button (click)="items().toSorted()"></button>'),
 
         // Going through the signal API
-        '<button (click)="model.set({ property: value })"></button>',
-        '<button (click)="model.update((v) => ({ ...v, property: value }))"></button>',
+        template('<button (click)="partenaire.set({ name: value })"></button>'),
+        template('<button (click)="comment.set(value)"></button>'),
+        template('<button (click)="items.update((v) => [...v, item])"></button>'),
+
+        // Assignments that do not target a signal
+        template('<button (click)="property = value"></button>'),
+        template('<button (click)="obj.property = value"></button>'),
+        template('<button (click)="getConfig().name = value"></button>'),
+        template('<button (click)="getConfig().users.push(user)"></button>'),
 
-        // Assignments that do not target a call result
-        '<button (click)="property = value"></button>',
-        '<button (click)="obj.property = value"></button>',
-        '<button (click)="this.obj.property = value"></button>',
+        // A view query reached from a template used to be reported with a `.update()`
+        // that does not exist on it.
+        template('<button (click)="rows().nativeElement.hidden = true"></button>'),
+        template('<button (click)="rows().items.push(item)"></button>'),
+        template('@for (slot of slots(); track slot) { <button (click)="slot.done = 1"></button> }'),
 
         // Two-way binding on the signal itself: Angular calls `.set()`
-        '<input [(ngModel)]="model" />',
-        '<app-child [(value)]="comment"></app-child>',
-
-        // Same exclusions as the TypeScript side: a call taking arguments, or reached
-        // through a foreign receiver, is not assumed to be a signal read.
-        '<button (click)="pendingFilesByFormKey.get(formKey).files = []"></button>',
-        '<button (click)="this.pendingFilesByFormKey.get(formKey).url = baseUrl"></button>',
-        '<button (click)="component.inputElement().nativeElement.value = &quot;&quot;"></button>',
-        '<button (click)="obj.getter().property = value"></button>',
+        template('<input [(ngModel)]="comment" />'),
+        template('<app-child [(value)]="comment"></app-child>'),
+
+        // A call taking arguments, or reached through a foreign receiver
+        template('<button (click)="pendingFilesByFormKey.get(formKey).files = []"></button>'),
+        template('<button (click)="pendingFilesByFormKey.get(formKey).files.push(f)"></button>'),
+        template('<button (click)="component.inputElement().nativeElement.value = 1"></button>'),
+        template('<button (click)="component.partenaire().users.push(user)"></button>'),
+
         // An output named `…Change` that carries no assignment
-        '<app-child (valueChange)="model.set($event)"></app-child>',
+        template('<app-child (valueChange)="comment.set($event)"></app-child>'),
+
+        // A `@for` item is only a signal's value when the loop iterates a signal
+        template('@for (u of getConfig().users; track u) { <button (click)="u.done = 1"></button> }'),
+        template('@for (u of rows().items; track u) { <button (click)="u.done = 1"></button> }'),
+        template('@for (u of other.users; track u) { <button (click)="u.done = 1"></button> }'),
+        // Reading the item mutates nothing
+        template('@for (u of items(); track u) { {{ u.name }} }'),
+        template('@let copy = getConfig().users; <button (click)="copy.push(item)"></button>'),
+
+        // A computed member whose method does not mutate
+        template(`<button (click)="items()['toSorted']()"></button>`),
+        template('<button (click)="items().filter(active).sort()"></button>'),
+        template('<button (click)="items().slice().sort()"></button>'),
       ],
 
       invalid: [
+        invalidTemplate('<button (click)="partenaire().name = value"></button>', 'directMutation'),
+        invalidTemplate('<button (click)="this.partenaire().name = value"></button>', 'directMutation'),
+        invalidTemplate('<button (click)="partenaire().deeply.nested.name = value"></button>', 'directMutation'),
+        invalidTemplate('<button (click)="partenaire().users[0] = value"></button>', 'directMutation'),
+        // Every compound assignment accepted by the Angular parser
+        invalidTemplate('<button (click)="partenaire().name += value"></button>', 'directMutation'),
+        invalidTemplate('<button (click)="partenaire().name ??= value"></button>', 'directMutation'),
+
+        // The mutation hidden in a two-way binding, reported once and not twice
+        invalidTemplate('<input [(ngModel)]="partenaire().name" />', 'directMutation'),
+        invalidTemplate('<app-child [(value)]="partenaire().deeply.name"></app-child>', 'directMutation'),
+        // An explicit `…Change` handler carrying the assignment: the Binary reports it,
+        // the BoundEvent must not report it a second time.
+        invalidTemplate('<app-child (valueChange)="partenaire().name = $event"></app-child>', 'directMutation'),
+
+        // In-place mutators
+        invalidTemplate('<button (click)="partenaire().users.splice(index, 1)"></button>', 'inPlaceMutation'),
+        invalidTemplate('<button (click)="items().push(item)"></button>', 'inPlaceMutation'),
+        invalidTemplate('<button (click)="partenaire()?.users?.sort()"></button>', 'inPlaceMutation'),
+        invalidTemplate('<button (click)="byId().set(key, value)"></button>', 'inPlaceMutation'),
+        invalidTemplate('<button (click)="tags().add(tag)"></button>', 'inPlaceMutation'),
+        invalidTemplate('<button (click)="inherited().users.push(user)"></button>', 'inPlaceMutation'),
+        invalidTemplate(`<button (click)="items()['push'](item)"></button>`, 'inPlaceMutation'),
+
+        // Mutating a `@for` item mutates the array the signal holds. The item is bound
+        // only inside its own block, which the ancestor walk enforces.
+        invalidTemplate('@for (u of items(); track u) { <button (click)="u.done = 1"></button> }', 'directMutation'),
+        invalidTemplate('@for (u of partenaire().users; track u) { <button (click)="u.tags.push(t)"></button> }', 'inPlaceMutation'),
+        invalidTemplate('@for (a of items(); track a) { @for (b of a.items; track b) { <button (click)="b.done = 1"></button> } }', 'directMutation'),
+
+        // Same through a `@let`
+        invalidTemplate('@let users = partenaire().users; <button (click)="users.push(user)"></button>', 'inPlaceMutation'),
+        invalidTemplate('@let value = partenaire(); <button (click)="value.name = other"></button>', 'directMutation'),
+
+        // Every other kind of signal, each with the advice that applies to it
+        invalidTemplate('<button (click)="double().users.push(user)"></button>', 'readOnlyMutation'),
+        invalidTemplate('<button (click)="formArray().push(control)"></button>', 'readOnlyMutation'),
+        invalidTemplate('<button (click)="title().users.push(user)"></button>', 'readOnlyMutation'),
+        invalidTemplate('<button (click)="fromStream().users.push(user)"></button>', 'readOnlyMutation'),
+        invalidTemplate('@for (u of double().users; track u) { <button (click)="u.done = 1"></button> }', 'readOnlyMutation'),
+        invalidTemplate('@for (u of title().users; track u) { <button (click)="u.done = 1"></button> }', 'readOnlyMutation'),
+      ],
+    });
+  });
+
+  it('should cover inline templates', () => {
+    templateRuleTester.run('no-direct-signal-mutation', rule, {
+      valid: [
+        { code: '{{ partenaire().name }}', filename: inlineTemplatePath },
         {
-          code: '<button (click)="model().property = value"></button>',
-          errors: [{ messageId: 'directMutation' }],
-        },
-        {
-          code: '<button (click)="this.model().property = value"></button>',
-          errors: [{ messageId: 'directMutation' }],
-        },
-        {
-          code: '<button (click)="model().deeply.nested.property = value"></button>',
-          errors: [{ messageId: 'directMutation' }],
-        },
-        {
-          code: '<button (click)="model().array[0] = value"></button>',
-          errors: [{ messageId: 'directMutation' }],
+          code: '<button (click)="getConfig().users.push(user)"></button>',
+          filename: inlineTemplatePath,
         },
-        // Every compound assignment accepted by the Angular parser
+      ],
+      invalid: [
         {
-          code: '<button (click)="model().property += value"></button>',
-          errors: [{ messageId: 'directMutation' }],
+          code: '<button (click)="partenaire().users.splice(index, 1)"></button>',
+          filename: inlineTemplatePath,
+          errors: [{ messageId: 'inPlaceMutation' }],
         },
+      ],
+    });
+  });
+
+  // Without the declaring class, the signals are unknown. Reporting on the call shape
+  // alone can be wrong, but a false positive costs a disable comment while a missed
+  // mutation is silent.
+  it('should fall back to the call shape when the component cannot be read', () => {
+    templateRuleTester.run('no-direct-signal-mutation', rule, {
+      valid: [
         {
-          code: '<button (click)="model().property ??= value"></button>',
-          errors: [{ messageId: 'directMutation' }],
+          code: '<button (click)="component.whatever().name = value"></button>',
+          filename: unknownTemplatePath,
         },
-        // The mutation hidden in a two-way binding, reported once and not twice
         {
-          code: '<input [(ngModel)]="model().comment" />',
-          errors: [{ messageId: 'directMutation' }],
+          code: '<button (click)="map.get(key).name = value"></button>',
+          filename: unknownTemplatePath,
         },
+      ],
+      invalid: [
         {
-          code: '<app-child [(value)]="model().nested.property"></app-child>',
+          code: '<button (click)="whatever().name = value"></button>',
+          filename: unknownTemplatePath,
           errors: [{ messageId: 'directMutation' }],
         },
-        // An explicit `…Change` handler carrying the assignment: the Binary reports it,
-        // the BoundEvent must not report it a second time.
         {
-          code: '<app-child (valueChange)="model().property = $event"></app-child>',
-          errors: [{ messageId: 'directMutation' }],
+          code: '<button (click)="whatever().users.push(user)"></button>',
+          filename: unknownTemplatePath,
+          errors: [{ messageId: 'inPlaceMutation' }],
         },
       ],
     });