@alepha/react 0.9.4 → 0.10.0

package/dist/index.browser.js

@@ -3,14 +3,99 @@ import { AlephaServer, HttpClient } from "@alepha/server";
 import { AlephaServerLinks, LinkProvider } from "@alepha/server-links";
 import { DateTimeProvider } from "@alepha/datetime";
 import { $logger } from "@alepha/logger";
-import { createRoot, hydrateRoot } from "react-dom/client";
 import { RouterProvider } from "@alepha/router";
-import React, { StrictMode, createContext, createElement, useContext, useEffect, useMemo, useState } from "react";
-import { jsx, jsxs } from "react/jsx-runtime";
+import React, { StrictMode, createContext, createElement, memo, use, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { createRoot, hydrateRoot } from "react-dom/client";
 
 //#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);
@@ -30,7 +115,10 @@ var PageDescriptor = class extends Descriptor {
 	* Only valid for server-side rendering, it will throw an error if called on the client-side.
 	*/
 	async render(options) {
-		throw new Error("render method is not implemented in this environment");
+		throw new AlephaError("render() method is not implemented in this environment");
+	}
+	async fetch(options) {
+		throw new AlephaError("fetch() method is not implemented in this environment");
 	}
 	match(url) {
 		return false;
@@ -84,7 +172,6 @@ const ClientOnly = (props) => {
 	if (props.disabled) return props.children;
 	return mounted ? props.children : props.fallback;
 };
-var ClientOnly_default = ClientOnly;
 
 //#endregion
 //#region src/components/ErrorViewer.tsx
@@ -192,7 +279,6 @@ const ErrorViewer = ({ error, alepha }) => {
 		})] })]
 	});
 };
