@dsivd/prestations-ng 19.0.6-beta.2 → 19.0.6

package/eslint/rules/no-direct-signal-mutation.mjs

@@ -1,8 +1,222 @@
+import { handlerExpressionOf, isComponentReceiver } from "../template-ast.mjs";
+
 /**
  * ESLint rule to detect direct mutations of signal/getter results.
  * Warns against patterns like: model().property = value
  * Suggests using .update() or .set() instead.
+ *
+ * Applies to TypeScript files and to Angular templates, where the mutation is also
+ * hidden in every two-way binding on a call result: [(ngModel)]="model().property".
  */
+
+// Assignment operators accepted by the Angular expression parser.
+const TEMPLATE_ASSIGNMENTS = new Set([
+  "=",
+  "+=",
+  "-=",
+  "*=",
+  "/=",
+  "%=",
+  "**=",
+  "&&=",
+  "||=",
+  "??=",
+]);
+
+const TEMPLATE_MEMBER_READS = new Set([
+  "PropertyRead",
+  "SafePropertyRead",
+  "KeyedRead",
+  "SafeKeyedRead",
+]);
+
+const VIEW_QUERY_FACTORIES = new Set([
+  "viewChild",
+  "viewChildren",
+  "contentChild",
+  "contentChildren",
+]);
+
+// ── TypeScript ───────────────────────────────────────────────────────────────
+
+function getCalledName(callee) {
+  if (!callee) {
+    return null;
+  }
+  if (callee.type === "Identifier") {
+    return callee.name;
+  }
+  if (
+    callee.type === "MemberExpression" &&
+    !callee.computed &&
+    callee.property.type === "Identifier"
+  ) {
+    return callee.property.name;
+  }
+  return null;
+}
+
+/**
+ * Finds the first/root function call used as the base of a mutation chain.
+ * Examples:
+ * - model().property = x         => model()
+ * - this.model().deep.prop = x   => this.model()
+ * - this.query().el().x = y      => this.query()
+ */
+function getFirstCallExpression(node) {
+  if (!node) {
+    return null;
+  }
+  if (node.type === "MemberExpression") {
+    return getFirstCallExpression(node.object);
+  }
+  if (node.type === "CallExpression") {
+    if (node.callee.type === "MemberExpression") {
+      const nestedCall = getFirstCallExpression(node.callee.object);
+      return nestedCall || node;
+    }
+    return node;
+  }
+  return null;
+}
+
+function isViewQueryFactoryCall(node) {
+  if (node?.type !== "CallExpression") {
+    return false;
+  }
+  // `viewChild.required(…)` unwraps to its factory.
+  let callee = node.callee;
+  while (callee?.type === "MemberExpression") {
+    callee = callee.object;
+  }
+  return callee?.type === "Identifier" && VIEW_QUERY_FACTORIES.has(callee.name);
+}
+
+function walkAst(node, visitor, visited = new WeakSet()) {
+  if (!node || typeof node !== "object") {
+    return;
+  }
+  if (visited.has(node)) {
+    return;
+  }
+  visited.add(node);
+
+  visitor(node);
+
+  for (const key of Object.keys(node)) {
+    // ESLint AST nodes include cyclic parent references.
+    if (key === "parent") {
+      continue;
+    }
+    const child = node[key];
+    if (Array.isArray(child)) {
+      for (const element of child) {
+        walkAst(element, visitor, visited);
+      }
+    } else {
+      walkAst(child, visitor, visited);
+    }
+  }
+}
+
+// A view query signal is read-only: `.set()` does not exist on it, so a mutation
+// reached through one must not be reported.
+function collectViewQueryAccessorNames(ast) {
+  const names = new Set();
+
+  walkAst(ast, (node) => {
+    if (
+      node.type === "VariableDeclarator" &&
+      node.id?.type === "Identifier" &&
+      isViewQueryFactoryCall(node.init)
+    ) {
+      names.add(node.id.name);
+      return;
+    }
+
+    if (
+      (node.type === "PropertyDefinition" || node.type === "ClassProperty") &&
+      node.key?.type === "Identifier" &&
+      isViewQueryFactoryCall(node.value)
+    ) {
+      names.add(node.key.name);
+    }
+  });
+
+  return names;
+}
+
+function isViewQueryAccessorCall(callee, viewQueryAccessorNames) {
+  const calledName = getCalledName(callee);
+  return calledName ? viewQueryAccessorNames.has(calledName) : false;
+}
+
+function isSignalLikeRootCall(node, viewQueryAccessorNames) {
+  if (node.arguments.length !== 0) {
+    return false;
+  }
+
+  // model().prop = ... (local signal-like accessor)
+  if (node.callee.type === "Identifier") {
+    return !viewQueryAccessorNames.has(node.callee.name);
+  }
+
+  // this.model().prop = ... (component/service signal accessor)
+  // component.model().prop = ... should not be assumed to be a signal read.
+  if (node.callee.type === "MemberExpression") {
+    if (node.callee.object?.type !== "ThisExpression") {
+      return false;
+    }
+    return !isViewQueryAccessorCall(node.callee, viewQueryAccessorNames);
+  }
+
+  return false;
+}
+
+// ── Angular templates ────────────────────────────────────────────────────────
+
+// Template counterpart of `getFirstCallExpression`.
+function getFirstTemplateCall(node) {
+  if (!node) {
+    return null;
+  }
+  if (TEMPLATE_MEMBER_READS.has(node.type)) {
+    return getFirstTemplateCall(node.receiver);
+  }
+  if (node.type === "Call" || node.type === "SafeCall") {
+    return getFirstTemplateCall(node.receiver) || node;
+  }
+  return null;
+}
+
+/**
+ * Template counterpart of `isSignalLikeRootCall`. A template has no bare identifier:
+ * `model()` and `this.model()` both read the member directly on the component, so both
+ * collapse to `isComponentReceiver`. `map.get(key)` (arguments) and
+ * `component.inputElement()` (foreign receiver) are therefore not assumed to be signal
+ * reads, as in TypeScript.
+ */
+function isSignalLikeRootTemplateCall(node) {
+  if (node.args?.length !== 0) {
+    return false;
+  }
+  const callee = node.receiver;
+  if (!callee || !TEMPLATE_MEMBER_READS.has(callee.type)) {
+    return false;
+  }
+  return isComponentReceiver(callee.receiver);
+}
+
+// Template counterpart of the TypeScript checks: a member of a signal-like call
+// result, such as `model().property` or `this.model().array[0]`.
+function isTemplateCallResultMember(node) {
+  if (!node || !TEMPLATE_MEMBER_READS.has(node.type)) {
+    return false;
+  }
+  const rootCall = getFirstTemplateCall(node.receiver);
+  return !!rootCall && isSignalLikeRootTemplateCall(rootCall);
+}
+
 export default {
   meta: {
     type: "problem",
@@ -19,157 +233,47 @@ export default {
   },
 
   create(context) {
-    const sourceCode = context.sourceCode;
-    const viewQueryFactoryNames = new Set([
-      "viewChild",
-      "viewChildren",
-      "contentChild",
-      "contentChildren",
-    ]);
-    const viewQueryAccessorNames = collectViewQueryAccessorNames(sourceCode.ast);
+    const viewQueryAccessorNames = collectViewQueryAccessorNames(
+      context.sourceCode.ast,
+    );
+
+    const report = (node) =>
+      context.report({ node, messageId: "directMutation" });
 
     return {
+      // ── TypeScript ───────────────────────────────────────────────────────────
       AssignmentExpression(node) {
         if (node.left.type !== "MemberExpression") {
           return;
         }
 
-        const rootCallExpression = getFirstCallExpression(node.left.object);
-        if (rootCallExpression && isSignalLikeRootCall(rootCallExpression)) {
-          context.report({
-            node,
-            messageId: "directMutation",
-          });
+        const rootCall = getFirstCallExpression(node.left.object);
+        if (rootCall && isSignalLikeRootCall(rootCall, viewQueryAccessorNames)) {
+          report(node);
         }
       },
-    };
-
-    function isSignalLikeRootCall(node) {
-      if (node.arguments.length !== 0) {
-        return false;
-      }
-
-      // model().prop = ... (local signal-like accessor)
-      if (node.callee.type === "Identifier") {
-        return !viewQueryAccessorNames.has(node.callee.name);
-      }
-
-      // this.model().prop = ... (component/service signal accessor)
-      // component.model().prop = ... should not be assumed to be a signal read.
-      if (node.callee.type === "MemberExpression") {
-        if (node.callee.object?.type !== "ThisExpression") {
-          return false;
-        }
-        return !isViewQueryAccessorCall(node.callee);
-      }
-
-      return false;
-    }
-
-    function isViewQueryAccessorCall(callee) {
-      const calledName = getCalledName(callee);
-      return calledName ? viewQueryAccessorNames.has(calledName) : false;
-    }
-
-    function getCalledName(callee) {
-      if (!callee) {
-        return null;
-      }
-      if (callee.type === "Identifier") {
-        return callee.name;
-      }
-      if (
-        callee.type === "MemberExpression" &&
-        !callee.computed &&
-        callee.property.type === "Identifier"
-      ) {
-        return callee.property.name;
-      }
-      return null;
-    }
-
-    /**
-     * Finds the first/root function call used as the base of a mutation chain.
-     * Examples:
-     * - model().property = x         => model()
-     * - this.model().deep.prop = x   => this.model()
-     * - this.query().el().x = y      => this.query()
-     */
-    function getFirstCallExpression(node) {
-      if (!node) {
-        return null;
-      }
-      if (node.type === "MemberExpression") {
-        return getFirstCallExpression(node.object);
-      }
-      if (node.type === "CallExpression") {
-        if (node.callee.type === "MemberExpression") {
-          const nestedCall = getFirstCallExpression(node.callee.object);
-          return nestedCall || node;
-        }
-        return node;
-      }
-      return null;
-    }
-
-    function collectViewQueryAccessorNames(ast) {
-      const names = new Set();
-
-      walkAst(ast, (node) => {
-        if (
-          node.type === "VariableDeclarator" &&
-          node.id?.type === "Identifier" &&
-          isViewQueryFactoryCall(node.init)
-        ) {
-          names.add(node.id.name);
-          return;
-        }
 
+      // ── Angular templates ────────────────────────────────────────────────────
+      Binary(node) {
         if (
-          (node.type === "PropertyDefinition" || node.type === "ClassProperty") &&
-          node.key?.type === "Identifier" &&
-          isViewQueryFactoryCall(node.value)
+          TEMPLATE_ASSIGNMENTS.has(node.operation) &&
+          isTemplateCallResultMember(node.left)
         ) {
-          names.add(node.key.name);
+          report(node);
         }
-      });
-
-      return names;
-    }
-
-    function isViewQueryFactoryCall(node) {
-      return (
-        node?.type === "CallExpression" &&
-        node.callee?.type === "Identifier" &&
-        viewQueryFactoryNames.has(node.callee.name)
-      );
-    }
-
-    function walkAst(node, visitor, visited = new WeakSet()) {
-      if (!node || typeof node !== "object") {
-        return;
-      }
-      if (visited.has(node)) {
-        return;
-      }
-      visited.add(node);
-
-      visitor(node);
+      },
 
-      for (const key of Object.keys(node)) {
-        // ESLint AST nodes include cyclic parent references.
-        if (key === "parent") {
-          continue;
+      BoundEvent(node) {
+        // `[(x)]="model().property"` makes Angular assign into the value of the signal.
+        // Reporting on the BoundEvent handler reports the binding exactly once.
+        if (!node.name?.endsWith("Change")) {
+          return;
         }
-        const child = node[key];
-        if (Array.isArray(child)) {
-          for (const element of child) {
-            walkAst(element, visitor, visited);
-          }
-        } else {
-          walkAst(child, visitor, visited);
+        const handler = handlerExpressionOf(node);
+        if (isTemplateCallResultMember(handler)) {
+          report(handler);
         }
-      }
-    }
+      },
+    };
   },
 };

package/eslint/rules/no-uninvoked-signal-in-template.mjs

@@ -0,0 +1,170 @@
+import { collectSignalNames } from "../signal-names.mjs";
+import { handlerExpressionOf, isComponentReceiver } from "../template-ast.mjs";
+
+/**
+ * ESLint rule to detect signals referenced without being called in a template.
+ * Warns against patterns like: {{ mySignal }}, !mySignal, mySignal + 'x'
+ * Suggests calling the signal instead: mySignal()
+ *
+ * The compiler only covers part of these cases (NG8109 / NG8117): it lets through
+ * the negation (`!mySignal`, always false) and the concatenation (`mySignal + 'x'`,
+ * which injects the source code of the function).
+ *
+ * Signal names are resolved from the template's twin `.ts` and from its inheritance
+ * chain, base classes of other packages included. Nothing has to be configured.
+ */
+
+// `mySignal.set(…)` targets the signal itself, not its value: no parentheses needed.
+const SIGNAL_MEMBERS = new Set(["set", "update", "asReadonly"]);
+
+// Implicit template variables: never signals of the component.
+const TEMPLATE_BUILTINS = [
+  "$event",
+  "$index",
+  "$count",
+  "$first",
+  "$last",
+  "$even",
+  "$odd",
+  "$any",
+  "$implicit",
+];
+
+// 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.
+function resolveComponentPath(filename) {
+  const inlineMatch = filename.match(/^(.*\.ts)(?:[/\\]|$)/);
+  if (inlineMatch) {
+    return inlineMatch[1];
+  }
+  return filename.endsWith(".html")
+    ? `${filename.slice(0, -".html".length)}.ts`
+    : undefined;
+}
+
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Warn on signals referenced without being called in an Angular template",
+      category: "Best Practices",
+      recommended: true,
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      uninvoked:
+        "Signal '{{name}}' is referenced without being called. Use '{{name}}()' instead: a bare reference is the function itself, always truthy and serialized as source code.",
+    },
+  },
+
+  create(context) {
+    const componentPath = resolveComponentPath(context.filename);
+    if (!componentPath) {
+      return {};
+    }
+
+    const signalNames = collectSignalNames(componentPath);
+    if (signalNames.size === 0) {
+      return {};
+    }
+
+    // Names bound by the template (#ref, @for items, @if aliases, @let, let-x): they
+    // shadow the class members, so they are never reported.
+    const shadowed = new Set(TEMPLATE_BUILTINS);
+    // References that already carry parentheses (`x()`) or that address the signal
+    // itself (`x.set(…)`).
+    const exempt = new Set();
+    // Spans already handled, by position. Holds the written positions (lvalue): a
+    // writable signal is bound WITHOUT parentheses — `[(x)]="mySignal"` — Angular
+    // calling `.set()` itself. A two-way binding also duplicates its expression
+    // (BoundAttribute + BoundEvent), so the same set dedupes the reports.
+    const handledSpans = new Set();
+    const candidates = [];
+
+    const markHandled = (node) => {
+      const { start, end } = node?.sourceSpan ?? {};
+      if (typeof start === "number") {
+        handledSpans.add(`${start}:${end}`);
+      }
+    };
+
+    const rememberDeclarations = (node) => {
+      for (const declaration of [
+        ...(node.references ?? []),
+        ...(node.variables ?? []),
+      ]) {
+        shadowed.add(declaration.name);
+      }
+    };
+
+    return {
+      Call: (node) => exempt.add(node.receiver),
+      SafeCall: (node) => exempt.add(node.receiver),
+      Element: rememberDeclarations,
+      Template: rememberDeclarations,
+      Content: rememberDeclarations,
+      BoundEvent(node) {
+        // `[(x)]="expr"` generates a BoundEvent `xChange` whose handler IS the written
+        // target. Its span is the one of the twin BoundAttribute expression: marking
+        // the span neutralizes both copies at once.
+        if (node.name?.endsWith("Change")) {
+          markHandled(handlerExpressionOf(node));
+        }
+      },
+      Binary(node) {
+        if (node.operation === "=") {
+          markHandled(node.left);
+        }
+      },
+      LetDeclaration(node) {
+        shadowed.add(node.name);
+      },
+      IfBlockBranch(node) {
+        if (node.expressionAlias) {
+          shadowed.add(node.expressionAlias.name);
+        }
+      },
+      ForLoopBlock(node) {
+        shadowed.add(node.item.name);
+        for (const contextVariable of node.contextVariables ?? []) {
+          shadowed.add(contextVariable.name);
+        }
+      },
+      PropertyRead(node) {
+        if (SIGNAL_MEMBERS.has(node.name)) {
+          exempt.add(node.receiver);
+        }
+        if (isComponentReceiver(node.receiver) && signalNames.has(node.name)) {
+          candidates.push(node);
+        }
+      },
+      "Program:exit"() {
+        for (const node of candidates) {
+          const { start, end } = node.sourceSpan;
+          const span = `${start}:${end}`;
+          if (
+            exempt.has(node) ||
+            shadowed.has(node.name) ||
+            handledSpans.has(span)
+          ) {
+            continue;
+          }
+          handledSpans.add(span);
+
+          context.report({
+            messageId: "uninvoked",
+            data: { name: node.name },
+            loc: {
+              start: context.sourceCode.getLocFromIndex(start),
+              end: context.sourceCode.getLocFromIndex(end),
+            },
+            fix: (fixer) => fixer.insertTextAfterRange([start, end], "()"),
+          });
+        }
+      },
+    };
+  },
+};