@tanstack/router-core 0.0.1-beta.19 → 0.0.1-beta.191

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tanstack/router-core",
   "author": "Tanner Linsley",
-  "version": "0.0.1-beta.19",
+  "version": "0.0.1-beta.191",
   "license": "MIT",
   "repository": "tanstack/router",
   "homepage": "https://tanstack.com/router",
@@ -23,7 +23,7 @@
     "url": "https://github.com/sponsors/tannerlinsley"
   },
   "module": "build/esm/index.js",
-  "main": "build/cjs/packages/router-core/src/index.js",
+  "main": "build/cjs/index.js",
   "browser": "build/umd/index.production.js",
   "types": "build/types/index.d.ts",
   "engines": {
@@ -40,10 +40,14 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.16.7",
-    "history": "^5.2.0",
-    "tiny-invariant": "^1.3.1"
+    "tiny-invariant": "^1.3.1",
+    "tiny-warning": "^1.0.3",
+    "@tanstack/store": "^0.0.1",
+    "@gisatcz/cross-package-react-context": "^0.2.0"
   },
-  "devDependencies": {
-    "babel-plugin-transform-async-to-promises": "^0.8.18"
+  "scripts": {
+    "build": "rollup --config rollup.config.js",
+    "test": "vitest",
+    "test:dev": "vitest --watch"
   }
-}
+}

package/src/defer.ts

@@ -0,0 +1,55 @@
+export type DeferredPromiseState<T> = { uid: string } & (
+  | {
+      status: 'pending'
+      data?: T
+      error?: unknown
+    }
+  | {
+      status: 'success'
+      data: T
+    }
+  | {
+      status: 'error'
+      data?: T
+      error: unknown
+    }
+)
+
+export type DeferredPromise<T> = Promise<T> & {
+  __deferredState: DeferredPromiseState<T>
+}
+
+export function defer<T>(_promise: Promise<T>) {
+  const promise = _promise as DeferredPromise<T>
+
+  if (!promise.__deferredState) {
+    promise.__deferredState = {
+      uid: Math.random().toString(36).slice(2),
+      status: 'pending',
+    }
+
+    const state = promise.__deferredState
+
+    promise
+      .then((data) => {
+        state.status = 'success' as any
+        state.data = data
+      })
+      .catch((error) => {
+        state.status = 'error' as any
+        state.error = error
+      })
+  }
+
+  return promise
+}
+
+export function isDehydratedDeferred(obj: any): boolean {
+  return (
+    typeof obj === 'object' &&
+    obj !== null &&
+    !(obj instanceof Promise) &&
+    !obj.then &&
+    '__deferredState' in obj
+  )
+}

package/src/fileRoute.ts

