@dsivd/prestations-ng 19.0.5-beta.2 → 19.0.5-beta.4

package/package.json

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

package/src/eslint/index.mjs

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

package/src/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/src/eslint/rules/index.mjs

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

package/src/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/types/dsivd-prestations-ng.d.ts

@@ -205,7 +205,6 @@ declare abstract class FoehnInputComponent<T> implements OnInit, AfterViewInit {
     onModelChange(value: T): void;
     handleChange(value: T): void;
     updateNgModel(value: T): void;
-    patchModel(patch: T extends object ? Partial<T> : never): void;
     hasErrorsToDisplay(): boolean;
     hasErrors(): boolean;
     hasInheritErrorFromParent(): boolean;