@c9up/aurora 0.1.4 → 0.1.5

package/dist/browser.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Browser DX helpers — navigation + a typed `localStorage` wrapper.
+ *
+ * All are SSR-safe: on the server (no `window` / `localStorage`) navigation is
+ * a no-op and storage reads return `null`, so the same code runs during SSR
+ * without `typeof window` guards at every call site. Node-free — part of the
+ * client barrel.
+ */
+/** Navigate to `url` with a full page load. No-op during SSR. */
+export declare function redirect(url: string): void;
+/**
+ * Navigate to `url`, replacing the current history entry (no back-button trap —
+ * use after a login/logout so "back" doesn't return to the form). No-op on SSR.
+ */
+export declare function replace(url: string): void;
+/** Reload the current page. No-op during SSR. */
+export declare function reload(): void;
+/**
+ * Typed, SSR-safe `localStorage` wrapper. Values are JSON-serialised; reads
+ * return `null` on the server, on a missing key, or on malformed JSON. Writes
+ * swallow quota / private-mode errors so a full storage never crashes the app.
+ */
+export declare const storage: {
+    get<T>(key: string): T | null;
+    set(key: string, value: unknown): void;
+    remove(key: string): void;
+    clear(): void;
+};

package/dist/browser.js

@@ -0,0 +1,69 @@
+/**
+ * Browser DX helpers — navigation + a typed `localStorage` wrapper.
+ *
+ * All are SSR-safe: on the server (no `window` / `localStorage`) navigation is
+ * a no-op and storage reads return `null`, so the same code runs during SSR
+ * without `typeof window` guards at every call site. Node-free — part of the
+ * client barrel.
+ */
+/** Navigate to `url` with a full page load. No-op during SSR. */
+export function redirect(url) {
+    if (typeof window !== "undefined") {
+        window.location.href = url;
+    }
+}
+/**
+ * Navigate to `url`, replacing the current history entry (no back-button trap —
+ * use after a login/logout so "back" doesn't return to the form). No-op on SSR.
+ */
+export function replace(url) {
+    if (typeof window !== "undefined") {
+        window.location.replace(url);
+    }
+}
+/** Reload the current page. No-op during SSR. */
+export function reload() {
+    if (typeof window !== "undefined") {
+        window.location.reload();
+    }
+}
+/**
+ * Typed, SSR-safe `localStorage` wrapper. Values are JSON-serialised; reads
+ * return `null` on the server, on a missing key, or on malformed JSON. Writes
+ * swallow quota / private-mode errors so a full storage never crashes the app.
+ */
+export const storage = {
+    get(key) {
+        if (typeof localStorage === "undefined")
+            return null;
+        const raw = localStorage.getItem(key);
+        if (raw === null)
+            return null;
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    },
+    set(key, value) {
+        if (typeof localStorage === "undefined")
+            return;
+        try {
+            localStorage.setItem(key, JSON.stringify(value));
+        }
+        catch {
+            // QuotaExceededError / Safari private mode — best-effort write.
+        }
+    },
+    remove(key) {
+        if (typeof localStorage !== "undefined") {
+            localStorage.removeItem(key);
+        }
+    },
+    clear() {
+        if (typeof localStorage !== "undefined") {
+            localStorage.clear();
+        }
+    },
+};

package/dist/hydrate.js

@@ -307,11 +307,21 @@ function hydrateTextSlot(commentMarker, value, cleanups, mountHooks, markerCurso
             }
             return;
         }
-        const textNode = commentMarker.nodeType === 3 /* TEXT */
+        let textNode = commentMarker.nodeType === 3 /* TEXT */
             ? commentMarker
             : commentMarker.previousSibling?.nodeType === 3
                 ? commentMarker.previousSibling
                 : null;
