@tanstack/solid-router 1.108.0

package/dist/cjs/scroll-restoration.cjs

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const web = require("solid-js/web");
+const routerCore = require("@tanstack/router-core");
+const useRouter = require("./useRouter.cjs");
+const ScriptOnce = require("./ScriptOnce.cjs");
+const storageKey = "tsr-scroll-restoration-v1_3";
+const sessionsStorage = typeof window !== "undefined" && window.sessionStorage;
+const throttle = (fn, wait) => {
+  let timeout;
+  return (...args) => {
+    if (!timeout) {
+      timeout = setTimeout(() => {
+        fn(...args);
+        timeout = null;
+      }, wait);
+    }
+  };
+};
+const scrollRestorationCache = sessionsStorage ? (() => {
+  const state = JSON.parse(window.sessionStorage.getItem(storageKey) || "null") || {};
+  return {
+    state,
+    // This setter is simply to make sure that we set the sessionStorage right
+    // after the state is updated. It doesn't necessarily need to be a functional
+    // update.
+    set: (updater) => (scrollRestorationCache.state = routerCore.functionalUpdate(updater, scrollRestorationCache.state) || scrollRestorationCache.state, window.sessionStorage.setItem(storageKey, JSON.stringify(scrollRestorationCache.state)))
+  };
+})() : void 0;
+const defaultGetScrollRestorationKey = (location) => {
+  return location.state.key || location.href;
+};
+function getCssSelector(el) {
+  const path = [];
+  let parent;
+  while (parent = el.parentNode) {
+    path.unshift(`${el.tagName}:nth-child(${[].indexOf.call(parent.children, el) + 1})`);
+    el = parent;
+  }
+  return `${path.join(" > ")}`.toLowerCase();
+}
+let ignoreScroll = false;
+function restoreScroll(storageKey2, key, behavior, shouldScrollRestoration, scrollToTopSelectors) {
+  var _a;
+  let byKey;
+  try {
+    byKey = JSON.parse(sessionStorage.getItem(storageKey2) || "{}");
+  } catch (error) {
+    console.error(error);
+    return;
+  }
+  const resolvedKey = key || ((_a = window.history.state) == null ? void 0 : _a.key);
+  const elementEntries = byKey[resolvedKey];
+  ignoreScroll = true;
+  (() => {
+    if (shouldScrollRestoration && elementEntries) {
+      for (const elementSelector in elementEntries) {
+        const entry = elementEntries[elementSelector];
+        if (elementSelector === "window") {
+          window.scrollTo({
+            top: entry.scrollY,
+            left: entry.scrollX,
+            behavior
+          });
+        } else if (elementSelector) {
+          const element = document.querySelector(elementSelector);
+          if (element) {
+            element.scrollLeft = entry.scrollX;
+            element.scrollTop = entry.scrollY;
+          }
+        }
+      }
+      return;
+    }
+    const hash = window.location.hash.split("#")[1];
+    if (hash) {
+      const hashScrollIntoViewOptions = (window.history.state || {}).__hashScrollIntoViewOptions ?? true;
+      if (hashScrollIntoViewOptions) {
+        const el = document.getElementById(hash);
+        if (el) {
+          el.scrollIntoView(hashScrollIntoViewOptions);
+        }
+      }
+      return;
+    }
+    ["window", ...(scrollToTopSelectors == null ? void 0 : scrollToTopSelectors.filter((d) => d !== "window")) ?? []].forEach((selector) => {
+      const element = selector === "window" ? window : document.querySelector(selector);
+      if (element) {
+        element.scrollTo({
+          top: 0,
+          left: 0,
+          behavior
+        });
+      }
+    });
+  })();
+  ignoreScroll = false;
+}
+function setupScrollRestoration(router, force) {
+  const shouldScrollRestoration = force ?? router.options.scrollRestoration ?? false;
+  if (shouldScrollRestoration) {
+    router.isScrollRestoring = true;
+  }
+  if (typeof document === "undefined" || router.isScrollRestorationSetup) {
+    return;
+  }
+  router.isScrollRestorationSetup = true;
+  ignoreScroll = false;
+  const getKey = router.options.getScrollRestorationKey || defaultGetScrollRestorationKey;
+  window.history.scrollRestoration = "manual";
+  const onScroll = (event) => {
+    if (ignoreScroll || !router.isScrollRestoring) {
+      return;
+    }
+    let elementSelector = "";
+    if (event.target === document || event.target === window) {
+      elementSelector = "window";
+    } else {
+      const attrId = event.target.getAttribute("data-scroll-restoration-id");
+      if (attrId) {
+        elementSelector = `[data-scroll-restoration-id="${attrId}"]`;
+      } else {
+        elementSelector = getCssSelector(event.target);
+      }
+    }
+    const restoreKey = getKey(router.state.location);
+    scrollRestorationCache.set((state) => {
+      const keyEntry = state[restoreKey] = state[restoreKey] || {};
+      const elementEntry = keyEntry[elementSelector] = keyEntry[elementSelector] || {};
+      if (elementSelector === "window") {
+        elementEntry.scrollX = window.scrollX || 0;
+        elementEntry.scrollY = window.scrollY || 0;
+      } else if (elementSelector) {
+        const element = document.querySelector(elementSelector);
+        if (element) {
+          elementEntry.scrollX = element.scrollLeft || 0;
+          elementEntry.scrollY = element.scrollTop || 0;
+        }
+      }
+      return state;
+    });
+  };
+  if (typeof document !== "undefined") {
+    document.addEventListener("scroll", throttle(onScroll, 100), true);
+  }
+  router.subscribe("onRendered", (event) => {
+    const cacheKey = getKey(event.toLocation);
+    if (!router.resetNextScroll) {
+      router.resetNextScroll = true;
+      return;
+    }
+    restoreScroll(storageKey, cacheKey, router.options.scrollRestorationBehavior, router.isScrollRestoring, router.options.scrollToTopSelectors);
+    if (router.isScrollRestoring) {
+      scrollRestorationCache.set((state) => {
+        state[cacheKey] = state[cacheKey] || {};
+        return state;
+      });
+    }
+  });
+}
+function ScrollRestoration() {
+  const router = useRouter.useRouter();
+  const getKey = router.options.getScrollRestorationKey || defaultGetScrollRestorationKey;
+  const userKey = getKey(router.latestLocation);
+  const resolvedKey = userKey !== defaultGetScrollRestorationKey(router.latestLocation) ? userKey : null;
+  if (!router.isScrollRestoring || !router.isServer) {
+    return null;
+  }
+  return web.createComponent(ScriptOnce.ScriptOnce, {
+    get children() {
+      return `(${restoreScroll.toString()})(${JSON.stringify(storageKey)},${JSON.stringify(resolvedKey)}, undefined, true)`;
+    },
+    log: false
+  });
+}
+exports.ScrollRestoration = ScrollRestoration;
+exports.defaultGetScrollRestorationKey = defaultGetScrollRestorationKey;
+exports.getCssSelector = getCssSelector;
+exports.restoreScroll = restoreScroll;
+exports.scrollRestorationCache = scrollRestorationCache;
+exports.setupScrollRestoration = setupScrollRestoration;
+exports.storageKey = storageKey;
+//# sourceMappingURL=scroll-restoration.cjs.map