-var ErrorViewer_default = ErrorViewer;
 const ErrorViewerProduction = () => {
 	const styles = {
 		container: {
@@ -268,7 +354,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 = () => {
@@ -286,19 +372,55 @@ const useRouterEvents = (opts = {}, deps = []) => {
 	const alepha = useAlepha();
 	useEffect(() => {
 		if (!alepha.isBrowser()) return;
+		const cb = (callback) => {
+			if (typeof callback === "function") return { callback };
+			return callback;
+		};
 		const subs = [];
 		const onBegin = opts.onBegin;
 		const onEnd = opts.onEnd;
 		const onError = opts.onError;
-		if (onBegin) subs.push(alepha.on("react:transition:begin", { callback: onBegin }));
-		if (onEnd) subs.push(alepha.on("react:transition:end", { callback: onEnd }));
-		if (onError) subs.push(alepha.on("react:transition:error", { callback: onError }));
+		const onSuccess = opts.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();
 		};
 	}, deps);
 };
 
+//#endregion
+//#region src/hooks/useStore.ts
+/**
+* Hook to access and mutate the Alepha state.
+*/
+const useStore = (key, defaultValue) => {
+	const alepha = useAlepha();
+	useMemo(() => {
+		if (defaultValue != null && alepha.state.get(key) == null) alepha.state.set(key, defaultValue);
+	}, [defaultValue]);
+	const [state, setState] = useState(alepha.state.get(key));
+	useEffect(() => {
+		if (!alepha.isBrowser()) return;
+		return alepha.events.on("state:mutate", (ev) => {
+			if (ev.key === key) setState(ev.value);
+		});
+	}, []);
+	return [state, (value) => {
+		alepha.state.set(key, value);
+	}];
+};
+
+//#endregion
+//#region src/hooks/useRouterState.ts
+const useRouterState = () => {
+	const [state] = useStore("react.router.state");
+	if (!state) throw new AlephaError("Missing react router state");
+	return state;
+};
+
 //#endregion
 //#region src/components/ErrorBoundary.tsx
 /**
@@ -328,7 +450,6 @@ var ErrorBoundary = class extends React.Component {
 		return this.props.children;
 	}
 };
-var ErrorBoundary_default = ErrorBoundary;
 
 //#endregion
 //#region src/components/NestedView.tsx
@@ -339,7 +460,7 @@ var ErrorBoundary_default = ErrorBoundary;
 *
 * @example
 * ```tsx
-* import { NestedView } from "@alepha/react";
+* import { NestedView } from "alepha/react";
 *
 * class App {
 *   parent = $page({
@@ -354,17 +475,69 @@ var ErrorBoundary_default = ErrorBoundary;
 * ```
 */
 const NestedView = (props) => {
-	const layer = useContext(RouterLayerContext);
-	const index = layer?.index ?? 0;
-	const alepha = useAlepha();
-	const state = alepha.state("react.router.state");
-	if (!state) throw new Error("<NestedView/> must be used inside a RouterLayerContext.");
+	const index = use(RouterLayerContext)?.index ?? 0;
+	const state = useRouterState();
 	const [view, setView] = useState(state.layers[index]?.element);
-	useRouterEvents({ onEnd: ({ state: state$1 }) => {
-		if (!state$1.layers[index]?.cache) setView(state$1.layers[index]?.element);
-	} }, []);
-	const element = view ?? props.children ?? null;
-	return /* @__PURE__ */ jsx(ErrorBoundary_default, {
+	const [animation, setAnimation] = useState("");
+	const animationExitDuration = useRef(0);
+	const animationExitNow = useRef(0);
+	useRouterEvents({
+		onBegin: async ({ previous, state: state$1 }) => {
+			const layer = previous.layers[index];
+			if (`${state$1.url.pathname}/`.startsWith(`${layer?.path}/`)) return;
+			const animationExit = parseAnimation(layer.route?.animation, state$1, "exit");
+			if (animationExit) {
+				const duration = animationExit.duration || 200;
+				animationExitNow.current = Date.now();
+				animationExitDuration.current = duration;
+				setAnimation(animationExit.animation);
+			} else {
+				animationExitNow.current = 0;
+				animationExitDuration.current = 0;
+				setAnimation("");
+			}
+		},
+		onEnd: async ({ state: state$1 }) => {
+			const layer = state$1.layers[index];
+			if (animationExitNow.current) {
+				const duration = animationExitDuration.current;
+				const diff = Date.now() - animationExitNow.current;
+				if (diff < duration) await new Promise((resolve) => setTimeout(resolve, duration - diff));
+			}
+			if (!layer?.cache) {
+				setView(layer?.element);
+				const animationEnter = parseAnimation(layer?.route?.animation, state$1, "enter");
+				if (animationEnter) setAnimation(animationEnter.animation);
+				else setAnimation("");
+			}
+		}
+	}, []);
+	let element = view ?? props.children ?? null;
+	if (animation) element = /* @__PURE__ */ jsx("div", {
+		style: {
+			display: "flex",
+			flex: 1,
+			height: "100%",
+			width: "100%",
+			position: "relative",
+			overflow: "hidden"
+		},
+		children: /* @__PURE__ */ jsx("div", {
+			style: {
+				height: "100%",
+				width: "100%",
+				display: "flex",
+				animation
+			},
+			children: element
+		})
+	});
+	if (props.errorBoundary === false) return /* @__PURE__ */ jsx(Fragment, { children: element });
+	if (props.errorBoundary) return /* @__PURE__ */ jsx(ErrorBoundary, {
+		fallback: props.errorBoundary,
+		children: element
+	});
+	return /* @__PURE__ */ jsx(ErrorBoundary, {
 		fallback: (error) => {
 			const result = state.onError(error, state);
 			if (result instanceof Redirection) return "Redirection inside ErrorBoundary is not allowed.";
@@ -373,7 +546,37 @@ const NestedView = (props) => {
 		children: element
 	});
 };
-var NestedView_default = NestedView;
+var NestedView_default = memo(NestedView);
+function parseAnimation(animationLike, state, type = "enter") {
+	if (!animationLike) return void 0;
+	const DEFAULT_DURATION = 300;
+	const animation = typeof animationLike === "function" ? animationLike(state) : animationLike;
+	if (typeof animation === "string") {
+		if (type === "exit") return;
+		return {
+			duration: DEFAULT_DURATION,
+			animation: `${DEFAULT_DURATION}ms ${animation}`
+		};
+	}
+	if (typeof animation === "object") {
+		const anim = animation[type];
+		const duration = typeof anim === "object" ? anim.duration ?? DEFAULT_DURATION : DEFAULT_DURATION;
+		const name = typeof anim === "object" ? anim.name : anim;
+		if (type === "exit") {
+			const timing$1 = typeof anim === "object" ? anim.timing ?? "" : "";
+			return {
+				duration,
+				animation: `${duration}ms ${timing$1} ${name}`
+			};
+		}
+		const timing = typeof anim === "object" ? anim.timing ?? "" : "";
+		return {
+			duration,
+			animation: `${duration}ms ${timing} ${name}`
+		};
+	}
+	return void 0;
+}
 
 //#endregion
 //#region src/providers/ReactPageProvider.ts
@@ -414,6 +617,14 @@ var ReactPageProvider = class {
 		if (this.env.REACT_STRICT_MODE) return createElement(StrictMode, {}, root);
 		return root;
 	}
+	convertStringObjectToObject = (schema, value) => {
+		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) {}
+		}
+		return value;
+	};
 	/**
 	* Create a new RouterState based on a given route and request.
 	* This method resolves the layers for the route, applying any query and params schemas defined in the route.
@@ -433,6 +644,7 @@ var ReactPageProvider = class {
 			const route$1 = it.route;
 			const config = {};
 			try {
+				this.convertStringObjectToObject(route$1.schema?.query, state.query);
 				config.query = route$1.schema?.query ? this.alepha.parse(route$1.schema.query, state.query) : {};
 			} catch (e) {
 				it.error = e;
@@ -559,6 +771,7 @@ var ReactPageProvider = class {
 		}
 	}
 	async createElement(page, props) {
+		if (page.lazy && page.component) this.log.warn(`Page ${page.name} has both lazy and component options, lazy will be used`);
 		if (page.lazy) {
 			const component = await page.lazy();
 			return createElement(component.default, props);
@@ -567,7 +780,7 @@ var ReactPageProvider = class {
 		return void 0;
 	}
 	renderError(error) {
-		return createElement(ErrorViewer_default, {
+		return createElement(ErrorViewer, {
 			error,
 			alepha: this.alepha
 		});
@@ -593,7 +806,7 @@ var ReactPageProvider = class {
 	}
 	renderView(index, path, view, page) {
 		view ??= this.renderEmptyView();
-		const element = page.client ? createElement(ClientOnly_default, typeof page.client === "object" ? page.client : {}, view) : view;
+		const element = page.client ? createElement(ClientOnly, typeof page.client === "object" ? page.client : {}, view) : view;
 		return createElement(RouterLayerContext.Provider, { value: {
 			index,
 			path
@@ -692,17 +905,21 @@ var ReactBrowserRouterProvider = class extends RouterProvider {
 			});
 		}
 	});
-	async transition(url, previous = []) {
+	async transition(url, previous = [], meta = {}) {
 		const { pathname, search } = url;
 		const entry = {
 			url,
 			query: {},
 			params: {},
 			layers: [],
-			onError: () => null
+			onError: () => null,
+			meta
 		};
 		const state = entry;
-		await this.alepha.emit("react:transition:begin", { state });
+		await this.alepha.events.emit("react:transition:begin", {
+			previous: this.alepha.state.get("react.router.state"),
+			state
+		});
 		try {
 			const { route, params } = this.match(pathname);
 			const query = {};
@@ -719,7 +936,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 = [{
@@ -728,7 +945,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
 			});
@@ -737,8 +954,8 @@ var ReactBrowserRouterProvider = class extends RouterProvider {
 			const layer = previous[i];
 			if (state.layers[i]?.name !== layer.name) this.pageApi.page(layer.name)?.onLeave?.();
 		}
-		await this.alepha.emit("react:transition:end", { state });
-		this.alepha.state("react.router.state", 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);
@@ -755,7 +972,6 @@ var ReactBrowserProvider = class {
 	alepha = $inject(Alepha);
 	router = $inject(ReactBrowserRouterProvider);
 	dateTimeProvider = $inject(DateTimeProvider);
-	root;
 	options = { scrollRestoration: "top" };
 	getRootElement() {
 		const root = this.document.getElementById(this.env.REACT_ROOT_ID);
@@ -767,7 +983,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.
@@ -831,7 +1047,8 @@ var ReactBrowserProvider = class {
 		});
 		await this.render({
 			url,
-			previous: options.force ? [] : this.state.layers
+			previous: options.force ? [] : this.state.layers,
+			meta: options.meta
 		});
 		if (this.state.url.pathname + this.state.url.search !== url) {
 			this.pushState(this.state.url.pathname + this.state.url.search);
@@ -848,7 +1065,7 @@ var ReactBrowserProvider = class {
 			from: this.state?.url.pathname
 		};
 		this.log.debug("Transitioning...", { to: url });
-		const redirect = await this.router.transition(new URL(`http://localhost${url}`), previous);
+		const redirect = await this.router.transition(new URL(`http://localhost${url}`), previous, options.meta);
 		if (redirect) {
 			this.log.info("Redirecting to", { redirect });
 			return await this.render({ url: redirect });
@@ -870,7 +1087,7 @@ var ReactBrowserProvider = class {
 	onTransitionEnd = $hook({
 		on: "react:transition:end",
 		handler: () => {
-			if (this.options.scrollRestoration === "top" && typeof window !== "undefined") {
+			if (this.options.scrollRestoration === "top" && typeof window !== "undefined" && !this.alepha.isTest()) {
 				this.log.trace("Restoring scroll position to top");
 				window.scrollTo(0, 0);
 			}
@@ -882,23 +1099,41 @@ 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.events.emit("react:browser:render", {
+				element,
+				root: this.getRootElement(),
+				hydration,
+				state: this.state
+			});
+			window.addEventListener("popstate", () => {
+				if (this.base + this.state.url.pathname === this.location.pathname) return;
+				this.log.debug("Popstate event triggered - rendering new state", { url: this.location.pathname + this.location.search });
+				this.render();
+			});
+		}
+	});
+};
+
+//#endregion
+//#region src/providers/ReactBrowserRendererProvider.ts
+var ReactBrowserRendererProvider = class {
+	log = $logger();
+	root;
+	onBrowserRender = $hook({
+		on: "react:browser:render",
+		handler: async ({ hydration, root, element }) => {
 			if (hydration?.layers) {
-				this.root = hydrateRoot(this.getRootElement(), element);
+				this.root = hydrateRoot(root, element);
 				this.log.info("Hydrated root element");
 			} else {
-				this.root ??= createRoot(this.getRootElement());
+				this.root ??= createRoot(root);
 				this.root.render(element);
 				this.log.info("Created root element");
 			}
-			window.addEventListener("popstate", () => {
-				if (this.base + this.state.url.pathname === this.location.pathname) return;
-				this.log.debug("Popstate event triggered - rendering new state", { url: this.location.pathname + this.location.search });
-				this.render();
-			});
 		}
 	});
 };
@@ -909,7 +1144,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();
@@ -1032,44 +1267,12 @@ const useRouter = () => {
 //#region src/components/Link.tsx
 const Link = (props) => {
 	const router = useRouter();
-	const { to,...anchorProps } = props;
 	return /* @__PURE__ */ jsx("a", {
-		...router.anchor(to),
-		...anchorProps,
+		...props,
+		...router.anchor(props.href),
 		children: props.children
 	});
 };
-var Link_default = Link;
-
-//#endregion
-//#region src/hooks/useStore.ts
-/**
-* Hook to access and mutate the Alepha state.
-*/
-const useStore = (key, defaultValue) => {
-	const alepha = useAlepha();
-	useMemo(() => {
-		if (defaultValue != null && alepha.state(key) == null) alepha.state(key, defaultValue);
-	}, [defaultValue]);
-	const [state, setState] = useState(alepha.state(key));
-	useEffect(() => {
-		if (!alepha.isBrowser()) return;
-		return alepha.on("state:mutate", (ev) => {
-			if (ev.key === key) setState(ev.value);
-		});
-	}, []);
-	return [state, (value) => {
-		alepha.state(key, value);
-	}];
-};
-
-//#endregion
-//#region src/hooks/useRouterState.ts
-const useRouterState = () => {
-	const [state] = useStore("react.router.state");
-	if (!state) throw new AlephaError("Missing react router state");
-	return state;
-};
 
 //#endregion
 //#region src/hooks/useActive.ts
@@ -1127,7 +1330,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]);
@@ -1147,8 +1350,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;
 	}
 };
 
