eslint-plugin-what 0.12.3 → 0.13.0

package/index.d.ts

@@ -0,0 +1,90 @@
+// eslint-plugin-what — TypeScript definitions.
+//
+// Declared by hand and held to the runtime by `npm run hygiene:types`. The
+// plugin is a default export, so the parity checker sees one name; the shapes
+// below are what a flat config actually consumes.
+//
+// ESLint's own types are not imported: `eslint` is a peer dependency, and
+// pulling @types/eslint in here would make a type-only package a hard
+// requirement for anyone who just wants to spread a preset into their config.
+
+/** One rule module. Structural, so a stock ESLint `Rule.RuleModule` assigns to it. */
+export interface WhatRuleModule {
+  meta: {
+    type?: 'problem' | 'suggestion' | 'layout';
+    docs?: { description?: string; recommended?: boolean; url?: string };
+    fixable?: 'code' | 'whitespace';
+    schema?: unknown[];
+    messages?: Record<string, string>;
+    [key: string]: unknown;
+  };
+  create(context: unknown): Record<string, (...args: never[]) => void>;
+}
+
+/** The rules this plugin ships, keyed exactly as they are referenced in config. */
+export interface WhatRules {
+  /** Signals are read by calling them; listing one in a deps array compares functions, not values. */
+  'no-signal-in-effect-deps': WhatRuleModule;
+  /** A signal passed as a JSX child renders once unless it stays reactive. */
+  'reactive-jsx-children': WhatRuleModule;
+  /** Writing a signal during render re-enters render. */
+  'no-signal-write-in-render': WhatRuleModule;
+  /** DOM events are lowercase; `onClick` on an intrinsic element never fires. */
+  'no-camelcase-events': WhatRuleModule;
+  /** `set(next)` over read-modify-write, which races concurrent updates. */
+  'prefer-set': WhatRuleModule;
+  /** A signal referenced without calling it yields the function, not its value. */
+  'no-uncalled-signals': WhatRuleModule;
+  /** `h()` is the compiler's output, not an authoring API. */
+  'no-h-in-user-code': WhatRuleModule;
+  /** A signal in JSX must be called to be read. */
+  'signal-call-in-jsx': WhatRuleModule;
+  /** A computed that writes a signal is a side effect pretending to be a value. */
+  'no-set-in-computed': WhatRuleModule;
+}
+
+/**
+ * A complete flat-config entry. Each preset carries its own `files` glob and
+ * JSX-enabled language options, so spreading one into a config array works
+ * against stock ESLint with no extra parser setup for .js/.jsx.
+ */
+export interface WhatFlatConfig {
+  name: string;
+  files: string[];
+  languageOptions: {
+    ecmaVersion: 'latest' | number;
+    sourceType: 'module' | 'script';
+    parserOptions?: { ecmaFeatures?: { jsx?: boolean }; [key: string]: unknown };
+    /**
+     * Only the `compiler` preset sets this, declaring the control-flow tags
+     * the What compiler lowers itself (`For`, `Show`, `Switch`, `Match`).
+     * Under the compiler they need no import; without it they must be
+     * imported, so the other presets leave `no-undef` free to say so.
+     */
+    globals?: Record<string, 'readonly' | 'writable' | 'off'>;
+    [key: string]: unknown;
+  };
+  plugins: Record<string, WhatPlugin>;
+  rules: Record<string, 'off' | 'warn' | 'error'>;
+}
+
+export interface WhatConfigs {
+  /** Everything on as warnings, except no-set-in-computed, which is always an error. */
+  recommended: WhatFlatConfig;
+  /** Everything on as errors, plus prefer-set as a warning. */
+  strict: WhatFlatConfig;
+  /**
+   * For compiler users: the rules the compiler already handles are off, and
+   * the compiler-lowered control-flow tags are declared as globals.
+   */
+  compiler: WhatFlatConfig;
+}
+
+export interface WhatPlugin {
+  meta: { name: string; version: string };
+  rules: WhatRules;
+  configs: WhatConfigs;
+}
+
+declare const plugin: WhatPlugin;
+export default plugin;

package/package.json

@@ -1,14 +1,19 @@
 {
   "name": "eslint-plugin-what",
-  "version": "0.12.3",
+  "version": "0.13.0",
   "description": "ESLint rules for What Framework — catch signal bugs, enforce patterns",
   "type": "module",
   "main": "src/index.js",
+  "types": "index.d.ts",
   "exports": {
-    ".": "./src/index.js"
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./src/index.js"
+    }
   },
   "files": [
-    "src"
+    "src",
+    "index.d.ts"
   ],
   "keywords": [
     "eslint",

package/src/index.js

@@ -65,6 +65,20 @@ const baseLanguageOptions = {
 
 const FILES = ['**/*.{js,jsx,ts,tsx}'];
 
+// Control-flow tags the What compiler lowers itself rather than resolving as
+// components (LOWERED_TAGS in what-compiler's babel plugin). Under the
+// compiler they need no import, so `no-undef` would otherwise report every
+// <For>, <Show>, <Switch> and <Match> in a compiled file as undefined.
+//
+// Only the `compiler` preset declares them. Without the compiler these really
+// must be imported from what-framework, and reporting that is correct.
+const COMPILER_LOWERED_TAGS = {
+  For: 'readonly',
+  Show: 'readonly',
+  Switch: 'readonly',
+  Match: 'readonly',
+};
+
 plugin.configs.recommended = {
   name: 'what/recommended',
   files: FILES,
@@ -106,7 +120,7 @@ plugin.configs.strict = {
 plugin.configs.compiler = {
   name: 'what/compiler',
   files: FILES,
-  languageOptions: baseLanguageOptions,
+  languageOptions: { ...baseLanguageOptions, globals: COMPILER_LOWERED_TAGS },
   plugins: { what: plugin },
   rules: {
     'what/no-signal-in-effect-deps': 'warn',

package/src/rules/no-h-in-user-code.js

@@ -3,7 +3,9 @@
  *
  * Warn when user code imports `h` from what-framework.
  * Users should use JSX syntax instead of calling h() directly.
- * The compiler handles JSX-to-h() transformation automatically.
+ * The compiler lowers JSX to _$template() + _$insert() + _$createComponent(),
+ * not to h(). h() is the uncompiled fallback and the framework's own internal
+ * element constructor.
  *
  * Bad:  import { h } from 'what-framework';
  *       h('div', { class: 'foo' }, 'Hello');