package/dist/cjs/scroll-restoration.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"scroll-restoration.cjs","sources":["../../src/scroll-restoration.tsx"],"sourcesContent":["import { functionalUpdate } from '@tanstack/router-core'\nimport { useRouter } from './useRouter'\nimport { ScriptOnce } from './ScriptOnce'\nimport type { AnyRouter } from './router'\nimport type { NonNullableUpdater, ParsedLocation } from '@tanstack/router-core'\n\nexport type ScrollRestorationEntry = { scrollX: number; scrollY: number }\n\nexport type ScrollRestorationByElement = Record<string, ScrollRestorationEntry>\n\nexport type ScrollRestorationByKey = Record<string, ScrollRestorationByElement>\n\nexport type ScrollRestorationCache = {\n  state: ScrollRestorationByKey\n  set: (updater: NonNullableUpdater<ScrollRestorationByKey>) => void\n}\nexport type ScrollRestorationOptions = {\n  getKey?: (location: ParsedLocation) => string\n  scrollBehavior?: ScrollToOptions['behavior']\n}\n\nexport const storageKey = 'tsr-scroll-restoration-v1_3'\nconst sessionsStorage = typeof window !== 'undefined' && window.sessionStorage\nconst throttle = (fn: (...args: Array<any>) => void, wait: number) => {\n  let timeout: any\n  return (...args: Array<any>) => {\n    if (!timeout) {\n      timeout = setTimeout(() => {\n        fn(...args)\n        timeout = null\n      }, wait)\n    }\n  }\n}\nexport const scrollRestorationCache: ScrollRestorationCache = sessionsStorage\n  ? (() => {\n      const state: ScrollRestorationByKey =\n        JSON.parse(window.sessionStorage.getItem(storageKey) || 'null') || {}\n\n      return {\n        state,\n        // This setter is simply to make sure that we set the sessionStorage right\n        // after the state is updated. It doesn't necessarily need to be a functional\n        // update.\n        set: (updater) => (\n          (scrollRestorationCache.state =\n            functionalUpdate(updater, scrollRestorationCache.state) ||\n            scrollRestorationCache.state),\n          window.sessionStorage.setItem(\n            storageKey,\n            JSON.stringify(scrollRestorationCache.state),\n          )\n        ),\n      }\n    })()\n  : (undefined as any)\n/**\n * The default `getKey` function for `useScrollRestoration`.\n * It returns the `key` from the location state or the `href` of the location.\n *\n * The `location.href` is used as a fallback to support the use case where the location state is not available like the initial render.\n */\n\nexport const defaultGetScrollRestorationKey = (location: ParsedLocation) => {\n  return location.state.key! || location.href\n}\n\nexport function getCssSelector(el: any): string {\n  const path = []\n  let parent\n  while ((parent = el.parentNode)) {\n    path.unshift(\n      `${el.tagName}:nth-child(${([].indexOf as any).call(parent.children, el) + 1})`,\n    )\n    el = parent\n  }\n  return `${path.join(' > ')}`.toLowerCase()\n}\n\nlet ignoreScroll = false\n\n// NOTE: This function must remain pure and not use any outside variables\n// unless they are passed in as arguments. Why? Because we need to be able to\n// toString() it into a script tag to execute as early as possible in the browser\n// during SSR. Additionally, we also call it from within the router lifecycle\nexport function restoreScroll(\n  storageKey: string,\n  key?: string,\n  behavior?: ScrollToOptions['behavior'],\n  shouldScrollRestoration?: boolean,\n  scrollToTopSelectors?: Array<string>,\n) {\n  let byKey: ScrollRestorationByKey\n\n  try {\n    byKey = JSON.parse(sessionStorage.getItem(storageKey) || '{}')\n  } catch (error: any) {\n    console.error(error)\n    return\n  }\n\n  const resolvedKey = key || window.history.state?.key\n  const elementEntries = byKey[resolvedKey]\n\n  //\n  ignoreScroll = true\n\n  //\n  ;(() => {\n    // If we have a cached entry for this location state,\n    // we always need to prefer that over the hash scroll.\n    if (shouldScrollRestoration && elementEntries) {\n      for (const elementSelector in elementEntries) {\n        const entry = elementEntries[elementSelector]!\n        if (elementSelector === 'window') {\n          window.scrollTo({\n            top: entry.scrollY,\n            left: entry.scrollX,\n            behavior,\n          })\n        } else if (elementSelector) {\n          const element = document.querySelector(elementSelector)\n          if (element) {\n            element.scrollLeft = entry.scrollX\n            element.scrollTop = entry.scrollY\n          }\n        }\n      }\n\n      return\n    }\n\n    // If we don't have a cached entry for the hash,\n    // Which means we've never seen this location before,\n    // we need to check if there is a hash in the URL.\n    // If there is, we need to scroll it's ID into view.\n    const hash = window.location.hash.split('#')[1]\n\n    if (hash) {\n      const hashScrollIntoViewOptions =\n        (window.history.state || {}).__hashScrollIntoViewOptions ?? true\n\n      if (hashScrollIntoViewOptions) {\n        const el = document.getElementById(hash)\n        if (el) {\n          el.scrollIntoView(hashScrollIntoViewOptions)\n        }\n      }\n\n      return\n    }\n\n    // If there is no cached entry for the hash and there is no hash in the URL,\n    // we need to scroll to the top of the page for every scrollToTop element\n    ;[\n      'window',\n      ...(scrollToTopSelectors?.filter((d) => d !== 'window') ?? []),\n    ].forEach((selector) => {\n      const element =\n        selector === 'window' ? window : document.querySelector(selector)\n      if (element) {\n        element.scrollTo({\n          top: 0,\n          left: 0,\n          behavior,\n        })\n      }\n    })\n  })()\n\n  //\n  ignoreScroll = false\n}\n\nexport function setupScrollRestoration(router: AnyRouter, force?: boolean) {\n  const shouldScrollRestoration =\n    force ?? router.options.scrollRestoration ?? false\n\n  if (shouldScrollRestoration) {\n    router.isScrollRestoring = true\n  }\n\n  if (typeof document === 'undefined' || router.isScrollRestorationSetup) {\n    return\n  }\n\n  router.isScrollRestorationSetup = true\n\n  //\n  ignoreScroll = false\n\n  const getKey =\n    router.options.getScrollRestorationKey || defaultGetScrollRestorationKey\n\n  window.history.scrollRestoration = 'manual'\n\n  // // Create a MutationObserver to monitor DOM changes\n  // const mutationObserver = new MutationObserver(() => {\n  //   ;ignoreScroll = true\n  //   requestAnimationFrame(() => {\n  //     ;ignoreScroll = false\n\n  //     // Attempt to restore scroll position on each dom\n  //     // mutation until the user scrolls. We do this\n  //     // because dynamic content may come in at different\n  //     // ticks after the initial render and we want to\n  //     // keep up with that content as much as possible.\n  //     // As soon as the user scrolls, we no longer need\n  //     // to attempt router.\n  //     // console.log('mutation observer restoreScroll')\n  //     restoreScroll(\n  //       storageKey,\n  //       getKey(router.state.location),\n  //       router.options.scrollRestorationBehavior,\n  //     )\n  //   })\n  // })\n\n  // const observeDom = () => {\n  //   // Observe changes to the entire document\n  //   mutationObserver.observe(document, {\n  //     childList: true, // Detect added or removed child nodes\n  //     subtree: true, // Monitor all descendants\n  //     characterData: true, // Detect text content changes\n  //   })\n  // }\n\n  // const unobserveDom = () => {\n  //   mutationObserver.disconnect()\n  // }\n\n  // observeDom()\n\n  const onScroll = (event: Event) => {\n    // unobserveDom()\n\n    if (ignoreScroll || !router.isScrollRestoring) {\n      return\n    }\n\n    let elementSelector = ''\n\n    if (event.target === document || event.target === window) {\n      elementSelector = 'window'\n    } else {\n      const attrId = (event.target as Element).getAttribute(\n        'data-scroll-restoration-id',\n      )\n\n      if (attrId) {\n        elementSelector = `[data-scroll-restoration-id=\"${attrId}\"]`\n      } else {\n        elementSelector = getCssSelector(event.target)\n      }\n    }\n\n    const restoreKey = getKey(router.state.location)\n\n    scrollRestorationCache.set((state) => {\n      const keyEntry = (state[restoreKey] =\n        state[restoreKey] || ({} as ScrollRestorationByElement))\n\n      const elementEntry = (keyEntry[elementSelector] =\n        keyEntry[elementSelector] || ({} as ScrollRestorationEntry))\n\n      if (elementSelector === 'window') {\n        elementEntry.scrollX = window.scrollX || 0\n        elementEntry.scrollY = window.scrollY || 0\n      } else if (elementSelector) {\n        const element = document.querySelector(elementSelector)\n        if (element) {\n          elementEntry.scrollX = element.scrollLeft || 0\n          elementEntry.scrollY = element.scrollTop || 0\n        }\n      }\n\n      return state\n    })\n  }\n\n  // Throttle the scroll event to avoid excessive updates\n  if (typeof document !== 'undefined') {\n    document.addEventListener('scroll', throttle(onScroll, 100), true)\n  }\n\n  router.subscribe('onRendered', (event) => {\n    // unobserveDom()\n\n    const cacheKey = getKey(event.toLocation)\n\n    // If the user doesn't want to restore the scroll position,\n    // we don't need to do anything.\n    if (!router.resetNextScroll) {\n      router.resetNextScroll = true\n      return\n    }\n\n    restoreScroll(\n      storageKey,\n      cacheKey,\n      router.options.scrollRestorationBehavior,\n      router.isScrollRestoring,\n      router.options.scrollToTopSelectors,\n    )\n\n    if (router.isScrollRestoring) {\n      // Mark the location as having been seen\n      scrollRestorationCache.set((state) => {\n        state[cacheKey] = state[cacheKey] || ({} as ScrollRestorationByElement)\n\n        return state\n      })\n    }\n  })\n}\n\nexport function ScrollRestoration() {\n  const router = useRouter()\n  const getKey =\n    router.options.getScrollRestorationKey || defaultGetScrollRestorationKey\n  const userKey = getKey(router.latestLocation)\n  const resolvedKey =\n    userKey !== defaultGetScrollRestorationKey(router.latestLocation)\n      ? userKey\n      : null\n\n  if (!router.isScrollRestoring || !router.isServer) {\n    return null\n  }\n\n  return (\n    <ScriptOnce\n      children={`(${restoreScroll.toString()})(${JSON.stringify(storageKey)},${JSON.stringify(resolvedKey)}, undefined, true)`}\n      log={false}\n    />\n  )\n}\n"],"names":["storageKey","sessionsStorage","window","sessionStorage","throttle","fn","wait","timeout","args","setTimeout","scrollRestorationCache","state","JSON","parse","getItem","set","updater","functionalUpdate","setItem","stringify","undefined","defaultGetScrollRestorationKey","location","key","href","getCssSelector","el","path","parent","parentNode","unshift","tagName","indexOf","call","children","join","toLowerCase","ignoreScroll","restoreScroll","behavior","shouldScrollRestoration","scrollToTopSelectors","byKey","error","console","resolvedKey","history","elementEntries","elementSelector","entry","scrollTo","top","scrollY","left","scrollX","element","document","querySelector","scrollLeft","scrollTop","hash","split","hashScrollIntoViewOptions","__hashScrollIntoViewOptions","getElementById","scrollIntoView","filter","d","forEach","selector","setupScrollRestoration","router","force","options","scrollRestoration","isScrollRestoring","isScrollRestorationSetup","getKey","getScrollRestorationKey","onScroll","event","target","attrId","getAttribute","restoreKey","keyEntry","elementEntry","addEventListener","subscribe","cacheKey","toLocation","resetNextScroll","scrollRestorationBehavior","ScrollRestoration","useRouter","userKey","latestLocation","isServer","_$createComponent","ScriptOnce","toString","log"],"mappings":"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"}

