@tanstack/react-router 0.0.1-beta.204 → 0.0.1-beta.205

package/build/types/route.d.ts

@@ -0,0 +1,222 @@
+import { RoutePaths } from './routeInfo';
+import { AnyRouter } from './router';
+import { AnyRouteMatch } from './RouteMatch';
+import { Expand, IsAny, NoInfer, PickRequired, UnionToIntersection, Assign } from './utils';
+import { ParsePathParams, ToSubOptions } from './link';
+import { ErrorRouteComponent, PendingRouteComponent, RouteComponent } from './react';
+import { ParsedLocation } from './location';
+export declare const rootRouteId: "__root__";
+export type RootRouteId = typeof rootRouteId;
+export type AnyPathParams = {};
+export type AnySearchSchema = {};
+export type AnyContext = {};
+export interface RouteMeta {
+}
+export type PreloadableObj = {
+    preload?: () => Promise<void>;
+};
+export type RoutePathOptions<TCustomId, TPath> = {
+    path: TPath;
+} | {
+    id: TCustomId;
+};
+export type RoutePathOptionsIntersection<TCustomId, TPath> = UnionToIntersection<RoutePathOptions<TCustomId, TPath>>;
+export type RouteOptions<TParentRoute extends AnyRoute = AnyRoute, TCustomId extends string = string, TPath extends string = string, TSearchSchema extends Record<string, any> = {}, TFullSearchSchema extends Record<string, any> = TSearchSchema, TParams extends AnyPathParams = AnyPathParams, TAllParams extends AnyPathParams = TParams, TRouteMeta extends RouteMeta = RouteMeta, TAllMeta extends Record<string, any> = AnyContext> = BaseRouteOptions<TParentRoute, TCustomId, TPath, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteMeta, TAllMeta> & NoInfer<UpdatableRouteOptions<TFullSearchSchema, TAllParams, TAllMeta>>;
+export type ParamsFallback<TPath extends string, TParams> = unknown extends TParams ? Record<ParsePathParams<TPath>, string> : TParams;
+export type BaseRouteOptions<TParentRoute extends AnyRoute = AnyRoute, TCustomId extends string = string, TPath extends string = string, TSearchSchema extends Record<string, any> = {}, TFullSearchSchema extends Record<string, any> = TSearchSchema, TParams extends AnyPathParams = {}, TAllParams = ParamsFallback<TPath, TParams>, TRouteMeta extends RouteMeta = RouteMeta, TAllContext extends Record<string, any> = AnyContext> = RoutePathOptions<TCustomId, TPath> & {
+    getParentRoute: () => TParentRoute;
+    validateSearch?: SearchSchemaValidator<TSearchSchema>;
+} & (keyof PickRequired<RouteMeta> extends never ? {
+    beforeLoad?: BeforeLoadFn<TFullSearchSchema, TParentRoute, TAllParams, TRouteMeta>;
+} : {
+    beforeLoad: BeforeLoadFn<TFullSearchSchema, TParentRoute, TAllParams, TRouteMeta>;
+}) & {
+    load?: RouteLoadFn<TAllParams, TFullSearchSchema, NoInfer<TAllContext>, NoInfer<TRouteMeta>>;
+} & ({
+    parseParams?: (rawParams: IsAny<TPath, any, Record<ParsePathParams<TPath>, string>>) => TParams extends Record<ParsePathParams<TPath>, any> ? TParams : 'parseParams must return an object';
+    stringifyParams?: (params: NoInfer<ParamsFallback<TPath, TParams>>) => Record<ParsePathParams<TPath>, string>;
+} | {
+    stringifyParams?: never;
+    parseParams?: never;
+});
+type BeforeLoadFn<TFullSearchSchema extends Record<string, any>, TParentRoute extends AnyRoute, TAllParams, TRouteMeta> = (opts: {
+    search: TFullSearchSchema;
+    abortController: AbortController;
+    preload: boolean;
+    params: TAllParams;
+    meta: TParentRoute['types']['allMeta'];
+    location: ParsedLocation;
+}) => Promise<TRouteMeta> | TRouteMeta | void;
+export type UpdatableRouteOptions<TFullSearchSchema extends Record<string, any>, TAllParams extends AnyPathParams, TAllContext extends AnyContext> = {
+    caseSensitive?: boolean;
+    wrapInSuspense?: boolean;
+    component?: RouteComponent<TFullSearchSchema, TAllParams, TAllContext>;
+    errorComponent?: ErrorRouteComponent<TFullSearchSchema, TAllParams, {}>;
+    pendingComponent?: PendingRouteComponent<TFullSearchSchema, TAllParams, TAllContext>;
+    preSearchFilters?: SearchFilter<TFullSearchSchema>[];
+    postSearchFilters?: SearchFilter<TFullSearchSchema>[];
+    onError?: (err: any) => void;
+    onEnter?: (match: AnyRouteMatch) => void;
+    onTransition?: (match: AnyRouteMatch) => void;
+    onLeave?: (match: AnyRouteMatch) => void;
+    reloadOnWindowFocus?: boolean;
+};
+export type ParseParamsOption<TPath extends string, TParams> = ParseParamsFn<TPath, TParams>;
+export type ParseParamsFn<TPath extends string, TParams> = (rawParams: IsAny<TPath, any, Record<ParsePathParams<TPath>, string>>) => TParams extends Record<ParsePathParams<TPath>, any> ? TParams : 'parseParams must return an object';
+export type ParseParamsObj<TPath extends string, TParams> = {
+    parse?: ParseParamsFn<TPath, TParams>;
+};
+export type SearchSchemaValidator<TReturn> = SearchSchemaValidatorObj<TReturn> | SearchSchemaValidatorFn<TReturn>;
+export type SearchSchemaValidatorObj<TReturn> = {
+    parse?: SearchSchemaValidatorFn<TReturn>;
+};
+export type SearchSchemaValidatorFn<TReturn> = (searchObj: Record<string, unknown>) => TReturn;
+export type DefinedPathParamWarning = 'Path params cannot be redefined by child routes!';
+export type ParentParams<TParentParams> = AnyPathParams extends TParentParams ? {} : {
+    [Key in keyof TParentParams]?: DefinedPathParamWarning;
+};
+export type RouteLoadFn<TAllParams = {}, TFullSearchSchema extends Record<string, any> = {}, TAllContext extends Record<string, any> = AnyContext, TRouteMeta extends Record<string, any> = AnyContext> = (match: LoadFnContext<TAllParams, TFullSearchSchema, TAllContext, TRouteMeta> & {
+    parentMatchPromise?: Promise<void>;
+}) => any;
+export interface LoadFnContext<TAllParams = {}, TFullSearchSchema extends Record<string, any> = {}, TAllContext extends Record<string, any> = AnyContext, TRouteMeta extends Record<string, any> = AnyContext> {
+    abortController: AbortController;
+    preload: boolean;
+    params: TAllParams;
+    search: TFullSearchSchema;
+    meta: Expand<Assign<TAllContext, TRouteMeta>>;
+}
+export type SearchFilter<T, U = T> = (prev: T) => U;
+export type ResolveId<TParentRoute, TCustomId extends string, TPath extends string> = TParentRoute extends {
+    id: infer TParentId extends string;
+} ? RoutePrefix<TParentId, string extends TCustomId ? TPath : TCustomId> : RootRouteId;
+export type InferFullSearchSchema<TRoute> = TRoute extends {
+    types: {
+        fullSearchSchema: infer TFullSearchSchema;
+    };
+} ? TFullSearchSchema : {};
+export type ResolveFullSearchSchema<TParentRoute, TSearchSchema> = Expand<Assign<InferFullSearchSchema<TParentRoute>, TSearchSchema>>;
+export interface AnyRoute extends Route<any, any, any, any, any, any, any, any, any, any, any, any, any, any> {
+}
+export type MergeFromFromParent<T, U> = IsAny<T, U, T & U>;
+export type StreamedPromise<T> = {
+    promise: Promise<T>;
+    status: 'resolved' | 'pending';
+    data: T;
+    resolve: (value: T) => void;
+};
+export type ResolveAllParams<TParentRoute extends AnyRoute, TParams extends AnyPathParams> = Record<never, string> extends TParentRoute['types']['allParams'] ? TParams : Expand<UnionToIntersection<TParentRoute['types']['allParams'] & TParams> & {}>;
+export type RouteConstraints = {
+    TParentRoute: AnyRoute;
+    TPath: string;
+    TFullPath: string;
+    TCustomId: string;
+    TId: string;
+    TSearchSchema: AnySearchSchema;
+    TFullSearchSchema: AnySearchSchema;
+    TParams: Record<string, any>;
+    TAllParams: Record<string, any>;
+    TParentContext: AnyContext;
+    TRouteMeta: RouteMeta;
+    TAllContext: AnyContext;
+    TRouterMeta: AnyContext;
+    TChildren: unknown;
+    TRouteTree: AnyRoute;
+};
+export declare class 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>, 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>, TRouteMeta extends RouteConstraints['TRouteMeta'] = RouteMeta, TAllMeta extends Expand<Assign<IsAny<TParentRoute['types']['allMeta'], {}>, TRouteMeta>> = Expand<Assign<IsAny<TParentRoute['types']['allMeta'], {}>, TRouteMeta>>, TRouterMeta extends RouteConstraints['TRouterMeta'] = AnyContext, TChildren extends RouteConstraints['TChildren'] = unknown, TRouteTree extends RouteConstraints['TRouteTree'] = AnyRoute> {
+    isRoot: TParentRoute extends Route<any> ? true : false;
+    options: RouteOptions<TParentRoute, TCustomId, TPath, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteMeta, TAllMeta>;
+    test: Expand<Assign<IsAny<TParentRoute['types']['allMeta'], {}>, TRouteMeta>>;
+    parentRoute: TParentRoute;
+    id: TId;
+    path: TPath;
+    fullPath: TFullPath;
+    to: TrimPathRight<TFullPath>;
+    children?: TChildren;
+    originalIndex?: number;
+    router?: AnyRouter;
+    rank: number;
+    constructor(options: RouteOptions<TParentRoute, TCustomId, TPath, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteMeta, TAllMeta>);
+    types: {
+        parentRoute: TParentRoute;
+        path: TPath;
+        to: TrimPathRight<TFullPath>;
+        fullPath: TFullPath;
+        customId: TCustomId;
+        id: TId;
+        searchSchema: TSearchSchema;
+        fullSearchSchema: TFullSearchSchema;
+        params: TParams;
+        allParams: TAllParams;
+        routeMeta: TRouteMeta;
+        allMeta: TAllMeta;
+        children: TChildren;
+        routeTree: TRouteTree;
+        routerMeta: TRouterMeta;
+    };
+    init: (opts: {
+        originalIndex: number;
+    }) => void;
+    addChildren: <TNewChildren extends AnyRoute[]>(children: TNewChildren) => Route<TParentRoute, TPath, TFullPath, TCustomId, TId, TSearchSchema, TFullSearchSchema, TParams, TAllParams, TRouteMeta, TAllMeta, TRouterMeta, TNewChildren, TRouteTree>;
+    update: (options: UpdatableRouteOptions<TFullSearchSchema, TAllParams, Expand<Assign<IsAny<TParentRoute['types']['allMeta'], {}>, TRouteMeta>>>) => this;
+    static __onInit: (route: any) => void;
+    useMatch: <TSelected = TAllMeta>(opts?: {
+        select?: ((search: TAllMeta) => TSelected) | undefined;
+    } | undefined) => TSelected;
+    useRouteMeta: <TSelected = TAllMeta>(opts?: {
+        select?: ((search: TAllMeta) => TSelected) | undefined;
+    } | undefined) => TSelected;
+    useSearch: <TSelected = TFullSearchSchema>(opts?: {
+        select?: ((search: TFullSearchSchema) => TSelected) | undefined;
+    } | undefined) => TSelected;
+    useParams: <TSelected = TAllParams>(opts?: {
+        select?: ((search: TAllParams) => TSelected) | undefined;
+    } | undefined) => TSelected;
+}
+export type AnyRootRoute = RootRoute<any, any, any>;
+export declare class RouterMeta<TRouterMeta extends {}> {
+    constructor();
+    createRootRoute: <TSearchSchema extends Record<string, any> = {}, TRouteMeta extends RouteMeta = RouteMeta>(options?: Omit<RouteOptions<AnyRoute, "__root__", "", TSearchSchema, TSearchSchema, {}, {}, TRouteMeta, Assign<TRouterMeta, TRouteMeta>>, "id" | "path" | "getParentRoute" | "stringifyParams" | "parseParams" | "caseSensitive"> | undefined) => RootRoute<TSearchSchema, TRouteMeta, TRouterMeta>;
+}
+export declare class RootRoute<TSearchSchema extends Record<string, any> = {}, TRouteMeta extends RouteMeta = RouteMeta, TRouterMeta extends {} = {}> extends Route<any, // TParentRoute
+'/', // TPath
+'/', // TFullPath
+string, // TCustomId
+RootRouteId, // TId
+TSearchSchema, // TSearchSchema
+TSearchSchema, // TFullSearchSchema
+{}, // TParams
+{}, // TAllParams
+TRouteMeta, // TRouteMeta
+Expand<Assign<TRouterMeta, TRouteMeta>>, // TAllContext
+TRouterMeta, // TRouterMeta
+any, // TChildren
+any> {
+    constructor(options?: Omit<RouteOptions<AnyRoute, // TParentRoute
+    RootRouteId, // TCustomId
+    '', // TPath
+    TSearchSchema, // TSearchSchema
+    TSearchSchema, // TFullSearchSchema
+    {}, // TParams
+    {}, // TAllParams
+    TRouteMeta, // TRouteMeta
+    Assign<TRouterMeta, TRouteMeta>>, 'path' | 'id' | 'getParentRoute' | 'caseSensitive' | 'parseParams' | 'stringifyParams'>);
+}
+export type ResolveFullPath<TParentRoute extends AnyRoute, TPath extends string, TPrefixed = RoutePrefix<TParentRoute['fullPath'], TPath>> = TPrefixed extends RootRouteId ? '/' : TPrefixed;
+type RoutePrefix<TPrefix extends string, TPath extends string> = string extends TPath ? RootRouteId : TPath extends string ? TPrefix extends RootRouteId ? TPath extends '/' ? '/' : `/${TrimPath<TPath>}` : `${TPrefix}/${TPath}` extends '/' ? '/' : `/${TrimPathLeft<`${TrimPathRight<TPrefix>}/${TrimPath<TPath>}`>}` : never;
+export type TrimPath<T extends string> = '' extends T ? '' : TrimPathRight<TrimPathLeft<T>>;
+export type TrimPathLeft<T extends string> = T extends `${RootRouteId}/${infer U}` ? TrimPathLeft<U> : T extends `/${infer U}` ? TrimPathLeft<U> : T;
+export type TrimPathRight<T extends string> = T extends '/' ? '/' : T extends `${infer U}/` ? TrimPathRight<U> : T;
+export type RouteMask<TRouteTree extends AnyRoute> = {
+    routeTree: TRouteTree;
+    from: RoutePaths<TRouteTree>;
+    to?: any;
+    params?: any;
+    search?: any;
+    hash?: any;
+    state?: any;
+    unmaskOnReload?: boolean;
+};
+export declare function createRouteMask<TRouteTree extends AnyRoute, TFrom extends RoutePaths<TRouteTree>, TTo extends string>(opts: {
+    routeTree: TRouteTree;
+} & ToSubOptions<TRouteTree, TFrom, TTo>): RouteMask<TRouteTree>;
+export {};

