@tanstack/router-core 0.0.1-alpha.6 → 0.0.1-alpha.8

package/src/link.ts

@@ -0,0 +1,289 @@
+import { AnyPathParams } from './routeConfig'
+import {
+  AnyAllRouteInfo,
+  DefaultAllRouteInfo,
+  RouteInfoByPath,
+} from './routeInfo'
+import { Location } from './router'
+import { NoInfer, PickAsRequired, PickRequired, Updater } from './utils'
+
+export type LinkInfo =
+  | {
+      type: 'external'
+      href: string
+    }
+  | {
+      type: 'internal'
+      next: Location
+      handleFocus: (e: any) => void
+      handleClick: (e: any) => void
+      handleEnter: (e: any) => void
+      handleLeave: (e: any) => void
+      isActive: boolean
+      disabled?: boolean
+    }
+
+type StartsWith<A, B> = A extends `${B extends string ? B : never}${infer _}`
+  ? true
+  : false
+
+type CleanPath<T extends string> = T extends `${infer L}//${infer R}`
+  ? CleanPath<`${CleanPath<L>}/${CleanPath<R>}`>
+  : T extends `${infer L}//`
+  ? `${CleanPath<L>}/`
+  : T extends `//${infer L}`
+  ? `/${CleanPath<L>}`
+  : T
+
+export type Split<S, TTrailing = true> = S extends unknown
+  ? string extends S
+    ? string[]
+    : S extends string
+    ? CleanPath<S> extends ''
+      ? []
+      : TTrailing extends true
+      ? CleanPath<S> extends `${infer T}/`
+        ? [T, '/']
+        : CleanPath<S> extends `/${infer U}`
+        ? ['/', U]
+        : CleanPath<S> extends `${infer T}/${infer U}`
+        ? [T, ...Split<U>]
+        : [S]
+      : CleanPath<S> extends `${infer T}/${infer U}`
+      ? [T, ...Split<U>]
+      : [S]
+    : never
+  : never
+
+export type ParsePathParams<T extends string> = Split<T>[number] extends infer U
+  ? U extends `:${infer V}`
+    ? V
+    : never
+  : never
+
+type Join<T> = T extends []
+  ? ''
+  : T extends [infer L extends string]
+  ? L
+  : T extends [infer L extends string, ...infer Tail extends [...string[]]]
+  ? CleanPath<`${L}/${Join<Tail>}`>
+  : never
+
+export type RelativeToPathAutoComplete<
+  AllPaths extends string,
+  TFrom extends string,
+  TTo extends string,
+  SplitPaths extends string[] = Split<AllPaths, false>,
+> = TTo extends `..${infer _}`
+  ? SplitPaths extends [
+      ...Split<ResolveRelativePath<TFrom, TTo>, false>,
+      ...infer TToRest,
+    ]
+    ? `${CleanPath<
+        Join<
+          [
+            ...Split<TTo, false>,
+            ...(
+              | TToRest
+              | (Split<
+                  ResolveRelativePath<TFrom, TTo>,
+                  false
+                >['length'] extends 1
+                  ? never
+                  : ['../'])
+            ),
+          ]
+        >
+      >}`
+    : never
+  : TTo extends `./${infer RestTTo}`
+  ? SplitPaths extends [
+      ...Split<TFrom, false>,
+      ...Split<RestTTo, false>,
+      ...infer RestPath,
+    ]
+    ? `${TTo}${Join<RestPath>}`
+    : never
+  : './' | '../' | AllPaths
+
+export type NavigateOptionsAbsolute<
+  TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
+  TFrom extends ValidFromPath<TAllRouteInfo> = '/',
+  TTo extends string = '.',
+> = ToOptions<TAllRouteInfo, TFrom, TTo> & {
+  // Whether to replace the current history stack instead of pushing a new one
+  replace?: boolean
+}
+
+export type ToOptions<
+  TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
+  TFrom extends ValidFromPath<TAllRouteInfo> = '/',
+  TTo extends string = '.',
+  TResolvedTo = ResolveRelativePath<TFrom, NoInfer<TTo>>,
+> = {
+  to?: ToPathOption<TAllRouteInfo, TFrom, TTo>
+  // The new has string or a function to update it
+  hash?: Updater<string>
+  // The source route path. This is automatically set when using route-level APIs, but for type-safe relative routing on the router itself, this is required
+  from?: TFrom
+  // // When using relative route paths, this option forces resolution from the current path, instead of the route API's path or `from` path
+  // fromCurrent?: boolean
+} & CheckPath<TAllRouteInfo, NoInfer<TResolvedTo>> &
+  SearchParamOptions<TAllRouteInfo, TFrom, TResolvedTo> &
+  PathParamOptions<TAllRouteInfo, TFrom, TResolvedTo>
+
+type SearchParamOptions<
+  TAllRouteInfo extends AnyAllRouteInfo,
+  TFrom,
+  TTo,
+  TFromSchema = RouteInfoByPath<TAllRouteInfo, TFrom>['fullSearchSchema'],
+  TToSchema = RouteInfoByPath<TAllRouteInfo, TTo>['fullSearchSchema'],
+> = StartsWith<TFrom, TTo> extends true // If the next route search extend or cover the from route, params will be optional
+  ? {
+      search?: SearchReducer<TFromSchema, TToSchema>
+    }
+  : // Optional search params? Allow it
+  keyof PickRequired<TToSchema> extends never
+  ? {
+      search?: SearchReducer<TFromSchema, TToSchema>
+    }
+  : {
+      // Must have required search params, enforce it
+      search: SearchReducer<TFromSchema, TToSchema>
+    }
+
+type SearchReducer<TFrom, TTo> =
+  | { [TKey in keyof TTo]: TTo[TKey] }
+  | ((current: TFrom) => TTo)
+
+type PathParamOptions<
+  TAllRouteInfo extends AnyAllRouteInfo,
+  TFrom,
+  TTo,
+  TFromParams = RouteInfoByPath<TAllRouteInfo, TFrom>['allParams'],
+  TToParams = RouteInfoByPath<TAllRouteInfo, TTo>['allParams'],
+> =
+  // If the next routes params extend or cover the from route, params will be optional
+  StartsWith<TFrom, TTo> extends true
+    ? {
+        params?: ParamsReducer<TFromParams, TToParams>
+      }
+    : // If the next route doesn't have params, warn if any have been passed
+    AnyPathParams extends TToParams
+    ? {
+        params?: ParamsReducer<TFromParams, Record<string, never>>
+      }
+    : // If the next route has params, enforce them
+      {
+        params: ParamsReducer<TFromParams, TToParams>
+      }
+
+type ParamsReducer<TFrom, TTo> = TTo | ((current: TFrom) => TTo)
+
+export type ToPathOption<
+  TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
+  TFrom extends ValidFromPath<TAllRouteInfo> = '/',
+  TTo extends string = '.',
+> =
+  | TTo
+  | RelativeToPathAutoComplete<
+      TAllRouteInfo['routePaths'],
+      NoInfer<TFrom> extends string ? NoInfer<TFrom> : '',
+      NoInfer<TTo> & string
+    >
+
+export type ToIdOption<
+  TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
+  TFrom extends ValidFromPath<TAllRouteInfo> = '/',
+  TTo extends string = '.',
+> =
+  | TTo
+  | RelativeToPathAutoComplete<
+      TAllRouteInfo['routeIds'],
+      NoInfer<TFrom> extends string ? NoInfer<TFrom> : '',
+      NoInfer<TTo> & string
+    >
+
+interface ActiveOptions {
+  exact?: boolean
+  includeHash?: boolean
+}
+
+export type LinkOptions<
+  TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
+  TFrom extends ValidFromPath<TAllRouteInfo> = '/',
+  TTo extends string = '.',
+> = NavigateOptionsAbsolute<TAllRouteInfo, TFrom, TTo> & {
+  // The standard anchor tag target attribute
+  target?: HTMLAnchorElement['target']
+  // Defaults to `{ exact: false, includeHash: false }`
+  activeOptions?: ActiveOptions
+  // If set, will preload the linked route on hover and cache it for this many milliseconds in hopes that the user will eventually navigate there.
+  preload?: false | 'intent'
+  // When preloaded and set, will cache the preloaded result for this duration in milliseconds
+  preloadMaxAge?: number
+  // Delay intent preloading by this many milliseconds. If the intent exits before this delay, the preload will be cancelled.
+  preloadDelay?: number
+  // If true, will render the link without the href attribute
+  disabled?: boolean
+}
+
+export type CheckRelativePath<
+  TAllRouteInfo extends AnyAllRouteInfo,
+  TFrom,
+  TTo,
+> = TTo extends string
+  ? TFrom extends string
+    ? ResolveRelativePath<TFrom, TTo> extends TAllRouteInfo['routePaths']
+      ? {}
+      : {
+          Error: `${TFrom} + ${TTo} resolves to ${ResolveRelativePath<
+            TFrom,
+            TTo
+          >}, which is not a valid route path.`
+          'Valid Route Paths': TAllRouteInfo['routePaths']
+        }
+    : {}
+  : {}
+
+export type CheckPath<TAllRouteInfo extends AnyAllRouteInfo, TPath> = Exclude<
+  TPath,
+  TAllRouteInfo['routePaths']
+> extends never
+  ? {}
+  : CheckPathError<TAllRouteInfo, Exclude<TPath, TAllRouteInfo['routePaths']>>
+
+export type CheckPathError<TAllRouteInfo extends AnyAllRouteInfo, TInvalids> = {
+  Error: `${TInvalids extends string
+    ? TInvalids
+    : never} is not a valid route path.`
+  'Valid Route Paths': TAllRouteInfo['routePaths']
+}
+
+export type ResolveRelativePath<TFrom, TTo = '.'> = TFrom extends string
+  ? TTo extends string
+    ? TTo extends '.'
+      ? TFrom
+      : TTo extends `./`
+      ? Join<[TFrom, '/']>
+      : TTo extends `./${infer TRest}`
+      ? ResolveRelativePath<TFrom, TRest>
+      : TTo extends `/${infer TRest}`
+      ? TTo
+      : Split<TTo> extends ['..', ...infer ToRest]
+      ? Split<TFrom> extends [...infer FromRest, infer FromTail]
+        ? ResolveRelativePath<Join<FromRest>, Join<ToRest>>
+        : never
+      : Split<TTo> extends ['.', ...infer ToRest]
+      ? ResolveRelativePath<TFrom, Join<ToRest>>
+      : CleanPath<Join<['/', ...Split<TFrom>, ...Split<TTo>]>>
+    : never
+  : never
+
+export type ValidFromPath<
+  TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
+> =
+  | undefined
+  | (string extends TAllRouteInfo['routePaths']
+      ? string
+      : TAllRouteInfo['routePaths'])

