theme-lib
Version:
This is a simple example Angular Library published to npm.
350 lines • 30 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/*
* @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)
* */
export class NbDialogService {
/**
* @param {?} document
* @param {?} globalConfig
* @param {?} positionBuilder
* @param {?} overlay
* @param {?} injector
* @param {?} cfr
*/
constructor(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.
* */
/**
* @template T
* @param {?} content
* @param {?=} userConfig
* @return {?}
*/
open(content, userConfig = {}) {
/** @type {?} */
const config = new NbDialogConfig(Object.assign({}, this.globalConfig, userConfig));
/** @type {?} */
const overlayRef = this.createOverlay(config);
/** @type {?} */
const dialogRef = new NbDialogRef(overlayRef);
/** @type {?} */
const container = this.createContainer(config, overlayRef);
this.createContent(config, content, container, dialogRef);
this.registerCloseListeners(config, overlayRef, dialogRef);
return dialogRef;
}
/**
* @protected
* @param {?} config
* @return {?}
*/
createOverlay(config) {
/** @type {?} */
const positionStrategy = this.createPositionStrategy();
/** @type {?} */
const scrollStrategy = this.createScrollStrategy(config.hasScroll);
return this.overlay.create({
positionStrategy,
scrollStrategy,
hasBackdrop: config.hasBackdrop,
backdropClass: config.backdropClass,
});
}
/**
* @protected
* @return {?}
*/
createPositionStrategy() {
return this.positionBuilder
.global()
.centerVertically()
.centerHorizontally();
}
/**
* @protected
* @param {?} hasScroll
* @return {?}
*/
createScrollStrategy(hasScroll) {
if (hasScroll) {
return this.overlay.scrollStrategies.noop();
}
else {
return this.overlay.scrollStrategies.block();
}
}
/**
* @protected
* @param {?} config
* @param {?} overlayRef
* @return {?}
*/
createContainer(config, overlayRef) {
/** @type {?} */
const injector = new NbPortalInjector(this.createInjector(config), new WeakMap([[NbDialogConfig, config]]));
/** @type {?} */
const containerPortal = new NbComponentPortal(NbDialogContainerComponent, null, injector, this.cfr);
/** @type {?} */
const containerRef = overlayRef.attach(containerPortal);
return containerRef.instance;
}
/**
* @protected
* @template T
* @param {?} config
* @param {?} content
* @param {?} container
* @param {?} dialogRef
* @return {?}
*/
createContent(config, content, container, dialogRef) {
if (content instanceof TemplateRef) {
/** @type {?} */
const portal = this.createTemplatePortal(config, content, dialogRef);
container.attachTemplatePortal(portal);
}
else {
/** @type {?} */
const portal = this.createComponentPortal(config, content, dialogRef);
dialogRef.componentRef = container.attachComponentPortal(portal);
if (config.context) {
Object.assign(dialogRef.componentRef.instance, Object.assign({}, config.context));
}
}
}
/**
* @protected
* @template T
* @param {?} config
* @param {?} content
* @param {?} dialogRef
* @return {?}
*/
createTemplatePortal(config, content, dialogRef) {
return new NbTemplatePortal(content, null, (/** @type {?} */ ({ $implicit: config.context, 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.
* */
/**
* @protected
* @template T
* @param {?} config
* @param {?} content
* @param {?} dialogRef
* @return {?}
*/
createComponentPortal(config, content, dialogRef) {
/** @type {?} */
const injector = this.createInjector(config);
/** @type {?} */
const portalInjector = new NbPortalInjector(injector, new WeakMap([[NbDialogRef, dialogRef]]));
return new NbComponentPortal(content, config.viewContainerRef, portalInjector);
}
/**
* @protected
* @param {?} config
* @return {?}
*/
createInjector(config) {
return config.viewContainerRef && config.viewContainerRef.injector || this.injector;
}
/**
* @protected
* @template T
* @param {?} config
* @param {?} overlayRef
* @param {?} dialogRef
* @return {?}
*/
registerCloseListeners(config, overlayRef, dialogRef) {
if (config.closeOnBackdropClick) {
overlayRef.backdropClick().subscribe(() => dialogRef.close());
}
if (config.closeOnEsc) {
observableFromEvent(this.document, 'keyup')
.pipe(filter((event) => event.keyCode === 27))
.subscribe(() => dialogRef.close());
}
}
}
NbDialogService.decorators = [
{ type: Injectable }
];
/** @nocollapse */
NbDialogService.ctorParameters = () => [
{ 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 }
];
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"]}