@alepha/react 0.7.4 → 0.7.5

package/dist/{ReactBrowserProvider-ufHSOTmv.js → useRouterState-cCucJfTC.js}

@@ -1,8 +1,8 @@
+import { jsx, jsxs } from 'react/jsx-runtime';
 import { __descriptor, OPTIONS, NotImplementedError, KIND, t, $logger, $inject, Alepha, $hook } from '@alepha/core';
+import React, { useState, useEffect, createContext, useContext, createElement, StrictMode, useMemo } from 'react';
 import { HttpClient } from '@alepha/server';
 import { RouterProvider } from '@alepha/router';
-import React, { useState, useEffect, createContext, useContext, createElement, StrictMode } from 'react';
-import { jsx, jsxs } from 'react/jsx-runtime';
 
 const KEY = "PAGE";
 const $page = (options) => {
@@ -277,7 +277,7 @@ const NestedView = (props) => {
 };
 
 function NotFoundPage() {
-  return /* @__PURE__ */ jsxs(
+  return /* @__PURE__ */ jsx(
     "div",
     {
       style: {
@@ -290,21 +290,7 @@ function NotFoundPage() {
         fontFamily: "sans-serif",
         padding: "1rem"
       },
-      children: [
-        /* @__PURE__ */ jsx("h1", { style: { fontSize: "1rem", marginBottom: "0.5rem" }, children: "This page does not exist" }),
-        /* @__PURE__ */ jsx(
-          "a",
-          {
-            href: "/",
-            style: {
-              fontSize: "0.7rem",
-              color: "#007bff",
-              textDecoration: "none"
-            },
-            children: "\u2190 Back to home"
-          }
-        )
-      ]
+      children: /* @__PURE__ */ jsx("h1", { style: { fontSize: "1rem", marginBottom: "0.5rem" }, children: "This page does not exist" })
     }
   );
 }
@@ -943,4 +929,233 @@ class ReactBrowserProvider {
   });
 }
 
-export { $page as $, BrowserRouterProvider as B, ClientOnly as C, ErrorBoundary as E, NestedView as N, PageDescriptorProvider as P, RouterContext as R, RouterLayerContext as a, ReactBrowserProvider as b, RedirectionError as c, useAlepha as d, isPageRoute as i, useRouterEvents as u };
+class RouterHookApi {
+  constructor(pages, state, layer, browser) {
+    this.pages = pages;
+    this.state = state;
+    this.layer = layer;
+    this.browser = browser;
+  }
+  get current() {
+    return this.state;
+  }
+  get pathname() {
+    return this.state.pathname;
+  }
+  get query() {
+    const query = {};
+    for (const [key, value] of new URLSearchParams(
+      this.state.search
+    ).entries()) {
+      query[key] = String(value);
+    }
+    return query;
+  }
+  async back() {
+    this.browser?.history.back();
+  }
+  async forward() {
+    this.browser?.history.forward();
+  }
+  async invalidate(props) {
+    await this.browser?.invalidate(props);
+  }
+  /**
+   * Create a valid href for the given pathname.
+   *
+   * @param pathname
+   * @param layer
+   */
+  createHref(pathname, layer = this.layer, options = {}) {
+    if (typeof pathname === "object") {
+      pathname = pathname.options.path ?? "";
+    }
+    if (options.params) {
+      for (const [key, value] of Object.entries(options.params)) {
+        pathname = pathname.replace(`:${key}`, String(value));
+      }
+    }
+    return pathname.startsWith("/") ? pathname : `${layer.path}/${pathname}`.replace(/\/\/+/g, "/");
+  }
+  async go(path, options) {
+    for (const page of this.pages) {
+      if (page.name === path) {
+        path = page.path ?? "";
+        break;
+      }
+    }
+    await this.browser?.go(this.createHref(path, this.layer, options), options);
+  }
+  anchor(path, options = {}) {
+    for (const page of this.pages) {
+      if (page.name === path) {
+        path = page.path ?? "";
+        break;
+      }
+    }
+    const href = this.createHref(path, this.layer, options);
+    return {
+      href,
+      onClick: (ev) => {
+        ev.stopPropagation();
+        ev.preventDefault();
+        this.go(path, options).catch(console.error);
+      }
+    };
+  }
+  /**
+   * Set query params.
+   *
+   * @param record
+   * @param options
+   */
+  setQueryParams(record, options = {}) {
+    const func = typeof record === "function" ? record : () => record;
+    const search = new URLSearchParams(func(this.query)).toString();
+    const state = search ? `${this.pathname}?${search}` : this.pathname;
+    if (options.push) {
+      window.history.pushState({}, "", state);
+    } else {
+      window.history.replaceState({}, "", state);
+    }
+  }
+}
+
+const useRouter = () => {
+  const ctx = useContext(RouterContext);
+  const layer = useContext(RouterLayerContext);
+  if (!ctx || !layer) {
+    throw new Error("useRouter must be used within a RouterProvider");
+  }
+  const pages = useMemo(() => {
+    return ctx.alepha.get(PageDescriptorProvider).getPages();
+  }, []);
+  return useMemo(
+    () => new RouterHookApi(
+      pages,
+      ctx.state,
+      layer,
+      ctx.alepha.isBrowser() ? ctx.alepha.get(ReactBrowserProvider) : void 0
+    ),
+    [layer]
+  );
+};
+
+const Link = (props) => {
+  React.useContext(RouterContext);
+  const router = useRouter();
+  const to = typeof props.to === "string" ? props.to : props.to[OPTIONS].path;
+  if (!to) {
+    return null;
+  }
+  const can = typeof props.to === "string" ? void 0 : props.to[OPTIONS].can;
+  if (can && !can()) {
+    return null;
+  }
+  const name = typeof props.to === "string" ? void 0 : props.to[OPTIONS].name;
+  const anchorProps = {
+    ...props,
+    to: void 0
+  };
+  return /* @__PURE__ */ jsx("a", { ...router.anchor(to), ...anchorProps, children: props.children ?? name });
+};
+
+const useActive = (path) => {
+  const router = useRouter();
+  const ctx = useContext(RouterContext);
+  const layer = useContext(RouterLayerContext);
+  if (!ctx || !layer) {
+    throw new Error("useRouter must be used within a RouterProvider");
+  }
+  let name;
+  if (typeof path === "object" && path.options.name) {
+    name = path.options.name;
+  }
+  const [current, setCurrent] = useState(ctx.state.pathname);
+  const href = useMemo(() => router.createHref(path, layer), [path, layer]);
+  const [isPending, setPending] = useState(false);
+  const isActive = current === href;
+  useRouterEvents({
+    onEnd: ({ state }) => setCurrent(state.pathname)
+  });
+  return {
+    name,
+    isPending,
+    isActive,
+    anchorProps: {
+      href,
+      onClick: (ev) => {
+        ev.stopPropagation();
+        ev.preventDefault();
+        if (isActive) return;
+        if (isPending) return;
+        setPending(true);
+        router.go(href).then(() => {
+          setPending(false);
+        });
+      }
+    }
+  };
+};
+
+const useInject = (clazz) => {
+  const ctx = useContext(RouterContext);
+  if (!ctx) {
+    throw new Error("useRouter must be used within a <RouterProvider>");
+  }
+  return useMemo(() => ctx.alepha.get(clazz), []);
+};
+
+const useClient = (_scope) => {
+  return useInject(HttpClient).of();
+};
+
+const useQueryParams = (schema, options = {}) => {
+  const ctx = useContext(RouterContext);
+  if (!ctx) {
+    throw new Error("useQueryParams must be used within a RouterProvider");
+  }
+  const key = options.key ?? "q";
+  const router = useRouter();
+  const querystring = router.query[key];
+  const [queryParams, setQueryParams] = useState(
+    decode(ctx.alepha, schema, router.query[key])
+  );
+  useEffect(() => {
+    setQueryParams(decode(ctx.alepha, schema, querystring));
+  }, [querystring]);
+  return [
+    queryParams,
+    (queryParams2) => {
+      setQueryParams(queryParams2);
+      router.setQueryParams((data) => {
+        return { ...data, [key]: encode(ctx.alepha, schema, queryParams2) };
+      });
+    }
+  ];
+};
+const encode = (alepha, schema, data) => {
+  return btoa(JSON.stringify(alepha.parse(schema, data)));
+};
+const decode = (alepha, schema, data) => {
+  try {
+    return alepha.parse(schema, JSON.parse(atob(decodeURIComponent(data))));
+  } catch (_error) {
+    return {};
+  }
+};
+
+const useRouterState = () => {
+  const ctx = useContext(RouterContext);
+  const layer = useContext(RouterLayerContext);
+  if (!ctx || !layer) {
+    throw new Error("useRouter must be used within a RouterProvider");
+  }
+  const [state, setState] = useState(ctx.state);
+  useRouterEvents({
+    onEnd: ({ state: state2 }) => setState({ ...state2 })
+  });
+  return state;
+};
+
+export { $page as $, BrowserRouterProvider as B, ClientOnly as C, ErrorBoundary as E, Link as L, NestedView as N, PageDescriptorProvider as P, RouterContext as R, RouterLayerContext as a, RedirectionError as b, RouterHookApi as c, useAlepha as d, useClient as e, useInject as f, useQueryParams as g, useRouter as h, useRouterEvents as i, useRouterState as j, isPageRoute as k, ReactBrowserProvider as l, useActive as u };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@alepha/react",
-	"version": "0.7.4",
+	"version": "0.7.5",
 	"type": "module",
 	"license": "MIT",
 	"main": "./dist/index.js",
@@ -13,11 +13,11 @@
 		"src"
 	],
 	"dependencies": {
-		"@alepha/core": "0.7.4",
-		"@alepha/router": "0.7.4",
-		"@alepha/server": "0.7.4",
-		"@alepha/server-cache": "0.7.4",
-		"@alepha/server-static": "0.7.4",
+		"@alepha/core": "0.7.5",
+		"@alepha/router": "0.7.5",
+		"@alepha/server": "0.7.5",
+		"@alepha/server-cache": "0.7.5",
+		"@alepha/server-static": "0.7.5",
 		"react-dom": "^19.1.0"
 	},
 	"devDependencies": {

package/src/components/NotFound.tsx

@@ -15,16 +15,6 @@ export default function NotFoundPage() {
 			<h1 style={{ fontSize: "1rem", marginBottom: "0.5rem" }}>
 				This page does not exist
 			</h1>
-			<a
-				href="/"
-				style={{
-					fontSize: "0.7rem",
-					color: "#007bff",
-					textDecoration: "none",
-				}}
-			>
-				← Back to home
-			</a>
 		</div>
 	);
 }

