react-router-manage/dist/index.d.ts

react-router-manage extends react-router(v6), it Including authentication, configuration, addition, deletion and modification

import { To as To$1 } from 'react-router';
export { AbortedDeferredError, ActionFunction, ActionFunctionArgs, Await, AwaitProps, DataRouteMatch, DataRouteObject, Fetcher, Hash, IndexRouteObject, IndexRouteProps, JsonFunction, LayoutRouteProps, LazyRouteFunction, LoaderFunction, LoaderFunctionArgs, Location, MemoryRouter, MemoryRouterProps, Navigate, NavigateFunction, NavigateOptions, NavigateProps, Navigation, NavigationType, Navigator, NonIndexRouteObject, Outlet, OutletProps, ParamParseKey, Params, Path, PathMatch, PathPattern, PathRouteProps, Pathname, RedirectFunction, RelativeRoutingType, Route, RouteMatch, RouteObject, RouteProps, Router, RouterProps, RouterProvider, RouterProviderProps, Routes, RoutesProps, Search, ShouldRevalidateFunction, To, UNSAFE_DataRouterContext, UNSAFE_DataRouterStateContext, UNSAFE_LocationContext, UNSAFE_NavigationContext, UNSAFE_RouteContext, createMemoryRouter, createPath, createRoutesFromChildren, createRoutesFromElements, defer, generatePath, isRouteErrorResponse, json, matchPath, matchRoutes, parsePath, redirect, renderMatches, resolvePath, unstable_Blocker, unstable_BlockerFunction, unstable_useBlocker, useActionData, useAsyncError, useAsyncValue, useHref, useInRouterContext, useLoaderData, useLocation, useMatch, useMatches, useNavigation, useNavigationType, useOutlet, useOutletContext, useParams, useResolvedPath, useRevalidator, useRouteError, useRouteLoaderData, useRoutes } from 'react-router';
import { To, NavigateOptions } from 'react-router-dom';
export { BrowserRouterProps, FetcherWithComponents, Form, FormProps, HashRouterProps, HistoryRouterProps, Link, LinkProps, NavLink, NavLinkProps, ScrollRestoration, ScrollRestorationProps, SubmitFunction, UNSAFE_useScrollRestoration, createBrowserRouter, createHashRouter, useBeforeUnload, useFetcher, useFetchers, useFormAction, useLinkClickHandler, useSearchParams, useSubmit } from 'react-router-dom';
import * as React from 'react';
import { ParsedQuery } from 'query-string';
import { BrowserHistory, Location } from '@remix-run/router';

