@tanstack/solid-router 1.108.0

package/dist/cjs/useLoaderDeps.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLoaderDeps.cjs","sources":["../../src/useLoaderDeps.tsx"],"sourcesContent":["import { useMatch } from './useMatch'\nimport type { AnyRouter, RegisteredRouter } from './router'\nimport type { RouteById } from './routeInfo'\nimport type { StrictOrFrom } from './utils'\nimport type { Expand } from '@tanstack/router-core'\n\nexport interface UseLoaderDepsBaseOptions<\n  TRouter extends AnyRouter,\n  TFrom,\n  TSelected,\n> {\n  select?: (deps: ResolveLoaderDeps<TRouter, TFrom>) => TSelected\n}\n\nexport type UseLoaderDepsOptions<\n  TRouter extends AnyRouter,\n  TFrom extends string | undefined,\n  TSelected,\n> = StrictOrFrom<TRouter, TFrom> &\n  UseLoaderDepsBaseOptions<TRouter, TFrom, TSelected>\nexport type ResolveLoaderDeps<TRouter extends AnyRouter, TFrom> = Expand<\n  RouteById<TRouter['routeTree'], TFrom>['types']['loaderDeps']\n>\n\nexport type UseLoaderDepsResult<\n  TRouter extends AnyRouter,\n  TFrom,\n  TSelected,\n> = unknown extends TSelected ? ResolveLoaderDeps<TRouter, TFrom> : TSelected\n\nexport type UseLoaderDepsRoute<out TId> = <\n  TRouter extends AnyRouter = RegisteredRouter,\n  TSelected = unknown,\n>(\n  opts?: UseLoaderDepsBaseOptions<TRouter, TId, TSelected>,\n) => UseLoaderDepsResult<TRouter, TId, TSelected>\n\nexport function useLoaderDeps<\n  TRouter extends AnyRouter = RegisteredRouter,\n  const TFrom extends string | undefined = undefined,\n  TSelected = unknown,\n>(\n  opts: UseLoaderDepsOptions<TRouter, TFrom, TSelected>,\n): UseLoaderDepsResult<TRouter, TFrom, TSelected> {\n  const { select, ...rest } = opts\n  return useMatch({\n    ...rest,\n    select: (s) => {\n      return select ? select(s.loaderDeps) : s.loaderDeps\n    },\n  }) as UseLoaderDepsResult<TRouter, TFrom, TSelected>\n}\n"],"names":["useLoaderDeps","opts","select","rest","useMatch","s","loaderDeps"],"mappings":";;;AAqCO,SAASA,cAKdC,MACgD;AAC1C,QAAA;AAAA,IAAEC;AAAAA,IAAQ,GAAGC;AAAAA,EAAAA,IAASF;AAC5B,SAAOG,kBAAS;AAAA,IACd,GAAGD;AAAAA,IACHD,QAASG,CAAM,MAAA;AACb,aAAOH,SAASA,OAAOG,EAAEC,UAAU,IAAID,EAAEC;AAAAA,IAAAA;AAAAA,EAC3C,CACD;AACH;;"}

package/dist/cjs/useLoaderDeps.d.cts

@@ -0,0 +1,12 @@
+import { AnyRouter, RegisteredRouter } from './router.cjs';
+import { RouteById } from './routeInfo.cjs';
+import { StrictOrFrom } from './utils.cjs';
+import { Expand } from '@tanstack/router-core';
+export interface UseLoaderDepsBaseOptions<TRouter extends AnyRouter, TFrom, TSelected> {
+    select?: (deps: ResolveLoaderDeps<TRouter, TFrom>) => TSelected;
+}
+export type UseLoaderDepsOptions<TRouter extends AnyRouter, TFrom extends string | undefined, TSelected> = StrictOrFrom<TRouter, TFrom> & UseLoaderDepsBaseOptions<TRouter, TFrom, TSelected>;
+export type ResolveLoaderDeps<TRouter extends AnyRouter, TFrom> = Expand<RouteById<TRouter['routeTree'], TFrom>['types']['loaderDeps']>;
+export type UseLoaderDepsResult<TRouter extends AnyRouter, TFrom, TSelected> = unknown extends TSelected ? ResolveLoaderDeps<TRouter, TFrom> : TSelected;
+export type UseLoaderDepsRoute<out TId> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: UseLoaderDepsBaseOptions<TRouter, TId, TSelected>) => UseLoaderDepsResult<TRouter, TId, TSelected>;
+export declare function useLoaderDeps<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string | undefined = undefined, TSelected = unknown>(opts: UseLoaderDepsOptions<TRouter, TFrom, TSelected>): UseLoaderDepsResult<TRouter, TFrom, TSelected>;

package/dist/cjs/useLocation.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const useRouterState = require("./useRouterState.cjs");
+function useLocation(opts) {
+  return useRouterState.useRouterState({
+    select: (state) => (opts == null ? void 0 : opts.select) ? opts.select(state.location) : state.location
+  });
+}
+exports.useLocation = useLocation;
+//# sourceMappingURL=useLocation.cjs.map

package/dist/cjs/useLocation.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocation.cjs","sources":["../../src/useLocation.tsx"],"sourcesContent":["import { useRouterState } from './useRouterState'\nimport type { Accessor } from 'solid-js'\nimport type { AnyRouter, RegisteredRouter, RouterState } from './router'\n\nexport interface UseLocationBaseOptions<TRouter extends AnyRouter, TSelected> {\n  select?: (state: RouterState<TRouter['routeTree']>['location']) => TSelected\n}\n\nexport type UseLocationResult<\n  TRouter extends AnyRouter,\n  TSelected,\n> = unknown extends TSelected\n  ? RouterState<TRouter['routeTree']>['location']\n  : TSelected\n\nexport function useLocation<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TSelected = unknown,\n>(\n  opts?: UseLocationBaseOptions<TRouter, TSelected>,\n): Accessor<UseLocationResult<TRouter, TSelected>> {\n  return useRouterState({\n    select: (state: any) =>\n      opts?.select ? opts.select(state.location) : state.location,\n  } as any) as Accessor<UseLocationResult<TRouter, TSelected>>\n}\n"],"names":["useLocation","opts","useRouterState","select","state","location"],"mappings":";;;AAeO,SAASA,YAIdC,MACiD;AACjD,SAAOC,8BAAe;AAAA,IACpBC,QAAQA,CAACC,WACPH,6BAAME,UAASF,KAAKE,OAAOC,MAAMC,QAAQ,IAAID,MAAMC;AAAAA,EAAAA,CAC/C;AACV;;"}

package/dist/cjs/useLocation.d.cts

@@ -0,0 +1,7 @@
+import { Accessor } from 'solid-js';
+import { AnyRouter, RegisteredRouter, RouterState } from './router.cjs';
+export interface UseLocationBaseOptions<TRouter extends AnyRouter, TSelected> {
+    select?: (state: RouterState<TRouter['routeTree']>['location']) => TSelected;
+}
+export type UseLocationResult<TRouter extends AnyRouter, TSelected> = unknown extends TSelected ? RouterState<TRouter['routeTree']>['location'] : TSelected;
+export declare function useLocation<TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: UseLocationBaseOptions<TRouter, TSelected>): Accessor<UseLocationResult<TRouter, TSelected>>;

