kensington-eslint-plugin 0.6.0 → 0.6.1

package/README.md

@@ -56,7 +56,7 @@ export default [
 What `strict` changes on top of `recommended`:
 
 - **Adds `no-helper-function-trap`** (error). The most valuable single rule the plugin ships.
-- **Promotes from `warn` to `error`**: `no-signal-async-write`, `no-ignored-effect-return`, `prefer-value-in-async`, `no-out-of-scope-reactive-reference`. Real reactive-correctness issues; strict mode chooses zero silent misses over tolerance of false positives.
+- **Promotes from `warn` to `error`**: `no-signal-async-write`, `no-ignored-effect-return`, `prefer-value-in-async`, `prefer-subscribe-in-effect`, `no-out-of-scope-reactive-reference`. Real reactive-correctness issues; strict mode chooses zero silent misses over tolerance of false positives.
 
 Use `strict` if you want CI to fail on any reactive-correctness issue, or if you're using an agent-driven workflow that benefits from harder enforcement. Use `recommended` for production codebases that prefer the warnings as guidance.
 
@@ -124,6 +124,7 @@ Because this is a standard ESLint plugin, it works anywhere ESLint runs with no
 | [`no-signal-async-write`](#no-signal-async-write) | Disallow writing a signal in an async callback when it was read in the enclosing `effect()` | warn | error |
 | [`no-ignored-effect-return`](#no-ignored-effect-return) | Require capturing the return value of `effect()` inside a function | warn | error |
 | [`prefer-value-in-async`](#prefer-value-in-async) | Prefer `.value` over `.get()` inside async callbacks within an `effect()` | warn | error |
+| [`prefer-subscribe-in-effect`](#prefer-subscribe-in-effect) | Prefer `.subscribe()` for trigger-only `.get()` calls inside an `effect()` | warn | error |
 | [`no-new-computed-in-effect`](#no-new-computed-in-effect) | Disallow creating a new `computed()` inside an `effect()` body | error | error |
 | [`no-new-signal-in-computed`](#no-new-signal-in-computed) | Require a stable key for `signal()` calls inside a `computed()` body | error | error |
 | [`no-unsafe-literal`](#no-unsafe-literal) | Disallow `.unsafeLiteral()` calls that bypass XSS protection | error | error |
@@ -321,6 +322,26 @@ effect(() => {
 
 ---
 
+### `prefer-subscribe-in-effect`
+
+Use `.subscribe()` when an effect reads a signal only to subscribe to its changes and does not need the current value. The alias makes the trigger-only intent clear.
+
+```js
+// Bad
+effect(() => {
+  count.get(); // warn. The value is ignored.
+});
+
+// Good
+effect(() => {
+  count.subscribe();
+});
+```
+
+The rule leaves value reads used in expressions, assignments, and nested callbacks alone.
+
+---
+
 ### `no-new-computed-in-effect`
 
 Creating `computed()` inside an `effect()` creates a new orphaned derived signal on every run. The previous one silently loses its subscriber with no cleanup.

package/index.js

@@ -25,6 +25,7 @@ import consistentContentLayout from './rules/consistent-content-layout.js';
 import noHelperFunctionTrap from './rules/no-helper-function-trap.js';
 import requireReactiveKey from './rules/require-reactive-key.js';
 import noAsyncSet from './rules/no-async-set.js';
+import preferSubscribeInEffect from './rules/prefer-subscribe-in-effect.js';
 
 const plugin = {
   meta: { name: 'eslint-plugin-kensington' },
@@ -56,6 +57,7 @@ const plugin = {
     'no-helper-function-trap': noHelperFunctionTrap,
     'require-reactive-key': requireReactiveKey,
     'no-async-set': noAsyncSet,
+    'prefer-subscribe-in-effect': preferSubscribeInEffect,
   },
   configs: {},
 };
@@ -80,6 +82,7 @@ plugin.configs.recommended = {
     'kensington/no-out-of-scope-reactive-reference': 'warn',
     'kensington/no-helper-function-trap': 'warn',
     'kensington/no-async-set': 'error',
+    'kensington/prefer-subscribe-in-effect': 'warn',
   },
 };
 
@@ -102,6 +105,7 @@ plugin.configs.strict = {
     'kensington/prefer-value-in-async': 'error',
     'kensington/no-out-of-scope-reactive-reference': 'error',
     'kensington/no-helper-function-trap': 'error',
+    'kensington/prefer-subscribe-in-effect': 'error',
   },
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kensington-eslint-plugin",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "ESLint rules for kensington signal correctness",
   "type": "module",
   "main": "index.js",

package/rules/prefer-subscribe-in-effect.js

@@ -0,0 +1,74 @@
+// Reports trigger-only .get() calls in an effect() callback. `.subscribe()` is
+// an alias for `.get()` that makes it clear the value is intentionally ignored.
+export default {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'prefer .subscribe() over trigger-only .get() calls in effect() callbacks',
+    },
+    messages: {
+      preferSubscribeInEffect:
+        'Use .subscribe() for a trigger-only read inside an effect. ' +
+        'It makes clear that the signal value is intentionally ignored.',
+    },
+  },
+
+  create(context) {
+    const effectNames = new Set();
+    // Each frame is { type: 'effect'|'other', callback? }. Nested functions are
+    // excluded because their .get() calls may consume a value independently of
+    // the surrounding effect's trigger-only reads.
+    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 === 'effect') { effectNames.add(spec.local.name); }
+        }
+      },
+
+      ':matches(ArrowFunctionExpression, FunctionExpression)'(node) {
+        const { parent } = node;
+        if (
+          parent.type === 'CallExpression' &&
+          parent.arguments[0] === node &&
+          parent.callee.type === 'Identifier' &&
+          effectNames.has(parent.callee.name)
+        ) {
+          fnStack.push({ type: 'effect', callback: node });
+          return;
+        }
+
+        fnStack.push({ type: 'other' });
+      },
+
+      ':matches(ArrowFunctionExpression, FunctionExpression):exit'() {
+        fnStack.pop();
+      },
+
+      CallExpression(node) {
+        const frame = fnStack[fnStack.length - 1];
+        if (!frame || frame.type !== 'effect') { return; }
+        if (
+          node.callee.type !== 'MemberExpression' ||
+          node.callee.object.type !== 'Identifier' ||
+          node.callee.property.type !== 'Identifier' ||
+          node.callee.property.name !== 'get' ||
+          node.arguments.length !== 0
+        ) { return; }
+
+        const parent = node.parent;
+        const isExpressionStatement = parent.type === 'ExpressionStatement';
+        const isConciseEffectBody = parent === frame.callback &&
+          frame.callback.type === 'ArrowFunctionExpression' &&
+          frame.callback.expression;
+
+        if (isExpressionStatement || isConciseEffectBody) {
+          context.report({ node, messageId: 'preferSubscribeInEffect' });
+        }
+      },
+    };
+  },
+};