@solidjs/router 0.15.1 → 0.15.3

package/README.md

@@ -818,7 +818,7 @@ if (unauthorized) {
 
 ### useLocation
 
-Retrieves reactive `location` object useful for getting things like `pathname`
+Retrieves reactive `location` object useful for getting things like `pathname`.
 
 ```js
 const location = useLocation();
@@ -880,7 +880,8 @@ return <div classList={{ active: Boolean(match()) }} />;
 For example if you stored breadcrumbs on your route definition you could retrieve them like so:
 ```js
 const matches = useCurrentMatches();
-const breadcrumbs = createMemo(() => matches().map(m => m.route.info.breadcrumb))
+
+const breadcrumbs = createMemo(() => matches().map(m => m.route.info.breadcrumb));
 ```
 
 ### usePreloadRoute
@@ -898,11 +899,11 @@ preload(`/users/settings`, { preloadData: true });
 `useBeforeLeave` takes a function that will be called prior to leaving a route. The function will be called with:
 
 - from (_Location_): current location (before change).
-- to (_string | number_}: path passed to `navigate`.
-- options (_NavigateOptions_}: options passed to `navigate`.
-- preventDefault (_void function_): call to block the route change.
-- defaultPrevented (_readonly boolean_): true if any previously called leave handlers called preventDefault().
-- retry (_void function_, _force?: boolean_ ): call to retry the same navigation, perhaps after confirming with the user. Pass `true` to skip running the leave handlers again (ie force navigate without confirming).
+- to (_string | number_): path passed to `navigate`.
+- options (_NavigateOptions_): options passed to `navigate`.
+- preventDefault (_function_): call to block the route change.
+- defaultPrevented (_readonly boolean_): `true` if any previously called leave handlers called `preventDefault`.
+- retry (_function_, _force?: boolean_ ): call to retry the same navigation, perhaps after confirming with the user. Pass `true` to skip running the leave handlers again (i.e. force navigate without confirming).
 
 Example usage:
 

package/dist/data/query.d.ts

@@ -1,4 +1,7 @@
 import type { CacheEntry, NarrowResponse } from "../types.js";
+/**
+ * Revalidates the given cache entry/entries.
+ */
 export declare function revalidate(key?: string | string[] | void, force?: boolean): Promise<void>;
 export declare function cacheKeyOp(key: string | string[] | void, fn: (cacheEntry: CacheEntry) => void): void;
 export type CachedFunction<T extends (...args: any) => any> = T extends (...args: infer A) => infer R ? ([] extends {

package/dist/data/query.js

@@ -24,6 +24,9 @@ function getCache() {
         throw new Error("Cannot find cache context");
     return (req.router || (req.router = {})).cache || (req.router.cache = new Map());
 }
+/**
+ * Revalidates the given cache entry/entries.
+ */
 export function revalidate(key, force = true) {
     return startTransition(() => {
         const now = Date.now();
@@ -97,9 +100,14 @@ export function query(fn, name) {
             inPreloadFn && "then" in res && res.catch(() => { });
             return res;
         }
-        let res = !isServer && sharedConfig.context && sharedConfig.has(key)
-            ? sharedConfig.load(key) // hydrating
-            : fn(...args);
+        let res;
+        if (!isServer && sharedConfig.has && sharedConfig.has(key)) {
+            res = sharedConfig.load(key); // hydrating
+            // @ts-ignore at least until we add a delete method to sharedConfig
+            delete globalThis._$HY.r[key];
+        }
+        else
+            res = fn(...args);
         if (cached) {
             cached[0] = now;
             cached[1] = res;

package/dist/index.js

@@ -251,13 +251,84 @@ const useHref = to => {
     return to_ !== undefined ? router.renderPath(to_) : to_;
   });
 };
+
+/**
+ * Retrieves method to do navigation. The method accepts a path to navigate to and an optional object with the following options:
+ * 
+ * - resolve (*boolean*, default `true`): resolve the path against the current route
+ * - replace (*boolean*, default `false`): replace the history entry
+ * - scroll (*boolean*, default `true`): scroll to top after navigation
+ * - state (*any*, default `undefined`): pass custom state to `location.state`
+ * 
+ * **Note**: The state is serialized using the structured clone algorithm which does not support all object types.
+ * 
+ * @example
+ * ```js
+ * const navigate = useNavigate();
+ * 
+ * if (unauthorized) {
+ *   navigate("/login", { replace: true });
+ * }
+ * ```
+ */
 const useNavigate = () => useRouter().navigatorFactory();
+
+/**
+ * Retrieves reactive `location` object useful for getting things like `pathname`.
+ * 
+ * @example
+ * ```js
+ * const location = useLocation();
+ * 
+ * const pathname = createMemo(() => parsePath(location.pathname));
+ * ```
+ */
 const useLocation = () => useRouter().location;
+
+/**
+ * Retrieves signal that indicates whether the route is currently in a *Transition*.
+ * Useful for showing stale/pending state when the route resolution is *Suspended* during concurrent rendering.
+ * 
+ * @example
+ * ```js
+ * const isRouting = useIsRouting();
+ * 
+ * return (
+ *   <div classList={{ "grey-out": isRouting() }}>
+ *     <MyAwesomeContent />
+ *   </div>
+ * );
+ * ```
+ */
 const useIsRouting = () => useRouter().isRouting;
+
+/**
+ * usePreloadRoute returns a function that can be used to preload a route manual.
+ * This is what happens automatically with link hovering and similar focus based behavior, but it is available here as an API.
+ * 
+ * @example
+ * ```js
+ * const preload = usePreloadRoute();
+ * 
+ * preload(`/users/settings`, { preloadData: true });
+ * ```
+ */
 const usePreloadRoute = () => {
   const pre = useRouter().preloadRoute;
   return (url, options = {}) => pre(url instanceof URL ? url : new URL(url, mockBase), options.preloadData);
 };
+
+/**
+ * `useMatch` takes an accessor that returns the path and creates a `Memo` that returns match information if the current path matches the provided path.
+ * Useful for determining if a given path matches the current route.
+ * 
+ * @example
+ * ```js
+ * const match = useMatch(() => props.href);
+ * 
+ * return <div classList={{ active: Boolean(match()) }} />;
+ * ```
+ */
 const useMatch = (path, matchFilters) => {
   const location = useLocation();
   const matchers = createMemo(() => expandOptionals(path()).map(path => createMatcher(path, undefined, matchFilters)));
@@ -268,8 +339,60 @@ const useMatch = (path, matchFilters) => {
     }
   });
 };
+
+/**
+ * `useCurrentMatches` returns all the matches for the current matched route.
+ * Useful for getting all the route information.
+ * 
+ * @example
+ * ```js
+ * const matches = useCurrentMatches();
+ * 
+ * const breadcrumbs = createMemo(() => matches().map(m => m.route.info.breadcrumb))
+ * ```
+ */
 const useCurrentMatches = () => useRouter().matches;
+
+/**
+ * Retrieves a reactive, store-like object containing the current route path parameters as defined in the Route.
+ * 
+ * @example
+ * ```js
+ * const params = useParams();
+ * 
+ * // fetch user based on the id path parameter
+ * const [user] = createResource(() => params.id, fetchUser);
+ * ```
+ */
 const useParams = () => useRouter().params;
+
+/**
+ * Retrieves a tuple containing a reactive object to read the current location's query parameters and a method to update them.
+ * The object is a proxy so you must access properties to subscribe to reactive updates.
+ * **Note** that values will be strings and property names will retain their casing.
+ * 
+ * The setter method accepts an object whose entries will be merged into the current query string.
+ * Values `''`, `undefined` and `null` will remove the key from the resulting query string.
+ * Updates will behave just like a navigation and the setter accepts the same optional second parameter as `navigate` and auto-scrolling is disabled by default.
+ * 
+ * @examples
+ * ```js
+ * const [searchParams, setSearchParams] = useSearchParams();
+ * 
+ * return (
+ *   <div>
+ *     <span>Page: {searchParams.page}</span>
+ *     <button
+ *       onClick={() =>
+ *         setSearchParams({ page: (parseInt(searchParams.page) || 0) + 1 })
+ *       }
+ *     >
+ *       Next Page
+ *     </button>
+ *   </div>
+ * );
+ * ```
+ */
 const useSearchParams = () => {
   const location = useLocation();
   const navigate = useNavigate();
@@ -283,6 +406,34 @@ const useSearchParams = () => {
   };
   return [location.query, setSearchParams];
 };
+
+/**
+ * useBeforeLeave takes a function that will be called prior to leaving a route.
+ * The function will be called with:
+ * 
+ * - from (*Location*): current location (before change).
+ * - to (*string | number*): path passed to `navigate`.
+ * - options (*NavigateOptions*): options passed to navigate.
+ * - preventDefault (*function*): call to block the route change.
+ * - defaultPrevented (*readonly boolean*): `true` if any previously called leave handlers called `preventDefault`.
+ * - retry (*function*, force?: boolean ): call to retry the same navigation, perhaps after confirming with the user. Pass `true` to skip running the leave handlers again (i.e. force navigate without confirming).
+ * 
+ * @example
+ * ```js
+ * useBeforeLeave((e: BeforeLeaveEventArgs) => {
+ *   if (form.isDirty && !e.defaultPrevented) {
+ *     // preventDefault to block immediately and prompt user async
+ *     e.preventDefault();
+ *     setTimeout(() => {
+ *       if (window.confirm("Discard unsaved changes - are you sure?")) {
+ *         // user wants to proceed anyway so retry with force=true
+ *         e.retry(true);
+ *       }
+ *     }, 100);
+ *   }
+ * });
+ * ```
+ */
 const useBeforeLeave = listener => {
   const s = useRouter().beforeLeave.subscribe({
     listener,
@@ -462,7 +613,7 @@ function createRouterContext(integration, branches, getContext, options = {}) {
       setReference(lastTransitionTarget.value);
       setState(lastTransitionTarget.state);
       resetErrorBoundaries();
-      if (!isServer) submissions[1]([]);
+      if (!isServer) submissions[1](subs => subs.filter(s => s.pending));
     }).finally(() => {
       if (lastTransitionTarget !== newTarget) return;
 
@@ -832,7 +983,7 @@ function dataOnly(event, routerState, branches) {
 }
 
 function intercept([value, setValue], get, set) {
-  return [get ? () => get(value()) : value, set ? v => setValue(set(v)) : setValue];
+  return [value, set ? v => setValue(set(v)) : setValue];
 }
 function createRouter(config) {
   let ignore = false;
@@ -906,6 +1057,10 @@ function getCache() {
   if (!req) throw new Error("Cannot find cache context");
   return (req.router || (req.router = {})).cache || (req.router.cache = new Map());
 }
+
+/**
+ * Revalidates the given cache entry/entries.
+ */
 function revalidate(key, force = true) {
   return startTransition(() => {
     const now = Date.now();
@@ -968,8 +1123,12 @@ function query(fn, name) {
       inPreloadFn && "then" in res && res.catch(() => {});
       return res;
     }
-    let res = !isServer && sharedConfig.context && sharedConfig.has(key) ? sharedConfig.load(key) // hydrating
-    : fn(...args);
+    let res;
+    if (!isServer && sharedConfig.has && sharedConfig.has(key)) {
+      res = sharedConfig.load(key); // hydrating
+      // @ts-ignore at least until we add a delete method to sharedConfig
+      delete globalThis._$HY.r[key];
+    } else res = fn(...args);
     if (cached) {
       cached[0] = now;
       cached[1] = res;

package/dist/routing.d.ts

@@ -6,16 +6,158 @@ export declare const useRouter: () => RouterContext;
 export declare const useRoute: () => RouteContext;
 export declare const useResolvedPath: (path: () => string) => Accessor<string | undefined>;
 export declare const useHref: (to: () => string | undefined) => Accessor<string | undefined>;
+/**
+ * Retrieves method to do navigation. The method accepts a path to navigate to and an optional object with the following options:
+ *
+ * - resolve (*boolean*, default `true`): resolve the path against the current route
+ * - replace (*boolean*, default `false`): replace the history entry
+ * - scroll (*boolean*, default `true`): scroll to top after navigation
+ * - state (*any*, default `undefined`): pass custom state to `location.state`
+ *
+ * **Note**: The state is serialized using the structured clone algorithm which does not support all object types.
+ *
+ * @example
+ * ```js
+ * const navigate = useNavigate();
+ *
+ * if (unauthorized) {
+ *   navigate("/login", { replace: true });
+ * }
+ * ```
+ */
 export declare const useNavigate: () => Navigator;
+/**
+ * Retrieves reactive `location` object useful for getting things like `pathname`.
+ *
+ * @example
+ * ```js
+ * const location = useLocation();
+ *
+ * const pathname = createMemo(() => parsePath(location.pathname));
+ * ```
+ */
 export declare const useLocation: <S = unknown>() => Location<S>;
+/**
+ * Retrieves signal that indicates whether the route is currently in a *Transition*.
+ * Useful for showing stale/pending state when the route resolution is *Suspended* during concurrent rendering.
+ *
+ * @example
+ * ```js
+ * const isRouting = useIsRouting();
+ *
+ * return (
+ *   <div classList={{ "grey-out": isRouting() }}>
+ *     <MyAwesomeContent />
+ *   </div>
+ * );
+ * ```
+ */
 export declare const useIsRouting: () => () => boolean;
+/**
+ * usePreloadRoute returns a function that can be used to preload a route manual.
+ * This is what happens automatically with link hovering and similar focus based behavior, but it is available here as an API.
+ *
+ * @example
+ * ```js
+ * const preload = usePreloadRoute();
+ *
+ * preload(`/users/settings`, { preloadData: true });
+ * ```
+ */
 export declare const usePreloadRoute: () => (url: string | URL, options?: {
     preloadData?: boolean;
 }) => void;
-export declare const useMatch: <S extends string>(path: () => S, matchFilters?: MatchFilters<S> | undefined) => Accessor<import("./types.js").PathMatch | undefined>;
+/**
+ * `useMatch` takes an accessor that returns the path and creates a `Memo` that returns match information if the current path matches the provided path.
+ * Useful for determining if a given path matches the current route.
+ *
+ * @example
+ * ```js
+ * const match = useMatch(() => props.href);
+ *
+ * return <div classList={{ active: Boolean(match()) }} />;
+ * ```
+ */
+export declare const useMatch: <S extends string>(path: () => S, matchFilters?: MatchFilters<S>) => Accessor<import("./types.js").PathMatch | undefined>;
+/**
+ * `useCurrentMatches` returns all the matches for the current matched route.
+ * Useful for getting all the route information.
+ *
+ * @example
+ * ```js
+ * const matches = useCurrentMatches();
+ *
+ * const breadcrumbs = createMemo(() => matches().map(m => m.route.info.breadcrumb))
+ * ```
+ */
 export declare const useCurrentMatches: () => () => RouteMatch[];
+/**
+ * Retrieves a reactive, store-like object containing the current route path parameters as defined in the Route.
+ *
+ * @example
+ * ```js
+ * const params = useParams();
+ *
+ * // fetch user based on the id path parameter
+ * const [user] = createResource(() => params.id, fetchUser);
+ * ```
+ */
 export declare const useParams: <T extends Params>() => T;
+/**
+ * Retrieves a tuple containing a reactive object to read the current location's query parameters and a method to update them.
+ * The object is a proxy so you must access properties to subscribe to reactive updates.
+ * **Note** that values will be strings and property names will retain their casing.
+ *
+ * The setter method accepts an object whose entries will be merged into the current query string.
+ * Values `''`, `undefined` and `null` will remove the key from the resulting query string.
+ * Updates will behave just like a navigation and the setter accepts the same optional second parameter as `navigate` and auto-scrolling is disabled by default.
+ *
+ * @examples
+ * ```js
+ * const [searchParams, setSearchParams] = useSearchParams();
+ *
+ * return (
+ *   <div>
+ *     <span>Page: {searchParams.page}</span>
+ *     <button
+ *       onClick={() =>
+ *         setSearchParams({ page: (parseInt(searchParams.page) || 0) + 1 })
+ *       }
+ *     >
+ *       Next Page
+ *     </button>
+ *   </div>
+ * );
+ * ```
+ */
 export declare const useSearchParams: <T extends SearchParams>() => [Partial<T>, (params: SetSearchParams, options?: Partial<NavigateOptions>) => void];
+/**
+ * useBeforeLeave takes a function that will be called prior to leaving a route.
+ * The function will be called with:
+ *
+ * - from (*Location*): current location (before change).
+ * - to (*string | number*): path passed to `navigate`.
+ * - options (*NavigateOptions*): options passed to navigate.
+ * - preventDefault (*function*): call to block the route change.
+ * - defaultPrevented (*readonly boolean*): `true` if any previously called leave handlers called `preventDefault`.
+ * - retry (*function*, force?: boolean ): call to retry the same navigation, perhaps after confirming with the user. Pass `true` to skip running the leave handlers again (i.e. force navigate without confirming).
+ *
+ * @example
+ * ```js
+ * useBeforeLeave((e: BeforeLeaveEventArgs) => {
+ *   if (form.isDirty && !e.defaultPrevented) {
+ *     // preventDefault to block immediately and prompt user async
+ *     e.preventDefault();
+ *     setTimeout(() => {
+ *       if (window.confirm("Discard unsaved changes - are you sure?")) {
+ *         // user wants to proceed anyway so retry with force=true
+ *         e.retry(true);
+ *       }
+ *     }, 100);
+ *   }
+ * });
+ * ```
+ */
 export declare const useBeforeLeave: (listener: (e: BeforeLeaveEventArgs) => void) => void;
 export declare function createRoutes(routeDef: RouteDefinition, base?: string): RouteDescription[];
 export declare function createBranch(routes: RouteDescription[], index?: number): Branch;

package/dist/routing.js

@@ -20,13 +20,79 @@ export const useHref = (to) => {
         return to_ !== undefined ? router.renderPath(to_) : to_;
     });
 };
+/**
+ * Retrieves method to do navigation. The method accepts a path to navigate to and an optional object with the following options:
+ *
+ * - resolve (*boolean*, default `true`): resolve the path against the current route
+ * - replace (*boolean*, default `false`): replace the history entry
+ * - scroll (*boolean*, default `true`): scroll to top after navigation
+ * - state (*any*, default `undefined`): pass custom state to `location.state`
+ *
+ * **Note**: The state is serialized using the structured clone algorithm which does not support all object types.
+ *
+ * @example
+ * ```js
+ * const navigate = useNavigate();
+ *
+ * if (unauthorized) {
+ *   navigate("/login", { replace: true });
+ * }
+ * ```
+ */
 export const useNavigate = () => useRouter().navigatorFactory();
+/**
+ * Retrieves reactive `location` object useful for getting things like `pathname`.
+ *
+ * @example
+ * ```js
+ * const location = useLocation();
+ *
+ * const pathname = createMemo(() => parsePath(location.pathname));
+ * ```
+ */
 export const useLocation = () => useRouter().location;
+/**
+ * Retrieves signal that indicates whether the route is currently in a *Transition*.
+ * Useful for showing stale/pending state when the route resolution is *Suspended* during concurrent rendering.
+ *
+ * @example
+ * ```js
+ * const isRouting = useIsRouting();
+ *
+ * return (
+ *   <div classList={{ "grey-out": isRouting() }}>
+ *     <MyAwesomeContent />
+ *   </div>
+ * );
+ * ```
+ */
 export const useIsRouting = () => useRouter().isRouting;
+/**
+ * usePreloadRoute returns a function that can be used to preload a route manual.
+ * This is what happens automatically with link hovering and similar focus based behavior, but it is available here as an API.
+ *
+ * @example
+ * ```js
+ * const preload = usePreloadRoute();
+ *
+ * preload(`/users/settings`, { preloadData: true });
+ * ```
+ */
 export const usePreloadRoute = () => {
     const pre = useRouter().preloadRoute;
     return (url, options = {}) => pre(url instanceof URL ? url : new URL(url, mockBase), options.preloadData);
 };
+/**
+ * `useMatch` takes an accessor that returns the path and creates a `Memo` that returns match information if the current path matches the provided path.
+ * Useful for determining if a given path matches the current route.
+ *
+ * @example
+ * ```js
+ * const match = useMatch(() => props.href);
+ *
+ * return <div classList={{ active: Boolean(match()) }} />;
+ * ```
+ */
 export const useMatch = (path, matchFilters) => {
     const location = useLocation();
     const matchers = createMemo(() => expandOptionals(path()).map(path => createMatcher(path, undefined, matchFilters)));
@@ -38,8 +104,57 @@ export const useMatch = (path, matchFilters) => {
         }
     });
 };
+/**
+ * `useCurrentMatches` returns all the matches for the current matched route.
+ * Useful for getting all the route information.
+ *
+ * @example
+ * ```js
+ * const matches = useCurrentMatches();
+ *
+ * const breadcrumbs = createMemo(() => matches().map(m => m.route.info.breadcrumb))
+ * ```
+ */
 export const useCurrentMatches = () => useRouter().matches;
+/**
+ * Retrieves a reactive, store-like object containing the current route path parameters as defined in the Route.
+ *
+ * @example
+ * ```js
+ * const params = useParams();
+ *
+ * // fetch user based on the id path parameter
+ * const [user] = createResource(() => params.id, fetchUser);
+ * ```
+ */
 export const useParams = () => useRouter().params;
+/**
+ * Retrieves a tuple containing a reactive object to read the current location's query parameters and a method to update them.
+ * The object is a proxy so you must access properties to subscribe to reactive updates.
+ * **Note** that values will be strings and property names will retain their casing.
+ *
+ * The setter method accepts an object whose entries will be merged into the current query string.
+ * Values `''`, `undefined` and `null` will remove the key from the resulting query string.
+ * Updates will behave just like a navigation and the setter accepts the same optional second parameter as `navigate` and auto-scrolling is disabled by default.
+ *
+ * @examples
+ * ```js
+ * const [searchParams, setSearchParams] = useSearchParams();
+ *
+ * return (
+ *   <div>
+ *     <span>Page: {searchParams.page}</span>
+ *     <button
+ *       onClick={() =>
+ *         setSearchParams({ page: (parseInt(searchParams.page) || 0) + 1 })
+ *       }
+ *     >
+ *       Next Page
+ *     </button>
+ *   </div>
+ * );
+ * ```
+ */
 export const useSearchParams = () => {
     const location = useLocation();
     const navigate = useNavigate();
@@ -53,6 +168,33 @@ export const useSearchParams = () => {
     };
     return [location.query, setSearchParams];
 };
+/**
+ * useBeforeLeave takes a function that will be called prior to leaving a route.
+ * The function will be called with:
+ *
+ * - from (*Location*): current location (before change).
+ * - to (*string | number*): path passed to `navigate`.
+ * - options (*NavigateOptions*): options passed to navigate.
+ * - preventDefault (*function*): call to block the route change.
+ * - defaultPrevented (*readonly boolean*): `true` if any previously called leave handlers called `preventDefault`.
+ * - retry (*function*, force?: boolean ): call to retry the same navigation, perhaps after confirming with the user. Pass `true` to skip running the leave handlers again (i.e. force navigate without confirming).
+ *
+ * @example
+ * ```js
+ * useBeforeLeave((e: BeforeLeaveEventArgs) => {
+ *   if (form.isDirty && !e.defaultPrevented) {
+ *     // preventDefault to block immediately and prompt user async
+ *     e.preventDefault();
+ *     setTimeout(() => {
+ *       if (window.confirm("Discard unsaved changes - are you sure?")) {
+ *         // user wants to proceed anyway so retry with force=true
+ *         e.retry(true);
+ *       }
+ *     }, 100);
+ *   }
+ * });
+ * ```
+ */
 export const useBeforeLeave = (listener) => {
     const s = useRouter().beforeLeave.subscribe({
         listener,
@@ -227,7 +369,7 @@ export function createRouterContext(integration, branches, getContext, options =
             setState(lastTransitionTarget.state);
             resetErrorBoundaries();
             if (!isServer)
-                submissions[1]([]);
+                submissions[1](subs => subs.filter(s => s.pending));
         }).finally(() => {
             if (lastTransitionTarget !== newTarget)
                 return;

package/package.json

@@ -6,7 +6,7 @@
     "Ryan Turnquist"
   ],
   "license": "MIT",
-  "version": "0.15.1",
+  "version": "0.15.3",
   "homepage": "https://github.com/solidjs/solid-router#readme",
   "repository": {
     "type": "git",
@@ -29,23 +29,23 @@
   ],
   "sideEffects": false,
   "devDependencies": {
-    "@babel/core": "^7.23.9",
-    "@babel/preset-typescript": "^7.23.3",
-    "@changesets/cli": "^2.27.1",
+    "@babel/core": "^7.26.0",
+    "@babel/preset-typescript": "^7.26.0",
+    "@changesets/cli": "^2.27.10",
     "@rollup/plugin-babel": "6.0.4",
-    "@rollup/plugin-node-resolve": "15.2.3",
+    "@rollup/plugin-node-resolve": "15.3.0",
     "@rollup/plugin-terser": "0.4.4",
-    "@types/jest": "^29.5.11",
-    "@types/node": "^20.11.14",
-    "babel-preset-solid": "^1.9.2",
-    "jsdom": "^24.0.0",
-    "prettier": "^2.7.0",
-    "rollup": "^4.9.6",
-    "solid-js": "^1.9.2",
-    "typescript": "^5.3.3",
-    "vite": "^5.4.8",
-    "vite-plugin-solid": "^2.9.1",
-    "vitest": "^2.1.2"
+    "@types/jest": "^29.5.14",
+    "@types/node": "^22.10.0",
+    "babel-preset-solid": "^1.9.3",
+    "jsdom": "^25.0.1",
+    "prettier": "^3.4.1",
+    "rollup": "^4.27.4",
+    "solid-js": "^1.9.3",
+    "typescript": "^5.7.2",
+    "vite": "^6.0.0",
+    "vite-plugin-solid": "^2.11.0",
+    "vitest": "^2.1.6"
   },
   "peerDependencies": {
     "solid-js": "^1.8.6"

package/dist/data/cache.d.ts

@@ -1,15 +0,0 @@
-import type { CacheEntry, NarrowResponse } from "../types.js";
-export declare function revalidate(key?: string | string[] | void, force?: boolean): Promise<void>;
-export declare function cacheKeyOp(key: string | string[] | void, fn: (cacheEntry: CacheEntry) => void): void;
-export type CachedFunction<T extends (...args: any) => any> = T extends (...args: infer A) => infer R ? ([] extends {
-    [K in keyof A]-?: A[K];
-} ? (...args: never[]) => R extends Promise<infer P> ? Promise<NarrowResponse<P>> : NarrowResponse<R> : (...args: A) => R extends Promise<infer P> ? Promise<NarrowResponse<P>> : NarrowResponse<R>) & {
-    keyFor: (...args: A) => string;
-    key: string;
-} : never;
-export declare function cache<T extends (...args: any) => any>(fn: T, name: string): CachedFunction<T>;
-export declare namespace cache {
-    var set: (key: string, value: any) => void;
-    var clear: () => void;
-}
-export declare function hashKey<T extends Array<any>>(args: T): string;

package/dist/data/cache.js

@@ -1,209 +0,0 @@
-import { createSignal, getListener, getOwner, onCleanup, sharedConfig, startTransition } from "solid-js";
-import { getRequestEvent, isServer } from "solid-js/web";
-import { useNavigate, getIntent, getInPreloadFn } from "../routing.js";
-const LocationHeader = "Location";
-const PRELOAD_TIMEOUT = 5000;
-const CACHE_TIMEOUT = 180000;
-let cacheMap = new Map();
-// cleanup forward/back cache
-if (!isServer) {
-    setInterval(() => {
-        const now = Date.now();
-        for (let [k, v] of cacheMap.entries()) {
-            if (!v[3].count && now - v[0] > CACHE_TIMEOUT) {
-                cacheMap.delete(k);
-            }
-        }
-    }, 300000);
-}
-function getCache() {
-    if (!isServer)
-        return cacheMap;
-    const req = getRequestEvent();
-    if (!req)
-        throw new Error("Cannot find cache context");
-    return (req.router || (req.router = {})).cache || (req.router.cache = new Map());
-}
-export function revalidate(key, force = true) {
-    return startTransition(() => {
-        const now = Date.now();
-        cacheKeyOp(key, entry => {
-            force && (entry[0] = 0); //force cache miss
-            entry[3][1](now); // retrigger live signals
-        });
-    });
-}
-export function cacheKeyOp(key, fn) {
-    key && !Array.isArray(key) && (key = [key]);
-    for (let k of cacheMap.keys()) {
-        if (key === undefined || matchKey(k, key))
-            fn(cacheMap.get(k));
-    }
-}
-export function cache(fn, name) {
-    // prioritize GET for server functions
-    if (fn.GET)
-        fn = fn.GET;
-    const cachedFn = ((...args) => {
-        const cache = getCache();
-        const intent = getIntent();
-        const inPreloadFn = getInPreloadFn();
-        const owner = getOwner();
-        const navigate = owner ? useNavigate() : undefined;
-        const now = Date.now();
-        const key = name + hashKey(args);
-        let cached = cache.get(key);
-        let tracking;
-        if (isServer) {
-            const e = getRequestEvent();
-            if (e) {
-                const dataOnly = (e.router || (e.router = {})).dataOnly;
-                if (dataOnly) {
-                    const data = e && (e.router.data || (e.router.data = {}));
-                    if (data && key in data)
-                        return data[key];
-                    if (Array.isArray(dataOnly) && !matchKey(key, dataOnly)) {
-                        data[key] = undefined;
-                        return Promise.resolve();
-                    }
-                }
-            }
-        }
-        if (getListener() && !isServer) {
-            tracking = true;
-            onCleanup(() => cached[3].count--);
-        }
-        if (cached &&
-            cached[0] &&
-            (isServer ||
-                intent === "native" ||
-                cached[3].count ||
-                Date.now() - cached[0] < PRELOAD_TIMEOUT)) {
-            if (tracking) {
-                cached[3].count++;
-                cached[3][0](); // track
-            }
-            if (cached[2] === "preload" && intent !== "preload") {
-                cached[0] = now;
-            }
-            let res = cached[1];
-            if (intent !== "preload") {
-                res =
-                    "then" in cached[1]
-                        ? cached[1].then(handleResponse(false), handleResponse(true))
-                        : handleResponse(false)(cached[1]);
-                !isServer && intent === "navigate" && startTransition(() => cached[3][1](cached[0])); // update version
-            }
-            inPreloadFn && "then" in res && res.catch(() => { });
-            return res;
-        }
-        let res = !isServer && sharedConfig.context && sharedConfig.has(key)
-            ? sharedConfig.load(key) // hydrating
-            : fn(...args);
-        if (cached) {
-            cached[0] = now;
-            cached[1] = res;
-            cached[2] = intent;
-            !isServer && intent === "navigate" && startTransition(() => cached[3][1](cached[0])); // update version
-        }
-        else {
-            cache.set(key, (cached = [now, res, intent, createSignal(now)]));
-            cached[3].count = 0;
-        }
-        if (tracking) {
-            cached[3].count++;
-            cached[3][0](); // track
-        }
-        if (isServer) {
-            const e = getRequestEvent();
-            if (e && e.router.dataOnly)
-                return (e.router.data[key] = res);
-        }
-        if (intent !== "preload") {
-            res =
-                "then" in res
-                    ? res.then(handleResponse(false), handleResponse(true))
-                    : handleResponse(false)(res);
-        }
-        inPreloadFn && "then" in res && res.catch(() => { });
-        // serialize on server
-        if (isServer &&
-            sharedConfig.context &&
-            sharedConfig.context.async &&
-            !sharedConfig.context.noHydrate) {
-            const e = getRequestEvent();
-            (!e || !e.serverOnly) && sharedConfig.context.serialize(key, res);
-        }
-        return res;
-        function handleResponse(error) {
-            return async (v) => {
-                if (v instanceof Response) {
-                    const url = v.headers.get(LocationHeader);
-                    if (url !== null) {
-                        // client + server relative redirect
-                        if (navigate && url.startsWith("/"))
-                            startTransition(() => {
-                                navigate(url, { replace: true });
-                            });
-                        else if (!isServer)
-                            window.location.href = url;
-                        else if (isServer) {
-                            const e = getRequestEvent();
-                            if (e)
-                                e.response = { status: 302, headers: new Headers({ Location: url }) };
-                        }
-                        return;
-                    }
-                    if (v.customBody)
-                        v = await v.customBody();
-                }
-                if (error)
-                    throw v;
-                return v;
-            };
-        }
-    });
-    cachedFn.keyFor = (...args) => name + hashKey(args);
-    cachedFn.key = name;
-    return cachedFn;
-}
-cache.set = (key, value) => {
-    const cache = getCache();
-    const now = Date.now();
-    let cached = cache.get(key);
-    if (cached) {
-        cached[0] = now;
-        cached[1] = value;
-        cached[2] = "preload";
-    }
-    else {
-        cache.set(key, (cached = [now, value, , createSignal(now)]));
-        cached[3].count = 0;
-    }
-};
-cache.clear = () => getCache().clear();
-function matchKey(key, keys) {
-    for (let k of keys) {
-        if (k && key.startsWith(k))
-            return true;
-    }
-    return false;
-}
-// Modified from the amazing Tanstack Query library (MIT)
-// https://github.com/TanStack/query/blob/main/packages/query-core/src/utils.ts#L168
-export function hashKey(args) {
-    return JSON.stringify(args, (_, val) => isPlainObject(val)
-        ? Object.keys(val)
-            .sort()
-            .reduce((result, key) => {
-            result[key] = val[key];
-            return result;
-        }, {})
-        : val);
-}
-function isPlainObject(obj) {
-    let proto;
-    return (obj != null &&
-        typeof obj === "object" &&
-        (!(proto = Object.getPrototypeOf(obj)) || proto === Object.prototype));
-}

package/dist/routers/createIntegration.d.ts

@@ -1,4 +0,0 @@
-import type { LocationChange, RouterContext, RouterUtils } from "../types";
-export declare function createIntegration(get: () => string | LocationChange, set: (next: LocationChange) => void, init?: (notify: (value?: string | LocationChange) => void) => () => void, create?: (router: RouterContext) => void, utils?: Partial<RouterUtils>): (props: import("./components").RouterProps) => import("solid-js").JSX.Element;
-export declare function bindEvent(target: EventTarget, type: string, handler: EventListener): () => void;
-export declare function scrollToHash(hash: string, fallbackTop?: boolean): void;

package/dist/routers/createIntegration.js

@@ -1,49 +0,0 @@
-import { createSignal, onCleanup } from "solid-js";
-import { createRouter } from "./components";
-function intercept([value, setValue], get, set) {
-    return [get ? () => get(value()) : value, set ? (v) => setValue(set(v)) : setValue];
-}
-function querySelector(selector) {
-    if (selector === "#") {
-        return null;
-    }
-    // Guard against selector being an invalid CSS selector
-    try {
-        return document.querySelector(selector);
-    }
-    catch (e) {
-        return null;
-    }
-}
-export function createIntegration(get, set, init, create, utils) {
-    let ignore = false;
-    const wrap = (value) => (typeof value === "string" ? { value } : value);
-    const signal = intercept(createSignal(wrap(get()), { equals: (a, b) => a.value === b.value }), undefined, next => {
-        !ignore && set(next);
-        return next;
-    });
-    init &&
-        onCleanup(init((value = get()) => {
-            ignore = true;
-            signal[1](wrap(value));
-            ignore = false;
-        }));
-    return createRouter({
-        signal,
-        create,
-        utils
-    });
-}
-export function bindEvent(target, type, handler) {
-    target.addEventListener(type, handler);
-    return () => target.removeEventListener(type, handler);
-}
-export function scrollToHash(hash, fallbackTop) {
-    const el = querySelector(`#${hash}`);
-    if (el) {
-        el.scrollIntoView();
-    }
-    else if (fallbackTop) {
-        window.scrollTo(0, 0);
-    }
-}