package/dist/cjs/scroll-restoration.d.cts

@@ -0,0 +1,29 @@
+import { AnyRouter } from './router.cjs';
+import { NonNullableUpdater, ParsedLocation } from '@tanstack/router-core';
+export type ScrollRestorationEntry = {
+    scrollX: number;
+    scrollY: number;
+};
+export type ScrollRestorationByElement = Record<string, ScrollRestorationEntry>;
+export type ScrollRestorationByKey = Record<string, ScrollRestorationByElement>;
+export type ScrollRestorationCache = {
+    state: ScrollRestorationByKey;
+    set: (updater: NonNullableUpdater<ScrollRestorationByKey>) => void;
+};
+export type ScrollRestorationOptions = {
+    getKey?: (location: ParsedLocation) => string;
+    scrollBehavior?: ScrollToOptions['behavior'];
+};
+export declare const storageKey = "tsr-scroll-restoration-v1_3";
+export declare const scrollRestorationCache: ScrollRestorationCache;
+/**
+ * The default `getKey` function for `useScrollRestoration`.
+ * It returns the `key` from the location state or the `href` of the location.
+ *
+ * The `location.href` is used as a fallback to support the use case where the location state is not available like the initial render.
+ */
+export declare const defaultGetScrollRestorationKey: (location: ParsedLocation) => string;
+export declare function getCssSelector(el: any): string;
+export declare function restoreScroll(storageKey: string, key?: string, behavior?: ScrollToOptions['behavior'], shouldScrollRestoration?: boolean, scrollToTopSelectors?: Array<string>): void;
+export declare function setupScrollRestoration(router: AnyRouter, force?: boolean): void;
+export declare function ScrollRestoration(): import("solid-js").JSX.Element;

