biome-plugin-solidjs 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tommy Morgan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,63 @@
+# biome-plugin-solidjs
+
+Biome [GritQL](https://biomejs.dev/linter/plugins/) lint rules for [SolidJS](https://www.solidjs.com/). Catches common reactivity bugs at lint time.
+
+## Rules
+
+| Rule | Description |
+|------|-------------|
+| `solid-no-destructured-props` | Flags destructured props in component signatures. Props are reactive getter objects — destructuring severs reactivity. |
+| `solid-no-array-map-in-jsx` | Flags `.map()` inside JSX expressions. In Solid, `.map()` runs once and produces static DOM. Use `<For>` or `<Index>`. |
+| `solid-no-memo-in-loop` | Flags `createMemo()` inside `.map()`, `.forEach()`, and other array method callbacks. |
+| `solid-no-toplevel-effect` | Flags `createEffect()` and `createMemo()` at module scope, where they have no reactive owner and will leak. |
+| `solid-no-stored-jsx` | Flags JSX stored in module-scope variables. Solid JSX compiles to real DOM operations, not virtual DOM descriptors. |
+
+## Install
+
+```bash
+npm install -D biome-plugin-solidjs
+```
+
+## Setup
+
+Add the rules you want to your `biome.json` or `biome.jsonc`:
+
+```jsonc
+{
+  "plugins": [
+    "./node_modules/biome-plugin-solidjs/rules/solid-no-destructured-props.grit",
+    "./node_modules/biome-plugin-solidjs/rules/solid-no-array-map-in-jsx.grit",
+    "./node_modules/biome-plugin-solidjs/rules/solid-no-memo-in-loop.grit",
+    "./node_modules/biome-plugin-solidjs/rules/solid-no-toplevel-effect.grit",
+    "./node_modules/biome-plugin-solidjs/rules/solid-no-stored-jsx.grit"
+  ]
+}
+```
+
+Pick only the rules relevant to your project — you don't have to use all of them.
+
+## Requirements
+
+- [Biome](https://biomejs.dev/) >= 2.0.0 (GritQL plugin support)
+
+## How it works
+
+Each rule is a `.grit` file using Biome's GritQL engine (`engine biome(1.0)`) to match AST patterns. The rules use structural heuristics rather than type information:
+
+- **Component detection**: Functions returning JSX are treated as components (for the destructured props rule).
+- **Scope detection**: `! $node <: within JsArrowFunctionExpression()` patterns distinguish module-level code from code inside functions.
+- **No type inference**: These rules can't catch bugs that require knowing TypeScript types (e.g., uncalled signals, direct store mutation). For those, consider [eslint-plugin-solid](https://github.com/solidjs-community/eslint-plugin-solid).
+
+## What these rules don't cover
+
+Some SolidJS pitfalls require TypeScript type information that GritQL doesn't have access to:
+
+- Signals referenced without `()` (needs to know what's a signal)
+- Direct store mutation (needs to know what's a store proxy)
+- Store prop destructuring from custom hooks (needs return type info)
+
+For full type-aware linting, use these rules alongside `eslint-plugin-solid`.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,32 @@
+{
+	"name": "biome-plugin-solidjs",
+	"version": "0.1.0",
+	"description": "Biome GritQL lint rules for SolidJS — catches common reactivity bugs at lint time",
+	"license": "MIT",
+	"author": "Tommy Morgan",
+	"type": "module",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/tommymorgan/biome-plugin-solidjs"
+	},
+	"keywords": [
+		"biome",
+		"gritql",
+		"solidjs",
+		"solid-js",
+		"lint",
+		"plugin",
+		"reactivity"
+	],
+	"files": [
+		"rules/*.grit",
+		"README.md",
+		"LICENSE"
+	],
+	"scripts": {
+		"test": "node --test test.js"
+	},
+	"peerDependencies": {
+		"@biomejs/biome": ">=2.0.0"
+	}
+}

package/rules/solid-no-array-map-in-jsx.grit

@@ -0,0 +1,20 @@
+engine biome(1.0)
+language js(typescript, jsx)
+
+// SolidJS: Never use Array.map() in JSX for reactive lists.
+// .map() runs once at component initialization and produces static DOM nodes.
+// Use <For> for arrays where order/length changes, or <Index> for stable-length lists.
+
+JsxExpressionChild() as $expr where {
+	$expr <: contains JsCallExpression() as $call where {
+		$call <: contains JsStaticMemberExpression() as $member where {
+			$member <: contains JsName() as $method where {
+				$method <: `map`
+			}
+		}
+	},
+	register_diagnostic(
+		span = $call,
+		message = "SolidJS: Do not use .map() in JSX. It runs once and produces static DOM nodes. Use <For> or <Index> for reactive lists."
+	)
+}

package/rules/solid-no-destructured-props.grit

@@ -0,0 +1,31 @@
+engine biome(1.0)
+language js(typescript, jsx)
+
+// SolidJS: Never destructure props in component signatures.
+// Props are reactive getter objects — destructuring severs reactivity.
+// Use `props.value` or `splitProps(props, [...])` instead.
+//
+// Detects functions that return JSX and have destructured parameters.
+// This heuristic identifies components without relying on naming conventions.
+
+or {
+	// Arrow function component: const Comp = ({ value }) => <div>...</div>
+	JsArrowFunctionExpression() as $arrow where {
+		$arrow <: contains JsObjectBindingPattern() as $pattern,
+		$arrow <: contains JsxOpeningElement(),
+		register_diagnostic(
+			span = $pattern,
+			message = "SolidJS: Do not destructure props. Props are reactive getter objects — destructuring breaks reactivity. Use `props` parameter and access `props.value`, or use `splitProps()`."
+		)
+	},
+
+	// Function declaration component: function Comp({ value }) { return <div>...</div> }
+	JsFunctionDeclaration() as $func where {
+		$func <: contains JsObjectBindingPattern() as $pattern,
+		$func <: contains JsxOpeningElement(),
+		register_diagnostic(
+			span = $pattern,
+			message = "SolidJS: Do not destructure props. Props are reactive getter objects — destructuring breaks reactivity. Use `props` parameter and access `props.value`, or use `splitProps()`."
+		)
+	}
+}

package/rules/solid-no-memo-in-loop.grit

@@ -0,0 +1,25 @@
+engine biome(1.0)
+language js(typescript, jsx)
+
+// SolidJS: Don't create reactive primitives inside loop callbacks.
+// createMemo inside .map()/.forEach()/.filter() creates a new memo on every
+// iteration, which is wasteful and likely a bug.
+
+JsCallExpression() as $outerCall where {
+	$outerCall <: contains JsStaticMemberExpression() as $member where {
+		$member <: contains JsName() as $method where {
+			$method <: or { `map`, `forEach`, `filter`, `reduce`, `flatMap` }
+		}
+	},
+	$outerCall <: contains JsArrowFunctionExpression() as $callback where {
+		$callback <: contains JsCallExpression() as $innerCall where {
+			$innerCall <: contains JsReferenceIdentifier() as $callee where {
+				$callee <: `createMemo`
+			}
+		}
+	},
+	register_diagnostic(
+		span = $innerCall,
+		message = "SolidJS: Do not call createMemo() inside loop callbacks (.map, .forEach, etc.). It creates a new memo on every iteration. Derive data inline or restructure upstream."
+	)
+}

package/rules/solid-no-stored-jsx.grit

@@ -0,0 +1,29 @@
+engine biome(1.0)
+language js(typescript, jsx)
+
+// SolidJS: Do not store JSX in variables at module scope.
+// In Solid, JSX compiles to real DOM operations — not virtual DOM descriptors.
+// Storing JSX creates live DOM nodes immediately, which has side effects.
+
+// Match JSX elements that are NOT inside any function body
+or {
+	JsxElement() as $jsx where {
+		! $jsx <: within JsArrowFunctionExpression(),
+		! $jsx <: within JsFunctionDeclaration(),
+		! $jsx <: within JsFunctionExpression(),
+		register_diagnostic(
+			span = $jsx,
+			message = "SolidJS: Do not store JSX in variables. In Solid, JSX creates live DOM nodes immediately — not virtual DOM descriptors. Return JSX directly from components instead."
+		)
+	},
+
+	JsxSelfClosingElement() as $jsx where {
+		! $jsx <: within JsArrowFunctionExpression(),
+		! $jsx <: within JsFunctionDeclaration(),
+		! $jsx <: within JsFunctionExpression(),
+		register_diagnostic(
+			span = $jsx,
+			message = "SolidJS: Do not store JSX in variables. In Solid, JSX creates live DOM nodes immediately — not virtual DOM descriptors. Return JSX directly from components instead."
+		)
+	}
+}

package/rules/solid-no-toplevel-effect.grit

@@ -0,0 +1,19 @@
+engine biome(1.0)
+language js(typescript, jsx)
+
+// SolidJS: Reactive primitives must be created inside a reactive root.
+// createEffect/createMemo at module scope have no owner and will leak.
+// Place them inside a component or wrap with createRoot().
+
+// Match createEffect/createRenderEffect/createMemo reference identifiers
+// that are NOT inside any function body.
+JsReferenceIdentifier() as $callee where {
+	$callee <: or { `createEffect`, `createRenderEffect`, `createMemo` },
+	! $callee <: within JsArrowFunctionExpression(),
+	! $callee <: within JsFunctionDeclaration(),
+	! $callee <: within JsFunctionExpression(),
+	register_diagnostic(
+		span = $callee,
+		message = "SolidJS: Reactive primitive at module scope has no owner and will leak. Place it inside a component or wrap with createRoot()."
+	)
+}