@benjavicente/router-core 1.168.9

package/src/Matches.ts

@@ -0,0 +1,291 @@
+import type { AnyRoute, StaticDataRouteOption } from './route'
+import type {
+  AllContext,
+  AllLoaderData,
+  AllParams,
+  FullSearchSchema,
+  ParseRoute,
+  RouteById,
+  RouteIds,
+} from './routeInfo'
+import type { AnyRouter, RegisteredRouter, SSROption } from './router'
+import type { Constrain, ControlledPromise } from './utils'
+
+export type AnyMatchAndValue = { match: any; value: any }
+
+export type FindValueByIndex<
+  TKey,
+  TValue extends ReadonlyArray<any>,
+> = TKey extends `${infer TIndex extends number}` ? TValue[TIndex] : never
+
+export type FindValueByKey<TKey, TValue> =
+  TValue extends ReadonlyArray<any>
+    ? FindValueByIndex<TKey, TValue>
+    : TValue[TKey & keyof TValue]
+
+export type CreateMatchAndValue<TMatch, TValue> = TValue extends any
+  ? {
+      match: TMatch
+      value: TValue
+    }
+  : never
+
+export type NextMatchAndValue<
+  TKey,
+  TMatchAndValue extends AnyMatchAndValue,
+> = TMatchAndValue extends any
+  ? CreateMatchAndValue<
+      TMatchAndValue['match'],
+      FindValueByKey<TKey, TMatchAndValue['value']>
+    >
+  : never
+
+export type IsMatchKeyOf<TValue> =
+  TValue extends ReadonlyArray<any>
+    ? number extends TValue['length']
+      ? `${number}`
+      : keyof TValue & `${number}`
+    : TValue extends object
+      ? keyof TValue & string
+      : never
+
+export type IsMatchPath<
+  TParentPath extends string,
+  TMatchAndValue extends AnyMatchAndValue,
+> = `${TParentPath}${IsMatchKeyOf<TMatchAndValue['value']>}`
+
+export type IsMatchResult<
+  TKey,
+  TMatchAndValue extends AnyMatchAndValue,
+> = TMatchAndValue extends any
+  ? TKey extends keyof TMatchAndValue['value']
+    ? TMatchAndValue['match']
+    : never
+  : never
+
+export type IsMatchParse<
+  TPath,
+  TMatchAndValue extends AnyMatchAndValue,
+  TParentPath extends string = '',
+> = TPath extends `${string}.${string}`
+  ? TPath extends `${infer TFirst}.${infer TRest}`
+    ? IsMatchParse<
+        TRest,
+        NextMatchAndValue<TFirst, TMatchAndValue>,
+        `${TParentPath}${TFirst}.`
+      >
+    : never
+  : {
+      path: IsMatchPath<TParentPath, TMatchAndValue>
+      result: IsMatchResult<TPath, TMatchAndValue>
+    }
+
+export type IsMatch<TMatch, TPath> = IsMatchParse<
+  TPath,
+  TMatch extends any ? { match: TMatch; value: TMatch } : never
+>
+
+/**
+ * Narrows matches based on a path
+ * @experimental
+ */
+export const isMatch = <TMatch, TPath extends string>(
+  match: TMatch,
+  path: Constrain<TPath, IsMatch<TMatch, TPath>['path']>,
+): match is IsMatch<TMatch, TPath>['result'] => {
+  const parts = (path as string).split('.')
+  let part
+  let i = 0
+  let value: any = match
+
+  while ((part = parts[i++]) != null && value != null) {
+    value = value[part]
+  }
+
+  return value != null
+}
+
+export interface DefaultRouteMatchExtensions {
+  scripts?: unknown
+  links?: unknown
+  headScripts?: unknown
+  meta?: unknown
+  styles?: unknown
+}
+
+export interface RouteMatchExtensions extends DefaultRouteMatchExtensions {}
+
+export interface RouteMatch<
+  out TRouteId,
+  out TFullPath,
+  out TAllParams,
+  out TFullSearchSchema,
+  out TLoaderData,
+  out TAllContext,
+  out TLoaderDeps,
+> extends RouteMatchExtensions {
+  id: string
+  routeId: TRouteId
+  fullPath: TFullPath
+  index: number
+  pathname: string
+  params: TAllParams
+  _strictParams: TAllParams
+  status: 'pending' | 'success' | 'error' | 'redirected' | 'notFound'
+  isFetching: false | 'beforeLoad' | 'loader'
+  error: unknown
+  paramsError: unknown
+  searchError: unknown
+  updatedAt: number
+  _nonReactive: {
+    /** @internal */
+    beforeLoadPromise?: ControlledPromise<void>
+    /** @internal */
+    loaderPromise?: ControlledPromise<void>
+    /** @internal */
+    pendingTimeout?: ReturnType<typeof setTimeout>
+    loadPromise?: ControlledPromise<void>
+    displayPendingPromise?: Promise<void>
+    minPendingPromise?: ControlledPromise<void>
+    dehydrated?: boolean
+    /** @internal */
+    error?: unknown
+  }
+  loaderData?: TLoaderData
+  /** @internal */
+  __routeContext?: Record<string, unknown>
+  /** @internal */
+  __beforeLoadContext?: Record<string, unknown>
+  context: TAllContext
+  search: TFullSearchSchema
+  _strictSearch: TFullSearchSchema
+  fetchCount: number
+  abortController: AbortController
+  cause: 'preload' | 'enter' | 'stay'
+  loaderDeps: TLoaderDeps
+  preload: boolean
+  invalid: boolean
+  headers?: Record<string, string>
+  globalNotFound?: boolean
+  staticData: StaticDataRouteOption
+  /** This attribute is not reactive */
+  ssr?: SSROption
+  _forcePending?: boolean
+  _displayPending?: boolean
+}
+
+export interface PreValidationErrorHandlingRouteMatch<
+  TRouteId,
+  TFullPath,
+  TAllParams,
+  TFullSearchSchema,
+> {
+  id: string
+  routeId: TRouteId
+  fullPath: TFullPath
+  index: number
+  pathname: string
+  search:
+    | { status: 'success'; value: TFullSearchSchema }
+    | { status: 'error'; error: unknown }
+  params:
+    | { status: 'success'; value: TAllParams }
+    | { status: 'error'; error: unknown }
+  staticData: StaticDataRouteOption
+  ssr?: boolean | 'data-only'
+}
+
+export type MakePreValidationErrorHandlingRouteMatchUnion<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TRoute extends AnyRoute = ParseRoute<TRouter['routeTree']>,
+> = TRoute extends any
+  ? PreValidationErrorHandlingRouteMatch<
+      TRoute['id'],
+      TRoute['fullPath'],
+      TRoute['types']['allParams'],
+      TRoute['types']['fullSearchSchema']
+    >
+  : never
+
+export type MakeRouteMatchFromRoute<TRoute extends AnyRoute> = RouteMatch<
+  TRoute['types']['id'],
+  TRoute['types']['fullPath'],
+  TRoute['types']['allParams'],
+  TRoute['types']['fullSearchSchema'],
+  TRoute['types']['loaderData'],
+  TRoute['types']['allContext'],
+  TRoute['types']['loaderDeps']
+>
+
+export type MakeRouteMatch<
+  TRouteTree extends AnyRoute = RegisteredRouter['routeTree'],
+  TRouteId = RouteIds<TRouteTree>,
+  TStrict extends boolean = true,
+> = RouteMatch<
+  TRouteId,
+  RouteById<TRouteTree, TRouteId>['types']['fullPath'],
+  TStrict extends false
+    ? AllParams<TRouteTree>
+    : RouteById<TRouteTree, TRouteId>['types']['allParams'],
+  TStrict extends false
+    ? FullSearchSchema<TRouteTree>
+    : RouteById<TRouteTree, TRouteId>['types']['fullSearchSchema'],
+  TStrict extends false
+    ? AllLoaderData<TRouteTree>
+    : RouteById<TRouteTree, TRouteId>['types']['loaderData'],
+  TStrict extends false
+    ? AllContext<TRouteTree>
+    : RouteById<TRouteTree, TRouteId>['types']['allContext'],
+  RouteById<TRouteTree, TRouteId>['types']['loaderDeps']
+>
+
+export type AnyRouteMatch = RouteMatch<any, any, any, any, any, any, any>
+
+export type MakeRouteMatchUnion<
+  TRouter extends AnyRouter = RegisteredRouter,
+  TRoute extends AnyRoute = ParseRoute<TRouter['routeTree']>,
+> = TRoute extends any
+  ? RouteMatch<
+      TRoute['id'],
+      TRoute['fullPath'],
+      TRoute['types']['allParams'],
+      TRoute['types']['fullSearchSchema'],
+      TRoute['types']['loaderData'],
+      TRoute['types']['allContext'],
+      TRoute['types']['loaderDeps']
+    >
+  : never
+
+/**
+ * The `MatchRouteOptions` type is used to describe the options that can be used when matching a route.
+ *
+ * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/MatchRouteOptionsType#matchrouteoptions-type)
+ */
+export interface MatchRouteOptions {
+  /**
+   * If `true`, will match against pending location instead of the current location.
+   *
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/MatchRouteOptionsType#pending-property)
+   */
+  pending?: boolean
+  /**
+   * If `true`, will match against the current location with case sensitivity.
+   *
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/MatchRouteOptionsType#casesensitive-property)
+   *
+   * @deprecated Declare case sensitivity in the route definition instead, or globally for all routes using the `caseSensitive` option on the router.
+   */
+  caseSensitive?: boolean
+  /**
+   * If `true`, will match against the current location's search params using a deep inclusive check. e.g. `{ a: 1 }` will match for a current location of `{ a: 1, b: 2 }`.
+   *
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/MatchRouteOptionsType#includesearch-property)
+   */
+  includeSearch?: boolean
+  /**
+   * If `true`, will match against the current location using a fuzzy match. e.g. `/posts` will match for a current location of `/posts/123`.
+   *
+   * @link [API Docs](https://tanstack.com/router/latest/docs/framework/react/api/router/MatchRouteOptionsType#fuzzy-property)
+   */
+  fuzzy?: boolean
+}