interface OldBrowserHistory extends BrowserHistory {
    back: () => void;
    forward: () => void;
}
interface RouterBaseConfigI {
    routes: RouteTypeI[];
    basename?: string;
    beforeEachMount?: BeforeEachMountI;
    autoDocumentTitle?: boolean | ((currentPathRoutes: RouteTypeExtendsI[]) => string);
    _isDefined: boolean;
    _defineId: number;
    navigate: NavigateFunction$1;
    _navigateRef: {
        current: NavigateFunction$1 | null;
    };
}
interface RouterConfigI extends Omit<RouterBaseConfigI, "_isDefined" | "_defineId" | "navigate" | "_navigateRef"> {
    /** Lazy component or before next called */
    LoadingComponent?: React.FunctionComponent<any>;
}
type PermissionModeType = "parent" | "children";
type CodeType = string | string[] | FnCodeType;
type FnCodeType = (route: RouteTypeI) => boolean;
type NextOptionsType = {
    name?: string;
    path?: string;
} | React.ComponentType<any>;
interface BeforeEachMountI {
    (to: RouteTypeI, next: (nextOptionsType?: NextOptionsType) => void): void;
}
interface BeforeEnterI {
    (to: RouteTypeI | undefined, next: (nextOptionsType?: NextOptionsType) => void): void;
}
interface BeforeLeaveI {
    (to: RouteTypeI | undefined, from: RouteTypeI | undefined, next: (ReplaceComponent?: any) => void): void;
}
interface RouteTypePropsI {
    beforeEnter?: BeforeEnterI;
    beforeEachMount?: BeforeEachMountI;
    Component: any;
    props: RouteTypeInputI["props"];
    _route: RouteTypeI;
    [prop: string]: any;
}
type RouteComponentType = React.LazyExoticComponent<any> | React.FC<any>;
type Simplify<T> = {
    [P in keyof T]: T[P];
};
type SetOptional<T, K extends keyof T> = Simplify<Partial<Pick<T, K>> & Pick<T, Exclude<keyof T, K>>>;
type RoutePathCallNullTypeI = SetOptional<RouteTypeI, "path">;
interface RouteTypeI {
    name: string;
    path: string;
    index?: boolean;
    component?: RouteComponentType;
    beforeEnter?: BeforeEnterI;
    beforeLeave?: BeforeLeaveI;
    items?: RouteTypeI[];
    children?: RoutePathCallNullTypeI[];
    title?: string;
    hidden?: boolean;
    icon?: string;
    code?: CodeType;
    parentName?: string;
    fullscreen?: boolean;
    props?: Record<string, any>;
    redirect?: string;
    type?: "real" | "null";
    breadcrumbs?: {
        isRoot?: boolean;
        text?: string | React.ReactNode | ((route: RouteTypeI) => React.ReactNode);
        hidden?: boolean;
    };
    meta?: Record<string, any>;
}
interface RouteTypeInputI extends RouteTypeI {
    _relativePath?: string;
    _level: number;
    path: string;
    items?: RouteTypeInputI[];
    children?: RouteTypeInputI[];
    parent?: RouteTypeInputI;
}
interface RouteTypeExtendsI extends RouteTypeInputI {
    parent?: RouteTypeExtendsI;
    parentAbs?: RouteTypeExtendsI;
    meta: Record<string, any>;
    items?: RouteTypeExtendsI[];
    children?: RouteTypeExtendsI[];
    _isHasAuth: boolean;
    _route: RouteTypeInputI;
    _component?: RouteComponentType;
    _currentComponent?: RouteComponentType;
    _itemsAndChildren?: RouteTypeExtendsI[];
    /**
     * The route permission irrelevant to the parent is used to
     * calculate the permission of the parent route for the child route in permissionType is 'children' mode
     */
    _currentIsHasAuth?: boolean;
    _props?: RouteTypePropsI;
}
interface AddRoutesI {
    (routes: RouteTypeI[]): void;
}
interface UpdateRoutesI {
    (routes: {
        routeName: string;
        routeData: Partial<RouteTypeI>;
    }[]): void;
}
interface RoutesBaseStateStruct {
    routesMap: RoutesMapI;
    routes: RouteTypeI[];
    flattenRoutes: RouteTypeI[];
    basename?: string;
}
interface ExtraNavigateOptions extends NavigateOptions {
    params?: Record<string, any>;
    query?: Record<string, any>;
}
interface NavigateFunction$1 {
    (to: To, options?: ExtraNavigateOptions): void;
    (delta: number): void;
}
interface RoutesStateStruct extends RoutesBaseStateStruct {
    navigate: NavigateFunction$1;
    location: Location;
    currentRoute: RouteTypeExtendsI;
    authRoutes: RouteTypeExtendsI[];
    query: ParsedQuery<string>;
    params: Record<string, number | string>;
}
interface RoutesMapI extends Record<string, RouteTypeExtendsI> {
}

/** Dynamically add routing method */
declare function useAddRoutes(): AddRoutesI;
declare function useRemoveRoutes(): (routeNames: string[]) => void;
declare function useUpdateRoutes(): UpdateRoutesI;

declare function useHistory(): OldBrowserHistory;

interface MRouterPropsI {
    permissionList?: string[];
    permissionMode?: PermissionModeType;
    wrapComponent?: React.FunctionComponent<any>;
    hasAuth?: boolean;
    routerConfig: RouterBaseConfigI;
    children?: (children: React.ReactNode) => React.ReactNode;
}

declare function defineRouterConfig(routerConfig: RouterConfigI): RouterBaseConfigI;

declare function useBeforeLeave(fn: BeforeLeaveI, options?: {
    beforeunload?: ((event?: Event) => any) | ((event?: Event) => Promise<any>);
}): void;
interface NavigateFunction {
    (to: To$1, options?: ExtraNavigateOptions): void;
    (delta: number): void;
}
declare const useNavigate: () => NavigateFunction;
declare function useRouter(): RoutesStateStruct;

declare const MRouter: React.FC<MRouterPropsI>;
declare const MHRouter: React.FC<MRouterPropsI>;

export { MHRouter, MRouter, RouteTypeExtendsI, RouteTypeI, RouterConfigI, RoutesMapI, defineRouterConfig, useAddRoutes, useBeforeLeave, useHistory, useNavigate, useRemoveRoutes, useRouter, useUpdateRoutes };