ngx-simple-modal
Version:
A simple unopinionated framework to implement simple modal based behaviour in angular (v2+) projects.
117 lines (116 loc) • 13.5 kB
JavaScript
import * as tslib_1 from "tslib";
import { ApplicationRef, ComponentFactoryResolver, EmbeddedViewRef, Injectable, Injector, Optional, Type, } from '@angular/core';
import { SimpleModalHolderComponent } from './simple-modal-holder.component';
var SimpleModalServiceConfig = /** @class */ (function () {
function SimpleModalServiceConfig() {
this.container = null;
}
return SimpleModalServiceConfig;
}());
export { SimpleModalServiceConfig };
var SimpleModalService = /** @class */ (function () {
/**
* @param {ComponentFactoryResolver} resolver
* @param {ApplicationRef} applicationRef
* @param {Injector} injector
* @param {SimpleModalServiceConfig} config
*/
function SimpleModalService(resolver, applicationRef, injector, config) {
this.resolver = resolver;
this.applicationRef = applicationRef;
this.injector = injector;
if (config) {
this.container = config.container;
}
}
/**
* Adds modal
* @param {Type<SimpleModalComponent<T, T1>>} component
* @param {T?} data
* @param {SimpleModalOptionsOverrides?} options
* @return {Observable<T1>}
*/
SimpleModalService.prototype.addModal = function (component, data, options) {
if (!this.modalHolderComponent) {
this.modalHolderComponent = this.createSimpleModalHolder();
}
return this.modalHolderComponent.addModal(component, data, options);
};
/**
* Hides and removes modal from DOM, resolves promise when fully removed
* @param {SimpleModalComponent} component
* @return {Promise<{}>}
*/
SimpleModalService.prototype.removeModal = function (component) {
if (!this.modalHolderComponent) {
return Promise.resolve({});
}
return this.modalHolderComponent.removeModal(component);
};
/**
* Closes all modals, resolves promise when they're fully removed
* @return {Promise<{}>}
*/
SimpleModalService.prototype.removeAll = function () {
if (!this.modalHolderComponent) {
return Promise.resolve({});
}
return this.modalHolderComponent.removeAllModals();
};
Object.defineProperty(SimpleModalService.prototype, "container", {
get: function () {
if (typeof this._container === 'string') {
this._container = document.getElementById(this._container);
}
if (!this._container && this.applicationRef['components'].length) {
var componentRootViewContainer = this.applicationRef['components'][0];
this.container = componentRootViewContainer.hostView
.rootNodes[0];
}
// fallback
if (!this._container || typeof this._container === 'string') {
this._container = document.getElementsByTagName('body')[0];
}
return this._container;
},
/**
* Accessor for contain - will auto generate from string
* if needed or default to the root element if nothing was set
*/
set: function (c) {
this._container = c;
},
enumerable: true,
configurable: true
});
/**
* Creates and add to DOM modal holder component
* @return {SimpleModalHolderComponent}
*/
SimpleModalService.prototype.createSimpleModalHolder = function () {
var _this = this;
var componentFactory = this.resolver.resolveComponentFactory(SimpleModalHolderComponent);
var componentRef = componentFactory.create(this.injector);
var componentRootNode = componentRef.hostView
.rootNodes[0];
this.applicationRef.attachView(componentRef.hostView);
componentRef.onDestroy(function () {
_this.applicationRef.detachView(componentRef.hostView);
});
this.container.appendChild(componentRootNode);
return componentRef.instance;
};
SimpleModalService.ctorParameters = function () { return [
{ type: ComponentFactoryResolver },
{ type: ApplicationRef },
{ type: Injector },
{ type: SimpleModalServiceConfig, decorators: [{ type: Optional }] }
]; };
SimpleModalService = tslib_1.__decorate([
Injectable(),
tslib_1.__param(3, Optional())
], SimpleModalService);
return SimpleModalService;
}());
export { SimpleModalService };
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"simple-modal.service.js","sourceRoot":"ng://ngx-simple-modal/","sources":["simple-modal/simple-modal.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ApplicationRef,\n  ComponentFactoryResolver,\n  EmbeddedViewRef,\n  Injectable,\n  Injector,\n  Optional,\n  Type,\n} from '@angular/core';\nimport { Observable } from 'rxjs';\n\nimport { SimpleModalHolderComponent } from './simple-modal-holder.component';\nimport { SimpleModalComponent } from './simple-modal.component';\nimport { SimpleModalOptionsOverrides } from './simple-modal-options';\n\nexport class SimpleModalServiceConfig {\n  container: HTMLElement | string = null;\n}\n\n@Injectable()\nexport class SimpleModalService {\n  /**\n   * Placeholder of modals\n   * @type {SimpleModalHolderComponent}\n   */\n  private modalHolderComponent: SimpleModalHolderComponent;\n\n  /**\n   * HTML container for modals\n   * type {HTMLElement | string}\n   */\n  private _container;\n\n  /**\n   * @param {ComponentFactoryResolver} resolver\n   * @param {ApplicationRef} applicationRef\n   * @param {Injector} injector\n   * @param {SimpleModalServiceConfig} config\n   */\n  constructor(\n    private resolver: ComponentFactoryResolver,\n    private applicationRef: ApplicationRef,\n    private injector: Injector,\n    @Optional() config: SimpleModalServiceConfig\n  ) {\n    if (config) {\n      this.container = config.container as any;\n    }\n  }\n\n  /**\n   * Adds modal\n   * @param {Type<SimpleModalComponent<T, T1>>} component\n   * @param {T?} data\n   * @param {SimpleModalOptionsOverrides?} options\n   * @return {Observable<T1>}\n   */\n  addModal<T, T1>(\n    component: Type<SimpleModalComponent<T, T1>>,\n    data?: T,\n    options?: SimpleModalOptionsOverrides\n  ): Observable<T1> {\n    if (!this.modalHolderComponent) {\n      this.modalHolderComponent = this.createSimpleModalHolder();\n    }\n    return this.modalHolderComponent.addModal<T, T1>(component, data, options);\n  }\n\n  /**\n   * Hides and removes modal from DOM, resolves promise when fully removed\n   * @param {SimpleModalComponent} component\n   * @return {Promise<{}>}\n\n   */\n  removeModal(component: SimpleModalComponent<any, any>): Promise<{}> {\n    if (!this.modalHolderComponent) {\n      return Promise.resolve({});\n    }\n    return this.modalHolderComponent.removeModal(component);\n  }\n\n  /**\n   * Closes all modals, resolves promise when they're fully removed\n   * @return {Promise<{}>}\n   */\n  removeAll(): Promise<{}> {\n    if (!this.modalHolderComponent) {\n      return Promise.resolve({});\n    }\n    return this.modalHolderComponent.removeAllModals();\n  }\n\n  /**\n   * Accessor for contain - will auto generate from string\n   * if needed or default to the root element if nothing was set\n   */\n\n  private set container(c) {\n    this._container = c;\n  }\n\n  private get container(): HTMLElement {\n    if (typeof this._container === 'string') {\n      this._container = document.getElementById(this._container);\n    }\n\n    if (!this._container && this.applicationRef['components'].length) {\n      const componentRootViewContainer = this.applicationRef['components'][0];\n      this.container = (componentRootViewContainer.hostView as EmbeddedViewRef<any>)\n        .rootNodes[0] as HTMLElement;\n    }\n\n    // fallback\n    if (!this._container || typeof this._container === 'string') {\n      this._container = document.getElementsByTagName('body')[0];\n    }\n\n    return this._container;\n  }\n\n  /**\n   * Creates and add to DOM modal holder component\n   * @return {SimpleModalHolderComponent}\n   */\n  private createSimpleModalHolder(): SimpleModalHolderComponent {\n    const componentFactory = this.resolver.resolveComponentFactory(SimpleModalHolderComponent);\n\n    const componentRef = componentFactory.create(this.injector);\n    const componentRootNode = (componentRef.hostView as EmbeddedViewRef<any>)\n      .rootNodes[0] as HTMLElement;\n\n    this.applicationRef.attachView(componentRef.hostView);\n\n    componentRef.onDestroy(() => {\n      this.applicationRef.detachView(componentRef.hostView);\n    });\n\n    this.container.appendChild(componentRootNode);\n\n    return componentRef.instance;\n  }\n}\n"]}