package/src/path.ts

@@ -0,0 +1,236 @@
+import { AnyPathParams } from './routeConfig'
+import { MatchLocation } from './router'
+import { last } from './utils'
+
+export interface Segment {
+  type: 'pathname' | 'param' | 'wildcard'
+  value: string
+}
+
+export function joinPaths(paths: (string | undefined)[]) {
+  return cleanPath(paths.filter(Boolean).join('/'))
+}
+
+export function cleanPath(path: string) {
+  // remove double slashes
+  return path.replace(/\/{2,}/g, '/')
+}
+
+export function trimPathLeft(path: string) {
+  return path === '/' ? path : path.replace(/^\/{1,}/, '')
+}
+
+export function trimPathRight(path: string) {
+  return path === '/' ? path : path.replace(/\/{1,}$/, '')
+}
+
+export function trimPath(path: string) {
+  return trimPathRight(trimPathLeft(path))
+}
+
+export function resolvePath(basepath: string, base: string, to: string) {
+  base = base.replace(new RegExp(`^${basepath}`), '/')
+  to = to.replace(new RegExp(`^${basepath}`), '/')
+
+  let baseSegments = parsePathname(base)
+  const toSegments = parsePathname(to)
+
+  toSegments.forEach((toSegment, index) => {
+    if (toSegment.value === '/') {
+      if (!index) {
+        // Leading slash
+        baseSegments = [toSegment]
+      } else if (index === toSegments.length - 1) {
+        // Trailing Slash
+        baseSegments.push(toSegment)
+      } else {
+        // ignore inter-slashes
+      }
+    } else if (toSegment.value === '..') {
+      // Extra trailing slash? pop it off
+      if (baseSegments.length > 1 && last(baseSegments)?.value === '/') {
+        baseSegments.pop()
+      }
+      baseSegments.pop()
+    } else if (toSegment.value === '.') {
+      return
+    } else {
+      baseSegments.push(toSegment)
+    }
+  })
+
+  const joined = joinPaths([basepath, ...baseSegments.map((d) => d.value)])
+
+  return cleanPath(joined)
+}
+
+export function parsePathname(pathname?: string): Segment[] {
+  if (!pathname) {
+    return []
+  }
+
+  pathname = cleanPath(pathname)
+
+  const segments: Segment[] = []
+
+  if (pathname.slice(0, 1) === '/') {
+    pathname = pathname.substring(1)
+    segments.push({
+      type: 'pathname',
+      value: '/',
+    })
+  }
+
+  if (!pathname) {
+    return segments
+  }
+
+  // Remove empty segments and '.' segments
+  const split = pathname.split('/').filter(Boolean)
+
+  segments.push(
+    ...split.map((part): Segment => {
+      if (part.startsWith('*')) {
+        return {
+          type: 'wildcard',
+          value: part,
+        }
+      }
+
+      if (part.charAt(0) === ':') {
+        return {
+          type: 'param',
+          value: part,
+        }
+      }
+
+      return {
+        type: 'pathname',
+        value: part,
+      }
+    }),
+  )
+
+  if (pathname.slice(-1) === '/') {
+    pathname = pathname.substring(1)
+    segments.push({
+      type: 'pathname',
+      value: '/',
+    })
+  }
+
+  return segments
+}
+
+export function interpolatePath(
+  path: string | undefined,
+  params: any,
+  leaveWildcard?: boolean,
+) {
+  const interpolatedPathSegments = parsePathname(path)
+
+  return joinPaths(
+    interpolatedPathSegments.map((segment) => {
+      if (segment.value === '*' && !leaveWildcard) {
+        return ''
+      }
+
+      if (segment.type === 'param') {
+        return params![segment.value.substring(1)] ?? ''
+      }
+
+      return segment.value
+    }),
+  )
+}
+
+export function matchPathname(
+  currentPathname: string,
+  matchLocation: Pick<MatchLocation, 'to' | 'fuzzy' | 'caseSensitive'>,
+): AnyPathParams | undefined {
+  const pathParams = matchByPath(currentPathname, matchLocation)
+  // const searchMatched = matchBySearch(currentLocation.search, matchLocation)
+
+  if (matchLocation.to && !pathParams) {
+    return
+  }
+
+  // if (matchLocation.search && !searchMatched) {
+  //   return
+  // }
+
+  return pathParams ?? {}
+}
+
+export function matchByPath(
+  from: string,
+  matchLocation: Pick<MatchLocation, 'to' | 'caseSensitive' | 'fuzzy'>,
+): Record<string, string> | undefined {
+  const baseSegments = parsePathname(from)
+  const routeSegments = parsePathname(`${matchLocation.to ?? '*'}`)
+
+  const params: Record<string, string> = {}
+
+  let isMatch = (() => {
+    for (
+      let i = 0;
+      i < Math.max(baseSegments.length, routeSegments.length);
+      i++
+    ) {
+      const baseSegment = baseSegments[i]
+      const routeSegment = routeSegments[i]
+
+      const isLastRouteSegment = i === routeSegments.length - 1
+      const isLastBaseSegment = i === baseSegments.length - 1
+
+      if (routeSegment) {
+        if (routeSegment.type === 'wildcard') {
+          if (baseSegment?.value) {
+            params['*'] = joinPaths(baseSegments.slice(i).map((d) => d.value))
+            return true
+          }
+          return false
+        }
+
+        if (routeSegment.type === 'pathname') {
+          if (routeSegment.value === '/' && !baseSegment?.value) {
+            return true
+          }
+
+          if (baseSegment) {
+            if (matchLocation.caseSensitive) {
+              if (routeSegment.value !== baseSegment.value) {
+                return false
+              }
+            } else if (
+              routeSegment.value.toLowerCase() !==
+              baseSegment.value.toLowerCase()
+            ) {
+              return false
+            }
+          }
+        }
+
+        if (!baseSegment) {
+          return false
+        }
+
+        if (routeSegment.type === 'param') {
+          if (baseSegment?.value === '/') {
+            return false
+          }
+          if (!baseSegment.value.startsWith(':')) {
+            params[routeSegment.value.substring(1)] = baseSegment.value
+          }
+        }
+      }
+
+      if (isLastRouteSegment && !isLastBaseSegment) {
+        return !!matchLocation.fuzzy
+      }
+    }
+    return true
+  })()
+
+  return isMatch ? (params as Record<string, string>) : undefined
+}

