@ossido-labs/ossido-router 0.1.0

package/dist/esm/hooks/useRouter.d.ts

@@ -0,0 +1,47 @@
+type NavigationFn = (path: string, opts?: NavigationOptions) => void;
+interface NavigationOptions {
+    /**
+     * If "false" the scroll offset will be kept across page navigation. Default "true"
+     */
+    scroll?: boolean;
+    /**
+     * Override the app's `viewTransitions` config for this navigation: `true`
+     * forces a View Transition, `false` skips it. Defaults to the config value.
+     */
+    viewTransition?: boolean;
+}
+interface UseRouterResult {
+    /**
+     * Redirects to the path passed as argument updating the browser history.
+     */
+    push: NavigationFn;
+    /**
+     * Redirects to the path passed as argument replacing the current history
+     * entry.
+     */
+    replace: NavigationFn;
+    /**
+     * This object contains all the query params of the current route
+     */
+    query: Record<string, string>;
+    /**
+     * Returns the current pathname
+     */
+    pathname: string;
+    /**
+     * Re-fetch the current route's server props — its `page.rs` `#[handler]` data
+     * — and re-render the page with the fresh values. Use it when something has
+     * changed the data the page was server-rendered with (e.g. after a mutation)
+     * and you want the page to reflect it without a full navigation.
+     *
+     * The current page stays on screen while the refetch is in flight (no
+     * `loading.tsx` flash); read `isRefetching` to reflect the pending state.
+     */
+    refetchProps: () => void;
+    /**
+     * `true` while a `refetchProps()` call from this hook is in flight.
+     */
+    isRefetching: boolean;
+}
+export declare const useRouter: () => UseRouterResult;
+export {};

package/dist/esm/hooks/useRouter.js

@@ -0,0 +1,49 @@
+import { useRouterContext } from "../components/RouterContext.js";
+import { useCallback, useTransition } from "react";
+
+//#region src/hooks/useRouter.ts
+const useRouter = () => {
+	const { location, updateLocation, retry } = useRouterContext();
+	const [isRefetching, startRefetch] = useTransition();
+	const navigate = useCallback((type, path, opts) => {
+		const { scroll = true, viewTransition } = opts || {};
+		const url = new URL(path, window.location.origin);
+		updateLocation({
+			href: url.href,
+			pathname: url.pathname,
+			search: Object.fromEntries(url.searchParams),
+			searchStr: url.search,
+			hash: url.hash
+		}, {
+			history: {
+				type,
+				path
+			},
+			scroll,
+			viewTransition
+		});
+	}, [updateLocation]);
+	const push = useCallback((path, opts) => {
+		navigate("pushState", path, opts);
+	}, [navigate]);
+	const replace = useCallback((path, opts) => {
+		navigate("replaceState", path, opts);
+	}, [navigate]);
+	const refetchProps = useCallback(() => {
+		startRefetch(() => {
+			retry();
+		});
+	}, [retry]);
+	return {
+		push,
+		replace,
+		query: location.search,
+		pathname: location.pathname,
+		refetchProps,
+		isRefetching
+	};
+};
+
+//#endregion
+export { useRouter };
+//# sourceMappingURL=useRouter.js.map