package/build/types/routeInfo.d.ts

@@ -0,0 +1,22 @@
+import { AnyRoute, Route } from './route';
+import { Expand, UnionToIntersection } from './utils';
+export type ParseRoute<TRouteTree extends AnyRoute> = TRouteTree | ParseRouteChildren<TRouteTree>;
+export type ParseRouteChildren<TRouteTree extends AnyRoute> = TRouteTree extends Route<any, any, any, any, any, any, any, any, any, any, any, any, infer TChildren, any> ? unknown extends TChildren ? never : TChildren extends AnyRoute[] ? {
+    [TId in TChildren[number]['id'] as string]: ParseRoute<TChildren[number]>;
+}[string] : never : never;
+export type RoutesById<TRouteTree extends AnyRoute> = {
+    [K in ParseRoute<TRouteTree> as K['id']]: K;
+};
+export type RouteById<TRouteTree extends AnyRoute, TId> = Extract<ParseRoute<TRouteTree>, {
+    id: TId;
+}>;
+export type RouteIds<TRouteTree extends AnyRoute> = ParseRoute<TRouteTree>['id'];
+export type RoutesByPath<TRouteTree extends AnyRoute> = {
+    [K in ParseRoute<TRouteTree> as K['fullPath']]: K;
+};
+export type RouteByPath<TRouteTree extends AnyRoute, TPath> = Extract<ParseRoute<TRouteTree>, {
+    fullPath: TPath;
+}>;
+export type RoutePaths<TRouteTree extends AnyRoute> = ParseRoute<TRouteTree>['fullPath'] | '/';
+export type FullSearchSchema<TRouteTree extends AnyRoute> = Partial<Expand<UnionToIntersection<ParseRoute<TRouteTree>['types']['fullSearchSchema']>>>;
+export type AllParams<TRouteTree extends AnyRoute> = Expand<UnionToIntersection<ParseRoute<TRouteTree>['types']['allParams']>>;

