eslint-plugin-what 0.10.0 → 0.11.1

package/README.md

@@ -36,12 +36,12 @@ export default [
 Catches the #1 mistake for new developers: using a signal reference instead of calling it. Signals are functions -- you must call them to read the value.
 
 ```jsx
-// Bad -- renders "[Function]", conditionals always truthy
+// Bad -- conditionals are always truthy; bare JSX reads rely on compiler auto-wrapping
 <span>{count}</span>
 {isLoading && <Spinner />}
 <span>{swr.data}</span>
 
-// Good
+// Good -- explicit reads work everywhere, compiler or not
 <span>{count()}</span>
 {isLoading() && <Spinner />}
 <span>{swr.data()}</span>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-what",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "description": "ESLint rules for What Framework — catch signal bugs, enforce patterns",
   "type": "module",
   "main": "src/index.js",

package/src/index.js

@@ -9,6 +9,8 @@
  *   export default [what.configs.recommended];
  */
 
+import { createRequire } from 'node:module';
+
 import noSignalInEffectDeps from './rules/no-signal-in-effect-deps.js';
 import reactiveJsxChildren from './rules/reactive-jsx-children.js';
 import noSignalWriteInRender from './rules/no-signal-write-in-render.js';
@@ -19,10 +21,14 @@ import noHInUserCode from './rules/no-h-in-user-code.js';
 import signalCallInJsx from './rules/signal-call-in-jsx.js';
 import noSetInComputed from './rules/no-set-in-computed.js';
 
+// Read the real version from package.json so plugin meta never goes stale.
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+
 const plugin = {
   meta: {
     name: 'eslint-plugin-what',
-    version: '0.6.0',
+    version: pkg.version,
   },
 
   rules: {
@@ -41,8 +47,28 @@ const plugin = {
 };
 
 // Flat config presets (ESLint 9+)
+//
+// Each preset is a COMPLETE standalone flat config entry: it carries its own
+// `files` glob and JSX-enabled language options, so
+// `export default [what.configs.recommended]` works with stock ESLint —
+// no extra parser setup required for .js/.jsx. (.ts/.tsx files match the glob
+// too, but TypeScript syntax additionally needs a TS parser config layered on
+// top, e.g. typescript-eslint.)
+
+const baseLanguageOptions = {
+  ecmaVersion: 'latest',
+  sourceType: 'module',
+  parserOptions: {
+    ecmaFeatures: { jsx: true },
+  },
+};
+
+const FILES = ['**/*.{js,jsx,ts,tsx}'];
 
 plugin.configs.recommended = {
+  name: 'what/recommended',
+  files: FILES,
+  languageOptions: baseLanguageOptions,
   plugins: { what: plugin },
   rules: {
     'what/no-signal-in-effect-deps': 'warn',
@@ -59,6 +85,9 @@ plugin.configs.recommended = {
 
 // Stricter config — all rules as errors + prefer-set
 plugin.configs.strict = {
+  name: 'what/strict',
+  files: FILES,
+  languageOptions: baseLanguageOptions,
   plugins: { what: plugin },
   rules: {
     'what/no-signal-in-effect-deps': 'error',
@@ -75,6 +104,9 @@ plugin.configs.strict = {
 
 // Config for projects using the What compiler (disables rules the compiler handles)
 plugin.configs.compiler = {
+  name: 'what/compiler',
+  files: FILES,
+  languageOptions: baseLanguageOptions,
   plugins: { what: plugin },
   rules: {
     'what/no-signal-in-effect-deps': 'warn',

package/src/rules/no-uncalled-signals.js

@@ -6,14 +6,16 @@
  *
  * Signals are functions — you must call them to read the value.
  * Using a signal without () gives you the function reference, which:
- * - Renders as "[Function]" in JSX
  * - Is always truthy in conditionals
  * - Produces wrong comparisons
+ * - Coerces to the function source in template literals
+ * - In JSX children it only works because the compiler auto-wraps it —
+ *   explicit () reads don't depend on that
  *
- * Bad:  <span>{count}</span>        → renders "[Function]"
  * Bad:  {isLoading && <Spinner />}  → always truthy
- * Bad:  {swr.data}                  → renders "[Function]"
- * Bad:  `Total: ${count}`           → "[Function]"
+ * Bad:  `Total: ${count}`           → function source, not the value
+ * Bad:  <span>{count}</span>        → implicit (relies on compiler auto-wrap)
+ * Bad:  {swr.data}                  → implicit (relies on compiler auto-wrap)
  *
  * Good: <span>{count()}</span>
  * Good: {isLoading() && <Spinner />}

package/src/rules/signal-call-in-jsx.js

@@ -1,18 +1,20 @@
 /**
  * Rule: what/signal-call-in-jsx
  *
- * Warn when a signal is used in JSX without calling it.
- * Signals are functions — using them without () in JSX renders "[Function]"
- * instead of the signal's value.
+ * Warn when a signal is used in JSX as a bare reference instead of being
+ * called. The What compiler auto-wraps bare signals ({count} works when the
+ * code is compiled), but explicit reads ({count()}) are clearer, lint-safe,
+ * and don't depend on compiler magic — e.g. they keep working in plain
+ * h()/runtime-only code paths.
  *
  * This rule specifically targets JSX expression containers, complementing
  * the broader no-uncalled-signals rule with JSX-specific messaging.
  *
- * Bad:  <span>{count}</span>          — renders "[Function]"
- * Bad:  <p>{isLoading && <Spinner />}</p> — always truthy
+ * Implicit: <span>{count}</span>          — relies on compiler auto-wrapping
+ * Bad:      <p>{isLoading && <Spinner />}</p> — signal fn is always truthy
  *
- * Good: <span>{count()}</span>
- * Good: <p>{isLoading() && <Spinner />}</p>
+ * Explicit: <span>{count()}</span>
+ * Good:     <p>{isLoading() && <Spinner />}</p>
  */
 
 import { createSignalTracker, SIGNAL_METHODS } from '../utils/signal-tracking.js';
@@ -26,11 +28,11 @@ export default {
     },
     messages: {
       signalNotCalledInJsx:
-        '"{{name}}" is a signal used in JSX without calling it. ' +
-        'Use {{{name}}()} to read the value, or the JSX will render "[Function]".',
+        '"{{name}}" is a signal used in JSX as a bare reference. ' +
+        'Prefer {{{name}}()} for an explicit read — bare signals rely on the compiler auto-wrapping them.',
       signalNotCalledInJsxLogical:
         '"{{name}}" is a signal used in a JSX conditional without calling it. ' +
-        'Signals are always truthy — use {{{name}}() && ...} instead.',
+        'A signal function is always truthy — use {{{name}}() && ...} instead.',
     },
     schema: [],
   },