@dsivd/prestations-ng 19.0.5-beta.3 → 19.0.5-beta.5

package/ANGULAR_SIGNALS.md

@@ -847,7 +847,4 @@ this.address.update((current) => ({
     ...current,
     locality: { ...current.locality, name: 'newName' },
 }));
-
-// 🟢 Or, if you're in a component extending `FoehnInputComponent` :
-this.patchModel({ locality: { name: 'newName' } });
 ```

package/UPGRADING_V19.md

@@ -1092,6 +1092,7 @@ 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 prestationsNgEslint from '@dsivd/prestations-ng/eslint';
 
 export default tseslint.config(
     {
@@ -1122,6 +1123,7 @@ export default tseslint.config(
             rxjs,
             'simple-import-sort': simpleImportSort,
             'import-x': importX,
+            '@dsivd/prestations-ng': prestationsNgEslint,
         },
         processor: angular.processInlineTemplates,
         rules: {
@@ -1228,6 +1230,9 @@ export default tseslint.config(
             // ── simple-import-sort ───────────────────────────────────────────
             'simple-import-sort/imports': 'error',
             'simple-import-sort/exports': 'error',
+
+            // ── prestations-ng ──────────────────────────────────────────────
+            '@dsivd/prestations-ng/no-direct-signal-mutation': 'error',
         },
     },
 

package/eslint/index.mjs

@@ -0,0 +1,7 @@
+import { noDirectSignalMutation } from './rules/index.mjs';
+
+export default {
+  rules: {
+    'no-direct-signal-mutation': noDirectSignalMutation,
+  },
+};

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

@@ -0,0 +1,98 @@
+import { describe, it } from 'vitest';
+import { RuleTester } from 'eslint';
+import rule from '../no-direct-signal-mutation.mjs';
+
+describe('no-direct-signal-mutation', () => {
+  const ruleTester = new RuleTester({
+    languageOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+    },
+  });
+
+  it('should validate signal mutation rule', () => {
+    ruleTester.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 })',
+
+        // 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',
+
+        // Method chaining without assignment
+        'model().update((v) => v).subscribe()',
+
+        // One-way bindings are OK
+        '[model]="model().property"',
+        '[ngModel]="model().comment"',
+      ],
+
+      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: "obj.getter().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' }],
+        },
+      ],
+    });
+  });
+});

package/eslint/rules/index.mjs

@@ -0,0 +1 @@
+export { default as noDirectSignalMutation } from './no-direct-signal-mutation.mjs';

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

@@ -0,0 +1,52 @@
+/**
+ * ESLint rule to detect direct mutations of signal/getter results.
+ * Warns against patterns like: model().property = value
+ * Suggests using .update() or .set() instead.
+ */
+export default {
+  meta: {
+    type: "problem",
+    docs: {
+      description:
+        "Warn on direct property mutations of function call results (signals, getters, etc.)",
+      category: "Best Practices",
+      recommended: true,
+    },
+    messages: {
+      directMutation:
+        "Direct mutation of function call result detected. Use .update() or .set() instead of direct assignment.",
+    },
+  },
+
+  create(context) {
+    return {
+      AssignmentExpression(node) {
+        // Check if left side is a member expression with a call expression
+        if (
+          node.left.type === "MemberExpression" &&
+          isCallExpression(node.left.object)
+        ) {
+          context.report({
+            node,
+            messageId: "directMutation",
+          });
+        }
+      },
+    };
+
+    /**
+     * Recursively check if a node is a call expression.
+     * Handles: func().prop, obj.func().prop, this.func().prop, etc.
+     */
+    function isCallExpression(node) {
+      if (!node) return false;
+      if (node.type === "CallExpression") {
+        return true;
+      }
+      if (node.type === "MemberExpression") {
+        return isCallExpression(node.object);
+      }
+      return false;
+    }
+  },
+};

package/fesm2022/dsivd-prestations-ng.mjs

@@ -793,16 +793,6 @@ class FoehnInputComponent {
         this.modelEffect = effect(() => {
             this.onModelChange(this.model());
         }, ...(ngDevMode ? [{ debugName: "modelEffect" }] : /* istanbul ignore next */ []));
-        this.patchModel = (patch) => {
-            this.model.update((current) => {
-                if (current &&
-                    typeof current === 'object' &&
-                    !Array.isArray(current)) {
-                    return { ...current, ...patch };
-                }
-                throw new Error('patchModel can only be used with object models.');
-            });
-        };
     }
     get errors() {
         return this._errors?.sort((a, b) => ObjectHelper.stripHtml(a.message).localeCompare(ObjectHelper.stripHtml(b.message)));