@tanstack/react-router 0.0.1-beta.83 → 1.0.0

package/build/types/CatchBoundary.d.ts

@@ -0,0 +1,36 @@
+import * as React from 'react';
+export declare function CatchBoundary(props: {
+    getResetKey: () => string;
+    children: any;
+    errorComponent?: any;
+    onCatch: (error: any) => void;
+}): React.JSX.Element;
+export declare class CatchBoundaryImpl extends React.Component<{
+    getResetKey: () => string;
+    children: (props: {
+        error: any;
+        reset: () => void;
+    }) => any;
+    onCatch?: (error: any) => void;
+}> {
+    state: any;
+    static getDerivedStateFromProps(props: any): {
+        resetKey: any;
+    };
+    static getDerivedStateFromError(error: any): {
+        error: any;
+    };
+    componentDidUpdate(prevProps: Readonly<{
+        getResetKey: () => string;
+        children: (props: {
+            error: any;
+            reset: () => void;
+        }) => any;
+        onCatch?: ((error: any, info: any) => void) | undefined;
+    }>, prevState: any): void;
+    componentDidCatch(error: any): void;
+    render(): any;
+}
+export declare function ErrorComponent({ error }: {
+    error: any;
+}): React.JSX.Element;

package/build/types/Matches.d.ts

@@ -0,0 +1,64 @@
+import * as React from 'react';
+import { ResolveRelativePath, ToOptions } from './link';
+import { AnyRoute, ReactNode } from './route';
+import { FullSearchSchema, ParseRoute, RouteById, RouteByPath, RouteIds, RoutePaths } from './routeInfo';
+import { RegisteredRouter } from './router';
+import { NoInfer, StrictOrFrom } from './utils';
+export declare const matchContext: React.Context<string | undefined>;
+export interface RouteMatch<TRouteTree extends AnyRoute = AnyRoute, TRouteId extends RouteIds<TRouteTree> = ParseRoute<TRouteTree>['id']> {
+    id: string;
+    routeId: TRouteId;
+    pathname: string;
+    params: RouteById<TRouteTree, TRouteId>['types']['allParams'];
+    status: 'pending' | 'success' | 'error';
+    isFetching: boolean;
+    showPending: boolean;
+    error: unknown;
+    paramsError: unknown;
+    searchError: unknown;
+    updatedAt: number;
+    loadPromise?: Promise<void>;
+    loaderData?: RouteById<TRouteTree, TRouteId>['types']['loaderData'];
+    routeContext: RouteById<TRouteTree, TRouteId>['types']['routeContext'];
+    context: RouteById<TRouteTree, TRouteId>['types']['allContext'];
+    search: FullSearchSchema<TRouteTree> & RouteById<TRouteTree, TRouteId>['types']['fullSearchSchema'];
+    fetchCount: number;
+    abortController: AbortController;
+    cause: 'preload' | 'enter' | 'stay';
+    loaderDeps: RouteById<TRouteTree, TRouteId>['types']['loaderDeps'];
+    preload: boolean;
+    invalid: boolean;
+}
+export type AnyRouteMatch = RouteMatch<any, any>;
+export declare function Matches(): React.JSX.Element;
+export declare function Match({ matchId }: {
+    matchId: string;
+}): React.JSX.Element;
+export declare const Outlet: React.NamedExoticComponent<object>;
+export interface MatchRouteOptions {
+    pending?: boolean;
+    caseSensitive?: boolean;
+    includeSearch?: boolean;
+    fuzzy?: boolean;
+}
+export type UseMatchRouteOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''> = ToOptions<AnyRoute, TFrom, TTo, TMaskFrom, TMaskTo> & MatchRouteOptions;
+export declare function useMatchRoute<TRouteTree extends AnyRoute = RegisteredRouter['routeTree']>(): <TFrom extends RoutePaths<TRouteTree> = "/", TTo extends string = "", TMaskFrom extends RoutePaths<TRouteTree> = "/", TMaskTo extends string = "", TResolved extends string = ResolveRelativePath<TFrom, NoInfer<TTo>>>(opts: UseMatchRouteOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>) => false | RouteById<TRouteTree, TResolved>["types"]["allParams"];
+export type MakeMatchRouteOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''> = ToOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & MatchRouteOptions & {
+    children?: ((params?: RouteByPath<TRouteTree, ResolveRelativePath<TFrom, NoInfer<TTo>>>['types']['allParams']) => ReactNode) | React.ReactNode;
+};
+export declare function MatchRoute<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''>(props: MakeMatchRouteOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>): any;
+export declare function useMatch<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TStrict extends boolean = true, TRouteMatchState = RouteMatch<TRouteTree, TFrom>, TSelected = TRouteMatchState>(opts: StrictOrFrom<TFrom> & {
+    select?: (match: TRouteMatchState) => TSelected;
+}): TStrict extends true ? TSelected : TSelected | undefined;
+export declare function useMatches<T = RouteMatch[]>(opts?: {
+    select?: (matches: RouteMatch[]) => T;
+}): T;
+export declare function useParentMatches<T = RouteMatch[]>(opts?: {
+    select?: (matches: RouteMatch[]) => T;
+}): T;
+export declare function useLoaderDeps<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TStrict extends boolean = true, TRouteMatch extends RouteMatch<TRouteTree, TFrom> = RouteMatch<TRouteTree, TFrom>, TSelected = Required<TRouteMatch>['loaderDeps']>(opts: StrictOrFrom<TFrom> & {
+    select?: (match: TRouteMatch) => TSelected;
+}): TStrict extends true ? TSelected : TSelected | undefined;
+export declare function useLoaderData<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TStrict extends boolean = true, TRouteMatch extends RouteMatch<TRouteTree, TFrom> = RouteMatch<TRouteTree, TFrom>, TSelected = Required<TRouteMatch>['loaderData']>(opts: StrictOrFrom<TFrom> & {
+    select?: (match: TRouteMatch) => TSelected;
+}): TStrict extends true ? TSelected : TSelected | undefined;

