gentics-ui-core
Version:
This is the common core framework for the Gentics CMS and Mesh UI, and other Angular applications.
266 lines • 31.2 kB
JavaScript
import { ComponentFactoryResolver, Injectable, Optional, SkipSelf } from '@angular/core';
import { OverlayHostService } from '../overlay-host/overlay-host.service';
import { DynamicModalWrapper } from './dynamic-modal-wrapper.component';
import { ModalDialog } from './modal-dialog.component';
import { BlankModal } from './blank-modal.component';
import * as i0 from "@angular/core";
import * as i1 from "../overlay-host/overlay-host.service";
/**
* A promise-based service for creating modal windows and dialogs.
* Depends on the [`<gtx-overlay-host>`](#/overlay-host) being present in the app.
*
* ## Return Values
* All the public methods return the `IModalInstance` object:
*
* ```
* interface IModalInstance {
* instance: IModalDialog;
* element: HTMLElement;
* open: () => Promise<any>;
* }
* ```
* Calling the `open()` method returns a promise which will be resolved when the modal is closed
* or rejected when a button is set to `shouldReject` or the modal calls the passed error handler.
*
* ## `.dialog()`
* To create a basic dialog modal, use the `.dialog()` method. This accepts an `IDialogConfig` object:
*
* ```TypeScript
* interface IDialogConfig {
* title: string;
* body?: string;
* buttons: {
* label: string;
* type?: 'default' | 'secondary' | 'success'| 'warning' | 'alert';
* flat?: boolean;
* // If specified, will be returned as the
* // value of the resolved promise (or the reason if rejected).
* returnValue?: any;
* // If true, clicking the button will cause
* // the promise to reject rather than resolve
* shouldReject?: boolean;
* }[];
* ```
*
* Example:
* ```TypeScript
* modalService.dialog({
* title: 'Are you sure?',
* body: 'Do you <em>really</em> want to delete this thing?',
* buttons: [
* { label: 'Delete', type: 'alert', returnValue: true },
* { label: 'Cancel', type: 'secondary', shouldReject: true }
* ]
* }).then(modal => modal.open())
* .then(result => console.log('deleting...'))
* .catch(() => console.log('cancelled');
* ```
*
* ## `.fromComponent()`
* For more complex modals, a component can be passed to the `.fromComponent()` method which will then be
* placed inside a modal window. The component must implement the IModalDialog interface, which allows the
* ModalService to hook into a `closeFn` & `cancelFn` so it knows to close the modal and resolve the promise.
* To forward errors from the modal to the caller, implement `registerErrorFn` from the IModalDialog interface.
*
* Example:
* ```TypeScript
* @Component({
* selector: 'my-modal-form',
* template: '...' // some big form
* })
* export class MyModalForm implements IModalDialog {
* // IModalDialog interface members
* closeFn: (val: any) => void;
* cancelFn: (val?: any) => void;
* registerCloseFn(close: (val: any) => void): void {
* this.closeFn = close;
* }
* registerCancelFn(cancel: (val?: any) => void): void {
* this.cancelFn = cancel;
* }
*
* someLocalVariable: string;
*
* // Bound to the form's submit event.
* onSubmitClick() : void {
* this.closeFn(this.form.value);
* }
*
* // Bound to the "cancel" button in the template
* onCancelClick(): void {
* this.cancelFn();
* }
* }
* ```
* The above component could then be used as follows:
* ```TypeScript
* modalService.fromComponent(MyModalForm, {}, { someLocalVariable: 'foo' })
* .then(modal => modal.open())
* .then(result => console.log(result));
* ```
*
* ## Modal Options
* All public methods take an optional options parameter to describe the behavior and appearance of the modal window
* itself:
* ```TypeScript
* interface IModalOptions {
* onOpen?: Function;
* onClose?: Function;
* closeOnOverlayClick?: boolean;
* closeOnEscape?: boolean;
* width?: string;
* padding?: boolean;
* modalBodyClass?: string;
* }
* ```
*/
export class ModalService {
constructor(componentFactoryResolver, overlayHostService, _parentModalService = null) {
this.componentFactoryResolver = componentFactoryResolver;
this._parentModalService = _parentModalService;
this.openModalComponents = [];
this.getHostViewContainer = () => overlayHostService.getHostView();
}
/**
* Returns an array of ComponentRefs for each currently-opened modal.
*/
get openModals() {
return this._parentModalService ? this._parentModalService.openModals : this.openModalComponents;
}
/**
* Create a new modal instance containing the specified component, optionally specifying "locals" which
* will be defined on the component instance with the given value.
*/
fromComponent(component, options, locals) {
let modal = this.wrapComponentInModal(component, options, locals);
return Promise.resolve(modal);
}
/**
* Create a new modal by appending the elementRef to a blank modal window. Primarily used internally
* for the implementation of the declarative [Modal](#/modal) component.
*/
fromElement(elementRef, options) {
return this.wrapComponentInModal(BlankModal, options)
.then(modal => {
modal.element.appendChild(elementRef.nativeElement);
return modal;
});
}
/**
* Creates and displays a standard modal dialog.
*/
dialog(config, options) {
return this.wrapComponentInModal(ModalDialog, options)
.then(modal => {
modal.instance.setConfig(config);
return modal;
});
}
wrapComponentInModal(component, options, locals) {
return this.createModalWrapper(options)
.then(modalWrapper => {
const componentRef = modalWrapper.injectContent(component);
const dialog = componentRef.instance;
if (locals !== undefined) {
for (let key in locals) {
dialog[key] = locals[key];
}
componentRef.changeDetectorRef.markForCheck();
}
this.checkModalDialogInterface(dialog);
return {
instance: dialog,
element: componentRef.location.nativeElement,
open: () => {
this.invokeOnOpenCallback(options);
this.openModals.push(componentRef);
componentRef.onDestroy(() => {
const index = this.openModals.indexOf(componentRef);
if (-1 < index) {
this.openModals.splice(index, 1);
}
});
modalWrapper.open();
return this.createPromiseFromDialog(modalWrapper, dialog);
}
};
});
}
/**
* Ensure that the component passed in implements IModalDialog.
*/
checkModalDialogInterface(dialog) {
const conforms = typeof dialog.registerCancelFn === 'function' && typeof dialog.registerCloseFn === 'function';
if (!conforms) {
throw new Error('ModalService#wrapComponentInModal(): Component must implement IModalDialog.');
}
}
/**
* Creates the DynamicModalWrapper in place in the DOM and returns a reference to the
* created component.
*/
createModalWrapper(options) {
return this.getHostViewContainer()
.then(hostViewContainer => {
let modalFactoryFactory = this.componentFactoryResolver.resolveComponentFactory(DynamicModalWrapper);
if (!hostViewContainer) {
throw new Error('No OverlayHost present, add a <gtx-overlay-host> element!');
}
const ref = hostViewContainer.createComponent(modalFactoryFactory);
return this.getConfiguredModalWrapper(ref, options);
});
}
/**
* Decorate the ModalWrapper instance with the dismissFn and return that instance.
*/
getConfiguredModalWrapper(wrapperComponentRef, options) {
let modalWrapper = wrapperComponentRef.instance;
modalWrapper.dismissFn = () => {
this.invokeOnCloseCallback(options);
wrapperComponentRef.destroy();
};
modalWrapper.setOptions(options);
return modalWrapper;
}
/**
* Returns a promise which is bound to the closeFn and cancelFn of the dialog instance,
* and will be resolved/rejected when either of those methods are invoked.
*/
createPromiseFromDialog(modalWrapper, dialog) {
return new Promise((resolve, reject) => {
dialog.registerCloseFn((value) => {
modalWrapper.dismissFn();
resolve(value);
});
dialog.registerCancelFn((value) => {
modalWrapper.dismissFn();
});
if (dialog.registerErrorFn) {
dialog.registerErrorFn((err) => {
reject(err);
modalWrapper.dismissFn();
});
}
});
}
invokeOnOpenCallback(options) {
if (options && options.onOpen && typeof options.onOpen === 'function') {
options.onOpen();
}
}
invokeOnCloseCallback(options) {
if (options && options.onClose && typeof options.onClose === 'function') {
options.onClose();
}
}
}
/** @nocollapse */ ModalService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ModalService, deps: [{ token: i0.ComponentFactoryResolver }, { token: i1.OverlayHostService }, { token: ModalService, optional: true, skipSelf: true }], target: i0.ɵɵFactoryTarget.Injectable });
/** @nocollapse */ ModalService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ModalService });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ModalService, decorators: [{
type: Injectable
}], ctorParameters: function () { return [{ type: i0.ComponentFactoryResolver }, { type: i1.OverlayHostService }, { type: ModalService, decorators: [{
type: Optional
}, {
type: SkipSelf
}] }]; } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"modal.service.js","sourceRoot":"","sources":["../../../../../src/components/modal/modal.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,wBAAwB,EAExB,UAAU,EAGV,QAAQ,EACR,QAAQ,EACX,MAAM,eAAe,CAAC;AACvB,OAAO,EAAC,kBAAkB,EAAC,MAAM,sCAAsC,CAAC;AACxE,OAAO,EAAC,mBAAmB,EAAC,MAAM,mCAAmC,CAAC;AACtE,OAAO,EAAC,WAAW,EAAC,MAAM,0BAA0B,CAAC;AACrD,OAAO,EAAC,UAAU,EAAC,MAAM,yBAAyB,CAAC;;;AAGnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4GG;AAEH,MAAM,OAAO,YAAY;IAYrB,YAAoB,wBAAkD,EAC1D,kBAAsC,EACN,sBAAoC,IAAI;QAFhE,6BAAwB,GAAxB,wBAAwB,CAA0B;QAE1B,wBAAmB,GAAnB,mBAAmB,CAAqB;QAZ5E,wBAAmB,GAAiC,EAAE,CAAC;QAa3D,IAAI,CAAC,oBAAoB,GAAG,GAAG,EAAE,CAAC,kBAAkB,CAAC,WAAW,EAAE,CAAC;IACvE,CAAC;IAXD;;OAEG;IACH,IAAW,UAAU;QACjB,OAAO,IAAI,CAAC,mBAAmB,CAAC,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC;IACrG,CAAC;IAQD;;;OAGG;IACI,aAAa,CAAyB,SAAkB,EAC1C,OAAuB,EACvB,MAAkC;QACnD,IAAI,KAAK,GAAG,IAAI,CAAC,oBAAoB,CAAC,SAAS,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;QAClE,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAClC,CAAC;IAED;;;OAGG;IACI,WAAW,CAAC,UAAsB,EAAE,OAAuB;QAC9D,OAAO,IAAI,CAAC,oBAAoB,CAAC,UAAU,EAAE,OAAO,CAAC;aAChD,IAAI,CAAC,KAAK,CAAC,EAAE;YACV,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;YACpD,OAAO,KAAK,CAAC;QACjB,CAAC,CAAC,CAAC;IACX,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,MAAqB,EAAE,OAAuB;QACzD,OAAO,IAAI,CAAC,oBAAoB,CAAC,WAAW,EAAE,OAAO,CAAC;aACjD,IAAI,CAAC,KAAK,CAAC,EAAE;YACV,KAAK,CAAC,QAAQ,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;YACjC,OAAO,KAAK,CAAC;QACjB,CAAC,CAAC,CAAC;IACV,CAAC;IAEO,oBAAoB,CAAyB,SAAkB,EAClB,OAAuB,EACvB,MAA+B;QAChF,OAAO,IAAI,CAAC,kBAAkB,CAAI,OAAO,CAAC;aACrC,IAAI,CAAC,YAAY,CAAC,EAAE;YACjB,MAAM,YAAY,GAAG,YAAY,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;YAC3D,MAAM,MAAM,GAAG,YAAY,CAAC,QAAQ,CAAC;YACrC,IAAI,MAAM,KAAK,SAAS,EAAE;gBACtB,KAAK,IAAI,GAAG,IAAI,MAAM,EAAE;oBACb,MAAO,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,GAAG,CAAC,CAAC;iBACrC;gBACD,YAAY,CAAC,iBAAiB,CAAC,YAAY,EAAE,CAAC;aACjD;YACD,IAAI,CAAC,yBAAyB,CAAC,MAAM,CAAC,CAAC;YACvC,OAAO;gBACH,QAAQ,EAAE,MAAa;gBACvB,OAAO,EAAE,YAAY,CAAC,QAAQ,CAAC,aAAa;gBAC5C,IAAI,EAAE,GAAiB,EAAE;oBACrB,IAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,CAAC;oBACnC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;oBACnC,YAAY,CAAC,SAAS,CAAC,GAAG,EAAE;wBACxB,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;wBACpD,IAAI,CAAC,CAAC,GAAG,KAAK,EAAE;4BACZ,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;yBACpC;oBACL,CAAC,CAAC,CAAC;oBACH,YAAY,CAAC,IAAI,EAAE,CAAC;oBACpB,OAAO,IAAI,CAAC,uBAAuB,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;gBAC9D,CAAC;aACJ,CAAC;QACN,CAAC,CAAC,CAAC;IACX,CAAC;IAED;;OAEG;IACK,yBAAyB,CAAC,MAAoB;QAClD,MAAM,QAAQ,GAAG,OAAO,MAAM,CAAC,gBAAgB,KAAK,UAAU,IAAI,OAAO,MAAM,CAAC,eAAe,KAAK,UAAU,CAAC;QAC/G,IAAI,CAAC,QAAQ,EAAE;YACX,MAAM,IAAI,KAAK,CAAC,6EAA6E,CAAC,CAAC;SAClG;IACL,CAAC;IAED;;;OAGG;IACK,kBAAkB,CAAyB,OAAuB;QACtE,OAAO,IAAI,CAAC,oBAAoB,EAAE;aAC7B,IAAI,CAAC,iBAAiB,CAAC,EAAE;YACtB,IAAI,mBAAmB,GAAG,IAAI,CAAC,wBAAwB,CAAC,uBAAuB,CAAC,mBAAmB,CAAC,CAAC;YACrG,IAAI,CAAC,iBAAiB,EAAE;gBACpB,MAAM,IAAI,KAAK,CAAC,2DAA2D,CAAC,CAAC;aAChF;YACD,MAAM,GAAG,GAAG,iBAAiB,CAAC,eAAe,CAAC,mBAAmB,CAAC,CAAC;YACnE,OAAO,IAAI,CAAC,yBAAyB,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;QACxD,CAAC,CAAC,CAAC;IACX,CAAC;IAED;;OAEG;IACK,yBAAyB,CAAyB,mBAAsD,EAC9E,OAAuB;QACrD,IAAI,YAAY,GAAG,mBAAmB,CAAC,QAAQ,CAAC;QAChD,YAAY,CAAC,SAAS,GAAG,GAAG,EAAE;YAC1B,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC,CAAC;YACpC,mBAAmB,CAAC,OAAO,EAAE,CAAC;QAClC,CAAC,CAAC;QACF,YAAY,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QACjC,OAAO,YAAY,CAAC;IACxB,CAAC;IAED;;;OAGG;IACK,uBAAuB,CAAyB,YAAiC,EAAE,MAAoB;QAC3G,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACnC,MAAM,CAAC,eAAe,CAAC,CAAC,KAAU,EAAE,EAAE;gBAClC,YAAY,CAAC,SAAS,EAAE,CAAC;gBACzB,OAAO,CAAC,KAAK,CAAC,CAAC;YACnB,CAAC,CAAC,CAAC;YAEH,MAAM,CAAC,gBAAgB,CAAC,CAAC,KAAU,EAAE,EAAE;gBACnC,YAAY,CAAC,SAAS,EAAE,CAAC;YAC7B,CAAC,CAAC,CAAC;YAEH,IAAI,MAAM,CAAC,eAAe,EAAE;gBACxB,MAAM,CAAC,eAAe,CAAC,CAAC,GAAU,EAAE,EAAE;oBAClC,MAAM,CAAC,GAAG,CAAC,CAAC;oBACZ,YAAY,CAAC,SAAS,EAAE,CAAC;gBAC7B,CAAC,CAAC,CAAC;aACN;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,oBAAoB,CAAC,OAAsB;QAC/C,IAAI,OAAO,IAAI,OAAO,CAAC,MAAM,IAAI,OAAO,OAAO,CAAC,MAAM,KAAK,UAAU,EAAE;YACnE,OAAO,CAAC,MAAM,EAAE,CAAC;SACpB;IACL,CAAC;IAEO,qBAAqB,CAAC,OAAsB;QAChD,IAAI,OAAO,IAAI,OAAO,CAAC,OAAO,IAAI,OAAO,OAAO,CAAC,OAAO,KAAK,UAAU,EAAE;YACrE,OAAO,CAAC,OAAO,EAAE,CAAC;SACrB;IACL,CAAC;;4HA/JQ,YAAY,4FAc4C,YAAY;gIAdpE,YAAY;2FAAZ,YAAY;kBADxB,UAAU;kIAe0D,YAAY;0BAAhE,QAAQ;;0BAAI,QAAQ","sourcesContent":["import {\n    ComponentRef,\n    ComponentFactoryResolver,\n    ElementRef,\n    Injectable,\n    ViewContainerRef,\n    Type,\n    Optional,\n    SkipSelf\n} from '@angular/core';\nimport {OverlayHostService} from '../overlay-host/overlay-host.service';\nimport {DynamicModalWrapper} from './dynamic-modal-wrapper.component';\nimport {ModalDialog} from './modal-dialog.component';\nimport {BlankModal} from './blank-modal.component';\nimport {IModalInstance, IDialogConfig, IModalDialog, IModalOptions} from './modal-interfaces';\n\n/**\n * A promise-based service for creating modal windows and dialogs.\n * Depends on the [`<gtx-overlay-host>`](#/overlay-host) being present in the app.\n *\n * ## Return Values\n * All the public methods return the `IModalInstance` object:\n *\n * ```\n * interface IModalInstance {\n *     instance: IModalDialog;\n *     element: HTMLElement;\n *     open: () => Promise<any>;\n * }\n * ```\n * Calling the `open()` method returns a promise which will be resolved when the modal is closed\n * or rejected when a button is set to `shouldReject` or the modal calls the passed error handler.\n *\n * ## `.dialog()`\n * To create a basic dialog modal, use the `.dialog()` method. This accepts an `IDialogConfig` object:\n *\n * ```TypeScript\n * interface IDialogConfig {\n *   title: string;\n *   body?: string;\n *   buttons: {\n *       label: string;\n *       type?: 'default' | 'secondary' | 'success'| 'warning' | 'alert';\n *       flat?: boolean;\n *       // If specified, will be returned as the\n *       // value of the resolved promise (or the reason if rejected).\n *       returnValue?: any;\n *       // If true, clicking the button will cause\n *       // the promise to reject rather than resolve\n *       shouldReject?: boolean;\n * }[];\n * ```\n *\n * Example:\n * ```TypeScript\n * modalService.dialog({\n *   title: 'Are you sure?',\n *   body: 'Do you <em>really</em> want to delete this thing?',\n *   buttons: [\n *     { label: 'Delete', type: 'alert', returnValue: true },\n *     { label: 'Cancel', type: 'secondary', shouldReject: true }\n *   ]\n * }).then(modal => modal.open())\n *   .then(result => console.log('deleting...'))\n *   .catch(() => console.log('cancelled');\n * ```\n *\n * ## `.fromComponent()`\n * For more complex modals, a component can be passed to the `.fromComponent()` method which will then be\n * placed inside a modal window. The component must implement the IModalDialog interface, which allows the\n * ModalService to hook into a `closeFn` & `cancelFn` so it knows to close the modal and resolve the promise.\n * To forward errors from the modal to the caller, implement `registerErrorFn` from the IModalDialog interface.\n *\n * Example:\n * ```TypeScript\n * @Component({\n *   selector: 'my-modal-form',\n *   template: '...' // some big form\n * })\n * export class MyModalForm implements IModalDialog {\n *   // IModalDialog interface members\n *   closeFn: (val: any) => void;\n *   cancelFn: (val?: any) => void;\n *   registerCloseFn(close: (val: any) => void): void {\n *       this.closeFn = close;\n *   }\n *   registerCancelFn(cancel: (val?: any) => void): void {\n *       this.cancelFn = cancel;\n *   }\n *\n *   someLocalVariable: string;\n *\n *   // Bound to the form's submit event.\n *   onSubmitClick() : void {\n *      this.closeFn(this.form.value);\n *   }\n *\n *   // Bound to the \"cancel\" button in the template\n *   onCancelClick(): void {\n *      this.cancelFn();\n *   }\n * }\n * ```\n * The above component could then be used as follows:\n * ```TypeScript\n * modalService.fromComponent(MyModalForm, {}, { someLocalVariable: 'foo' })\n *   .then(modal => modal.open())\n *   .then(result => console.log(result));\n * ```\n *\n * ## Modal Options\n * All public methods take an optional options parameter to describe the behavior and appearance of the modal window\n * itself:\n * ```TypeScript\n * interface IModalOptions {\n *     onOpen?: Function;\n *     onClose?: Function;\n *     closeOnOverlayClick?: boolean;\n *     closeOnEscape?: boolean;\n *     width?: string;\n *     padding?: boolean;\n *     modalBodyClass?: string;\n * }\n * ```\n */\n@Injectable()\nexport class ModalService {\n\n    private openModalComponents: ComponentRef<IModalDialog>[] = [];\n    private getHostViewContainer: () => Promise<ViewContainerRef>;\n\n    /**\n     * Returns an array of ComponentRefs for each currently-opened modal.\n     */\n    public get openModals(): ComponentRef<IModalDialog>[] {\n        return this._parentModalService ? this._parentModalService.openModals : this.openModalComponents;\n    }\n\n    constructor(private componentFactoryResolver: ComponentFactoryResolver,\n                overlayHostService: OverlayHostService,\n                @Optional() @SkipSelf() private _parentModalService: ModalService = null) {\n        this.getHostViewContainer = () => overlayHostService.getHostView();\n    }\n\n    /**\n     * Create a new modal instance containing the specified component, optionally specifying \"locals\" which\n     * will be defined on the component instance with the given value.\n     */\n    public fromComponent<T extends IModalDialog>(component: Type<T>,\n                         options?: IModalOptions,\n                         locals?: { [K in keyof T]?: T[K] }): Promise<IModalInstance<T>> {\n        let modal = this.wrapComponentInModal(component, options, locals);\n        return Promise.resolve(modal);\n    }\n\n    /**\n     * Create a new modal by appending the elementRef to a blank modal window. Primarily used internally\n     * for the implementation of the declarative [Modal](#/modal) component.\n     */\n    public fromElement(elementRef: ElementRef, options?: IModalOptions): Promise<IModalInstance<BlankModal>> {\n        return this.wrapComponentInModal(BlankModal, options)\n            .then(modal => {\n                modal.element.appendChild(elementRef.nativeElement);\n                return modal;\n            });\n    }\n\n    /**\n     * Creates and displays a standard modal dialog.\n     */\n    public dialog(config: IDialogConfig, options?: IModalOptions): Promise<IModalInstance<ModalDialog>> {\n       return this.wrapComponentInModal(ModalDialog, options)\n           .then(modal => {\n               modal.instance.setConfig(config);\n               return modal;\n           });\n    }\n\n    private wrapComponentInModal<T extends IModalDialog>(component: Type<T>,\n                                                         options?: IModalOptions,\n                                                         locals?: { [key: string]: any }): Promise<IModalInstance<T>> {\n        return this.createModalWrapper<T>(options)\n            .then(modalWrapper => {\n                const componentRef = modalWrapper.injectContent(component);\n                const dialog = componentRef.instance;\n                if (locals !== undefined) {\n                    for (let key in locals) {\n                        (<any> dialog)[key] = locals[key];\n                    }\n                    componentRef.changeDetectorRef.markForCheck();\n                }\n                this.checkModalDialogInterface(dialog);\n                return {\n                    instance: dialog as any,\n                    element: componentRef.location.nativeElement,\n                    open: (): Promise<any> => {\n                        this.invokeOnOpenCallback(options);\n                        this.openModals.push(componentRef);\n                        componentRef.onDestroy(() => {\n                            const index = this.openModals.indexOf(componentRef);\n                            if (-1 < index) {\n                                this.openModals.splice(index, 1);\n                            }\n                        });\n                        modalWrapper.open();\n                        return this.createPromiseFromDialog(modalWrapper, dialog);\n                    }\n                };\n            });\n    }\n\n    /**\n     * Ensure that the component passed in implements IModalDialog.\n     */\n    private checkModalDialogInterface(dialog: IModalDialog): void {\n        const conforms = typeof dialog.registerCancelFn === 'function' && typeof dialog.registerCloseFn === 'function';\n        if (!conforms) {\n            throw new Error('ModalService#wrapComponentInModal(): Component must implement IModalDialog.');\n        }\n    }\n\n    /**\n     * Creates the DynamicModalWrapper in place in the DOM and returns a reference to the\n     * created component.\n     */\n    private createModalWrapper<T extends IModalDialog>(options?: IModalOptions): Promise<DynamicModalWrapper> {\n        return this.getHostViewContainer()\n            .then(hostViewContainer => {\n                let modalFactoryFactory = this.componentFactoryResolver.resolveComponentFactory(DynamicModalWrapper);\n                if (!hostViewContainer) {\n                    throw new Error('No OverlayHost present, add a <gtx-overlay-host> element!');\n                }\n                const ref = hostViewContainer.createComponent(modalFactoryFactory);\n                return this.getConfiguredModalWrapper(ref, options);\n            });\n    }\n\n    /**\n     * Decorate the ModalWrapper instance with the dismissFn and return that instance.\n     */\n    private getConfiguredModalWrapper<T extends IModalDialog>(wrapperComponentRef: ComponentRef<DynamicModalWrapper>,\n                                      options?: IModalOptions): DynamicModalWrapper {\n        let modalWrapper = wrapperComponentRef.instance;\n        modalWrapper.dismissFn = () => {\n            this.invokeOnCloseCallback(options);\n            wrapperComponentRef.destroy();\n        };\n        modalWrapper.setOptions(options);\n        return modalWrapper;\n    }\n\n    /**\n     * Returns a promise which is bound to the closeFn and cancelFn of the dialog instance,\n     * and will be resolved/rejected when either of those methods are invoked.\n     */\n    private createPromiseFromDialog<T extends IModalDialog>(modalWrapper: DynamicModalWrapper, dialog: IModalDialog): Promise<any> {\n        return new Promise((resolve, reject) => {\n            dialog.registerCloseFn((value: any) => {\n                modalWrapper.dismissFn();\n                resolve(value);\n            });\n\n            dialog.registerCancelFn((value: any) => {\n                modalWrapper.dismissFn();\n            });\n\n            if (dialog.registerErrorFn) {\n                dialog.registerErrorFn((err: Error) => {\n                    reject(err);\n                    modalWrapper.dismissFn();\n                });\n            }\n        });\n    }\n\n    private invokeOnOpenCallback(options: IModalOptions): void {\n        if (options && options.onOpen && typeof options.onOpen === 'function') {\n            options.onOpen();\n        }\n    }\n\n    private invokeOnCloseCallback(options: IModalOptions): void {\n        if (options && options.onClose && typeof options.onClose === 'function') {\n            options.onClose();\n        }\n    }\n}\n"]}