@alepha/react 0.9.4 → 0.9.5

package/README.md

@@ -10,12 +10,6 @@ This package is part of the Alepha framework and can be installed via the all-in
 npm install alepha
 ```
 
-Alternatively, you can install it individually:
-
-```bash
-npm install @alepha/core @alepha/react
-```
-
 ## Module
 
 Provides full-stack React development with declarative routing, server-side rendering, and client-side hydration.
@@ -24,16 +18,34 @@ The React module enables building modern React applications using the `$page` de
 It delivers seamless server-side rendering, automatic code splitting, and client-side navigation with full
 type safety and schema validation for route parameters and data.
 
+This module can be imported and used as follows:
+
+```typescript
+import { Alepha, run } from "alepha";
+import { AlephaReact } from "alepha/react";
+
+const alepha = Alepha.create()
+	.with(AlephaReact);
+
+run(alepha);
+```
+
 ## API Reference
 
 ### Descriptors
 
+Descriptors are functions that define and configure various aspects of your application. They follow the convention of starting with `$` and return configured descriptor instances.
+
+For more details, see the [Descriptors documentation](https://feunard.github.io/alepha/docs/descriptors).
+
 #### $page()
 
 Main descriptor for defining a React route in the application.
 
 ### Hooks
 
+Hooks provide a way to tap into various lifecycle events and extend functionality. They follow the convention of starting with `use` and return configured hook instances.
+
 #### useAlepha()
 
 Main Alepha hook.

package/dist/index.browser.js

@@ -1,12 +1,12 @@
-import { $env, $hook, $inject, $module, Alepha, AlephaError, Descriptor, KIND, createDescriptor, t } from "@alepha/core";
+import { $env, $hook, $inject, $module, Alepha, AlephaError, Descriptor, KIND, TypeGuard, createDescriptor, t } from "@alepha/core";
 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
 /**
@@ -30,7 +30,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 +87,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 +194,6 @@ const ErrorViewer = ({ error, alepha }) => {
 		})] })]
 	});
 };
-var ErrorViewer_default = ErrorViewer;
 const ErrorViewerProduction = () => {
 	const styles = {
 		container: {
@@ -286,19 +287,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.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)));
 		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(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/components/ErrorBoundary.tsx
 /**
@@ -328,7 +365,6 @@ var ErrorBoundary = class extends React.Component {
 		return this.props.children;
 	}
 };
-var ErrorBoundary_default = ErrorBoundary;
 
 //#endregion
 //#region src/components/NestedView.tsx
@@ -339,7 +375,7 @@ var ErrorBoundary_default = ErrorBoundary;
 *
 * @example
 * ```tsx
-* import { NestedView } from "@alepha/react";
+* import { NestedView } from "alepha/react";
 *
 * class App {
 *   parent = $page({
@@ -354,17 +390,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 +461,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 +532,14 @@ var ReactPageProvider = class {
 		if (this.env.REACT_STRICT_MODE) return createElement(StrictMode, {}, root);
 		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 {
+				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 +559,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 +686,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 +695,7 @@ var ReactPageProvider = class {
 		return void 0;
 	}
 	renderError(error) {
-		return createElement(ErrorViewer_default, {
+		return createElement(ErrorViewer, {
 			error,
 			alepha: this.alepha
 		});
@@ -593,7 +721,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 +820,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.emit("react:transition:begin", {
+			previous: this.alepha.state("react.router.state"),
+			state
+		});
 		try {
 			const { route, params } = this.match(pathname);
 			const query = {};
@@ -737,8 +869,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);
+		await this.alepha.emit("react:transition:end", { state });
 	}
 	root(state) {
 		return this.pageApi.root(state);
@@ -755,7 +887,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);
@@ -831,7 +962,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 +980,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 +1002,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);
 			}
@@ -886,19 +1018,37 @@ var ReactBrowserProvider = class {
 			}
 			await this.render({ previous });
 			const element = this.router.root(this.state);
+			await this.alepha.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();
-			});
 		}
 	});
 };
@@ -1032,44 +1182,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
@@ -1196,11 +1314,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