theme-lib
Version:
This is a simple example Angular Library published to npm.
424 lines • 32.6 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import * as tslib_1 from "tslib";
/*
* @license
* Copyright Akveo. All Rights Reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*/
import { ComponentFactoryResolver, Inject, Injectable, Injector, TemplateRef } from '@angular/core';
import { fromEvent as observableFromEvent } from 'rxjs';
import { filter } from 'rxjs/operators';
import { NbComponentPortal, NbOverlayService, NbPortalInjector, NbPositionBuilderService, NbTemplatePortal, } from '../cdk';
import { NB_DOCUMENT } from '../../theme.options';
import { NB_DIALOG_CONFIG, NbDialogConfig } from './dialog-config';
import { NbDialogRef } from './dialog-ref';
import { NbDialogContainerComponent } from './dialog-container';
/*
* The `NbDialogService` helps to open dialogs.
*
* @stacked-example(Showcase, dialog/dialog-showcase.component)
*
* A new dialog is opened by calling the `open` method with a component to be loaded and an optional configuration.
* `open` method will return `NbDialogRef` that can be used for the further manipulations.
*
* ### Installation
*
* Import `NbDialogModule.forRoot()` to your app module.
* ```ts
* @NgModule({
* imports: [
* // ...
* NbDialogModule.forRoot(config),
* ],
* })
* export class AppModule { }
* ```
*
* If you are using it in a lazy loaded module than you have to install it with `NbDialogModule.forChild()`:
* ```ts
* @NgModule({
* imports: [
* // ...
* NbDialogModule.forChild(config),
* ],
* })
* export class LazyLoadedModule { }
* ```
*
* ### Usage
*
* ```ts
* const dialogRef = this.dialogService.open(MyDialogComponent, { ... });
* ```
*
* `NbDialogRef` gives capability access reference to the rendered dialog component,
* destroy dialog and some other options described below.
*
* Also, you can inject `NbDialogRef` in dialog component.
*
* ```ts
* this.dialogService.open(MyDialogComponent, { ... });
*
* // my-dialog.component.ts
* constructor(protected dialogRef: NbDialogRef) {
* }
*
* close() {
* this.dialogRef.close();
* }
* ```
*
* Instead of component you can create dialog from TemplateRef:
*
* @stacked-example(Template ref, dialog/dialog-template.component)
*
* The dialog may return result through `NbDialogRef`. Calling component can receive this result with `onClose`
* stream of `NbDialogRef`.
*
* @stacked-example(Result, dialog/dialog-result.component)
*
* ### Configuration
*
* As we mentioned above, `open` method of the `NbDialogService` may receive optional configuration options.
* Also, you can provide global dialogs configuration through `NbDialogModule.forRoot({ ... })`.
*
* This config may contain the following:
*
* `context` - both, template and component may receive data through `config.context` property.
* For components, this data will be assigned through inputs.
* For templates, you can access it inside template as $implicit.
*
* ```ts
* this.dialogService.open(template, { context: 'pass data in template' });
* ```
*
* ```html
* <ng-template let-some-additional-data>
* {{ some-additional-data }}
* <ng-template/>
* ```
*
* `hasBackdrop` - determines is service have to render backdrop under the dialog.
* Default is true.
* @stacked-example(Backdrop, dialog/dialog-has-backdrop.component)
*
* `closeOnBackdropClick` - close dialog on backdrop click if true.
* Default is true.
* @stacked-example(Backdrop click, dialog/dialog-backdrop-click.component)
*
* `closeOnEsc` - close dialog on escape button on the keyboard.
* Default is true.
* @stacked-example(Escape hit, dialog/dialog-esc.component)
*
* `hasScroll` - Disables scroll on content under dialog if true and does nothing otherwise.
* Default is false.
* Please, open dialogs in the separate window and try to scroll.
* @stacked-example(Scroll, dialog/dialog-scroll.component)
*
* `autoFocus` - Focuses dialog automatically after open if true. It's useful to prevent misclicks on
* trigger elements and opening multiple dialogs.
* Default is true.
*
* As you can see, if you open dialog with auto focus dialog will focus first focusable element
* or just blur previously focused automatically.
* Otherwise, without auto focus, the focus will stay on the previously focused element.
* Please, open dialogs in the separate window and try to click on the button without focus
* and then hit space any times. Multiple same dialogs will be opened.
* @stacked-example(Auto focus, dialog/dialog-auto-focus.component)
* */
var NbDialogService = /** @class */ (function () {
function NbDialogService(document, globalConfig, positionBuilder, overlay, injector, cfr) {
this.document = document;
this.globalConfig = globalConfig;
this.positionBuilder = positionBuilder;
this.overlay = overlay;
this.injector = injector;
this.cfr = cfr;
}
/*
* Opens new instance of the dialog, may receive optional config.
* */
/*
* Opens new instance of the dialog, may receive optional config.
* */
/**
* @template T
* @param {?} content
* @param {?=} userConfig
* @return {?}
*/
NbDialogService.prototype.open = /*
* Opens new instance of the dialog, may receive optional config.
* */
/**
* @template T
* @param {?} content
* @param {?=} userConfig
* @return {?}
*/
function (content, userConfig) {
if (userConfig === void 0) { userConfig = {}; }
/** @type {?} */
var config = new NbDialogConfig(tslib_1.__assign({}, this.globalConfig, userConfig));
/** @type {?} */
var overlayRef = this.createOverlay(config);
/** @type {?} */
var dialogRef = new NbDialogRef(overlayRef);
/** @type {?} */
var container = this.createContainer(config, overlayRef);
this.createContent(config, content, container, dialogRef);
this.registerCloseListeners(config, overlayRef, dialogRef);
return dialogRef;
};
/**
* @protected
* @param {?} config
* @return {?}
*/
NbDialogService.prototype.createOverlay = /**
* @protected
* @param {?} config
* @return {?}
*/
function (config) {
/** @type {?} */
var positionStrategy = this.createPositionStrategy();
/** @type {?} */
var scrollStrategy = this.createScrollStrategy(config.hasScroll);
return this.overlay.create({
positionStrategy: positionStrategy,
scrollStrategy: scrollStrategy,
hasBackdrop: config.hasBackdrop,
backdropClass: config.backdropClass,
});
};
/**
* @protected
* @return {?}
*/
NbDialogService.prototype.createPositionStrategy = /**
* @protected
* @return {?}
*/
function () {
return this.positionBuilder
.global()
.centerVertically()
.centerHorizontally();
};
/**
* @protected
* @param {?} hasScroll
* @return {?}
*/
NbDialogService.prototype.createScrollStrategy = /**
* @protected
* @param {?} hasScroll
* @return {?}
*/
function (hasScroll) {
if (hasScroll) {
return this.overlay.scrollStrategies.noop();
}
else {
return this.overlay.scrollStrategies.block();
}
};
/**
* @protected
* @param {?} config
* @param {?} overlayRef
* @return {?}
*/
NbDialogService.prototype.createContainer = /**
* @protected
* @param {?} config
* @param {?} overlayRef
* @return {?}
*/
function (config, overlayRef) {
/** @type {?} */
var injector = new NbPortalInjector(this.createInjector(config), new WeakMap([[NbDialogConfig, config]]));
/** @type {?} */
var containerPortal = new NbComponentPortal(NbDialogContainerComponent, null, injector, this.cfr);
/** @type {?} */
var containerRef = overlayRef.attach(containerPortal);
return containerRef.instance;
};
/**
* @protected
* @template T
* @param {?} config
* @param {?} content
* @param {?} container
* @param {?} dialogRef
* @return {?}
*/
NbDialogService.prototype.createContent = /**
* @protected
* @template T
* @param {?} config
* @param {?} content
* @param {?} container
* @param {?} dialogRef
* @return {?}
*/
function (config, content, container, dialogRef) {
if (content instanceof TemplateRef) {
/** @type {?} */
var portal = this.createTemplatePortal(config, content, dialogRef);
container.attachTemplatePortal(portal);
}
else {
/** @type {?} */
var portal = this.createComponentPortal(config, content, dialogRef);
dialogRef.componentRef = container.attachComponentPortal(portal);
if (config.context) {
Object.assign(dialogRef.componentRef.instance, tslib_1.__assign({}, config.context));
}
}
};
/**
* @protected
* @template T
* @param {?} config
* @param {?} content
* @param {?} dialogRef
* @return {?}
*/
NbDialogService.prototype.createTemplatePortal = /**
* @protected
* @template T
* @param {?} config
* @param {?} content
* @param {?} dialogRef
* @return {?}
*/
function (config, content, dialogRef) {
return new NbTemplatePortal(content, null, (/** @type {?} */ ({ $implicit: config.context, dialogRef: dialogRef })));
};
/*
* We're creating portal with custom injector provided through config or using global injector.
* This approach provides us capability inject `NbDialogRef` in dialog component.
* */
/*
* We're creating portal with custom injector provided through config or using global injector.
* This approach provides us capability inject `NbDialogRef` in dialog component.
* */
/**
* @protected
* @template T
* @param {?} config
* @param {?} content
* @param {?} dialogRef
* @return {?}
*/
NbDialogService.prototype.createComponentPortal = /*
* We're creating portal with custom injector provided through config or using global injector.
* This approach provides us capability inject `NbDialogRef` in dialog component.
* */
/**
* @protected
* @template T
* @param {?} config
* @param {?} content
* @param {?} dialogRef
* @return {?}
*/
function (config, content, dialogRef) {
/** @type {?} */
var injector = this.createInjector(config);
/** @type {?} */
var portalInjector = new NbPortalInjector(injector, new WeakMap([[NbDialogRef, dialogRef]]));
return new NbComponentPortal(content, config.viewContainerRef, portalInjector);
};
/**
* @protected
* @param {?} config
* @return {?}
*/
NbDialogService.prototype.createInjector = /**
* @protected
* @param {?} config
* @return {?}
*/
function (config) {
return config.viewContainerRef && config.viewContainerRef.injector || this.injector;
};
/**
* @protected
* @template T
* @param {?} config
* @param {?} overlayRef
* @param {?} dialogRef
* @return {?}
*/
NbDialogService.prototype.registerCloseListeners = /**
* @protected
* @template T
* @param {?} config
* @param {?} overlayRef
* @param {?} dialogRef
* @return {?}
*/
function (config, overlayRef, dialogRef) {
if (config.closeOnBackdropClick) {
overlayRef.backdropClick().subscribe(function () { return dialogRef.close(); });
}
if (config.closeOnEsc) {
observableFromEvent(this.document, 'keyup')
.pipe(filter(function (event) { return event.keyCode === 27; }))
.subscribe(function () { return dialogRef.close(); });
}
};
NbDialogService.decorators = [
{ type: Injectable }
];
/** @nocollapse */
NbDialogService.ctorParameters = function () { return [
{ type: undefined, decorators: [{ type: Inject, args: [NB_DOCUMENT,] }] },
{ type: undefined, decorators: [{ type: Inject, args: [NB_DIALOG_CONFIG,] }] },
{ type: NbPositionBuilderService },
{ type: NbOverlayService },
{ type: Injector },
{ type: ComponentFactoryResolver }
]; };
return NbDialogService;
}());
export { NbDialogService };
if (false) {
/**
* @type {?}
* @protected
*/
NbDialogService.prototype.document;
/**
* @type {?}
* @protected
*/
NbDialogService.prototype.globalConfig;
/**
* @type {?}
* @protected
*/
NbDialogService.prototype.positionBuilder;
/**
* @type {?}
* @protected
*/
NbDialogService.prototype.overlay;
/**
* @type {?}
* @protected
*/
NbDialogService.prototype.injector;
/**
* @type {?}
* @protected
*/
NbDialogService.prototype.cfr;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog.service.js","sourceRoot":"ng://theme-lib/","sources":["lib/components/dialog/dialog.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\r\n * @license\r\n * Copyright Akveo. All Rights Reserved.\r\n * Licensed under the MIT License. See License.txt in the project root for license information.\r\n */\r\n\r\nimport { ComponentFactoryResolver, Inject, Injectable, Injector, TemplateRef, Type } from '@angular/core';\r\nimport { fromEvent as observableFromEvent } from 'rxjs';\r\nimport { filter } from 'rxjs/operators';\r\n\r\nimport {\r\n  NbComponentPortal,\r\n  NbGlobalPositionStrategy,\r\n  NbOverlayRef,\r\n  NbOverlayService,\r\n  NbPortalInjector,\r\n  NbPositionBuilderService,\r\n  NbScrollStrategy,\r\n  NbTemplatePortal,\r\n} from '../cdk';\r\nimport { NB_DOCUMENT } from '../../theme.options';\r\nimport { NB_DIALOG_CONFIG, NbDialogConfig } from './dialog-config';\r\nimport { NbDialogRef } from './dialog-ref';\r\nimport { NbDialogContainerComponent } from './dialog-container';\r\n\r\n\r\n/*\r\n * The `NbDialogService` helps to open dialogs.\r\n *\r\n * @stacked-example(Showcase, dialog/dialog-showcase.component)\r\n *\r\n * A new dialog is opened by calling the `open` method with a component to be loaded and an optional configuration.\r\n * `open` method will return `NbDialogRef` that can be used for the further manipulations.\r\n *\r\n * ### Installation\r\n *\r\n * Import `NbDialogModule.forRoot()` to your app module.\r\n * ```ts\r\n * @NgModule({\r\n *   imports: [\r\n *   \t// ...\r\n *     NbDialogModule.forRoot(config),\r\n *   ],\r\n * })\r\n * export class AppModule { }\r\n * ```\r\n *\r\n * If you are using it in a lazy loaded module than you have to install it with `NbDialogModule.forChild()`:\r\n * ```ts\r\n * @NgModule({\r\n *   imports: [\r\n *   \t// ...\r\n *     NbDialogModule.forChild(config),\r\n *   ],\r\n * })\r\n * export class LazyLoadedModule { }\r\n * ```\r\n *\r\n * ### Usage\r\n *\r\n * ```ts\r\n * const dialogRef = this.dialogService.open(MyDialogComponent, { ... });\r\n * ```\r\n *\r\n * `NbDialogRef` gives capability access reference to the rendered dialog component,\r\n * destroy dialog and some other options described below.\r\n *\r\n * Also, you can inject `NbDialogRef` in dialog component.\r\n *\r\n * ```ts\r\n * this.dialogService.open(MyDialogComponent, { ... });\r\n *\r\n * // my-dialog.component.ts\r\n * constructor(protected dialogRef: NbDialogRef) {\r\n * }\r\n *\r\n * close() {\r\n *   this.dialogRef.close();\r\n * }\r\n * ```\r\n *\r\n * Instead of component you can create dialog from TemplateRef:\r\n *\r\n * @stacked-example(Template ref, dialog/dialog-template.component)\r\n *\r\n * The dialog may return result through `NbDialogRef`. Calling component can receive this result with `onClose`\r\n * stream of `NbDialogRef`.\r\n *\r\n * @stacked-example(Result, dialog/dialog-result.component)\r\n *\r\n * ### Configuration\r\n *\r\n * As we mentioned above, `open` method of the `NbDialogService` may receive optional configuration options.\r\n * Also, you can provide global dialogs configuration through `NbDialogModule.forRoot({ ... })`.\r\n *\r\n * This config may contain the following:\r\n *\r\n * `context` - both, template and component may receive data through `config.context` property.\r\n * For components, this data will be assigned through inputs.\r\n * For templates, you can access it inside template as $implicit.\r\n *\r\n * ```ts\r\n * this.dialogService.open(template, { context: 'pass data in template' });\r\n * ```\r\n *\r\n * ```html\r\n * <ng-template let-some-additional-data>\r\n *   {{ some-additional-data }}\r\n * <ng-template/>\r\n * ```\r\n *\r\n * `hasBackdrop` - determines is service have to render backdrop under the dialog.\r\n * Default is true.\r\n * @stacked-example(Backdrop, dialog/dialog-has-backdrop.component)\r\n *\r\n * `closeOnBackdropClick` - close dialog on backdrop click if true.\r\n * Default is true.\r\n * @stacked-example(Backdrop click, dialog/dialog-backdrop-click.component)\r\n *\r\n * `closeOnEsc` - close dialog on escape button on the keyboard.\r\n * Default is true.\r\n * @stacked-example(Escape hit, dialog/dialog-esc.component)\r\n *\r\n * `hasScroll` - Disables scroll on content under dialog if true and does nothing otherwise.\r\n * Default is false.\r\n * Please, open dialogs in the separate window and try to scroll.\r\n * @stacked-example(Scroll, dialog/dialog-scroll.component)\r\n *\r\n * `autoFocus` - Focuses dialog automatically after open if true. It's useful to prevent misclicks on\r\n * trigger elements and opening multiple dialogs.\r\n * Default is true.\r\n *\r\n * As you can see, if you open dialog with auto focus dialog will focus first focusable element\r\n * or just blur previously focused automatically.\r\n * Otherwise, without auto focus, the focus will stay on the previously focused element.\r\n * Please, open dialogs in the separate window and try to click on the button without focus\r\n * and then hit space any times. Multiple same dialogs will be opened.\r\n * @stacked-example(Auto focus, dialog/dialog-auto-focus.component)\r\n * */\r\n@Injectable()\r\nexport class NbDialogService {\r\n  constructor(@Inject(NB_DOCUMENT) protected document,\r\n              @Inject(NB_DIALOG_CONFIG) protected globalConfig,\r\n              protected positionBuilder: NbPositionBuilderService,\r\n              protected overlay: NbOverlayService,\r\n              protected injector: Injector,\r\n              protected cfr: ComponentFactoryResolver) {\r\n  }\r\n\r\n  /*\r\n   * Opens new instance of the dialog, may receive optional config.\r\n   * */\r\n  open<T>(content: Type<T> | TemplateRef<T>, userConfig: Partial<NbDialogConfig<T>> = {}): NbDialogRef<T> {\r\n    const config = new NbDialogConfig({ ...this.globalConfig, ...userConfig });\r\n    const overlayRef = this.createOverlay(config);\r\n    const dialogRef = new NbDialogRef<T>(overlayRef);\r\n    const container = this.createContainer(config, overlayRef);\r\n    this.createContent(config, content, container, dialogRef);\r\n\r\n    this.registerCloseListeners(config, overlayRef, dialogRef);\r\n\r\n    return dialogRef;\r\n  }\r\n\r\n  protected createOverlay(config: NbDialogConfig): NbOverlayRef {\r\n    const positionStrategy = this.createPositionStrategy();\r\n    const scrollStrategy = this.createScrollStrategy(config.hasScroll);\r\n\r\n    return this.overlay.create({\r\n      positionStrategy,\r\n      scrollStrategy,\r\n      hasBackdrop: config.hasBackdrop,\r\n      backdropClass: config.backdropClass,\r\n    });\r\n  }\r\n\r\n  protected createPositionStrategy(): NbGlobalPositionStrategy {\r\n    return this.positionBuilder\r\n      .global()\r\n      .centerVertically()\r\n      .centerHorizontally();\r\n  }\r\n\r\n  protected createScrollStrategy(hasScroll: boolean): NbScrollStrategy {\r\n    if (hasScroll) {\r\n      return this.overlay.scrollStrategies.noop();\r\n    } else {\r\n      return this.overlay.scrollStrategies.block();\r\n    }\r\n  }\r\n\r\n  protected createContainer(config: NbDialogConfig, overlayRef: NbOverlayRef): NbDialogContainerComponent {\r\n    const injector = new NbPortalInjector(this.createInjector(config), new WeakMap([[NbDialogConfig, config]]));\r\n    const containerPortal = new NbComponentPortal(NbDialogContainerComponent, null, injector, this.cfr);\r\n    const containerRef = overlayRef.attach(containerPortal);\r\n    return containerRef.instance;\r\n  }\r\n\r\n  protected createContent<T>(config: NbDialogConfig,\r\n                             content: Type<T> | TemplateRef<T>,\r\n                             container: NbDialogContainerComponent,\r\n                             dialogRef: NbDialogRef<T>) {\r\n    if (content instanceof TemplateRef) {\r\n      const portal = this.createTemplatePortal(config, content, dialogRef);\r\n      container.attachTemplatePortal(portal);\r\n    } else {\r\n      const portal = this.createComponentPortal(config, content, dialogRef);\r\n      dialogRef.componentRef = container.attachComponentPortal(portal);\r\n\r\n      if (config.context) {\r\n        Object.assign(dialogRef.componentRef.instance, { ...config.context })\r\n      }\r\n    }\r\n  }\r\n\r\n  protected createTemplatePortal<T>(config: NbDialogConfig,\r\n                                    content: TemplateRef<T>,\r\n                                    dialogRef: NbDialogRef<T>): NbTemplatePortal {\r\n    return new NbTemplatePortal(content, null, <any>{ $implicit: config.context, dialogRef });\r\n  }\r\n\r\n  /*\r\n   * We're creating portal with custom injector provided through config or using global injector.\r\n   * This approach provides us capability inject `NbDialogRef` in dialog component.\r\n   * */\r\n  protected createComponentPortal<T>(config: NbDialogConfig,\r\n                                     content: Type<T>,\r\n                                     dialogRef: NbDialogRef<T>): NbComponentPortal {\r\n    const injector = this.createInjector(config);\r\n    const portalInjector = new NbPortalInjector(injector, new WeakMap([[NbDialogRef, dialogRef]]));\r\n    return new NbComponentPortal(content, config.viewContainerRef, portalInjector);\r\n  }\r\n\r\n  protected createInjector(config: NbDialogConfig): Injector {\r\n    return config.viewContainerRef && config.viewContainerRef.injector || this.injector;\r\n  }\r\n\r\n  protected registerCloseListeners<T>(config: NbDialogConfig, overlayRef: NbOverlayRef, dialogRef: NbDialogRef<T>) {\r\n    if (config.closeOnBackdropClick) {\r\n      overlayRef.backdropClick().subscribe(() => dialogRef.close());\r\n    }\r\n\r\n    if (config.closeOnEsc) {\r\n      observableFromEvent(this.document, 'keyup')\r\n        .pipe(filter((event: KeyboardEvent) => event.keyCode === 27))\r\n        .subscribe(() => dialogRef.close());\r\n    }\r\n  }\r\n}\r\n"]}