package/dist/cjs/typePrimitives.d.cts

@@ -0,0 +1,66 @@
+import { FromPathOption, LinkComponentProps, NavigateOptions, PathParamOptions, SearchParamOptions, ToPathOption } from './link.cjs';
+import { RouteIds } from './routeInfo.cjs';
+import { AnyRouter, RegisteredRouter } from './router.cjs';
+import { UseParamsOptions, UseParamsResult } from './useParams.cjs';
+import { UseSearchOptions, UseSearchResult } from './useSearch.cjs';
+import { Constrain, ConstrainLiteral } from '@tanstack/router-core';
+export type ValidateFromPath<TFrom, TRouter extends AnyRouter = RegisteredRouter> = FromPathOption<TRouter, TFrom>;
+export type ValidateToPath<TTo extends string | undefined, TFrom extends string = string, TRouter extends AnyRouter = RegisteredRouter> = ToPathOption<TRouter, TFrom, TTo>;
+export type ValidateSearch<TTo extends string | undefined, TFrom extends string = string, TRouter extends AnyRouter = RegisteredRouter> = SearchParamOptions<TRouter, TFrom, TTo>;
+export type ValidateParams<TTo extends string | undefined, TFrom extends string = string, TRouter extends AnyRouter = RegisteredRouter> = PathParamOptions<TRouter, TFrom, TTo>;
+/**
+ * @internal
+ */
+export type InferFrom<TOptions> = TOptions extends {
+    from: infer TFrom extends string;
+} ? TFrom : string;
+/**
+ * @internal
+ */
+export type InferTo<TOptions> = TOptions extends {
+    to: infer TTo extends string;
+} ? TTo : undefined;
+/**
+ * @internal
+ */
+export type InferMaskTo<TOptions> = TOptions extends {
+    mask: {
+        to: infer TTo extends string;
+    };
+} ? TTo : '';
+export type InferMaskFrom<TOptions> = TOptions extends {
+    mask: {
+        from: infer TFrom extends string;
+    };
+} ? TFrom : string;
+export type ValidateNavigateOptions<TOptions, TRouter extends AnyRouter = RegisteredRouter> = Constrain<TOptions, NavigateOptions<TRouter, InferFrom<TOptions>, InferTo<TOptions>, InferMaskFrom<TOptions>, InferMaskTo<TOptions>>>;
+export type ValidateNavigateOptionsArray<TOptions extends ReadonlyArray<any>, TRouter extends AnyRouter = RegisteredRouter> = {
+    [K in keyof TOptions]: ValidateNavigateOptions<TOptions[K], TRouter>;
+};
+export type ValidateLinkOptions<TOptions, TComp = 'a', TRouter extends AnyRouter = RegisteredRouter> = Constrain<TOptions, LinkComponentProps<TComp, TRouter, InferFrom<TOptions>, InferTo<TOptions>, InferMaskFrom<TOptions>, InferMaskTo<TOptions>>>;
+export type ValidateLinkOptionsArray<TOptions extends ReadonlyArray<any>, TComp = 'a', TRouter extends AnyRouter = RegisteredRouter> = {
+    [K in keyof TOptions]: ValidateLinkOptions<TOptions[K], TComp, TRouter>;
+};
+export type ValidateId<TId extends string, TRouter extends AnyRouter = RegisteredRouter> = ConstrainLiteral<TId, RouteIds<TRouter['routeTree']>>;
+/**
+ * @internal
+ */
+export type InferStrict<TOptions> = TOptions extends {
+    strict: infer TStrict extends boolean;
+} ? TStrict : true;
+/**
+ * @internal
+ */
+export type InferShouldThrow<TOptions> = TOptions extends {
+    shouldThrow: infer TShouldThrow extends boolean;
+} ? TShouldThrow : true;
+/**
+ * @internal
+ */
+export type InferSelected<TOptions> = TOptions extends {
+    select: (...args: Array<any>) => infer TSelected;
+} ? TSelected : unknown;
+export type ValidateUseSearchOptions<TOptions, TRouter extends AnyRouter = RegisteredRouter> = Constrain<TOptions, UseSearchOptions<TRouter, InferFrom<TOptions>, InferStrict<TOptions>, InferShouldThrow<TOptions>, InferSelected<TOptions>>>;
+export type ValidateUseSearchResult<TOptions, TRouter extends AnyRouter = RegisteredRouter> = UseSearchResult<TRouter, InferFrom<TOptions>, InferStrict<TOptions>, InferSelected<TOptions>>;
+export type ValidateUseParamsOptions<TOptions, TRouter extends AnyRouter = RegisteredRouter> = Constrain<TOptions, UseParamsOptions<TRouter, InferFrom<TOptions>, InferStrict<TOptions>, InferShouldThrow<TOptions>, InferSelected<TOptions>>>;
+export type ValidateUseParamsResult<TOptions, TRouter extends AnyRouter = RegisteredRouter> = Constrain<TOptions, UseParamsResult<TRouter, InferFrom<TOptions>, InferStrict<TOptions>, InferSelected<TOptions>>>;