package/src/RouterProvider.ts

@@ -0,0 +1,47 @@
+import type { NavigateOptions, ToOptions } from './link'
+import type { ParsedLocation } from './location'
+import type { RoutePaths } from './routeInfo'
+import type { RegisteredRouter, ViewTransitionOptions } from './router'
+
+export interface MatchLocation {
+  to?: string | number | null
+  fuzzy?: boolean
+  caseSensitive?: boolean
+  from?: string
+}
+
+export interface CommitLocationOptions {
+  replace?: boolean
+  resetScroll?: boolean
+  hashScrollIntoView?: boolean | ScrollIntoViewOptions
+  viewTransition?: boolean | ViewTransitionOptions
+  /**
+   * @deprecated All navigations use transitions under the hood now
+   **/
+  startTransition?: boolean
+  ignoreBlocker?: boolean
+}
+
+export type NavigateFn = <
+  TRouter extends RegisteredRouter,
+  TTo extends string | undefined,
+  TFrom extends RoutePaths<TRouter['routeTree']> | string = string,
+  TMaskFrom extends RoutePaths<TRouter['routeTree']> | string = TFrom,
+  TMaskTo extends string = '',
+>(
+  opts: NavigateOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo>,
+) => Promise<void>
+
+export type BuildLocationFn = <
+  TRouter extends RegisteredRouter,
+  TTo extends string | undefined,
+  TFrom extends RoutePaths<TRouter['routeTree']> | string = string,
+  TMaskFrom extends RoutePaths<TRouter['routeTree']> | string = TFrom,
+  TMaskTo extends string = '',
+>(
+  opts: ToOptions<TRouter, TFrom, TTo, TMaskFrom, TMaskTo> & {
+    leaveParams?: boolean
+    _includeValidateSearch?: boolean
+    _isNavigate?: boolean
+  },
+) => ParsedLocation