@@ -1196,11 +1399,12 @@ const AlephaReact = $module({
 		ReactPageProvider,
 		ReactBrowserRouterProvider,
 		ReactBrowserProvider,
-		ReactRouter
+		ReactRouter,
+		ReactBrowserRendererProvider
 	],
-	register: (alepha) => alepha.with(AlephaServer).with(AlephaServerLinks).with(ReactPageProvider).with(ReactBrowserProvider).with(ReactBrowserRouterProvider).with(ReactRouter)
+	register: (alepha) => alepha.with(AlephaServer).with(AlephaServerLinks).with(ReactPageProvider).with(ReactBrowserProvider).with(ReactBrowserRouterProvider).with(ReactBrowserRendererProvider).with(ReactRouter)
 });
 
 //#endregion
-export { $page, AlephaContext, AlephaReact, ClientOnly_default as ClientOnly, ErrorBoundary_default as ErrorBoundary, ErrorViewer_default as ErrorViewer, Link_default as Link, NestedView_default as NestedView, NotFoundPage as NotFound, PageDescriptor, ReactBrowserProvider, ReactBrowserRouterProvider, ReactPageProvider, ReactRouter, Redirection, RouterLayerContext, isPageRoute, ssrSchemaLoading, useActive, useAlepha, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState, useSchema, useStore };
+export { $page, AlephaContext, AlephaReact, ClientOnly, ErrorBoundary, ErrorViewer, Link, NestedView_default as NestedView, NotFoundPage as NotFound, PageDescriptor, ReactBrowserProvider, ReactBrowserRouterProvider, ReactPageProvider, ReactRouter, Redirection, RouterLayerContext, isPageRoute, ssrSchemaLoading, useActive, useAlepha, useClient, useInject, useQueryParams, useRouter, useRouterEvents, useRouterState, useSchema, useStore };
 //# sourceMappingURL=index.browser.js.map