package/dist/cjs/useMatch.cjs

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Solid = require("solid-js");
+const invariant = require("tiny-invariant");
+const useRouterState = require("./useRouterState.cjs");
+const matchContext = require("./matchContext.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 useMatch(opts) {
+  const nearestMatchId = Solid__namespace.useContext(opts.from ? matchContext.dummyMatchContext : matchContext.matchContext);
+  const matchSelection = useRouterState.useRouterState({
+    select: (state) => {
+      const match = state.matches.find((d) => opts.from ? opts.from === d.routeId : d.id === nearestMatchId());
+      invariant(!((opts.shouldThrow ?? true) && !match), `Could not find ${opts.from ? `an active match from "${opts.from}"` : "a nearest match!"}`);
+      if (match === void 0) {
+        return void 0;
+      }
+      return opts.select ? opts.select(match) : match;
+    }
+  });
+  return matchSelection;
+}
+exports.useMatch = useMatch;
+//# sourceMappingURL=useMatch.cjs.map

package/dist/cjs/useMatch.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMatch.cjs","sources":["../../src/useMatch.tsx"],"sourcesContent":["import * as Solid from 'solid-js'\nimport invariant from 'tiny-invariant'\nimport { useRouterState } from './useRouterState'\nimport { dummyMatchContext, matchContext } from './matchContext'\nimport type { AnyRouter, RegisteredRouter } from './router'\nimport type { MakeRouteMatch, MakeRouteMatchUnion } from './Matches'\nimport type { StrictOrFrom } from './utils'\nimport type { ThrowOrOptional } from '@tanstack/router-core'\n\nexport interface UseMatchBaseOptions<\n  TRouter extends AnyRouter,\n  TFrom,\n  TStrict extends boolean,\n  TThrow extends boolean,\n  TSelected,\n> {\n  select?: (\n    match: MakeRouteMatch<TRouter['routeTree'], TFrom, TStrict>,\n  ) => TSelected\n  shouldThrow?: TThrow\n}\n\nexport type UseMatchRoute<out TFrom> = <\n  TRouter extends AnyRouter = RegisteredRouter,\n  TSelected = unknown,\n>(\n  opts?: UseMatchBaseOptions<TRouter, TFrom, true, true, TSelected>,\n) => Solid.Accessor<UseMatchResult<TRouter, TFrom, true, TSelected>>\n\nexport type UseMatchOptions<\n  TRouter extends AnyRouter,\n  TFrom extends string | undefined,\n  TStrict extends boolean,\n  TThrow extends boolean,\n  TSelected,\n> = StrictOrFrom<TRouter, TFrom, TStrict> &\n  UseMatchBaseOptions<TRouter, TFrom, TStrict, TThrow, TSelected>\n\nexport type UseMatchResult<\n  TRouter extends AnyRouter,\n  TFrom,\n  TStrict extends boolean,\n  TSelected,\n> = unknown extends TSelected\n  ? TStrict extends true\n    ? MakeRouteMatch<TRouter['routeTree'], TFrom, TStrict>\n    : MakeRouteMatchUnion<TRouter>\n  : TSelected\n\nexport type ThrowConstraint<\n  TStrict extends boolean,\n  TThrow extends boolean,\n> = TStrict extends false ? (TThrow extends true ? never : TThrow) : TThrow\n\nexport function useMatch<\n  TRouter extends AnyRouter = RegisteredRouter,\n  const TFrom extends string | undefined = undefined,\n  TStrict extends boolean = true,\n  TThrow extends boolean = true,\n  TSelected = unknown,\n>(\n  opts: UseMatchOptions<\n    TRouter,\n    TFrom,\n    TStrict,\n    ThrowConstraint<TStrict, TThrow>,\n    TSelected\n  >,\n): Solid.Accessor<\n  ThrowOrOptional<UseMatchResult<TRouter, TFrom, TStrict, TSelected>, TThrow>\n> {\n  const nearestMatchId = Solid.useContext(\n    opts.from ? dummyMatchContext : matchContext,\n  )\n\n  const matchSelection = useRouterState({\n    select: (state: any) => {\n      const match = state.matches.find((d: any) =>\n        opts.from ? opts.from === d.routeId : d.id === nearestMatchId(),\n      )\n\n      invariant(\n        !((opts.shouldThrow ?? true) && !match),\n        `Could not find ${opts.from ? `an active match from \"${opts.from}\"` : 'a nearest match!'}`,\n      )\n\n      if (match === undefined) {\n        return undefined\n      }\n\n      return opts.select ? opts.select(match) : match\n    },\n  } as any)\n\n  return matchSelection as any\n}\n"],"names":["useMatch","opts","nearestMatchId","Solid","useContext","from","dummyMatchContext","matchContext","matchSelection","useRouterState","select","state","match","matches","find","d","routeId","id","invariant","shouldThrow","undefined"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAsDO,SAASA,SAOdC,MASA;AACA,QAAMC,iBAAiBC,iBAAMC,WAC3BH,KAAKI,OAAOC,iCAAoBC,yBAClC;AAEA,QAAMC,iBAAiBC,eAAAA,eAAe;AAAA,IACpCC,QAAQA,CAACC,UAAe;AACtB,YAAMC,QAAQD,MAAME,QAAQC,KAAK,CAACC,MAChCd,KAAKI,OAAOJ,KAAKI,SAASU,EAAEC,UAAUD,EAAEE,OAAOf,gBACjD;AAEAgB,gBACE,GAAGjB,KAAKkB,eAAe,SAAS,CAACP,QACjC,kBAAkBX,KAAKI,OAAO,yBAAyBJ,KAAKI,IAAI,MAAM,kBAAkB,EAC1F;AAEA,UAAIO,UAAUQ,QAAW;AAChBA,eAAAA;AAAAA,MAAAA;AAGT,aAAOnB,KAAKS,SAAST,KAAKS,OAAOE,KAAK,IAAIA;AAAAA,IAAAA;AAAAA,EAC5C,CACM;AAEDJ,SAAAA;AACT;;"}

package/dist/cjs/useMatch.d.cts

@@ -0,0 +1,14 @@
+import { AnyRouter, RegisteredRouter } from './router.cjs';
+import { MakeRouteMatch, MakeRouteMatchUnion } from './Matches.cjs';
+import { StrictOrFrom } from './utils.cjs';
+import { ThrowOrOptional } from '@tanstack/router-core';
+import * as Solid from 'solid-js';
+export interface UseMatchBaseOptions<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TThrow extends boolean, TSelected> {
+    select?: (match: MakeRouteMatch<TRouter['routeTree'], TFrom, TStrict>) => TSelected;
+    shouldThrow?: TThrow;
+}
+export type UseMatchRoute<out TFrom> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: UseMatchBaseOptions<TRouter, TFrom, true, true, TSelected>) => Solid.Accessor<UseMatchResult<TRouter, TFrom, true, TSelected>>;
+export type UseMatchOptions<TRouter extends AnyRouter, TFrom extends string | undefined, TStrict extends boolean, TThrow extends boolean, TSelected> = StrictOrFrom<TRouter, TFrom, TStrict> & UseMatchBaseOptions<TRouter, TFrom, TStrict, TThrow, TSelected>;
+export type UseMatchResult<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TSelected> = unknown extends TSelected ? TStrict extends true ? MakeRouteMatch<TRouter['routeTree'], TFrom, TStrict> : MakeRouteMatchUnion<TRouter> : TSelected;
+export type ThrowConstraint<TStrict extends boolean, TThrow extends boolean> = TStrict extends false ? (TThrow extends true ? never : TThrow) : TThrow;
+export declare function useMatch<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string | undefined = undefined, TStrict extends boolean = true, TThrow extends boolean = true, TSelected = unknown>(opts: UseMatchOptions<TRouter, TFrom, TStrict, ThrowConstraint<TStrict, TThrow>, TSelected>): Solid.Accessor<ThrowOrOptional<UseMatchResult<TRouter, TFrom, TStrict, TSelected>, TThrow>>;

package/dist/cjs/useNavigate.cjs

@@ -0,0 +1,45 @@
+"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 useNavigate(_defaultOpts) {
+  const {
+    navigate
+  } = useRouter.useRouter();
+  return (options) => {
+    return navigate({
+      ...options
+    });
+  };
+}
+function Navigate(props) {
+  const {
+    navigate
+  } = useRouter.useRouter();
+  Solid__namespace.onMount(() => {
+    navigate({
+      ...props
+    });
+  });
+  return null;
+}
+exports.Navigate = Navigate;
+exports.useNavigate = useNavigate;
+//# sourceMappingURL=useNavigate.cjs.map

package/dist/cjs/useNavigate.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNavigate.cjs","sources":["../../src/useNavigate.tsx"],"sourcesContent":["import * as Solid from 'solid-js'\nimport { useRouter } from './useRouter'\nimport type { FromPathOption, NavigateOptions } from './link'\nimport type { AnyRouter, RegisteredRouter } from './router'\n\nexport type UseNavigateResult<TDefaultFrom extends string> = <\n  TRouter extends RegisteredRouter,\n  TTo extends string | undefined,\n  TFrom extends string = TDefaultFrom,\n  TMaskFrom extends string = TFrom,\n  TMaskTo extends string = '',\n>({\n  from,\n  ...rest\n}: NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>) => Promise<void>\n\nexport function useNavigate<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TDefaultFrom extends string = string,\n>(_defaultOpts?: {\n  from?: FromPathOption<TRouter, TDefaultFrom>\n}): UseNavigateResult<TDefaultFrom> {\n  const { navigate } = useRouter()\n\n  return ((options: NavigateOptions) => {\n    return navigate({ ...options })\n  }) as UseNavigateResult<TDefaultFrom>\n}\n\n// NOTE: I don't know of anyone using this. It's undocumented, so let's wait until someone needs it\n// export function typedNavigate<\n//   TRouteTree extends AnyRoute = RegisteredRouter['routeTree'],\n//   TDefaultFrom extends RoutePaths<TRouteTree> = '/',\n// >(navigate: (opts: NavigateOptions<any>) => Promise<void>) {\n//   return navigate as <\n//     TFrom extends RoutePaths<TRouteTree> = TDefaultFrom,\n//     TTo extends string = '',\n//     TMaskFrom extends RoutePaths<TRouteTree> = '/',\n//     TMaskTo extends string = '',\n//   >(\n//     opts?: NavigateOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>,\n//   ) => Promise<void>\n// } //\n\nexport function Navigate<\n  TRouter extends AnyRouter = RegisteredRouter,\n  const TFrom extends string = string,\n  const TTo extends string | undefined = undefined,\n  const TMaskFrom extends string = TFrom,\n  const TMaskTo extends string = '',\n>(props: NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>): null {\n  const { navigate } = useRouter()\n\n  Solid.onMount(() => {\n    navigate({\n      ...props,\n    })\n  })\n\n  return null\n}\n"],"names":["useNavigate","_defaultOpts","navigate","useRouter","options","Navigate","props","Solid","onMount"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAgBO,SAASA,YAGdC,cAEkC;AAC5B,QAAA;AAAA,IAAEC;AAAAA,MAAaC,oBAAU;AAE/B,SAAQ,CAACC,YAA6B;AACpC,WAAOF,SAAS;AAAA,MAAE,GAAGE;AAAAA,IAAAA,CAAS;AAAA,EAChC;AACF;AAiBO,SAASC,SAMdC,OAAuE;AACjE,QAAA;AAAA,IAAEJ;AAAAA,MAAaC,oBAAU;AAE/BI,mBAAMC,QAAQ,MAAM;AACT,aAAA;AAAA,MACP,GAAGF;AAAAA,IAAAA,CACJ;AAAA,EAAA,CACF;AAEM,SAAA;AACT;;;"}

package/dist/cjs/useNavigate.d.cts

@@ -0,0 +1,7 @@
+import { FromPathOption, NavigateOptions } from './link.cjs';
+import { AnyRouter, RegisteredRouter } from './router.cjs';
+export type UseNavigateResult<TDefaultFrom extends string> = <TRouter extends RegisteredRouter, TTo extends string | undefined, TFrom extends string = TDefaultFrom, TMaskFrom extends string = TFrom, TMaskTo extends string = ''>({ from, ...rest }: NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>) => Promise<void>;
+export declare function useNavigate<TRouter extends AnyRouter = RegisteredRouter, TDefaultFrom extends string = string>(_defaultOpts?: {
+    from?: FromPathOption<TRouter, TDefaultFrom>;
+}): UseNavigateResult<TDefaultFrom>;
+export declare function Navigate<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string = string, const TTo extends string | undefined = undefined, const TMaskFrom extends string = TFrom, const TMaskTo extends string = ''>(props: NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>): null;

package/dist/cjs/useParams.cjs

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

package/dist/cjs/useParams.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useParams.cjs","sources":["../../src/useParams.tsx"],"sourcesContent":["import { useMatch } from './useMatch'\nimport type { ThrowConstraint } from './useMatch'\nimport type { Accessor } from 'solid-js'\nimport type { AllParams, RouteById } from './routeInfo'\nimport type { AnyRouter, RegisteredRouter } from './router'\nimport type { StrictOrFrom } from './utils'\nimport type { Expand, ThrowOrOptional } from '@tanstack/router-core'\n\nexport interface UseParamsBaseOptions<\n  TRouter extends AnyRouter,\n  TFrom,\n  TStrict extends boolean,\n  TThrow extends boolean,\n  TSelected,\n> {\n  select?: (params: ResolveParams<TRouter, TFrom, TStrict>) => TSelected\n  shouldThrow?: TThrow\n}\n\nexport type UseParamsOptions<\n  TRouter extends AnyRouter,\n  TFrom extends string | undefined,\n  TStrict extends boolean,\n  TThrow extends boolean,\n  TSelected,\n> = StrictOrFrom<TRouter, TFrom, TStrict> &\n  UseParamsBaseOptions<TRouter, TFrom, TStrict, TThrow, TSelected>\nexport type ResolveParams<\n  TRouter extends AnyRouter,\n  TFrom,\n  TStrict extends boolean,\n> = TStrict extends false\n  ? AllParams<TRouter['routeTree']>\n  : Expand<RouteById<TRouter['routeTree'], TFrom>['types']['allParams']>\n\nexport type UseParamsResult<\n  TRouter extends AnyRouter,\n  TFrom,\n  TStrict extends boolean,\n  TSelected,\n> = unknown extends TSelected\n  ? ResolveParams<TRouter, TFrom, TStrict>\n  : TSelected\n\nexport type UseParamsRoute<out TFrom> = <\n  TRouter extends AnyRouter = RegisteredRouter,\n  TSelected = unknown,\n>(\n  opts?: UseParamsBaseOptions<\n    TRouter,\n    TFrom,\n    /* TStrict */ true,\n    /* TThrow */ true,\n    TSelected\n  >,\n) => Accessor<UseParamsResult<TRouter, TFrom, true, TSelected>>\n\nexport function useParams<\n  TRouter extends AnyRouter = RegisteredRouter,\n  const TFrom extends string | undefined = undefined,\n  TStrict extends boolean = true,\n  TThrow extends boolean = true,\n  TSelected = unknown,\n>(\n  opts: UseParamsOptions<\n    TRouter,\n    TFrom,\n    TStrict,\n    ThrowConstraint<TStrict, TThrow>,\n    TSelected\n  >,\n): Accessor<\n  ThrowOrOptional<UseParamsResult<TRouter, TFrom, TStrict, TSelected>, TThrow>\n> {\n  return useMatch({\n    from: opts.from!,\n    strict: opts.strict,\n    shouldThrow: opts.shouldThrow,\n    select: (match: any) => {\n      return opts.select ? opts.select(match.params) : match.params\n    },\n  } as any) as any\n}\n"],"names":["useParams","opts","useMatch","from","strict","shouldThrow","select","match","params"],"mappings":";;;AAyDO,SAASA,UAOdC,MASA;AACA,SAAOC,kBAAS;AAAA,IACdC,MAAMF,KAAKE;AAAAA,IACXC,QAAQH,KAAKG;AAAAA,IACbC,aAAaJ,KAAKI;AAAAA,IAClBC,QAAQA,CAACC,UAAe;AACtB,aAAON,KAAKK,SAASL,KAAKK,OAAOC,MAAMC,MAAM,IAAID,MAAMC;AAAAA,IAAAA;AAAAA,EACzD,CACM;AACV;;"}

package/dist/cjs/useParams.d.cts

@@ -0,0 +1,15 @@
+import { ThrowConstraint } from './useMatch.cjs';
+import { Accessor } from 'solid-js';
+import { AllParams, RouteById } from './routeInfo.cjs';
+import { AnyRouter, RegisteredRouter } from './router.cjs';
+import { StrictOrFrom } from './utils.cjs';
+import { Expand, ThrowOrOptional } from '@tanstack/router-core';
+export interface UseParamsBaseOptions<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TThrow extends boolean, TSelected> {
+    select?: (params: ResolveParams<TRouter, TFrom, TStrict>) => TSelected;
+    shouldThrow?: TThrow;
+}
+export type UseParamsOptions<TRouter extends AnyRouter, TFrom extends string | undefined, TStrict extends boolean, TThrow extends boolean, TSelected> = StrictOrFrom<TRouter, TFrom, TStrict> & UseParamsBaseOptions<TRouter, TFrom, TStrict, TThrow, TSelected>;
+export type ResolveParams<TRouter extends AnyRouter, TFrom, TStrict extends boolean> = TStrict extends false ? AllParams<TRouter['routeTree']> : Expand<RouteById<TRouter['routeTree'], TFrom>['types']['allParams']>;
+export type UseParamsResult<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TSelected> = unknown extends TSelected ? ResolveParams<TRouter, TFrom, TStrict> : TSelected;
+export type UseParamsRoute<out TFrom> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: UseParamsBaseOptions<TRouter, TFrom, true, true, TSelected>) => Accessor<UseParamsResult<TRouter, TFrom, true, TSelected>>;
+export declare function useParams<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string | undefined = undefined, TStrict extends boolean = true, TThrow extends boolean = true, TSelected = unknown>(opts: UseParamsOptions<TRouter, TFrom, TStrict, ThrowConstraint<TStrict, TThrow>, TSelected>): Accessor<ThrowOrOptional<UseParamsResult<TRouter, TFrom, TStrict, TSelected>, TThrow>>;

package/dist/cjs/useRouteContext.cjs

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

package/dist/cjs/useRouteContext.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRouteContext.cjs","sources":["../../src/useRouteContext.ts"],"sourcesContent":["import { useMatch } from './useMatch'\nimport type { Accessor } from 'solid-js'\nimport type { AllContext, RouteById } from './routeInfo'\nimport type { AnyRouter, RegisteredRouter } from './router'\nimport type { StrictOrFrom } from './utils'\nimport type { Expand } from '@tanstack/router-core'\n\nexport interface UseRouteContextBaseOptions<\n  TRouter extends AnyRouter,\n  TFrom,\n  TStrict extends boolean,\n  TSelected,\n> {\n  select?: (search: ResolveRouteContext<TRouter, TFrom, TStrict>) => TSelected\n}\n\nexport type UseRouteContextOptions<\n  TRouter extends AnyRouter,\n  TFrom extends string | undefined,\n  TStrict extends boolean,\n  TSelected,\n> = StrictOrFrom<TRouter, TFrom, TStrict> &\n  UseRouteContextBaseOptions<TRouter, TFrom, TStrict, TSelected>\n\nexport type ResolveRouteContext<\n  TRouter extends AnyRouter,\n  TFrom,\n  TStrict extends boolean,\n> = TStrict extends false\n  ? AllContext<TRouter['routeTree']>\n  : Expand<RouteById<TRouter['routeTree'], TFrom>['types']['allContext']>\n\nexport type UseRouteContextResult<\n  TRouter extends AnyRouter,\n  TFrom,\n  TStrict extends boolean,\n  TSelected,\n> = unknown extends TSelected\n  ? ResolveRouteContext<TRouter, TFrom, TStrict>\n  : TSelected\n\nexport type UseRouteContextRoute<out TFrom> = <\n  TRouter extends AnyRouter = RegisteredRouter,\n  TSelected = unknown,\n>(\n  opts?: UseRouteContextBaseOptions<TRouter, TFrom, true, TSelected>,\n) => Accessor<UseRouteContextResult<TRouter, TFrom, true, TSelected>>\n\nexport function useRouteContext<\n  TRouter extends AnyRouter = RegisteredRouter,\n  const TFrom extends string | undefined = undefined,\n  TStrict extends boolean = true,\n  TSelected = unknown,\n>(\n  opts: UseRouteContextOptions<TRouter, TFrom, TStrict, TSelected>,\n): Accessor<UseRouteContextResult<TRouter, TFrom, TStrict, TSelected>> {\n  return useMatch({\n    ...(opts as any),\n    select: (match) =>\n      opts.select ? opts.select(match.context) : match.context,\n  }) as any\n}\n"],"names":["useMatch"],"mappings":";;;AAgDO,SAAS,gBAMd,MACqE;AACrE,SAAOA,kBAAS;AAAA,IACd,GAAI;AAAA,IACJ,QAAQ,CAAC,UACP,KAAK,SAAS,KAAK,OAAO,MAAM,OAAO,IAAI,MAAM;AAAA,EAAA,CACpD;AACH;;"}

package/dist/cjs/useRouteContext.d.cts

@@ -0,0 +1,13 @@
+import { Accessor } from 'solid-js';
+import { AllContext, RouteById } from './routeInfo.cjs';
+import { AnyRouter, RegisteredRouter } from './router.cjs';
+import { StrictOrFrom } from './utils.cjs';
+import { Expand } from '@tanstack/router-core';
+export interface UseRouteContextBaseOptions<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TSelected> {
+    select?: (search: ResolveRouteContext<TRouter, TFrom, TStrict>) => TSelected;
+}
+export type UseRouteContextOptions<TRouter extends AnyRouter, TFrom extends string | undefined, TStrict extends boolean, TSelected> = StrictOrFrom<TRouter, TFrom, TStrict> & UseRouteContextBaseOptions<TRouter, TFrom, TStrict, TSelected>;
+export type ResolveRouteContext<TRouter extends AnyRouter, TFrom, TStrict extends boolean> = TStrict extends false ? AllContext<TRouter['routeTree']> : Expand<RouteById<TRouter['routeTree'], TFrom>['types']['allContext']>;
+export type UseRouteContextResult<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TSelected> = unknown extends TSelected ? ResolveRouteContext<TRouter, TFrom, TStrict> : TSelected;
+export type UseRouteContextRoute<out TFrom> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: UseRouteContextBaseOptions<TRouter, TFrom, true, TSelected>) => Accessor<UseRouteContextResult<TRouter, TFrom, true, TSelected>>;
+export declare function useRouteContext<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string | undefined = undefined, TStrict extends boolean = true, TSelected = unknown>(opts: UseRouteContextOptions<TRouter, TFrom, TStrict, TSelected>): Accessor<UseRouteContextResult<TRouter, TFrom, TStrict, TSelected>>;

package/dist/cjs/useRouter.cjs

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Solid = require("solid-js");
+const warning = require("tiny-warning");
+const routerContext = require("./routerContext.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 useRouter(opts) {
+  const value = Solid__namespace.useContext(routerContext.getRouterContext());
+  warning(!(((opts == null ? void 0 : opts.warn) ?? true) && !value), "useRouter must be used inside a <RouterProvider> component!");
+  return value;
+}
+exports.useRouter = useRouter;
+//# sourceMappingURL=useRouter.cjs.map

package/dist/cjs/useRouter.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRouter.cjs","sources":["../../src/useRouter.tsx"],"sourcesContent":["import * as Solid from 'solid-js'\nimport warning from 'tiny-warning'\nimport { getRouterContext } from './routerContext'\nimport type { AnyRouter, RegisteredRouter } from './router'\n\nexport function useRouter<TRouter extends AnyRouter = RegisteredRouter>(opts?: {\n  warn?: boolean\n}): TRouter {\n  const value = Solid.useContext(getRouterContext() as any)\n  warning(\n    !((opts?.warn ?? true) && !value),\n    'useRouter must be used inside a <RouterProvider> component!',\n  )\n  return value as any\n}\n"],"names":["useRouter","opts","value","Solid","useContext","getRouterContext","warning","warn"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAKO,SAASA,UAAwDC,MAE5D;AACV,QAAMC,QAAQC,iBAAMC,WAAWC,cAAAA,iBAAAA,CAAyB;AACxDC,UACE,IAAGL,6BAAMM,SAAQ,SAAS,CAACL,QAC3B,6DACF;AACOA,SAAAA;AACT;;"}

