@tanstack/solid-router 1.114.14 → 1.114.16

package/dist/source/typePrimitives.d.ts

@@ -1,68 +1,10 @@
 import type { LinkComponentProps } from './link';
 import type { UseParamsOptions } from './useParams';
 import type { UseSearchOptions } from './useSearch';
-import type { AnyRouter, Constrain, ConstrainLiteral, FromPathOption, NavigateOptions, PathParamOptions, Redirect, RegisteredRouter, RouteIds, SearchParamOptions, ToPathOption, UseParamsResult, UseSearchResult } from '@tanstack/router-core';
-export type ValidateFromPath<TRouter extends AnyRouter = RegisteredRouter, TFrom = string> = FromPathOption<TRouter, TFrom>;
-export type ValidateToPath<TRouter extends AnyRouter = RegisteredRouter, TTo extends string | undefined = undefined, TFrom extends string = string> = ToPathOption<TRouter, TFrom, TTo>;
-export type ValidateSearch<TRouter extends AnyRouter = RegisteredRouter, TTo extends string | undefined = undefined, TFrom extends string = string> = SearchParamOptions<TRouter, TFrom, TTo>;
-export type ValidateParams<TRouter extends AnyRouter = RegisteredRouter, TTo extends string | undefined = undefined, TFrom extends string = string> = PathParamOptions<TRouter, TFrom, TTo>;
-/**
- * @internal
- */
-export type InferFrom<TOptions, TDefaultFrom extends string = string> = TOptions extends {
-    from: infer TFrom extends string;
-} ? TFrom : TDefaultFrom;
-/**
- * @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<TRouter extends AnyRouter = RegisteredRouter, TOptions = unknown, TDefaultFrom extends string = string> = Constrain<TOptions, NavigateOptions<TRouter, InferFrom<TOptions, TDefaultFrom>, InferTo<TOptions>, InferMaskFrom<TOptions>, InferMaskTo<TOptions>>>;
-export type ValidateNavigateOptionsArray<TRouter extends AnyRouter = RegisteredRouter, TOptions extends ReadonlyArray<any> = ReadonlyArray<unknown>, TDefaultFrom extends string = string> = {
-    [K in keyof TOptions]: ValidateNavigateOptions<TRouter, TOptions[K], TDefaultFrom>;
-};
-export type ValidateRedirectOptions<TRouter extends AnyRouter = RegisteredRouter, TOptions = unknown, TDefaultFrom extends string = string> = Constrain<TOptions, Redirect<TRouter, InferFrom<TOptions, TDefaultFrom>, InferTo<TOptions>, InferMaskFrom<TOptions>, InferMaskTo<TOptions>>>;
-export type ValidateRedirectOptionsArray<TRouter extends AnyRouter = RegisteredRouter, TOptions extends ReadonlyArray<any> = ReadonlyArray<unknown>, TDefaultFrom extends string = string> = {
-    [K in keyof TOptions]: ValidateRedirectOptions<TRouter, TOptions[K], TDefaultFrom>;
-};
+import type { AnyRouter, Constrain, InferFrom, InferMaskFrom, InferMaskTo, InferSelected, InferShouldThrow, InferStrict, InferTo, RegisteredRouter } from '@tanstack/router-core';
 export type ValidateLinkOptions<TRouter extends AnyRouter = RegisteredRouter, TOptions = unknown, TDefaultFrom extends string = string, TComp = 'a'> = Constrain<TOptions, LinkComponentProps<TComp, TRouter, InferFrom<TOptions, TDefaultFrom>, InferTo<TOptions>, InferMaskFrom<TOptions>, InferMaskTo<TOptions>>>;
 export type ValidateLinkOptionsArray<TRouter extends AnyRouter = RegisteredRouter, TOptions extends ReadonlyArray<any> = ReadonlyArray<unknown>, TDefaultFrom extends string = string, TComp = 'a'> = {
     [K in keyof TOptions]: ValidateLinkOptions<TRouter, TOptions[K], TDefaultFrom, TComp>;
 };
-export type ValidateId<TRouter extends AnyRouter = RegisteredRouter, TId extends string = string> = 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/solid-router",
-  "version": "1.114.14",
+  "version": "1.114.16",
   "description": "Modern and scalable routing for Solid applications",
   "author": "Tanner Linsley",
   "license": "MIT",
@@ -60,8 +60,8 @@
     "jsesc": "^3.0.2",
     "tiny-invariant": "^1.3.3",
     "tiny-warning": "^1.0.3",
-    "@tanstack/history": "1.114.12",
-    "@tanstack/router-core": "1.114.12"
+    "@tanstack/router-core": "1.114.16",
+    "@tanstack/history": "1.114.12"
   },
   "devDependencies": {
     "@solidjs/testing-library": "^0.8.10",

package/src/ScrollRestoration.tsx

@@ -1,12 +1,15 @@
-import { useRouter } from './useRouter'
 import {
   defaultGetScrollRestorationKey,
   getCssSelector,
   scrollRestorationCache,
   setupScrollRestoration,
-} from './scroll-restoration'
-import type { ScrollRestorationOptions } from './scroll-restoration'
-import type { ParsedLocation } from '@tanstack/router-core'
+} from '@tanstack/router-core'
+import { useRouter } from './useRouter'
+import type {
+  ParsedLocation,
+  ScrollRestorationEntry,
+  ScrollRestorationOptions,
+} from '@tanstack/router-core'
 
 function useScrollRestoration() {
   const router = useRouter()
@@ -41,7 +44,7 @@ export function useElementScrollRestoration(
   ) & {
     getKey?: (location: ParsedLocation) => string
   },
-) {
+): ScrollRestorationEntry | undefined {
   useScrollRestoration()
 
   const router = useRouter()

package/src/index.tsx

@@ -335,7 +335,33 @@ export { CatchNotFound, DefaultGlobalNotFound } from './not-found'
 export { notFound, isNotFound } from '@tanstack/router-core'
 export type { NotFoundError } from '@tanstack/router-core'
 
-export * from './typePrimitives'
+export type {
+  ValidateLinkOptions,
+  ValidateUseSearchOptions,
+  ValidateUseParamsOptions,
+  ValidateLinkOptionsArray,
+} from './typePrimitives'
+
+export type {
+  ValidateFromPath,
+  ValidateToPath,
+  ValidateSearch,
+  ValidateParams,
+  InferFrom,
+  InferTo,
+  InferMaskTo,
+  InferMaskFrom,
+  ValidateNavigateOptions,
+  ValidateNavigateOptionsArray,
+  ValidateRedirectOptions,
+  ValidateRedirectOptionsArray,
+  ValidateId,
+  InferStrict,
+  InferShouldThrow,
+  InferSelected,
+  ValidateUseSearchResult,
+  ValidateUseParamsResult,
+} from '@tanstack/router-core'
 
 export { ScriptOnce } from './ScriptOnce'
 

package/src/router.ts

@@ -25,11 +25,11 @@ import {
   replaceEqualDeep,
   resolvePath,
   rootRouteId,
+  setupScrollRestoration,
   trimPath,
   trimPathLeft,
   trimPathRight,
 } from '@tanstack/router-core'
-import { setupScrollRestoration } from './scroll-restoration'
 import type * as Solid from 'solid-js'
 import type { HistoryLocation, RouterHistory } from '@tanstack/history'
 

package/src/scroll-restoration.tsx

@@ -1,328 +1,11 @@
-import { functionalUpdate } from '@tanstack/router-core'
+import {
+  defaultGetScrollRestorationKey,
+  restoreScroll,
+  storageKey,
+} from '@tanstack/router-core'
 import { useRouter } from './useRouter'
 import { ScriptOnce } from './ScriptOnce'
 
-import type {
-  AnyRouter,
-  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 const storageKey = 'tsr-scroll-restoration-v1_3'
-let sessionsStorage = false
-try {
-  sessionsStorage =
-    typeof window !== 'undefined' && typeof window.sessionStorage === 'object'
-} catch {}
-const throttle = (fn: (...args: Array<any>) => void, wait: number) => {
-  let timeout: any
-  return (...args: Array<any>) => {
-    if (!timeout) {
-      timeout = setTimeout(() => {
-        fn(...args)
-        timeout = null
-      }, wait)
-    }
-  }
-}
-export const scrollRestorationCache: ScrollRestorationCache = sessionsStorage
-  ? (() => {
-      const state: ScrollRestorationByKey =
-        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 =
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            functionalUpdate(updater, scrollRestorationCache.state) ||
-            scrollRestorationCache.state),
-          window.sessionStorage.setItem(
-            storageKey,
-            JSON.stringify(scrollRestorationCache.state),
-          )
-        ),
-      }
-    })()
-  : (undefined as any)
-/**
- * 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 const defaultGetScrollRestorationKey = (location: ParsedLocation) => {
-  return location.state.key! || location.href
-}
-
-export function getCssSelector(el: any): string {
-  const path = []
-  let parent
-  while ((parent = el.parentNode)) {
-    path.unshift(
-      `${el.tagName}:nth-child(${([].indexOf as any).call(parent.children, el) + 1})`,
-    )
-    el = parent
-  }
-  return `${path.join(' > ')}`.toLowerCase()
-}
-
-let ignoreScroll = false
-
-// NOTE: This function must remain pure and not use any outside variables
-// unless they are passed in as arguments. Why? Because we need to be able to
-// toString() it into a script tag to execute as early as possible in the browser
-// during SSR. Additionally, we also call it from within the router lifecycle
-export function restoreScroll(
-  storageKey: string,
-  key: string | undefined,
-  behavior: ScrollToOptions['behavior'] | undefined,
-  shouldScrollRestoration: boolean | undefined,
-  scrollToTopSelectors: Array<string> | undefined,
-) {
-  let byKey: ScrollRestorationByKey
-
-  try {
-    byKey = JSON.parse(sessionStorage.getItem(storageKey) || '{}')
-  } catch (error: any) {
-    console.error(error)
-    return
-  }
-
-  const resolvedKey = key || window.history.state?.key
-  const elementEntries = byKey[resolvedKey]
-
-  //
-  ignoreScroll = true
-
-  //
-  ;(() => {
-    // If we have a cached entry for this location state,
-    // we always need to prefer that over the hash scroll.
-    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
-    }
-
-    // If we don't have a cached entry for the hash,
-    // Which means we've never seen this location before,
-    // we need to check if there is a hash in the URL.
-    // If there is, we need to scroll it's ID into view.
-    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
-    }
-
-    // If there is no cached entry for the hash and there is no hash in the URL,
-    // we need to scroll to the top of the page for every scrollToTop element
-    ;[
-      'window',
-      ...(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
-}
-
-export function setupScrollRestoration(router: AnyRouter, force?: boolean) {
-  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'
-
-  // // Create a MutationObserver to monitor DOM changes
-  // const mutationObserver = new MutationObserver(() => {
-  //   ;ignoreScroll = true
-  //   requestAnimationFrame(() => {
-  //     ;ignoreScroll = false
-
-  //     // Attempt to restore scroll position on each dom
-  //     // mutation until the user scrolls. We do this
-  //     // because dynamic content may come in at different
-  //     // ticks after the initial render and we want to
-  //     // keep up with that content as much as possible.
-  //     // As soon as the user scrolls, we no longer need
-  //     // to attempt router.
-  //     // console.log('mutation observer restoreScroll')
-  //     restoreScroll(
-  //       storageKey,
-  //       getKey(router.state.location),
-  //       router.options.scrollRestorationBehavior,
-  //     )
-  //   })
-  // })
-
-  // const observeDom = () => {
-  //   // Observe changes to the entire document
-  //   mutationObserver.observe(document, {
-  //     childList: true, // Detect added or removed child nodes
-  //     subtree: true, // Monitor all descendants
-  //     characterData: true, // Detect text content changes
-  //   })
-  // }
-
-  // const unobserveDom = () => {
-  //   mutationObserver.disconnect()
-  // }
-
-  // observeDom()
-
-  const onScroll = (event: Event) => {
-    // unobserveDom()
-
-    if (ignoreScroll || !router.isScrollRestoring) {
-      return
-    }
-
-    let elementSelector = ''
-
-    if (event.target === document || event.target === window) {
-      elementSelector = 'window'
-    } else {
-      const attrId = (event.target as Element).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] || ({} as ScrollRestorationByElement))
-
-      const elementEntry = (keyEntry[elementSelector] =
-        keyEntry[elementSelector] || ({} as ScrollRestorationEntry))
-
-      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
-    })
-  }
-
-  // Throttle the scroll event to avoid excessive updates
-  if (typeof document !== 'undefined') {
-    document.addEventListener('scroll', throttle(onScroll, 100), true)
-  }
-
-  router.subscribe('onRendered', (event) => {
-    // unobserveDom()
-
-    const cacheKey = getKey(event.toLocation)
-
-    // If the user doesn't want to restore the scroll position,
-    // we don't need to do anything.
-    if (!router.resetNextScroll) {
-      router.resetNextScroll = true
-      return
-    }
-
-    restoreScroll(
-      storageKey,
-      cacheKey,
-      router.options.scrollRestorationBehavior || undefined,
-      router.isScrollRestoring || undefined,
-      router.options.scrollToTopSelectors || undefined,
-    )
-
-    if (router.isScrollRestoring) {
-      // Mark the location as having been seen
-      scrollRestorationCache.set((state) => {
-        state[cacheKey] = state[cacheKey] || ({} as ScrollRestorationByElement)
-
-        return state
-      })
-    }
-  })
-}
-
 export function ScrollRestoration() {
   const router = useRouter()
   const getKey =