package/dist/esm/hooks/useRouter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRouter.js","names":[],"sources":["../../../src/hooks/useRouter.ts"],"sourcesContent":["import { useCallback, useTransition } from 'react';\n\nimport { useRouterContext } from '../components/RouterContext';\n\ntype NavigationType = 'pushState' | 'replaceState';\ntype NavigationFn = (path: string, opts?: NavigationOptions) => void;\n\ninterface NavigationOptions {\n  /**\n   * If \"false\" the scroll offset will be kept across page navigation. Default \"true\"\n   */\n  scroll?: boolean;\n  /**\n   * Override the app's `viewTransitions` config for this navigation: `true`\n   * forces a View Transition, `false` skips it. Defaults to the config value.\n   */\n  viewTransition?: boolean;\n}\n\ninterface UseRouterResult {\n  /**\n   * Redirects to the path passed as argument updating the browser history.\n   */\n  push: NavigationFn;\n\n  /**\n   * Redirects to the path passed as argument replacing the current history\n   * entry.\n   */\n  replace: NavigationFn;\n\n  /**\n   * This object contains all the query params of the current route\n   */\n  query: Record<string, string>;\n\n  /**\n   * Returns the current pathname\n   */\n  pathname: string;\n\n  /**\n   * Re-fetch the current route's server props — its `page.rs` `#[handler]` data\n   * — and re-render the page with the fresh values. Use it when something has\n   * changed the data the page was server-rendered with (e.g. after a mutation)\n   * and you want the page to reflect it without a full navigation.\n   *\n   * The current page stays on screen while the refetch is in flight (no\n   * `loading.tsx` flash); read `isRefetching` to reflect the pending state.\n   */\n  refetchProps: () => void;\n\n  /**\n   * `true` while a `refetchProps()` call from this hook is in flight.\n   */\n  isRefetching: boolean;\n}\n\nexport const useRouter = (): UseRouterResult => {\n  const { location, updateLocation, retry } = useRouterContext();\n  const [isRefetching, startRefetch] = useTransition();\n\n  const navigate = useCallback(\n    (type: NavigationType, path: string, opts?: NavigationOptions): void => {\n      const { scroll = true, viewTransition } = opts || {};\n      const url = new URL(path, window.location.origin);\n\n      // The history/scroll update is applied by `updateLocation` when the\n      // navigation actually commits — which, for a route without `loading.tsx`,\n      // is after its data has been prefetched (so the URL doesn't change while\n      // the current page is still showing).\n      updateLocation(\n        {\n          href: url.href,\n          pathname: url.pathname,\n          search: Object.fromEntries(url.searchParams),\n          searchStr: url.search,\n          hash: url.hash,\n        },\n        { history: { type, path }, scroll, viewTransition },\n      );\n    },\n    [updateLocation],\n  );\n\n  const push = useCallback(\n    (path: string, opts?: NavigationOptions): void => {\n      navigate('pushState', path, opts);\n    },\n    [navigate],\n  );\n\n  const replace = useCallback(\n    (path: string, opts?: NavigationOptions): void => {\n      navigate('replaceState', path, opts);\n    },\n    [navigate],\n  );\n\n  const refetchProps = useCallback((): void => {\n    // `retry` bumps the navigation id, which changes the data-resource key and\n    // so triggers a refetch of the current route (same mechanism as the error\n    // boundary's reset). Wrapped in a transition so React keeps the current page\n    // rendered until the fresh props resolve, instead of flashing the loading\n    // fallback.\n    startRefetch(() => {\n      retry();\n    });\n  }, [retry]);\n\n  return {\n    push,\n    replace,\n    query: location.search,\n    pathname: location.pathname,\n    refetchProps,\n    isRefetching,\n  };\n};\n"],"mappings":";;;;AA0DA,MAAa,kBAAmC;CAC9C,MAAM,EAAE,UAAU,gBAAgB,UAAU,iBAAiB;CAC7D,MAAM,CAAC,cAAc,gBAAgB,cAAc;CAEnD,MAAM,WAAW,aACd,MAAsB,MAAc,SAAmC;EACtE,MAAM,EAAE,SAAS,MAAM,mBAAmB,QAAQ,CAAC;EACnD,MAAM,MAAM,IAAI,IAAI,MAAM,OAAO,SAAS,MAAM;EAMhD,eACE;GACE,MAAM,IAAI;GACV,UAAU,IAAI;GACd,QAAQ,OAAO,YAAY,IAAI,YAAY;GAC3C,WAAW,IAAI;GACf,MAAM,IAAI;EACZ,GACA;GAAE,SAAS;IAAE;IAAM;GAAK;GAAG;GAAQ;EAAe,CACpD;CACF,GACA,CAAC,cAAc,CACjB;CAEA,MAAM,OAAO,aACV,MAAc,SAAmC;EAChD,SAAS,aAAa,MAAM,IAAI;CAClC,GACA,CAAC,QAAQ,CACX;CAEA,MAAM,UAAU,aACb,MAAc,SAAmC;EAChD,SAAS,gBAAgB,MAAM,IAAI;CACrC,GACA,CAAC,QAAQ,CACX;CAEA,MAAM,eAAe,kBAAwB;EAM3C,mBAAmB;GACjB,MAAM;EACR,CAAC;CACH,GAAG,CAAC,KAAK,CAAC;CAEV,OAAO;EACL;EACA;EACA,OAAO,SAAS;EAChB,UAAU,SAAS;EACnB;EACA;CACF;AACF"}

package/dist/esm/hot.d.ts

@@ -0,0 +1,9 @@
+/** Bump the store and notify subscribers. Dev-only in practice. */
+export declare function notifyRouteHotUpdate(): void;
+/**
+ * Subscribe the calling component to route hot-swaps. Returns a value that
+ * changes whenever {@link notifyRouteHotUpdate} fires, forcing a re-render so
+ * freshly swapped `route.component`s are picked up. Inert outside dev, where
+ * nothing bumps the store.
+ */
+export declare function useRouteHotVersion(): number;

package/dist/esm/hot.js

@@ -0,0 +1,32 @@
+import { useSyncExternalStore } from "react";
+
+//#region src/hot.ts
+let version = 0;
+const listeners = /* @__PURE__ */ new Set();
+/** Bump the store and notify subscribers. Dev-only in practice. */
+function notifyRouteHotUpdate() {
+	version += 1;
+	for (const listener of listeners) listener();
+}
+function subscribe(listener) {
+	listeners.add(listener);
+	return () => {
+		listeners.delete(listener);
+	};
+}
+function getSnapshot() {
+	return version;
+}
+/**
+* Subscribe the calling component to route hot-swaps. Returns a value that
+* changes whenever {@link notifyRouteHotUpdate} fires, forcing a re-render so
+* freshly swapped `route.component`s are picked up. Inert outside dev, where
+* nothing bumps the store.
+*/
+function useRouteHotVersion() {
+	return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+
+//#endregion
+export { notifyRouteHotUpdate, useRouteHotVersion };
+//# sourceMappingURL=hot.js.map

package/dist/esm/hot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hot.js","names":[],"sources":["../../src/hot.ts"],"sourcesContent":["import { useSyncExternalStore } from 'react';\n\n// Dev-only HMR bridge for route components.\n//\n// A route module edit that React Fast Refresh CAN apply in place (the module\n// only exports components) never reaches here — vite contains it at that\n// module's own boundary. But an edit that breaks the boundary (a non-component\n// export, or an anonymous default export) makes react-refresh call\n// `import.meta.hot.invalidate()`, which would otherwise propagate to the client\n// entry and force a full page reload — refetching the route's server data.\n//\n// Instead, the generated route tree accepts its route-module deps and swaps the\n// affected `route.component`s, then bumps this store so the match tree\n// re-renders with them. That downgrades a full reload to a route-subtree\n// remount. Prod builds never call `notifyRouteHotUpdate` (the generated hot\n// block is dead code under `if (import.meta.hot)` and is eliminated), so the\n// subscription is inert.\nlet version = 0;\nconst listeners = new Set<() => void>();\n\n/** Bump the store and notify subscribers. Dev-only in practice. */\nexport function notifyRouteHotUpdate(): void {\n  version += 1;\n  for (const listener of listeners) listener();\n}\n\nfunction subscribe(listener: () => void): () => void {\n  listeners.add(listener);\n  return () => {\n    listeners.delete(listener);\n  };\n}\n\nfunction getSnapshot(): number {\n  return version;\n}\n\n/**\n * Subscribe the calling component to route hot-swaps. Returns a value that\n * changes whenever {@link notifyRouteHotUpdate} fires, forcing a re-render so\n * freshly swapped `route.component`s are picked up. Inert outside dev, where\n * nothing bumps the store.\n */\nexport function useRouteHotVersion(): number {\n  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n}\n"],"mappings":";;;AAiBA,IAAI,UAAU;AACd,MAAM,4BAAY,IAAI,IAAgB;;AAGtC,SAAgB,uBAA6B;CAC3C,WAAW;CACX,KAAK,MAAM,YAAY,WAAW,SAAS;AAC7C;AAEA,SAAS,UAAU,UAAkC;CACnD,UAAU,IAAI,QAAQ;CACtB,aAAa;EACX,UAAU,OAAO,QAAQ;CAC3B;AACF;AAEA,SAAS,cAAsB;CAC7B,OAAO;AACT;;;;;;;AAQA,SAAgB,qBAA6B;CAC3C,OAAO,qBAAqB,WAAW,aAAa,WAAW;AACjE"}

package/dist/esm/index.d.ts

@@ -0,0 +1,9 @@
+export { RouterProvider } from './components/RouterProvider';
+export { Link } from './components/Link';
+export { createRouter } from './router';
+export type { RouterInstanceType } from './router';
+export { createRoute, createRootRoute } from './route';
+export { useRouter } from './hooks/useRouter';
+export { preloadRouteChain } from './utils/preload-route-chain';
+export { notifyRouteHotUpdate, useRouteHotVersion } from './hot';
+export type { RouteProps, RouteComponent, OssidoErrorProps, ServerErrorPayload, } from './types';

package/dist/esm/index.js

@@ -0,0 +1,9 @@
+import { notifyRouteHotUpdate, useRouteHotVersion } from "./hot.js";
+import { useRouter } from "./hooks/useRouter.js";
+import { createRootRoute, createRoute } from "./route.js";
+import { Link } from "./components/Link.js";
+import { RouterProvider } from "./components/RouterProvider.js";
+import { createRouter } from "./router.js";
+import { preloadRouteChain } from "./utils/preload-route-chain.js";
+
+export { Link, RouterProvider, createRootRoute, createRoute, createRouter, notifyRouteHotUpdate, preloadRouteChain, useRouteHotVersion, useRouter };

package/dist/esm/route.d.ts

@@ -0,0 +1,70 @@
+import type { RouteComponent, LoadingComponent, ErrorComponent, NotFoundComponent } from './types';
+interface RouteOptions {
+    id?: string;
+    isRoot?: boolean;
+    getParentRoute?: () => Route;
+    path?: string;
+    filePath?: string;
+    /**
+     * The route's source file path (e.g. `/about/page`, `/blog/layout`), matching
+     * the Rust route key. Used to seed/read this route's server data — for pages
+     * and, crucially, for `layout.rs` data (keyed by `dataKey` in the payload's
+     * `layoutData`).
+     */
+    dataKey?: string;
+    component: RouteComponent;
+    hasHandler?: boolean;
+    /**
+     * Nearest-ancestor `loading.tsx`, resolved at generation time. Rendered as
+     * the `<Suspense>` fallback while this route's server data loads on client
+     * navigation. Falls back to a framework default when absent.
+     */
+    loadingComponent?: LoadingComponent;
+    /**
+     * Nearest-ancestor `error.tsx`, resolved at generation time. Rendered by the
+     * route error boundary. Falls back to a framework default when absent.
+     */
+    errorComponent?: ErrorComponent;
+    /**
+     * Nearest-ancestor `not-found.tsx`, resolved at generation time. On the root
+     * route it is the global not-found UI, rendered when no route matches. Falls
+     * back to a framework default when absent.
+     */
+    notFoundComponent?: NotFoundComponent;
+}
+export declare function createRoute(options: RouteOptions): Route;
+export declare const ROOT_ROUTE_ID = "__root__";
+export declare class Route {
+    options: RouteOptions;
+    /**
+     * The route id is used to identify the route in the router
+     * and is used to match the route with the URL.
+     *
+     * For now is the `path`
+     */
+    id?: string;
+    isRoot: boolean;
+    /**
+     * Used for identify the route by matching the URL
+     */
+    path?: string;
+    fullPath: string;
+    /**
+     * Utility to identify the route in the file system
+     * Used i.e. for finding the criticalCss to load
+     *
+     * The path does not include the file extension
+     */
+    filePath?: string;
+    children?: Array<Route>;
+    parentRoute?: Route;
+    originalIndex?: number;
+    component: RouteComponent;
+    '$$typeof': symbol;
+    constructor(options: RouteOptions);
+    init: (originalIndex: number) => void;
+    addChildren(routes: Array<Route>): this;
+    update: (options: Partial<RouteOptions>) => this;
+}
+export declare function createRootRoute(options: RouteOptions): Route;
+export {};

package/dist/esm/route.js

@@ -0,0 +1,50 @@
+import { joinPaths, trimPathLeft } from "./utils.js";
+
+//#region src/route.ts
+function createRoute(options) {
+	return new Route(options);
+}
+const ROOT_ROUTE_ID = "__root__";
+var Route = class {
+	constructor(options) {
+		this.init = (originalIndex) => {
+			this.originalIndex = originalIndex;
+			this.parentRoute = this.options.getParentRoute?.();
+			const isRoot = !this.parentRoute && !this.options.path && !this.options.id;
+			if (isRoot) this.path = ROOT_ROUTE_ID;
+			let path = isRoot ? ROOT_ROUTE_ID : this.options.path;
+			if (path && path !== "/") path = trimPathLeft(path);
+			const customId = this.options.id || path || this.options.filePath;
+			let id = isRoot ? ROOT_ROUTE_ID : joinPaths([customId]);
+			if (path === "__root__") path = "/";
+			if (id !== "__root__") id = joinPaths(["/", id]);
+			this.filePath = this.options.filePath;
+			this.path = path;
+			this.id = id;
+			this.fullPath = path || "";
+		};
+		this.update = (options) => {
+			Object.assign(this.options, options);
+			this.isRoot = options.isRoot || !options.getParentRoute;
+			return this;
+		};
+		this.isRoot = options.isRoot ?? typeof options.getParentRoute !== "function";
+		this.options = options;
+		this.$$typeof = Symbol.for("react.memo");
+		this.component = options.component;
+	}
+	addChildren(routes) {
+		this.children = routes;
+		return this;
+	}
+};
+function createRootRoute(options) {
+	return new Route({
+		...options,
+		isRoot: true
+	});
+}
+
+//#endregion
+export { ROOT_ROUTE_ID, Route, createRootRoute, createRoute };
+//# sourceMappingURL=route.js.map

package/dist/esm/route.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.js","names":[],"sources":["../../src/route.ts"],"sourcesContent":["import type {\n  RouteComponent,\n  LoadingComponent,\n  ErrorComponent,\n  NotFoundComponent,\n} from './types';\nimport { trimPathLeft, joinPaths } from './utils';\n\ninterface RouteOptions {\n  id?: string;\n  isRoot?: boolean;\n  getParentRoute?: () => Route;\n  path?: string;\n  filePath?: string;\n  /**\n   * The route's source file path (e.g. `/about/page`, `/blog/layout`), matching\n   * the Rust route key. Used to seed/read this route's server data — for pages\n   * and, crucially, for `layout.rs` data (keyed by `dataKey` in the payload's\n   * `layoutData`).\n   */\n  dataKey?: string;\n  component: RouteComponent;\n  hasHandler?: boolean;\n  /**\n   * Nearest-ancestor `loading.tsx`, resolved at generation time. Rendered as\n   * the `<Suspense>` fallback while this route's server data loads on client\n   * navigation. Falls back to a framework default when absent.\n   */\n  loadingComponent?: LoadingComponent;\n  /**\n   * Nearest-ancestor `error.tsx`, resolved at generation time. Rendered by the\n   * route error boundary. Falls back to a framework default when absent.\n   */\n  errorComponent?: ErrorComponent;\n  /**\n   * Nearest-ancestor `not-found.tsx`, resolved at generation time. On the root\n   * route it is the global not-found UI, rendered when no route matches. Falls\n   * back to a framework default when absent.\n   */\n  notFoundComponent?: NotFoundComponent;\n}\n\nexport function createRoute(options: RouteOptions): Route {\n  return new Route(options);\n}\n\nexport const ROOT_ROUTE_ID = '__root__';\n\nexport class Route {\n  options: RouteOptions;\n\n  /**\n   * The route id is used to identify the route in the router\n   * and is used to match the route with the URL.\n   *\n   * For now is the `path`\n   */\n  id?: string;\n  isRoot: boolean;\n  /**\n   * Used for identify the route by matching the URL\n   */\n  path?: string;\n  fullPath!: string;\n\n  /**\n   * Utility to identify the route in the file system\n   * Used i.e. for finding the criticalCss to load\n   *\n   * The path does not include the file extension\n   */\n  filePath?: string;\n\n  children?: Array<Route>;\n  parentRoute?: Route;\n  originalIndex?: number;\n  component: RouteComponent;\n\n  '$$typeof': symbol;\n\n  constructor(options: RouteOptions) {\n    this.isRoot =\n      options.isRoot ?? typeof options.getParentRoute !== 'function';\n    this.options = options;\n    this.$$typeof = Symbol.for('react.memo');\n\n    this.component = options.component;\n  }\n\n  init = (originalIndex: number): void => {\n    this.originalIndex = originalIndex;\n\n    this.parentRoute = this.options.getParentRoute?.();\n\n    // Only the true root (no parent) claims the shared ROOT_ROUTE_ID. A nested\n    // or route-group `layout` is also pathless, but it has a parent — it must\n    // get its own id (from its filePath) so it doesn't overwrite the root in\n    // `routesById`.\n    const isRoot = !this.parentRoute && !this.options.path && !this.options.id;\n\n    if (isRoot) {\n      this.path = ROOT_ROUTE_ID;\n    }\n\n    let path: undefined | string = isRoot ? ROOT_ROUTE_ID : this.options.path;\n\n    // If the path is anything other than an index path, trim it up\n    if (path && path !== '/') {\n      path = trimPathLeft(path);\n    }\n\n    const customId = this.options.id || path || this.options.filePath;\n\n    // Strip the parentId prefix from the first level of children\n    let id = isRoot ? ROOT_ROUTE_ID : joinPaths([customId]);\n\n    if (path === ROOT_ROUTE_ID) {\n      path = '/';\n    }\n\n    if (id !== ROOT_ROUTE_ID) {\n      id = joinPaths(['/', id]);\n    }\n\n    this.filePath = this.options.filePath;\n    this.path = path;\n    this.id = id;\n    this.fullPath = path || '';\n  };\n\n  addChildren(routes: Array<Route>): this {\n    this.children = routes;\n    return this;\n  }\n\n  update = (options: Partial<RouteOptions>): this => {\n    Object.assign(this.options, options);\n    this.isRoot = options.isRoot || !options.getParentRoute;\n    return this;\n  };\n}\n\n// TODO: not use yet. To be updated in ossido-fs-router-vite-plugin package\nexport function createRootRoute(options: RouteOptions): Route {\n  return new Route({ ...options, isRoot: true });\n}\n"],"mappings":";;;AA0CA,SAAgB,YAAY,SAA8B;CACxD,OAAO,IAAI,MAAM,OAAO;AAC1B;AAEA,MAAa,gBAAgB;AAE7B,IAAa,QAAb,MAAmB;CAgCjB,YAAY,SAAuB;eAS3B,kBAAgC;GACtC,KAAK,gBAAgB;GAErB,KAAK,cAAc,KAAK,QAAQ,iBAAiB;GAMjD,MAAM,SAAS,CAAC,KAAK,eAAe,CAAC,KAAK,QAAQ,QAAQ,CAAC,KAAK,QAAQ;GAExE,IAAI,QACF,KAAK,OAAO;GAGd,IAAI,OAA2B,SAAS,gBAAgB,KAAK,QAAQ;GAGrE,IAAI,QAAQ,SAAS,KACnB,OAAO,aAAa,IAAI;GAG1B,MAAM,WAAW,KAAK,QAAQ,MAAM,QAAQ,KAAK,QAAQ;GAGzD,IAAI,KAAK,SAAS,gBAAgB,UAAU,CAAC,QAAQ,CAAC;GAEtD,IAAI,qBACF,OAAO;GAGT,IAAI,mBACF,KAAK,UAAU,CAAC,KAAK,EAAE,CAAC;GAG1B,KAAK,WAAW,KAAK,QAAQ;GAC7B,KAAK,OAAO;GACZ,KAAK,KAAK;GACV,KAAK,WAAW,QAAQ;EAC1B;iBAOU,YAAyC;GACjD,OAAO,OAAO,KAAK,SAAS,OAAO;GACnC,KAAK,SAAS,QAAQ,UAAU,CAAC,QAAQ;GACzC,OAAO;EACT;EA1DE,KAAK,SACH,QAAQ,UAAU,OAAO,QAAQ,mBAAmB;EACtD,KAAK,UAAU;EACf,KAAK,WAAW,OAAO,IAAI,YAAY;EAEvC,KAAK,YAAY,QAAQ;CAC3B;CA2CA,YAAY,QAA4B;EACtC,KAAK,WAAW;EAChB,OAAO;CACT;AAOF;AAGA,SAAgB,gBAAgB,SAA8B;CAC5D,OAAO,IAAI,MAAM;EAAE,GAAG;EAAS,QAAQ;CAAK,CAAC;AAC/C"}

package/dist/esm/router.d.ts

@@ -0,0 +1,27 @@
+import type { ComponentType as ReactComponentType } from 'react';
+import type { Route } from './route';
+type RouteTree = Route;
+interface CreateRouterOptions {
+    routeTree: RouteTree;
+    basePath?: string;
+    options?: RouterOptions;
+}
+interface RouterOptions {
+    component?: ReactComponentType;
+    hasHandler?: boolean;
+    routeTree?: RouteTree;
+}
+export declare function createRouter(options: CreateRouterOptions): Router;
+export type RouterInstanceType = InstanceType<typeof Router>;
+export declare class Router {
+    #private;
+    options?: RouterOptions;
+    basePath: string;
+    routeTree?: RouteTree;
+    isServer: boolean;
+    routesById: Record<string, Route>;
+    routesByPath: Record<string, Route>;
+    constructor(options: CreateRouterOptions);
+    update: (newOptions: CreateRouterOptions) => void;
+}
+export {};

package/dist/esm/router.js

@@ -0,0 +1,52 @@
+import { trimPath, trimPathRight } from "./utils.js";
+
+//#region src/router.ts
+function createRouter(options) {
+	return new Router(options);
+}
+var Router = class {
+	constructor(options) {
+		this.basePath = "/";
+		this.isServer = typeof document === "undefined";
+		this.routesById = {};
+		this.routesByPath = {};
+		this.update = (newOptions) => {
+			this.options = {
+				...this.options,
+				...newOptions
+			};
+			this.#updateBasePath(newOptions.basePath);
+			if (this.options.routeTree !== this.routeTree) {
+				this.routeTree = this.options.routeTree;
+				this.#buildRouteTree();
+			}
+		};
+		this.#buildRouteTree = () => {
+			const recurseRoutes = (childRoutes) => {
+				childRoutes.forEach((route, i) => {
+					route.init(i);
+					this.routesById[route.id || ""] = route;
+					if (!route.isRoot && route.options.path) {
+						const trimmedFullPath = trimPathRight(route.fullPath);
+						if (!this.routesByPath[trimmedFullPath] || route.fullPath.endsWith("/")) this.routesByPath[trimmedFullPath] = route;
+					}
+					const children = route.children;
+					if (children?.length) recurseRoutes(children);
+				});
+			};
+			recurseRoutes([this.routeTree]);
+		};
+		this.#updateBasePath = (basePath) => {
+			if (basePath === void 0) return;
+			this.basePath = basePath === "" || basePath === "/" ? "/" : `/${trimPath(basePath)}`;
+		};
+		this.update({ ...options });
+		if (!this.isServer) window.__OSSIDO__ROUTER__ = this;
+	}
+	#buildRouteTree;
+	#updateBasePath;
+};
+
+//#endregion
+export { Router, createRouter };
+//# sourceMappingURL=router.js.map

package/dist/esm/router.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"router.js","names":["#updateBasePath","#buildRouteTree"],"sources":["../../src/router.ts"],"sourcesContent":["import type { ComponentType as ReactComponentType } from 'react';\n\nimport { trimPath, trimPathRight } from './utils';\nimport type { Route } from './route';\n\ntype RouteTree = Route;\n\ninterface CreateRouterOptions {\n  routeTree: RouteTree;\n  basePath?: string;\n  options?: RouterOptions;\n}\n\ninterface RouterOptions {\n  component?: ReactComponentType;\n  hasHandler?: boolean;\n  routeTree?: RouteTree;\n}\n\nexport function createRouter(options: CreateRouterOptions): Router {\n  return new Router(options);\n}\n\nexport type RouterInstanceType = InstanceType<typeof Router>;\n\nexport class Router {\n  options?: RouterOptions;\n  basePath = '/';\n  routeTree?: RouteTree;\n\n  isServer: boolean = typeof document === 'undefined';\n\n  routesById: Record<string, Route> = {};\n\n  routesByPath: Record<string, Route> = {};\n\n  constructor(options: CreateRouterOptions) {\n    this.update({\n      ...options,\n    });\n\n    if (!this.isServer) {\n      window.__OSSIDO__ROUTER__ = this;\n    }\n  }\n\n  update = (newOptions: CreateRouterOptions): void => {\n    this.options = {\n      ...this.options,\n      ...newOptions,\n    };\n\n    this.#updateBasePath(newOptions.basePath);\n\n    if (this.options.routeTree !== this.routeTree) {\n      this.routeTree = this.options.routeTree;\n      this.#buildRouteTree();\n    }\n  };\n\n  #buildRouteTree = (): void => {\n    const recurseRoutes = (childRoutes: Array<Route>): void => {\n      childRoutes.forEach((route: Route, i: number) => {\n        route.init(i);\n\n        this.routesById[route.id || ''] = route;\n\n        if (!route.isRoot && route.options.path) {\n          const trimmedFullPath = trimPathRight(route.fullPath);\n          if (\n            !this.routesByPath[trimmedFullPath] ||\n            route.fullPath.endsWith('/')\n          ) {\n            this.routesByPath[trimmedFullPath] = route;\n          }\n        }\n\n        const children = route.children;\n        if (children?.length) {\n          recurseRoutes(children);\n        }\n      });\n    };\n\n    recurseRoutes([this.routeTree as Route]);\n  };\n\n  #updateBasePath = (basePath?: string): void => {\n    // No option passed → keep the current base path.\n    if (basePath === undefined) return;\n\n    this.basePath =\n      basePath === '' || basePath === '/' ? '/' : `/${trimPath(basePath)}`;\n  };\n}\n"],"mappings":";;;AAmBA,SAAgB,aAAa,SAAsC;CACjE,OAAO,IAAI,OAAO,OAAO;AAC3B;AAIA,IAAa,SAAb,MAAoB;CAWlB,YAAY,SAA8B;kBAT/B;kBAGS,OAAO,aAAa;oBAEJ,CAAC;sBAEC,CAAC;iBAY7B,eAA0C;GAClD,KAAK,UAAU;IACb,GAAG,KAAK;IACR,GAAG;GACL;GAEA,KAAKA,gBAAgB,WAAW,QAAQ;GAExC,IAAI,KAAK,QAAQ,cAAc,KAAK,WAAW;IAC7C,KAAK,YAAY,KAAK,QAAQ;IAC9B,KAAKC,gBAAgB;GACvB;EACF;+BAE8B;GAC5B,MAAM,iBAAiB,gBAAoC;IACzD,YAAY,SAAS,OAAc,MAAc;KAC/C,MAAM,KAAK,CAAC;KAEZ,KAAK,WAAW,MAAM,MAAM,MAAM;KAElC,IAAI,CAAC,MAAM,UAAU,MAAM,QAAQ,MAAM;MACvC,MAAM,kBAAkB,cAAc,MAAM,QAAQ;MACpD,IACE,CAAC,KAAK,aAAa,oBACnB,MAAM,SAAS,SAAS,GAAG,GAE3B,KAAK,aAAa,mBAAmB;KAEzC;KAEA,MAAM,WAAW,MAAM;KACvB,IAAI,UAAU,QACZ,cAAc,QAAQ;IAE1B,CAAC;GACH;GAEA,cAAc,CAAC,KAAK,SAAkB,CAAC;EACzC;0BAEmB,aAA4B;GAE7C,IAAI,aAAa,QAAW;GAE5B,KAAK,WACH,aAAa,MAAM,aAAa,MAAM,MAAM,IAAI,SAAS,QAAQ;EACrE;EAxDE,KAAK,OAAO,EACV,GAAG,QACL,CAAC;EAED,IAAI,CAAC,KAAK,UACR,OAAO,qBAAqB;CAEhC;CAgBA;CA2BA;AAOF"}

package/dist/esm/types.d.ts

@@ -0,0 +1,63 @@
+import type { ReactNode, ComponentType } from 'react';
+import type { ServerErrorSource } from '@ossido-labs/ossido-ui';
+export type Mode = 'Dev' | 'Prod';
+export interface Segment {
+    type: 'pathname' | 'param' | 'wildcard';
+    value: string;
+}
+/**
+ * Provided by the rust server and used in the ssr env
+ * @see ossido {@link ServerPayloadLocation}
+ */
+export interface ServerInitialLocation {
+    href: string;
+    pathname: string;
+    searchStr: string;
+}
+/**
+ * Props a route component may receive.
+ *
+ * Page components receive their server data spread directly as props, so their
+ * concrete prop shape is defined by the user's handler return type — not by this
+ * type. Layout/root components receive `children`.
+ */
+export interface RouteProps {
+    children?: ReactNode;
+}
+/**
+ * A route (page or layout) component.
+ *
+ * Pages are called with the resolved server data spread as props, so props are
+ * intentionally untyped here (`any`); the concrete shape lives in user code.
+ */
+export type RouteComponent = ComponentType<any> & {
+    /**
+     * Loads the component's code chunk, resolving when it's ready (and caching it
+     * so the component then renders synchronously). Present on lazily-loaded route
+     * components; absent on eagerly-imported ones (e.g. the root layout).
+     */
+    preload?: () => Promise<void>;
+    /**
+     * Dev-only. Swap the resolved component behind a lazily-loaded route in place,
+     * so an HMR update to the route module renders without re-running the dynamic
+     * import. Set by the lazy-load wrapper; used by the generated route tree's hot
+     * accept handler. Absent in prod and on eagerly-imported components.
+     */
+    update?: (next: RouteComponent) => void;
+};
+/**
+ * Serialized Rust handler error, sent by the server (dev mode only) so a
+ * backend panic can surface in the error overlay like a JS error.
+ * @see crates/ossido/src/server_error.rs
+ */
+export interface ServerErrorPayload {
+    name: string;
+    message: string;
+    stack?: string;
+    source?: ServerErrorSource;
+}
+/** A `loading.tsx` component. Rendered as a `<Suspense>` fallback (no props). */
+export type LoadingComponent = ComponentType;
+/** A `not-found.tsx` component. Rendered when no route matches (no props). */
+export type NotFoundComponent = ComponentType;
+export type { OssidoErrorProps, OssidoErrorWithSource, ServerErrorSource, ErrorComponent, } from '@ossido-labs/ossido-ui';

package/dist/esm/utils/from-url-to-parsed-location.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedLocation } from '../components/RouterContext';
+export declare function fromUrlToParsedLocation(href: string): ParsedLocation;

package/dist/esm/utils/from-url-to-parsed-location.js

@@ -0,0 +1,15 @@
+//#region src/utils/from-url-to-parsed-location.ts
+function fromUrlToParsedLocation(href) {
+	const location = new URL(href, window.location.origin);
+	return {
+		href: location.href,
+		pathname: location.pathname,
+		search: Object.fromEntries(location.searchParams),
+		searchStr: location.search,
+		hash: location.hash
+	};
+}
+
+//#endregion
+export { fromUrlToParsedLocation };
+//# sourceMappingURL=from-url-to-parsed-location.js.map

package/dist/esm/utils/from-url-to-parsed-location.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"from-url-to-parsed-location.js","names":[],"sources":["../../../src/utils/from-url-to-parsed-location.ts"],"sourcesContent":["import type { ParsedLocation } from '../components/RouterContext';\n\nexport function fromUrlToParsedLocation(href: string): ParsedLocation {\n  const location = new URL(href, window.location.origin);\n  return {\n    href: location.href,\n    pathname: location.pathname,\n    search: Object.fromEntries(location.searchParams),\n    searchStr: location.search,\n    hash: location.hash,\n  };\n}\n"],"mappings":";AAEA,SAAgB,wBAAwB,MAA8B;CACpE,MAAM,WAAW,IAAI,IAAI,MAAM,OAAO,SAAS,MAAM;CACrD,OAAO;EACL,MAAM,SAAS;EACf,UAAU,SAAS;EACnB,QAAQ,OAAO,YAAY,SAAS,YAAY;EAChD,WAAW,SAAS;EACpB,MAAM,SAAS;CACjB;AACF"}

package/dist/esm/utils/match-route.d.ts

@@ -0,0 +1,16 @@
+import type { Route } from '../route';
+/**
+ * In order to correctly handle pathnames that might finish with a slash
+ * we first sanitize them by removing the final slash.
+ */
+export declare function sanitizePathname(pathname: string): string;
+/**
+ * Returns the route that matches the given pathname, from the router's route
+ * table. Pure (no hooks) so it can be used both by `useRoute` and at navigation
+ * time (to inspect the target route before committing).
+ *
+ * This matching is also implemented on the server side to pick the bundle to
+ * load at the first rendering — see crates/ossido/src/payload.rs. Any
+ * optimization should happen on both.
+ */
+export declare function matchRoute(routesById: Record<string, Route>, pathname?: string): Route | undefined;

package/dist/esm/utils/match-route.js

@@ -0,0 +1,72 @@
+//#region src/utils/match-route.ts
+const DYNAMIC_PATH_REGEX = /\[(.*?)\]/;
+/**
+* The dynamic routes of a route table, pre-filtered and pre-split, computed
+* once per `routesById` object instead of on every match. Keyed weakly so the
+* per-request SSR routers are garbage-collected with their cache entry. Sorted
+* by route id so matching order is deterministic and mirrors the server-side
+* matcher (crates/ossido/src/manifest.rs).
+*
+* The route table is only rebuilt when the router receives a new route tree
+* (never after startup in practice), so keying by object identity is safe.
+*/
+const dynamicRoutesCache = /* @__PURE__ */ new WeakMap();
+function getDynamicRoutes(routesById) {
+	let cached = dynamicRoutesCache.get(routesById);
+	if (!cached) {
+		cached = Object.keys(routesById).filter((route) => DYNAMIC_PATH_REGEX.test(route)).sort().map((route) => ({
+			route,
+			segments: route.split("/").filter(Boolean)
+		}));
+		dynamicRoutesCache.set(routesById, cached);
+	}
+	return cached;
+}
+/**
+* In order to correctly handle pathnames that might finish with a slash
+* we first sanitize them by removing the final slash.
+*/
+function sanitizePathname(pathname) {
+	if (pathname.endsWith("/") && pathname !== "/") return pathname.substring(0, pathname.length - 1);
+	return pathname;
+}
+/**
+* Returns the route that matches the given pathname, from the router's route
+* table. Pure (no hooks) so it can be used both by `useRoute` and at navigation
+* time (to inspect the target route before committing).
+*
+* This matching is also implemented on the server side to pick the bundle to
+* load at the first rendering — see crates/ossido/src/payload.rs. Any
+* optimization should happen on both.
+*/
+function matchRoute(routesById, pathname) {
+	if (!pathname) return;
+	pathname = sanitizePathname(pathname);
+	if (routesById[pathname]) return routesById[pathname];
+	const dynamicRoutes = getDynamicRoutes(routesById);
+	if (!dynamicRoutes.length) return;
+	const pathSegments = pathname.split("/").filter(Boolean);
+	let match = void 0;
+	for (const { segments: dynamicRouteSegments } of dynamicRoutes) {
+		const routeSegmentsCollector = [];
+		for (let i = 0; i < dynamicRouteSegments.length; i++) {
+			if (dynamicRouteSegments[i]?.startsWith("[...")) {
+				routeSegmentsCollector.push(dynamicRouteSegments[i] ?? "");
+				match = `/${routeSegmentsCollector.join("/")}`;
+				break;
+			}
+			if (dynamicRouteSegments[i] === pathSegments[i] || DYNAMIC_PATH_REGEX.test(dynamicRouteSegments[i] || "")) routeSegmentsCollector.push(dynamicRouteSegments[i] ?? "");
+			else break;
+		}
+		if (routeSegmentsCollector.length === pathSegments.length) {
+			match = `/${routeSegmentsCollector.join("/")}`;
+			break;
+		}
+	}
+	if (!match) return;
+	return routesById[match];
+}
+
+//#endregion
+export { matchRoute, sanitizePathname };
+//# sourceMappingURL=match-route.js.map

package/dist/esm/utils/match-route.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"match-route.js","names":[],"sources":["../../../src/utils/match-route.ts"],"sourcesContent":["import type { Route } from '../route';\n\nconst DYNAMIC_PATH_REGEX = /\\[(.*?)\\]/;\n\ninterface DynamicRouteEntry {\n  route: string;\n  segments: Array<string>;\n}\n\n/**\n * The dynamic routes of a route table, pre-filtered and pre-split, computed\n * once per `routesById` object instead of on every match. Keyed weakly so the\n * per-request SSR routers are garbage-collected with their cache entry. Sorted\n * by route id so matching order is deterministic and mirrors the server-side\n * matcher (crates/ossido/src/manifest.rs).\n *\n * The route table is only rebuilt when the router receives a new route tree\n * (never after startup in practice), so keying by object identity is safe.\n */\nconst dynamicRoutesCache = new WeakMap<\n  Record<string, Route>,\n  Array<DynamicRouteEntry>\n>();\n\nfunction getDynamicRoutes(\n  routesById: Record<string, Route>,\n): Array<DynamicRouteEntry> {\n  let cached = dynamicRoutesCache.get(routesById);\n  if (!cached) {\n    cached = Object.keys(routesById)\n      .filter((route) => DYNAMIC_PATH_REGEX.test(route))\n      .sort()\n      .map((route) => ({ route, segments: route.split('/').filter(Boolean) }));\n    dynamicRoutesCache.set(routesById, cached);\n  }\n  return cached;\n}\n\n/**\n * In order to correctly handle pathnames that might finish with a slash\n * we first sanitize them by removing the final slash.\n */\nexport function sanitizePathname(pathname: string): string {\n  if (pathname.endsWith('/') && pathname !== '/') {\n    return pathname.substring(0, pathname.length - 1);\n  }\n\n  return pathname;\n}\n\n/**\n * Returns the route that matches the given pathname, from the router's route\n * table. Pure (no hooks) so it can be used both by `useRoute` and at navigation\n * time (to inspect the target route before committing).\n *\n * This matching is also implemented on the server side to pick the bundle to\n * load at the first rendering — see crates/ossido/src/payload.rs. Any\n * optimization should happen on both.\n */\nexport function matchRoute(\n  routesById: Record<string, Route>,\n  pathname?: string,\n): Route | undefined {\n  if (!pathname) return;\n\n  pathname = sanitizePathname(pathname);\n\n  if (routesById[pathname]) return routesById[pathname];\n\n  const dynamicRoutes = getDynamicRoutes(routesById);\n\n  if (!dynamicRoutes.length) return;\n\n  const pathSegments = pathname.split('/').filter(Boolean);\n\n  let match = undefined;\n\n  for (const { segments: dynamicRouteSegments } of dynamicRoutes) {\n    const routeSegmentsCollector: Array<string> = [];\n\n    for (let i = 0; i < dynamicRouteSegments.length; i++) {\n      if (dynamicRouteSegments[i]?.startsWith('[...')) {\n        routeSegmentsCollector.push(dynamicRouteSegments[i] ?? '');\n        match = `/${routeSegmentsCollector.join('/')}`;\n        break;\n      }\n      if (\n        dynamicRouteSegments[i] === pathSegments[i] ||\n        DYNAMIC_PATH_REGEX.test(dynamicRouteSegments[i] || '')\n      ) {\n        routeSegmentsCollector.push(dynamicRouteSegments[i] ?? '');\n      } else {\n        break;\n      }\n    }\n\n    if (routeSegmentsCollector.length === pathSegments.length) {\n      match = `/${routeSegmentsCollector.join('/')}`;\n      break;\n    }\n  }\n\n  if (!match) return;\n  return routesById[match];\n}\n"],"mappings":";AAEA,MAAM,qBAAqB;;;;;;;;;;;AAiB3B,MAAM,qCAAqB,IAAI,QAG7B;AAEF,SAAS,iBACP,YAC0B;CAC1B,IAAI,SAAS,mBAAmB,IAAI,UAAU;CAC9C,IAAI,CAAC,QAAQ;EACX,SAAS,OAAO,KAAK,UAAU,CAAC,CAC7B,QAAQ,UAAU,mBAAmB,KAAK,KAAK,CAAC,CAAC,CACjD,KAAK,CAAC,CACN,KAAK,WAAW;GAAE;GAAO,UAAU,MAAM,MAAM,GAAG,CAAC,CAAC,OAAO,OAAO;EAAE,EAAE;EACzE,mBAAmB,IAAI,YAAY,MAAM;CAC3C;CACA,OAAO;AACT;;;;;AAMA,SAAgB,iBAAiB,UAA0B;CACzD,IAAI,SAAS,SAAS,GAAG,KAAK,aAAa,KACzC,OAAO,SAAS,UAAU,GAAG,SAAS,SAAS,CAAC;CAGlD,OAAO;AACT;;;;;;;;;;AAWA,SAAgB,WACd,YACA,UACmB;CACnB,IAAI,CAAC,UAAU;CAEf,WAAW,iBAAiB,QAAQ;CAEpC,IAAI,WAAW,WAAW,OAAO,WAAW;CAE5C,MAAM,gBAAgB,iBAAiB,UAAU;CAEjD,IAAI,CAAC,cAAc,QAAQ;CAE3B,MAAM,eAAe,SAAS,MAAM,GAAG,CAAC,CAAC,OAAO,OAAO;CAEvD,IAAI,QAAQ;CAEZ,KAAK,MAAM,EAAE,UAAU,0BAA0B,eAAe;EAC9D,MAAM,yBAAwC,CAAC;EAE/C,KAAK,IAAI,IAAI,GAAG,IAAI,qBAAqB,QAAQ,KAAK;GACpD,IAAI,qBAAqB,EAAE,EAAE,WAAW,MAAM,GAAG;IAC/C,uBAAuB,KAAK,qBAAqB,MAAM,EAAE;IACzD,QAAQ,IAAI,uBAAuB,KAAK,GAAG;IAC3C;GACF;GACA,IACE,qBAAqB,OAAO,aAAa,MACzC,mBAAmB,KAAK,qBAAqB,MAAM,EAAE,GAErD,uBAAuB,KAAK,qBAAqB,MAAM,EAAE;QAEzD;EAEJ;EAEA,IAAI,uBAAuB,WAAW,aAAa,QAAQ;GACzD,QAAQ,IAAI,uBAAuB,KAAK,GAAG;GAC3C;EACF;CACF;CAEA,IAAI,CAAC,OAAO;CACZ,OAAO,WAAW;AACpB"}