package/build/types/router.d.ts

@@ -0,0 +1,115 @@
+import { RouterHistory } from '@tanstack/history';
+import { AnySearchSchema, AnyRoute, AnyContext, AnyPathParams, RouteMask } from './route';
+import { FullSearchSchema } from './routeInfo';
+import { PickAsRequired, Updater, NonNullableUpdater } from './utils';
+import { ErrorRouteComponent, PendingRouteComponent, RouteComponent } from './react';
+import { RouteMatch } from './RouteMatch';
+import { ParsedLocation } from './location';
+import { LocationState } from './location';
+import { SearchSerializer, SearchParser } from './searchParams';
+declare global {
+    interface Window {
+        __TSR_DEHYDRATED__?: HydrationCtx;
+    }
+}
+export interface Register {
+}
+export type AnyRouter = Router<any, any>;
+export type RegisteredRouter = Register extends {
+    router: infer TRouter extends AnyRouter;
+} ? TRouter : AnyRouter;
+export type HydrationCtx = {
+    router: DehydratedRouter;
+    payload: Record<string, any>;
+};
+export type RouterContextOptions<TRouteTree extends AnyRoute> = AnyContext extends TRouteTree['types']['routerMeta'] ? {
+    meta?: TRouteTree['types']['routerMeta'];
+} : {
+    meta: TRouteTree['types']['routerMeta'];
+};
+export interface RouterOptions<TRouteTree extends AnyRoute, TDehydrated extends Record<string, any> = Record<string, any>> {
+    history?: RouterHistory;
+    stringifySearch?: SearchSerializer;
+    parseSearch?: SearchParser;
+    defaultPreload?: false | 'intent';
+    defaultPreloadDelay?: number;
+    defaultComponent?: RouteComponent<AnySearchSchema, AnyPathParams, AnyContext>;
+    defaultErrorComponent?: ErrorRouteComponent<AnySearchSchema, AnyPathParams, AnyContext>;
+    defaultPendingComponent?: PendingRouteComponent<AnySearchSchema, AnyPathParams, AnyContext>;
+    defaultMaxAge?: number;
+    defaultGcMaxAge?: number;
+    defaultPreloadMaxAge?: number;
+    caseSensitive?: boolean;
+    routeTree?: TRouteTree;
+    basepath?: string;
+    createRoute?: (opts: {
+        route: AnyRoute;
+        router: AnyRouter;
+    }) => void;
+    meta?: TRouteTree['types']['routerMeta'];
+    routeMasks?: RouteMask<TRouteTree>[];
+    unmaskOnReload?: boolean;
+}
+export interface RouterState<TRouteTree extends AnyRoute = AnyRoute> {
+    status: 'idle' | 'pending';
+    isFetching: boolean;
+    matches: RouteMatch<TRouteTree>[];
+    pendingMatches: 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 DehydratedRouterState {
+    dehydratedMatches: DehydratedRouteMatch[];
+}
+export type DehydratedRouteMatch = Pick<RouteMatch, 'fetchedAt' | 'invalid' | 'id' | '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>> {
+    options: PickAsRequired<RouterOptions<TRouteTree, TDehydrated>, 'stringifySearch' | 'parseSearch' | 'meta'>;
+    routeTree: TRouteTree;
+    constructor(options: RouterConstructorOptions<TRouteTree, TDehydrated>);
+    subscribers: Set<RouterListener<RouterEvent>>;
+    subscribe: <TType extends keyof RouterEvents>(eventType: TType, fn: ListenerFn<RouterEvents[TType]>) => () => void;
+    emit: (routerEvent: RouterEvent) => void;
+}
+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]>>;

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

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

package/build/types/searchParams.d.ts

@@ -0,0 +1,7 @@
+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;
+export type SearchSerializer = (searchObj: Record<string, any>) => string;
+export type SearchParser = (searchStr: string) => Record<string, any>;

package/build/types/utils.d.ts

@@ -0,0 +1,48 @@
+export type NoInfer<T> = [T][T extends any ? 0 : never];
+export type IsAny<T, Y, N = T> = 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 Assign<Left, Right> = Omit<Left, keyof Right> & Right;
+export type AssignAll<T extends any[]> = T extends [infer Left, ...infer Right] ? Right extends any[] ? Assign<Left, AssignAll<Right>> : Left : {};
+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 const isServer: boolean;
+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;
+export declare function useStableCallback<T extends (...args: any[]) => any>(fn: T): T;