kensington-eslint-plugin 0.1.2 → 0.2.0

package/README.md

@@ -70,6 +70,8 @@ Because this is a standard ESLint plugin, it works anywhere ESLint runs — no e
 | [`no-effect-in-effect`](#no-effect-in-effect) | Disallow creating a new `effect()` inside an `effect()` body | error |
 | [`no-async-effect`](#no-async-effect) | Disallow async callbacks passed to `effect()` | error |
 | [`no-async-computed`](#no-async-computed) | Disallow async callbacks passed to `computed()` | error |
+| [`no-set-in-transform`](#no-set-in-transform) | Disallow `.set()` inside a `.transform()` callback | error |
+| [`no-set-on-transform`](#no-set-on-transform) | Disallow `.set()` on a transform-derived signal | error |
 
 ---
 
@@ -345,3 +347,37 @@ effect(() => {
   fetch('/api').then(r => r.json()).then(v => data.set(v));
 });
 ```
+
+---
+
+### `no-set-in-transform`
+
+Transform callbacks must be pure derivations. Calling `.set()` inside one causes a write during a read pass, the same class of bug as `.set()` inside `computed()`.
+
+```js
+// Bad
+const rows = items.transform(list => {
+  selectedId.set(null); // error
+  return list.map(item => t.li(item.name));
+});
+
+// Good — move the write into a separate effect
+effect(() => {
+  if (!items.get().length) { selectedId.set(null); }
+});
+```
+
+---
+
+### `no-set-on-transform`
+
+Transform-derived signals are read-only. Calling `.set()` on one throws at runtime; this rule catches it statically.
+
+```js
+// Bad
+const doubled = count.transform(v => v * 2);
+doubled.set(10); // error — transform results are read-only
+
+// Good — write to the source signal instead
+count.set(5);
+```

package/index.js

@@ -13,6 +13,8 @@ import noNewComputedInComputed from './rules/no-new-computed-in-computed.js';
 import noEffectInEffect from './rules/no-effect-in-effect.js';
 import noAsyncEffect from './rules/no-async-effect.js';
 import noAsyncComputed from './rules/no-async-computed.js';
+import noSetInTransform from './rules/no-set-in-transform.js';
+import noSetOnTransform from './rules/no-set-on-transform.js';
 
 const plugin = {
   meta: { name: 'eslint-plugin-kensington' },
@@ -32,6 +34,8 @@ const plugin = {
     'no-effect-in-effect': noEffectInEffect,
     'no-async-effect': noAsyncEffect,
     'no-async-computed': noAsyncComputed,
+    'no-set-in-transform': noSetInTransform,
+    'no-set-on-transform': noSetOnTransform,
   },
   configs: {},
 };
@@ -54,6 +58,8 @@ plugin.configs.recommended = {
     'kensington/no-effect-in-effect': 'error',
     'kensington/no-async-effect': 'error',
     'kensington/no-async-computed': 'error',
+    'kensington/no-set-in-transform': 'error',
+    'kensington/no-set-on-transform': 'error',
   },
 };
 

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "kensington-eslint-plugin",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "ESLint rules for kensington signal correctness",
   "type": "module",
   "main": "index.js",
   "scripts": {
-    "test": "node --test tests/no-set-in-computed.test.js tests/no-self-read-write.test.js tests/no-signal-async-write.test.js tests/no-set-on-computed.test.js tests/no-new-signal-in-effect.test.js tests/no-effect-in-computed.test.js tests/no-ignored-effect-return.test.js tests/prefer-value-in-async.test.js tests/no-new-computed-in-effect.test.js tests/no-new-signal-in-computed.test.js tests/no-unsafe-literal.test.js tests/no-new-computed-in-computed.test.js tests/no-effect-in-effect.test.js tests/no-async-effect.test.js tests/no-async-computed.test.js"
+    "test": "node --test tests/no-set-in-computed.test.js tests/no-self-read-write.test.js tests/no-signal-async-write.test.js tests/no-set-on-computed.test.js tests/no-new-signal-in-effect.test.js tests/no-effect-in-computed.test.js tests/no-ignored-effect-return.test.js tests/prefer-value-in-async.test.js tests/no-new-computed-in-effect.test.js tests/no-new-signal-in-computed.test.js tests/no-unsafe-literal.test.js tests/no-new-computed-in-computed.test.js tests/no-effect-in-effect.test.js tests/no-async-effect.test.js tests/no-async-computed.test.js tests/no-set-in-transform.test.js tests/no-set-on-transform.test.js"
   },
   "peerDependencies": {
     "eslint": ">=9"
@@ -20,6 +20,13 @@
     "type": "git",
     "url": "https://github.com/ryanlsimms/kensington-eslint-plugin"
   },
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "kensington",
+    "signals"
+  ],
   "license": "ISC",
   "files": [
     "index.js",

package/rules/no-set-in-transform.js

@@ -0,0 +1,80 @@
+// Reports .set() calls inside a .transform() callback.
+// Stops searching when a nested effect() or computed() is reached (separate reactive context).
+export default {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'disallow .set() inside a .transform() callback',
+    },
+    messages: {
+      noSetInTransform:
+        '.set() called inside a .transform() callback. Transform functions must be pure derivations. ' +
+        'Move the write into a separate effect() instead.',
+    },
+  },
+
+  create(context) {
+    const computedNames = new Set();
+    const effectNames = new Set();
+    // Each entry is 'transform', 'computed', 'effect', or 'other' — innermost frame is last.
+    const fnStack = [];
+
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value !== 'kensington') { return; }
+        for (const spec of node.specifiers) {
+          if (spec.type !== 'ImportSpecifier') { continue; }
+          if (spec.imported.name === 'computed') { computedNames.add(spec.local.name); }
+          if (spec.imported.name === 'effect') { effectNames.add(spec.local.name); }
+        }
+      },
+
+      ':matches(ArrowFunctionExpression, FunctionExpression)'(node) {
+        const { parent } = node;
+        if (parent.type === 'CallExpression' && parent.arguments[0] === node) {
+          if (
+            parent.callee.type === 'MemberExpression' &&
+            parent.callee.property.type === 'Identifier' &&
+            parent.callee.property.name === 'transform'
+          ) {
+            fnStack.push('transform');
+            return;
+          }
+          if (parent.callee.type === 'Identifier') {
+            if (computedNames.has(parent.callee.name)) {
+              fnStack.push('computed');
+              return;
+            }
+            if (effectNames.has(parent.callee.name)) {
+              fnStack.push('effect');
+              return;
+            }
+          }
+        }
+        fnStack.push('other');
+      },
+
+      ':matches(ArrowFunctionExpression, FunctionExpression):exit'() {
+        fnStack.pop();
+      },
+
+      CallExpression(node) {
+        if (
+          node.callee.type !== 'MemberExpression' ||
+          node.callee.object.type !== 'Identifier' ||
+          node.callee.property.type !== 'Identifier' ||
+          node.callee.property.name !== 'set' ||
+          node.arguments.length !== 1
+        ) { return; }
+
+        for (let i = fnStack.length - 1; i >= 0; i--) {
+          if (fnStack[i] === 'transform') {
+            context.report({ node, messageId: 'noSetInTransform' });
+            return;
+          }
+          if (fnStack[i] === 'effect' || fnStack[i] === 'computed') { return; }
+        }
+      },
+    };
+  },
+};

package/rules/no-set-on-transform.js

@@ -0,0 +1,48 @@
+// Reports .set() on a variable directly assigned from a .transform() call.
+// Transform-derived signals are read-only; kensington throws at runtime, but this catches it statically.
+export default {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'disallow .set() on a transform-derived signal',
+    },
+    messages: {
+      noSetOnTransform:
+        "'{{name}}' is a transform-derived signal and cannot be written with .set(). " +
+        'Use signal() for writable state.',
+    },
+  },
+
+  create(context) {
+    const transformBindings = new Set();
+
+    return {
+      VariableDeclarator(node) {
+        if (
+          node.id.type !== 'Identifier' ||
+          !node.init ||
+          node.init.type !== 'CallExpression' ||
+          node.init.callee.type !== 'MemberExpression' ||
+          node.init.callee.property.type !== 'Identifier' ||
+          node.init.callee.property.name !== 'transform'
+        ) { return; }
+        transformBindings.add(node.id.name);
+      },
+
+      CallExpression(node) {
+        if (
+          node.callee.type !== 'MemberExpression' ||
+          node.callee.object.type !== 'Identifier' ||
+          node.callee.property.type !== 'Identifier' ||
+          node.callee.property.name !== 'set' ||
+          node.arguments.length !== 1
+        ) { return; }
+
+        const name = node.callee.object.name;
+        if (transformBindings.has(name)) {
+          context.report({ node, messageId: 'noSetOnTransform', data: { name } });
+        }
+      },
+    };
+  },
+};