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

package/build/types/router.d.ts

@@ -0,0 +1,260 @@
+import { Store } from '@tanstack/store';
+import { LinkInfo, LinkOptions, NavigateOptions, ToOptions, ResolveRelativePath } from './link';
+import { Route, AnySearchSchema, AnyRoute, AnyContext, AnyPathParams, RegisteredRouteComponent, RegisteredErrorRouteComponent, RegisteredPendingRouteComponent, RouteMask } from './route';
+import { RoutesById, RoutesByPath, ParseRoute, FullSearchSchema, RouteById, RoutePaths, RouteIds } from './routeInfo';
+import { NoInfer, PickAsRequired, Timeout, Updater, NonNullableUpdater } from './utils';
+import { HistoryState, RouterHistory } from './history';
+declare global {
+    interface Window {
+        __TSR_DEHYDRATED__?: HydrationCtx;
+    }
+}
+export interface Register {
+}
+export interface LocationState {
+}
+export type AnyRouter = Router<any, any>;
+export type RegisteredRouter = Register extends {
+    router: infer TRouter extends AnyRouter;
+} ? TRouter : AnyRouter;
+export interface ParsedLocation<TSearchObj extends AnySearchSchema = {}> {
+    href: string;
+    pathname: string;
+    search: TSearchObj;
+    searchStr: string;
+    state: HistoryState;
+    hash: string;
+    maskedLocation?: ParsedLocation<TSearchObj>;
+    unmaskOnReload?: boolean;
+}
+export interface FromLocation {
+    pathname: string;
+    search?: unknown;
+    hash?: string;
+}
+export type SearchSerializer = (searchObj: Record<string, any>) => string;
+export type SearchParser = (searchStr: string) => Record<string, any>;
+export type HydrationCtx = {
+    router: DehydratedRouter;
+    payload: Record<string, any>;
+};
+export interface RouteMatch<TRouteTree extends AnyRoute = AnyRoute, TRouteId extends RouteIds<TRouteTree> = ParseRoute<TRouteTree>['id']> {
+    id: string;
+    key?: string;
+    routeId: TRouteId;
+    pathname: string;
+    params: RouteById<TRouteTree, TRouteId>['types']['allParams'];
+    status: 'pending' | 'success' | 'error';
+    isFetching: boolean;
+    invalid: boolean;
+    error: unknown;
+    paramsError: unknown;
+    searchError: unknown;
+    updatedAt: number;
+    maxAge: number;
+    preloadMaxAge: number;
+    loaderData: RouteById<TRouteTree, TRouteId>['types']['loader'];
+    loadPromise?: Promise<void>;
+    __resolveLoadPromise?: () => void;
+    routeContext: RouteById<TRouteTree, TRouteId>['types']['routeContext'];
+    context: RouteById<TRouteTree, TRouteId>['types']['context'];
+    routeSearch: RouteById<TRouteTree, TRouteId>['types']['searchSchema'];
+    search: FullSearchSchema<TRouteTree> & RouteById<TRouteTree, TRouteId>['types']['fullSearchSchema'];
+    fetchedAt: number;
+    abortController: AbortController;
+}
+export type AnyRouteMatch = RouteMatch<any>;
+export type RouterContextOptions<TRouteTree extends AnyRoute> = AnyContext extends TRouteTree['types']['routerContext'] ? {
+    context?: TRouteTree['types']['routerContext'];
+} : {
+    context: TRouteTree['types']['routerContext'];
+};
+export interface RouterOptions<TRouteTree extends AnyRoute, TDehydrated extends Record<string, any>> {
+    history?: RouterHistory;
+    stringifySearch?: SearchSerializer;
+    parseSearch?: SearchParser;
+    defaultPreload?: false | 'intent';
+    defaultPreloadDelay?: number;
+    reloadOnWindowFocus?: boolean;
+    defaultComponent?: RegisteredRouteComponent<unknown, AnySearchSchema, AnyPathParams, AnyContext, AnyContext>;
+    defaultErrorComponent?: RegisteredErrorRouteComponent<AnySearchSchema, AnyPathParams, AnyContext, AnyContext>;
+    defaultPendingComponent?: RegisteredPendingRouteComponent<AnySearchSchema, AnyPathParams, AnyContext, AnyContext>;
+    defaultMaxAge?: number;
+    defaultGcMaxAge?: number;
+    defaultPreloadMaxAge?: number;
+    caseSensitive?: boolean;
+    routeTree?: TRouteTree;
+    basepath?: string;
+    createRoute?: (opts: {
+        route: AnyRoute;
+        router: AnyRouter;
+    }) => void;
+    context?: TRouteTree['types']['routerContext'];
+    dehydrate?: () => TDehydrated;
+    hydrate?: (dehydrated: TDehydrated) => void;
+    routeMasks?: RouteMask<TRouteTree>[];
+    unmaskOnReload?: boolean;
+}
+export interface RouterState<TRouteTree extends AnyRoute = AnyRoute> {
+    status: 'idle' | 'pending';
+    isFetching: boolean;
+    matchesById: Record<string, RouteMatch<TRouteTree>>;
+    matchIds: string[];
+    pendingMatchIds: string[];
+    matches: RouteMatch<TRouteTree>[];
+    pendingMatches: RouteMatch<TRouteTree>[];
+    renderedMatchIds: string[];
+    renderedMatches: RouteMatch<TRouteTree>[];
+    location: ParsedLocation<FullSearchSchema<TRouteTree>>;
+    resolvedLocation: ParsedLocation<FullSearchSchema<TRouteTree>>;
+    lastUpdated: number;
+}
+export type ListenerFn<TEvent extends RouterEvent> = (event: TEvent) => void;
+export interface BuildNextOptions {
+    to?: string | number | null;
+    params?: true | Updater<unknown>;
+    search?: true | Updater<unknown>;
+    hash?: true | Updater<string>;
+    state?: true | NonNullableUpdater<LocationState>;
+    mask?: {
+        to?: string | number | null;
+        params?: true | Updater<unknown>;
+        search?: true | Updater<unknown>;
+        hash?: true | Updater<string>;
+        state?: true | NonNullableUpdater<LocationState>;
+        unmaskOnReload?: boolean;
+    };
+    from?: string;
+}
+export interface CommitLocationOptions {
+    replace?: boolean;
+    resetScroll?: boolean;
+}
+export interface MatchLocation {
+    to?: string | number | null;
+    fuzzy?: boolean;
+    caseSensitive?: boolean;
+    from?: string;
+}
+export interface MatchRouteOptions {
+    pending?: boolean;
+    caseSensitive?: boolean;
+    includeSearch?: boolean;
+    fuzzy?: boolean;
+}
+export interface DehydratedRouterState {
+    matchIds: string[];
+    dehydratedMatches: DehydratedRouteMatch[];
+}
+export type DehydratedRouteMatch = Pick<RouteMatch, 'fetchedAt' | 'invalid' | 'maxAge' | 'preloadMaxAge' | 'id' | 'loaderData' | 'status' | 'updatedAt'>;
+export interface DehydratedRouter {
+    state: DehydratedRouterState;
+}
+export type RouterConstructorOptions<TRouteTree extends AnyRoute, TDehydrated extends Record<string, any>> = Omit<RouterOptions<TRouteTree, TDehydrated>, 'context'> & RouterContextOptions<TRouteTree>;
+export declare const componentTypes: readonly ["component", "errorComponent", "pendingComponent"];
+export type RouterEvents = {
+    onBeforeLoad: {
+        type: 'onBeforeLoad';
+        from: ParsedLocation;
+        to: ParsedLocation;
+        pathChanged: boolean;
+    };
+    onLoad: {
+        type: 'onLoad';
+        from: ParsedLocation;
+        to: ParsedLocation;
+        pathChanged: boolean;
+    };
+};
+export type RouterEvent = RouterEvents[keyof RouterEvents];
+export type RouterListener<TRouterEvent extends RouterEvent> = {
+    eventType: TRouterEvent['type'];
+    fn: ListenerFn<TRouterEvent>;
+};
+export declare class Router<TRouteTree extends AnyRoute = AnyRoute, TDehydrated extends Record<string, any> = Record<string, any>> {
+    #private;
+    types: {
+        RootRoute: TRouteTree;
+    };
+    options: PickAsRequired<RouterOptions<TRouteTree, TDehydrated>, 'stringifySearch' | 'parseSearch' | 'context'>;
+    history: RouterHistory;
+    basepath: string;
+    routeTree: TRouteTree;
+    routesById: RoutesById<TRouteTree>;
+    routesByPath: RoutesByPath<TRouteTree>;
+    flatRoutes: ParseRoute<TRouteTree>[];
+    navigateTimeout: undefined | Timeout;
+    nextAction: undefined | 'push' | 'replace';
+    navigationPromise: undefined | Promise<void>;
+    __store: Store<RouterState<TRouteTree>>;
+    state: RouterState<TRouteTree>;
+    dehydratedData?: TDehydrated;
+    resetNextScroll: boolean;
+    tempLocationKey: string;
+    constructor(options: RouterConstructorOptions<TRouteTree, TDehydrated>);
+    subscribers: Set<RouterListener<RouterEvent>>;
+    subscribe: <TType extends keyof RouterEvents>(eventType: TType, fn: ListenerFn<RouterEvents[TType]>) => () => void;
+    reset: () => void;
+    mount: () => () => void;
+    update: (opts?: RouterOptions<any, any>) => this;
+    cancelMatches: () => void;
+    cancelMatch: (id: string) => void;
+    safeLoad: (opts?: {
+        next?: ParsedLocation;
+    }) => Promise<void>;
+    latestLoadPromise: Promise<void>;
+    load: (opts?: {
+        next?: ParsedLocation;
+        throwOnError?: boolean;
+        __dehydratedMatches?: DehydratedRouteMatch[];
+    }) => Promise<void>;
+    getRoute: (id: string) => Route;
+    preloadRoute: (navigateOpts?: BuildNextOptions & {
+        maxAge?: number;
+    }) => Promise<readonly [RouteMatch<TRouteTree, ParseRoute<TRouteTree>["id"]>, RouteMatch<TRouteTree, ParseRoute<TRouteTree>["id"]>[]]>;
+    cleanMatches: () => void;
+    matchRoutes: (pathname: string, locationSearch: AnySearchSchema, opts?: {
+        throwOnError?: boolean;
+        debug?: boolean;
+    }) => RouteMatch<TRouteTree>[];
+    loadMatches: (matchIds: string[], opts?: {
+        preload?: boolean;
+        maxAge?: number;
+    }) => Promise<void>;
+    resolvePath: (from: string, path: string) => string;
+    navigate: <TFrom extends RoutePaths<TRouteTree> = "/", TTo extends string = "", TMaskFrom extends RoutePaths<TRouteTree> = TFrom, TMaskTo extends string = "">({ from, to, ...rest }: NavigateOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>) => Promise<void>;
+    matchRoute: <TRouteTree_1 extends AnyRoute = AnyRoute, TFrom extends RoutePaths<TRouteTree_1> = "/", TTo extends string = "", TResolved = ResolveRelativePath<TFrom, NoInfer<TTo>>>(location: ToOptions<TRouteTree_1, TFrom, TTo, "/", "">, opts?: MatchRouteOptions) => false | RouteById<TRouteTree_1, TResolved>["types"]["allParams"];
+    buildLink: <TFrom extends RoutePaths<TRouteTree> = "/", TTo extends string = "">(dest: LinkOptions<TRouteTree, TFrom, TTo, TFrom, "">) => LinkInfo;
+    dehydrate: () => DehydratedRouter;
+    hydrate: (__do_not_use_server_ctx?: HydrationCtx) => Promise<void>;
+    injectedHtml: (string | (() => Promise<string> | string))[];
+    injectHtml: (html: string | (() => Promise<string> | string)) => Promise<void>;
+    dehydrateData: <T>(key: any, getData: T | (() => T | Promise<T>)) => () => T | undefined;
+    hydrateData: <T = unknown>(key: any) => T | undefined;
+    buildLocation: (opts?: BuildNextOptions) => ParsedLocation;
+    getRouteMatch: (id: string) => undefined | RouteMatch<TRouteTree>;
+    setRouteMatch: (id: string, updater: (prev: RouteMatch<TRouteTree>) => RouteMatch<TRouteTree>) => void;
+    setRouteMatchData: (id: string, updater: (prev: any) => any, opts?: {
+        updatedAt?: number;
+        maxAge?: number;
+    }) => void;
+    invalidate: (opts?: {
+        matchId?: string;
+        reload?: boolean;
+        __fromFocus?: boolean;
+    }) => Promise<void>;
+}
+export type AnyRedirect = Redirect<any, any, any>;
+export type Redirect<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = TFrom, TMaskTo extends string = ''> = NavigateOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & {
+    code?: number;
+};
+export declare function redirect<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = ''>(opts: Redirect<TRouteTree, TFrom, TTo>): Redirect<TRouteTree, TFrom, TTo>;
+export declare function isRedirect(obj: any): obj is AnyRedirect;
+export declare class SearchParamError extends Error {
+}
+export declare class PathParamError extends Error {
+}
+export declare function lazyFn<T extends Record<string, (...args: any[]) => any>, TKey extends keyof T = 'default'>(fn: () => Promise<T>, key?: TKey): (...args: Parameters<T[TKey]>) => Promise<ReturnType<T[TKey]>>;
+export declare function isMatchInvalid(match: AnyRouteMatch, opts?: {
+    preload?: boolean;
+}): boolean;