package/src/config.ts

@@ -0,0 +1,42 @@
+import type { SSROption } from './router'
+import type { AnySerializationAdapter } from './ssr/serializer/transformer'
+
+export interface RouterConfigOptions<
+  in out TSerializationAdapters,
+  in out TDefaultSsr,
+> {
+  serializationAdapters?: TSerializationAdapters
+  defaultSsr?: TDefaultSsr
+}
+
+export interface RouterConfig<
+  in out TSerializationAdapters,
+  in out TDefaultSsr,
+> {
+  '~types': RouterConfigTypes<TSerializationAdapters, TDefaultSsr>
+  serializationAdapters: TSerializationAdapters
+  defaultSsr: TDefaultSsr | undefined
+}
+
+export interface RouterConfigTypes<
+  in out TSerializationAdapters,
+  in out TDefaultSsr,
+> {
+  serializationAdapters: TSerializationAdapters
+  defaultSsr: TDefaultSsr
+}
+
+export const createRouterConfig = <
+  const TSerializationAdapters extends ReadonlyArray<AnySerializationAdapter> =
+    [],
+  TDefaultSsr extends SSROption = SSROption,
+>(
+  options: RouterConfigOptions<TSerializationAdapters, TDefaultSsr>,
+): RouterConfig<TSerializationAdapters, TDefaultSsr> => {
+  return {
+    serializationAdapters: options.serializationAdapters,
+    defaultSsr: options.defaultSsr,
+  } as RouterConfig<TSerializationAdapters, TDefaultSsr>
+}
+
+export type AnyRouterConfig = RouterConfig<any, any>