package/build/types/RouteMatch.d.ts

@@ -0,0 +1,23 @@
+import { AnyRoute } from './route';
+import { ParseRoute, FullSearchSchema, RouteById, RouteIds } from './routeInfo';
+export interface RouteMatch<TRouteTree extends AnyRoute = AnyRoute, TRouteId extends RouteIds<TRouteTree> = ParseRoute<TRouteTree>['id']> {
+    id: 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;
+    loadPromise?: Promise<void>;
+    __resolveLoadPromise?: () => void;
+    context: RouteById<TRouteTree, TRouteId>['types']['allContext'];
+    routeSearch: RouteById<TRouteTree, TRouteId>['types']['searchSchema'];
+    search: FullSearchSchema<TRouteTree> & RouteById<TRouteTree, TRouteId>['types']['fullSearchSchema'];
+    fetchedAt: number;
+    abortController: AbortController;
+}
+export type AnyRouteMatch = RouteMatch<any>;

package/build/types/RouterProvider.d.ts

@@ -0,0 +1,35 @@
+import * as React from 'react';
+import { NavigateOptions, ResolveRelativePath, ToOptions } from './link';
+import { ParsedLocation } from './location';
+import { AnyRoute } from './route';
+import { RouteById, RoutePaths } from './routeInfo';
+import { RegisteredRouter, Router, RouterOptions, RouterState } from './router';
+import { NoInfer } from './utils';
+import { MatchRouteOptions } from './Matches';
+import { RouteMatch } from './Matches';
+export interface CommitLocationOptions {
+    replace?: boolean;
+    resetScroll?: boolean;
+    startTransition?: boolean;
+}
+export interface MatchLocation {
+    to?: string | number | null;
+    fuzzy?: boolean;
+    caseSensitive?: boolean;
+    from?: string;
+}
+export type NavigateFn<TRouteTree extends AnyRoute> = <TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = TFrom, TMaskTo extends string = ''>(opts: NavigateOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>) => Promise<void>;
+export type MatchRouteFn<TRouteTree extends AnyRoute> = <TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TResolved = ResolveRelativePath<TFrom, NoInfer<TTo>>>(location: ToOptions<TRouteTree, TFrom, TTo>, opts?: MatchRouteOptions) => false | RouteById<TRouteTree, TResolved>['types']['allParams'];
+export type BuildLocationFn<TRouteTree extends AnyRoute> = (opts: ToOptions<TRouteTree>) => ParsedLocation;
+export type InjectedHtmlEntry = string | (() => Promise<string> | string);
+export declare let routerContext: React.Context<Router<any, Record<string, any>>>;
+export declare function RouterProvider<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TDehydrated extends Record<string, any> = Record<string, any>>({ router, ...rest }: RouterProps<TRouteTree, TDehydrated>): React.JSX.Element;
+export declare function getRouteMatch<TRouteTree extends AnyRoute>(state: RouterState<TRouteTree>, id: string): undefined | RouteMatch<TRouteTree>;
+export declare function useRouterState<TSelected = RouterState<RegisteredRouter['routeTree']>>(opts?: {
+    select: (state: RouterState<RegisteredRouter['routeTree']>) => TSelected;
+}): TSelected;
+export type RouterProps<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TDehydrated extends Record<string, any> = Record<string, any>> = Omit<RouterOptions<TRouteTree, TDehydrated>, 'context'> & {
+    router: Router<TRouteTree>;
+    context?: Partial<RouterOptions<TRouteTree, TDehydrated>['context']>;
+};
+export declare function useRouter<TRouteTree extends AnyRoute = RegisteredRouter['routeTree']>(): Router<TRouteTree>;

