@tanstack/react-router 0.0.1-beta.20 → 0.0.1-beta.200

package/build/types/react.d.ts

@@ -0,0 +1,200 @@
+import * as React from 'react';
+import { NoInfer } from '@tanstack/react-store';
+import { MatchRouteOptions, RegisteredRouter, RouterOptions, Router, RouteMatch, RouteByPath, AnyRoute, AnyRouteProps, LinkOptions, ToOptions, ResolveRelativePath, NavigateOptions, ResolveFullPath, ResolveId, AnySearchSchema, ParsePathParams, RouteContext, AnyContext, UseLoaderResult, ResolveFullSearchSchema, RouteConstraints, RoutePaths, RoutesById, RouteIds, RouteById, ParseRoute, AllParams, AnyPathParams, Expand, ResolveAllParams, DeepMergeAll, IsAny } from '@tanstack/router-core';
+declare module '@tanstack/router-core' {
+    interface RouterOptions<TRouteTree extends AnyRoute, TDehydrated extends Record<string, any>> {
+        Wrap?: React.ComponentType<{
+            children: React.ReactNode;
+            dehydratedState?: TDehydrated;
+        }>;
+    }
+    interface RegisterRouteComponent<TLoader = unknown, TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> {
+        RouteComponent: RouteComponent<RouteProps<TLoader, TFullSearchSchema, TAllParams, TAllContext>>;
+    }
+    interface RegisterErrorRouteComponent<TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> {
+        ErrorRouteComponent: RouteComponent<ErrorRouteProps<TFullSearchSchema, TAllParams, TAllContext>>;
+    }
+    interface RegisterPendingRouteComponent<TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> {
+        PendingRouteComponent: RouteComponent<PendingRouteProps<TFullSearchSchema, TAllParams, TAllContext>>;
+    }
+    interface Route<TParentRoute extends RouteConstraints['TParentRoute'] = AnyRoute, TPath extends RouteConstraints['TPath'] = '/', TFullPath extends RouteConstraints['TFullPath'] = ResolveFullPath<TParentRoute, TPath>, TCustomId extends RouteConstraints['TCustomId'] = string, TId extends RouteConstraints['TId'] = ResolveId<TParentRoute, TCustomId, TPath>, TLoaderContext extends RouteConstraints['TLoaderContext'] = AnyContext, TLoader = unknown, TSearchSchema extends RouteConstraints['TSearchSchema'] = {}, TFullSearchSchema extends RouteConstraints['TFullSearchSchema'] = ResolveFullSearchSchema<TParentRoute, TSearchSchema>, TParams extends RouteConstraints['TParams'] = Expand<Record<ParsePathParams<TPath>, string>>, TAllParams extends RouteConstraints['TAllParams'] = ResolveAllParams<TParentRoute, TParams>, TRouteContext extends RouteConstraints['TRouteContext'] = RouteContext, TAllContext extends RouteConstraints['TAllContext'] = Expand<DeepMergeAll<[
+        IsAny<TParentRoute['types']['context'], {}>,
+        TLoaderContext,
+        TRouteContext
+    ]>>, TRouterContext extends RouteConstraints['TRouterContext'] = AnyContext, TChildren extends RouteConstraints['TChildren'] = unknown, TRouteTree extends RouteConstraints['TRouteTree'] = AnyRoute> {
+        useMatch: <TSelected = TAllContext>(opts?: {
+            select?: (search: TAllContext) => TSelected;
+        }) => TSelected;
+        useLoader: <TSelected = TLoader>(opts?: {
+            select?: (search: TLoader) => TSelected;
+        }) => UseLoaderResult<TSelected>;
+        useRouteContext: <TSelected = TAllContext>(opts?: {
+            select?: (search: TAllContext) => TSelected;
+        }) => TSelected;
+        useSearch: <TSelected = TFullSearchSchema>(opts?: {
+            select?: (search: TFullSearchSchema) => TSelected;
+        }) => TSelected;
+        useParams: <TSelected = TAllParams>(opts?: {
+            select?: (search: TAllParams) => TSelected;
+        }) => TSelected;
+    }
+    interface RegisterRouteProps<TLoader = unknown, TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> {
+        RouteProps: RouteProps<TLoader, TFullSearchSchema, TAllParams, TAllContext>;
+    }
+    interface RegisterPendingRouteProps<TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> {
+        PendingRouteProps: PendingRouteProps<TFullSearchSchema, TAllParams, TAllContext>;
+    }
+    interface RegisterErrorRouteProps<TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> {
+        ErrorRouteProps: ErrorRouteProps;
+    }
+}
+export type RouteProps<TLoader = unknown, TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> = {
+    useLoader: <TSelected = TLoader>(opts?: {
+        select?: (search: TLoader) => TSelected;
+    }) => UseLoaderResult<TSelected>;
+    useMatch: <TSelected = TAllContext>(opts?: {
+        select?: (search: TAllContext) => TSelected;
+    }) => TSelected;
+    useRouteContext: <TSelected = TAllContext>(opts?: {
+        select?: (search: TAllContext) => TSelected;
+    }) => TSelected;
+    useSearch: <TSelected = TFullSearchSchema>(opts?: {
+        select?: (search: TFullSearchSchema) => TSelected;
+    }) => TSelected;
+    useParams: <TSelected = TAllParams>(opts?: {
+        select?: (search: TAllParams) => TSelected;
+    }) => TSelected;
+};
+export type ErrorRouteProps<TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> = {
+    error: unknown;
+    info: {
+        componentStack: string;
+    };
+} & Omit<RouteProps<unknown, TFullSearchSchema, TAllParams, TAllContext>, 'useLoader'>;
+export type PendingRouteProps<TFullSearchSchema extends Record<string, any> = AnySearchSchema, TAllParams extends AnyPathParams = AnyPathParams, TAllContext extends Record<string, any> = AnyContext> = Omit<RouteProps<unknown, TFullSearchSchema, TAllParams, TAllContext>, 'useLoader'>;
+type ReactNode = any;
+export type SyncRouteComponent<TProps> = ((props: TProps) => ReactNode) | React.LazyExoticComponent<(props: TProps) => ReactNode>;
+export type AsyncRouteComponent<TProps> = SyncRouteComponent<TProps> & {
+    preload?: () => Promise<void>;
+};
+export type ErrorRouteComponent = AsyncRouteComponent<ErrorRouteComponentProps>;
+export type ErrorRouteComponentProps = {
+    error: Error;
+    info: {
+        componentStack: string;
+    };
+};
+export type AnyRouteComponent = RouteComponent<AnyRouteProps>;
+export type RouteComponent<TProps> = AsyncRouteComponent<TProps>;
+export declare function lazyRouteComponent<T extends Record<string, any>, TKey extends keyof T = 'default'>(importer: () => Promise<T>, exportName?: TKey): T[TKey] extends (props: infer TProps) => any ? AsyncRouteComponent<TProps> : never;
+export type LinkPropsOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''> = LinkOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & {
+    activeProps?: React.AnchorHTMLAttributes<HTMLAnchorElement> | (() => React.AnchorHTMLAttributes<HTMLAnchorElement>);
+    inactiveProps?: React.AnchorHTMLAttributes<HTMLAnchorElement> | (() => React.AnchorHTMLAttributes<HTMLAnchorElement>);
+    startTransition?: boolean;
+};
+export type MakeUseMatchRouteOptions<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 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 type MakeLinkPropsOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''> = LinkPropsOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & React.AnchorHTMLAttributes<HTMLAnchorElement>;
+export type MakeLinkOptions<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''> = LinkPropsOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, 'children'> & {
+    children?: React.ReactNode | ((state: {
+        isActive: boolean;
+    }) => React.ReactNode);
+};
+export type PromptProps = {
+    message: string;
+    condition?: boolean | any;
+    children?: ReactNode;
+};
+export declare function useLinkProps<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''>(options: MakeLinkPropsOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>): React.AnchorHTMLAttributes<HTMLAnchorElement>;
+export interface LinkComponent<TProps extends Record<string, any> = {}> {
+    <TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''>(props: MakeLinkOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> & TProps & React.RefAttributes<HTMLAnchorElement>): ReactNode;
+}
+export declare const Link: LinkComponent;
+export declare function Navigate<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RoutePaths<TRouteTree> = '/', TTo extends string = '', TMaskFrom extends RoutePaths<TRouteTree> = '/', TMaskTo extends string = ''>(props: NavigateOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>): null;
+export declare const matchIdsContext: React.Context<string[]>;
+export declare const routerContext: React.Context<import("@tanstack/router-core").AnyRouter>;
+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 useRouterState<TSelected = RegisteredRouter['state']>(opts?: {
+    select: (state: RegisteredRouter['state']) => TSelected;
+}): TSelected;
+export declare function RouterProvider<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TDehydrated extends Record<string, any> = Record<string, any>>({ router, ...rest }: RouterProps<TRouteTree, TDehydrated>): JSX.Element;
+export declare function useRouter(): RegisteredRouter;
+export declare function useMatches<T = RouteMatch[]>(opts?: {
+    select?: (matches: RouteMatch[]) => T;
+}): T;
+type StrictOrFrom<TFrom> = {
+    from: TFrom;
+    strict?: true;
+} | {
+    from?: never;
+    strict: false;
+};
+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 ? TRouteMatchState : TRouteMatchState | undefined;
+export type RouteFromIdOrRoute<T, TRouteTree extends AnyRoute = RegisteredRouter['routeTree']> = T extends ParseRoute<TRouteTree> ? T : T extends RouteIds<TRouteTree> ? RoutesById<TRouteTree>[T] : T extends string ? RouteIds<TRouteTree> : never;
+export declare function useLoader<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TStrict extends boolean = true, TLoader = RouteById<TRouteTree, TFrom>['types']['loader'], TSelected = TLoader>(opts: StrictOrFrom<TFrom> & {
+    select?: (search: TLoader) => TSelected;
+}): TStrict extends true ? TSelected : TSelected | undefined;
+export declare function useRouterContext<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TStrict extends boolean = true, TContext = RouteById<TRouteTree, TFrom>['types']['context'], TSelected = TContext>(opts: StrictOrFrom<TFrom> & {
+    select?: (search: TContext) => TSelected;
+}): TStrict extends true ? TSelected : TSelected | undefined;
+export declare function useRouteContext<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TStrict extends boolean = true, TRouteContext = RouteById<TRouteTree, TFrom>['types']['context'], TSelected = TRouteContext>(opts: StrictOrFrom<TFrom> & {
+    select?: (search: TRouteContext) => TSelected;
+}): TStrict extends true ? TSelected : TSelected | undefined;
+export declare function useSearch<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TStrict extends boolean = true, TSearch = RouteById<TRouteTree, TFrom>['types']['fullSearchSchema'], TSelected = TSearch>(opts: StrictOrFrom<TFrom> & {
+    select?: (search: TSearch) => TSelected;
+}): TStrict extends true ? TSelected : TSelected | undefined;
+export declare function useParams<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TFrom extends RouteIds<TRouteTree> = RouteIds<TRouteTree>, TDefaultSelected = AllParams<TRouteTree> & RouteById<TRouteTree, TFrom>['types']['allParams'], TSelected = TDefaultSelected>(opts: StrictOrFrom<TFrom> & {
+    select?: (search: TDefaultSelected) => TSelected;
+}): TSelected;
+export declare function useNavigate<TRouteTree extends AnyRoute = RegisteredRouter['routeTree'], TDefaultFrom extends RoutePaths<TRouteTree> = '/'>(defaultOpts?: {
+    from?: TDefaultFrom;
+}): <TFrom extends RoutePaths<TRouteTree> = TDefaultFrom, TTo extends string = "", TMaskFrom extends RoutePaths<TRouteTree> = "/", TMaskTo extends string = "">(opts?: NavigateOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo> | undefined) => Promise<void>;
+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: MakeUseMatchRouteOptions<TRouteTree, TFrom, TTo, TMaskFrom, TMaskTo>) => false | RouteById<TRouteTree, TResolved>["types"]["allParams"];
+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 Outlet(): JSX.Element | null;
+export declare function useInjectHtml(): (html: string | (() => Promise<string> | string)) => void;
+export declare function useDehydrate(): <T>(key: any, data: T | (() => T | Promise<T>)) => () => T | undefined;
+export declare function useHydrate(): <T = unknown>(key: any) => T;
+export declare function CatchBoundary(props: {
+    resetKey: string;
+    children: any;
+    errorComponent?: any;
+    onCatch: (error: any) => void;
+}): JSX.Element;
+export declare class CatchBoundaryImpl extends React.Component<{
+    resetKey: string;
+    children: (props: {
+        error: any;
+        reset: () => void;
+    }) => any;
+    onCatch?: (error: any) => void;
+}> {
+    state: any;
+    static getDerivedStateFromError(error: any): {
+        error: any;
+    };
+    componentDidUpdate(prevProps: Readonly<{
+        resetKey: 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;
+}): JSX.Element;
+export declare function useBlocker(message: string, condition?: boolean | any): void;
+export declare function Block({ message, condition, children }: PromptProps): any;
+export declare function shallow<T>(objA: T, objB: T): boolean;
+export {};

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

@@ -0,0 +1,3 @@
+import { ScrollRestorationOptions } from '@tanstack/router-core';
+export declare function useScrollRestoration(options?: ScrollRestorationOptions): void;
+export declare function ScrollRestoration(props: ScrollRestorationOptions): null;