mobx-route 0.18.0 → 0.19.0

package/index.d.ts

@@ -1,3 +1,421 @@
+import { IQueryParams, RawQueryParamsData, History } from 'mobx-location-history';
 export * from 'mobx-location-history';
-export * from "./core/index.js";
-//# sourceMappingURL=index.d.ts.map
+import { ParseOptions, MatchOptions, ParamData, TokenData } from 'path-to-regexp';
+import { AnyObject, EmptyObject, IsPartial, Maybe, MaybeFn, MaybePromise } from 'yummies/types';
+
+type AnyVirtualRoute = VirtualRoute<any> | AbstractVirtualRoute<any>;
+interface VirtualOpenExtraParams extends Omit<RouteNavigateParams, 'state' | 'mergeQuery'> {
+}
+interface AbstractVirtualRoute<TParams extends AnyObject | EmptyObject = EmptyObject> {
+    isOpened: boolean;
+    params: TParams | null;
+    /**
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/VirtualRoute.html#open-params-extraparams-query-replace-promise-void)
+     */
+    open(...args: IsPartial<TParams> extends true ? [params?: Maybe<TParams>, extraParams?: VirtualOpenExtraParams] : [params: TParams, extraParams?: VirtualOpenExtraParams]): Promise<void>;
+}
+interface VirtualRouteConfiguration<TParams extends AnyObject | EmptyObject = EmptyObject> {
+    /**
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/VirtualRoute.html#abortsignal)
+     */
+    abortSignal?: AbortSignal;
+    queryParams?: IQueryParams;
+    /**
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/VirtualRoute.html#initialparams)
+     */
+    initialParams?: MaybeFn<Maybe<TParams>, [
+        route: VirtualRoute<NoInfer<TParams>>
+    ]>;
+    /**
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/VirtualRoute.html#meta)
+     */
+    meta?: AnyObject;
+    /**
+     * Custom implementation of open behaviour for this route
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/VirtualRoute.html#open)
+     */
+    open?: (...args: IsPartial<TParams> extends true ? [params: Maybe<TParams>, route: VirtualRoute<TParams>] : [params: TParams, route: VirtualRoute<TParams>]) => MaybePromise<boolean | void>;
+    /**
+     * Custom implementation of close behaviour for this route
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/VirtualRoute.html#close)
+     */
+    close?: (route: VirtualRoute<TParams>) => boolean | void;
+    /**
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/VirtualRoute.html#checkopened)
+     */
+    checkOpened?: (route: VirtualRoute<TParams>) => boolean;
+    /**
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/VirtualRoute.html#beforeopen)
+     */
+    beforeOpen?: (...args: IsPartial<TParams> extends true ? [params: Maybe<TParams>, route: VirtualRoute<TParams>] : [params: TParams, route: VirtualRoute<TParams>]) => MaybePromise<void | boolean>;
+    /**
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/VirtualRoute.html#afterclose)
+     */
+    afterClose?: () => void;
+    /**
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/VirtualRoute.html#afteropen)
+     */
+    afterOpen?: (params: NoInfer<TParams>, route: VirtualRoute<NoInfer<TParams>>) => void;
+}
+
+/**
+ * Class for creating routes with custom activation logic
+ *
+ * [**Documentation**](https://js2me.github.io/mobx-route/core/VirtualRoute.html)
+ */
+declare class VirtualRoute<TParams extends AnyObject | EmptyObject = EmptyObject> implements AbstractVirtualRoute<TParams> {
+    protected config: VirtualRouteConfiguration<TParams>;
+    protected abortController: AbortController;
+    query: IQueryParams;
+    params: TParams | null;
+    private isLocalOpened;
+    private openChecker;
+    private reactionDisposer;
+    constructor(config?: VirtualRouteConfiguration<TParams>);
+    /**
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/VirtualRoute.html#isopened-boolean)
+     */
+    get isOpened(): boolean;
+    /**
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/VirtualRoute.html#setopenchecker-openchecker-void)
+     */
+    setOpenChecker(openChecker: Maybe<VirtualRouteConfiguration<TParams>['checkOpened']>): void;
+    /**
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/VirtualRoute.html#open-params-extraparams-query-replace-promise-void)
+     */
+    open(...args: IsPartial<TParams> extends true ? [params?: Maybe<TParams>, extraParams?: VirtualOpenExtraParams] : [params: TParams, extraParams?: VirtualOpenExtraParams]): Promise<void>;
+    /**
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/VirtualRoute.html#close-void)
+     */
+    close(): void;
+    private firstOpenedStateCheck;
+    private processOpenedState;
+    destroy(): void;
+}
+declare const createVirtualRoute: <TParams extends AnyObject | EmptyObject = EmptyObject>(config?: VirtualRouteConfiguration<TParams>) => VirtualRoute<TParams>;
+
+type AnyRouteGroup = RouteGroup<RoutesCollection>;
+type AnyRouteEntity = AnyRoute | AnyRouteGroup | AnyVirtualRoute;
+interface AbstractRouteGroup<TRoutesCollection extends RoutesCollection = RoutesCollection> {
+    routes: TRoutesCollection;
+    isOpened: boolean;
+}
+type AnyAbstractRoute = AnyRoute | AbstractVirtualRoute<any>;
+type AnyAbstractRouteEntity = AnyAbstractRoute | AbstractRouteGroup;
+type RoutesArrayCollection = AnyAbstractRouteEntity[];
+type RoutesObjectCollection = Record<string, AnyAbstractRouteEntity>;
+type RoutesCollection = RoutesArrayCollection | RoutesObjectCollection;
+
+/**
+ * Class for grouping related routes and managing their state.
+ *
+ * [**Documentation**](https://js2me.github.io/mobx-route/core/RouteGroup.html)
+ */
+declare class RouteGroup<TRoutesCollection extends RoutesCollection> implements AbstractRouteGroup<TRoutesCollection> {
+    private _indexRoute?;
+    routes: TRoutesCollection;
+    constructor(routes: TRoutesCollection, _indexRoute?: AnyRouteEntity | undefined);
+    /**
+     * Returns true if at least one route in the group is open.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/RouteGroup.html#isopened-boolean)
+     */
+    get isOpened(): boolean;
+    /**
+     * First found index route.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/RouteGroup.html#indexroute-route-undefined)
+     */
+    get indexRoute(): AnyRouteEntity | undefined;
+    /**
+     * Main navigation method for the group.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/RouteGroup.html#open-args-any-void)
+     */
+    open(...args: any[]): void;
+}
+declare const createRouteGroup: <TRoutesCollection extends RoutesCollection>(routes: TRoutesCollection, indexRoute?: AnyRouteEntity) => RouteGroup<TRoutesCollection>;
+
+type PreparedNavigationData<TParams extends AnyObject = AnyObject> = {
+    state?: any;
+    /**
+     * path parameters
+     *
+     * can be received from extended routes
+     */
+    params?: TParams;
+    url: string;
+    replace?: boolean;
+    query?: AnyObject;
+};
+/**
+ * Returning `false` means ignore navigation
+ */
+type BeforeOpenFeedback = void | boolean | {
+    url: string;
+    state?: any;
+    replace?: boolean;
+};
+interface UrlCreateParams<TInputParams> {
+    baseUrl?: string | undefined;
+    params: TInputParams;
+    query: AnyObject;
+}
+type UrlCreateParamsFn<TInputParams = any> = (params: UrlCreateParams<TInputParams>, currentQueryData: RawQueryParamsData) => Maybe<UrlCreateParams<TInputParams>>;
+interface CreatedUrlOutputParams {
+    mergeQuery?: boolean;
+    omitQuery?: boolean;
+}
+interface RouteConfiguration<TPath extends string, TInputParams extends InputPathParams<TPath> = InputPathParams<TPath>, TOutputParams extends AnyObject = ParsedPathParams<TPath>, TParentRoute extends Route<string, any, any, any> | null = null> extends Omit<Partial<RouteGlobalConfig>, 'createUrl'> {
+    /**
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/Route.html#abortsignal)
+     */
+    abortSignal?: AbortSignal;
+    index?: boolean;
+    hash?: boolean;
+    /**
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/Route.html#meta)
+     */
+    meta?: AnyObject;
+    parseOptions?: ParseOptions;
+    matchOptions?: MatchOptions & ParseOptions;
+    parent?: TParentRoute;
+    children?: AnyRoute[];
+    /**
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/Route.html#params)
+     */
+    params?: (params: ParsedPathParams<TPath>, meta: AnyObject | undefined) => TOutputParams | null | false;
+    /**
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/Route.html#checkopened)
+     */
+    checkOpened?: (parsedPathData: ParsedPathData<NoInfer<TPath>>) => boolean;
+    /**
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/Route.html#beforeopen)
+     */
+    beforeOpen?: (preparedNavigationData: PreparedNavigationData<NoInfer<TInputParams>>) => MaybePromise<BeforeOpenFeedback>;
+    /**
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/Route.html#afterclose)
+     */
+    afterClose?: () => void;
+    /**
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/Route.html#afteropen)
+     */
+    afterOpen?: (data: ParsedPathData<NoInfer<TPath>>, route: Route<NoInfer<TPath>, NoInfer<TInputParams>, NoInfer<TOutputParams>, NoInfer<TParentRoute>>) => void;
+    /**
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/Route.html#createurl)
+     */
+    createUrl?: UrlCreateParamsFn<TInputParams>;
+}
+type AnyRoute = IRoute;
+interface IRoute<TPath extends string = string, TInputParams extends InputPathParams<TPath> = InputPathParams<TPath>, TOutputParams extends AnyObject = ParsedPathParams<TPath>> {
+    isOpened: boolean;
+    path: TPath;
+    /**
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/Route.html#hasopenedchildren-boolean)
+     */
+    hasOpenedChildren: boolean;
+    /**
+     * Navigates to this route.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/Route.html#open-args)
+     */
+    open(...args: IsPartial<TInputParams> extends true ? [
+        params?: TInputParams | null | undefined,
+        navigateParams?: RouteNavigateParams
+    ] : [params: TInputParams, navigateParams?: RouteNavigateParams]): Promise<void>;
+    open(...args: IsPartial<TInputParams> extends true ? [
+        params?: TInputParams | null | undefined,
+        replace?: RouteNavigateParams['replace'],
+        query?: RouteNavigateParams['query']
+    ] : [
+        params: TInputParams,
+        replace?: RouteNavigateParams['replace'],
+        query?: RouteNavigateParams['query']
+    ]): Promise<void>;
+    open(url: string, navigateParams?: RouteNavigateParams): Promise<void>;
+    open(url: string, replace?: RouteNavigateParams['replace'], query?: RouteNavigateParams['query']): Promise<void>;
+    createUrl(...args: IsPartial<TInputParams> extends true ? [params?: Maybe<TInputParams>, query?: AnyObject, mergeQuery?: boolean] : [params: TInputParams, query?: AnyObject, mergeQuery?: boolean]): string;
+    destroy(): void;
+    readonly params: TOutputParams | null;
+}
+type InputPathParam = string | number | boolean | null;
+type ParsedPathParam = string;
+type Simplify<T> = T extends infer U ? {
+    [K in keyof U]: U[K];
+} : never;
+type RouteParams<TRoute extends AnyAbstractRouteEntity> = TRoute extends {
+    path: string;
+} ? ParsedPathParams<TRoute['path']> : TRoute extends {
+    params: infer TParams;
+} ? Exclude<TParams, null> : AnyObject;
+type PathToObject<Path extends string, PropertyValue = string> = Simplify<Path extends `${infer Prefix}{${infer Optional}}${infer Suffix}` ? PathToObject<`${Prefix}${Suffix}`, PropertyValue> & Partial<PathToObject<Optional, PropertyValue>> : Path extends `${infer PartA}/${infer PartB}` ? PathToObject<PartA, PropertyValue> & PathToObject<PartB, PropertyValue> : Path extends `:${infer Param}?` ? {
+    [K in Param]?: PropertyValue;
+} : Path extends `:${infer Param}` ? {
+    [K in Param]: PropertyValue;
+} : Path extends `*${infer Wildcard}` ? {
+    [K in Wildcard]: PropertyValue[];
+} : {}>;
+type ParsedPathParams<Path extends string> = PathToObject<Path, ParsedPathParam>;
+type InputPathParams<Path extends string> = PathToObject<Path, InputPathParam>;
+interface RouteNavigateParams {
+    replace?: boolean;
+    state?: any;
+    query?: AnyObject;
+    mergeQuery?: boolean;
+}
+interface ParsedPathData<TPath extends string> {
+    path: string;
+    params: ParsedPathParams<TPath>;
+}
+type InferPath<T extends AnyRoute> = T extends IRoute<infer TPath, any, any> ? TPath : never;
+type InferInputParams<T extends AnyRoute> = T extends VirtualRoute<infer TParams> ? TParams : T extends IRoute<any, infer TInputParams, any> ? TInputParams : never;
+type InferParams<T extends AnyRoute> = T extends VirtualRoute<infer TParams> ? TParams : T extends IRoute<any, any, infer TParams> ? TParams : never;
+
+/**
+ * Class for creating path based route.
+ *
+ * [**Documentation**](https://js2me.github.io/mobx-route/core/Route.html)
+ */
+declare class Route<TPath extends string, TInputParams extends InputPathParams<TPath> = InputPathParams<TPath>, TOutputParams extends AnyObject = ParsedPathParams<TPath>, TParentRoute extends Route<any, any, any, any> | null = null> implements IRoute<TPath, TInputParams, TOutputParams> {
+    path: TPath;
+    protected config: RouteConfiguration<TPath, TInputParams, TOutputParams, TParentRoute>;
+    protected abortController: AbortController;
+    protected history: History;
+    parent: TParentRoute;
+    query: IQueryParams;
+    private _tokenData;
+    private _matcher?;
+    private _compiler?;
+    private reactionDisposer;
+    meta?: AnyObject;
+    /**
+     * Indicates if this route is an index route. Index routes activate when parent route path matches exactly.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/Route.html#isindex-boolean)
+     */
+    isIndex: boolean;
+    /**
+     * Indicates if this route is an hash route.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/Route.html#ishash-boolean)
+     */
+    isHash: boolean;
+    children: AnyRoute[];
+    constructor(path: TPath, config?: RouteConfiguration<TPath, TInputParams, TOutputParams, TParentRoute>);
+    protected get baseUrl(): string | undefined;
+    protected get parsedPathData(): ParsedPathData<TPath> | null;
+    /**
+     * Matched path segment for current URL.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/Route.html#currentpath-parsedpathname-null)
+     */
+    get currentPath(): string | null;
+    /**
+     * Current parsed path parameters.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/Route.html#params-parsedpathparams-null)
+     */
+    get params(): TOutputParams | null;
+    /**
+     * Defines the "open" state for this route.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/Route.html#isopened-boolean)
+     */
+    get isOpened(): boolean;
+    /**
+     * Allows to create child route based on this route with merging this route path and extending path.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/Route.html#extend-path-config-route)
+     */
+    extend<TExtendedPath extends string, TExtendedInputParams extends InputPathParams<`${TPath}${TExtendedPath}`> = InputPathParams<`${TPath}${TExtendedPath}`>, TExtendedOutputParams extends AnyObject = TInputParams & ParsedPathParams<`${TPath}${TExtendedPath}`>>(path: TExtendedPath, config?: Omit<RouteConfiguration<`${TPath}${TExtendedPath}`, TInputParams & TExtendedInputParams, TExtendedOutputParams, any>, 'parent'>): Route<`${TPath}${TExtendedPath}`, TInputParams & TExtendedInputParams, TExtendedOutputParams, this>;
+    addChildren(...routes: AnyRoute[]): void;
+    removeChildren(...routes: AnyRoute[]): void;
+    /**
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/Route.html#hasopenedchildren-boolean)
+     */
+    get hasOpenedChildren(): boolean;
+    protected processParams(params?: TInputParams | null | undefined): ParamData | undefined;
+    createUrl(...args: IsPartial<TInputParams> extends true ? [
+        params?: Maybe<TInputParams>,
+        query?: Maybe<AnyObject>,
+        mergeQueryOrParams?: boolean | CreatedUrlOutputParams
+    ] : [
+        params: TInputParams,
+        query?: Maybe<AnyObject>,
+        mergeQueryOrParams?: boolean | CreatedUrlOutputParams
+    ]): string;
+    /**
+     * Navigates to this route.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-route/core/Route.html#open-args)
+     */
+    open(...args: IsPartial<TInputParams> extends true ? [
+        params?: TInputParams | null | undefined,
+        navigateParams?: RouteNavigateParams
+    ] : [params: TInputParams, navigateParams?: RouteNavigateParams]): Promise<void>;
+    open(...args: IsPartial<TInputParams> extends true ? [
+        params?: TInputParams | null | undefined,
+        replace?: RouteNavigateParams['replace'],
+        query?: RouteNavigateParams['query']
+    ] : [
+        params: TInputParams,
+        replace?: RouteNavigateParams['replace'],
+        query?: RouteNavigateParams['query']
+    ]): Promise<void>;
+    open(url: string, navigateParams?: RouteNavigateParams): Promise<void>;
+    open(url: string, replace?: RouteNavigateParams['replace'], query?: RouteNavigateParams['query']): Promise<void>;
+    protected beforeOpen(openData: PreparedNavigationData<TInputParams>): MaybePromise<BeforeOpenFeedback>;
+    protected afterClose(): true | void;
+    protected get tokenData(): TokenData;
+    private firstOpenedStateCheck;
+    private processOpenedState;
+    private get isAbleToMergeQuery();
+    destroy(): void;
+}
+declare const createRoute: <TPath extends string, TInputParams extends InputPathParams<TPath> = InputPathParams<TPath>, TOutputParams extends AnyObject = ParsedPathParams<TPath>, TParentRoute extends Route<any, any, any, any> | null = null>(path: TPath, config?: RouteConfiguration<TPath, TInputParams, TOutputParams, TParentRoute>) => Route<TPath, TInputParams, TOutputParams, TParentRoute>;
+
+interface RouteGlobalConfig {
+    history: History;
+    queryParams: IQueryParams;
+    baseUrl?: string;
+    mergeQuery?: boolean;
+    createUrl?: UrlCreateParamsFn;
+    formatLinkHref?: (href: string) => string;
+}
+
+declare const routeConfig: {
+    get: () => RouteGlobalConfig;
+    set: (value: RouteGlobalConfig | null | undefined) => RouteGlobalConfig | null | undefined;
+    update: (value: Partial<RouteGlobalConfig>) => void;
+};
+
+interface RouterConfiguration<TRoutesStruct extends RoutesCollection> {
+    routes: TRoutesStruct;
+    history?: History;
+    queryParams?: IQueryParams;
+}
+interface RouterNavigateOptions extends RouteNavigateParams {
+}
+type AnyRouter = Router<RoutesCollection>;
+
+/**
+ * Class for centralized routing management.
+ *
+ * [**Documentation**](https://js2me.github.io/mobx-route/core/Router.html)
+ */
+declare class Router<TRoutesCollection extends RoutesCollection> {
+    routes: TRoutesCollection;
+    history: History;
+    query: IQueryParams;
+    constructor(config: RouterConfiguration<TRoutesCollection>);
+    get location(): any;
+    navigate(url: string, options?: RouterNavigateOptions): void;
+}
+declare const createRouter: <TRoutesCollection extends RoutesCollection>(config: RouterConfiguration<TRoutesCollection>) => Router<TRoutesCollection>;
+
+declare const isRouteEntity: (route: any) => route is AnyRouteEntity;
+
+export { Route, RouteGroup, Router, VirtualRoute, createRoute, createRouteGroup, createRouter, createVirtualRoute, isRouteEntity, routeConfig };
+export type { AbstractRouteGroup, AbstractVirtualRoute, AnyAbstractRoute, AnyAbstractRouteEntity, AnyRoute, AnyRouteEntity, AnyRouteGroup, AnyRouter, AnyVirtualRoute, BeforeOpenFeedback, CreatedUrlOutputParams, IRoute, InferInputParams, InferParams, InferPath, InputPathParam, InputPathParams, ParsedPathData, ParsedPathParam, ParsedPathParams, PathToObject, PreparedNavigationData, RouteConfiguration, RouteGlobalConfig, RouteNavigateParams, RouteParams, RouterConfiguration, RouterNavigateOptions, RoutesArrayCollection, RoutesCollection, RoutesObjectCollection, UrlCreateParams, UrlCreateParamsFn, VirtualOpenExtraParams, VirtualRouteConfiguration };