package/src/defer.ts

@@ -0,0 +1,69 @@
+import { defaultSerializeError } from './router'
+
+/**
+ * Well-known symbol used by {@link defer} to tag a promise with
+ * its deferred state. Consumers can read `promise[TSR_DEFERRED_PROMISE]`
+ * to access `status`, `data`, or `error`.
+ */
+export const TSR_DEFERRED_PROMISE = Symbol.for('TSR_DEFERRED_PROMISE')
+
+export type DeferredPromiseState<T> =
+  | {
+      status: 'pending'
+      data?: T
+      error?: unknown
+    }
+  | {
+      status: 'success'
+      data: T
+    }
+  | {
+      status: 'error'
+      data?: T
+      error: unknown
+    }
+
+export type DeferredPromise<T> = Promise<T> & {
+  [TSR_DEFERRED_PROMISE]: DeferredPromiseState<T>
+}
+
+/**
+ * Wrap a promise with a deferred state for use with `<Await>` and `useAwaited`.
+ *
+ * The returned promise is augmented with internal state (status/data/error)
+ * so UI can read progress or suspend until it settles.
+ *
+ * @param _promise The promise to wrap.
+ * @param options Optional config. Provide `serializeError` to customize how
+ * errors are serialized for transfer.
+ * @returns The same promise with attached deferred metadata.
+ * @link https://tanstack.com/router/latest/docs/framework/react/api/router/deferFunction
+ */
+export function defer<T>(
+  _promise: Promise<T>,
+  options?: {
+    serializeError?: typeof defaultSerializeError
+  },
+) {
+  const promise = _promise as DeferredPromise<T>
+  // this is already deferred promise
+  if ((promise as any)[TSR_DEFERRED_PROMISE]) {
+    return promise
+  }
+  promise[TSR_DEFERRED_PROMISE] = { status: 'pending' }
+
+  promise
+    .then((data) => {
+      promise[TSR_DEFERRED_PROMISE].status = 'success'
+      promise[TSR_DEFERRED_PROMISE].data = data
+    })
+    .catch((error) => {
+      promise[TSR_DEFERRED_PROMISE].status = 'error'
+      ;(promise[TSR_DEFERRED_PROMISE] as any).error = {
+        data: (options?.serializeError ?? defaultSerializeError)(error),
+        __isServerError: true,
+      }
+    })
+
+  return promise
+}

package/src/fileRoute.ts