package/dist/cjs/useRouter.d.cts

@@ -0,0 +1,4 @@
+import { AnyRouter, RegisteredRouter } from './router.cjs';
+export declare function useRouter<TRouter extends AnyRouter = RegisteredRouter>(opts?: {
+    warn?: boolean;
+}): TRouter;

package/dist/cjs/useRouterState.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const solidStore = require("@tanstack/solid-store");
+const useRouter = require("./useRouter.cjs");
+function useRouterState(opts) {
+  const contextRouter = useRouter.useRouter({
+    warn: (opts == null ? void 0 : opts.router) === void 0
+  });
+  const router = (opts == null ? void 0 : opts.router) || contextRouter;
+  return solidStore.useStore(router.__store, (state) => {
+    if (opts == null ? void 0 : opts.select) return opts.select(state);
+    return state;
+  });
+}
+exports.useRouterState = useRouterState;
+//# sourceMappingURL=useRouterState.cjs.map

package/dist/cjs/useRouterState.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRouterState.cjs","sources":["../../src/useRouterState.tsx"],"sourcesContent":["import { useStore } from '@tanstack/solid-store'\nimport { useRouter } from './useRouter'\nimport type { AnyRouter, RegisteredRouter, RouterState } from './router'\nimport type { Accessor } from 'solid-js'\n\nexport type UseRouterStateOptions<TRouter extends AnyRouter, TSelected> = {\n  router?: TRouter\n  select?: (state: RouterState<TRouter['routeTree']>) => TSelected\n}\n\nexport type UseRouterStateResult<\n  TRouter extends AnyRouter,\n  TSelected,\n> = unknown extends TSelected ? RouterState<TRouter['routeTree']> : TSelected\n\nexport function useRouterState<\n  TRouter extends AnyRouter = RegisteredRouter,\n  TSelected = unknown,\n>(\n  opts?: UseRouterStateOptions<TRouter, TSelected>,\n): Accessor<UseRouterStateResult<TRouter, TSelected>> {\n  const contextRouter = useRouter<TRouter>({\n    warn: opts?.router === undefined,\n  })\n  const router = opts?.router || contextRouter\n\n  return useStore(router.__store, (state) => {\n    if (opts?.select) return opts.select(state)\n\n    return state\n  }) as Accessor<UseRouterStateResult<TRouter, TSelected>>\n}\n"],"names":["useRouterState","opts","contextRouter","useRouter","warn","router","undefined","useStore","__store","state","select"],"mappings":";;;;AAeO,SAASA,eAIdC,MACoD;AACpD,QAAMC,gBAAgBC,UAAAA,UAAmB;AAAA,IACvCC,OAAMH,6BAAMI,YAAWC;AAAAA,EAAAA,CACxB;AACKD,QAAAA,UAASJ,6BAAMI,WAAUH;AAExBK,SAAAA,oBAASF,OAAOG,SAAUC,CAAU,UAAA;AACzC,QAAIR,6BAAMS,OAAeT,QAAAA,KAAKS,OAAOD,KAAK;AAEnCA,WAAAA;AAAAA,EAAAA,CACR;AACH;;"}

