@gjsify/rolldown-plugin-solid 0.42.0

package/README.md

@@ -0,0 +1,72 @@
+# @gjsify/rolldown-plugin-solid
+
+A Rolldown (and Rollup/Vite-compatible) plugin that compiles **SolidJS JSX** during gjsify builds, in `universal` generate mode — the only mode whose output contains no DOM.
+
+Part of the [gjsify](https://github.com/gjsify/gjsify) project — Node.js and Web APIs for GJS (GNOME JavaScript).
+
+## Why a Babel plugin in an oxc toolchain
+
+Solid's JSX is a *compiler*, not a runtime: `babel-plugin-jsx-dom-expressions` turns markup into straight-line calls against a renderer, and no oxc/SWC port of it exists. Rolldown's own transformer cannot stand in — pointed at a `.tsx` with no JSX configuration it defaults to the automatic React runtime and emits `import { jsx } from "react/jsx-runtime"`, which resolves to nothing under GJS.
+
+Babel is loaded on the first matching module, so a build with no JSX in it never pays for it.
+
+## Installation
+
+```bash
+gjsify install @gjsify/rolldown-plugin-solid
+```
+
+## Usage
+
+Wire it through `package.json#gjsify`, no JS-form config file needed:
+
+```json
+{
+    "gjsify": {
+        "bundler": {
+            "plugins": [{ "name": "@gjsify/rolldown-plugin-solid" }]
+        }
+    }
+}
+```
+
+Or directly in a Rolldown / Vite config:
+
+```typescript
+import { solidPlugin } from '@gjsify/rolldown-plugin-solid';
+
+export default {
+    plugins: [solidPlugin({ moduleName: '@gjsify/gtk-host/solid' })],
+};
+```
+
+### Options
+
+| Option | Default | Meaning |
+| --- | --- | --- |
+| `moduleName` | `@gjsify/gtk-host/solid` | Module the compiler imports the renderer ops from. |
+| `generate` | `universal` | `babel-preset-solid` mode. `dom` emits `document.createElement`, which does not exist on GJS. |
+| `include` | `/\.(m\|c)?[jt]sx$/` | Which modules to compile. A `.ts` file cannot contain JSX. |
+
+The target module must re-export **every** member of Solid's `Renderer<NodeType>` under its contract name — `createElement`, `createTextNode`, `insertNode`, `insert`, `spread`, `setProp`, `mergeProps`, `effect`, `memo`, `createComponent`, `render`, `use`. The compiler emits those names literally, so a renderer that exports eleven of the twelve builds fine and fails with `MISSING_EXPORT` on the twelfth — only for the JSX that happens to need it.
+
+## TypeScript
+
+The type side is configured separately, and both halves are required:
+
+```json
+{
+    "compilerOptions": {
+        "jsx": "preserve",
+        "jsxImportSource": "@gjsify/gtk-host",
+        "noImplicitAny": true,
+        "strictFunctionTypes": true
+    }
+}
+```
+
+`jsx: "preserve"` is what this plugin needs (`"react"` is refused outright with `jsxImportSource`). Without `noImplicitAny` every JSX element is implicitly `any` and `tsc` exits 0 having checked nothing.
+
+## License
+
+MIT

package/lib/index.d.ts

@@ -0,0 +1,30 @@
+import type { Plugin } from 'rolldown';
+/** `babel-preset-solid`'s `generate` modes. Only `universal` can run on GJS. */
+export type SolidGenerateMode = 'dom' | 'ssr' | 'universal';
+export interface SolidPluginOptions {
+    /**
+     * Module the compiler imports the renderer ops from.
+     *
+     * Defaults to gjsify's GTK renderer. Any module works as long as it exports
+     * every member of Solid's `Renderer<NodeType>` under its contract name.
+     */
+    moduleName?: string;
+    /** Defaults to `universal`, the only mode with no DOM in its output. */
+    generate?: SolidGenerateMode;
+    /**
+     * Which modules to compile. Defaults to `.jsx` / `.tsx` (also `.mtsx`,
+     * `.ctsx`). A `.ts` file cannot contain JSX, so widening this is a mistake.
+     */
+    include?: RegExp;
+}
+/**
+ * Compile Solid JSX to renderer calls.
+ *
+ * Wire it through `package.json#gjsify` so no JS-form config file is needed:
+ *
+ * ```json
+ * "gjsify": { "bundler": { "plugins": [{ "name": "@gjsify/rolldown-plugin-solid" }] } }
+ * ```
+ */
+export declare function solidPlugin(options?: SolidPluginOptions): Plugin;
+export default solidPlugin;

package/lib/index.js

@@ -0,0 +1,145 @@
+// SolidJS JSX for Rolldown — the compile step a GTK/GJS Solid app needs.
+//
+// WHY BABEL AT ALL, in a repo that transforms everything else with oxc: Solid's
+// JSX is not a runtime, it is a compiler. `babel-plugin-jsx-dom-expressions`
+// turns `<gtk-box>…</gtk-box>` into straight-line calls against a renderer, and
+// no oxc/SWC port of it exists. Rolldown's own transformer therefore CANNOT do
+// this job — pointed at a `.tsx` with no JSX configuration it defaults to the
+// automatic React runtime and emits `import { jsx } from "react/jsx-runtime"`,
+// which resolves to nothing under GJS.
+//
+// WHY `generate: "universal"`: the default `"dom"` mode emits
+// `document.createElement` plus `template()`/`cloneNode` cloning. There is no DOM
+// under GJS, so that output cannot run at all. `"universal"` emits imports of the
+// renderer ops from `moduleName` instead — measured on
+// `gtk-host/type-tests/jsx/positive.tsx`, five of them:
+//
+//   import { createElement as _$createElement } from "@gjsify/gtk-host/solid";
+//   import { insertNode   as _$insertNode   } from "@gjsify/gtk-host/solid";
+//   import { setProp      as _$setProp      } from "@gjsify/gtk-host/solid";
+//   import { insert       as _$insert       } from "@gjsify/gtk-host/solid";
+//   import { use          as _$use          } from "@gjsify/gtk-host/solid";
+//
+// The names are LITERAL — they are the member names of Solid's
+// `Renderer<NodeType>`, and the target module must re-export all of them under
+// exactly those names. A renderer that exports eleven of the twelve builds fine
+// and fails with MISSING_EXPORT on the twelfth, only for the JSX that happens to
+// need it (that was `setProp`).
+//
+// Two further shapes the measurement fixed:
+//  - Children are inserted BEFORE properties are set (`insertNode` then
+//    `setProp`), so `createElement` never sees a prop. Construct-only properties
+//    therefore cannot be handled by an adapter; the host has to defer
+//    materialisation (ADR 0027 § Decision 5).
+//  - Handlers arrive through `setProp` under their JSX spelling (`onClicked`),
+//    not through a separate op.
+const DEFAULT_INCLUDE = /\.(m|c)?[jt]sx$/;
+const DEFAULT_MODULE_NAME = '@gjsify/gtk-host/solid';
+/**
+ * The two compiler modules, loaded on first transform rather than at import.
+ *
+ * Same contract as `@gjsify/rolldown-plugin-deepkit`: the heavy compiler stays
+ * uninstantiated for every build that has no JSX in it, and a project that never
+ * writes JSX never pays Babel's load time.
+ *
+ * THE CACHE HOLDS THE MODULES, NOT THE PRESET CHAIN. The chain carries
+ * `moduleName` and `generate`, so caching it made both options inert for every
+ * plugin instance after the first one in a process — and the failure is silent in
+ * the direction that matters: the second bundle imports its renderer ops from the
+ * FIRST bundle's module, which builds green and dies at its first import. Only the
+ * imports are expensive, and they do not depend on the options.
+ */
+let compiler = null;
+function loadCompiler() {
+    compiler ??= (async () => {
+        const babel = await import('@babel/core');
+        // Both presets are CommonJS, so the namespace carries them on `default`.
+        // Their types come from `src/babel-presets.d.ts` — neither ships any.
+        const { default: solid } = await import('babel-preset-solid');
+        const { default: typescript } = await import('@babel/preset-typescript');
+        return { babel, solid, typescript };
+    })();
+    return compiler;
+}
+async function load(moduleName, generate) {
+    const { babel, solid, typescript } = await loadCompiler();
+    // Babel applies presets LAST-TO-FIRST, so `preset-typescript` listed second is
+    // the one that runs first: it strips the annotations and `babel-preset-solid`
+    // then sees plain JSX. That is the order Solid's own tooling ships, and it is
+    // the one to keep — but it is convention here, not a constraint. MEASURED, 14
+    // inputs chosen to break it (as-casts and `satisfies` inside attributes,
+    // `<T,>` and `<T extends unknown>` arrows, explicit type arguments on a
+    // component, parameter properties, `declare`, `namespace`, overloads, a spread
+    // of a cast, a conditional type): both orders emit BYTE-IDENTICAL output, and
+    // neither throws. Babel merges every preset's visitors into one traversal, and
+    // the two never claim the same node — TypeScript syntax is not JSX and JSX is
+    // not TypeScript syntax. Recorded because the reversal is the obvious
+    // "cleanup", and a reader who tries it deserves the measurement rather than a
+    // warning nothing backs.
+    return {
+        babel,
+        presets: [
+            [solid, { generate, moduleName }],
+            [typescript, { isTSX: true, allExtensions: true }],
+        ],
+    };
+}
+/**
+ * Compile Solid JSX to renderer calls.
+ *
+ * Wire it through `package.json#gjsify` so no JS-form config file is needed:
+ *
+ * ```json
+ * "gjsify": { "bundler": { "plugins": [{ "name": "@gjsify/rolldown-plugin-solid" }] } }
+ * ```
+ */
+export function solidPlugin(options = {}) {
+    const moduleName = options.moduleName ?? DEFAULT_MODULE_NAME;
+    const generate = options.generate ?? 'universal';
+    const include = options.include ?? DEFAULT_INCLUDE;
+    return {
+        name: 'gjsify-solid',
+        transform: {
+            // Before every other JS transform: what follows must never see JSX.
+            order: 'pre',
+            async handler(code, id) {
+                // A `\0` prefix is rollup's mark for a module another plugin MINTED,
+                // whose id names no file. Compiling one is claiming someone else's
+                // module, and the id would be reported back in every diagnostic.
+                if (id.startsWith('\0'))
+                    return null;
+                // Match on the PATH, not on the id. Vite appends `?used`, `?import`
+                // and `?t=<timestamp>` on the HMR path, and an anchored `\.tsx$`
+                // silently declines every one of them — the plugin becomes a no-op
+                // and raw JSX reaches the next transform, which is the failure this
+                // package exists to prevent. This package advertises Vite support.
+                if (!include.test(id.split('?')[0]))
+                    return null;
+                const { babel, presets } = await load(moduleName, generate);
+                const result = await babel.transformAsync(code, {
+                    // The consumer's own Babel config must not reach this: the
+                    // preset chain above is the contract, and a stray `.babelrc`
+                    // in a monorepo root would silently change the output.
+                    babelrc: false,
+                    configFile: false,
+                    filename: id,
+                    sourceFileName: id,
+                    sourceMaps: true,
+                    presets,
+                });
+                const transformed = result?.code;
+                if (typeof transformed !== 'string') {
+                    // Babel returning no code for a file that matched the filter is
+                    // not a "nothing to do" — it is a silent drop, and returning
+                    // null here would ship the untransformed JSX onwards.
+                    throw new Error(`@gjsify/rolldown-plugin-solid: Babel produced no output for ${id}. ` +
+                        `The file matched ${String(include)} and was expected to contain Solid JSX.`);
+                }
+                // The map is REAL and handed on: Babel rewrites every line here, so
+                // dropping it points every later frame at the compiled output.
+                return { code: transformed, map: result?.map ?? null };
+            },
+        },
+    };
+}
+export default solidPlugin;

package/package.json

@@ -0,0 +1,71 @@
+{
+    "name": "@gjsify/rolldown-plugin-solid",
+    "version": "0.42.0",
+    "description": "SolidJS JSX compiler plugin for Rolldown / Rollup / Vite — universal generate, targeting a gjsify renderer",
+    "type": "module",
+    "main": "lib/index.js",
+    "module": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./lib/index.d.ts",
+            "default": "./lib/index.js"
+        }
+    },
+    "files": [
+        "lib"
+    ],
+    "scripts": {
+        "clear": "gjsify clear lib test.node.mjs test.gjs.mjs tsconfig.tsbuildinfo",
+        "check": "gjsify tsc --noEmit",
+        "build": "gjsify tsc -p tsconfig.build.json",
+        "build:test": "gjsify run build:test:node && gjsify run build:test:gjs",
+        "build:test:node": "gjsify build src/test.mts --app node --outfile test.node.mjs",
+        "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs",
+        "test": "gjsify run build:test && gjsify run test:node && gjsify run test:gjs",
+        "test:node": "node test.node.mjs",
+        "test:gjs": "gjsify run test.gjs.mjs"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/gjsify/gjsify.git"
+    },
+    "bugs": {
+        "url": "https://github.com/gjsify/gjsify/issues"
+    },
+    "homepage": "https://github.com/gjsify/gjsify/tree/main/packages/infra/rolldown-plugin-solid#readme",
+    "keywords": [
+        "rolldown",
+        "rollup",
+        "vite",
+        "solid",
+        "solid-js",
+        "jsx",
+        "gtk",
+        "gjs"
+    ],
+    "license": "MIT",
+    "dependencies": {
+        "@babel/core": "^7.28.4",
+        "@babel/preset-typescript": "^7.27.1",
+        "babel-preset-solid": "^1.9.9"
+    },
+    "peerDependencies": {
+        "rolldown": "^1.1.4"
+    },
+    "peerDependenciesMeta": {
+        "rolldown": {
+            "optional": true
+        }
+    },
+    "devDependencies": {
+        "@gjsify/cli": "^0.42.0",
+        "@gjsify/unit": "^0.42.0",
+        "@types/babel__core": "^7.20.5",
+        "@types/node": "^25.9.2",
+        "rolldown": "^1.1.4"
+    },
+    "gjsify": {
+        "tier": 1
+    }
+}