@@ -0,0 +1,164 @@
+import type { Register } from './router'
+import type {
+  AnyContext,
+  AnyPathParams,
+  AnyRoute,
+  FileBaseRouteOptions,
+  ResolveParams,
+  Route,
+  RouteConstraints,
+  UpdatableRouteOptions,
+} from './route'
+import type { AnyValidator } from './validators'
+
+export interface FileRouteTypes {
+  fileRoutesByFullPath: any
+  fullPaths: any
+  to: any
+  fileRoutesByTo: any
+  id: any
+  fileRoutesById: any
+}
+
+export type InferFileRouteTypes<TRouteTree extends AnyRoute> =
+  unknown extends TRouteTree['types']['fileRouteTypes']
+    ? never
+    : TRouteTree['types']['fileRouteTypes'] extends FileRouteTypes
+      ? TRouteTree['types']['fileRouteTypes']
+      : never
+
+export interface FileRoutesByPath {
+  // '/': {
+  //   parentRoute: typeof rootRoute
+  // }
+}
+
+export interface FileRouteOptions<
+  TRegister,
+  TFilePath extends string,
+  TParentRoute extends AnyRoute,
+  TId extends RouteConstraints['TId'],
+  TPath extends RouteConstraints['TPath'],
+  TFullPath extends RouteConstraints['TFullPath'],
+  TSearchValidator = undefined,
+  TParams = ResolveParams<TPath>,
+  TRouteContextFn = AnyContext,
+  TBeforeLoadFn = AnyContext,
+  TLoaderDeps extends Record<string, any> = {},
+  TLoaderFn = undefined,
+  TSSR = unknown,
+  TServerMiddlewares = unknown,
+  THandlers = undefined,
+>
+  extends
+    FileBaseRouteOptions<
+      TRegister,
+      TParentRoute,
+      TId,
+      TPath,
+      TSearchValidator,
+      TParams,
+      TLoaderDeps,
+      TLoaderFn,
+      AnyContext,
+      TRouteContextFn,
+      TBeforeLoadFn,
+      AnyContext,
+      TSSR,
+      TServerMiddlewares,
+      THandlers
+    >,
+    UpdatableRouteOptions<
+      TParentRoute,
+      TId,
+      TFullPath,
+      TParams,
+      TSearchValidator,
+      TLoaderFn,
+      TLoaderDeps,
+      AnyContext,
+      TRouteContextFn,
+      TBeforeLoadFn
+    > {}
+
+export type CreateFileRoute<
+  TFilePath extends string,
+  TParentRoute extends AnyRoute,
+  TId extends RouteConstraints['TId'],
+  TPath extends RouteConstraints['TPath'],
+  TFullPath extends RouteConstraints['TFullPath'],
+> = <
+  TRegister = Register,
+  TSearchValidator = undefined,
+  TParams = ResolveParams<TPath>,
+  TRouteContextFn = AnyContext,
+  TBeforeLoadFn = AnyContext,
+  TLoaderDeps extends Record<string, any> = {},
+  TLoaderFn = undefined,
+  TSSR = unknown,
+  TServerMiddlewares = unknown,
+  THandlers = undefined,
+>(
+  options?: FileRouteOptions<
+    TRegister,
+    TFilePath,
+    TParentRoute,
+    TId,
+    TPath,
+    TFullPath,
+    TSearchValidator,
+    TParams,
+    TRouteContextFn,
+    TBeforeLoadFn,
+    TLoaderDeps,
+    TLoaderFn,
+    TSSR,
+    TServerMiddlewares,
+    THandlers
+  >,
+) => Route<
+  TRegister,
+  TParentRoute,
+  TPath,
+  TFullPath,
+  TFilePath,
+  TId,
+  TSearchValidator,
+  TParams,
+  AnyContext,
+  TRouteContextFn,
+  TBeforeLoadFn,
+  TLoaderDeps,
+  TLoaderFn,
+  unknown,
+  unknown,
+  TSSR,
+  TServerMiddlewares,
+  THandlers
+>
+
+export type LazyRouteOptions = Pick<
+  UpdatableRouteOptions<
+    AnyRoute,
+    string,
+    string,
+    AnyPathParams,
+    AnyValidator,
+    {},
+    AnyContext,
+    AnyContext,
+    AnyContext,
+    AnyContext
+  >,
+  'component' | 'errorComponent' | 'pendingComponent' | 'notFoundComponent'
+>
+
+export interface LazyRoute<in out TRoute extends AnyRoute> {
+  options: {
+    id: string
+  } & LazyRouteOptions
+}
+
+export type CreateLazyFileRoute<TRoute extends AnyRoute> = (
+  opts: LazyRouteOptions,
+) => LazyRoute<TRoute>

package/src/global.ts

@@ -0,0 +1,9 @@
+import type { AnyRouter } from './router'
+
+declare global {
+  interface Window {
+    __TSR_ROUTER__?: AnyRouter
+  }
+}
+
+export {}

package/src/hash-scroll.ts

@@ -0,0 +1,21 @@
+import type { AnyRouter } from './router'
+
+/**
+ * @private
+ * Handles hash-based scrolling after navigation completes.
+ * To be used in framework-specific <Transitioner> components during the onResolved event.
+ */
+export function handleHashScroll(router: AnyRouter) {
+  if (typeof document !== 'undefined' && (document as any).querySelector) {
+    const location = router.stores.location.state
+    const hashScrollIntoViewOptions =
+      location.state.__hashScrollIntoViewOptions ?? true
+
+    if (hashScrollIntoViewOptions && location.hash !== '') {
+      const el = document.getElementById(location.hash)
+      if (el) {
+        el.scrollIntoView(hashScrollIntoViewOptions)
+      }
+    }
+  }
+}

package/src/history.ts

@@ -0,0 +1,9 @@
+import type { HistoryLocation } from '@benjavicente/history'
+
+declare module '@benjavicente/history' {
+  interface HistoryState {
+    __tempLocation?: HistoryLocation
+    __tempKey?: string
+    __hashScrollIntoViewOptions?: boolean | ScrollIntoViewOptions
+  }
+}