package/dist/esm/utils/preload-route-chain.d.ts

@@ -0,0 +1,16 @@
+import type { RouterInstanceType } from '../router';
+/**
+ * Preload the code of the route matching `pathname` and of every layout that
+ * wraps it, so a subsequent render commits the components eagerly instead of
+ * suspending on their `React.lazy` chunk.
+ *
+ * Used ahead of the *initial* render on both sides — the server before
+ * streaming (a suspending route would push the page content into an
+ * out-of-order late chunk, painting an empty shell first) and the client
+ * before hydration (so the first client render matches that inline HTML).
+ * Client-side navigation has its own preload in `RouterContext`.
+ *
+ * A failed chunk load resolves anyway: the render then falls back to the lazy
+ * component, which surfaces the load error through the route's error boundary.
+ */
+export declare function preloadRouteChain(router: RouterInstanceType, pathname?: string): Promise<void>;

package/dist/esm/utils/preload-route-chain.js

@@ -0,0 +1,31 @@
+import { matchRoute } from "./match-route.js";
+
+//#region src/utils/preload-route-chain.ts
+/**
+* Preload the code of the route matching `pathname` and of every layout that
+* wraps it, so a subsequent render commits the components eagerly instead of
+* suspending on their `React.lazy` chunk.
+*
+* Used ahead of the *initial* render on both sides — the server before
+* streaming (a suspending route would push the page content into an
+* out-of-order late chunk, painting an empty shell first) and the client
+* before hydration (so the first client render matches that inline HTML).
+* Client-side navigation has its own preload in `RouterContext`.
+*
+* A failed chunk load resolves anyway: the render then falls back to the lazy
+* component, which surfaces the load error through the route's error boundary.
+*/
+async function preloadRouteChain(router, pathname) {
+	const matched = matchRoute(router.routesById, pathname);
+	if (!matched) return;
+	const pending = [];
+	for (let node = matched; node; node = node.isRoot ? void 0 : node.options.getParentRoute?.()) {
+		const preload = node.component.preload;
+		if (preload) pending.push(preload().catch(() => void 0));
+	}
+	await Promise.all(pending);
+}
+
+//#endregion
+export { preloadRouteChain };
+//# sourceMappingURL=preload-route-chain.js.map