@ima/core
Version:
IMA.js framework for isomorphic javascript application
227 lines (226 loc) • 8.74 kB
TypeScript
import { PageManager, ManageArgs } from './PageManager';
import { Controller } from '../../controller/Controller';
import { ControllerDecorator } from '../../controller/ControllerDecorator';
import { Dispatcher } from '../../event/Dispatcher';
import { Extension } from '../../extension/Extension';
import { AbstractRoute, RouteController, RouteParams, RouteView } from '../../router/AbstractRoute';
import { RouteOptions } from '../../router/Router';
import { RouterEvents } from '../../router/RouterEvents';
import { UnknownParameters } from '../../types';
import { PageHandlerRegistry } from '../handler/PageHandlerRegistry';
import { PageFactory } from '../PageFactory';
import { ManagedPage, PageAction } from '../PageTypes';
import { PageRenderer } from '../renderer/PageRenderer';
import { PageStateManager } from '../state/PageStateManager';
export interface PageManagerDispatcherEvents {
[RouterEvents.AFTER_LOADING_ASYNC_ROUTE]: {
route: InstanceType<typeof AbstractRoute>;
};
[RouterEvents.BEFORE_LOADING_ASYNC_ROUTE]: {
route: InstanceType<typeof AbstractRoute>;
};
}
/**
* Page manager for controller.
*/
export declare abstract class AbstractPageManager extends PageManager {
#private;
/**
* Snapshot of the previously managed page before it was replaced with
* a new one
*/
protected _previousManagedPage: ManagedPage;
/**
* Factory used by the page manager to create instances of the
* controller for the current route, and decorate the controllers and
* page state managers.
*/
protected _pageFactory: PageFactory;
/**
* Details of the currently managed page.
*/
protected _managedPage: ManagedPage;
/**
* The current renderer of the page.
*/
protected _pageRenderer: PageRenderer;
/**
* The current page state manager.
*/
protected _pageStateManager: PageStateManager;
/**
* A registry that holds a list of pre-manage and post-manage handlers.
*/
protected _pageHandlerRegistry: PageHandlerRegistry;
protected _dispatcher: Dispatcher;
/**
* Initializes the page manager.
*
* @param pageFactory Factory used by the page manager to
* create instances of the controller for the current route, and
* decorate the controllers and page state managers.
* @param pageRenderer The current renderer of the page.
* @param pageStateManager The current page state
* manager.
* @param pageHandlerRegistry Instance of HandlerRegistry that
* holds a list of pre-manage and post-manage handlers.
*/
constructor(pageFactory: PageFactory, pageRenderer: PageRenderer, pageStateManager: PageStateManager, pageHandlerRegistry: PageHandlerRegistry, dispatcher: Dispatcher);
/**
* @inheritDoc
*/
init(): void;
/**
* @inheritDoc
*/
preManage(): Promise<void>;
/**
* @inheritDoc
*/
manage({ route, options, params, action }: ManageArgs): Promise<void | import("../PageTypes").PageData>;
postManage(): void;
/**
* @inheritDoc
*/
destroy(): Promise<void>;
protected _constructManagedPageValue(controller: RouteController, view: unknown, route: InstanceType<typeof AbstractRoute>, options: RouteOptions, params: RouteParams, controllerInstance: InstanceType<typeof Controller>, decoratedController: ControllerDecorator, viewInstance: unknown): ManagedPage;
/**
* Creates a cloned version of currently managed page and stores it in
* a helper property.
* Snapshot is used in manager handlers to easily determine differences
* between the current and the previous state.
*/
protected _storeManagedPageSnapshot(): void;
/**
* Clear value from managed page.
*/
protected _getInitialManagedPage(): ManagedPage;
/**
* Removes properties we do not want to propagate outside of the page manager
*
* @param value The managed page object to strip down
*/
protected _stripManagedPageValueForPublic(value: ManagedPage): {
controller: RouteController;
view: unknown;
route: AbstractRoute<string | import("../..").RoutePathExpression>;
options: RouteOptions;
params: RouteParams;
};
/**
* Set page state manager to extension which has restricted rights to set
* global state.
*/
_setRestrictedPageStateManager(extension: Extension, extensionState: UnknownParameters): void;
/**
* For defined extension switches to pageStageManager and clears partial state
* after extension state is loaded.
*/
_switchToPageStateManagerAfterLoaded(extension: Extension, extensionState: UnknownParameters): void;
/**
* Initialize page source so call init method on controller and his
* extensions.
*/
protected _initPageSource(): Promise<void>;
/**
* Initializes managed instance of controller with the provided parameters.
*/
protected _initController(): Promise<void>;
/**
* Initialize extensions for managed instance of controller with the
* provided parameters.
*/
protected _initExtensions(): Promise<void>;
/**
* Iterates over extensions of current controller and switches each one to
* pageStateManager and clears their partial state.
*/
protected _switchToPageStateManager(): void;
/**
* Load page source so call load method on controller and his extensions.
* Merge loaded state and render it.
*/
protected _loadPageSource(): Promise<void | import("../PageTypes").PageData>;
/**
* Load controller state from managed instance of controller.
*/
protected _getLoadedControllerState(): Promise<{}>;
/**
* Load extensions state from managed instance of controller.
*/
protected _getLoadedExtensionsState(controllerState?: UnknownParameters): Promise<UnknownParameters>;
/**
* Activate page source so call activate method on controller and his
* extensions.
*/
protected _activatePageSource(): Promise<void>;
/**
* Activate managed instance of controller.
*/
protected _activateController(): Promise<void>;
/**
* Activate extensions for managed instance of controller.
*/
protected _activateExtensions(): Promise<void>;
/**
* Update page source so call update method on controller and his
* extensions. Merge updated state and render it.
*/
protected _updatePageSource(): Promise<void | import("../PageTypes").PageData>;
/**
* Return updated controller state for current page controller.
*/
protected _getUpdatedControllerState(): {} | Promise<{}>;
/**
* Return updated extensions state for current page controller.
*/
protected _getUpdatedExtensionsState(controllerState?: UnknownParameters): Promise<UnknownParameters>;
/**
* Deactivate page source so call deactivate method on controller and his
* extensions.
*/
protected _deactivatePageSource(): Promise<void>;
/**
* Deactivate last managed instance of controller only If controller was
* activated.
*/
protected _deactivateController(): Promise<void>;
/**
* Deactivate extensions for last managed instance of controller only if
* they were activated.
*/
protected _deactivateExtensions(): Promise<void>;
/**
* Destroy page source so call destroy method on controller and his
* extensions.
*/
protected _destroyPageSource(): Promise<void>;
/**
* Destroy last managed instance of controller.
*/
protected _destroyController(): Promise<void>;
/**
* Destroy extensions for last managed instance of controller.
*
* @protected
* @return {Promise<undefined>}
*/
protected _destroyExtensions(): Promise<void>;
/**
* The method clear state on current rendered component to DOM.
*
* @param options The current route options.
*/
_clearComponentState(options: RouteOptions): void;
/**
* Return true if manager has to update last managed controller and view.
*/
protected _hasOnlyUpdate(controller: RouteController, view: unknown, options: RouteOptions): boolean;
protected _runPreManageHandlers(actualManagedPage: ManagedPage, action: PageAction): Promise<unknown>;
protected _runPostManageHandlers(previousManagedPage: ManagedPage, action: PageAction): Promise<unknown>;
protected getViewController(route: ManagedPage['route']): Promise<{
controller: RouteController;
view: RouteView;
}>;
}
//# sourceMappingURL=AbstractPageManager.d.ts.map