package/build/types/scroll-restoration.d.ts

@@ -0,0 +1,6 @@
+import { AnyRouter, ParsedLocation } from './router';
+export type ScrollRestorationOptions = {
+    getKey?: (location: ParsedLocation) => string;
+};
+export declare function watchScrollPositions(router: AnyRouter, opts?: ScrollRestorationOptions): () => void;
+export declare function restoreScrollPositions(router: AnyRouter, opts?: ScrollRestorationOptions): void;

package/build/types/searchParams.d.ts

@@ -0,0 +1,5 @@
+import { AnySearchSchema } from './route';
+export declare const defaultParseSearch: (searchStr: string) => AnySearchSchema;
+export declare const defaultStringifySearch: (search: Record<string, any>) => string;
+export declare function parseSearchWith(parser: (str: string) => any): (searchStr: string) => AnySearchSchema;
+export declare function stringifySearchWith(stringify: (search: any) => string, parser?: (str: string) => any): (search: Record<string, any>) => string;

package/build/types/utils.d.ts

@@ -0,0 +1,44 @@
+export type NoInfer<T> = [T][T extends any ? 0 : never];
+export type IsAny<T, Y, N> = 1 extends 0 & T ? Y : N;
+export type IsAnyBoolean<T> = 1 extends 0 & T ? true : false;
+export type IsKnown<T, Y, N> = unknown extends T ? N : Y;
+export type PickAsRequired<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+export type PickAsPartial<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type PickUnsafe<T, K> = K extends keyof T ? Pick<T, K> : never;
+export type PickExtra<T, K> = {
+    [TKey in keyof K as string extends TKey ? never : TKey extends keyof T ? never : TKey]: K[TKey];
+};
+export type PickRequired<T> = {
+    [K in keyof T as undefined extends T[K] ? never : K]: T[K];
+};
+export type Expand<T> = T extends object ? T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never : T;
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => any ? I : never;
+export type Values<O> = O[ValueKeys<O>];
+export type ValueKeys<O> = Extract<keyof O, PropertyKey>;
+export type DeepAwaited<T> = T extends Promise<infer A> ? DeepAwaited<A> : T extends Record<infer A, Promise<infer B>> ? {
+    [K in A]: DeepAwaited<B>;
+} : T;
+export type PathParamMask<TRoutePath extends string> = TRoutePath extends `${infer L}/$${infer C}/${infer R}` ? PathParamMask<`${L}/${string}/${R}`> : TRoutePath extends `${infer L}/$${infer C}` ? PathParamMask<`${L}/${string}`> : TRoutePath;
+export type Timeout = ReturnType<typeof setTimeout>;
+export type Updater<TPrevious, TResult = TPrevious> = TResult | ((prev?: TPrevious) => TResult);
+export type NonNullableUpdater<TPrevious, TResult = TPrevious> = TResult | ((prev: TPrevious) => TResult);
+export type PickExtract<T, U> = {
+    [K in keyof T as T[K] extends U ? K : never]: T[K];
+};
+export type PickExclude<T, U> = {
+    [K in keyof T as T[K] extends U ? never : K]: T[K];
+};
+export declare function last<T>(arr: T[]): T | undefined;
+export declare function functionalUpdate<TResult>(updater: Updater<TResult> | NonNullableUpdater<TResult>, previous: TResult): TResult;
+export declare function pick<T, K extends keyof T>(parent: T, keys: K[]): Pick<T, K>;
+/**
+ * This function returns `a` if `b` is deeply equal.
+ * If not, it will replace any deeply equal children of `b` with those of `a`.
+ * This can be used for structural sharing between immutable JSON values for example.
+ * Do not use this with signals
+ */
+export declare function replaceEqualDeep<T>(prev: any, _next: T): T;
+export declare function isPlainObject(o: any): boolean;
+export declare function partialDeepEqual(a: any, b: any): boolean;