@@ -0,0 +1,161 @@
+import { ParsePathParams } from './link'
+import {
+  AnyRoute,
+  ResolveFullPath,
+  ResolveFullSearchSchema,
+  MergeFromFromParent,
+  RouteContext,
+  AnyContext,
+  RouteOptions,
+  InferFullSearchSchema,
+  UpdatableRouteOptions,
+  Route,
+  AnyPathParams,
+  RootRouteId,
+  TrimPathLeft,
+  RouteConstraints,
+} from './route'
+
+export interface FileRoutesByPath {
+  // '/': {
+  //   parentRoute: typeof rootRoute
+  // }
+}
+
+type Replace<
+  S extends string,
+  From extends string,
+  To extends string,
+> = S extends `${infer Start}${From}${infer Rest}`
+  ? `${Start}${To}${Replace<Rest, From, To>}`
+  : S
+
+export type TrimLeft<
+  T extends string,
+  S extends string,
+> = T extends `${S}${infer U}` ? U : T
+
+export type TrimRight<
+  T extends string,
+  S extends string,
+> = T extends `${infer U}${S}` ? U : T
+
+export type Trim<T extends string, S extends string> = TrimLeft<
+  TrimRight<T, S>,
+  S
+>
+
+export type RemoveUnderScores<T extends string> = Replace<
+  Replace<TrimRight<TrimLeft<T, '/_'>, '_'>, '_/', '/'>,
+  '/_',
+  '/'
+>
+
+export type ResolveFilePath<
+  TParentRoute extends AnyRoute,
+  TFilePath extends string,
+> = TParentRoute['id'] extends RootRouteId
+  ? TrimPathLeft<TFilePath>
+  : Replace<
+      TrimPathLeft<TFilePath>,
+      TrimPathLeft<TParentRoute['types']['customId']>,
+      ''
+    >
+
+export type FileRoutePath<
+  TParentRoute extends AnyRoute,
+  TFilePath extends string,
+> = ResolveFilePath<TParentRoute, TFilePath> extends `_${infer _}`
+  ? string
+  : ResolveFilePath<TParentRoute, TFilePath>
+
+export class FileRoute<
+  TFilePath extends keyof FileRoutesByPath,
+  TParentRoute extends AnyRoute = FileRoutesByPath[TFilePath]['parentRoute'],
+  TId extends RouteConstraints['TId'] = TFilePath,
+  TPath extends RouteConstraints['TPath'] = FileRoutePath<
+    TParentRoute,
+    TFilePath
+  >,
+  TFullPath extends RouteConstraints['TFullPath'] = ResolveFullPath<
+    TParentRoute,
+    RemoveUnderScores<TPath>
+  >,
+> {
+  constructor(public path: TFilePath) {}
+
+  createRoute = <
+    TLoader = unknown,
+    TSearchSchema extends RouteConstraints['TSearchSchema'] = {},
+    TFullSearchSchema extends RouteConstraints['TFullSearchSchema'] = ResolveFullSearchSchema<
+      TParentRoute,
+      TSearchSchema
+    >,
+    TParams extends RouteConstraints['TParams'] = ParsePathParams<TPath> extends never
+      ? AnyPathParams
+      : Record<ParsePathParams<TPath>, RouteConstraints['TPath']>,
+    TAllParams extends RouteConstraints['TAllParams'] = MergeFromFromParent<
+      TParentRoute['types']['allParams'],
+      TParams
+    >,
+    TParentContext extends RouteConstraints['TParentContext'] = TParentRoute['types']['routeContext'],
+    TAllParentContext extends RouteConstraints['TId'] = TParentRoute['types']['context'],
+    TRouteContext extends RouteConstraints['TRouteContext'] = RouteContext,
+    TContext extends RouteConstraints['TAllContext'] = MergeFromFromParent<
+      TParentRoute['types']['context'],
+      TRouteContext
+    >,
+    TRouterContext extends RouteConstraints['TRouterContext'] = AnyContext,
+    TChildren extends RouteConstraints['TChildren'] = unknown,
+    TRouteTree extends RouteConstraints['TRouteTree'] = AnyRoute,
+  >(
+    options: Omit<
+      RouteOptions<
+        TParentRoute,
+        string,
+        string,
+        TLoader,
+        InferFullSearchSchema<TParentRoute>,
+        TSearchSchema,
+        TFullSearchSchema,
+        TParams,
+        TAllParams,
+        TParentContext,
+        TAllParentContext,
+        TRouteContext,
+        TContext
+      >,
+      'getParentRoute' | 'path' | 'id'
+    > &
+      UpdatableRouteOptions<
+        TLoader,
+        TSearchSchema,
+        TFullSearchSchema,
+        TAllParams,
+        TRouteContext,
+        TContext
+      >,
+  ): Route<
+    TParentRoute,
+    TPath,
+    TFullPath,
+    TFilePath,
+    TId,
+    TLoader,
+    TSearchSchema,
+    TFullSearchSchema,
+    TParams,
+    TAllParams,
+    TParentContext,
+    TAllParentContext,
+    TRouteContext,
+    TContext,
+    TRouterContext,
+    TChildren,
+    TRouteTree
+  > => {
+    const route = new Route(options as any)
+    ;(route as any).isRoot = false
+    return route as any
+  }
+}

package/src/history.ts