package/dist/cjs/useRouterState.d.cts

@@ -0,0 +1,8 @@
+import { AnyRouter, RegisteredRouter, RouterState } from './router.cjs';
+import { Accessor } from 'solid-js';
+export type UseRouterStateOptions<TRouter extends AnyRouter, TSelected> = {
+    router?: TRouter;
+    select?: (state: RouterState<TRouter['routeTree']>) => TSelected;
+};
+export type UseRouterStateResult<TRouter extends AnyRouter, TSelected> = unknown extends TSelected ? RouterState<TRouter['routeTree']> : TSelected;
+export declare function useRouterState<TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: UseRouterStateOptions<TRouter, TSelected>): Accessor<UseRouterStateResult<TRouter, TSelected>>;

package/dist/cjs/useSearch.cjs

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

package/dist/cjs/useSearch.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSearch.cjs","sources":["../../src/useSearch.tsx"],"sourcesContent":["import { useMatch } from './useMatch'\nimport type { ThrowConstraint } from './useMatch'\nimport type { Accessor } from 'solid-js'\nimport type { FullSearchSchema, RouteById } from './routeInfo'\nimport type { AnyRouter, RegisteredRouter } from './router'\nimport type { StrictOrFrom } from './utils'\nimport type { Expand, ThrowOrOptional } from '@tanstack/router-core'\n\nexport interface UseSearchBaseOptions<\n  TRouter extends AnyRouter,\n  TFrom,\n  TStrict extends boolean,\n  TThrow extends boolean,\n  TSelected,\n> {\n  select?: (state: ResolveSearch<TRouter, TFrom, TStrict>) => TSelected\n  shouldThrow?: TThrow\n}\n\nexport type UseSearchOptions<\n  TRouter extends AnyRouter,\n  TFrom,\n  TStrict extends boolean,\n  TThrow extends boolean,\n  TSelected,\n> = StrictOrFrom<TRouter, TFrom, TStrict> &\n  UseSearchBaseOptions<TRouter, TFrom, TStrict, TThrow, TSelected>\n\nexport type UseSearchResult<\n  TRouter extends AnyRouter,\n  TFrom,\n  TStrict extends boolean,\n  TSelected,\n> = unknown extends TSelected\n  ? ResolveSearch<TRouter, TFrom, TStrict>\n  : TSelected\n\nexport type ResolveSearch<\n  TRouter extends AnyRouter,\n  TFrom,\n  TStrict extends boolean,\n> = TStrict extends false\n  ? FullSearchSchema<TRouter['routeTree']>\n  : Expand<RouteById<TRouter['routeTree'], TFrom>['types']['fullSearchSchema']>\n\nexport type UseSearchRoute<out TFrom> = <\n  TRouter extends AnyRouter = RegisteredRouter,\n  TSelected = unknown,\n>(\n  opts?: UseSearchBaseOptions<\n    TRouter,\n    TFrom,\n    /* TStrict */ true,\n    /* TThrow */ true,\n    TSelected\n  >,\n) => Accessor<UseSearchResult<TRouter, TFrom, true, TSelected>>\n\nexport function useSearch<\n  TRouter extends AnyRouter = RegisteredRouter,\n  const TFrom extends string | undefined = undefined,\n  TStrict extends boolean = true,\n  TThrow extends boolean = true,\n  TSelected = unknown,\n>(\n  opts: UseSearchOptions<\n    TRouter,\n    TFrom,\n    TStrict,\n    ThrowConstraint<TStrict, TThrow>,\n    TSelected\n  >,\n): Accessor<\n  ThrowOrOptional<UseSearchResult<TRouter, TFrom, TStrict, TSelected>, TThrow>\n> {\n  return useMatch({\n    from: opts.from!,\n    strict: opts.strict,\n    shouldThrow: opts.shouldThrow,\n    select: (match: any) => {\n      return opts.select ? opts.select(match.search) : match.search\n    },\n  }) as any\n}\n"],"names":["useSearch","opts","useMatch","from","strict","shouldThrow","select","match","search"],"mappings":";;;AA0DO,SAASA,UAOdC,MASA;AACA,SAAOC,kBAAS;AAAA,IACdC,MAAMF,KAAKE;AAAAA,IACXC,QAAQH,KAAKG;AAAAA,IACbC,aAAaJ,KAAKI;AAAAA,IAClBC,QAAQA,CAACC,UAAe;AACtB,aAAON,KAAKK,SAASL,KAAKK,OAAOC,MAAMC,MAAM,IAAID,MAAMC;AAAAA,IAAAA;AAAAA,EACzD,CACD;AACH;;"}

