@solidjs/router 0.15.3 → 0.16.0

package/dist/data/createAsync.js

@@ -1,15 +1,15 @@
 /**
  * This is mock of the eventual Solid 2.0 primitive. It is not fully featured.
  */
-import { createResource, sharedConfig, untrack } from "solid-js";
+import { createResource, sharedConfig, untrack, catchError } from "solid-js";
 import { createStore, reconcile, unwrap } from "solid-js/store";
 import { isServer } from "solid-js/web";
 export function createAsync(fn, options) {
     let resource;
     let prev = () => !resource || resource.state === "unresolved" ? undefined : resource.latest;
-    [resource] = createResource(() => subFetch(fn, untrack(prev)), v => v, options);
+    [resource] = createResource(() => subFetch(fn, catchError(() => untrack(prev), () => undefined)), v => v, options);
     const resultAccessor = (() => resource());
-    Object.defineProperty(resultAccessor, 'latest', {
+    Object.defineProperty(resultAccessor, "latest", {
         get() {
             return resource.latest;
         }
@@ -18,13 +18,15 @@ export function createAsync(fn, options) {
 }
 export function createAsyncStore(fn, options = {}) {
     let resource;
-    let prev = () => !resource || resource.state === "unresolved" ? undefined : unwrap(resource.latest);
-    [resource] = createResource(() => subFetch(fn, untrack(prev)), v => v, {
+    let prev = () => !resource || resource.state === "unresolved"
+        ? undefined
+        : unwrap(resource.latest);
+    [resource] = createResource(() => subFetch(fn, catchError(() => untrack(prev), () => undefined)), v => v, {
         ...options,
         storage: (init) => createDeepSignal(init, options.reconcile)
     });
     const resultAccessor = (() => resource());
-    Object.defineProperty(resultAccessor, 'latest', {
+    Object.defineProperty(resultAccessor, "latest", {
         get() {
             return resource.latest;
         }

package/dist/data/query.js

@@ -146,6 +146,15 @@ export function query(fn, name) {
         function handleResponse(error) {
             return async (v) => {
                 if (v instanceof Response) {
+                    const e = getRequestEvent();
+                    if (e) {
+                        for (const [key, value] of v.headers) {
+                            if (key == "set-cookie")
+                                e.response.headers.append("set-cookie", value);
+                            else
+                                e.response.headers.set(key, value);
+                        }
+                    }
                     const url = v.headers.get(LocationHeader);
                     if (url !== null) {
                         // client + server relative redirect
@@ -155,11 +164,8 @@ export function query(fn, name) {
                             });
                         else if (!isServer)
                             window.location.href = url;
-                        else if (isServer) {
-                            const e = getRequestEvent();
-                            if (e)
-                                e.response = { status: 302, headers: new Headers({ Location: url }) };
-                        }
+                        else if (e)
+                            e.response.status = 302;
                         return;
                     }
                     if (v.customBody)

package/dist/data/response.d.ts

@@ -1,4 +1,4 @@
-import type { RouterResponseInit, CustomResponse } from "../types";
+import type { RouterResponseInit, CustomResponse } from "../types.js";
 export declare function redirect(url: string, init?: number | RouterResponseInit): CustomResponse<never>;
 export declare function reload(init?: RouterResponseInit): CustomResponse<never>;
 export declare function json<T>(data: T, init?: RouterResponseInit): CustomResponse<T>;

package/dist/index.d.ts

@@ -4,4 +4,4 @@ export * from "./lifecycle.js";
 export { useHref, useIsRouting, useLocation, useMatch, useCurrentMatches, useNavigate, useParams, useResolvedPath, useSearchParams, useBeforeLeave, usePreloadRoute } from "./routing.js";
 export { mergeSearchString as _mergeSearchString } from "./utils.js";
 export * from "./data/index.js";
-export type { Location, LocationChange, MatchFilter, MatchFilters, NavigateOptions, Navigator, OutputMatch, Params, PathMatch, RouteSectionProps, RoutePreloadFunc, RoutePreloadFuncArgs, RouteDefinition, RouteDescription, RouteMatch, RouterIntegration, RouterUtils, SetParams, Submission, BeforeLeaveEventArgs, RouteLoadFunc, RouteLoadFuncArgs, RouterResponseInit, CustomResponse } from "./types.js";
+export type { Location, LocationChange, SearchParams, MatchFilter, MatchFilters, NavigateOptions, Navigator, OutputMatch, Params, PathMatch, RouteSectionProps, RoutePreloadFunc, RoutePreloadFuncArgs, RouteDefinition, RouteDescription, RouteMatch, RouterIntegration, RouterUtils, SetParams, Submission, BeforeLeaveEventArgs, RouteLoadFunc, RouteLoadFuncArgs, RouterResponseInit, CustomResponse } from "./types.js";

package/dist/index.js

@@ -1,5 +1,5 @@
 import { isServer, getRequestEvent, createComponent as createComponent$1, memo, delegateEvents, spread, mergeProps as mergeProps$1, template } from 'solid-js/web';
-import { getOwner, runWithOwner, createMemo, createContext, onCleanup, useContext, untrack, createSignal, createRenderEffect, on, startTransition, resetErrorBoundaries, batch, createComponent, children, mergeProps, Show, createRoot, sharedConfig, getListener, $TRACK, splitProps, createResource } from 'solid-js';
+import { getOwner, runWithOwner, createMemo, createContext, onCleanup, useContext, untrack, createSignal, createRenderEffect, on, startTransition, resetErrorBoundaries, batch, createComponent, children, mergeProps, Show, createRoot, sharedConfig, getListener, $TRACK, splitProps, createResource, catchError } from 'solid-js';
 import { createStore, reconcile, unwrap } from 'solid-js/store';
 
 function createBeforeLeave() {
@@ -193,6 +193,9 @@ function createMemoObject(fn) {
     },
     ownKeys() {
       return Reflect.ownKeys(fn());
+    },
+    has(_, property) {
+      return property in fn();
     }
   });
 }
@@ -234,8 +237,18 @@ function expandOptionals(pattern) {
   }
   return expandOptionals(suffix).reduce((results, expansion) => [...results, ...prefixes.map(p => p + expansion)], []);
 }
+function setFunctionName(obj, value) {
+  Object.defineProperty(obj, "name", {
+    value,
+    writable: false,
+    configurable: false
+  });
+  return obj;
+}
 
 const MAX_REDIRECTS = 100;
+
+/** Consider this API opaque and internal. It is likely to change in the future. */
 const RouterContextObj = createContext();
 const RouteContextObj = createContext();
 const useRouter = () => invariant(useContext(RouterContextObj), "<A> and 'use' router primitives can be only used inside a Route.");
@@ -927,7 +940,10 @@ function Routes(props) {
         }
         createRoot(dispose => {
           disposers[i] = dispose;
-          next[i] = createRouteContext(props.routerState, next[i - 1] || props.routerState.base, createOutlet(() => routeStates()[i + 1]), () => props.routerState.matches()[i]);
+          next[i] = createRouteContext(props.routerState, next[i - 1] || props.routerState.base, createOutlet(() => routeStates()[i + 1]), () => {
+            const routeMatches = props.routerState.matches();
+            return routeMatches[i] ?? routeMatches[0];
+          });
         });
       }
     }
@@ -1159,6 +1175,12 @@ function query(fn, name) {
     function handleResponse(error) {
       return async v => {
         if (v instanceof Response) {
+          const e = getRequestEvent();
+          if (e) {
+            for (const [key, value] of v.headers) {
+              if (key == "set-cookie") e.response.headers.append("set-cookie", value);else e.response.headers.set(key, value);
+            }
+          }
           const url = v.headers.get(LocationHeader);
           if (url !== null) {
             // client + server relative redirect
@@ -1166,15 +1188,7 @@ function query(fn, name) {
               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
-                })
-              };
-            }
+            });else if (!isServer) window.location.href = url;else if (e) e.response.status = 302;
             return;
           }
           if (v.customBody) v = await v.customBody();
@@ -1319,8 +1333,10 @@ function action(fn, options = {}) {
   const o = typeof options === "string" ? {
     name: options
   } : options;
-  const url = fn.url || o.name && `https://action/${o.name}` || (!isServer ? `https://action/${hashString(fn.toString())}` : "");
+  const name = o.name || (!isServer ? String(hashString(fn.toString())) : undefined);
+  const url = fn.url || name && `https://action/${name}` || "";
   mutate.base = url;
+  if (name) setFunctionName(mutate, name);
   return toAction(mutate, url);
 }
 function toAction(fn, url) {
@@ -1382,7 +1398,12 @@ async function handleResponse(response, error, navigate) {
   } : undefined;
 }
 
-function setupNativeEvents(preload = true, explicitLinks = false, actionBase = "/_server", transformUrl) {
+function setupNativeEvents({
+  preload = true,
+  explicitLinks = false,
+  actionBase = "/_server",
+  transformUrl
+} = {}) {
   return router => {
     const basePath = router.base.path();
     const navigateFromRoute = router.navigatorFactory(router.base);
@@ -1515,7 +1536,7 @@ function Router(props) {
       saveCurrentDepth();
     },
     init: notify => bindEvent(window, "popstate", notifyIfNotBlocked(notify, delta => {
-      if (delta && delta < 0) {
+      if (delta) {
         return !beforeLeave.confirm(delta);
       } else {
         const s = getSource();
@@ -1524,7 +1545,12 @@ function Router(props) {
         });
       }
     })),
-    create: setupNativeEvents(props.preload, props.explicitLinks, props.actionBase, props.transformUrl),
+    create: setupNativeEvents({
+      preload: props.preload,
+      explicitLinks: props.explicitLinks,
+      actionBase: props.actionBase,
+      transformUrl: props.transformUrl
+    }),
     utils: {
       go: delta => window.history.go(delta),
       beforeLeave
@@ -1565,7 +1591,11 @@ function HashRouter(props) {
       saveCurrentDepth();
     },
     init: notify => bindEvent(window, "hashchange", notifyIfNotBlocked(notify, delta => !beforeLeave.confirm(delta && delta < 0 ? delta : getSource()))),
-    create: setupNativeEvents(props.preload, props.explicitLinks, props.actionBase),
+    create: setupNativeEvents({
+      preload: props.preload,
+      explicitLinks: props.explicitLinks,
+      actionBase: props.actionBase
+    }),
     utils: {
       go: delta => window.history.go(delta),
       renderPath: path => `#${path}`,
@@ -1627,7 +1657,11 @@ function MemoryRouter(props) {
     get: memoryHistory.get,
     set: memoryHistory.set,
     init: memoryHistory.listen,
-    create: setupNativeEvents(props.preload, props.explicitLinks, props.actionBase),
+    create: setupNativeEvents({
+      preload: props.preload,
+      explicitLinks: props.explicitLinks,
+      actionBase: props.actionBase
+    }),
     utils: {
       go: memoryHistory.go
     }
@@ -1709,9 +1743,10 @@ function Navigate(props) {
 function createAsync(fn, options) {
   let resource;
   let prev = () => !resource || resource.state === "unresolved" ? undefined : resource.latest;
-  [resource] = createResource(() => subFetch(fn, untrack(prev)), v => v, options);
+  [resource] = createResource(() => subFetch(fn, catchError(() => untrack(prev), () => undefined)), v => v, options);
   const resultAccessor = () => resource();
-  Object.defineProperty(resultAccessor, 'latest', {
+  if (options?.name) setFunctionName(resultAccessor, options.name);
+  Object.defineProperty(resultAccessor, "latest", {
     get() {
       return resource.latest;
     }
@@ -1721,12 +1756,12 @@ function createAsync(fn, options) {
 function createAsyncStore(fn, options = {}) {
   let resource;
   let prev = () => !resource || resource.state === "unresolved" ? undefined : unwrap(resource.latest);
-  [resource] = createResource(() => subFetch(fn, untrack(prev)), v => v, {
+  [resource] = createResource(() => subFetch(fn, catchError(() => untrack(prev), () => undefined)), v => v, {
     ...options,
     storage: init => createDeepSignal(init, options.reconcile)
   });
   const resultAccessor = () => resource();
-  Object.defineProperty(resultAccessor, 'latest', {
+  Object.defineProperty(resultAccessor, "latest", {
     get() {
       return resource.latest;
     }
@@ -1841,4 +1876,4 @@ function json(data, init = {}) {
   return response;
 }
 
-export { A, HashRouter, MemoryRouter, Navigate, Route, Router, StaticRouter, mergeSearchString as _mergeSearchString, action, cache, createAsync, createAsyncStore, createBeforeLeave, createMemoryHistory, createRouter, json, keepDepth, notifyIfNotBlocked, query, redirect, reload, revalidate, saveCurrentDepth, useAction, useBeforeLeave, useCurrentMatches, useHref, useIsRouting, useLocation, useMatch, useNavigate, useParams, usePreloadRoute, useResolvedPath, useSearchParams, useSubmission, useSubmissions };
+export { A, HashRouter, MemoryRouter, Navigate, Route, Router, RouterContextObj as RouterContext, StaticRouter, mergeSearchString as _mergeSearchString, action, cache, createAsync, createAsyncStore, createBeforeLeave, createMemoryHistory, createRouter, json, keepDepth, notifyIfNotBlocked, query, redirect, reload, revalidate, saveCurrentDepth, useAction, useBeforeLeave, useCurrentMatches, useHref, useIsRouting, useLocation, useMatch, useNavigate, useParams, usePreloadRoute, useResolvedPath, useSearchParams, useSubmission, useSubmissions };

package/dist/routers/HashRouter.d.ts

@@ -1,5 +1,5 @@
 import type { JSX } from "solid-js";
-import type { BaseRouterProps } from "./components.js";
+import type { BaseRouterProps } from "./components.jsx";
 export declare function hashParser(str: string): string;
 export type HashRouterProps = BaseRouterProps & {
     actionBase?: string;

package/dist/routers/Router.js

@@ -28,7 +28,7 @@ export function Router(props) {
             saveCurrentDepth();
         },
         init: notify => bindEvent(window, "popstate", notifyIfNotBlocked(notify, delta => {
-            if (delta && delta < 0) {
+            if (delta) {
                 return !beforeLeave.confirm(delta);
             }
             else {

package/dist/routers/components.d.ts

@@ -1,5 +1,5 @@
 import type { Component, JSX } from "solid-js";
-import type { MatchFilters, RouteDefinition, RouterIntegration, RouteSectionProps, RoutePreloadFunc } from "../types.js";
+import type { MatchFilters, RouteDefinition, RoutePreloadFunc, RouterIntegration, RouteSectionProps } from "../types.js";
 export type BaseRouterProps = {
     base?: string;
     /**

package/dist/routers/components.jsx

@@ -1,6 +1,6 @@
 /*@refresh skip*/
-import { getRequestEvent, isServer } from "solid-js/web";
 import { children, createMemo, createRoot, getOwner, mergeProps, on, Show, untrack } from "solid-js";
+import { getRequestEvent, isServer } from "solid-js/web";
 import { createBranches, createRouteContext, createRouterContext, getIntent, getRouteMatches, RouteContextObj, RouterContextObj, setInPreloadFn } from "../routing.js";
 export const createRouterComponent = (router) => (props) => {
     const { base } = props;
@@ -70,7 +70,10 @@ function Routes(props) {
                 }
                 createRoot(dispose => {
                     disposers[i] = dispose;
-                    next[i] = createRouteContext(props.routerState, next[i - 1] || props.routerState.base, createOutlet(() => routeStates()[i + 1]), () => props.routerState.matches()[i]);
+                    next[i] = createRouteContext(props.routerState, next[i - 1] || props.routerState.base, createOutlet(() => routeStates()[i + 1]), () => {
+                        const routeMatches = props.routerState.matches();
+                        return routeMatches[i] ?? routeMatches[0];
+                    });
                 });
             }
         }

package/dist/routers/createRouter.d.ts

@@ -1,4 +1,4 @@
-import type { LocationChange, RouterContext, RouterUtils } from "../types.ts";
+import type { LocationChange, RouterContext, RouterUtils } from "../types.js";
 export declare function createRouter(config: {
     get: () => string | LocationChange;
     set: (next: LocationChange) => void;

package/dist/src/components.d.ts

@@ -0,0 +1,31 @@
+import type { JSX } from "solid-js";
+import type { Location, Navigator } from "./types.js";
+declare module "solid-js" {
+    namespace JSX {
+        interface AnchorHTMLAttributes<T> {
+            state?: string;
+            noScroll?: boolean;
+            replace?: boolean;
+            preload?: boolean;
+            link?: boolean;
+        }
+    }
+}
+export interface AnchorProps extends Omit<JSX.AnchorHTMLAttributes<HTMLAnchorElement>, "state"> {
+    href: string;
+    replace?: boolean | undefined;
+    noScroll?: boolean | undefined;
+    state?: unknown | undefined;
+    inactiveClass?: string | undefined;
+    activeClass?: string | undefined;
+    end?: boolean | undefined;
+}
+export declare function A(props: AnchorProps): JSX.Element;
+export interface NavigateProps {
+    href: ((args: {
+        navigate: Navigator;
+        location: Location;
+    }) => string) | string;
+    state?: unknown;
+}
+export declare function Navigate(props: NavigateProps): null;

package/dist/src/components.jsx

@@ -0,0 +1,39 @@
+import { createMemo, mergeProps, splitProps } from "solid-js";
+import { useHref, useLocation, useNavigate, useResolvedPath } from "./routing.js";
+import { normalizePath } from "./utils.js";
+export function A(props) {
+    props = mergeProps({ inactiveClass: "inactive", activeClass: "active" }, props);
+    const [, rest] = splitProps(props, [
+        "href",
+        "state",
+        "class",
+        "activeClass",
+        "inactiveClass",
+        "end"
+    ]);
+    const to = useResolvedPath(() => props.href);
+    const href = useHref(to);
+    const location = useLocation();
+    const isActive = createMemo(() => {
+        const to_ = to();
+        if (to_ === undefined)
+            return [false, false];
+        const path = normalizePath(to_.split(/[?#]/, 1)[0]).toLowerCase();
+        const loc = decodeURI(normalizePath(location.pathname).toLowerCase());
+        return [props.end ? path === loc : loc.startsWith(path + "/") || loc === path, path === loc];
+    });
+    return (<a {...rest} href={href() || props.href} state={JSON.stringify(props.state)} classList={{
+            ...(props.class && { [props.class]: true }),
+            [props.inactiveClass]: !isActive()[0],
+            [props.activeClass]: isActive()[0],
+            ...rest.classList
+        }} link aria-current={isActive()[1] ? "page" : undefined}/>);
+}
+export function Navigate(props) {
+    const navigate = useNavigate();
+    const location = useLocation();
+    const { href, state } = props;
+    const path = typeof href === "function" ? href({ navigate, location }) : href;
+    navigate(path, { replace: true, state });
+    return null;
+}

package/dist/src/data/action.d.ts

@@ -0,0 +1,17 @@
+import { JSX } from "solid-js";
+import type { Submission, SubmissionStub, NarrowResponse } from "../types.js";
+export type Action<T extends Array<any>, U, V = T> = (T extends [FormData | URLSearchParams] | [] ? JSX.SerializableAttributeValue : unknown) & ((...vars: T) => Promise<NarrowResponse<U>>) & {
+    url: string;
+    with<A extends any[], B extends any[]>(this: (this: any, ...args: [...A, ...B]) => Promise<NarrowResponse<U>>, ...args: A): Action<B, U, V>;
+};
+export declare const actions: Map<string, Action<any, any, any>>;
+export declare function useSubmissions<T extends Array<any>, U, V>(fn: Action<T, U, V>, filter?: (input: V) => boolean): Submission<T, NarrowResponse<U>>[] & {
+    pending: boolean;
+};
+export declare function useSubmission<T extends Array<any>, U, V>(fn: Action<T, U, V>, filter?: (input: V) => boolean): Submission<T, NarrowResponse<U>> | SubmissionStub;
+export declare function useAction<T extends Array<any>, U, V>(action: Action<T, U, V>): (...args: Parameters<Action<T, U, V>>) => Promise<NarrowResponse<U>>;
+export declare function action<T extends Array<any>, U = void>(fn: (...args: T) => Promise<U>, name?: string): Action<T, U>;
+export declare function action<T extends Array<any>, U = void>(fn: (...args: T) => Promise<U>, options?: {
+    name?: string;
+    onComplete?: (s: Submission<T, U>) => void;
+}): Action<T, U>;

package/dist/src/data/action.js

@@ -0,0 +1,163 @@
+import { $TRACK, createMemo, createSignal, onCleanup, getOwner } from "solid-js";
+import { isServer } from "solid-js/web";
+import { useRouter } from "../routing.js";
+import { mockBase, setFunctionName } from "../utils.js";
+import { cacheKeyOp, hashKey, revalidate, query } from "./query.js";
+export const actions = /* #__PURE__ */ new Map();
+export function useSubmissions(fn, filter) {
+    const router = useRouter();
+    const subs = createMemo(() => router.submissions[0]().filter(s => s.url === fn.base && (!filter || filter(s.input))));
+    return new Proxy([], {
+        get(_, property) {
+            if (property === $TRACK)
+                return subs();
+            if (property === "pending")
+                return subs().some(sub => !sub.result);
+            return subs()[property];
+        },
+        has(_, property) {
+            return property in subs();
+        }
+    });
+}
+export function useSubmission(fn, filter) {
+    const submissions = useSubmissions(fn, filter);
+    return new Proxy({}, {
+        get(_, property) {
+            if ((submissions.length === 0 && property === "clear") || property === "retry")
+                return () => { };
+            return submissions[submissions.length - 1]?.[property];
+        }
+    });
+}
+export function useAction(action) {
+    const r = useRouter();
+    return (...args) => action.apply({ r }, args);
+}
+export function action(fn, options = {}) {
+    function mutate(...variables) {
+        const router = this.r;
+        const form = this.f;
+        const p = (router.singleFlight && fn.withOptions
+            ? fn.withOptions({ headers: { "X-Single-Flight": "true" } })
+            : fn)(...variables);
+        const [result, setResult] = createSignal();
+        let submission;
+        function handler(error) {
+            return async (res) => {
+                const result = await handleResponse(res, error, router.navigatorFactory());
+                let retry = null;
+                o.onComplete?.({
+                    ...submission,
+                    result: result?.data,
+                    error: result?.error,
+                    pending: false,
+                    retry() {
+                        return (retry = submission.retry());
+                    }
+                });
+                if (retry)
+                    return retry;
+                if (!result)
+                    return submission.clear();
+                setResult(result);
+                if (result.error && !form)
+                    throw result.error;
+                return result.data;
+            };
+        }
+        router.submissions[1](s => [
+            ...s,
+            (submission = {
+                input: variables,
+                url,
+                get result() {
+                    return result()?.data;
+                },
+                get error() {
+                    return result()?.error;
+                },
+                get pending() {
+                    return !result();
+                },
+                clear() {
+                    router.submissions[1](v => v.filter(i => i !== submission));
+                },
+                retry() {
+                    setResult(undefined);
+                    const p = fn(...variables);
+                    return p.then(handler(), handler(true));
+                }
+            })
+        ]);
+        return p.then(handler(), handler(true));
+    }
+    const o = typeof options === "string" ? { name: options } : options;
+    const name = o.name || (!isServer ? String(hashString(fn.toString())) : undefined);
+    const url = fn.url || (name && `https://action/${name}`) || "";
+    mutate.base = url;
+    if (name)
+        setFunctionName(mutate, name);
+    return toAction(mutate, url);
+}
+function toAction(fn, url) {
+    fn.toString = () => {
+        if (!url)
+            throw new Error("Client Actions need explicit names if server rendered");
+        return url;
+    };
+    fn.with = function (...args) {
+        const newFn = function (...passedArgs) {
+            return fn.call(this, ...args, ...passedArgs);
+        };
+        newFn.base = fn.base;
+        const uri = new URL(url, mockBase);
+        uri.searchParams.set("args", hashKey(args));
+        return toAction(newFn, (uri.origin === "https://action" ? uri.origin : "") + uri.pathname + uri.search);
+    };
+    fn.url = url;
+    if (!isServer) {
+        actions.set(url, fn);
+        getOwner() && onCleanup(() => actions.delete(url));
+    }
+    return fn;
+}
+const hashString = (s) => s.split("").reduce((a, b) => ((a << 5) - a + b.charCodeAt(0)) | 0, 0);
+async function handleResponse(response, error, navigate) {
+    let data;
+    let custom;
+    let keys;
+    let flightKeys;
+    if (response instanceof Response) {
+        if (response.headers.has("X-Revalidate"))
+            keys = response.headers.get("X-Revalidate").split(",");
+        if (response.customBody) {
+            data = custom = await response.customBody();
+            if (response.headers.has("X-Single-Flight")) {
+                data = data._$value;
+                delete custom._$value;
+                flightKeys = Object.keys(custom);
+            }
+        }
+        if (response.headers.has("Location")) {
+            const locationUrl = response.headers.get("Location") || "/";
+            if (locationUrl.startsWith("http")) {
+                window.location.href = locationUrl;
+            }
+            else {
+                navigate(locationUrl);
+            }
+        }
+    }
+    else if (error)
+        return { error: response };
+    else
+        data = response;
+    // invalidate
+    cacheKeyOp(keys, entry => (entry[0] = 0));
+    // set cache
+    flightKeys && flightKeys.forEach(k => query.set(k, custom[k]));
+    // trigger revalidation
+    await revalidate(keys, false);
+    return data != null ? { data } : undefined;
+}

package/dist/src/data/action.spec.d.ts

@@ -0,0 +1 @@
+export {};