@@ -0,0 +1,300 @@
+// While the public API was clearly inspired by the "history" npm package,
+// This implementation attempts to be more lightweight by
+// making assumptions about the way TanStack Router works
+
+export interface RouterHistory {
+  location: HistoryLocation
+  subscribe: (cb: () => void) => () => void
+  push: (path: string, state?: any) => void
+  replace: (path: string, state?: any) => void
+  go: (index: number) => void
+  back: () => void
+  forward: () => void
+  createHref: (href: string) => string
+  block: (blockerFn: BlockerFn) => () => void
+}
+
+export interface HistoryLocation extends ParsedPath {
+  state: HistoryState
+}
+
+export interface ParsedPath {
+  href: string
+  pathname: string
+  search: string
+  hash: string
+}
+
+export interface HistoryState {
+  key: string
+  __tempLocation?: HistoryLocation
+  __tempKey?: string
+}
+
+type BlockerFn = (retry: () => void, cancel: () => void) => void
+
+const pushStateEvent = 'pushstate'
+const popStateEvent = 'popstate'
+const beforeUnloadEvent = 'beforeunload'
+
+const beforeUnloadListener = (event: Event) => {
+  event.preventDefault()
+  // @ts-ignore
+  return (event.returnValue = '')
+}
+
+const stopBlocking = () => {
+  removeEventListener(beforeUnloadEvent, beforeUnloadListener, {
+    capture: true,
+  })
+}
+
+function createHistory(opts: {
+  getLocation: () => HistoryLocation
+  subscriber: false | ((onUpdate: () => void) => () => void)
+  pushState: (path: string, state: any) => void
+  replaceState: (path: string, state: any) => void
+  go: (n: number) => void
+  back: () => void
+  forward: () => void
+  createHref: (path: string) => string
+}): RouterHistory {
+  let location = opts.getLocation()
+  let unsub = () => {}
+  let subscribers = new Set<() => void>()
+  let blockers: BlockerFn[] = []
+  let queue: (() => void)[] = []
+
+  const tryFlush = () => {
+    if (blockers.length) {
+      blockers[0]?.(tryFlush, () => {
+        blockers = []
+        stopBlocking()
+      })
+      return
+    }
+
+    while (queue.length) {
+      queue.shift()?.()
+    }
+
+    if (!opts.subscriber) {
+      onUpdate()
+    }
+  }
+
+  const queueTask = (task: () => void) => {
+    queue.push(task)
+    tryFlush()
+  }
+
+  const onUpdate = () => {
+    location = opts.getLocation()
+    subscribers.forEach((subscriber) => subscriber())
+  }
+
+  return {
+    get location() {
+      return location
+    },
+    subscribe: (cb: () => void) => {
+      if (subscribers.size === 0) {
+        unsub =
+          typeof opts.subscriber === 'function'
+            ? opts.subscriber(onUpdate)
+            : () => {}
+      }
+      subscribers.add(cb)
+
+      return () => {
+        subscribers.delete(cb)
+        if (subscribers.size === 0) {
+          unsub()
+        }
+      }
+    },
+    push: (path: string, state: any) => {
+      assignKey(state)
+      queueTask(() => {
+        opts.pushState(path, state)
+      })
+    },
+    replace: (path: string, state: any) => {
+      assignKey(state)
+      queueTask(() => {
+        opts.replaceState(path, state)
+      })
+    },
+    go: (index) => {
+      queueTask(() => {
+        opts.go(index)
+      })
+    },
+    back: () => {
+      queueTask(() => {
+        opts.back()
+      })
+    },
+    forward: () => {
+      queueTask(() => {
+        opts.forward()
+      })
+    },
+    createHref: (str) => opts.createHref(str),
+    block: (cb) => {
+      blockers.push(cb)
+
+      if (blockers.length === 1) {
+        addEventListener(beforeUnloadEvent, beforeUnloadListener, {
+          capture: true,
+        })
+      }
+
+      return () => {
+        blockers = blockers.filter((b) => b !== cb)
+
+        if (!blockers.length) {
+          stopBlocking()
+        }
+      }
+    },
+  }
+}
+
+function assignKey(state: HistoryState) {
+  state.key = createRandomKey()
+  // if (state.__actualLocation) {
+  //   state.__actualLocation.state = {
+  //     ...state.__actualLocation.state,
+  //     key,
+  //   }
+  // }
+}
+
+export function createBrowserHistory(opts?: {
+  getHref?: () => string
+  createHref?: (path: string) => string
+}): RouterHistory {
+  const getHref =
+    opts?.getHref ??
+    (() =>
+      `${window.location.pathname}${window.location.search}${window.location.hash}`)
+
+  const createHref = opts?.createHref ?? ((path) => path)
+
+  const getLocation = () => parseLocation(getHref(), window.history.state)
+
+  return createHistory({
+    getLocation,
+    subscriber: (onUpdate) => {
+      window.addEventListener(pushStateEvent, onUpdate)
+      window.addEventListener(popStateEvent, onUpdate)
+
+      var pushState = window.history.pushState
+      window.history.pushState = function () {
+        let res = pushState.apply(history, arguments as any)
+        onUpdate()
+        return res
+      }
+      var replaceState = window.history.replaceState
+      window.history.replaceState = function () {
+        let res = replaceState.apply(history, arguments as any)
+        onUpdate()
+        return res
+      }
+
+      return () => {
+        window.history.pushState = pushState
+        window.history.replaceState = replaceState
+        window.removeEventListener(pushStateEvent, onUpdate)
+        window.removeEventListener(popStateEvent, onUpdate)
+      }
+    },
+    pushState: (path, state) => {
+      window.history.pushState(state, '', createHref(path))
+    },
+    replaceState: (path, state) => {
+      window.history.replaceState(state, '', createHref(path))
+    },
+    back: () => window.history.back(),
+    forward: () => window.history.forward(),
+    go: (n) => window.history.go(n),
+    createHref: (path) => createHref(path),
+  })
+}
+
+export function createHashHistory(): RouterHistory {
+  return createBrowserHistory({
+    getHref: () => window.location.hash.substring(1),
+    createHref: (path) => `#${path}`,
+  })
+}
+
+export function createMemoryHistory(
+  opts: {
+    initialEntries: string[]
+    initialIndex?: number
+  } = {
+    initialEntries: ['/'],
+  },
+): RouterHistory {
+  const entries = opts.initialEntries
+  let index = opts.initialIndex ?? entries.length - 1
+  let currentState = {
+    key: createRandomKey(),
+  } as HistoryState
+
+  const getLocation = () => parseLocation(entries[index]!, currentState)
+
+  return createHistory({
+    getLocation,
+    subscriber: false,
+    pushState: (path, state) => {
+      currentState = state
+      entries.push(path)
+      index++
+    },
+    replaceState: (path, state) => {
+      currentState = state
+      entries[index] = path
+    },
+    back: () => {
+      index--
+    },
+    forward: () => {
+      index = Math.min(index + 1, entries.length - 1)
+    },
+    go: (n) => window.history.go(n),
+    createHref: (path) => path,
+  })
+}
+
+function parseLocation(href: string, state: HistoryState): HistoryLocation {
+  let hashIndex = href.indexOf('#')
+  let searchIndex = href.indexOf('?')
+
+  return {
+    href,
+    pathname: href.substring(
+      0,
+      hashIndex > 0
+        ? searchIndex > 0
+          ? Math.min(hashIndex, searchIndex)
+          : hashIndex
+        : searchIndex > 0
+        ? searchIndex
+        : href.length,
+    ),
+    hash: hashIndex > -1 ? href.substring(hashIndex) : '',
+    search:
+      searchIndex > -1
+        ? href.slice(searchIndex, hashIndex === -1 ? undefined : hashIndex)
+        : '',
+    state: state || {},
+  }
+}
+
+// Thanks co-pilot!
+function createRandomKey() {
+  return (Math.random() + 1).toString(36).substring(7)
+}

package/src/index.ts

@@ -1,19 +1,14 @@
-export {
-  createHashHistory,
-  createBrowserHistory,
-  createMemoryHistory,
-} from 'history'
-
 export { default as invariant } from 'tiny-invariant'
-
-export * from './frameworks'
+export { default as warning } from 'tiny-warning'
+export * from './history'
 export * from './link'
 export * from './path'
 export * from './qss'
 export * from './route'
-export * from './routeConfig'
+export * from './fileRoute'
 export * from './routeInfo'
-export * from './routeMatch'
 export * from './router'
 export * from './searchParams'
 export * from './utils'
+export * from './scroll-restoration'
+export * from './defer'