package/src/qss.ts

@@ -1,6 +1,6 @@
 // @ts-nocheck
 
-// We're inlining qss here for compression's sake, but we've included it as a hard dependency for the MIT license it requires.
+// qss has been slightly modified and inlined here for our use cases (and compression's sake). We've included it as a hard dependency for MIT license attribution.
 
 export function encode(obj, pfx?: string) {
   var k,

package/src/route.ts

@@ -0,0 +1,181 @@
+import {
+  CheckRelativePath,
+  LinkInfo,
+  LinkOptions,
+  ResolveRelativePath,
+  ToOptions,
+} from './link'
+import { RouteConfig, RouteOptions } from './routeConfig'
+import {
+  AnyAllRouteInfo,
+  AnyRouteInfo,
+  DefaultAllRouteInfo,
+  RouteInfo,
+  RouteInfoByPath,
+} from './routeInfo'
+import { RouteMatch } from './routeMatch'
+import { Action, ActionState, MatchRouteOptions, Router } from './router'
+import { NoInfer, replaceEqualDeep } from './utils'
+
+export interface AnyRoute extends Route<any, any> {}
+
+export interface Route<
+  TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
+  TRouteInfo extends AnyRouteInfo = RouteInfo,
+> {
+  routeId: TRouteInfo['id']
+  routeRouteId: TRouteInfo['routeId']
+  routePath: TRouteInfo['path']
+  fullPath: TRouteInfo['fullPath']
+  parentRoute?: AnyRoute
+  childRoutes?: AnyRoute[]
+  options: RouteOptions
+  router: Router<TAllRouteInfo['routeConfig'], TAllRouteInfo>
+  buildLink: <TTo extends string = '.'>(
+    options: Omit<
+      LinkOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo>,
+      'from'
+    >,
+  ) => LinkInfo
+  matchRoute: <
+    TTo extends string = '.',
+    TResolved extends string = ResolveRelativePath<TRouteInfo['id'], TTo>,
+  >(
+    matchLocation: CheckRelativePath<
+      TAllRouteInfo,
+      TRouteInfo['fullPath'],
+      NoInfer<TTo>
+    > &
+      Omit<ToOptions<TAllRouteInfo, TRouteInfo['fullPath'], TTo>, 'from'>,
+    opts?: MatchRouteOptions,
+  ) => RouteInfoByPath<TAllRouteInfo, TResolved>['allParams']
+  navigate: <TTo extends string = '.'>(
+    options: Omit<LinkOptions<TAllRouteInfo, TRouteInfo['id'], TTo>, 'from'>,
+  ) => Promise<void>
+  action: unknown extends TRouteInfo['actionResponse']
+    ?
+        | Action<TRouteInfo['actionPayload'], TRouteInfo['actionResponse']>
+        | undefined
+    : Action<TRouteInfo['actionPayload'], TRouteInfo['actionResponse']>
+}
+
+export function createRoute<
+  TAllRouteInfo extends AnyAllRouteInfo = DefaultAllRouteInfo,
+  TRouteInfo extends AnyRouteInfo = RouteInfo,
+>(
+  routeConfig: RouteConfig,
+  options: TRouteInfo['options'],
+  parent: undefined | Route<TAllRouteInfo, any>,
+  router: Router<TAllRouteInfo['routeConfig'], TAllRouteInfo>,
+): Route<TAllRouteInfo, TRouteInfo> {
+  const { id, routeId, path: routePath, fullPath } = routeConfig
+
+  const action =
+    router.state.actions[id] ||
+    (() => {
+      router.state.actions[id] = {
+        pending: [],
+        submit: async <T, U>(
+          submission: T,
+          actionOpts?: { invalidate?: boolean },
+        ) => {
+          if (!route) {
+            return
+          }
+
+          const invalidate = actionOpts?.invalidate ?? true
+
+          const actionState: ActionState<T, U> = {
+            submittedAt: Date.now(),
+            status: 'pending',
+            submission,
+          }
+
+          action.current = actionState
+          action.latest = actionState
+          action.pending.push(actionState)
+
+          router.state = {
+            ...router.state,
+            currentAction: actionState,
+            latestAction: actionState,
+          }
+
+          router.notify()
+
+          try {
+            const res = await route.options.action?.(submission)
+            actionState.data = res as U
+            if (invalidate) {
+              router.invalidateRoute({ to: '.', fromCurrent: true })
+              await router.reload()
+            }
+            actionState.status = 'success'
+            return res
+          } catch (err) {
+            console.error(err)
+            actionState.error = err
+            actionState.status = 'error'
+          } finally {
+            action.pending = action.pending.filter((d) => d !== actionState)
+            router.removeActionQueue.push({ action, actionState })
+            router.notify()
+          }
+        },
+      }
+      return router.state.actions[id]!
+    })()
+
+  let route: Route<TAllRouteInfo, TRouteInfo> = {
+    routeId: id,
+    routeRouteId: routeId,
+    routePath,
+    fullPath,
+    options,
+    router,
+    childRoutes: undefined!,
+    parentRoute: parent,
+    action,
+
+    buildLink: (options) => {
+      return router.buildLink({
+        ...options,
+        from: fullPath,
+      } as any) as any
+    },
+
+    navigate: (options) => {
+      return router.navigate({
+        ...options,
+        from: fullPath,
+      } as any) as any
+    },
+
+    matchRoute: (matchLocation, opts) => {
+      return router.matchRoute(
+        {
+          ...matchLocation,
+          from: fullPath,
+        } as any,
+        opts,
+      )
+    },
+  }
+
+  router.options.createRoute?.({ router, route })
+
+  return route
+}
+
+export function cascadeLoaderData(matches: RouteMatch<any, any>[]) {
+  matches.forEach((match, index) => {
+    const parent = matches[index - 1]
+
+    if (parent) {
+      match.loaderData = replaceEqualDeep(match.loaderData, {
+        ...parent.loaderData,
+        ...match.routeLoaderData,
+      })
+    }
+  })
+}