package/dist/cjs/useBlocker.cjs

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Solid = require("solid-js");
+const useRouter = require("./useRouter.cjs");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const Solid__namespace = /* @__PURE__ */ _interopNamespaceDefault(Solid);
+function _resolveBlockerOpts(opts, condition) {
+  if (opts === void 0) {
+    return {
+      shouldBlockFn: () => true,
+      withResolver: false
+    };
+  }
+  if ("shouldBlockFn" in opts) {
+    return opts;
+  }
+  if (typeof opts === "function") {
+    const shouldBlock2 = Boolean(condition ?? true);
+    const _customBlockerFn2 = async () => {
+      if (shouldBlock2) return await opts();
+      return false;
+    };
+    return {
+      shouldBlockFn: _customBlockerFn2,
+      enableBeforeUnload: shouldBlock2,
+      withResolver: false
+    };
+  }
+  const shouldBlock = Boolean(opts.condition ?? true);
+  const fn = opts.blockerFn;
+  const _customBlockerFn = async () => {
+    if (shouldBlock && fn !== void 0) {
+      return await fn();
+    }
+    return shouldBlock;
+  };
+  return {
+    shouldBlockFn: _customBlockerFn,
+    enableBeforeUnload: shouldBlock,
+    withResolver: fn === void 0
+  };
+}
+function useBlocker(opts, condition) {
+  const {
+    shouldBlockFn,
+    enableBeforeUnload = true,
+    disabled = false,
+    withResolver = false
+  } = _resolveBlockerOpts(opts, condition);
+  const router = useRouter.useRouter();
+  const {
+    history
+  } = router;
+  const [resolver, setResolver] = Solid__namespace.createSignal({
+    status: "idle",
+    current: void 0,
+    next: void 0,
+    action: void 0,
+    proceed: void 0,
+    reset: void 0
+  });
+  Solid__namespace.createEffect(() => {
+    const blockerFnComposed = async (blockerFnArgs) => {
+      function getLocation(location) {
+        const parsedLocation = router.parseLocation(void 0, location);
+        const matchedRoutes = router.getMatchedRoutes(parsedLocation);
+        if (matchedRoutes.foundRoute === void 0) {
+          throw new Error(`No route found for location ${location.href}`);
+        }
+        return {
+          routeId: matchedRoutes.foundRoute.id,
+          fullPath: matchedRoutes.foundRoute.fullPath,
+          pathname: parsedLocation.pathname,
+          params: matchedRoutes.routeParams,
+          search: parsedLocation.search
+        };
+      }
+      const current = getLocation(blockerFnArgs.currentLocation);
+      const next = getLocation(blockerFnArgs.nextLocation);
+      const shouldBlock = await shouldBlockFn({
+        action: blockerFnArgs.action,
+        current,
+        next
+      });
+      if (!withResolver) {
+        return shouldBlock;
+      }
+      if (!shouldBlock) {
+        return false;
+      }
+      const promise = new Promise((resolve) => {
+        setResolver({
+          status: "blocked",
+          current,
+          next,
+          action: blockerFnArgs.action,
+          proceed: () => resolve(false),
+          reset: () => resolve(true)
+        });
+      });
+      const canNavigateAsync = await promise;
+      setResolver({
+        status: "idle",
+        current: void 0,
+        next: void 0,
+        action: void 0,
+        proceed: void 0,
+        reset: void 0
+      });
+      return canNavigateAsync;
+    };
+    return disabled ? void 0 : history.block({
+      blockerFn: blockerFnComposed,
+      enableBeforeUnload
+    });
+  });
+  return resolver;
+}
+const _resolvePromptBlockerArgs = (props) => {
+  if ("shouldBlockFn" in props) {
+    return {
+      ...props
+    };
+  }
+  const shouldBlock = Boolean(props.condition ?? true);
+  const fn = props.blockerFn;
+  const _customBlockerFn = async () => {
+    if (shouldBlock && fn !== void 0) {
+      return await fn();
+    }
+    return shouldBlock;
+  };
+  return {
+    shouldBlockFn: _customBlockerFn,
+    enableBeforeUnload: shouldBlock,
+    withResolver: fn === void 0
+  };
+};
+function Block(opts) {
+  const {
+    children,
+    ...rest
+  } = opts;
+  const args = _resolvePromptBlockerArgs(rest);
+  const resolver = useBlocker(args);
+  return children ? typeof children === "function" ? children(resolver) : children : null;
+}
+exports.Block = Block;
+exports.useBlocker = useBlocker;
+//# sourceMappingURL=useBlocker.cjs.map

