ngx-modialog-7
Version:
Modal / Dialog for Angular
347 lines • 29.3 kB
JavaScript
/**
* @fileoverview added by tsickle
* Generated from: lib/overlay/overlay.component.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { Component, ElementRef, ViewChild, ViewContainerRef, ViewEncapsulation, Renderer2, TemplateRef, HostListener } from '@angular/core';
import { PromiseCompleter, supportsKey } from '../framework/utils';
import { DialogRef } from '../models/dialog-ref';
import { BaseDynamicComponent } from '../components/index';
// TODO: use DI factory for this.
// TODO: consolidate dup code
/** @type {?} */
const isDoc = !(typeof document === 'undefined' || !document);
/**
* @record
*/
export function EmbedComponentConfig() { }
if (false) {
/** @type {?} */
EmbedComponentConfig.prototype.component;
/** @type {?|undefined} */
EmbedComponentConfig.prototype.projectableNodes;
}
/**
* Represents the modal overlay.
*/
// tslint:disable-next-line:component-class-suffix
export class ModalOverlay extends BaseDynamicComponent {
/**
* @param {?} dialogRef
* @param {?} vcr
* @param {?} el
* @param {?} renderer
*/
constructor(dialogRef, vcr, el, renderer) {
super(el, renderer);
this.dialogRef = dialogRef;
this.vcr = vcr;
this.activateAnimationListener();
}
/**
* \@internal
* @template T
* @param {?} content
* @return {?}
*/
getProjectables(content) {
/** @type {?} */
let nodes;
if (typeof content === 'string') {
nodes = [[this.renderer.createText(`${content}`)]];
}
else if (content instanceof TemplateRef) {
nodes = [this.vcr.createEmbeddedView(content, { $implicit: this.dialogRef.context, dialogRef: this.dialogRef }).rootNodes];
}
else {
nodes = [this.embedComponent({ component: content }).rootNodes];
}
return nodes;
}
/**
* @param {?} config
* @return {?}
*/
embedComponent(config) {
/** @type {?} */
const ctx = (/** @type {?} */ (config));
return this.vcr.createEmbeddedView(this.template, (/** @type {?} */ ({
$implicit: ctx
})));
}
/**
* @template T
* @param {?} type
* @param {?=} projectableNodes
* @return {?}
*/
addComponent(type, projectableNodes = []) {
return super._addComponent({
component: type,
vcRef: this.innerVcr,
projectableNodes
});
}
/**
* @return {?}
*/
fullscreen() {
/** @type {?} */
const style = {
position: 'fixed',
top: 0,
left: 0,
bottom: 0,
right: 0,
'z-index': 1500
};
Object.keys(style).forEach((/**
* @template THIS
* @this {THIS}
* @param {?} k
* @return {THIS}
*/
k => this.setStyle(k, style[k])));
}
/**
* @return {?}
*/
insideElement() {
/** @type {?} */
const style = {
position: 'absolute',
overflow: 'hidden',
width: '100%',
height: '100%',
top: 0,
left: 0,
bottom: 0,
right: 0
};
Object.keys(style).forEach((/**
* @template THIS
* @this {THIS}
* @param {?} k
* @return {THIS}
*/
k => this.setStyle(k, style[k])));
}
/**
* Set a specific inline style for the container of the whole dialog component
* The dialog component root element is the host of this component, it contains only 1 direct
* child which is the container.
*
* Structure:
*
* ```html
* <modal-overlay>
* <div>
* <!-- BACKDROP ELEMENT -->
* <!-- DIALOG CONTAINER ELEMENT -->
* </div>
* </modal-overlay>
* ```
*
* @template THIS
* @this {THIS}
* @param {?} prop The style key
* @param {?} value The value, undefined to remove
* @return {THIS}
*/
setContainerStyle(prop, value) {
(/** @type {?} */ (this)).renderer.setStyle((/** @type {?} */ (this)).container.nativeElement, prop, value);
return (/** @type {?} */ (this));
}
/**
* Define an element that click inside it will not trigger modal close.
* Since events bubble, clicking on a dialog will bubble up to the overlay, a plugin
* must define an element that represent the dialog, the overlay will make sure no to close when
* it was clicked.
* @param {?} element
* @return {?}
*/
setClickBoundary(element) {
/** @type {?} */
let target;
/** @type {?} */
const elListener = (/**
* @param {?} event
* @return {?}
*/
event => target = (/** @type {?} */ (event.target)));
/** @type {?} */
const docListener = (/**
* @param {?} event
* @return {?}
*/
event => {
if (this.dialogRef.context.isBlocking || !this.dialogRef.overlay.isTopMost(this.dialogRef)) {
return;
}
/** @type {?} */
let current = event.target;
// on click, this will hit.
if (current === target) {
return;
}
// on mouse down -> drag -> release the current might not be 'target', it might be
// a sibling or a child (i.e: not part of the tree-up direction). It might also be a release
// outside the dialog... so we compare to the boundary element
do {
if (current === element) {
return;
}
} while (current.parentNode && (current = current.parentNode));
this.dialogRef.dismiss();
});
if (isDoc) {
this.dialogRef.onDestroy.subscribe((/**
* @return {?}
*/
() => {
element.removeEventListener('click', elListener, false);
element.removeEventListener('touchstart', elListener, false);
document.removeEventListener('click', docListener, false);
document.removeEventListener('touchend', docListener, false);
}));
setTimeout((/**
* @return {?}
*/
() => {
element.addEventListener('mousedown', elListener, false);
element.addEventListener('touchstart', docListener, false);
document.addEventListener('click', docListener, false);
document.addEventListener('touchend', docListener, false);
}));
}
}
/**
* Temp workaround for animation where destruction of the top level component does not
* trigger child animations. Solution should be found either in animation module or in design
* of the modal component tree.
* @return {?}
*/
canDestroy() {
/** @type {?} */
const completer = new PromiseCompleter();
if (!Array.isArray(this.beforeDestroyHandlers)) {
completer.resolve();
}
else {
// run destroy notification but protect against halt.
/** @type {?} */
let id = setTimeout((/**
* @return {?}
*/
() => {
id = null;
completer.reject();
}), 1000);
/** @type {?} */
const resolve = (/**
* @return {?}
*/
() => {
if (id === null) {
return;
}
clearTimeout(id);
completer.resolve();
});
Promise.all(this.beforeDestroyHandlers.map((/**
* @param {?} fn
* @return {?}
*/
fn => fn())))
.then(resolve)
.catch(resolve);
}
return completer.promise;
}
/**
* A handler running before destruction of the overlay
* use to delay destruction due to animation.
* This is part of the workaround for animation, see canDestroy.
*
* NOTE: There is no guarantee that the listeners will fire, use dialog.onDestory for that.
* @param {?} fn
* @return {?}
*/
beforeDestroy(fn) {
if (!this.beforeDestroyHandlers) {
this.beforeDestroyHandlers = [];
}
this.beforeDestroyHandlers.push(fn);
}
/**
* @param {?} event
* @return {?}
*/
documentKeypress(event) {
// check that this modal is the last in the stack.
if (!this.dialogRef.overlay.isTopMost(this.dialogRef)) {
return;
}
if (supportsKey(event.keyCode, (/** @type {?} */ (this.dialogRef.context.keyboard)))) {
this.dialogRef.dismiss();
}
}
/**
* @return {?}
*/
ngOnDestroy() {
super.ngOnDestroy();
if (this.dialogRef.destroyed !== true) {
// if we're here the overlay is destroyed by an external event that is not user invoked.
// i.e: The user did no call dismiss or close and dialogRef.destroy() did not invoke.
// this will happen when routing or killing an element containing a blocked overlay (ngIf)
// we bail out, i.e gracefully shutting down.
this.dialogRef.bailOut();
}
}
}
ModalOverlay.decorators = [
{ type: Component, args: [{
// tslint:disable-next-line:component-selector
selector: 'modal-overlay',
encapsulation: ViewEncapsulation.None,
template: "<div #container>\n <ng-template #innerView></ng-template>\n</div>\n<ng-template #template let-ctx>\n <ng-container *ngComponentOutlet=\"ctx.component; injector: ctx.injector; content: ctx.projectableNodes\"></ng-container>\n</ng-template>"
}] }
];
/** @nocollapse */
ModalOverlay.ctorParameters = () => [
{ type: DialogRef },
{ type: ViewContainerRef },
{ type: ElementRef },
{ type: Renderer2 }
];
ModalOverlay.propDecorators = {
container: [{ type: ViewChild, args: ['container', { read: ElementRef, static: true },] }],
innerVcr: [{ type: ViewChild, args: ['innerView', { read: ViewContainerRef, static: true },] }],
template: [{ type: ViewChild, args: ['template', { static: true },] }],
documentKeypress: [{ type: HostListener, args: ['body:keydown', ['$event'],] }]
};
if (false) {
/**
* @type {?}
* @private
*/
ModalOverlay.prototype.beforeDestroyHandlers;
/** @type {?} */
ModalOverlay.prototype.container;
/** @type {?} */
ModalOverlay.prototype.innerVcr;
/** @type {?} */
ModalOverlay.prototype.template;
/**
* @type {?}
* @private
*/
ModalOverlay.prototype.dialogRef;
/**
* @type {?}
* @private
*/
ModalOverlay.prototype.vcr;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"overlay.component.js","sourceRoot":"ng://ngx-modialog-7/","sources":["lib/overlay/overlay.component.ts"],"names":[],"mappings":"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","sourcesContent":["declare const clearTimeout: any;\n\nimport {\n  Component,\n  ComponentRef,\n  ElementRef,\n  EmbeddedViewRef,\n  Injector,\n  ViewChild,\n  ViewContainerRef,\n  ViewEncapsulation,\n  Renderer2,\n  TemplateRef, HostListener\n} from '@angular/core';\n\nimport { PromiseCompleter, supportsKey } from '../framework/utils';\nimport { DialogRef } from '../models/dialog-ref';\nimport { ContainerContent } from '../models/tokens';\nimport { BaseDynamicComponent } from '../components/index';\n\n// TODO: use DI factory for this.\n// TODO: consolidate dup code\nconst isDoc: boolean = !(typeof document === 'undefined' || !document);\n\nexport interface EmbedComponentConfig {\n  component: any;\n  projectableNodes?: any[][];\n}\n\n/**\n * Represents the modal overlay.\n */\n@Component({\n  // tslint:disable-next-line:component-selector\n  selector: 'modal-overlay',\n  encapsulation: ViewEncapsulation.None,\n  templateUrl: './overlay.component.html'\n})\n// tslint:disable-next-line:component-class-suffix\nexport class ModalOverlay extends BaseDynamicComponent {\n  private beforeDestroyHandlers: Array<() => Promise<void>>;\n\n  @ViewChild('container', {read: ElementRef, static: true}) public container: ElementRef;\n  @ViewChild('innerView', {read: ViewContainerRef, static: true }) public innerVcr: ViewContainerRef;\n  @ViewChild('template', { static: true }) public template: TemplateRef<any>;\n\n  constructor(private dialogRef: DialogRef<any>,\n              private vcr: ViewContainerRef,\n              el: ElementRef,\n              renderer: Renderer2) {\n    super(el, renderer);\n    this.activateAnimationListener();\n  }\n\n  /**\n   * @internal\n   */\n  getProjectables<T>(content: ContainerContent): any[][] {\n\n    let nodes: any[];\n    if (typeof content === 'string') {\n      nodes = [[this.renderer.createText(`${content}`)]];\n    } else if (content instanceof TemplateRef) {\n      nodes = [this.vcr.createEmbeddedView(content, {$implicit: this.dialogRef.context, dialogRef: this.dialogRef}).rootNodes];\n    } else {\n      nodes = [this.embedComponent({component: content}).rootNodes];\n    }\n\n    return nodes;\n  }\n\n  embedComponent(config: EmbedComponentConfig): EmbeddedViewRef<EmbedComponentConfig> {\n    const ctx: EmbedComponentConfig & { injector: Injector } = <any>config;\n\n    return this.vcr.createEmbeddedView(this.template, <any>{\n      $implicit: ctx\n    });\n  }\n\n  addComponent<T>(type: any, projectableNodes: any[][] = []): ComponentRef<T> {\n    return super._addComponent<T>({\n      component: type,\n      vcRef: this.innerVcr,\n      projectableNodes\n    });\n  }\n\n  fullscreen(): void {\n    const style = {\n      position: 'fixed',\n      top: 0,\n      left: 0,\n      bottom: 0,\n      right: 0,\n      'z-index': 1500\n    };\n    Object.keys(style).forEach(k => this.setStyle(k, style[k]));\n  }\n\n  insideElement(): void {\n    const style = {\n      position: 'absolute',\n      overflow: 'hidden',\n      width: '100%',\n      height: '100%',\n      top: 0,\n      left: 0,\n      bottom: 0,\n      right: 0\n    };\n    Object.keys(style).forEach(k => this.setStyle(k, style[k]));\n  }\n\n  /**\n   * Set a specific inline style for the container of the whole dialog component\n   * The dialog component root element is the host of this component, it contains only 1 direct\n   * child which is the container.\n   *\n   * Structure:\n   *\n   * ```html\n   * <modal-overlay>\n   *   <div>\n   *     <!-- BACKDROP ELEMENT -->\n   *     <!-- DIALOG CONTAINER ELEMENT -->\n   *   </div>\n   * </modal-overlay>\n   * ```\n   *\n   * @param prop The style key\n   * @param value The value, undefined to remove\n   */\n  setContainerStyle(prop: string, value: string): this {\n    this.renderer.setStyle(this.container.nativeElement, prop, value);\n    return this;\n  }\n\n  /**\n   * Define an element that click inside it will not trigger modal close.\n   * Since events bubble, clicking on a dialog will bubble up to the overlay, a plugin\n   * must define an element that represent the dialog, the overlay will make sure no to close when\n   * it was clicked.\n   * @param element\n   */\n  setClickBoundary(element: Element): void {\n    let target: Element;\n    const elListener = event => target = event.target as any;\n    const docListener = event => {\n      if (this.dialogRef.context.isBlocking || !this.dialogRef.overlay.isTopMost(this.dialogRef)) {\n        return;\n      }\n\n      let current: any = event.target;\n\n      // on click, this will hit.\n      if (current === target) {\n        return;\n      }\n\n      // on mouse down -> drag -> release the current might not be 'target', it might be\n      // a sibling or a child (i.e: not part of the tree-up direction). It might also be a release\n      // outside the dialog... so we compare to the boundary element\n      do {\n        if (current === element) {\n          return;\n        }\n      } while (current.parentNode && (current = current.parentNode));\n      this.dialogRef.dismiss();\n    };\n\n    if (isDoc) {\n      this.dialogRef.onDestroy.subscribe(() => {\n        element.removeEventListener('click', elListener, false);\n        element.removeEventListener('touchstart', elListener, false);\n        document.removeEventListener('click', docListener, false);\n        document.removeEventListener('touchend', docListener, false);\n      });\n\n\n      setTimeout(() => {\n        element.addEventListener('mousedown', elListener, false);\n        element.addEventListener('touchstart', docListener, false);\n        document.addEventListener('click', docListener, false);\n        document.addEventListener('touchend', docListener, false);\n      });\n    }\n  }\n\n  /**\n   * Temp workaround for animation where destruction of the top level component does not\n   * trigger child animations. Solution should be found either in animation module or in design\n   * of the modal component tree.\n   */\n  canDestroy(): Promise<void> {\n    const completer = new PromiseCompleter<void>();\n\n    if (!Array.isArray(this.beforeDestroyHandlers)) {\n      completer.resolve();\n    } else {\n\n      // run destroy notification but protect against halt.\n      let id = setTimeout(() => {\n        id = null;\n        completer.reject();\n      }, 1000);\n\n      const resolve = () => {\n        if (id === null) {\n          return;\n        }\n\n        clearTimeout(id);\n        completer.resolve();\n      };\n\n      Promise.all(this.beforeDestroyHandlers.map(fn => fn()))\n        .then(resolve)\n        .catch(resolve);\n\n    }\n\n    return completer.promise;\n  }\n\n  /**\n   * A handler running before destruction of the overlay\n   * use to delay destruction due to animation.\n   * This is part of the workaround for animation, see canDestroy.\n   *\n   * NOTE: There is no guarantee that the listeners will fire, use dialog.onDestory for that.\n   * @param fn\n   */\n  beforeDestroy(fn: () => Promise<void>) {\n    if (!this.beforeDestroyHandlers) {\n      this.beforeDestroyHandlers = [];\n    }\n    this.beforeDestroyHandlers.push(fn);\n  }\n\n  @HostListener('body:keydown', ['$event'])\n  documentKeypress(event: KeyboardEvent) {\n    // check that this modal is the last in the stack.\n    if (!this.dialogRef.overlay.isTopMost(this.dialogRef)) {\n      return;\n    }\n\n\n    if (supportsKey(event.keyCode, <any>this.dialogRef.context.keyboard)) {\n      this.dialogRef.dismiss();\n    }\n  }\n\n  ngOnDestroy(): void {\n    super.ngOnDestroy();\n    if (this.dialogRef.destroyed !== true) {\n      // if we're here the overlay is destroyed by an external event that is not user invoked.\n      // i.e: The user did no call dismiss or close and dialogRef.destroy() did not invoke.\n      // this will happen when routing or killing an element containing a blocked overlay (ngIf)\n      // we bail out, i.e gracefully shutting down.\n      this.dialogRef.bailOut();\n    }\n  }\n}\n"]}