package/dist/routers/createIntegration.jsx

@@ -1,48 +0,0 @@
-import { createSignal, onCleanup } from "solid-js";
-function intercept([value, setValue], get, set) {
-    return [get ? () => get(value()) : value, set ? (v) => setValue(set(v)) : setValue];
-}
-function querySelector(selector) {
-    if (selector === "#") {
-        return null;
-    }
-    // Guard against selector being an invalid CSS selector
-    try {
-        return document.querySelector(selector);
-    }
-    catch (e) {
-        return null;
-    }
-}
-export function createIntegration(get, set, init, create, utils) {
-    let ignore = false;
-    const wrap = (value) => (typeof value === "string" ? { value } : value);
-    const signal = intercept(createSignal(wrap(get()), { equals: (a, b) => a.value === b.value }), undefined, next => {
-        !ignore && set(next);
-        return next;
-    });
-    init &&
-        onCleanup(init((value = get()) => {
-            ignore = true;
-            signal[1](wrap(value));
-            ignore = false;
-        }));
-    return {
-        signal,
-        create,
-        utils
-    };
-}
-export function bindEvent(target, type, handler) {
-    target.addEventListener(type, handler);
-    return () => target.removeEventListener(type, handler);
-}
-export function scrollToHash(hash, fallbackTop) {
-    const el = querySelector(`#${hash}`);
-    if (el) {
-        el.scrollIntoView();
-    }
-    else if (fallbackTop) {
-        window.scrollTo(0, 0);
-    }
-}