@tanstack/router-core 1.136.4 → 1.136.5

package/dist/cjs/router.d.cts

@@ -1,6 +1,6 @@
 import { Store } from '@tanstack/store';
 import { loadRouteChunk } from './load-matches.cjs';
-import { ParsePathnameCache } from './path.cjs';
+import { ProcessedTree } from './new-process-route-tree.cjs';
 import { SearchParser, SearchSerializer } from './searchParams.cjs';
 import { AnyRedirect, ResolvedRedirect } from './redirect.cjs';
 import { HistoryLocation, HistoryState, ParsedHistoryState, RouterHistory } from '@tanstack/history';
@@ -458,7 +458,7 @@ export type InvalidateFn<TRouter extends AnyRouter> = (opts?: {
     forcePending?: boolean;
 }) => Promise<void>;
 export type ParseLocationFn<TRouteTree extends AnyRoute> = (locationToParse: HistoryLocation, previousLocation?: ParsedLocation<FullSearchSchema<TRouteTree>>) => ParsedLocation<FullSearchSchema<TRouteTree>>;
-export type GetMatchRoutesFn = (pathname: string, routePathname: string | undefined) => {
+export type GetMatchRoutesFn = (pathname: string) => {
     matchedRoutes: Array<AnyRoute>;
     routeParams: Record<string, string>;
     foundRoute: AnyRoute | undefined;
@@ -567,7 +567,7 @@ export declare class RouterCore<in out TRouteTree extends AnyRoute, in out TTrai
     routeTree: TRouteTree;
     routesById: RoutesById<TRouteTree>;
     routesByPath: RoutesByPath<TRouteTree>;
-    flatRoutes: Array<AnyRoute>;
+    processedTree: ProcessedTree<TRouteTree, any, any>;
     isServer: boolean;
     pathParamsDecodeCharMap?: Map<string, string>;
     /**
@@ -594,13 +594,12 @@ export declare class RouterCore<in out TRouteTree extends AnyRoute, in out TTrai
      * current router options, rewrite rules and search parser/stringifier.
      */
     parseLocation: ParseLocationFn<TRouteTree>;
+    resolvePathCache: import('./lru-cache.cjs').LRUCache<string, string>;
     /** Resolve a path against the router basepath and trailing-slash policy. */
     resolvePathWithBase: (from: string, path: string) => string;
     get looseRoutesById(): Record<string, AnyRoute>;
     matchRoutes: MatchRoutesFn;
     private matchRoutesInternal;
-    /** a cache for `parsePathname` */
-    private parsePathnameCache;
     getMatchedRoutes: GetMatchRoutesFn;
     cancelMatch: (id: string) => void;
     cancelMatches: () => void;
@@ -664,14 +663,10 @@ export declare function getInitialRouterState(location: ParsedLocation): RouterS
  * Build the matched route chain and extract params for a pathname.
  * Falls back to the root route if no specific route is found.
  */
-export declare function getMatchedRoutes<TRouteLike extends RouteLike>({ pathname, routePathname, caseSensitive, routesByPath, routesById, flatRoutes, parseCache, }: {
+export declare function getMatchedRoutes<TRouteLike extends RouteLike>({ pathname, routesById, processedTree, }: {
     pathname: string;
-    routePathname?: string;
-    caseSensitive?: boolean;
-    routesByPath: Record<string, TRouteLike>;
     routesById: Record<string, TRouteLike>;
-    flatRoutes: Array<TRouteLike>;
-    parseCache?: ParsePathnameCache;
+    processedTree: ProcessedTree<any, any, any>;
 }): {
     matchedRoutes: TRouteLike[];
     routeParams: Record<string, string>;

package/dist/esm/Matches.d.ts

@@ -120,6 +120,8 @@ export interface MatchRouteOptions {
      * 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;
     /**

package/dist/esm/Matches.js.map

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

package/dist/esm/index.d.ts

@@ -10,15 +10,12 @@ export type { ParsedLocation } from './location.js';
 export type { Manifest, RouterManagedTag } from './manifest.js';
 export { isMatch } from './Matches.js';
 export type { AnyMatchAndValue, FindValueByIndex, FindValueByKey, CreateMatchAndValue, NextMatchAndValue, IsMatchKeyOf, IsMatchPath, IsMatchResult, IsMatchParse, IsMatch, RouteMatch, RouteMatchExtensions, MakeRouteMatchUnion, MakeRouteMatch, AnyRouteMatch, MakeRouteMatchFromRoute, MatchRouteOptions, } from './Matches.js';
-export { joinPaths, cleanPath, trimPathLeft, trimPathRight, trimPath, removeTrailingSlash, exactPathTest, resolvePath, parsePathname, interpolatePath, matchPathname, matchByPath, } from './path.js';
-export type { Segment } from './path.js';
+export { joinPaths, cleanPath, trimPathLeft, trimPathRight, trimPath, removeTrailingSlash, exactPathTest, resolvePath, interpolatePath, } from './path.js';
 export { encode, decode } from './qss.js';
 export { rootRouteId } from './root.js';
 export type { RootRouteId } from './root.js';
 export { BaseRoute, BaseRouteApi, BaseRootRoute } from './route.js';
 export type { AnyPathParams, SearchSchemaInput, AnyContext, RouteContext, PreloadableObj, RoutePathOptions, StaticDataRouteOption, RoutePathOptionsIntersection, SearchFilter, SearchMiddlewareContext, SearchMiddleware, ResolveId, InferFullSearchSchema, InferFullSearchSchemaInput, InferAllParams, InferAllContext, MetaDescriptor, RouteLinkEntry, SearchValidator, AnySearchValidator, DefaultSearchValidator, ErrorRouteProps, ErrorComponentProps, NotFoundRouteProps, ResolveParams, ParseParamsFn, StringifyParamsFn, ParamsOptions, UpdatableStaticRouteOption, ContextReturnType, ContextAsyncReturnType, ResolveRouteContext, ResolveLoaderData, RoutePrefix, TrimPath, TrimPathLeft, TrimPathRight, ResolveSearchSchemaFnInput, ResolveSearchSchemaInput, ResolveSearchSchemaFn, ResolveSearchSchema, ResolveFullSearchSchema, ResolveFullSearchSchemaInput, ResolveAllContext, BeforeLoadContextParameter, RouteContextParameter, ResolveAllParamsFromParent, AnyRoute, Route, RouteTypes, FullSearchSchemaOption, RemountDepsOptions, MakeRemountDepsOptionsUnion, ResolveFullPath, AnyRouteWithContext, RouteOptions, FileBaseRouteOptions, BaseRouteOptions, UpdatableRouteOptions, RouteLoaderFn, LoaderFnContext, RouteContextFn, ContextOptions, RouteContextOptions, BeforeLoadContextOptions, RootRouteOptions, RootRouteOptionsExtensions, UpdatableRouteOptionsExtensions, RouteConstraints, RouteTypesById, RouteMask, RouteExtensions, RouteLazyFn, RouteAddChildrenFn, RouteAddFileChildrenFn, RouteAddFileTypesFn, ResolveOptionalParams, ResolveRequiredParams, RootRoute, FilebaseRouteOptionsInterface, } from './route.js';
-export { processRouteTree } from './process-route-tree.js';
-export type { ProcessRouteTreeResult } from './process-route-tree.js';
 export { defaultSerializeError, getLocationChangeInfo, RouterCore, lazyFn, SearchParamError, PathParamError, getInitialRouterState, getMatchedRoutes, trailingSlashOptions, } from './router.js';
 export type { ViewTransitionOptions, TrailingSlashOption, Register, AnyRouter, AnyRouterWithContext, RegisteredRouter, RouterState, BuildNextOptions, RouterListener, RouterEvent, ListenerFn, RouterEvents, MatchRoutesOpts, RouterOptionsExtensions, DefaultRemountDepsFn, PreloadRouteFn, MatchRouteFn, RouterContextOptions, RouterOptions, RouterConstructorOptions, UpdateFn, ParseLocationFn, InvalidateFn, ControllablePromise, InjectedHtmlEntry, EmitFn, LoadFn, GetMatchFn, SubscribeFn, UpdateMatchFn, CommitLocationFn, GetMatchRoutesFn, MatchRoutesFn, StartTransitionFn, LoadRouteChunkFn, ClearCacheFn, CreateRouterFn, SSROption, } from './router.js';
 export * from './config.js';

package/dist/esm/index.js

@@ -2,11 +2,10 @@ import { TSR_DEFERRED_PROMISE, defer } from "./defer.js";
 import { preloadWarning } from "./link.js";
 import { componentTypes } from "./load-matches.js";
 import { isMatch } from "./Matches.js";
-import { cleanPath, exactPathTest, interpolatePath, joinPaths, matchByPath, matchPathname, parsePathname, removeTrailingSlash, resolvePath, trimPath, trimPathLeft, trimPathRight } from "./path.js";
+import { cleanPath, exactPathTest, interpolatePath, joinPaths, removeTrailingSlash, resolvePath, trimPath, trimPathLeft, trimPathRight } from "./path.js";
 import { decode, encode } from "./qss.js";
 import { rootRouteId } from "./root.js";
 import { BaseRootRoute, BaseRoute, BaseRouteApi } from "./route.js";
-import { processRouteTree } from "./process-route-tree.js";
 import { PathParamError, RouterCore, SearchParamError, defaultSerializeError, getInitialRouterState, getLocationChangeInfo, getMatchedRoutes, lazyFn, trailingSlashOptions } from "./router.js";
 import { createRouterConfig } from "./config.js";
 import { retainSearchParams, stripSearchParams } from "./searchMiddleware.js";
@@ -64,14 +63,10 @@ export {
   lazyFn,
   makeSerovalPlugin,
   makeSsrSerovalPlugin,
-  matchByPath,
-  matchPathname,
   notFound,
-  parsePathname,
   parseRedirect,
   parseSearchWith,
   preloadWarning,
-  processRouteTree,
   redirect,
   removeTrailingSlash,
   replaceEqualDeep,

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;"}

package/dist/esm/lru-cache.d.ts

@@ -1,5 +1,6 @@
 export type LRUCache<TKey, TValue> = {
     get: (key: TKey) => TValue | undefined;
     set: (key: TKey, value: TValue) => void;
+    clear: () => void;
 };
 export declare function createLRUCache<TKey, TValue>(max: number): LRUCache<TKey, TValue>;

package/dist/esm/lru-cache.js

@@ -53,6 +53,11 @@ function createLRUCache(max) {
         if (!oldest) oldest = entry;
         cache.set(key, entry);
       }
+    },
+    clear() {
+      cache.clear();
+      oldest = void 0;
+      newest = void 0;
     }
   };
 }

package/dist/esm/lru-cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"lru-cache.js","sources":["../../src/lru-cache.ts"],"sourcesContent":["export type LRUCache<TKey, TValue> = {\n  get: (key: TKey) => TValue | undefined\n  set: (key: TKey, value: TValue) => void\n}\n\nexport function createLRUCache<TKey, TValue>(\n  max: number,\n): LRUCache<TKey, TValue> {\n  type Node = { prev?: Node; next?: Node; key: TKey; value: TValue }\n  const cache = new Map<TKey, Node>()\n  let oldest: Node | undefined\n  let newest: Node | undefined\n\n  const touch = (entry: Node) => {\n    if (!entry.next) return\n    if (!entry.prev) {\n      entry.next.prev = undefined\n      oldest = entry.next\n      entry.next = undefined\n      if (newest) {\n        entry.prev = newest\n        newest.next = entry\n      }\n    } else {\n      entry.prev.next = entry.next\n      entry.next.prev = entry.prev\n      entry.next = undefined\n      if (newest) {\n        newest.next = entry\n        entry.prev = newest\n      }\n    }\n    newest = entry\n  }\n\n  return {\n    get(key) {\n      const entry = cache.get(key)\n      if (!entry) return undefined\n      touch(entry)\n      return entry.value\n    },\n    set(key, value) {\n      if (cache.size >= max && oldest) {\n        const toDelete = oldest\n        cache.delete(toDelete.key)\n        if (toDelete.next) {\n          oldest = toDelete.next\n          toDelete.next.prev = undefined\n        }\n        if (toDelete === newest) {\n          newest = undefined\n        }\n      }\n      const existing = cache.get(key)\n      if (existing) {\n        existing.value = value\n        touch(existing)\n      } else {\n        const entry: Node = { key, value, prev: newest }\n        if (newest) newest.next = entry\n        newest = entry\n        if (!oldest) oldest = entry\n        cache.set(key, entry)\n      }\n    },\n  }\n}\n"],"names":[],"mappings":"AAKO,SAAS,eACd,KACwB;AAExB,QAAM,4BAAY,IAAA;AAClB,MAAI;AACJ,MAAI;AAEJ,QAAM,QAAQ,CAAC,UAAgB;AAC7B,QAAI,CAAC,MAAM,KAAM;AACjB,QAAI,CAAC,MAAM,MAAM;AACf,YAAM,KAAK,OAAO;AAClB,eAAS,MAAM;AACf,YAAM,OAAO;AACb,UAAI,QAAQ;AACV,cAAM,OAAO;AACb,eAAO,OAAO;AAAA,MAChB;AAAA,IACF,OAAO;AACL,YAAM,KAAK,OAAO,MAAM;AACxB,YAAM,KAAK,OAAO,MAAM;AACxB,YAAM,OAAO;AACb,UAAI,QAAQ;AACV,eAAO,OAAO;AACd,cAAM,OAAO;AAAA,MACf;AAAA,IACF;AACA,aAAS;AAAA,EACX;AAEA,SAAO;AAAA,IACL,IAAI,KAAK;AACP,YAAM,QAAQ,MAAM,IAAI,GAAG;AAC3B,UAAI,CAAC,MAAO,QAAO;AACnB,YAAM,KAAK;AACX,aAAO,MAAM;AAAA,IACf;AAAA,IACA,IAAI,KAAK,OAAO;AACd,UAAI,MAAM,QAAQ,OAAO,QAAQ;AAC/B,cAAM,WAAW;AACjB,cAAM,OAAO,SAAS,GAAG;AACzB,YAAI,SAAS,MAAM;AACjB,mBAAS,SAAS;AAClB,mBAAS,KAAK,OAAO;AAAA,QACvB;AACA,YAAI,aAAa,QAAQ;AACvB,mBAAS;AAAA,QACX;AAAA,MACF;AACA,YAAM,WAAW,MAAM,IAAI,GAAG;AAC9B,UAAI,UAAU;AACZ,iBAAS,QAAQ;AACjB,cAAM,QAAQ;AAAA,MAChB,OAAO;AACL,cAAM,QAAc,EAAE,KAAK,OAAO,MAAM,OAAA;AACxC,YAAI,eAAe,OAAO;AAC1B,iBAAS;AACT,YAAI,CAAC,OAAQ,UAAS;AACtB,cAAM,IAAI,KAAK,KAAK;AAAA,MACtB;AAAA,IACF;AAAA,EAAA;AAEJ;"}
+{"version":3,"file":"lru-cache.js","sources":["../../src/lru-cache.ts"],"sourcesContent":["export type LRUCache<TKey, TValue> = {\n  get: (key: TKey) => TValue | undefined\n  set: (key: TKey, value: TValue) => void\n  clear: () => void\n}\n\nexport function createLRUCache<TKey, TValue>(\n  max: number,\n): LRUCache<TKey, TValue> {\n  type Node = { prev?: Node; next?: Node; key: TKey; value: TValue }\n  const cache = new Map<TKey, Node>()\n  let oldest: Node | undefined\n  let newest: Node | undefined\n\n  const touch = (entry: Node) => {\n    if (!entry.next) return\n    if (!entry.prev) {\n      entry.next.prev = undefined\n      oldest = entry.next\n      entry.next = undefined\n      if (newest) {\n        entry.prev = newest\n        newest.next = entry\n      }\n    } else {\n      entry.prev.next = entry.next\n      entry.next.prev = entry.prev\n      entry.next = undefined\n      if (newest) {\n        newest.next = entry\n        entry.prev = newest\n      }\n    }\n    newest = entry\n  }\n\n  return {\n    get(key) {\n      const entry = cache.get(key)\n      if (!entry) return undefined\n      touch(entry)\n      return entry.value\n    },\n    set(key, value) {\n      if (cache.size >= max && oldest) {\n        const toDelete = oldest\n        cache.delete(toDelete.key)\n        if (toDelete.next) {\n          oldest = toDelete.next\n          toDelete.next.prev = undefined\n        }\n        if (toDelete === newest) {\n          newest = undefined\n        }\n      }\n      const existing = cache.get(key)\n      if (existing) {\n        existing.value = value\n        touch(existing)\n      } else {\n        const entry: Node = { key, value, prev: newest }\n        if (newest) newest.next = entry\n        newest = entry\n        if (!oldest) oldest = entry\n        cache.set(key, entry)\n      }\n    },\n    clear() {\n      cache.clear()\n      oldest = undefined\n      newest = undefined\n    },\n  }\n}\n"],"names":[],"mappings":"AAMO,SAAS,eACd,KACwB;AAExB,QAAM,4BAAY,IAAA;AAClB,MAAI;AACJ,MAAI;AAEJ,QAAM,QAAQ,CAAC,UAAgB;AAC7B,QAAI,CAAC,MAAM,KAAM;AACjB,QAAI,CAAC,MAAM,MAAM;AACf,YAAM,KAAK,OAAO;AAClB,eAAS,MAAM;AACf,YAAM,OAAO;AACb,UAAI,QAAQ;AACV,cAAM,OAAO;AACb,eAAO,OAAO;AAAA,MAChB;AAAA,IACF,OAAO;AACL,YAAM,KAAK,OAAO,MAAM;AACxB,YAAM,KAAK,OAAO,MAAM;AACxB,YAAM,OAAO;AACb,UAAI,QAAQ;AACV,eAAO,OAAO;AACd,cAAM,OAAO;AAAA,MACf;AAAA,IACF;AACA,aAAS;AAAA,EACX;AAEA,SAAO;AAAA,IACL,IAAI,KAAK;AACP,YAAM,QAAQ,MAAM,IAAI,GAAG;AAC3B,UAAI,CAAC,MAAO,QAAO;AACnB,YAAM,KAAK;AACX,aAAO,MAAM;AAAA,IACf;AAAA,IACA,IAAI,KAAK,OAAO;AACd,UAAI,MAAM,QAAQ,OAAO,QAAQ;AAC/B,cAAM,WAAW;AACjB,cAAM,OAAO,SAAS,GAAG;AACzB,YAAI,SAAS,MAAM;AACjB,mBAAS,SAAS;AAClB,mBAAS,KAAK,OAAO;AAAA,QACvB;AACA,YAAI,aAAa,QAAQ;AACvB,mBAAS;AAAA,QACX;AAAA,MACF;AACA,YAAM,WAAW,MAAM,IAAI,GAAG;AAC9B,UAAI,UAAU;AACZ,iBAAS,QAAQ;AACjB,cAAM,QAAQ;AAAA,MAChB,OAAO;AACL,cAAM,QAAc,EAAE,KAAK,OAAO,MAAM,OAAA;AACxC,YAAI,eAAe,OAAO;AAC1B,iBAAS;AACT,YAAI,CAAC,OAAQ,UAAS;AACtB,cAAM,IAAI,KAAK,KAAK;AAAA,MACtB;AAAA,IACF;AAAA,IACA,QAAQ;AACN,YAAM,MAAA;AACN,eAAS;AACT,eAAS;AAAA,IACX;AAAA,EAAA;AAEJ;"}

package/dist/esm/new-process-route-tree.d.ts

@@ -0,0 +1,177 @@
+import { LRUCache } from './lru-cache.js';
+export declare const SEGMENT_TYPE_PATHNAME = 0;
+export declare const SEGMENT_TYPE_PARAM = 1;
+export declare const SEGMENT_TYPE_WILDCARD = 2;
+export declare const SEGMENT_TYPE_OPTIONAL_PARAM = 3;
+export type SegmentKind = typeof SEGMENT_TYPE_PATHNAME | typeof SEGMENT_TYPE_PARAM | typeof SEGMENT_TYPE_WILDCARD | typeof SEGMENT_TYPE_OPTIONAL_PARAM;
+type ParsedSegment = Uint16Array & {
+    /** segment type (0 = pathname, 1 = param, 2 = wildcard, 3 = optional param) */
+    0: SegmentKind;
+    /** index of the end of the prefix */
+    1: number;
+    /** index of the start of the value */
+    2: number;
+    /** index of the end of the value */
+    3: number;
+    /** index of the start of the suffix */
+    4: number;
+    /** index of the end of the segment */
+    5: number;
+};
+/**
+ * Populates the `output` array with the parsed representation of the given `segment` string.
+ *
+ * Usage:
+ * ```ts
+ * let output
+ * let cursor = 0
+ * while (cursor < path.length) {
+ *   output = parseSegment(path, cursor, output)
+ *   const end = output[5]
+ *   cursor = end + 1
+ * ```
+ *
+ * `output` is stored outside to avoid allocations during repeated calls. It doesn't need to be typed
+ * or initialized, it will be done automatically.
+ */
+export declare function parseSegment(
+/** The full path string containing the segment. */
+path: string, 
+/** The starting index of the segment within the path. */
+start: number, 
+/** A Uint16Array (length: 6) to populate with the parsed segment data. */
+output?: Uint16Array): ParsedSegment;
+type StaticSegmentNode<T extends RouteLike> = SegmentNode<T> & {
+    kind: typeof SEGMENT_TYPE_PATHNAME;
+};
+type DynamicSegmentNode<T extends RouteLike> = SegmentNode<T> & {
+    kind: typeof SEGMENT_TYPE_PARAM | typeof SEGMENT_TYPE_WILDCARD | typeof SEGMENT_TYPE_OPTIONAL_PARAM;
+    prefix?: string;
+    suffix?: string;
+    caseSensitive: boolean;
+};
+type AnySegmentNode<T extends RouteLike> = StaticSegmentNode<T> | DynamicSegmentNode<T>;
+type SegmentNode<T extends RouteLike> = {
+    kind: SegmentKind;
+    /** Static segments (highest priority) */
+    static: Map<string, StaticSegmentNode<T>> | null;
+    /** Case insensitive static segments (second highest priority) */
+    staticInsensitive: Map<string, StaticSegmentNode<T>> | null;
+    /** Dynamic segments ($param) */
+    dynamic: Array<DynamicSegmentNode<T>> | null;
+    /** Optional dynamic segments ({-$param}) */
+    optional: Array<DynamicSegmentNode<T>> | null;
+    /** Wildcard segments ($ - lowest priority) */
+    wildcard: Array<DynamicSegmentNode<T>> | null;
+    /** Terminal route (if this path can end here) */
+    route: T | null;
+    /** The full path for this segment node (will only be valid on leaf nodes) */
+    fullPath: string;
+    parent: AnySegmentNode<T> | null;
+    depth: number;
+    /** is it an index route (trailing / path), only valid for nodes with a `route` */
+    isIndex: boolean;
+    /** Same as `route`, but only present if both an "index route" and a "layout route" exist at this path */
+    notFound: T | null;
+};
+type RouteLike = {
+    path?: string;
+    children?: Array<RouteLike>;
+    parentRoute?: RouteLike;
+    isRoot?: boolean;
+    options?: {
+        caseSensitive?: boolean;
+    };
+} & ({
+    fullPath: string;
+    from?: never;
+} | {
+    fullPath?: never;
+    from: string;
+});
+export type ProcessedTree<TTree extends Extract<RouteLike, {
+    fullPath: string;
+}>, TFlat extends Extract<RouteLike, {
+    from: string;
+}>, TSingle extends Extract<RouteLike, {
+    from: string;
+}>> = {
+    /** a representation of the `routeTree` as a segment tree */
+    segmentTree: AnySegmentNode<TTree>;
+    /** a mini route tree generated from the flat `routeMasks` list */
+    masksTree: AnySegmentNode<TFlat> | null;
+    /** @deprecated keep until v2 so that `router.matchRoute` can keep not caring about the actual route tree */
+    singleCache: Map<any, AnySegmentNode<TSingle>>;
+    /** a cache of route matches from the `segmentTree` */
+    matchCache: LRUCache<string, ReturnType<typeof findMatch<TTree>>>;
+    /** a cache of route matches from the `masksTree` */
+    flatCache: LRUCache<string, ReturnType<typeof findMatch<TFlat>>> | null;
+};
+export declare function processRouteMasks<TRouteLike extends Extract<RouteLike, {
+    from: string;
+}>>(routeList: Array<TRouteLike>, processedTree: ProcessedTree<any, TRouteLike, any>): void;
+/**
+ * Take an arbitrary list of routes, create a tree from them (if it hasn't been created already), and match a path against it.
+ */
+export declare function findFlatMatch<T extends Extract<RouteLike, {
+    from: string;
+}>>(
+/** The path to match. */
+path: string, 
+/** The `processedTree` returned by the initial `processRouteTree` call. */
+processedTree: ProcessedTree<any, T, any>): {
+    route: T;
+    params: Record<string, string>;
+} | null;
+/**
+ * @deprecated keep until v2 so that `router.matchRoute` can keep not caring about the actual route tree
+ */
+export declare function findSingleMatch(from: string, caseSensitive: boolean, fuzzy: boolean, path: string, processedTree: ProcessedTree<any, any, {
+    from: string;
+}>): {
+    route: {
+        from: string;
+    };
+    params: Record<string, string>;
+} | null;
+export declare function findRouteMatch<T extends Extract<RouteLike, {
+    fullPath: string;
+}>>(
+/** The path to match against the route tree. */
+path: string, 
+/** The `processedTree` returned by the initial `processRouteTree` call. */
+processedTree: ProcessedTree<T, any, any>, 
+/** If `true`, allows fuzzy matching (partial matches), i.e. which node in the tree would have been an exact match if the `path` had been shorter? */
+fuzzy?: boolean): {
+    route: T;
+    params: Record<string, string>;
+} | null;
+/** Trim trailing slashes (except preserving root '/'). */
+export declare function trimPathRight(path: string): string;
+/**
+ * Processes a route tree into a segment trie for efficient path matching.
+ * Also builds lookup maps for routes by ID and by trimmed full path.
+ */
+export declare function processRouteTree<TRouteLike extends Extract<RouteLike, {
+    fullPath: string;
+}> & {
+    id: string;
+}>(
+/** The root of the route tree to process. */
+routeTree: TRouteLike, 
+/** Whether matching should be case sensitive by default (overridden by individual route options). */
+caseSensitive?: boolean, 
+/** Optional callback invoked for each route during processing. */
+initRoute?: (route: TRouteLike, index: number) => void): {
+    /** Should be considered a black box, needs to be provided to all matching functions in this module. */
+    processedTree: ProcessedTree<TRouteLike, any, any>;
+    /** A lookup map of routes by their unique IDs. */
+    routesById: Record<string, TRouteLike>;
+    /** A lookup map of routes by their trimmed full paths. */
+    routesByPath: Record<string, TRouteLike>;
+};
+declare function findMatch<T extends RouteLike>(path: string, segmentTree: AnySegmentNode<T>, fuzzy?: boolean): {
+    route: T;
+    params: Record<string, string>;
+} | null;
+export {};