package/dist/cjs/useSearch.d.cts

@@ -0,0 +1,15 @@
+import { ThrowConstraint } from './useMatch.cjs';
+import { Accessor } from 'solid-js';
+import { FullSearchSchema, RouteById } from './routeInfo.cjs';
+import { AnyRouter, RegisteredRouter } from './router.cjs';
+import { StrictOrFrom } from './utils.cjs';
+import { Expand, ThrowOrOptional } from '@tanstack/router-core';
+export interface UseSearchBaseOptions<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TThrow extends boolean, TSelected> {
+    select?: (state: ResolveSearch<TRouter, TFrom, TStrict>) => TSelected;
+    shouldThrow?: TThrow;
+}
+export type UseSearchOptions<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TThrow extends boolean, TSelected> = StrictOrFrom<TRouter, TFrom, TStrict> & UseSearchBaseOptions<TRouter, TFrom, TStrict, TThrow, TSelected>;
+export type UseSearchResult<TRouter extends AnyRouter, TFrom, TStrict extends boolean, TSelected> = unknown extends TSelected ? ResolveSearch<TRouter, TFrom, TStrict> : TSelected;
+export type ResolveSearch<TRouter extends AnyRouter, TFrom, TStrict extends boolean> = TStrict extends false ? FullSearchSchema<TRouter['routeTree']> : Expand<RouteById<TRouter['routeTree'], TFrom>['types']['fullSearchSchema']>;
+export type UseSearchRoute<out TFrom> = <TRouter extends AnyRouter = RegisteredRouter, TSelected = unknown>(opts?: UseSearchBaseOptions<TRouter, TFrom, true, true, TSelected>) => Accessor<UseSearchResult<TRouter, TFrom, true, TSelected>>;
+export declare function useSearch<TRouter extends AnyRouter = RegisteredRouter, const TFrom extends string | undefined = undefined, TStrict extends boolean = true, TThrow extends boolean = true, TSelected = unknown>(opts: UseSearchOptions<TRouter, TFrom, TStrict, ThrowConstraint<TStrict, TThrow>, TSelected>): Accessor<ThrowOrOptional<UseSearchResult<TRouter, TFrom, TStrict, TSelected>, TThrow>>;

