@tanstack/router-core 0.0.1-beta.8 → 1.20.3-alpha.1

package/package.json

@@ -1,48 +1,52 @@
 {
   "name": "@tanstack/router-core",
+  "version": "1.20.3-alpha.1",
+  "description": "Modern and scalable routing for React applications",
   "author": "Tanner Linsley",
-  "version": "0.0.1-beta.8",
   "license": "MIT",
-  "repository": "tanstack/router",
-  "homepage": "https://tanstack.com/router",
-  "description": "",
-  "publishConfig": {
-    "registry": "https://registry.npmjs.org/"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/TanStack/router.git",
+    "directory": "packages/router-core"
   },
-  "keywords": [
-    "react",
-    "location",
-    "router",
-    "routing",
-    "async",
-    "async router",
-    "typescript"
-  ],
+  "homepage": "https://tanstack.com/router",
   "funding": {
     "type": "github",
     "url": "https://github.com/sponsors/tannerlinsley"
   },
-  "module": "build/esm/index.js",
-  "main": "build/cjs/packages/router-core/src/index.js",
-  "browser": "build/umd/index.production.js",
-  "types": "build/types/index.d.ts",
-  "engines": {
-    "node": ">=12"
+  "keywords": [
+    "history",
+    "typescript"
+  ],
+  "type": "module",
+  "types": "dist/esm/index.d.ts",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.js",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.cts",
+        "default": "./dist/cjs/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
   },
+  "sideEffects": false,
   "files": [
-    "build/**",
+    "dist",
     "src"
   ],
-  "peerDependencies": {
-    "react": ">=16",
-    "react-dom": ">=16"
+  "engines": {
+    "node": ">=12"
   },
   "dependencies": {
-    "@babel/runtime": "^7.16.7",
-    "history": "^5.2.0",
-    "tiny-invariant": "^1.3.1"
+    "@tanstack/store": "^0.7.0",
+    "tiny-invariant": "^1.3.3",
+    "@tanstack/history": "1.20.3-alpha.1"
   },
-  "devDependencies": {
-    "babel-plugin-transform-async-to-promises": "^0.8.18"
-  }
-}
+  "scripts": {}
+}

package/src/Matches.ts

@@ -0,0 +1,239 @@
+import type { AnyRoute, StaticDataRouteOption } from './route'
+import type {
+  AllContext,
+  AllLoaderData,
+  AllParams,
+  FullSearchSchema,
+  ParseRoute,
+  RouteById,
+  RouteIds,
+} from './routeInfo'
+import type { AnyRouter, RegisteredRouter } 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 value: any = match
+
+  while ((part = parts.shift()) != null && value != null) {
+    value = value[part]
+  }
+
+  return value != null
+}
+
+export interface DefaultRouteMatchExtensions {
+  scripts?: unknown
+  links?: unknown
+  headScripts?: unknown
+  meta?: 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
+  loadPromise?: ControlledPromise<void>
+  beforeLoadPromise?: ControlledPromise<void>
+  loaderPromise?: ControlledPromise<void>
+  loaderData?: TLoaderData
+  __routeContext: Record<string, unknown>
+  __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
+  minPendingPromise?: ControlledPromise<void>
+  pendingTimeout?: ReturnType<typeof setTimeout>
+}
+
+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)
+   */
+  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,50 @@
+import type { NavigateOptions, ToOptions } from './link'
+import type { ParsedLocation } from './location'
+import type { RoutePaths } from './routeInfo'
+import type {
+  AnyRouter,
+  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 React 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> | void
+
+export type BuildLocationFn = <
+  TRouter extends AnyRouter,
+  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
+  },
+) => ParsedLocation

package/src/defer.ts

@@ -0,0 +1,52 @@
+import { defaultSerializeError } from './router'
+
+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>
+}
+
+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,140 @@
+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<
+  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,
+> extends FileBaseRouteOptions<
+      TParentRoute,
+      TId,
+      TPath,
+      TSearchValidator,
+      TParams,
+      TLoaderDeps,
+      TLoaderFn,
+      AnyContext,
+      TRouteContextFn,
+      TBeforeLoadFn
+    >,
+    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'],
+> = <
+  TSearchValidator = undefined,
+  TParams = ResolveParams<TPath>,
+  TRouteContextFn = AnyContext,
+  TBeforeLoadFn = AnyContext,
+  TLoaderDeps extends Record<string, any> = {},
+  TLoaderFn = undefined,
+>(
+  options?: FileRouteOptions<
+    TFilePath,
+    TParentRoute,
+    TId,
+    TPath,
+    TFullPath,
+    TSearchValidator,
+    TParams,
+    TRouteContextFn,
+    TBeforeLoadFn,
+    TLoaderDeps,
+    TLoaderFn
+  >,
+) => Route<
+  TParentRoute,
+  TPath,
+  TFullPath,
+  TFilePath,
+  TId,
+  TSearchValidator,
+  TParams,
+  AnyContext,
+  TRouteContextFn,
+  TBeforeLoadFn,
+  TLoaderDeps,
+  TLoaderFn,
+  unknown,
+  unknown
+>
+
+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/history.ts

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