+        if (!textNode &&
+            commentMarker.nodeType === 8 /* Comment */ &&
+            commentMarker.parentNode) {
+            // Empty SSR text slot: a `<!---->` placeholder holds the position
+            // (see ssr.ts). Materialize the reactive text node there — node
+            // count stays 1, so sibling slot paths remain aligned.
+            const fresh = (commentMarker.ownerDocument ?? document).createTextNode("");
+            commentMarker.parentNode.replaceChild(fresh, commentMarker);
+            textNode = fresh;
+        }
         if (!textNode)
             return;
         const dispose = effect(() => {

package/dist/index.d.ts

@@ -1,12 +1,9 @@
-export { AuroraManager, type AuroraManagerConfig } from "./AuroraManager.js";
+export { redirect, reload, replace, storage } from "./browser.js";
 export { component, onMount, onUnmount } from "./component.js";
 export { html, isTemplateResult } from "./html.js";
 export { hydrate } from "./hydrate.js";
-export { type PageFactory, Pages, type PagesConfig, } from "./Pages.js";
 export { batch, effect, isSignal, memo, onCleanup, type ReadSignal, type Signal, signal, untrack, } from "./reactive.js";
 export { type Disposer, render } from "./render.js";
 export { type AuroraHttpContext, type AuroraResponse, type AuroraRouteConfig, auroraRoute, } from "./route.js";
-export { type RenderHttpContext, type RenderPageOptions, type RenderResponse, renderPage, } from "./server/renderPage.js";
-export { type AssetsHttpContext, type AssetsRequest, type AssetsResponse, type ServeAssetsOptions, serveAssets, } from "./server/serveAssets.js";
 export { renderToString } from "./ssr.js";
 export type { TemplateResult } from "./types.js";

package/dist/index.js

@@ -1,12 +1,14 @@
-// ─── Inertia-shape server surface ─────────────────────────────────
-export { AuroraManager } from "./AuroraManager.js";
+// ─── Client surface (node-free — safe to bundle for the browser) ──────
+//
+// Server-only exports (AuroraManager, Pages, renderPage, serveAssets) that pull
+// node:fs / node:path / node:url live in `@c9up/aurora/server`. Keeping them off
+// this barrel is what lets a browser bundle import the client primitives without
+// the bundler dragging Node built-ins through the import graph.
+export { redirect, reload, replace, storage } from "./browser.js";
 export { component, onMount, onUnmount } from "./component.js";
 export { html, isTemplateResult } from "./html.js";
 export { hydrate } from "./hydrate.js";
-export { Pages, } from "./Pages.js";
 export { batch, effect, isSignal, memo, onCleanup, signal, untrack, } from "./reactive.js";
 export { render } from "./render.js";
 export { auroraRoute, } from "./route.js";
-export { renderPage, } from "./server/renderPage.js";
-export { serveAssets, } from "./server/serveAssets.js";
 export { renderToString } from "./ssr.js";

package/dist/server.d.ts

@@ -0,0 +1,4 @@
+export { AuroraManager, type AuroraManagerConfig } from "./AuroraManager.js";
+export { type PageFactory, Pages, type PagesConfig } from "./Pages.js";
+export { type RenderHttpContext, type RenderPageOptions, type RenderResponse, renderPage, } from "./server/renderPage.js";
+export { type AssetsHttpContext, type AssetsRequest, type AssetsResponse, type ServeAssetsOptions, serveAssets, } from "./server/serveAssets.js";

package/dist/server.js

@@ -0,0 +1,10 @@
+// ─── Server-only surface (imports node:fs / node:path / node:url) ─────
+//
+// Kept OUT of the package's main barrel (`@c9up/aurora`) so a browser bundle
+// importing client primitives (component/html/hydrate/render) never pulls the
+// Node built-ins through the import graph. Server code imports from
+// `@c9up/aurora/server`; the client `.` entry stays node-free.
+export { AuroraManager } from "./AuroraManager.js";
+export { Pages } from "./Pages.js";
+export { renderPage, } from "./server/renderPage.js";
+export { serveAssets, } from "./server/serveAssets.js";

package/dist/ssr.js

@@ -75,8 +75,18 @@ function stringifyTemplateResult(result) {
                 out += stringifyValue(value, false);
                 out += `<!--${SLOT_END}-->`;
             }
+            else if (inAttr) {
+                out += stringifyValue(value, true);
+            }
             else {
-                out += stringifyValue(value, inAttr);
+                // Text-region scalar slot. An empty result (e.g. `cond ? x : ''`)
+                // would emit NO node and desync the path-based hydration of the
+                // following sibling slots (their @input/@submit bindings break).
+                // Emit an empty-comment placeholder so the position is preserved
+                // — lit-html / Solid do the same; hydration materializes the text
+                // node there.
+                const text = stringifyValue(value, false);
+                out += text === "" ? "<!---->" : text;
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c9up/aurora",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Aurora — reactive UI runtime for the Ream framework. Tagged-template DOM, signal-based state, isomorphic SSR + hydration, zero build step.",
   "license": "MIT",
   "type": "module",
@@ -30,6 +30,10 @@
     "./hydrate": {
       "types": "./dist/hydrate.d.ts",
       "import": "./dist/hydrate.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js"
     }
   },
   "peerDependencies": {

package/src/browser.ts

@@ -0,0 +1,68 @@
+/**
+ * Browser DX helpers — navigation + a typed `localStorage` wrapper.
+ *
+ * All are SSR-safe: on the server (no `window` / `localStorage`) navigation is
+ * a no-op and storage reads return `null`, so the same code runs during SSR
+ * without `typeof window` guards at every call site. Node-free — part of the
+ * client barrel.
+ */
+
+/** Navigate to `url` with a full page load. No-op during SSR. */
+export function redirect(url: string): void {
+	if (typeof window !== "undefined") {
+		window.location.href = url;
+	}
+}
+
+/**
+ * Navigate to `url`, replacing the current history entry (no back-button trap —
+ * use after a login/logout so "back" doesn't return to the form). No-op on SSR.
+ */
+export function replace(url: string): void {
+	if (typeof window !== "undefined") {
+		window.location.replace(url);
+	}
+}
+
+/** Reload the current page. No-op during SSR. */
+export function reload(): void {
+	if (typeof window !== "undefined") {
+		window.location.reload();
+	}
+}
+
+/**
+ * Typed, SSR-safe `localStorage` wrapper. Values are JSON-serialised; reads
+ * return `null` on the server, on a missing key, or on malformed JSON. Writes
+ * swallow quota / private-mode errors so a full storage never crashes the app.
+ */
+export const storage = {
+	get<T>(key: string): T | null {
+		if (typeof localStorage === "undefined") return null;
+		const raw = localStorage.getItem(key);
+		if (raw === null) return null;
+		try {
+			return JSON.parse(raw);
+		} catch {
+			return null;
+		}
+	},
+	set(key: string, value: unknown): void {
+		if (typeof localStorage === "undefined") return;
+		try {
+			localStorage.setItem(key, JSON.stringify(value));
+		} catch {
+			// QuotaExceededError / Safari private mode — best-effort write.
+		}
+	},
+	remove(key: string): void {
+		if (typeof localStorage !== "undefined") {
+			localStorage.removeItem(key);
+		}
+	},
+	clear(): void {
+		if (typeof localStorage !== "undefined") {
+			localStorage.clear();
+		}
+	},
+};

package/src/hydrate.ts

@@ -422,12 +422,26 @@ function hydrateTextSlot(
 			}
 			return;
 		}
-		const textNode =
+		let textNode =
 			commentMarker.nodeType === 3 /* TEXT */
 				? (commentMarker as Text)
 				: commentMarker.previousSibling?.nodeType === 3
 					? (commentMarker.previousSibling as Text)
 					: null;
+		if (
+			!textNode &&
+			commentMarker.nodeType === 8 /* Comment */ &&
+			commentMarker.parentNode
+		) {
+			// Empty SSR text slot: a `<!---->` placeholder holds the position
+			// (see ssr.ts). Materialize the reactive text node there — node
+			// count stays 1, so sibling slot paths remain aligned.
+			const fresh = (commentMarker.ownerDocument ?? document).createTextNode(
+				"",
+			);
+			commentMarker.parentNode.replaceChild(fresh, commentMarker);
+			textNode = fresh;
+		}
 		if (!textNode) return;
 		const dispose = effect(() => {
 			const v = fn();

package/src/index.ts

@@ -1,13 +1,13 @@
-// ─── Inertia-shape server surface ─────────────────────────────────
-export { AuroraManager, type AuroraManagerConfig } from "./AuroraManager.js";
+// ─── Client surface (node-free — safe to bundle for the browser) ──────
+//
+// Server-only exports (AuroraManager, Pages, renderPage, serveAssets) that pull
+// node:fs / node:path / node:url live in `@c9up/aurora/server`. Keeping them off
+// this barrel is what lets a browser bundle import the client primitives without
+// the bundler dragging Node built-ins through the import graph.
+export { redirect, reload, replace, storage } from "./browser.js";
 export { component, onMount, onUnmount } from "./component.js";
 export { html, isTemplateResult } from "./html.js";
 export { hydrate } from "./hydrate.js";
-export {
-	type PageFactory,
-	Pages,
-	type PagesConfig,
-} from "./Pages.js";
 export {
 	batch,
 	effect,
@@ -26,18 +26,5 @@ export {
 	type AuroraRouteConfig,
 	auroraRoute,
 } from "./route.js";
-export {
-	type RenderHttpContext,
-	type RenderPageOptions,
-	type RenderResponse,
-	renderPage,
-} from "./server/renderPage.js";
-export {
-	type AssetsHttpContext,
-	type AssetsRequest,
-	type AssetsResponse,
-	type ServeAssetsOptions,
-	serveAssets,
-} from "./server/serveAssets.js";
 export { renderToString } from "./ssr.js";
 export type { TemplateResult } from "./types.js";

package/src/server.ts

@@ -0,0 +1,22 @@
+// ─── Server-only surface (imports node:fs / node:path / node:url) ─────
+//
+// Kept OUT of the package's main barrel (`@c9up/aurora`) so a browser bundle
+// importing client primitives (component/html/hydrate/render) never pulls the
+// Node built-ins through the import graph. Server code imports from
+// `@c9up/aurora/server`; the client `.` entry stays node-free.
+
+export { AuroraManager, type AuroraManagerConfig } from "./AuroraManager.js";
+export { type PageFactory, Pages, type PagesConfig } from "./Pages.js";
+export {
+	type RenderHttpContext,
+	type RenderPageOptions,
+	type RenderResponse,
+	renderPage,
+} from "./server/renderPage.js";
+export {
+	type AssetsHttpContext,
+	type AssetsRequest,
+	type AssetsResponse,
+	type ServeAssetsOptions,
+	serveAssets,
+} from "./server/serveAssets.js";

package/src/ssr.ts

@@ -78,8 +78,17 @@ function stringifyTemplateResult(result: TemplateResult): string {
 				out += `<!--${SLOT_START}-->`;
 				out += stringifyValue(value, false);
 				out += `<!--${SLOT_END}-->`;
+			} else if (inAttr) {
+				out += stringifyValue(value, true);
 			} else {
-				out += stringifyValue(value, inAttr);
+				// Text-region scalar slot. An empty result (e.g. `cond ? x : ''`)
+				// would emit NO node and desync the path-based hydration of the
+				// following sibling slots (their @input/@submit bindings break).
+				// Emit an empty-comment placeholder so the position is preserved
+				// — lit-html / Solid do the same; hydration materializes the text
+				// node there.
+				const text = stringifyValue(value, false);
+				out += text === "" ? "<!---->" : text;
 			}
 		}
 	}