package/dist/cjs/useBlocker.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBlocker.cjs","sources":["../../src/useBlocker.tsx"],"sourcesContent":["import * as Solid from 'solid-js'\nimport { useRouter } from './useRouter'\nimport type {\n  BlockerFnArgs,\n  HistoryAction,\n  HistoryLocation,\n} from '@tanstack/history'\nimport type { AnyRoute, SolidNode } from './route'\nimport type { ParseRoute } from './routeInfo'\nimport type { AnyRouter, RegisteredRouter } from './router'\n\ninterface ShouldBlockFnLocation<\n  out TRouteId,\n  out TFullPath,\n  out TAllParams,\n  out TFullSearchSchema,\n> {\n  routeId: TRouteId\n  fullPath: TFullPath\n  pathname: string\n  params: TAllParams\n  search: TFullSearchSchema\n}\n\ntype AnyShouldBlockFnLocation = ShouldBlockFnLocation<any, any, any, any>\ntype MakeShouldBlockFnLocationUnion<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TRoute extends AnyRoute = ParseRoute<TRouter['routeTree']>,\n> = TRoute extends any\n  ? ShouldBlockFnLocation<\n      TRoute['id'],\n      TRoute['fullPath'],\n      TRoute['types']['allParams'],\n      TRoute['types']['fullSearchSchema']\n    >\n  : never\n\ntype BlockerResolver<TRouter extends AnyRouter = RegisteredRouter> =\n  | {\n      status: 'blocked'\n      current: MakeShouldBlockFnLocationUnion<TRouter>\n      next: MakeShouldBlockFnLocationUnion<TRouter>\n      action: HistoryAction\n      proceed: () => void\n      reset: () => void\n    }\n  | {\n      status: 'idle'\n      current: undefined\n      next: undefined\n      action: undefined\n      proceed: undefined\n      reset: undefined\n    }\n\ntype ShouldBlockFnArgs<TRouter extends AnyRouter = RegisteredRouter> = {\n  current: MakeShouldBlockFnLocationUnion<TRouter>\n  next: MakeShouldBlockFnLocationUnion<TRouter>\n  action: HistoryAction\n}\n\nexport type ShouldBlockFn<TRouter extends AnyRouter = RegisteredRouter> = (\n  args: ShouldBlockFnArgs<TRouter>,\n) => boolean | Promise<boolean>\nexport type UseBlockerOpts<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TWithResolver extends boolean = boolean,\n> = {\n  shouldBlockFn: ShouldBlockFn<TRouter>\n  enableBeforeUnload?: boolean | (() => boolean)\n  disabled?: boolean\n  withResolver?: TWithResolver\n}\n\ntype LegacyBlockerFn = () => Promise<any> | any\ntype LegacyBlockerOpts = {\n  blockerFn?: LegacyBlockerFn\n  condition?: boolean | any\n}\n\nfunction _resolveBlockerOpts(\n  opts?: UseBlockerOpts | LegacyBlockerOpts | LegacyBlockerFn,\n  condition?: boolean | any,\n): UseBlockerOpts {\n  if (opts === undefined) {\n    return {\n      shouldBlockFn: () => true,\n      withResolver: false,\n    }\n  }\n\n  if ('shouldBlockFn' in opts) {\n    return opts\n  }\n\n  if (typeof opts === 'function') {\n    const shouldBlock = Boolean(condition ?? true)\n\n    const _customBlockerFn = async () => {\n      if (shouldBlock) return await opts()\n      return false\n    }\n\n    return {\n      shouldBlockFn: _customBlockerFn,\n      enableBeforeUnload: shouldBlock,\n      withResolver: false,\n    }\n  }\n\n  const shouldBlock = Boolean(opts.condition ?? true)\n  const fn = opts.blockerFn\n\n  const _customBlockerFn = async () => {\n    if (shouldBlock && fn !== undefined) {\n      return await fn()\n    }\n    return shouldBlock\n  }\n\n  return {\n    shouldBlockFn: _customBlockerFn,\n    enableBeforeUnload: shouldBlock,\n    withResolver: fn === undefined,\n  }\n}\n\nexport function useBlocker<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TWithResolver extends boolean = false,\n>(\n  opts: UseBlockerOpts<TRouter, TWithResolver>,\n): TWithResolver extends true ? Solid.Accessor<BlockerResolver<TRouter>> : void\n\n/**\n * @deprecated Use the shouldBlockFn property instead\n */\nexport function useBlocker(\n  blockerFnOrOpts?: LegacyBlockerOpts,\n): Solid.Accessor<BlockerResolver>\n\n/**\n * @deprecated Use the UseBlockerOpts object syntax instead\n */\nexport function useBlocker(\n  blockerFn?: LegacyBlockerFn,\n  condition?: boolean | any,\n): Solid.Accessor<BlockerResolver>\n\nexport function useBlocker(\n  opts?: UseBlockerOpts | LegacyBlockerOpts | LegacyBlockerFn,\n  condition?: boolean | any,\n): Solid.Accessor<BlockerResolver> | void {\n  const {\n    shouldBlockFn,\n    enableBeforeUnload = true,\n    disabled = false,\n    withResolver = false,\n  } = _resolveBlockerOpts(opts, condition)\n\n  const router = useRouter()\n  const { history } = router\n\n  const [resolver, setResolver] = Solid.createSignal<BlockerResolver>({\n    status: 'idle',\n    current: undefined,\n    next: undefined,\n    action: undefined,\n    proceed: undefined,\n    reset: undefined,\n  })\n\n  Solid.createEffect(() => {\n    const blockerFnComposed = async (blockerFnArgs: BlockerFnArgs) => {\n      function getLocation(\n        location: HistoryLocation,\n      ): AnyShouldBlockFnLocation {\n        const parsedLocation = router.parseLocation(undefined, location)\n        const matchedRoutes = router.getMatchedRoutes(parsedLocation)\n        if (matchedRoutes.foundRoute === undefined) {\n          throw new Error(`No route found for location ${location.href}`)\n        }\n        return {\n          routeId: matchedRoutes.foundRoute.id,\n          fullPath: matchedRoutes.foundRoute.fullPath,\n          pathname: parsedLocation.pathname,\n          params: matchedRoutes.routeParams,\n          search: parsedLocation.search,\n        }\n      }\n\n      const current = getLocation(blockerFnArgs.currentLocation)\n      const next = getLocation(blockerFnArgs.nextLocation)\n\n      const shouldBlock = await shouldBlockFn({\n        action: blockerFnArgs.action,\n        current,\n        next,\n      })\n      if (!withResolver) {\n        return shouldBlock\n      }\n\n      if (!shouldBlock) {\n        return false\n      }\n\n      const promise = new Promise<boolean>((resolve) => {\n        setResolver({\n          status: 'blocked',\n          current,\n          next,\n          action: blockerFnArgs.action,\n          proceed: () => resolve(false),\n          reset: () => resolve(true),\n        })\n      })\n\n      const canNavigateAsync = await promise\n      setResolver({\n        status: 'idle',\n        current: undefined,\n        next: undefined,\n        action: undefined,\n        proceed: undefined,\n        reset: undefined,\n      })\n\n      return canNavigateAsync\n    }\n\n    return disabled\n      ? undefined\n      : history.block({ blockerFn: blockerFnComposed, enableBeforeUnload })\n  })\n\n  return resolver\n}\n\nconst _resolvePromptBlockerArgs = (\n  props: PromptProps | LegacyPromptProps,\n): UseBlockerOpts => {\n  if ('shouldBlockFn' in props) {\n    return { ...props }\n  }\n\n  const shouldBlock = Boolean(props.condition ?? true)\n  const fn = props.blockerFn\n\n  const _customBlockerFn = async () => {\n    if (shouldBlock && fn !== undefined) {\n      return await fn()\n    }\n    return shouldBlock\n  }\n\n  return {\n    shouldBlockFn: _customBlockerFn,\n    enableBeforeUnload: shouldBlock,\n    withResolver: fn === undefined,\n  }\n}\n\nexport function Block<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TWithResolver extends boolean = boolean,\n>(opts: PromptProps<TRouter, TWithResolver>): SolidNode\n\n/**\n *  @deprecated Use the UseBlockerOpts property instead\n */\nexport function Block(opts: LegacyPromptProps): SolidNode\n\nexport function Block(opts: PromptProps | LegacyPromptProps): SolidNode {\n  const { children, ...rest } = opts\n  const args = _resolvePromptBlockerArgs(rest)\n\n  const resolver = useBlocker(args)\n  return children\n    ? typeof children === 'function'\n      ? children(resolver as any)\n      : children\n    : null\n}\n\ntype LegacyPromptProps = {\n  blockerFn?: LegacyBlockerFn\n  condition?: boolean | any\n  children?: SolidNode | ((params: BlockerResolver) => SolidNode)\n}\n\ntype PromptProps<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TWithResolver extends boolean = boolean,\n  TParams = TWithResolver extends true ? BlockerResolver<TRouter> : void,\n> = UseBlockerOpts<TRouter, TWithResolver> & {\n  children?: SolidNode | ((params: TParams) => SolidNode)\n}\n"],"names":["_resolveBlockerOpts","opts","condition","undefined","shouldBlockFn","withResolver","shouldBlock","Boolean","_customBlockerFn","enableBeforeUnload","fn","blockerFn","useBlocker","disabled","router","useRouter","history","resolver","setResolver","Solid","createSignal","status","current","next","action","proceed","reset","createEffect","blockerFnComposed","blockerFnArgs","getLocation","location","parsedLocation","parseLocation","matchedRoutes","getMatchedRoutes","foundRoute","Error","href","routeId","id","fullPath","pathname","params","routeParams","search","currentLocation","nextLocation","promise","Promise","resolve","canNavigateAsync","block","_resolvePromptBlockerArgs","props","Block","children","rest","args"],"mappings":"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"}

