@solidjs/router 0.16.1 → 0.17.0-next.1

package/dist/index.js

@@ -1,6 +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, catchError } from 'solid-js';
-import { createStore, reconcile, unwrap } from 'solid-js/store';
+import { isServer, getRequestEvent, createComponent as createComponent$1, memo, delegateEvents, spread, mergeProps, template } from '@solidjs/web';
+import { getOwner, runWithOwner, createMemo, createContext, onCleanup, useContext, untrack, createSignal, flush, createComponent, children, merge, createRoot, sharedConfig, getObserver, $TRACK, action as action$1, omit } from 'solid-js';
 
 function createBeforeLeave() {
   let listeners = new Set();
@@ -251,8 +250,15 @@ const MAX_REDIRECTS = 100;
 /** Consider this API opaque and internal. It is likely to change in the future. */
 const RouterContextObj = createContext();
 const RouteContextObj = createContext();
+function useOptionalContext(context) {
+  try {
+    return useContext(context);
+  } catch {
+    return undefined;
+  }
+}
 const useRouter = () => invariant(useContext(RouterContextObj), "<A> and 'use' router primitives can be only used inside a Route.");
-const useRoute = () => useContext(RouteContextObj) || useRouter().base;
+const useRoute = () => useOptionalContext(RouteContextObj) || useRouter().base;
 const useResolvedPath = path => {
   const route = useRoute();
   return createMemo(() => route.resolvePath(path()));
@@ -299,8 +305,8 @@ const useNavigate = () => useRouter().navigatorFactory();
 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.
+ * Retrieves a signal that indicates whether the router is currently processing a navigation.
+ * Useful for showing pending navigation state while the next route and its data settle.
  * 
  * @example
  * ```js
@@ -459,7 +465,6 @@ function createRoutes(routeDef, base = "") {
   const {
     component,
     preload,
-    load,
     children,
     info
   } = routeDef;
@@ -467,7 +472,7 @@ function createRoutes(routeDef, base = "") {
   const shared = {
     key: routeDef,
     component,
-    preload: preload || load,
+    preload,
     info
   };
   return asArray(routeDef.path).reduce((acc, originalPath) => {
@@ -561,7 +566,7 @@ function createLocation(path, state, queryWrapper) {
   const search = createMemo(() => url().search, true);
   const hash = createMemo(() => url().hash);
   const key = () => "";
-  const queryFn = on(search, () => extractSearchParams(url()));
+  const queryFn = createMemo(() => extractSearchParams(url()));
   return {
     get pathname() {
       return pathname();
@@ -601,49 +606,45 @@ function createRouterContext(integration, branches, getContext, options = {}) {
   const renderPath = utils.renderPath || (p => p);
   const beforeLeave = utils.beforeLeave || createBeforeLeave();
   const basePath = resolvePath("", options.base || "");
+  const initialSource = untrack(source);
   if (basePath === undefined) {
     throw new Error(`${basePath} is not a valid base path`);
-  } else if (basePath && !source().value) {
+  } else if (basePath && !initialSource.value) {
     setSource({
       value: basePath,
       replace: true,
       scroll: false
     });
   }
-  const [isRouting, setIsRouting] = createSignal(false);
+  const [isRouting, setIsRouting] = createSignal(false, {
+    pureWrite: true
+  });
 
-  // Keep track of last target, so that last call to transition wins
-  let lastTransitionTarget;
+  // Navigate override written from event handlers.
+  const [navigateTarget, setNavigateTarget] = createSignal(undefined, {
+    pureWrite: true
+  });
 
-  // Transition the location to a new value
-  const transition = (newIntent, newTarget) => {
-    if (newTarget.value === reference() && newTarget.state === state()) return;
-    if (lastTransitionTarget === undefined) setIsRouting(true);
-    intent = newIntent;
-    lastTransitionTarget = newTarget;
-    startTransition(() => {
-      if (lastTransitionTarget !== newTarget) return;
-      setReference(lastTransitionTarget.value);
-      setState(lastTransitionTarget.state);
-      resetErrorBoundaries();
-      if (!isServer) submissions[1](subs => subs.filter(s => s.pending));
-    }).finally(() => {
-      if (lastTransitionTarget !== newTarget) return;
+  // Keep track of last target, so that last call to navigate wins
+  let lastTransitionTarget;
 
-      // Batch, in order for isRouting and final source update to happen together
-      batch(() => {
-        intent = undefined;
-        if (newIntent === "navigate") navigateEnd(lastTransitionTarget);
-        setIsRouting(false);
-        lastTransitionTarget = undefined;
-      });
-    });
-  };
-  const [reference, setReference] = createSignal(source().value);
-  const [state, setState] = createSignal(source().state);
+  // source() remains canonical for native history changes; navigateTarget()
+  // temporarily overrides it for in-flight programmatic navigation.
+  const reference = createMemo(() => {
+    const nav = navigateTarget();
+    if (nav !== undefined) return nav.value;
+    return source().value;
+  });
+  const state = createMemo(() => {
+    const nav = navigateTarget();
+    if (nav !== undefined) return nav.state;
+    return source().state;
+  });
   const location = createLocation(reference, state, utils.queryWrapper);
   const referrers = [];
-  const submissions = createSignal(isServer ? initFromFlash() : []);
+  const submissions = createSignal(isServer ? initFromFlash() : [], {
+    pureWrite: true
+  });
   const matches = createMemo(() => {
     if (typeof options.transformUrl === "function") {
       return getRouteMatches(branches(), options.transformUrl(location.pathname));
@@ -667,11 +668,6 @@ function createRouterContext(integration, branches, getContext, options = {}) {
       return resolvePath(basePath, to);
     }
   };
-
-  // Create a native transition, when source updates
-  createRenderEffect(on(source, source => transition("native", source), {
-    defer: true
-  }));
   return {
     base: baseRoute,
     location,
@@ -738,17 +734,36 @@ function createRouterContext(integration, branches, getContext, options = {}) {
             scroll,
             state: state()
           });
-          transition("navigate", {
+          const newTarget = {
             value: resolvedTo,
             state: nextState
-          });
+          };
+          if (lastTransitionTarget === undefined) {
+            setIsRouting(true);
+            flush();
+          }
+          intent = "navigate";
+          lastTransitionTarget = newTarget;
+          if (lastTransitionTarget === newTarget) {
+            setNavigateTarget({
+              ...lastTransitionTarget
+            });
+            queueMicrotask(() => {
+              if (lastTransitionTarget !== newTarget) return;
+              intent = undefined;
+              navigateEnd(lastTransitionTarget);
+              setNavigateTarget(undefined);
+              setIsRouting(false);
+              lastTransitionTarget = undefined;
+            });
+          }
         }
       }
     });
   }
   function navigatorFactory(route) {
     // Workaround for vite issue (https://github.com/vitejs/vite/issues/3803)
-    route = route || useContext(RouteContextObj) || baseRoute;
+    route = route || useOptionalContext(RouteContextObj) || baseRoute;
     return (to, options) => navigateFromRoute(route, to, options);
   }
   function navigateEnd(next) {
@@ -794,7 +809,12 @@ function createRouterContext(integration, branches, getContext, options = {}) {
   }
   function initFromFlash() {
     const e = getRequestEvent();
-    return e && e.router && e.router.submission ? [e.router.submission] : [];
+    if (!(e && e.router && e.router.submission)) return [];
+    return [{
+      ...e.router.submission,
+      clear() {},
+      retry() {}
+    }];
   }
 }
 function createRouteContext(router, parent, outlet, match) {
@@ -836,30 +856,38 @@ function createRouteContext(router, parent, outlet, match) {
   return route;
 }
 
-const createRouterComponent = router => props => {
+const createRouterComponent = router => function IntegratedRouter(props) {
   const {
-    base
-  } = props;
-  const routeDefs = children(() => props.children);
-  const branches = createMemo(() => createBranches(routeDefs(), props.base || ""));
+    base,
+    singleFlight,
+    transformUrl,
+    root,
+    rootPreload,
+    routeChildren
+  } = untrack(() => ({
+    base: props.base,
+    singleFlight: props.singleFlight,
+    transformUrl: props.transformUrl,
+    root: props.root,
+    rootPreload: props.rootPreload,
+    routeChildren: props.children
+  }));
+  const routeDefs = children(() => routeChildren);
+  const branches = createMemo(() => createBranches(routeDefs(), base || ""));
   let context;
   const routerState = createRouterContext(router, branches, () => context, {
     base,
-    singleFlight: props.singleFlight,
-    transformUrl: props.transformUrl
+    singleFlight,
+    transformUrl
   });
   router.create && router.create(routerState);
-  return createComponent$1(RouterContextObj.Provider, {
+  return createComponent$1(RouterContextObj, {
     value: routerState,
     get children() {
       return createComponent$1(Root, {
         routerState: routerState,
-        get root() {
-          return props.root;
-        },
-        get preload() {
-          return props.rootPreload || props.rootLoad;
-        },
+        root: root,
+        preload: rootPreload,
         get children() {
           return [memo(() => (context = getOwner()) && null), createComponent$1(Routes, {
             routerState: routerState,
@@ -884,15 +912,9 @@ function Root(props) {
     });
     setInPreloadFn(false);
   }));
-  return createComponent$1(Show, {
-    get when() {
-      return props.root;
-    },
-    keyed: true,
-    get fallback() {
-      return props.children;
-    },
-    children: Root => createComponent$1(Root, {
+  const RootComp = props.root;
+  if (RootComp) {
+    return createComponent$1(RootComp, {
       params: params,
       location: location,
       get data() {
@@ -901,8 +923,9 @@ function Root(props) {
       get children() {
         return props.children;
       }
-    })
-  });
+    });
+  }
+  return props.children;
 }
 function Routes(props) {
   if (isServer) {
@@ -925,11 +948,14 @@ function Routes(props) {
   }
   const disposers = [];
   let root;
-  const routeStates = createMemo(on(props.routerState.matches, (nextMatches, prevMatches, prev) => {
-    let equal = prevMatches && nextMatches.length === prevMatches.length;
+  let prevMatches;
+  const routeStates = createMemo(prev => {
+    const nextMatches = props.routerState.matches();
+    const previousMatches = prevMatches;
+    let equal = previousMatches && nextMatches.length === previousMatches.length;
     const next = [];
     for (let i = 0, len = nextMatches.length; i < len; i++) {
-      const prevMatch = prevMatches && prevMatches[i];
+      const prevMatch = previousMatches && previousMatches[i];
       const nextMatch = nextMatches[i];
       if (prev && prevMatch && nextMatch.route.key === prevMatch.route.key) {
         next[i] = prev[i];
@@ -940,7 +966,7 @@ function Routes(props) {
         }
         createRoot(dispose => {
           disposers[i] = dispose;
-          next[i] = createRouteContext(props.routerState, next[i - 1] || props.routerState.base, createOutlet(() => routeStates()[i + 1]), () => {
+          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];
           });
@@ -949,30 +975,33 @@ function Routes(props) {
     }
     disposers.splice(nextMatches.length).forEach(dispose => dispose());
     if (prev && equal) {
+      prevMatches = nextMatches;
       return prev;
     }
     root = next[0];
+    prevMatches = nextMatches;
     return next;
-  }));
-  return createOutlet(() => routeStates() && root)();
+  }, undefined);
+  const outlet = createOutlet(() => routeStates() && root);
+  return memo(outlet);
 }
 const createOutlet = child => {
-  return () => createComponent$1(Show, {
-    get when() {
-      return child();
-    },
-    keyed: true,
-    children: child => createComponent$1(RouteContextObj.Provider, {
-      value: child,
-      get children() {
-        return child.outlet();
-      }
-    })
-  });
+  return () => {
+    const c = child();
+    if (c) {
+      return createComponent$1(RouteContextObj, {
+        value: c,
+        get children() {
+          return c.outlet();
+        }
+      });
+    }
+    return undefined;
+  };
 };
 const Route = props => {
   const childRoutes = children(() => props.children);
-  return mergeProps(props, {
+  return merge(props, {
     get children() {
       return childRoutes();
     }
@@ -1078,12 +1107,10 @@ function getCache() {
  * Revalidates the given cache entry/entries.
  */
 function revalidate(key, force = true) {
-  return startTransition(() => {
-    const now = Date.now();
-    cacheKeyOp(key, entry => {
-      force && (entry[0] = 0); //force cache miss
-      entry[4][1](now); // retrigger live signals
-    });
+  const now = Date.now();
+  cacheKeyOp(key, entry => {
+    force && (entry[0] = 0); //force cache miss
+    entry[4][1](now); // retrigger live signals
   });
 }
 function cacheKeyOp(key, fn) {
@@ -1119,7 +1146,7 @@ function query(fn, name) {
         }
       }
     }
-    if (getListener() && !isServer) {
+    if (getObserver() && !isServer) {
       tracking = true;
       onCleanup(() => cached[4].count--);
     }
@@ -1134,7 +1161,7 @@ function query(fn, name) {
       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[4][1](cached[0])); // update version
+        !isServer && intent === "navigate" && cached[4][1](cached[0]); // update version
       }
       inPreloadFn && "then" in res && res.catch(() => {});
       return res;
@@ -1149,7 +1176,7 @@ function query(fn, name) {
       cached[0] = now;
       cached[1] = res;
       cached[3] = intent;
-      !isServer && intent === "navigate" && startTransition(() => cached[4][1](cached[0])); // update version
+      !isServer && intent === "navigate" && cached[4][1](cached[0]); // update version
     } else {
       cache.set(key, cached = [now, res,, intent, createSignal(now)]);
       cached[4].count = 0;
@@ -1184,10 +1211,8 @@ function query(fn, name) {
           const url = v.headers.get(LocationHeader);
           if (url !== null) {
             // client + server relative redirect
-            if (navigate && url.startsWith("/")) startTransition(() => {
-              navigate(url, {
-                replace: true
-              });
+            if (navigate && url.startsWith("/")) navigate(url, {
+              replace: true
             });else if (!isServer) window.location.href = url;else if (e) e.response.status = 302;
             return;
           }
@@ -1223,9 +1248,6 @@ query.set = (key, value) => {
 };
 query.delete = key => getCache().delete(key);
 query.clear = () => getCache().clear();
-
-/** @deprecated use query instead */
-const cache = query;
 function matchKey(key, keys) {
   for (let k of keys) {
     if (k && key.startsWith(k)) return true;
@@ -1246,6 +1268,9 @@ function isPlainObject(obj) {
   return obj != null && typeof obj === "object" && (!(proto = Object.getPrototypeOf(obj)) || proto === Object.prototype);
 }
 
+const submitHooksSymbol = Symbol("routerActionSubmitHooks");
+const settledHooksSymbol = Symbol("routerActionSettledHooks");
+const invokeSymbol = Symbol("routerActionInvoke");
 const actions = /* #__PURE__ */new Map();
 function useSubmissions(fn, filter) {
   const router = useRouter();
@@ -1253,7 +1278,6 @@ function useSubmissions(fn, filter) {
   return new Proxy([], {
     get(_, property) {
       if (property === $TRACK) return subs();
-      if (property === "pending") return subs().some(sub => !sub.result);
       return subs()[property];
     },
     has(_, property) {
@@ -1261,99 +1285,111 @@ function useSubmissions(fn, filter) {
     }
   });
 }
-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];
-    }
-  });
-}
 function useAction(action) {
   const r = useRouter();
   return (...args) => action.apply({
     r
   }, args);
 }
-function action(fn, options = {}) {
-  function mutate(...variables) {
+function actionImpl(fn, options = {}) {
+  async function invoke(variables, current) {
     const router = this.r;
     const form = this.f;
-    const p = (router.singleFlight && fn.withOptions ? fn.withOptions({
+    const submitHooks = current[submitHooksSymbol];
+    const settledHooks = current[settledHooksSymbol];
+    const runMutation = () => (router.singleFlight && fn.withOptions ? fn.withOptions({
       headers: {
         "X-Single-Flight": "true"
       }
     }) : fn)(...variables);
-    const [result, setResult] = createSignal();
+    const run = action$1(async function* (context) {
+      context.optimistic?.();
+      try {
+        const value = await context.call();
+        yield;
+        return {
+          error: false,
+          value
+        };
+      } catch (error) {
+        yield;
+        return {
+          error: true,
+          value: error
+        };
+      }
+    });
+    const settled = await settleActionResult(run({
+      call: runMutation,
+      optimistic: submitHooks.size ? () => {
+        for (const hook of submitHooks.values()) hook(...variables);
+      } : undefined
+    }));
+    const response = await handleResponse(settled.value, settled.error, router.navigatorFactory());
+    if (!response) return undefined;
     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 = {
+    submission = {
       input: variables,
       url,
-      get result() {
-        return result()?.data;
-      },
-      get error() {
-        return result()?.error;
-      },
-      get pending() {
-        return !result();
-      },
+      result: response.data,
+      error: response.error,
       clear() {
-        router.submissions[1](v => v.filter(i => i !== submission));
+        router.submissions[1](entries => entries.filter(entry => entry !== submission));
       },
       retry() {
-        setResult(undefined);
-        const p = fn(...variables);
-        return p.then(handler(), handler(true));
+        submission.clear();
+        return current[invokeSymbol].call({
+          r: router,
+          f: form
+        }, variables, current);
       }
-    }]);
-    return p.then(handler(), handler(true));
+    };
+    router.submissions[1](entries => [...entries, submission]);
+    for (const hook of settledHooks.values()) hook(submission);
+    if (response.error && !form) throw response.error;
+    return response.data;
   }
   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) {
+  const wrapped = toAction(invoke, url);
+  if (name) setFunctionName(wrapped, name);
+  return wrapped;
+}
+const action = actionImpl;
+function toAction(invoke, url, boundArgs = [], base = url, submitHooks = new Map(), settledHooks = new Map()) {
+  const fn = function (...args) {
+    return invoke.call(this, [...boundArgs, ...args], fn);
+  };
   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);
+    const next = toAction(invoke, (uri.origin === "https://action" ? uri.origin : "") + uri.pathname + uri.search, [...boundArgs, ...args], base, submitHooks, settledHooks);
+    return next;
+  };
+  fn.onSubmit = function (hook) {
+    const id = Symbol("actionOnSubmitHook");
+    submitHooks.set(id, hook);
+    getOwner() && onCleanup(() => submitHooks.delete(id));
+    return this;
+  };
+  fn.onSettled = function (hook) {
+    const id = Symbol("actionOnSettledHook");
+    settledHooks.set(id, hook);
+    getOwner() && onCleanup(() => settledHooks.delete(id));
+    return this;
   };
   fn.url = url;
+  fn.base = base;
+  fn[submitHooksSymbol] = submitHooks;
+  fn[settledHooksSymbol] = settledHooks;
+  fn[invokeSymbol] = invoke;
   if (!isServer) {
     actions.set(url, fn);
     getOwner() && onCleanup(() => actions.delete(url));
@@ -1361,6 +1397,21 @@ function toAction(fn, url) {
   return fn;
 }
 const hashString = s => s.split("").reduce((a, b) => (a << 5) - a + b.charCodeAt(0) | 0, 0);
+async function settleActionResult(result) {
+  const value = result;
+  if (value && typeof value.then === "function") {
+    return result.then(value => value);
+  }
+  if (value && typeof value.next === "function") {
+    const iterator = value;
+    let next = await iterator.next();
+    while (!next.done) {
+      next = await iterator.next();
+    }
+    return next.value;
+  }
+  return result;
+}
 async function handleResponse(response, error, navigate) {
   let data;
   let custom;
@@ -1669,12 +1720,21 @@ function MemoryRouter(props) {
 }
 
 var _tmpl$ = /*#__PURE__*/template(`<a>`);
+function toClassName(value) {
+  if (!value) return "";
+  if (typeof value === "string" || typeof value === "number") return String(value);
+  if (Array.isArray(value)) return value.map(toClassName).filter(Boolean).join(" ");
+  if (typeof value === "object") {
+    return Object.entries(value).filter(([, enabled]) => enabled).map(([name]) => name).join(" ");
+  }
+  return "";
+}
 function A(props) {
-  props = mergeProps({
+  props = merge({
     inactiveClass: "inactive",
     activeClass: "active"
   }, props);
-  const [, rest] = splitProps(props, ["href", "state", "class", "activeClass", "inactiveClass", "end"]);
+  const rest = omit(props, "href", "state", "class", "activeClass", "inactiveClass", "end");
   const to = useResolvedPath(() => props.href);
   const href = useHref(to);
   const location = useLocation();
@@ -1685,26 +1745,20 @@ function A(props) {
     const loc = decodeURI(normalizePath(location.pathname).toLowerCase());
     return [props.end ? path === loc : loc.startsWith(path + "/") || loc === path, path === loc];
   });
+  const className = createMemo(() => [toClassName(props.class), isActive()[0] ? props.activeClass : props.inactiveClass].filter(Boolean).join(" "));
   return (() => {
     var _el$ = _tmpl$();
-    spread(_el$, mergeProps$1(rest, {
+    spread(_el$, mergeProps(rest, {
       get href() {
         return href() || props.href;
       },
       get state() {
         return JSON.stringify(props.state);
       },
-      get classList() {
-        return {
-          ...(props.class && {
-            [props.class]: true
-          }),
-          [props.inactiveClass]: !isActive()[0],
-          [props.activeClass]: isActive()[0],
-          ...rest.classList
-        };
+      get ["class"]() {
+        return className();
       },
-      "link": "",
+      "link": true,
       get ["aria-current"]() {
         return isActive()[1] ? "page" : undefined;
       }
@@ -1730,99 +1784,6 @@ function Navigate(props) {
   return null;
 }
 
-/**
- * This is mock of the eventual Solid 2.0 primitive. It is not fully featured.
- */
-
-/**
- * As `createAsync` and `createAsyncStore` are wrappers for `createResource`,
- * this type allows to support `latest` field for these primitives.
- * It will be removed in the future.
- */
-
-function createAsync(fn, options) {
-  let resource;
-  let prev = () => !resource || resource.state === "unresolved" ? undefined : resource.latest;
-  [resource] = createResource(() => subFetch(fn, catchError(() => untrack(prev), () => undefined)), v => v, options);
-  const resultAccessor = () => resource();
-  if (options?.name) setFunctionName(resultAccessor, options.name);
-  Object.defineProperty(resultAccessor, "latest", {
-    get() {
-      return resource.latest;
-    }
-  });
-  return resultAccessor;
-}
-function createAsyncStore(fn, options = {}) {
-  let resource;
-  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", {
-    get() {
-      return resource.latest;
-    }
-  });
-  return resultAccessor;
-}
-function createDeepSignal(value, options) {
-  const [store, setStore] = createStore({
-    value: structuredClone(value)
-  });
-  return [() => store.value, v => {
-    typeof v === "function" && (v = v());
-    setStore("value", reconcile(structuredClone(v), options));
-    return store.value;
-  }];
-}
-
-// mock promise while hydrating to prevent fetching
-class MockPromise {
-  static all() {
-    return new MockPromise();
-  }
-  static allSettled() {
-    return new MockPromise();
-  }
-  static any() {
-    return new MockPromise();
-  }
-  static race() {
-    return new MockPromise();
-  }
-  static reject() {
-    return new MockPromise();
-  }
-  static resolve() {
-    return new MockPromise();
-  }
-  catch() {
-    return new MockPromise();
-  }
-  then() {
-    return new MockPromise();
-  }
-  finally() {
-    return new MockPromise();
-  }
-}
-function subFetch(fn, prev) {
-  if (isServer || !sharedConfig.context) return fn(prev);
-  const ogFetch = fetch;
-  const ogPromise = Promise;
-  try {
-    window.fetch = () => new MockPromise();
-    Promise = MockPromise;
-    return fn(prev);
-  } finally {
-    window.fetch = ogFetch;
-    Promise = ogPromise;
-  }
-}
-
 function redirect(url, init = 302) {
   let responseInit;
   let revalidate;
@@ -1876,4 +1837,4 @@ function json(data, init = {}) {
   return response;
 }
 
-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 };
+export { A, HashRouter, MemoryRouter, Navigate, Route, Router, RouterContextObj as RouterContext, StaticRouter, mergeSearchString as _mergeSearchString, action, createBeforeLeave, createMemoryHistory, createRouter, json, keepDepth, notifyIfNotBlocked, query, redirect, reload, revalidate, saveCurrentDepth, useAction, useBeforeLeave, useCurrentMatches, useHref, useIsRouting, useLocation, useMatch, useNavigate, useParams, usePreloadRoute, useResolvedPath, useSearchParams, useSubmissions };