@alepha/react 0.9.5 → 0.10.1

package/dist/index.js

@@ -1,4 +1,4 @@
-import { $env, $hook, $inject, $module, Alepha, AlephaError, Descriptor, KIND, TypeGuard, createDescriptor, t } from "@alepha/core";
+import { $env, $hook, $inject, $module, Alepha, AlephaError, Descriptor, KIND, createDescriptor, t } from "@alepha/core";
 import { AlephaServer, HttpClient, ServerProvider, ServerRouterProvider, ServerTimingProvider } from "@alepha/server";
 import { AlephaServerCache } from "@alepha/server-cache";
 import { AlephaServerLinks, LinkProvider, ServerLinksProvider } from "@alepha/server-links";
@@ -15,6 +15,91 @@ import { RouterProvider } from "@alepha/router";
 //#region src/descriptors/$page.ts
 /**
 * Main descriptor for defining a React route in the application.
+*
+* The $page descriptor is the core building block for creating type-safe, SSR-enabled React routes.
+* It provides a declarative way to define pages with powerful features:
+*
+* **Routing & Navigation**
+* - URL pattern matching with parameters (e.g., `/users/:id`)
+* - Nested routing with parent-child relationships
+* - Type-safe URL parameter and query string validation
+*
+* **Data Loading**
+* - Server-side data fetching with the `resolve` function
+* - Automatic serialization and hydration for SSR
+* - Access to request context, URL params, and parent data
+*
+* **Component Loading**
+* - Direct component rendering or lazy loading for code splitting
+* - Client-only rendering when browser APIs are needed
+* - Automatic fallback handling during hydration
+*
+* **Performance Optimization**
+* - Static generation for pre-rendered pages at build time
+* - Server-side caching with configurable TTL and providers
+* - Code splitting through lazy component loading
+*
+* **Error Handling**
+* - Custom error handlers with support for redirects
+* - Hierarchical error handling (child → parent)
+* - HTTP status code handling (404, 401, etc.)
+*
+* **Page Animations**
+* - CSS-based enter/exit animations
+* - Dynamic animations based on page state
+* - Custom timing and easing functions
+*
+* **Lifecycle Management**
+* - Server response hooks for headers and status codes
+* - Page leave handlers for cleanup (browser only)
+* - Permission-based access control
+*
+* @example Simple page with data fetching
+* ```typescript
+* const userProfile = $page({
+*   path: "/users/:id",
+*   schema: {
+*     params: t.object({ id: t.int() }),
+*     query: t.object({ tab: t.optional(t.string()) })
+*   },
+*   resolve: async ({ params }) => {
+*     const user = await userApi.getUser(params.id);
+*     return { user };
+*   },
+*   lazy: () => import("./UserProfile.tsx")
+* });
+* ```
+*
+* @example Nested routing with error handling
+* ```typescript
+* const projectSection = $page({
+*   path: "/projects/:id",
+*   children: () => [projectBoard, projectSettings],
+*   resolve: async ({ params }) => {
+*     const project = await projectApi.get(params.id);
+*     return { project };
+*   },
+*   errorHandler: (error) => {
+*     if (HttpError.is(error, 404)) {
+*       return <ProjectNotFound />;
+*     }
+*   }
+* });
+* ```
+*
+* @example Static generation with caching
+* ```typescript
+* const blogPost = $page({
+*   path: "/blog/:slug",
+*   static: {
+*     entries: posts.map(p => ({ params: { slug: p.slug } }))
+*   },
+*   resolve: async ({ params }) => {
+*     const post = await loadPost(params.slug);
+*     return { post };
+*   }
+* });
+* ```
 */
 const $page = (options) => {
 	return createDescriptor(PageDescriptor, options);
@@ -248,7 +333,7 @@ const AlephaContext = createContext(void 0);
 *
 * - alepha.state() for state management
 * - alepha.inject() for dependency injection
-* - alepha.emit() for event handling
+* - alepha.events.emit() for event handling
 * etc...
 */
 const useAlepha = () => {
@@ -275,10 +360,10 @@ const useRouterEvents = (opts = {}, deps = []) => {
 		const onEnd = opts.onEnd;
 		const onError = opts.onError;
 		const onSuccess = opts.onSuccess;
-		if (onBegin) subs.push(alepha.on("react:transition:begin", cb(onBegin)));
-		if (onEnd) subs.push(alepha.on("react:transition:end", cb(onEnd)));
-		if (onError) subs.push(alepha.on("react:transition:error", cb(onError)));
-		if (onSuccess) subs.push(alepha.on("react:transition:success", cb(onSuccess)));
+		if (onBegin) subs.push(alepha.events.on("react:transition:begin", cb(onBegin)));
+		if (onEnd) subs.push(alepha.events.on("react:transition:end", cb(onEnd)));
+		if (onError) subs.push(alepha.events.on("react:transition:error", cb(onError)));
+		if (onSuccess) subs.push(alepha.events.on("react:transition:success", cb(onSuccess)));
 		return () => {
 			for (const sub of subs) sub();
 		};
@@ -293,17 +378,17 @@ const useRouterEvents = (opts = {}, deps = []) => {
 const useStore = (key, defaultValue) => {
 	const alepha = useAlepha();
 	useMemo(() => {
-		if (defaultValue != null && alepha.state(key) == null) alepha.state(key, defaultValue);
+		if (defaultValue != null && alepha.state.get(key) == null) alepha.state.set(key, defaultValue);
 	}, [defaultValue]);
-	const [state, setState] = useState(alepha.state(key));
+	const [state, setState] = useState(alepha.state.get(key));
 	useEffect(() => {
 		if (!alepha.isBrowser()) return;
-		return alepha.on("state:mutate", (ev) => {
+		return alepha.events.on("state:mutate", (ev) => {
 			if (ev.key === key) setState(ev.value);
 		});
 	}, []);
 	return [state, (value) => {
-		alepha.state(key, value);
+		alepha.state.set(key, value);
 	}];
 };
 
@@ -537,8 +622,8 @@ var ReactPageProvider = class {
 		return root;
 	}
 	convertStringObjectToObject = (schema, value) => {
-		if (TypeGuard.IsObject(schema) && typeof value === "object") {
-			for (const key in schema.properties) if (TypeGuard.IsObject(schema.properties[key]) && typeof value[key] === "string") try {
+		if (t.schema.isObject(schema) && typeof value === "object") {
+			for (const key in schema.properties) if (t.schema.isObject(schema.properties[key]) && typeof value[key] === "string") try {
 				value[key] = this.alepha.parse(schema.properties[key], decodeURIComponent(value[key]));
 			} catch (e) {}
 		}
@@ -825,12 +910,13 @@ var ReactServerProvider = class {
 	serverTimingProvider = $inject(ServerTimingProvider);
 	env = $env(envSchema$1);
 	ROOT_DIV_REGEX = new RegExp(`<div([^>]*)\\s+id=["']${this.env.REACT_ROOT_ID}["']([^>]*)>(.*?)<\\/div>`, "is");
+	preprocessedTemplate = null;
 	onConfigure = $hook({
 		on: "configure",
 		handler: async () => {
 			const pages = this.alepha.descriptors($page);
 			const ssrEnabled = pages.length > 0 && this.env.REACT_SSR_ENABLED !== false;
-			this.alepha.state("react.server.ssr", ssrEnabled);
+			this.alepha.state.set("react.server.ssr", ssrEnabled);
 			for (const page of pages) {
 				page.render = this.createRenderFunction(page.name);
 				page.fetch = async (options) => {
@@ -886,6 +972,8 @@ var ReactServerProvider = class {
 		return this.alepha.env.REACT_SERVER_TEMPLATE ?? "<!DOCTYPE html><html lang='en'><head></head><body></body></html>";
 	}
 	async registerPages(templateLoader) {
+		const template = await templateLoader();
+		if (template) this.preprocessedTemplate = this.preprocessTemplate(template);
 		for (const page of this.pageApi.getPages()) {
 			if (page.children?.length) continue;
 			this.log.debug(`+ ${page.match} -> ${page.name}`);
@@ -932,7 +1020,7 @@ var ReactServerProvider = class {
 			};
 			const state = entry;
 			this.log.trace("Rendering", { url });
-			await this.alepha.emit("react:server:render:begin", { state });
+			await this.alepha.events.emit("react:server:render:begin", { state });
 			const { redirect } = await this.pageApi.createLayers(page, state);
 			if (redirect) return {
 				state,
@@ -940,13 +1028,14 @@ var ReactServerProvider = class {
 				redirect
 			};
 			if (!withIndex && !options.html) {
-				this.alepha.state("react.router.state", state);
+				this.alepha.state.set("react.router.state", state);
 				return {
 					state,
 					html: renderToString(this.pageApi.root(state))
 				};
 			}
-			const html = this.renderToHtml(this.template ?? "", state, options.hydration);
+			const template = this.template ?? "";
+			const html = this.renderToHtml(template, state, options.hydration);
 			if (html instanceof Redirection) return {
 				state,
 				html: "",
@@ -956,7 +1045,7 @@ var ReactServerProvider = class {
 				state,
 				html
 			};
-			await this.alepha.emit("react:server:render:end", result);
+			await this.alepha.events.emit("react:server:render:end", result);
 			return result;
 		};
 	}
@@ -974,7 +1063,7 @@ var ReactServerProvider = class {
 				layers: []
 			};
 			const state = entry;
-			if (this.alepha.has(ServerLinksProvider)) this.alepha.state("api", await this.alepha.inject(ServerLinksProvider).getUserApiLinks({
+			if (this.alepha.has(ServerLinksProvider)) this.alepha.state.set("api", await this.alepha.inject(ServerLinksProvider).getUserApiLinks({
 				user: serverRequest.user,
 				authorization: serverRequest.headers.authorization
 			}));
@@ -987,7 +1076,7 @@ var ReactServerProvider = class {
 				}
 				target = target.parent;
 			}
-			await this.alepha.emit("react:server:render:begin", {
+			await this.alepha.events.emit("react:server:render:begin", {
 				request: serverRequest,
 				state
 			});
@@ -1009,7 +1098,7 @@ var ReactServerProvider = class {
 				state,
 				html
 			};
-			await this.alepha.emit("react:server:render:end", event);
+			await this.alepha.events.emit("react:server:render:end", event);
 			route.onServerResponse?.(serverRequest);
 			this.log.trace("Page rendered", { name: route.name });
 			return event.html;
@@ -1017,7 +1106,7 @@ var ReactServerProvider = class {
 	}
 	renderToHtml(template, state, hydration = true) {
 		const element = this.pageApi.root(state);
-		this.alepha.state("react.router.state", state);
+		this.alepha.state.set("react.router.state", state);
 		this.serverTimingProvider.beginTiming("renderToString");
 		let app = "";
 		try {
@@ -1055,18 +1144,48 @@ var ReactServerProvider = class {
 		}
 		return response.html;
 	}
-	fillTemplate(response, app, script) {
-		if (this.ROOT_DIV_REGEX.test(response.html)) response.html = response.html.replace(this.ROOT_DIV_REGEX, (_match, beforeId, afterId) => {
-			return `<div${beforeId} id="${this.env.REACT_ROOT_ID}"${afterId}>${app}</div>`;
-		});
-		else {
-			const bodyOpenTag = /<body([^>]*)>/i;
-			if (bodyOpenTag.test(response.html)) response.html = response.html.replace(bodyOpenTag, (match) => {
-				return `${match}<div id="${this.env.REACT_ROOT_ID}">${app}</div>`;
-			});
+	preprocessTemplate(template) {
+		const bodyCloseMatch = template.match(/<\/body>/i);
+		const bodyCloseIndex = bodyCloseMatch?.index ?? template.length;
+		const beforeScript = template.substring(0, bodyCloseIndex);
+		const afterScript = template.substring(bodyCloseIndex);
+		const rootDivMatch = beforeScript.match(this.ROOT_DIV_REGEX);
+		if (rootDivMatch) {
+			const beforeDiv = beforeScript.substring(0, rootDivMatch.index);
+			const afterDivStart = rootDivMatch.index + rootDivMatch[0].length;
+			const afterDiv = beforeScript.substring(afterDivStart);
+			const beforeApp = `${beforeDiv}<div${rootDivMatch[1]} id="${this.env.REACT_ROOT_ID}"${rootDivMatch[2]}>`;
+			const afterApp = `</div>${afterDiv}`;
+			return {
+				beforeApp,
+				afterApp,
+				beforeScript: "",
+				afterScript
+			};
 		}
-		const bodyCloseTagRegex = /<\/body>/i;
-		if (bodyCloseTagRegex.test(response.html)) response.html = response.html.replace(bodyCloseTagRegex, `${script}</body>`);
+		const bodyMatch = beforeScript.match(/<body([^>]*)>/i);
+		if (bodyMatch) {
+			const beforeBody = beforeScript.substring(0, bodyMatch.index + bodyMatch[0].length);
+			const afterBody = beforeScript.substring(bodyMatch.index + bodyMatch[0].length);
+			const beforeApp = `${beforeBody}<div id="${this.env.REACT_ROOT_ID}">`;
+			const afterApp = `</div>${afterBody}`;
+			return {
+				beforeApp,
+				afterApp,
+				beforeScript: "",
+				afterScript
+			};
+		}
+		return {
+			beforeApp: `<div id="${this.env.REACT_ROOT_ID}">`,
+			afterApp: `</div>`,
+			beforeScript,
+			afterScript
+		};
+	}
+	fillTemplate(response, app, script) {
+		if (!this.preprocessedTemplate) this.preprocessedTemplate = this.preprocessTemplate(response.html);
+		response.html = this.preprocessedTemplate.beforeApp + app + this.preprocessedTemplate.afterApp + script + this.preprocessedTemplate.afterScript;
 	}
 };
 
@@ -1099,8 +1218,8 @@ var ReactBrowserRouterProvider = class extends RouterProvider {
 			meta
 		};
 		const state = entry;
-		await this.alepha.emit("react:transition:begin", {
-			previous: this.alepha.state("react.router.state"),
+		await this.alepha.events.emit("react:transition:begin", {
+			previous: this.alepha.state.get("react.router.state"),
 			state
 		});
 		try {
@@ -1119,7 +1238,7 @@ var ReactBrowserRouterProvider = class extends RouterProvider {
 				index: 0,
 				path: "/"
 			});
-			await this.alepha.emit("react:transition:success", { state });
+			await this.alepha.events.emit("react:transition:success", { state });
 		} catch (e) {
 			this.log.error("Transition has failed", e);
 			state.layers = [{
@@ -1128,7 +1247,7 @@ var ReactBrowserRouterProvider = class extends RouterProvider {
 				index: 0,
 				path: "/"
 			}];
-			await this.alepha.emit("react:transition:error", {
+			await this.alepha.events.emit("react:transition:error", {
 				error: e,
 				state
 			});
@@ -1137,8 +1256,8 @@ var ReactBrowserRouterProvider = class extends RouterProvider {
 			const layer = previous[i];
 			if (state.layers[i]?.name !== layer.name) this.pageApi.page(layer.name)?.onLeave?.();
 		}
-		this.alepha.state("react.router.state", state);
-		await this.alepha.emit("react:transition:end", { state });
+		this.alepha.state.set("react.router.state", state);
+		await this.alepha.events.emit("react:transition:end", { state });
 	}
 	root(state) {
 		return this.pageApi.root(state);
@@ -1166,7 +1285,7 @@ var ReactBrowserProvider = class {
 	}
 	transitioning;
 	get state() {
-		return this.alepha.state("react.router.state");
+		return this.alepha.state.get("react.router.state");
 	}
 	/**
 	* Accessor for Document DOM API.
@@ -1282,11 +1401,11 @@ var ReactBrowserProvider = class {
 			const hydration = this.getHydrationState();
 			const previous = hydration?.layers ?? [];
 			if (hydration) {
-				for (const [key, value] of Object.entries(hydration)) if (key !== "layers") this.alepha.state(key, value);
+				for (const [key, value] of Object.entries(hydration)) if (key !== "layers") this.alepha.state.set(key, value);
 			}
 			await this.render({ previous });
 			const element = this.router.root(this.state);
-			await this.alepha.emit("react:browser:render", {
+			await this.alepha.events.emit("react:browser:render", {
 				element,
 				root: this.getRootElement(),
 				hydration,
@@ -1307,7 +1426,7 @@ var ReactRouter = class {
 	alepha = $inject(Alepha);
 	pageApi = $inject(ReactPageProvider);
 	get state() {
-		return this.alepha.state("react.router.state");
+		return this.alepha.state.get("react.router.state");
 	}
 	get pages() {
 		return this.pageApi.getPages();
@@ -1493,7 +1612,7 @@ const useQueryParams = (schema, options = {}) => {
 	const key = options.key ?? "q";
 	const router = useRouter();
 	const querystring = router.query[key];
-	const [queryParams, setQueryParams] = useState(decode(alepha, schema, router.query[key]));
+	const [queryParams = {}, setQueryParams] = useState(decode(alepha, schema, router.query[key]));
 	useEffect(() => {
 		setQueryParams(decode(alepha, schema, querystring));
 	}, [querystring]);
@@ -1513,8 +1632,8 @@ const encode = (alepha, schema, data) => {
 const decode = (alepha, schema, data) => {
 	try {
 		return alepha.parse(schema, JSON.parse(atob(decodeURIComponent(data))));
-	} catch (_error) {
-		return {};
+	} catch {
+		return;
 	}
 };