package/dist/cjs/useBlocker.d.cts

@@ -0,0 +1,68 @@
+import { HistoryAction } from '@tanstack/history';
+import { AnyRoute, SolidNode } from './route.cjs';
+import { ParseRoute } from './routeInfo.cjs';
+import { AnyRouter, RegisteredRouter } from './router.cjs';
+import * as Solid from 'solid-js';
+interface ShouldBlockFnLocation<out TRouteId, out TFullPath, out TAllParams, out TFullSearchSchema> {
+    routeId: TRouteId;
+    fullPath: TFullPath;
+    pathname: string;
+    params: TAllParams;
+    search: TFullSearchSchema;
+}
+type MakeShouldBlockFnLocationUnion<TRouter extends AnyRouter = RegisteredRouter, TRoute extends AnyRoute = ParseRoute<TRouter['routeTree']>> = TRoute extends any ? ShouldBlockFnLocation<TRoute['id'], TRoute['fullPath'], TRoute['types']['allParams'], TRoute['types']['fullSearchSchema']> : never;
+type BlockerResolver<TRouter extends AnyRouter = RegisteredRouter> = {
+    status: 'blocked';
+    current: MakeShouldBlockFnLocationUnion<TRouter>;
+    next: MakeShouldBlockFnLocationUnion<TRouter>;
+    action: HistoryAction;
+    proceed: () => void;
+    reset: () => void;
+} | {
+    status: 'idle';
+    current: undefined;
+    next: undefined;
+    action: undefined;
+    proceed: undefined;
+    reset: undefined;
+};
+type ShouldBlockFnArgs<TRouter extends AnyRouter = RegisteredRouter> = {
+    current: MakeShouldBlockFnLocationUnion<TRouter>;
+    next: MakeShouldBlockFnLocationUnion<TRouter>;
+    action: HistoryAction;
+};
+export type ShouldBlockFn<TRouter extends AnyRouter = RegisteredRouter> = (args: ShouldBlockFnArgs<TRouter>) => boolean | Promise<boolean>;
+export type UseBlockerOpts<TRouter extends AnyRouter = RegisteredRouter, TWithResolver extends boolean = boolean> = {
+    shouldBlockFn: ShouldBlockFn<TRouter>;
+    enableBeforeUnload?: boolean | (() => boolean);
+    disabled?: boolean;
+    withResolver?: TWithResolver;
+};
+type LegacyBlockerFn = () => Promise<any> | any;
+type LegacyBlockerOpts = {
+    blockerFn?: LegacyBlockerFn;
+    condition?: boolean | any;
+};
+export declare function useBlocker<TRouter extends AnyRouter = RegisteredRouter, TWithResolver extends boolean = false>(opts: UseBlockerOpts<TRouter, TWithResolver>): TWithResolver extends true ? Solid.Accessor<BlockerResolver<TRouter>> : void;
+/**
+ * @deprecated Use the shouldBlockFn property instead
+ */
+export declare function useBlocker(blockerFnOrOpts?: LegacyBlockerOpts): Solid.Accessor<BlockerResolver>;
+/**
+ * @deprecated Use the UseBlockerOpts object syntax instead
+ */
+export declare function useBlocker(blockerFn?: LegacyBlockerFn, condition?: boolean | any): Solid.Accessor<BlockerResolver>;
+export declare function Block<TRouter extends AnyRouter = RegisteredRouter, TWithResolver extends boolean = boolean>(opts: PromptProps<TRouter, TWithResolver>): SolidNode;
+/**
+ *  @deprecated Use the UseBlockerOpts property instead
+ */
+export declare function Block(opts: LegacyPromptProps): SolidNode;
+type LegacyPromptProps = {
+    blockerFn?: LegacyBlockerFn;
+    condition?: boolean | any;
+    children?: SolidNode | ((params: BlockerResolver) => SolidNode);
+};
+type PromptProps<TRouter extends AnyRouter = RegisteredRouter, TWithResolver extends boolean = boolean, TParams = TWithResolver extends true ? BlockerResolver<TRouter> : void> = UseBlockerOpts<TRouter, TWithResolver> & {
+    children?: SolidNode | ((params: TParams) => SolidNode);
+};
+export {};

package/dist/cjs/useCanGoBack.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const useRouterState = require("./useRouterState.cjs");
+function useCanGoBack() {
+  return useRouterState.useRouterState({ select: (s) => s.location.state.__TSR_index !== 0 });
+}
+exports.useCanGoBack = useCanGoBack;
+//# sourceMappingURL=useCanGoBack.cjs.map

package/dist/cjs/useCanGoBack.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanGoBack.cjs","sources":["../../src/useCanGoBack.ts"],"sourcesContent":["import { useRouterState } from './useRouterState'\n\nexport function useCanGoBack() {\n  return useRouterState({ select: (s) => s.location.state.__TSR_index !== 0 })\n}\n"],"names":["useRouterState"],"mappings":";;;AAEO,SAAS,eAAe;AACtB,SAAAA,eAAA,eAAe,EAAE,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,gBAAgB,GAAG;AAC7E;;"}

