@ossido-labs/ossido-router 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Chris Schofield
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# ossido-router
+
+This package holds the logic related to the client/server react routing.
+
+Check [ossido](https://github.com/ossido-labs/ossido) for more.

package/dist/esm/components/CriticalCss.d.ts

@@ -0,0 +1,13 @@
+import type { JSX } from 'react';
+import type { Mode } from '../types';
+interface CriticalCssProps {
+    routeFilePath?: string;
+    mode?: Mode;
+}
+/**
+ * Returns the critical CSS for the given route
+ * This is required in order to avoid FOUC during development
+ * since vite does not support CSS injection without JS waterfall
+ */
+export declare function CriticalCss({ routeFilePath, mode, }: CriticalCssProps): JSX.Element | null;
+export {};

package/dist/esm/components/CriticalCss.js

@@ -0,0 +1,22 @@
+import { jsx } from "react/jsx-runtime";
+
+//#region src/components/CriticalCss.tsx
+const CRITICAL_CSS_PATH = "/vite-server/ossido_internal__critical_css";
+const CRITICAL_CSS_ENABLED = typeof __OSSIDO_CRITICAL_CSS__ === "undefined" || __OSSIDO_CRITICAL_CSS__;
+/**
+* Returns the critical CSS for the given route
+* This is required in order to avoid FOUC during development
+* since vite does not support CSS injection without JS waterfall
+*/
+function CriticalCss({ routeFilePath, mode }) {
+	if (!CRITICAL_CSS_ENABLED || !routeFilePath || mode !== "Dev") return null;
+	return /* @__PURE__ */ jsx("link", {
+		href: `${CRITICAL_CSS_PATH}?componentId=${routeFilePath}`,
+		precedence: "high",
+		rel: "stylesheet"
+	});
+}
+
+//#endregion
+export { CriticalCss };
+//# sourceMappingURL=CriticalCss.js.map

package/dist/esm/components/CriticalCss.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CriticalCss.js","names":[],"sources":["../../../src/components/CriticalCss.tsx"],"sourcesContent":["import type { JSX } from 'react';\n\nimport type { Mode } from '../types';\n\nconst VITE_PROXY_PATH = '/vite-server';\nconst CRITICAL_CSS_PATH = VITE_PROXY_PATH + '/ossido_internal__critical_css';\n\n/**\n * Baked in by the vite `define` in ossido's build config, mirroring the\n * `dev.criticalCss` option. When the user disables critical CSS the vite\n * endpoint is disabled too, so the links must not render (they would be dead,\n * render-blocking requests). The `typeof` guard keeps this safe under\n * vitest/tsdown where the define is not applied.\n */\ndeclare const __OSSIDO_CRITICAL_CSS__: boolean;\nconst CRITICAL_CSS_ENABLED =\n  typeof __OSSIDO_CRITICAL_CSS__ === 'undefined' || __OSSIDO_CRITICAL_CSS__;\n\ninterface CriticalCssProps {\n  routeFilePath?: string;\n  mode?: Mode;\n}\n\n/**\n * Returns the critical CSS for the given route\n * This is required in order to avoid FOUC during development\n * since vite does not support CSS injection without JS waterfall\n */\nexport function CriticalCss({\n  routeFilePath,\n  mode,\n}: CriticalCssProps): JSX.Element | null {\n  if (!CRITICAL_CSS_ENABLED || !routeFilePath || mode !== 'Dev') {\n    return null;\n  }\n\n  return (\n    <link\n      href={`${CRITICAL_CSS_PATH}?componentId=${routeFilePath}`}\n      precedence=\"high\"\n      rel=\"stylesheet\"\n    />\n  );\n}\n"],"mappings":";;;AAKA,MAAM,oBAAoB;AAU1B,MAAM,uBACJ,OAAO,4BAA4B,eAAe;;;;;;AAYpD,SAAgB,YAAY,EAC1B,eACA,QACuC;CACvC,IAAI,CAAC,wBAAwB,CAAC,iBAAiB,SAAS,OACtD,OAAO;CAGT,OACE,oBAAC,QAAD;EACE,MAAM,GAAG,kBAAkB,eAAe;EAC1C,YAAW;EACX,KAAI;CACL;AAEL"}

package/dist/esm/components/Link.d.ts

@@ -0,0 +1,30 @@
+import type { JSX, Ref } from 'react';
+interface OssidoLinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {
+    /**
+     * If "true" the route gets loaded when the link enters the viewport.
+     * @default true
+     */
+    preload?: boolean;
+    /**
+     * If "false" the scroll offset will be kept across page navigation.
+     * @default true
+     */
+    scroll?: boolean;
+    /**
+     * If "true" the history entry will be replaced instead of pushed.
+     * @default false
+     */
+    replace?: boolean;
+    /**
+     * Override the app's `viewTransitions` config for this link: `true` forces a
+     * View Transition, `false` skips it. Defaults to the config value.
+     */
+    viewTransition?: boolean;
+    /**
+     * Forwarded to the underlying `<a>`, merged with the internal preload ref.
+     * Lets wrappers (e.g. react-aria's `render`) connect their own ref.
+     */
+    ref?: Ref<HTMLAnchorElement>;
+}
+export declare function Link(componentProps: OssidoLinkProps): JSX.Element;
+export {};

package/dist/esm/components/Link.js

@@ -0,0 +1,47 @@
+import { useRoute } from "../hooks/useRoute.js";
+import { useRouter } from "../hooks/useRouter.js";
+import { useCallback } from "react";
+import { jsx } from "react/jsx-runtime";
+import { useInView } from "react-intersection-observer";
+
+//#region src/components/Link.tsx
+function isEventModifierKeyActiveAndTargetDifferentFromSelf(event) {
+	const target = event.currentTarget.getAttribute("target");
+	return target && target !== "_self" || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey;
+}
+function Link(componentProps) {
+	const { preload = true, scroll = true, children, href, replace, viewTransition, onClick, ref: forwardedRef, ...rest } = componentProps;
+	const router = useRouter();
+	const route = useRoute(href);
+	const { ref: inViewRef } = useInView({
+		onChange(inView) {
+			if (inView && preload) route?.component.preload?.();
+		},
+		triggerOnce: true
+	});
+	const setRef = useCallback((node) => {
+		inViewRef(node);
+		if (typeof forwardedRef === "function") forwardedRef(node);
+		else if (forwardedRef) forwardedRef.current = node;
+	}, [inViewRef, forwardedRef]);
+	const handleTransition = (event) => {
+		onClick?.(event);
+		if (href?.startsWith("#") || isEventModifierKeyActiveAndTargetDifferentFromSelf(event)) return;
+		event.preventDefault();
+		router[replace ? "replace" : "push"](href || "", {
+			scroll,
+			viewTransition
+		});
+	};
+	return /* @__PURE__ */ jsx("a", {
+		...rest,
+		href,
+		ref: setRef,
+		onClick: handleTransition,
+		children
+	});
+}
+
+//#endregion
+export { Link };
+//# sourceMappingURL=Link.js.map

package/dist/esm/components/Link.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Link.js","names":[],"sources":["../../../src/components/Link.tsx"],"sourcesContent":["import type { JSX, MouseEvent, Ref } from 'react';\nimport { useCallback } from 'react';\nimport { useInView } from 'react-intersection-observer';\n\nimport { useRouter } from '../hooks/useRouter';\nimport { useRoute } from '../hooks/useRoute';\n\ninterface OssidoLinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement> {\n  /**\n   * If \"true\" the route gets loaded when the link enters the viewport.\n   * @default true\n   */\n  preload?: boolean;\n\n  /**\n   * If \"false\" the scroll offset will be kept across page navigation.\n   * @default true\n   */\n  scroll?: boolean;\n\n  /**\n   * If \"true\" the history entry will be replaced instead of pushed.\n   * @default false\n   */\n  replace?: boolean;\n\n  /**\n   * Override the app's `viewTransitions` config for this link: `true` forces a\n   * View Transition, `false` skips it. Defaults to the config value.\n   */\n  viewTransition?: boolean;\n\n  /**\n   * Forwarded to the underlying `<a>`, merged with the internal preload ref.\n   * Lets wrappers (e.g. react-aria's `render`) connect their own ref.\n   */\n  ref?: Ref<HTMLAnchorElement>;\n}\n\nfunction isEventModifierKeyActiveAndTargetDifferentFromSelf(\n  event: MouseEvent<HTMLAnchorElement>,\n): boolean {\n  const target = event.currentTarget.getAttribute('target');\n  return (\n    (target && target !== '_self') ||\n    event.metaKey ||\n    event.ctrlKey ||\n    event.shiftKey ||\n    event.altKey // triggers resource download\n  );\n}\n\nexport function Link(componentProps: OssidoLinkProps): JSX.Element {\n  const {\n    preload = true,\n    scroll = true,\n    children,\n    href,\n    replace,\n    viewTransition,\n    onClick,\n    ref: forwardedRef,\n    ...rest\n  } = componentProps;\n\n  const router = useRouter();\n  const route = useRoute(href);\n  const { ref: inViewRef } = useInView({\n    onChange(inView) {\n      if (inView && preload) route?.component.preload?.();\n    },\n    triggerOnce: true,\n  });\n\n  // Merge the caller's ref (e.g. from react-aria's `render`) with the internal\n  // in-view ref, so both receive the underlying `<a>` node. Memoised so the\n  // callback ref identity is stable across renders.\n  const setRef = useCallback(\n    (node: HTMLAnchorElement | null): void => {\n      inViewRef(node);\n      if (typeof forwardedRef === 'function') {\n        forwardedRef(node);\n      } else if (forwardedRef) {\n        forwardedRef.current = node;\n      }\n    },\n    [inViewRef, forwardedRef],\n  );\n\n  const handleTransition: React.MouseEventHandler<HTMLAnchorElement> = (\n    event,\n  ) => {\n    onClick?.(event);\n\n    if (\n      href?.startsWith('#') ||\n      // If the user is pressing a modifier key or using the target attribute,\n      // we fall back to default behaviour of `a` tag\n      isEventModifierKeyActiveAndTargetDifferentFromSelf(event)\n    ) {\n      return;\n    }\n\n    event.preventDefault();\n\n    const method = replace ? 'replace' : 'push';\n\n    router[method](href || '', { scroll, viewTransition });\n  };\n\n  return (\n    <a {...rest} href={href} ref={setRef} onClick={handleTransition}>\n      {children}\n    </a>\n  );\n}\n"],"mappings":";;;;;;;AAuCA,SAAS,mDACP,OACS;CACT,MAAM,SAAS,MAAM,cAAc,aAAa,QAAQ;CACxD,OACG,UAAU,WAAW,WACtB,MAAM,WACN,MAAM,WACN,MAAM,YACN,MAAM;AAEV;AAEA,SAAgB,KAAK,gBAA8C;CACjE,MAAM,EACJ,UAAU,MACV,SAAS,MACT,UACA,MACA,SACA,gBACA,SACA,KAAK,cACL,GAAG,SACD;CAEJ,MAAM,SAAS,UAAU;CACzB,MAAM,QAAQ,SAAS,IAAI;CAC3B,MAAM,EAAE,KAAK,cAAc,UAAU;EACnC,SAAS,QAAQ;GACf,IAAI,UAAU,SAAS,OAAO,UAAU,UAAU;EACpD;EACA,aAAa;CACf,CAAC;CAKD,MAAM,SAAS,aACZ,SAAyC;EACxC,UAAU,IAAI;EACd,IAAI,OAAO,iBAAiB,YAC1B,aAAa,IAAI;OACZ,IAAI,cACT,aAAa,UAAU;CAE3B,GACA,CAAC,WAAW,YAAY,CAC1B;CAEA,MAAM,oBACJ,UACG;EACH,UAAU,KAAK;EAEf,IACE,MAAM,WAAW,GAAG,KAGpB,mDAAmD,KAAK,GAExD;EAGF,MAAM,eAAe;EAIrB,OAFe,UAAU,YAAY,OAEvB,CAAC,QAAQ,IAAI;GAAE;GAAQ;EAAe,CAAC;CACvD;CAEA,OACE,oBAAC,KAAD;EAAG,GAAI;EAAY;EAAM,KAAK;EAAQ,SAAS;EAC5C;CACA;AAEP"}

package/dist/esm/components/Matches.d.ts

@@ -0,0 +1,7 @@
+import type { JSX } from 'react';
+import type { Mode } from '../types';
+interface MatchesProps {
+    mode?: Mode;
+}
+export declare function Matches({ mode }: MatchesProps): JSX.Element;
+export {};

package/dist/esm/components/Matches.js

@@ -0,0 +1,22 @@
+import { useRouterContext } from "./RouterContext.js";
+import { useRoute } from "../hooks/useRoute.js";
+import { useRouteHotVersion } from "../hot.js";
+import { RouteMatch } from "./RouteMatch.js";
+import { NotFound } from "./NotFound.js";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/components/Matches.tsx
+function Matches({ mode }) {
+	const { location } = useRouterContext();
+	useRouteHotVersion();
+	const route = useRoute(location.pathname);
+	if (!route) return /* @__PURE__ */ jsx(NotFound, { mode });
+	return /* @__PURE__ */ jsx(RouteMatch, {
+		route,
+		mode
+	});
+}
+
+//#endregion
+export { Matches };
+//# sourceMappingURL=Matches.js.map

package/dist/esm/components/Matches.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Matches.js","names":[],"sources":["../../../src/components/Matches.tsx"],"sourcesContent":["import type { JSX } from 'react';\n\nimport { useRoute } from '../hooks/useRoute';\n\nimport type { Mode } from '../types';\nimport { useRouteHotVersion } from '../hot';\n\nimport { RouteMatch } from './RouteMatch';\nimport { NotFound } from './NotFound';\nimport { useRouterContext } from './RouterContext';\n\ninterface MatchesProps {\n  mode?: Mode;\n}\n\nexport function Matches({ mode }: MatchesProps): JSX.Element {\n  const { location } = useRouterContext();\n\n  // Dev-only: re-render the whole match tree when a route component is\n  // hot-swapped (see `../hot`). Inert in prod — the store is never bumped.\n  useRouteHotVersion();\n\n  const route = useRoute(location.pathname);\n\n  if (!route) {\n    return <NotFound mode={mode} />;\n  }\n\n  return <RouteMatch route={route} mode={mode} />;\n}\n"],"mappings":";;;;;;;;AAeA,SAAgB,QAAQ,EAAE,QAAmC;CAC3D,MAAM,EAAE,aAAa,iBAAiB;CAItC,mBAAmB;CAEnB,MAAM,QAAQ,SAAS,SAAS,QAAQ;CAExC,IAAI,CAAC,OACH,OAAO,oBAAC,UAAD,EAAgB,KAAO;CAGhC,OAAO,oBAAC,YAAD;EAAmB;EAAa;CAAO;AAChD"}

package/dist/esm/components/NotFound.d.ts

@@ -0,0 +1,5 @@
+import type { JSX } from 'react';
+import type { Mode } from '../types';
+export declare function NotFound({ mode }: {
+    mode?: Mode;
+}): JSX.Element | null;

package/dist/esm/components/NotFound.js

@@ -0,0 +1,22 @@
+import { useRouterContext } from "./RouterContext.js";
+import { CriticalCss } from "./CriticalCss.js";
+import { ROOT_ROUTE_ID } from "../route.js";
+import { NotFoundDefaultContent } from "./NotFoundDefaultContent.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/components/NotFound.tsx
+function NotFound({ mode }) {
+	const { router } = useRouterContext();
+	const rootRoute = router.routesById[ROOT_ROUTE_ID];
+	const RootLayout = rootRoute?.component;
+	if (!RootLayout) return null;
+	const CustomNotFound = rootRoute?.options.notFoundComponent;
+	return /* @__PURE__ */ jsxs(RootLayout, { children: [/* @__PURE__ */ jsx(CriticalCss, {
+		routeFilePath: "__root__",
+		mode
+	}), CustomNotFound ? /* @__PURE__ */ jsx(CustomNotFound, {}) : /* @__PURE__ */ jsx(NotFoundDefaultContent, {})] });
+}
+
+//#endregion
+export { NotFound };
+//# sourceMappingURL=NotFound.js.map

package/dist/esm/components/NotFound.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotFound.js","names":[],"sources":["../../../src/components/NotFound.tsx"],"sourcesContent":["import type { JSX } from 'react';\n\nimport { useRouterContext } from '../components/RouterContext';\nimport { ROOT_ROUTE_ID } from '../route';\n\nimport type { Mode } from '../types';\n\nimport { NotFoundDefaultContent } from './NotFoundDefaultContent';\nimport { CriticalCss } from './CriticalCss';\n\nexport function NotFound({ mode }: { mode?: Mode }): JSX.Element | null {\n  const { router } = useRouterContext();\n\n  const rootRoute = router.routesById[ROOT_ROUTE_ID];\n  const RootLayout = rootRoute?.component;\n\n  if (!RootLayout) return null;\n\n  // The global not-found is the root `not-found.tsx`, rendered inside the root\n  // layout (Next.js semantics). Falls back to the framework default.\n  const CustomNotFound = rootRoute?.options.notFoundComponent;\n\n  return (\n    <RootLayout>\n      <CriticalCss routeFilePath=\"__root__\" mode={mode} />\n      {CustomNotFound ? <CustomNotFound /> : <NotFoundDefaultContent />}\n    </RootLayout>\n  );\n}\n"],"mappings":";;;;;;;AAUA,SAAgB,SAAS,EAAE,QAA6C;CACtE,MAAM,EAAE,WAAW,iBAAiB;CAEpC,MAAM,YAAY,OAAO,WAAW;CACpC,MAAM,aAAa,WAAW;CAE9B,IAAI,CAAC,YAAY,OAAO;CAIxB,MAAM,iBAAiB,WAAW,QAAQ;CAE1C,OACE,qBAAC,YAAD,aACE,oBAAC,aAAD;EAAa,eAAc;EAAiB;CAAO,IAClD,iBAAiB,oBAAC,gBAAD,CAAiB,KAAI,oBAAC,wBAAD,CAAyB,EACtD;AAEhB"}

package/dist/esm/components/NotFoundDefaultContent.d.ts

@@ -0,0 +1,7 @@
+import type { JSX } from 'react';
+/**
+ * Framework default 404 page, shown when no route matches and the app provides
+ * no `/404` route. Shares the {@link DefaultScreen} shell with
+ * {@link DefaultError} so the two default screens look consistent.
+ */
+export declare function NotFoundDefaultContent(): JSX.Element;

package/dist/esm/components/NotFoundDefaultContent.js

@@ -0,0 +1,29 @@
+import { Link } from "./Link.js";
+import { DefaultScreen } from "@ossido-labs/ossido-ui";
+import { jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/components/NotFoundDefaultContent.tsx
+/**
+* Framework default 404 page, shown when no route matches and the app provides
+* no `/404` route. Shares the {@link DefaultScreen} shell with
+* {@link DefaultError} so the two default screens look consistent.
+*/
+function NotFoundDefaultContent() {
+	return /* @__PURE__ */ jsxs(DefaultScreen, {
+		role: "status",
+		badge: "404",
+		title: "Page not found",
+		children: [/* @__PURE__ */ jsx("p", {
+			className: "ossido-screen-text",
+			children: "The page you’re looking for doesn’t exist or may have moved."
+		}), /* @__PURE__ */ jsx(Link, {
+			href: "/",
+			className: "ossido-screen-action",
+			children: "Return to homepage"
+		})]
+	});
+}
+
+//#endregion
+export { NotFoundDefaultContent };
+//# sourceMappingURL=NotFoundDefaultContent.js.map

package/dist/esm/components/NotFoundDefaultContent.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NotFoundDefaultContent.js","names":[],"sources":["../../../src/components/NotFoundDefaultContent.tsx"],"sourcesContent":["import type { JSX } from 'react';\nimport { DefaultScreen } from '@ossido-labs/ossido-ui';\n\nimport { Link } from './Link';\n\n/**\n * Framework default 404 page, shown when no route matches and the app provides\n * no `/404` route. Shares the {@link DefaultScreen} shell with\n * {@link DefaultError} so the two default screens look consistent.\n */\nexport function NotFoundDefaultContent(): JSX.Element {\n  return (\n    <DefaultScreen role=\"status\" badge=\"404\" title=\"Page not found\">\n      <p className=\"ossido-screen-text\">\n        The page you’re looking for doesn’t exist or may have moved.\n      </p>\n      <Link href=\"/\" className=\"ossido-screen-action\">\n        Return to homepage\n      </Link>\n    </DefaultScreen>\n  );\n}\n"],"mappings":";;;;;;;;;;AAUA,SAAgB,yBAAsC;CACpD,OACE,qBAAC,eAAD;EAAe,MAAK;EAAS,OAAM;EAAM,OAAM;YAA/C,CACE,oBAAC,KAAD;GAAG,WAAU;aAAqB;EAE/B,IACH,oBAAC,MAAD;GAAM,MAAK;GAAI,WAAU;aAAuB;EAE1C,EACO;;AAEnB"}

package/dist/esm/components/OssidoErrorBoundary.d.ts

@@ -0,0 +1,39 @@
+import { Component } from 'react';
+import type { ReactNode } from 'react';
+import type { ErrorComponent } from '../types';
+interface OssidoErrorBoundaryProps {
+    fallback: ErrorComponent;
+    /**
+     * Changes per navigation/retry (the route's data-resource key). When it
+     * changes the boundary clears any caught error and re-renders its children —
+     * a reset without remounting. Not remounting matters: the surrounding
+     * `<Suspense>` stays mounted, so a navigation (whose data + code are already
+     * prefetched) swaps straight to the new page instead of flashing the fallback.
+     */
+    resetKey: string;
+    /**
+     * Called by the fallback's `reset`. It bumps the navigation id (which changes
+     * `resetKey`), clearing the error and creating a fresh data resource.
+     */
+    onReset: () => void;
+    children: ReactNode;
+}
+interface OssidoErrorBoundaryState {
+    error: Error | null;
+    resetKey: string;
+}
+/**
+ * Renders the nearest `error.tsx` (or the framework default) when a descendant
+ * throws — including a rejected data resource surfaced through `use()`.
+ *
+ * Resets via {@link OssidoErrorBoundaryProps.resetKey} rather than a `key` from
+ * the caller, so its children re-render (not remount) on navigation.
+ */
+export declare class OssidoErrorBoundary extends Component<OssidoErrorBoundaryProps, OssidoErrorBoundaryState> {
+    state: OssidoErrorBoundaryState;
+    static getDerivedStateFromError(error: Error): Partial<OssidoErrorBoundaryState>;
+    static getDerivedStateFromProps(props: OssidoErrorBoundaryProps, state: OssidoErrorBoundaryState): Partial<OssidoErrorBoundaryState> | null;
+    reset: () => void;
+    render(): ReactNode;
+}
+export {};

package/dist/esm/components/OssidoErrorBoundary.js

@@ -0,0 +1,48 @@
+import { Component } from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/components/OssidoErrorBoundary.tsx
+/**
+* Renders the nearest `error.tsx` (or the framework default) when a descendant
+* throws — including a rejected data resource surfaced through `use()`.
+*
+* Resets via {@link OssidoErrorBoundaryProps.resetKey} rather than a `key` from
+* the caller, so its children re-render (not remount) on navigation.
+*/
+var OssidoErrorBoundary = class extends Component {
+	constructor(..._args) {
+		super(..._args);
+		this.state = {
+			error: null,
+			resetKey: this.props.resetKey
+		};
+		this.reset = () => {
+			this.props.onReset();
+		};
+	}
+	static getDerivedStateFromError(error) {
+		return { error };
+	}
+	static getDerivedStateFromProps(props, state) {
+		if (props.resetKey !== state.resetKey) return {
+			error: null,
+			resetKey: props.resetKey
+		};
+		return null;
+	}
+	render() {
+		const { error } = this.state;
+		if (error) {
+			const Fallback = this.props.fallback;
+			return /* @__PURE__ */ jsx(Fallback, {
+				error,
+				reset: this.reset
+			});
+		}
+		return this.props.children;
+	}
+};
+
+//#endregion
+export { OssidoErrorBoundary };
+//# sourceMappingURL=OssidoErrorBoundary.js.map

package/dist/esm/components/OssidoErrorBoundary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OssidoErrorBoundary.js","names":[],"sources":["../../../src/components/OssidoErrorBoundary.tsx"],"sourcesContent":["import { Component } from 'react';\nimport type { ReactNode } from 'react';\n\nimport type { ErrorComponent } from '../types';\n\ninterface OssidoErrorBoundaryProps {\n  fallback: ErrorComponent;\n  /**\n   * Changes per navigation/retry (the route's data-resource key). When it\n   * changes the boundary clears any caught error and re-renders its children —\n   * a reset without remounting. Not remounting matters: the surrounding\n   * `<Suspense>` stays mounted, so a navigation (whose data + code are already\n   * prefetched) swaps straight to the new page instead of flashing the fallback.\n   */\n  resetKey: string;\n  /**\n   * Called by the fallback's `reset`. It bumps the navigation id (which changes\n   * `resetKey`), clearing the error and creating a fresh data resource.\n   */\n  onReset: () => void;\n  children: ReactNode;\n}\n\ninterface OssidoErrorBoundaryState {\n  error: Error | null;\n  resetKey: string;\n}\n\n/**\n * Renders the nearest `error.tsx` (or the framework default) when a descendant\n * throws — including a rejected data resource surfaced through `use()`.\n *\n * Resets via {@link OssidoErrorBoundaryProps.resetKey} rather than a `key` from\n * the caller, so its children re-render (not remount) on navigation.\n */\nexport class OssidoErrorBoundary extends Component<\n  OssidoErrorBoundaryProps,\n  OssidoErrorBoundaryState\n> {\n  state: OssidoErrorBoundaryState = {\n    error: null,\n    resetKey: this.props.resetKey,\n  };\n\n  static getDerivedStateFromError(\n    error: Error,\n  ): Partial<OssidoErrorBoundaryState> {\n    return { error };\n  }\n\n  static getDerivedStateFromProps(\n    props: OssidoErrorBoundaryProps,\n    state: OssidoErrorBoundaryState,\n  ): Partial<OssidoErrorBoundaryState> | null {\n    // A new navigation/retry: drop the caught error and try the children again.\n    if (props.resetKey !== state.resetKey) {\n      return { error: null, resetKey: props.resetKey };\n    }\n    return null;\n  }\n\n  reset = (): void => {\n    // Bumps the navigation id → `resetKey` changes → the error is cleared and a\n    // fresh data resource is created (a refetch).\n    this.props.onReset();\n  };\n\n  render(): ReactNode {\n    const { error } = this.state;\n    if (error) {\n      const Fallback = this.props.fallback;\n      return <Fallback error={error} reset={this.reset} />;\n    }\n    return this.props.children;\n  }\n}\n"],"mappings":";;;;;;;;;;;AAmCA,IAAa,sBAAb,cAAyC,UAGvC;;;eACkC;GAChC,OAAO;GACP,UAAU,KAAK,MAAM;EACvB;qBAmBoB;GAGlB,KAAK,MAAM,QAAQ;EACrB;;CArBA,OAAO,yBACL,OACmC;EACnC,OAAO,EAAE,MAAM;CACjB;CAEA,OAAO,yBACL,OACA,OAC0C;EAE1C,IAAI,MAAM,aAAa,MAAM,UAC3B,OAAO;GAAE,OAAO;GAAM,UAAU,MAAM;EAAS;EAEjD,OAAO;CACT;CAQA,SAAoB;EAClB,MAAM,EAAE,UAAU,KAAK;EACvB,IAAI,OAAO;GACT,MAAM,WAAW,KAAK,MAAM;GAC5B,OAAO,oBAAC,UAAD;IAAiB;IAAO,OAAO,KAAK;GAAQ;EACrD;EACA,OAAO,KAAK,MAAM;CACpB;AACF"}

package/dist/esm/components/Redirect.d.ts

@@ -0,0 +1,11 @@
+interface RedirectProps {
+    to: string;
+}
+/**
+ * Performs a client-side redirect (returned from a route's data load) in an
+ * effect — never during render, since navigation is a side effect and the app
+ * renders under `StrictMode`. Uses `replace` so the redirecting URL does not
+ * become a back-button trap.
+ */
+export declare function Redirect({ to }: RedirectProps): null;
+export {};

package/dist/esm/components/Redirect.js

@@ -0,0 +1,21 @@
+import { useRouter } from "../hooks/useRouter.js";
+import { useEffect } from "react";
+
+//#region src/components/Redirect.tsx
+/**
+* Performs a client-side redirect (returned from a route's data load) in an
+* effect — never during render, since navigation is a side effect and the app
+* renders under `StrictMode`. Uses `replace` so the redirecting URL does not
+* become a back-button trap.
+*/
+function Redirect({ to }) {
+	const { replace } = useRouter();
+	useEffect(() => {
+		replace(to);
+	}, [replace, to]);
+	return null;
+}
+
+//#endregion
+export { Redirect };
+//# sourceMappingURL=Redirect.js.map

package/dist/esm/components/Redirect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Redirect.js","names":[],"sources":["../../../src/components/Redirect.tsx"],"sourcesContent":["import { useEffect } from 'react';\n\nimport { useRouter } from '../hooks/useRouter';\n\ninterface RedirectProps {\n  to: string;\n}\n\n/**\n * Performs a client-side redirect (returned from a route's data load) in an\n * effect — never during render, since navigation is a side effect and the app\n * renders under `StrictMode`. Uses `replace` so the redirecting URL does not\n * become a back-button trap.\n */\nexport function Redirect({ to }: RedirectProps): null {\n  const { replace } = useRouter();\n\n  useEffect(() => {\n    replace(to);\n  }, [replace, to]);\n\n  return null;\n}\n"],"mappings":";;;;;;;;;;AAcA,SAAgB,SAAS,EAAE,MAA2B;CACpD,MAAM,EAAE,YAAY,UAAU;CAE9B,gBAAgB;EACd,QAAQ,EAAE;CACZ,GAAG,CAAC,SAAS,EAAE,CAAC;CAEhB,OAAO;AACT"}

package/dist/esm/components/RouteDataLoader.d.ts

@@ -0,0 +1,21 @@
+import type { JSX } from 'react';
+import type { Route } from '../route';
+import type { ParsedLocation } from './RouterContext';
+interface RouteDataLoaderProps {
+    route: Route;
+    resourceKey: string;
+    location: ParsedLocation;
+}
+/**
+ * Reads the route's server data resource via `use()`. On the initial render the
+ * resource is pre-seeded (SSR data) so this resolves synchronously; on client
+ * navigation it suspends until the fetch settles, showing the `<Suspense>`
+ * fallback (`loading.tsx`). A rejected resource is re-thrown by `use()` and
+ * caught by the surrounding error boundary (`error.tsx`).
+ *
+ * The route's critical CSS is intentionally rendered by `RouteMatch` OUTSIDE
+ * the `<Suspense>` boundary (see the note there) — a `precedence` stylesheet
+ * inside the boundary would defer its streamed reveal.
+ */
+export declare function RouteDataLoader({ route, resourceKey, location, }: RouteDataLoaderProps): JSX.Element;
+export {};

package/dist/esm/components/RouteDataLoader.js

@@ -0,0 +1,27 @@
+import { getOrCreateResource } from "../data/resourceCache.js";
+import { Redirect } from "./Redirect.js";
+import { use } from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/components/RouteDataLoader.tsx
+/**
+* Reads the route's server data resource via `use()`. On the initial render the
+* resource is pre-seeded (SSR data) so this resolves synchronously; on client
+* navigation it suspends until the fetch settles, showing the `<Suspense>`
+* fallback (`loading.tsx`). A rejected resource is re-thrown by `use()` and
+* caught by the surrounding error boundary (`error.tsx`).
+*
+* The route's critical CSS is intentionally rendered by `RouteMatch` OUTSIDE
+* the `<Suspense>` boundary (see the note there) — a `precedence` stylesheet
+* inside the boundary would defer its streamed reveal.
+*/
+function RouteDataLoader({ route, resourceKey, location }) {
+	const result = use(getOrCreateResource(resourceKey, route, location));
+	if (result.kind === "redirect") return /* @__PURE__ */ jsx(Redirect, { to: result.destination });
+	const Component = route.component;
+	return /* @__PURE__ */ jsx(Component, { ...result.props });
+}
+
+//#endregion
+export { RouteDataLoader };
+//# sourceMappingURL=RouteDataLoader.js.map

package/dist/esm/components/RouteDataLoader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RouteDataLoader.js","names":[],"sources":["../../../src/components/RouteDataLoader.tsx"],"sourcesContent":["import { use } from 'react';\nimport type { JSX } from 'react';\n\nimport type { Route } from '../route';\nimport { getOrCreateResource } from '../data/resourceCache';\n\nimport type { ParsedLocation } from './RouterContext';\nimport { Redirect } from './Redirect';\n\ninterface RouteDataLoaderProps {\n  route: Route;\n  resourceKey: string;\n  location: ParsedLocation;\n}\n\n/**\n * Reads the route's server data resource via `use()`. On the initial render the\n * resource is pre-seeded (SSR data) so this resolves synchronously; on client\n * navigation it suspends until the fetch settles, showing the `<Suspense>`\n * fallback (`loading.tsx`). A rejected resource is re-thrown by `use()` and\n * caught by the surrounding error boundary (`error.tsx`).\n *\n * The route's critical CSS is intentionally rendered by `RouteMatch` OUTSIDE\n * the `<Suspense>` boundary (see the note there) — a `precedence` stylesheet\n * inside the boundary would defer its streamed reveal.\n */\nexport function RouteDataLoader({\n  route,\n  resourceKey,\n  location,\n}: RouteDataLoaderProps): JSX.Element {\n  const result = use(getOrCreateResource(resourceKey, route, location));\n\n  if (result.kind === 'redirect') {\n    return <Redirect to={result.destination} />;\n  }\n\n  const Component = route.component;\n\n  // Server data is spread directly as the page component's props.\n  return <Component {...result.props} />;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AA0BA,SAAgB,gBAAgB,EAC9B,OACA,aACA,YACoC;CACpC,MAAM,SAAS,IAAI,oBAAoB,aAAa,OAAO,QAAQ,CAAC;CAEpE,IAAI,OAAO,SAAS,YAClB,OAAO,oBAAC,UAAD,EAAU,IAAI,OAAO,YAAc;CAG5C,MAAM,YAAY,MAAM;CAGxB,OAAO,oBAAC,WAAD,EAAW,GAAI,OAAO,MAAQ;AACvC"}

package/dist/esm/components/RouteMatch.d.ts

@@ -0,0 +1,15 @@
+import type { JSX } from 'react';
+import type { Mode } from '../types';
+import type { Route } from '../route';
+interface RouteMatchProps {
+    route: Route;
+    mode?: Mode;
+}
+/**
+ * Renders the matched route: its parent layouts wrap an error boundary +
+ * `<Suspense>` boundary around the data-reading leaf. The boundary is keyed by
+ * the data-resource key so a navigation (including same-route param changes)
+ * remounts it and shows the loading fallback, while the layouts persist.
+ */
+export declare const RouteMatch: ({ route, mode }: RouteMatchProps) => JSX.Element;
+export {};

package/dist/esm/components/RouteMatch.js

@@ -0,0 +1,81 @@
+import { buildResourceKey, readLayoutData } from "../data/resourceCache.js";
+import { useRouterContext } from "./RouterContext.js";
+import { CriticalCss } from "./CriticalCss.js";
+import { RouteDataLoader } from "./RouteDataLoader.js";
+import { OssidoErrorBoundary } from "./OssidoErrorBoundary.js";
+import { Suspense, memo, useMemo } from "react";
+import { DefaultError, DefaultLoading, DevErrorReporter } from "@ossido-labs/ossido-ui";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+
+//#region src/components/RouteMatch.tsx
+/**
+* Renders the matched route: its parent layouts wrap an error boundary +
+* `<Suspense>` boundary around the data-reading leaf. The boundary is keyed by
+* the data-resource key so a navigation (including same-route param changes)
+* remounts it and shows the loading fallback, while the layouts persist.
+*/
+const RouteMatch = ({ route, mode }) => {
+	const { location, navigationId, retry } = useRouterContext();
+	const routes = useMemo(() => loadParentComponents(route), [route.id]);
+	const resourceKey = buildResourceKey(navigationId, location);
+	const LoadingComponent = route.options.loadingComponent ?? DefaultLoading;
+	const ErrorComponent = route.options.errorComponent ?? (mode === "Dev" ? DevErrorReporter : DefaultError);
+	return /* @__PURE__ */ jsxs(TraverseRootComponents, {
+		routes,
+		mode,
+		children: [/* @__PURE__ */ jsx(CriticalCss, {
+			routeFilePath: route.filePath,
+			mode
+		}), /* @__PURE__ */ jsx(Suspense, {
+			fallback: /* @__PURE__ */ jsx(LoadingComponent, {}),
+			children: /* @__PURE__ */ jsx(OssidoErrorBoundary, {
+				resetKey: resourceKey,
+				fallback: ErrorComponent,
+				onReset: retry,
+				children: /* @__PURE__ */ jsx(RouteDataLoader, {
+					route,
+					resourceKey,
+					location
+				})
+			})
+		})]
+	});
+};
+/**
+* Renders the layout (`layout`) components that wrap the selected route.
+* Layouts receive only `children` now — they live OUTSIDE the keyed Suspense
+* boundary, so they persist across navigation while only the page area shows
+* the loading fallback. Memoized so navigation does not re-render layouts.
+*/
+const TraverseRootComponents = memo(({ routes, index = 0, mode, children }) => {
+	if (routes.length > index) {
+		const route = routes[index];
+		const Parent = route.component;
+		const routeFilePath = route.filePath || route.id;
+		const layoutProps = route.options.hasHandler && route.options.dataKey ? readLayoutData(route.options.dataKey) : void 0;
+		return /* @__PURE__ */ jsxs(Parent, {
+			...layoutProps,
+			children: [/* @__PURE__ */ jsx(CriticalCss, {
+				routeFilePath,
+				mode
+			}), /* @__PURE__ */ jsx(TraverseRootComponents, {
+				routes,
+				index: index + 1,
+				mode,
+				children
+			})]
+		});
+	}
+	return /* @__PURE__ */ jsx(Fragment, { children });
+});
+TraverseRootComponents.displayName = "TraverseRootComponents";
+const loadParentComponents = (route, loader = []) => {
+	const parentComponent = route.options.getParentRoute?.();
+	loader.push(parentComponent);
+	if (!parentComponent.isRoot) return loadParentComponents(parentComponent, loader);
+	return loader.reverse();
+};
+
+//#endregion
+export { RouteMatch };
+//# sourceMappingURL=RouteMatch.js.map

package/dist/esm/components/RouteMatch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RouteMatch.js","names":[],"sources":["../../../src/components/RouteMatch.tsx"],"sourcesContent":["import type { JSX } from 'react';\nimport { memo, Suspense, useMemo } from 'react';\n\nimport { DefaultLoading, DefaultError, DevErrorReporter } from '@ossido-labs/ossido-ui';\n\nimport type { Mode } from '../types';\nimport type { Route } from '../route';\nimport { buildResourceKey, readLayoutData } from '../data/resourceCache';\n\nimport { useRouterContext } from './RouterContext';\nimport { CriticalCss } from './CriticalCss';\nimport { RouteDataLoader } from './RouteDataLoader';\nimport { OssidoErrorBoundary } from './OssidoErrorBoundary';\n\ninterface RouteMatchProps {\n  route: Route;\n  mode?: Mode;\n}\n\n/**\n * Renders the matched route: its parent layouts wrap an error boundary +\n * `<Suspense>` boundary around the data-reading leaf. The boundary is keyed by\n * the data-resource key so a navigation (including same-route param changes)\n * remounts it and shows the loading fallback, while the layouts persist.\n */\nexport const RouteMatch = ({ route, mode }: RouteMatchProps): JSX.Element => {\n  const { location, navigationId, retry } = useRouterContext();\n\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  const routes = useMemo(() => loadParentComponents(route), [route.id]);\n\n  const resourceKey = buildResourceKey(navigationId, location);\n\n  const LoadingComponent = route.options.loadingComponent ?? DefaultLoading;\n  // In dev the boundary reports the error to the shared store (rendered by the\n  // floating DevErrorOverlayHost); production falls back to a detail-free page\n  // so source/stack are never leaked to end users.\n  const ErrorComponent =\n    route.options.errorComponent ??\n    (mode === 'Dev' ? DevErrorReporter : DefaultError);\n\n  return (\n    <TraverseRootComponents routes={routes} mode={mode}>\n      {/* The leaf route's critical CSS must stay OUTSIDE the <Suspense> below:\n          React 19 ties a boundary's reveal to any `precedence` stylesheet\n          rendered inside it, which would push the streamed initial content into\n          an out-of-order late chunk (empty shell paints first — a flash on\n          every cold load). Rendered here it still hoists into the shell's\n          <head> as render-blocking, but the boundary streams inline. */}\n      <CriticalCss routeFilePath={route.filePath} mode={mode} />\n      {/* The <Suspense> is not keyed by the resource key, so navigation\n          re-renders (rather than remounts) the subtree. With the destination's\n          data + code prefetched by `updateLocation`, that lets the new page\n          appear in place with no fallback flash. The error boundary resets via\n          `resetKey` instead of a key change. */}\n      <Suspense fallback={<LoadingComponent />}>\n        <OssidoErrorBoundary\n          resetKey={resourceKey}\n          fallback={ErrorComponent}\n          onReset={retry}\n        >\n          <RouteDataLoader\n            route={route}\n            resourceKey={resourceKey}\n            location={location}\n          />\n        </OssidoErrorBoundary>\n      </Suspense>\n    </TraverseRootComponents>\n  );\n};\n\ninterface TraverseRootComponentsProps {\n  routes: Array<Route>;\n  children?: React.ReactNode;\n  index?: number;\n  mode?: Mode;\n}\n\n/**\n * Renders the layout (`layout`) components that wrap the selected route.\n * Layouts receive only `children` now — they live OUTSIDE the keyed Suspense\n * boundary, so they persist across navigation while only the page area shows\n * the loading fallback. Memoized so navigation does not re-render layouts.\n */\nconst TraverseRootComponents = memo(\n  ({\n    routes,\n    index = 0,\n    mode,\n    children,\n  }: TraverseRootComponentsProps): React.JSX.Element => {\n    if (routes.length > index) {\n      const route = routes[index] as Route;\n      const Parent = route.component;\n\n      // Fallback to the route id if the filePath is not defined\n      // as is the case for the root route\n      const routeFilePath = route.filePath || route.id;\n\n      // A `layout.rs` handler's data is seeded (by SSR or the page's data fetch)\n      // and read synchronously here, then spread as the layout's props alongside\n      // `children`. Layouts without a data handler receive only `children`.\n      const layoutProps =\n        route.options.hasHandler && route.options.dataKey\n          ? readLayoutData(route.options.dataKey)\n          : undefined;\n\n      return (\n        <Parent {...layoutProps}>\n          <CriticalCss routeFilePath={routeFilePath} mode={mode} />\n          <TraverseRootComponents routes={routes} index={index + 1} mode={mode}>\n            {children}\n          </TraverseRootComponents>\n        </Parent>\n      );\n    }\n\n    return <>{children}</>;\n  },\n);\nTraverseRootComponents.displayName = 'TraverseRootComponents';\n\nconst loadParentComponents = (\n  route: Route,\n  loader: Array<Route> = [],\n): Array<Route> => {\n  const parentComponent = route.options.getParentRoute?.() as Route;\n\n  loader.push(parentComponent);\n\n  if (!parentComponent.isRoot) {\n    return loadParentComponents(parentComponent, loader);\n  }\n\n  return loader.reverse();\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAyBA,MAAa,cAAc,EAAE,OAAO,WAAyC;CAC3E,MAAM,EAAE,UAAU,cAAc,UAAU,iBAAiB;CAG3D,MAAM,SAAS,cAAc,qBAAqB,KAAK,GAAG,CAAC,MAAM,EAAE,CAAC;CAEpE,MAAM,cAAc,iBAAiB,cAAc,QAAQ;CAE3D,MAAM,mBAAmB,MAAM,QAAQ,oBAAoB;CAI3D,MAAM,iBACJ,MAAM,QAAQ,mBACb,SAAS,QAAQ,mBAAmB;CAEvC,OACE,qBAAC,wBAAD;EAAgC;EAAc;YAA9C,CAOE,oBAAC,aAAD;GAAa,eAAe,MAAM;GAAgB;EAAO,IAMzD,oBAAC,UAAD;GAAU,UAAU,oBAAC,kBAAD,CAAmB;aACrC,oBAAC,qBAAD;IACE,UAAU;IACV,UAAU;IACV,SAAS;cAET,oBAAC,iBAAD;KACS;KACM;KACH;IACX;GACkB;EACb,EACY;;AAE5B;;;;;;;AAeA,MAAM,yBAAyB,MAC5B,EACC,QACA,QAAQ,GACR,MACA,eACoD;CACpD,IAAI,OAAO,SAAS,OAAO;EACzB,MAAM,QAAQ,OAAO;EACrB,MAAM,SAAS,MAAM;EAIrB,MAAM,gBAAgB,MAAM,YAAY,MAAM;EAK9C,MAAM,cACJ,MAAM,QAAQ,cAAc,MAAM,QAAQ,UACtC,eAAe,MAAM,QAAQ,OAAO,IACpC;EAEN,OACE,qBAAC,QAAD;GAAQ,GAAI;aAAZ,CACE,oBAAC,aAAD;IAA4B;IAAqB;GAAO,IACxD,oBAAC,wBAAD;IAAgC;IAAQ,OAAO,QAAQ;IAAS;IAC7D;GACqB,EAClB;;CAEZ;CAEA,OAAO,gCAAG,SAAW;AACvB,CACF;AACA,uBAAuB,cAAc;AAErC,MAAM,wBACJ,OACA,SAAuB,CAAC,MACP;CACjB,MAAM,kBAAkB,MAAM,QAAQ,iBAAiB;CAEvD,OAAO,KAAK,eAAe;CAE3B,IAAI,CAAC,gBAAgB,QACnB,OAAO,qBAAqB,iBAAiB,MAAM;CAGrD,OAAO,OAAO,QAAQ;AACxB"}