package/build/types/awaited.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+import { DeferredPromise } from './defer';
+export type AwaitOptions<T> = {
+    promise: DeferredPromise<T>;
+};
+export declare function useAwaited<T>({ promise }: AwaitOptions<T>): [T];
+export declare function Await<T>(props: AwaitOptions<T> & {
+    children: (result: T) => JSX.Element;
+}): JSX.Element;

package/build/types/defer.d.ts

@@ -0,0 +1,19 @@
+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 declare function defer<T>(_promise: Promise<T>): DeferredPromise<T>;
+export declare function isDehydratedDeferred(obj: any): boolean;

package/build/types/fileRoute.d.ts

@@ -0,0 +1,38 @@
+import { ParsePathParams } from './link';
+import { AnyRoute, ResolveFullPath, ResolveFullSearchSchema, MergeFromFromParent, RouteContext, AnyContext, RouteOptions, UpdatableRouteOptions, Route, RootRouteId, TrimPathLeft, RouteConstraints } from './route';
+import { Assign, Expand, IsAny } from './utils';
+export interface FileRoutesByPath {
+}
+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 declare 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>>> {
+    path: TFilePath;
+    constructor(path: TFilePath);
+    createRoute: <TSearchSchema extends import("./route").AnySearchSchema = {}, TFullSearchSchema extends import("./route").AnySearchSchema = ResolveFullSearchSchema<TParentRoute, TSearchSchema>, TParams extends Record<string, any> = Expand<Record<ParsePathParams<TPath>, string>>, TAllParams extends Record<string, any> = MergeFromFromParent<TParentRoute["types"]["allParams"], TParams>, TRouteContext extends RouteContext = RouteContext, TContext extends Expand<Assign<IsAny<TParentRoute["types"]["allContext"], {}>, TRouteContext>> = Expand<Assign<IsAny<TParentRoute["types"]["allContext"], {}>, TRouteContext>>, TRouterContext extends AnyContext = AnyContext, TLoaderDeps extends Record<string, any> = {}, TLoaderData extends unknown = unknown, TChildren extends unknown = unknown, TRouteTree extends AnyRoute = AnyRoute>(options?: (Omit<RouteOptions<TParentRoute, string, TPath, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteContext, TContext, TLoaderDeps, TLoaderData>, "path" | "id" | "getParentRoute"> & {
+        meta?: import("./route").RouteMeta | undefined;
+    } & {
+        caseSensitive?: boolean | undefined;
+        wrapInSuspense?: boolean | undefined;
+        component?: import("./route").RouteComponent<any> | undefined;
+        errorComponent?: false | import("./route").ErrorRouteComponent | null | undefined;
+        pendingComponent?: import("./route").RouteComponent<any> | undefined;
+        pendingMs?: number | undefined;
+        pendingMinMs?: number | undefined;
+        staleTime?: number | undefined;
+        gcTime?: number | undefined;
+        preloadStaleTime?: number | undefined;
+        preloadGcTime?: number | undefined;
+        preSearchFilters?: import("./route").SearchFilter<TFullSearchSchema, TFullSearchSchema>[] | undefined;
+        postSearchFilters?: import("./route").SearchFilter<TFullSearchSchema, TFullSearchSchema>[] | undefined;
+        onError?: ((err: any) => void) | undefined;
+        onEnter?: ((match: import("./Matches").AnyRouteMatch) => void) | undefined;
+        onStay?: ((match: import("./Matches").AnyRouteMatch) => void) | undefined;
+        onLeave?: ((match: import("./Matches").AnyRouteMatch) => void) | undefined;
+    }) | undefined) => Route<TParentRoute, TPath, TFullPath, TFilePath, TId, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteContext, TContext, TRouterContext, TLoaderDeps, TLoaderData, TChildren, TRouteTree>;
+}
+export {};

package/build/types/history.d.ts

@@ -0,0 +1,7 @@
+import { HistoryLocation } from '@tanstack/history';
+declare module '@tanstack/history' {
+    interface HistoryState {
+        __tempLocation?: HistoryLocation;
+        __tempKey?: string;
+    }
+}