package/dist/cjs/utils.cjs

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Solid = require("solid-js");
+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);
+const useLayoutEffect = typeof window !== "undefined" ? Solid__namespace.createRenderEffect : Solid__namespace.createEffect;
+const usePrevious = (fn) => {
+  return Solid__namespace.createMemo(
+    (prev = {
+      current: null,
+      previous: null
+    }) => {
+      const current = fn();
+      if (prev.current !== current) {
+        prev.previous = prev.current;
+        prev.current = current;
+      }
+      return prev;
+    }
+  );
+};
+function useIntersectionObserver(ref, callback, intersectionObserverOptions = {}, options = {}) {
+  const isIntersectionObserverAvailable = typeof IntersectionObserver === "function";
+  let observerRef = null;
+  Solid__namespace.createEffect(() => {
+    const r = ref();
+    if (!r || !isIntersectionObserverAvailable || options.disabled) {
+      return;
+    }
+    observerRef = new IntersectionObserver(([entry]) => {
+      callback(entry);
+    }, intersectionObserverOptions);
+    observerRef.observe(r);
+    Solid__namespace.onCleanup(() => {
+      observerRef == null ? void 0 : observerRef.disconnect();
+    });
+  });
+  return () => observerRef;
+}
+exports.useIntersectionObserver = useIntersectionObserver;
+exports.useLayoutEffect = useLayoutEffect;
+exports.usePrevious = usePrevious;
+//# sourceMappingURL=utils.cjs.map