package/src/descriptors/$page.ts

@@ -7,7 +7,8 @@ import {
 	type Static,
 	type TSchema,
 } from "@alepha/core";
-import type { ServerRequest, ServerRoute } from "@alepha/server";
+import type { ServerRequest } from "@alepha/server";
+import type { ServerRouteCache } from "@alepha/server-cache";
 import type { FC, ReactNode } from "react";
 import type { ClientOnlyProps } from "../components/ClientOnly.tsx";
 import type { PageReactContext } from "../providers/PageDescriptorProvider.ts";
@@ -27,7 +28,7 @@ export interface PageDescriptorOptions<
 	TConfig extends PageConfigSchema = PageConfigSchema,
 	TProps extends object = TPropsDefault,
 	TPropsParent extends object = TPropsParentDefault,
-> extends Pick<ServerRoute, "cache"> {
+> {
 	/**
 	 * Name your page.
 	 *
@@ -117,6 +118,8 @@ export interface PageDescriptorOptions<
 	client?: boolean | ClientOnlyProps;
 
 	afterHandler?: (request: ServerRequest) => any;
+
+	cache?: ServerRouteCache;
 }
 
 export interface PageDescriptor<

package/src/index.browser.ts

@@ -7,6 +7,7 @@ import { ReactBrowserRenderer } from "./providers/ReactBrowserRenderer.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
+export * from "./index.shared.ts";
 export * from "./providers/BrowserRouterProvider.ts";
 export * from "./providers/PageDescriptorProvider.ts";
 export * from "./providers/ReactBrowserProvider.ts";

package/src/index.shared.ts

@@ -3,14 +3,10 @@ export { default as ErrorBoundary } from "./components/ErrorBoundary.tsx";
 export * from "./components/ErrorViewer.tsx";
 export { default as Link } from "./components/Link.tsx";
 export { default as NestedView } from "./components/NestedView.tsx";
-
 export * from "./contexts/RouterContext.ts";
 export * from "./contexts/RouterLayerContext.ts";
-
 export * from "./descriptors/$page.ts";
-
 export * from "./errors/RedirectionError.ts";
-
 export * from "./hooks/RouterHookApi.ts";
 export * from "./hooks/useActive.ts";
 export * from "./hooks/useAlepha.ts";

package/src/index.ts

@@ -13,8 +13,6 @@ import { ReactServerProvider } from "./providers/ReactServerProvider.ts";
 
 // ---------------------------------------------------------------------------------------------------------------------
 
-export { default as NestedView } from "./components/NestedView.tsx";
-export * from "./errors/RedirectionError.ts";
 export * from "./index.shared.ts";
 export * from "./providers/PageDescriptorProvider.ts";
 export * from "./providers/ReactBrowserProvider.ts";