theme-lib
Version:
This is a simple example Angular Library published to npm.
274 lines • 24.8 kB
JavaScript
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
import { ComponentFactoryResolver, Inject, Injectable, Injector, TemplateRef, } from '@angular/core';
import { filter } from 'rxjs/operators';
import { NbComponentPortal, NbOverlayPositionBuilder, NbOverlayService, } from '../cdk/overlay';
import { NbBlockScrollStrategyAdapter } from '../cdk/adapter/block-scroll-strategy-adapter';
import { NB_WINDOW_CONFIG, NB_WINDOW_CONTENT, NB_WINDOW_CONTEXT, NbWindowConfig, NbWindowState, } from './window.options';
import { NbWindowRef } from './window-ref';
import { NbWindowsContainerComponent } from './windows-container.component';
import { NbWindowComponent } from './window.component';
/*
* The `NbWindowService` can be used to open windows.
*
* @stacked-example(Showcase, window/window-showcase.component)
*
* ### Installation
*
* Import `NbWindowModule` to your app module.
* ```ts
* @NgModule({
* imports: [
* // ...
* NbWindowModule.forRoot(config),
* ],
* })
* export class AppModule { }
* ```
*
* If you are using it in a lazy loaded module than you have to install `NbWindowModule.forChild`:
* ```ts
* @NgModule({
* imports: [
* // ...
* NbWindowModule.forChild(config),
* ],
* })
* export class LazyLoadedModule { }
* ```
*
* ### Usage
*
* A new window can be opened by calling the `open` method with a component or template to be loaded
* and an optional configuration.
* `open` method will return `NbWindowRef` that can be used for the further manipulations.
*
* ```ts
* const windowRef = this.windowService.open(MyComponent, { ... });
* ```
*
* `NbWindowRef` gives you ability manipulate opened window.
* Also, you can inject `NbWindowRef` inside provided component which rendered in window.
*
* ```ts
* this.windowService.open(MyWindowComponent, { ... });
*
* // my.component.ts
* constructor(protected windowRef: NbWindowRef) {
* }
*
* minimize() {
* this.windowRef.minimize();
* }
*
* close() {
* this.windowRef.close();
* }
* ```
*
* Instead of component you can create window from TemplateRef. As usual you can access context provided via config
* via `let-` variables. Also you can get reference to the `NbWindowRef` in context's `windowRef` property.
*
* @stacked-example(Window content from TemplateRef, window/template-window.component)
*
* ### Configuration
*
* As mentioned above, `open` method of the `NbWindowService` may receive optional configuration options.
* Also, you can modify default windows configuration through `NbWindowModule.forRoot({ ... })`.
* You can read about all available options on [API tab](docs/components/window/api#nbwindowconfig).
*
* @stacked-example(Configuration, window/windows-backdrop.component)
*/
export class NbWindowService {
/**
* @param {?} componentFactoryResolver
* @param {?} overlayService
* @param {?} overlayPositionBuilder
* @param {?} blockScrollStrategy
* @param {?} defaultWindowsConfig
* @param {?} cfr
*/
constructor(componentFactoryResolver, overlayService, overlayPositionBuilder, blockScrollStrategy, defaultWindowsConfig, cfr) {
this.componentFactoryResolver = componentFactoryResolver;
this.overlayService = overlayService;
this.overlayPositionBuilder = overlayPositionBuilder;
this.blockScrollStrategy = blockScrollStrategy;
this.defaultWindowsConfig = defaultWindowsConfig;
this.cfr = cfr;
this.openWindows = [];
}
/*
* Opens new window.
* @param windowContent
* @param windowConfig
* */
/**
* @param {?} windowContent
* @param {?=} windowConfig
* @return {?}
*/
open(windowContent, windowConfig = {}) {
if (this.windowsContainerViewRef == null) {
this.createWindowsContainer();
}
/** @type {?} */
const config = new NbWindowConfig(this.defaultWindowsConfig, windowConfig);
/** @type {?} */
const windowRef = new NbWindowRef(config);
windowRef.componentRef = this.appendWindow(windowContent, config, windowRef);
this.openWindows.push(windowRef);
this.subscribeToEvents(windowRef);
return windowRef;
}
/**
* @protected
* @return {?}
*/
createWindowsContainer() {
this.overlayRef = this.overlayService.create({
scrollStrategy: this.overlayService.scrollStrategies.noop(),
positionStrategy: this.overlayPositionBuilder.global().bottom().right(),
hasBackdrop: true,
});
/** @type {?} */
const windowsContainerPortal = new NbComponentPortal(NbWindowsContainerComponent, null, null, this.cfr);
/** @type {?} */
const overlayRef = this.overlayRef.attach(windowsContainerPortal);
this.windowsContainerViewRef = overlayRef.instance.viewContainerRef;
}
/**
* @protected
* @param {?} content
* @param {?} config
* @param {?} windowRef
* @return {?}
*/
appendWindow(content, config, windowRef) {
/** @type {?} */
const context = content instanceof TemplateRef
? { $implicit: config.context, windowRef }
: config.context;
/** @type {?} */
const providers = [
{ provide: NB_WINDOW_CONTENT, useValue: content },
{ provide: NB_WINDOW_CONTEXT, useValue: context },
{ provide: NbWindowConfig, useValue: config },
{ provide: NbWindowRef, useValue: windowRef },
];
/** @type {?} */
const parentInjector = config.viewContainerRef
? config.viewContainerRef.injector
: this.windowsContainerViewRef.injector;
/** @type {?} */
const injector = Injector.create({ parent: parentInjector, providers });
/** @type {?} */
const windowFactory = this.componentFactoryResolver.resolveComponentFactory(NbWindowComponent);
/** @type {?} */
const ref = this.windowsContainerViewRef.createComponent(windowFactory, null, injector);
ref.instance.cfr = this.cfr;
ref.changeDetectorRef.detectChanges();
return ref;
}
/**
* @protected
* @param {?} windowRef
* @return {?}
*/
subscribeToEvents(windowRef) {
if (windowRef.config.closeOnBackdropClick) {
this.overlayRef.backdropClick().subscribe(() => windowRef.close());
}
if (windowRef.config.closeOnEsc) {
this.overlayRef.keydownEvents()
.pipe(filter((event) => event.keyCode === 27))
.subscribe(() => windowRef.close());
}
windowRef.stateChange.subscribe(() => this.checkAndUpdateOverlay());
windowRef.onClose.subscribe(() => {
this.openWindows.splice(this.openWindows.indexOf(windowRef), 1);
this.checkAndUpdateOverlay();
});
}
/**
* @protected
* @return {?}
*/
checkAndUpdateOverlay() {
/** @type {?} */
const fullScreenWindows = this.openWindows.filter(w => w.state === NbWindowState.FULL_SCREEN);
if (fullScreenWindows.length > 0) {
this.blockScrollStrategy.enable();
}
else {
this.blockScrollStrategy.disable();
}
if (fullScreenWindows.some(w => w.config.hasBackdrop)) {
this.overlayRef.backdropElement.removeAttribute('hidden');
}
else {
this.overlayRef.backdropElement.setAttribute('hidden', '');
}
}
}
NbWindowService.decorators = [
{ type: Injectable }
];
/** @nocollapse */
NbWindowService.ctorParameters = () => [
{ type: ComponentFactoryResolver },
{ type: NbOverlayService },
{ type: NbOverlayPositionBuilder },
{ type: NbBlockScrollStrategyAdapter },
{ type: NbWindowConfig, decorators: [{ type: Inject, args: [NB_WINDOW_CONFIG,] }] },
{ type: ComponentFactoryResolver }
];
if (false) {
/**
* @type {?}
* @protected
*/
NbWindowService.prototype.overlayRef;
/**
* @type {?}
* @protected
*/
NbWindowService.prototype.windowsContainerViewRef;
/**
* @type {?}
* @protected
*/
NbWindowService.prototype.openWindows;
/**
* @type {?}
* @protected
*/
NbWindowService.prototype.componentFactoryResolver;
/**
* @type {?}
* @protected
*/
NbWindowService.prototype.overlayService;
/**
* @type {?}
* @protected
*/
NbWindowService.prototype.overlayPositionBuilder;
/**
* @type {?}
* @protected
*/
NbWindowService.prototype.blockScrollStrategy;
/**
* @type {?}
* @protected
*/
NbWindowService.prototype.defaultWindowsConfig;
/**
* @type {?}
* @protected
*/
NbWindowService.prototype.cfr;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"window.service.js","sourceRoot":"ng://theme-lib/","sources":["lib/components/window/window.service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n  ComponentFactoryResolver,\r\n  ComponentRef,\r\n  Inject,\r\n  Injectable,\r\n  Injector,\r\n  TemplateRef,\r\n  ViewContainerRef,\r\n} from '@angular/core';\r\nimport { filter } from 'rxjs/operators';\r\nimport {\r\n  NbComponentPortal,\r\n  NbComponentType,\r\n  NbOverlayPositionBuilder,\r\n  NbOverlayRef,\r\n  NbOverlayService,\r\n} from '../cdk/overlay';\r\nimport { NbBlockScrollStrategyAdapter } from '../cdk/adapter/block-scroll-strategy-adapter';\r\nimport {\r\n  NB_WINDOW_CONFIG,\r\n  NB_WINDOW_CONTENT,\r\n  NB_WINDOW_CONTEXT,\r\n  NbWindowConfig,\r\n  NbWindowState,\r\n} from './window.options';\r\nimport { NbWindowRef } from './window-ref';\r\nimport { NbWindowsContainerComponent } from './windows-container.component';\r\nimport { NbWindowComponent } from './window.component';\r\n\r\n/*\r\n * The `NbWindowService` can be used to open windows.\r\n *\r\n * @stacked-example(Showcase, window/window-showcase.component)\r\n *\r\n * ### Installation\r\n *\r\n * Import `NbWindowModule` to your app module.\r\n * ```ts\r\n * @NgModule({\r\n *   imports: [\r\n *   \t// ...\r\n *     NbWindowModule.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 `NbWindowModule.forChild`:\r\n * ```ts\r\n * @NgModule({\r\n *   imports: [\r\n *   \t// ...\r\n *     NbWindowModule.forChild(config),\r\n *   ],\r\n * })\r\n * export class LazyLoadedModule { }\r\n * ```\r\n *\r\n * ### Usage\r\n *\r\n * A new window can be opened by calling the `open` method with a component or template to be loaded\r\n * and an optional configuration.\r\n * `open` method will return `NbWindowRef` that can be used for the further manipulations.\r\n *\r\n * ```ts\r\n * const windowRef = this.windowService.open(MyComponent, { ... });\r\n * ```\r\n *\r\n * `NbWindowRef` gives you ability manipulate opened window.\r\n * Also, you can inject `NbWindowRef` inside provided component which rendered in window.\r\n *\r\n * ```ts\r\n * this.windowService.open(MyWindowComponent, { ... });\r\n *\r\n * // my.component.ts\r\n * constructor(protected windowRef: NbWindowRef) {\r\n * }\r\n *\r\n * minimize() {\r\n *   this.windowRef.minimize();\r\n * }\r\n *\r\n * close() {\r\n *   this.windowRef.close();\r\n * }\r\n * ```\r\n *\r\n * Instead of component you can create window from TemplateRef. As usual you can access context provided via config\r\n * via `let-` variables. Also you can get reference to the `NbWindowRef` in context's `windowRef` property.\r\n *\r\n * @stacked-example(Window content from TemplateRef, window/template-window.component)\r\n *\r\n * ### Configuration\r\n *\r\n * As mentioned above, `open` method of the `NbWindowService` may receive optional configuration options.\r\n * Also, you can modify default windows configuration through `NbWindowModule.forRoot({ ... })`.\r\n * You can read about all available options on [API tab](docs/components/window/api#nbwindowconfig).\r\n *\r\n * @stacked-example(Configuration, window/windows-backdrop.component)\r\n */\r\n@Injectable()\r\nexport class NbWindowService {\r\n\r\n  protected overlayRef: NbOverlayRef;\r\n  protected windowsContainerViewRef: ViewContainerRef;\r\n  protected openWindows: NbWindowRef[] = [];\r\n\r\n  constructor(\r\n    protected componentFactoryResolver: ComponentFactoryResolver,\r\n    protected overlayService: NbOverlayService,\r\n    protected overlayPositionBuilder: NbOverlayPositionBuilder,\r\n    protected blockScrollStrategy: NbBlockScrollStrategyAdapter,\r\n    @Inject(NB_WINDOW_CONFIG) protected readonly defaultWindowsConfig: NbWindowConfig,\r\n    protected cfr: ComponentFactoryResolver,\r\n  ) {\r\n  }\r\n\r\n  /*\r\n   * Opens new window.\r\n   * @param windowContent\r\n   * @param windowConfig\r\n   * */\r\n  open(\r\n    windowContent: TemplateRef<any> | NbComponentType,\r\n    windowConfig: Partial<NbWindowConfig> = {},\r\n  ): NbWindowRef {\r\n    if (this.windowsContainerViewRef == null) {\r\n      this.createWindowsContainer();\r\n    }\r\n\r\n    const config = new NbWindowConfig(this.defaultWindowsConfig, windowConfig);\r\n    const windowRef = new NbWindowRef(config);\r\n    windowRef.componentRef = this.appendWindow(windowContent, config, windowRef);\r\n\r\n    this.openWindows.push(windowRef);\r\n    this.subscribeToEvents(windowRef);\r\n\r\n    return windowRef;\r\n  }\r\n\r\n  protected createWindowsContainer() {\r\n    this.overlayRef = this.overlayService.create({\r\n      scrollStrategy: this.overlayService.scrollStrategies.noop(),\r\n      positionStrategy: this.overlayPositionBuilder.global().bottom().right(),\r\n      hasBackdrop: true,\r\n    });\r\n    const windowsContainerPortal = new NbComponentPortal(NbWindowsContainerComponent, null, null, this.cfr);\r\n    const overlayRef = this.overlayRef.attach(windowsContainerPortal);\r\n    this.windowsContainerViewRef = overlayRef.instance.viewContainerRef;\r\n  }\r\n\r\n  protected appendWindow(\r\n    content: TemplateRef<any> | NbComponentType,\r\n    config: NbWindowConfig,\r\n    windowRef: NbWindowRef,\r\n  ): ComponentRef<NbWindowComponent> {\r\n    const context = content instanceof TemplateRef\r\n      ? { $implicit: config.context, windowRef }\r\n      : config.context;\r\n\r\n    const providers = [\r\n      { provide: NB_WINDOW_CONTENT, useValue: content },\r\n      { provide: NB_WINDOW_CONTEXT, useValue: context },\r\n      { provide: NbWindowConfig, useValue: config },\r\n      { provide: NbWindowRef, useValue: windowRef },\r\n    ];\r\n    const parentInjector = config.viewContainerRef\r\n      ? config.viewContainerRef.injector\r\n      : this.windowsContainerViewRef.injector;\r\n    const injector = Injector.create({ parent: parentInjector, providers });\r\n    const windowFactory = this.componentFactoryResolver.resolveComponentFactory(NbWindowComponent);\r\n\r\n    const ref = this.windowsContainerViewRef.createComponent(windowFactory, null, injector);\r\n    ref.instance.cfr = this.cfr;\r\n    ref.changeDetectorRef.detectChanges();\r\n    return ref\r\n  }\r\n\r\n  protected subscribeToEvents(windowRef: NbWindowRef) {\r\n    if (windowRef.config.closeOnBackdropClick) {\r\n      this.overlayRef.backdropClick().subscribe(() => windowRef.close());\r\n    }\r\n\r\n    if (windowRef.config.closeOnEsc) {\r\n      this.overlayRef.keydownEvents()\r\n        .pipe(filter((event: KeyboardEvent) => event.keyCode === 27))\r\n        .subscribe(() => windowRef.close());\r\n    }\r\n\r\n    windowRef.stateChange.subscribe(() => this.checkAndUpdateOverlay());\r\n\r\n    windowRef.onClose.subscribe(() => {\r\n      this.openWindows.splice(this.openWindows.indexOf(windowRef), 1);\r\n      this.checkAndUpdateOverlay();\r\n    });\r\n  }\r\n\r\n  protected checkAndUpdateOverlay() {\r\n    const fullScreenWindows = this.openWindows.filter(w => w.state === NbWindowState.FULL_SCREEN);\r\n    if (fullScreenWindows.length > 0) {\r\n      this.blockScrollStrategy.enable();\r\n    } else {\r\n      this.blockScrollStrategy.disable();\r\n    }\r\n\r\n    if (fullScreenWindows.some(w => w.config.hasBackdrop)) {\r\n      this.overlayRef.backdropElement.removeAttribute('hidden');\r\n    } else {\r\n      this.overlayRef.backdropElement.setAttribute('hidden', '');\r\n    }\r\n  }\r\n}\r\n"]}