package/dist/cjs/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.cjs","sources":["../../src/utils.ts"],"sourcesContent":["import * as Solid from 'solid-js'\nimport type { RouteIds } from './routeInfo'\nimport type { AnyRouter } from './router'\nimport type { ConstrainLiteral } from '@tanstack/router-core'\n\nexport type StrictOrFrom<\n  TRouter extends AnyRouter,\n  TFrom,\n  TStrict extends boolean = true,\n> = TStrict extends false\n  ? {\n      from?: never\n      strict: TStrict\n    }\n  : {\n      from: ConstrainLiteral<TFrom, RouteIds<TRouter['routeTree']>>\n      strict?: TStrict\n    }\n\nexport const useLayoutEffect =\n  typeof window !== 'undefined' ? Solid.createRenderEffect : Solid.createEffect\n\nexport const usePrevious = (fn: () => boolean) => {\n  return Solid.createMemo(\n    (\n      prev: { current: boolean | null; previous: boolean | null } = {\n        current: null,\n        previous: null,\n      },\n    ) => {\n      const current = fn()\n\n      if (prev.current !== current) {\n        prev.previous = prev.current\n        prev.current = current\n      }\n\n      return prev\n    },\n  )\n}\n\n/**\n * React hook to wrap `IntersectionObserver`.\n *\n * This hook will create an `IntersectionObserver` and observe the ref passed to it.\n *\n * When the intersection changes, the callback will be called with the `IntersectionObserverEntry`.\n *\n * @param ref - The ref to observe\n * @param intersectionObserverOptions - The options to pass to the IntersectionObserver\n * @param options - The options to pass to the hook\n * @param callback - The callback to call when the intersection changes\n * @returns The IntersectionObserver instance\n * @example\n * ```tsx\n * const MyComponent = () => {\n * const ref = React.useRef<HTMLDivElement>(null)\n * useIntersectionObserver(\n *  ref,\n *  (entry) => { doSomething(entry) },\n *  { rootMargin: '10px' },\n *  { disabled: false }\n * )\n * return <div ref={ref} />\n * ```\n */\nexport function useIntersectionObserver<T extends Element>(\n  ref: Solid.Accessor<T | null>,\n  callback: (entry: IntersectionObserverEntry | undefined) => void,\n  intersectionObserverOptions: IntersectionObserverInit = {},\n  options: { disabled?: boolean } = {},\n): Solid.Accessor<IntersectionObserver | null> {\n  const isIntersectionObserverAvailable =\n    typeof IntersectionObserver === 'function'\n  let observerRef: IntersectionObserver | null = null\n\n  Solid.createEffect(() => {\n    const r = ref()\n    if (!r || !isIntersectionObserverAvailable || options.disabled) {\n      return\n    }\n\n    observerRef = new IntersectionObserver(([entry]) => {\n      callback(entry)\n    }, intersectionObserverOptions)\n\n    observerRef.observe(r)\n\n    Solid.onCleanup(() => {\n      observerRef?.disconnect()\n    })\n  })\n\n  return () => observerRef\n}\n"],"names":["Solid"],"mappings":";;;;;;;;;;;;;;;;;;;;AAmBO,MAAM,kBACX,OAAO,WAAW,cAAcA,iBAAM,qBAAqBA,iBAAM;AAEtD,MAAA,cAAc,CAAC,OAAsB;AAChD,SAAOA,iBAAM;AAAA,IACX,CACE,OAA8D;AAAA,MAC5D,SAAS;AAAA,MACT,UAAU;AAAA,IAAA,MAET;AACH,YAAM,UAAU,GAAG;AAEf,UAAA,KAAK,YAAY,SAAS;AAC5B,aAAK,WAAW,KAAK;AACrB,aAAK,UAAU;AAAA,MAAA;AAGV,aAAA;AAAA,IAAA;AAAA,EAEX;AACF;AA2BgB,SAAA,wBACd,KACA,UACA,8BAAwD,CACxD,GAAA,UAAkC,IACW;AACvC,QAAA,kCACJ,OAAO,yBAAyB;AAClC,MAAI,cAA2C;AAE/CA,mBAAM,aAAa,MAAM;AACvB,UAAM,IAAI,IAAI;AACd,QAAI,CAAC,KAAK,CAAC,mCAAmC,QAAQ,UAAU;AAC9D;AAAA,IAAA;AAGF,kBAAc,IAAI,qBAAqB,CAAC,CAAC,KAAK,MAAM;AAClD,eAAS,KAAK;AAAA,OACb,2BAA2B;AAE9B,gBAAY,QAAQ,CAAC;AAErBA,qBAAM,UAAU,MAAM;AACpB,iDAAa;AAAA,IAAW,CACzB;AAAA,EAAA,CACF;AAED,SAAO,MAAM;AACf;;;;"}

package/dist/cjs/utils.d.cts

@@ -0,0 +1,44 @@
+import { RouteIds } from './routeInfo.cjs';
+import { AnyRouter } from './router.cjs';
+import { ConstrainLiteral } from '@tanstack/router-core';
+import * as Solid from 'solid-js';
+export type StrictOrFrom<TRouter extends AnyRouter, TFrom, TStrict extends boolean = true> = TStrict extends false ? {
+    from?: never;
+    strict: TStrict;
+} : {
+    from: ConstrainLiteral<TFrom, RouteIds<TRouter['routeTree']>>;
+    strict?: TStrict;
+};
+export declare const useLayoutEffect: typeof Solid.createRenderEffect;
+export declare const usePrevious: (fn: () => boolean) => Solid.Accessor<{
+    current: boolean | null;
+    previous: boolean | null;
+}>;
+/**
+ * React hook to wrap `IntersectionObserver`.
+ *
+ * This hook will create an `IntersectionObserver` and observe the ref passed to it.
+ *
+ * When the intersection changes, the callback will be called with the `IntersectionObserverEntry`.
+ *
+ * @param ref - The ref to observe
+ * @param intersectionObserverOptions - The options to pass to the IntersectionObserver
+ * @param options - The options to pass to the hook
+ * @param callback - The callback to call when the intersection changes
+ * @returns The IntersectionObserver instance
+ * @example
+ * ```tsx
+ * const MyComponent = () => {
+ * const ref = React.useRef<HTMLDivElement>(null)
+ * useIntersectionObserver(
+ *  ref,
+ *  (entry) => { doSomething(entry) },
+ *  { rootMargin: '10px' },
+ *  { disabled: false }
+ * )
+ * return <div ref={ref} />
+ * ```
+ */
+export declare function useIntersectionObserver<T extends Element>(ref: Solid.Accessor<T | null>, callback: (entry: IntersectionObserverEntry | undefined) => void, intersectionObserverOptions?: IntersectionObserverInit, options?: {
+    disabled?: boolean;
+}): Solid.Accessor<IntersectionObserver | null>;