package/dist/cjs/useCanGoBack.d.cts

@@ -0,0 +1 @@
+export declare function useCanGoBack(): import('solid-js').Accessor<boolean>;

package/dist/cjs/useLoaderData.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const useMatch = require("./useMatch.cjs");
+function useLoaderData(opts) {
+  return useMatch.useMatch({
+    from: opts.from,
+    strict: opts.strict,
+    select: (s) => {
+      return opts.select ? opts.select(s.loaderData) : s.loaderData;
+    }
+  });
+}
+exports.useLoaderData = useLoaderData;
+//# sourceMappingURL=useLoaderData.cjs.map

package/dist/cjs/useLoaderData.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLoaderData.cjs","sources":["../../src/useLoaderData.tsx"],"sourcesContent":["import { useMatch } from './useMatch'\nimport type { Accessor } from 'solid-js'\nimport type { AnyRouter, RegisteredRouter } from './router'\nimport type { AllLoaderData, RouteById } from './routeInfo'\nimport type { StrictOrFrom } from './utils'\nimport type { Expand } from '@tanstack/router-core'\n\nexport interface UseLoaderDataBaseOptions<\n  TRouter extends AnyRouter,\n  TFrom,\n  TStrict extends boolean,\n  TSelected,\n> {\n  select?: (match: ResolveLoaderData<TRouter, TFrom, TStrict>) => TSelected\n}\n\nexport type UseLoaderDataOptions<\n  TRouter extends AnyRouter,\n  TFrom extends string | undefined,\n  TStrict extends boolean,\n  TSelected,\n> = StrictOrFrom<TRouter, TFrom, TStrict> &\n  UseLoaderDataBaseOptions<TRouter, TFrom, TStrict, TSelected>\n\nexport type ResolveLoaderData<\n  TRouter extends AnyRouter,\n  TFrom,\n  TStrict extends boolean,\n> = TStrict extends false\n  ? AllLoaderData<TRouter['routeTree']>\n  : Expand<RouteById<TRouter['routeTree'], TFrom>['types']['loaderData']>\n\nexport type UseLoaderDataResult<\n  TRouter extends AnyRouter,\n  TFrom,\n  TStrict extends boolean,\n  TSelected,\n> = unknown extends TSelected\n  ? ResolveLoaderData<TRouter, TFrom, TStrict>\n  : TSelected\n\nexport type UseLoaderDataRoute<out TId> = <\n  TRouter extends AnyRouter = RegisteredRouter,\n  TSelected = unknown,\n>(\n  opts?: UseLoaderDataBaseOptions<TRouter, TId, true, TSelected>,\n) => Accessor<UseLoaderDataResult<TRouter, TId, true, TSelected>>\n\nexport function useLoaderData<\n  TRouter extends AnyRouter = RegisteredRouter,\n  const TFrom extends string | undefined = undefined,\n  TStrict extends boolean = true,\n  TSelected = unknown,\n>(\n  opts: UseLoaderDataOptions<TRouter, TFrom, TStrict, TSelected>,\n): Accessor<UseLoaderDataResult<TRouter, TFrom, TStrict, TSelected>> {\n  return useMatch({\n    from: opts.from!,\n    strict: opts.strict,\n    select: (s: any) => {\n      return opts.select ? opts.select(s.loaderData) : s.loaderData\n    },\n  } as any) as any\n}\n"],"names":["useLoaderData","opts","useMatch","from","strict","select","s","loaderData"],"mappings":";;;AAgDO,SAASA,cAMdC,MACmE;AACnE,SAAOC,kBAAS;AAAA,IACdC,MAAMF,KAAKE;AAAAA,IACXC,QAAQH,KAAKG;AAAAA,IACbC,QAAQA,CAACC,MAAW;AAClB,aAAOL,KAAKI,SAASJ,KAAKI,OAAOC,EAAEC,UAAU,IAAID,EAAEC;AAAAA,IAAAA;AAAAA,EACrD,CACM;AACV;;"}

package/dist/cjs/useLoaderData.d.cts

@@ -0,0 +1,13 @@
+import { Accessor } from 'solid-js';
+import { AnyRouter, RegisteredRouter } from './router.cjs';
+import { AllLoaderData, RouteById } from './routeInfo.cjs';
+import { StrictOrFrom } from './utils.cjs';
+import { Expand } from '@tanstack/router-core';
+export interface UseLoaderDataBaseOptions<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TSelected> {
+    select?: (match: ResolveLoaderData<TRouter, TFrom, TStrict>) => TSelected;
+}
+export type UseLoaderDataOptions<TRouter extends AnyRouter, TFrom extends string | undefined, TStrict extends boolean, TSelected> = StrictOrFrom<TRouter, TFrom, TStrict> & UseLoaderDataBaseOptions<TRouter, TFrom, TStrict, TSelected>;
+export type ResolveLoaderData<TRouter extends AnyRouter, TFrom, TStrict extends boolean> = TStrict extends false ? AllLoaderData<TRouter['routeTree']> : Expand<RouteById<TRouter['routeTree'], TFrom>['types']['loaderData']>;
+export type UseLoaderDataResult<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TSelected> = unknown extends TSelected ? ResolveLoaderData<TRouter, TFrom, TStrict> : TSelected;
+export type UseLoaderDataRoute<out TId> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: UseLoaderDataBaseOptions<TRouter, TId, true, TSelected>) => Accessor<UseLoaderDataResult<TRouter, TId, true, TSelected>>;
+export declare function useLoaderData<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string | undefined = undefined, TStrict extends boolean = true, TSelected = unknown>(opts: UseLoaderDataOptions<TRouter, TFrom, TStrict, TSelected>): Accessor<UseLoaderDataResult<TRouter, TFrom, TStrict, TSelected>>;

package/dist/cjs/useLoaderDeps.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const useMatch = require("./useMatch.cjs");
+function useLoaderDeps(opts) {
+  const {
+    select,
+    ...rest
+  } = opts;
+  return useMatch.useMatch({
+    ...rest,
+    select: (s) => {
+      return select ? select(s.loaderDeps) : s.loaderDeps;
+    }
+  });
+}
+exports.useLoaderDeps = useLoaderDeps;
+//# sourceMappingURL=useLoaderDeps.cjs.map