@sigil-dev/compiler 0.9.2 → 0.9.4

package/README.md

@@ -1,162 +1,162 @@
-# @sigil-dev/compiler
-
-Compile-time JSX transform for Sigil.  
-Turns reactive macros and JSX into direct DOM operations with a tiny runtime overhead.
-
-```bash
-bun add -d @sigil-dev/compiler
-```
-
-## What it does
-
-The compiler runs at build time and does two things:
-
-**1. Transforms reactive macros into signal primitives**  
-This helps you avoid footguns ~~which should hardly be possible, we're not react~~
-
-```typescript
-// you write:
-let count = $state(0);
-let doubled = $derived(count * 2);
-
-$effect(() => {
-  console.log(doubled);
-});
-
-// compiler outputs:
-const count = createSignal(0);
-const doubled = createMemo(() => count() * 2);
-
-createEffect(() => {
-  console.log(doubled());
-});
-```
-
-**2. Transforms JSX into imperative DOM**
-
-```tsx
-// you write:
-const el = <div class="box">{count}</div>;
-
-// compiler outputs (dom mode):
-const el = document.createElement("div");
-el.className = "box";
-const t = document.createTextNode("");
-createEffect(() => { t.data = String(count()); });
-el.appendChild(t);
-```
-There's no virtual DOM involved, and none of the nonsense involved with it. Output is either a string or DOM manipulation. You won't fight with the runtime over what actually changed and what didn't
-
-## Modes
-
-Three output modes for the full SSR lifecycle:
- 
-| Mode | Use | Output |
-|------|-----|--------|
-| `dom` | Client SPA navigation | Imperative DOM calls |
-| `ssr` | Server render | HTML string concatenation |
-| `hydrate` | Initial client load | Claims existing SSR nodes |
-
-The same source file compiles to different output depending on mode. In `ssr` mode, `$effect` is dropped entirely (effects don't make sense on the server). In `hydrate` mode, `claim()` calls replace `createElement` to reuse server-rendered nodes.
-
-## Macros
-
-### `$state`
-
-Declares a reactive variable. Primitive values use subscription sets. Objects and arrays use Proxy for deep reactivity.
-
-```typescript
-let count = $state(0);
-count++;           // compiled to count.set(count.peek() + 1)
-count = 10;        // compiled to count.set(10)
-
-let user = $state({ name: "Rei" });
-user.name = "Asuka"; // proxy handles this — no rewrite needed
-```
-
-### `$derived`
-
-A memoized value derived from other reactive state. Cached until dependencies change.
-
-```typescript
-let doubled = $derived(count * 2);
-// compiled to: const doubled = createMemo(() => count() * 2)
-// which is another tiny shim over createEffect()
-```
-
-### `$effect`
-
-Runs a side effect that re-runs when its reactive dependencies change.
-
-```typescript
-$effect(() => {
-  document.title = `Count: ${count}`;
-});
-// compiled to: createEffect(() => { document.title = `Count: ${count()}`; })
-```
-
-## Keyed lists
-
-`.map()` with a `key` prop compiles to a reconciled list that surgically updates only changed items:
-
-```tsx
-const items = $state([{ id: 1, name: "Rei" }, { id: 2, name: "Asuka" }]);
-
-<ul>
-  {items.map(item => (
-    <li key={item.id}>{item.name}</li>
-  ))}
-</ul>
-```
-
-Compiled to `reconcile()` — moves, inserts, and removes DOM nodes by key without recreating unchanged elements.
-
-## Scoped CSS
-
-CSS defined in a component file is automatically scoped with a deterministic hash:
-
-```tsx
-// styles in your component file get a unique hash prefix
-// .box → .box.s-a3f9b2c1
-// :global(.reset) escapes scoping
-```
-
-## Setup
-
-### Vite
-
-```typescript
-// vite.config.ts
-import { sigil } from "@sigil-dev/compiler/vite";
-
-export default {
-  plugins: [sigil()]
-};
-```
-
-### Bun (reccommended)
-
-```typescript
-// build script
-import { sigil } from "@sigil-dev/compiler/bun";
-
-await Bun.build({
-  entrypoints: ["src/index.tsx"],
-  plugins: [sigil({ mode: "dom" })],
-});
-```
-
-### Babel
-
-```typescript
-// babel.config.ts
-import { sigilBabelPlugin } from "@sigil-dev/compiler/babel";
-
-export default {
-  plugins: [sigilBabelPlugin({ mode: "dom" })]
-};
-```
-
-## Used by
-
-`@sigil-dev/grimoire` uses this compiler internally to process route files in three passes (ssr, hydrate, dom) during the build step. You can use it standalone for SPA projects via Vite, or wire it into any Babel-compatible build pipeline.
+# @sigil-dev/compiler
+
+Compile-time JSX transform for Sigil.  
+Turns reactive macros and JSX into direct DOM operations with a tiny runtime overhead.
+
+```bash
+bun add -d @sigil-dev/compiler
+```
+
+## What it does
+
+The compiler runs at build time and does two things:
+
+**1. Transforms reactive macros into signal primitives**  
+This helps you avoid footguns ~~which should hardly be possible, we're not react~~
+
+```typescript
+// you write:
+let count = $state(0);
+let doubled = $derived(count * 2);
+
+$effect(() => {
+  console.log(doubled);
+});
+
+// compiler outputs:
+const count = createSignal(0);
+const doubled = createMemo(() => count() * 2);
+
+createEffect(() => {
+  console.log(doubled());
+});
+```
+
+**2. Transforms JSX into imperative DOM**
+
+```tsx
+// you write:
+const el = <div class="box">{count}</div>;
+
+// compiler outputs (dom mode):
+const el = document.createElement("div");
+el.className = "box";
+const t = document.createTextNode("");
+createEffect(() => { t.data = String(count()); });
+el.appendChild(t);
+```
+There's no virtual DOM involved, and none of the nonsense involved with it. Output is either a string or DOM manipulation. You won't fight with the runtime over what actually changed and what didn't
+
+## Modes
+
+Three output modes for the full SSR lifecycle:
+ 
+| Mode | Use | Output |
+|------|-----|--------|
+| `dom` | Client SPA navigation | Imperative DOM calls |
+| `ssr` | Server render | HTML string concatenation |
+| `hydrate` | Initial client load | Claims existing SSR nodes |
+
+The same source file compiles to different output depending on mode. In `ssr` mode, `$effect` is dropped entirely (effects don't make sense on the server). In `hydrate` mode, `claim()` calls replace `createElement` to reuse server-rendered nodes.
+
+## Macros
+
+### `$state`
+
+Declares a reactive variable. Primitive values use subscription sets. Objects and arrays use Proxy for deep reactivity.
+
+```typescript
+let count = $state(0);
+count++;           // compiled to count.set(count.peek() + 1)
+count = 10;        // compiled to count.set(10)
+
+let user = $state({ name: "Rei" });
+user.name = "Asuka"; // proxy handles this — no rewrite needed
+```
+
+### `$derived`
+
+A memoized value derived from other reactive state. Cached until dependencies change.
+
+```typescript
+let doubled = $derived(count * 2);
+// compiled to: const doubled = createMemo(() => count() * 2)
+// which is another tiny shim over createEffect()
+```
+
+### `$effect`
+
+Runs a side effect that re-runs when its reactive dependencies change.
+
+```typescript
+$effect(() => {
+  document.title = `Count: ${count}`;
+});
+// compiled to: createEffect(() => { document.title = `Count: ${count()}`; })
+```
+
+## Keyed lists
+
+`.map()` with a `key` prop compiles to a reconciled list that surgically updates only changed items:
+
+```tsx
+const items = $state([{ id: 1, name: "Rei" }, { id: 2, name: "Asuka" }]);
+
+<ul>
+  {items.map(item => (
+    <li key={item.id}>{item.name}</li>
+  ))}
+</ul>
+```
+
+Compiled to `reconcile()` — moves, inserts, and removes DOM nodes by key without recreating unchanged elements.
+
+## Scoped CSS
+
+CSS defined in a component file is automatically scoped with a deterministic hash:
+
+```tsx
+// styles in your component file get a unique hash prefix
+// .box → .box.s-a3f9b2c1
+// :global(.reset) escapes scoping
+```
+
+## Setup
+
+### Vite
+
+```typescript
+// vite.config.ts
+import { sigil } from "@sigil-dev/compiler/vite";
+
+export default {
+  plugins: [sigil()]
+};
+```
+
+### Bun (reccommended)
+
+```typescript
+// build script
+import { sigil } from "@sigil-dev/compiler/bun";
+
+await Bun.build({
+  entrypoints: ["src/index.tsx"],
+  plugins: [sigil({ mode: "dom" })],
+});
+```
+
+### Babel
+
+```typescript
+// babel.config.ts
+import { sigilBabelPlugin } from "@sigil-dev/compiler/babel";
+
+export default {
+  plugins: [sigilBabelPlugin({ mode: "dom" })]
+};
+```
+
+## Used by
+
+`@sigil-dev/grimoire` uses this compiler internally to process route files in three passes (ssr, hydrate, dom) during the build step. You can use it standalone for SPA projects via Vite, or wire it into any Babel-compatible build pipeline.

package/index.ts

@@ -1,4 +1,4 @@
-// packages/compiler/index.ts
-
-export { default as sigilPlugin } from "./src/babel/index.ts";
-export { sigil } from "./src/vite/index.ts";
+// packages/compiler/index.ts
+
+export { default as sigilPlugin } from "./src/babel/index.ts";
+export { sigil } from "./src/vite/index.ts";

package/jsr.json

@@ -1,8 +1,8 @@
-{
-	"name": "@sigil-dev/compiler",
-	"version": "0.6.0",
-	"exports": "./index.ts",
-	"publish": {
-		"exclude": ["src/**/*.test.ts"]
-	}
-}
+{
+	"name": "@sigil-dev/compiler",
+	"version": "0.6.0",
+	"exports": "./index.ts",
+	"publish": {
+		"exclude": ["src/**/*.test.ts"]
+	}
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@sigil-dev/compiler",
   "module": "index.ts",
   "type": "module",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "private": false,
   "description": "Compiler for the Sigil framework",
   "peerDependencies": {
@@ -15,16 +15,16 @@
     "./bun": "./src/bun-plugin.ts"
   },
   "devDependencies": {
-    "@babel/core": "next",
-    "@babel/plugin-syntax-jsx": "next",
-    "@babel/plugin-syntax-typescript": "next",
-    "@babel/traverse": "next",
-    "@babel/types": "next"
+    "@babel/core": "8.0.0-rc.6",
+    "@babel/plugin-syntax-jsx": "8.0.0-rc.6",
+    "@babel/plugin-syntax-typescript": "8.0.0-rc.6",
+    "@babel/traverse": "8.0.0-rc.6",
+    "@babel/types": "8.0.0-rc.6"
   },
   "dependencies": {
     "@babel/generator": "^7.29.7",
     "@babel/parser": "^7.29.7",
-    "@babel/plugin-transform-typescript": "^8.0.0-rc.6",
-    "@babel/preset-typescript": "^8.0.0-rc.6"
+    "@babel/plugin-transform-typescript": "8.0.0-rc.6",
+    "@babel/preset-typescript": "8.0.0-rc.6"
   }
 }

package/src/babel/handlers/dom/derived.ts

@@ -1,62 +1,62 @@
-import type { NodePath } from "@babel/core";
-import { types as t } from "@babel/core";
-import { MAGIC } from "../../util/magic.ts";
-
-const setCall = (name: string, value: t.Expression) =>
-	t.callExpression(
-		t.memberExpression(t.identifier(name), t.identifier("set")),
-		[value],
-	);
-
-export function handleDerived(
-	declaration: NodePath<t.VariableDeclaration>,
-	declarator: NodePath<t.VariableDeclarator>,
-	init: NodePath<t.CallExpression>,
-	signals: Set<string>,
-): void {
-	const { id } = declarator.node;
-	if (!t.isIdentifier(id))
-		throw new Error("Destructured $derived not supported");
-	const name = id.name;
-	signals.add(id.name);
-
-	const binding = declaration.scope.getBinding(name);
-	if (!binding) return;
-	const refs = [...binding.referencePaths];
-	const violations = [...binding.constantViolations];
-
-	init.replaceWith(
-		t.callExpression(t.identifier(MAGIC.createMemo), [
-			t.arrowFunctionExpression([], init.node.arguments[0] as t.Expression),
-		]),
-	);
-	declaration.node.kind = "let";
-
-	// A6: $derived reassign — convert assignments to .set() calls
-	for (const violation of violations) {
-		if (violation.isAssignmentExpression()) {
-			const { operator, right } = violation.node;
-			if (operator === "=") {
-				violation.replaceWith(setCall(name, right));
-			} else {
-				const baseOp = operator.slice(0, -1);
-				violation.replaceWith(
-					setCall(
-						name,
-						t.binaryExpression(
-							baseOp as t.BinaryExpression["operator"],
-							t.callExpression(t.identifier(name), []),
-							right,
-						),
-					),
-				);
-			}
-		}
-	}
-
-	for (const ref of refs) {
-		if (!ref.isIdentifier()) continue;
-		if (ref.parentPath?.isUpdateExpression()) continue;
-		ref.replaceWith(t.callExpression(ref.node, []));
-	}
-}
+import type { NodePath } from "@babel/core";
+import { types as t } from "@babel/core";
+import { MAGIC } from "../../util/magic.ts";
+
+const setCall = (name: string, value: t.Expression) =>
+	t.callExpression(
+		t.memberExpression(t.identifier(name), t.identifier("set")),
+		[value],
+	);
+
+export function handleDerived(
+	declaration: NodePath<t.VariableDeclaration>,
+	declarator: NodePath<t.VariableDeclarator>,
+	init: NodePath<t.CallExpression>,
+	signals: Set<string>,
+): void {
+	const { id } = declarator.node;
+	if (!t.isIdentifier(id))
+		throw new Error("Destructured $derived not supported");
+	const name = id.name;
+	signals.add(id.name);
+
+	const binding = declaration.scope.getBinding(name);
+	if (!binding) return;
+	const refs = [...binding.referencePaths];
+	const violations = [...binding.constantViolations];
+
+	init.replaceWith(
+		t.callExpression(t.identifier(MAGIC.createMemo), [
+			t.arrowFunctionExpression([], init.node.arguments[0] as t.Expression),
+		]),
+	);
+	declaration.node.kind = "let";
+
+	// A6: $derived reassign — convert assignments to .set() calls
+	for (const violation of violations) {
+		if (violation.isAssignmentExpression()) {
+			const { operator, right } = violation.node;
+			if (operator === "=") {
+				violation.replaceWith(setCall(name, right));
+			} else {
+				const baseOp = operator.slice(0, -1);
+				violation.replaceWith(
+					setCall(
+						name,
+						t.binaryExpression(
+							baseOp as t.BinaryExpression["operator"],
+							t.callExpression(t.identifier(name), []),
+							right,
+						),
+					),
+				);
+			}
+		}
+	}
+
+	for (const ref of refs) {
+		if (!ref.isIdentifier()) continue;
+		if (ref.parentPath?.isUpdateExpression()) continue;
+		ref.replaceWith(t.callExpression(ref.node, []));
+	}
+}

package/src/babel/handlers/dom/effect.ts

@@ -1,15 +1,15 @@
-import type { NodePath, types as t } from "@babel/core";
-import { MAGIC } from "../../util/magic.ts";
-
-export function handleEffect(statement: NodePath<t.ExpressionStatement>): void {
-	const expr = statement.get("expression");
-	if (!expr.isCallExpression()) return;
-	const callee = expr.get("callee");
-	if (!callee.isIdentifier()) return;
-	if (callee.node.name === "$effect") callee.node.name = MAGIC.createEffect;
-	else if (callee.node.name === "$derived") {
-		throw statement.buildCodeFrameError(
-			"$derived must be assigned to a variable: let doubled = $derived(count*2)",
-		);
-	}
-}
+import type { NodePath, types as t } from "@babel/core";
+import { MAGIC } from "../../util/magic.ts";
+
+export function handleEffect(statement: NodePath<t.ExpressionStatement>): void {
+	const expr = statement.get("expression");
+	if (!expr.isCallExpression()) return;
+	const callee = expr.get("callee");
+	if (!callee.isIdentifier()) return;
+	if (callee.node.name === "$effect") callee.node.name = MAGIC.createEffect;
+	else if (callee.node.name === "$derived") {
+		throw statement.buildCodeFrameError(
+			"$derived must be assigned to a variable: let doubled = $derived(count*2)",
+		);
+	}
+}