package/dist/esm/Asset.d.ts

@@ -0,0 +1,2 @@
+import { RouterManagedTag } from '@tanstack/router-core';
+export declare function Asset({ tag, attrs, children }: RouterManagedTag): any;

package/dist/esm/Asset.js

@@ -0,0 +1,59 @@
+import { template, spread, mergeProps, insert } from "solid-js/web";
+var _tmpl$ = /* @__PURE__ */ template(`<title>`), _tmpl$2 = /* @__PURE__ */ template(`<meta>`), _tmpl$3 = /* @__PURE__ */ template(`<link>`), _tmpl$4 = /* @__PURE__ */ template(`<style>`), _tmpl$5 = /* @__PURE__ */ template(`<script>`);
+function Asset({
+  tag,
+  attrs,
+  children
+}) {
+  switch (tag) {
+    case "title":
+      return (() => {
+        var _el$ = _tmpl$();
+        spread(_el$, attrs, false, true);
+        insert(_el$, children);
+        return _el$;
+      })();
+    case "meta":
+      return (() => {
+        var _el$2 = _tmpl$2();
+        spread(_el$2, attrs, false, false);
+        return _el$2;
+      })();
+    case "link":
+      return (() => {
+        var _el$3 = _tmpl$3();
+        spread(_el$3, attrs, false, false);
+        return _el$3;
+      })();
+    case "style":
+      return (() => {
+        var _el$4 = _tmpl$4();
+        spread(_el$4, mergeProps(attrs, {
+          "innerHTML": children
+        }), false, false);
+        return _el$4;
+      })();
+    case "script":
+      if (attrs && attrs.src) {
+        return (() => {
+          var _el$5 = _tmpl$5();
+          spread(_el$5, attrs, false, false);
+          return _el$5;
+        })();
+      }
+      if (typeof children === "string") return (() => {
+        var _el$6 = _tmpl$5();
+        spread(_el$6, mergeProps(attrs, {
+          "innerHTML": children
+        }), false, false);
+        return _el$6;
+      })();
+      return null;
+    default:
+      return null;
+  }
+}
+export {
+  Asset
+};
+//# sourceMappingURL=Asset.js.map

package/dist/esm/Asset.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Asset.js","sources":["../../src/Asset.tsx"],"sourcesContent":["import type { RouterManagedTag } from '@tanstack/router-core'\n\nexport function Asset({ tag, attrs, children }: RouterManagedTag): any {\n  switch (tag) {\n    case 'title':\n      return <title {...attrs}>{children}</title>\n    case 'meta':\n      return <meta {...attrs} />\n    case 'link':\n      return <link {...attrs} />\n    case 'style':\n      return <style {...attrs} innerHTML={children} />\n    case 'script':\n      if ((attrs as any) && (attrs as any).src) {\n        return <script {...attrs} />\n      }\n      if (typeof children === 'string')\n        return <script {...attrs} innerHTML={children} />\n      return null\n    default:\n      return null\n  }\n}\n"],"names":["Asset","tag","attrs","children","_el$","_tmpl$","_$insert","_el$2","_tmpl$2","_el$3","_tmpl$3","_el$4","_tmpl$4","_$mergeProps","src","_el$5","_tmpl$5","_el$6"],"mappings":";;AAEO,SAASA,MAAM;AAAA,EAAEC;AAAAA,EAAKC;AAAAA,EAAOC;AAA2B,GAAQ;AACrE,UAAQF,KAAG;AAAA,IACT,KAAK;AACH,cAAA,MAAA;AAAA,YAAAG,OAAAC,OAAA;AAAAD,eAAAA,MAAkBF,OAAK,OAAA,IAAA;AAAAI,eAAAF,MAAGD,QAAQ;AAAAC,eAAAA;AAAAA,MAAAA,GAAA;AAAA,IACpC,KAAK;AACH,cAAA,MAAA;AAAA,YAAAG,QAAAC,QAAA;AAAAD,eAAAA,OAAiBL,OAAK,OAAA,KAAA;AAAAK,eAAAA;AAAAA,MAAAA,GAAA;AAAA,IACxB,KAAK;AACH,cAAA,MAAA;AAAA,YAAAE,QAAAC,QAAA;AAAAD,eAAAA,OAAiBP,OAAK,OAAA,KAAA;AAAAO,eAAAA;AAAAA,MAAAA,GAAA;AAAA,IACxB,KAAK;AACH,cAAA,MAAA;AAAA,YAAAE,QAAAC,QAAA;AAAAD,eAAAA,OAAAE,WAAkBX,OAAK;AAAA,UAAA,aAAaC;AAAAA,QAAAA,CAAQ,GAAA,OAAA,KAAA;AAAAQ,eAAAA;AAAAA,MAAAA,GAAA;AAAA,IAC9C,KAAK;AACET,UAAAA,SAAkBA,MAAcY,KAAK;AACxC,gBAAA,MAAA;AAAA,cAAAC,QAAAC,QAAA;AAAAD,iBAAAA,OAAmBb,OAAK,OAAA,KAAA;AAAAa,iBAAAA;AAAAA,QAAAA,GAAA;AAAA,MAAA;AAE1B,UAAI,OAAOZ,aAAa,SACtB,SAAA,MAAA;AAAA,YAAAc,QAAAD,QAAA;AAAAC,eAAAA,OAAAJ,WAAmBX,OAAK;AAAA,UAAA,aAAaC;AAAAA,QAAAA,CAAQ,GAAA,OAAA,KAAA;AAAAc,eAAAA;AAAAA,MAAAA,GAAA;AACxC,aAAA;AAAA,IACT;AACS,aAAA;AAAA,EAAA;AAEb;"}

package/dist/esm/CatchBoundary.d.ts

@@ -0,0 +1,11 @@
+import { ErrorRouteComponent } from './route.js';
+import * as Solid from 'solid-js';
+export declare function CatchBoundary(props: {
+    getResetKey: () => number | string;
+    children: Solid.JSX.Element;
+    errorComponent?: ErrorRouteComponent;
+    onCatch?: (error: Error) => void;
+} & Solid.ParentProps): Solid.JSX.Element;
+export declare function ErrorComponent({ error }: {
+    error: any;
+}): Solid.JSX.Element;