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

package/eslint/configs/ts-recommended.mjs

@@ -0,0 +1,142 @@
+import eslint from '@eslint/js';
+import rxjs from '@smarttools/eslint-plugin-rxjs';
+import angular from 'angular-eslint';
+import importX from 'eslint-plugin-import-x';
+import simpleImportSort from 'eslint-plugin-simple-import-sort';
+import tseslint from 'typescript-eslint';
+
+import tsRules from './ts-rules.mjs';
+
+/**
+ * The house TypeScript preset: the shared baselines, this library's own rules, and the
+ * conventions every prestations-ng project follows.
+ *
+ * Meant for the `extends` of a `**\/*.ts` block. It brings its own parser and plugins,
+ * so do not spread `angular.configs.tsRecommended` alongside it — declaring the same
+ * plugin twice from two different copies makes ESLint fail outright.
+ */
+const tsRecommended = (plugin) => [
+    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…
+    ...tsRules(plugin),
+    {
+        name: 'prestations-ng/ts-recommended',
+        plugins: {
+            rxjs,
+            'simple-import-sort': simpleImportSort,
+            'import-x': importX,
+        },
+        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-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',
+        },
+    },
+];
+export default tsRecommended;

package/eslint/configs/ts-rules.mjs

@@ -0,0 +1,14 @@
+import tsBase from './ts-base.mjs';
+
+// Only the rules written by this library. `tsRecommended` includes it, alongside the
+// house style; use this layer directly to opt out of the latter.
+const tsRules = (plugin) => [
+    tsBase(plugin),
+    {
+        name: 'prestations-ng/ts-rules',
+        rules: {
+            '@dsivd/prestations-ng/no-direct-signal-mutation': 'error',
+        },
+    },
+];
+export default tsRules;

package/eslint/index.mjs

@@ -1,7 +1,22 @@
-import { noDirectSignalMutation } from './rules/index.mjs';
+import templateRecommended from './configs/template-recommended.mjs';
+import templateRules from './configs/template-rules.mjs';
+import tsRecommended from './configs/ts-recommended.mjs';
+import tsRules from './configs/ts-rules.mjs';
+import rules from './rules/index.mjs';
 
-export default {
-  rules: {
-    'no-direct-signal-mutation': noDirectSignalMutation,
-  },
+const plugin = {
+    meta: { name: '@dsivd/prestations-ng' },
+    rules,
 };
+
+const configs = {
+    // The house presets: baselines, this library's rules, and the shared conventions.
+    tsRecommended: tsRecommended(plugin),
+    templateRecommended: templateRecommended(plugin),
+    // Only this library's own rules, for a project that supplies its own style.
+    tsRules: tsRules(plugin),
+    templateRules: templateRules(plugin),
+};
+
+export { configs, plugin, rules };
+export default { configs, plugin, rules };

package/eslint/rules/index.mjs

@@ -1 +1,7 @@
-export { default as noDirectSignalMutation } from './no-direct-signal-mutation.mjs';
+import noDirectSignalMutation from './no-direct-signal-mutation.mjs';
+import noUninvokedSignalInTemplate from './no-uninvoked-signal-in-template.mjs';
+
+export default {
+  'no-direct-signal-mutation': noDirectSignalMutation,
+  'no-uninvoked-signal-in-template': noUninvokedSignalInTemplate,
+};

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);
         }
-      }
-    }
+      },
+    };
   },
 };