@datarailsshared/datarailsshared 1.5.520 → 1.5.524

package/esm2022/src/lib/drawer/drawer-ref.mjs

@@ -0,0 +1,98 @@
+import { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';
+import { merge, Subject } from 'rxjs';
+import { filter, take } from 'rxjs/operators';
+/**
+ * Reference to a drawer dispatched from the drawer service.
+ */
+export class DrawerRef {
+    /** Instance of the component making up the content of the drawer. */
+    get instance() {
+        return this._ref.componentInstance;
+    }
+    /**
+     * `ComponentRef` of the component opened into the drawer. Will be
+     * null when the drawer is opened using a `TemplateRef`.
+     */
+    get componentRef() {
+        return this._ref.componentRef;
+    }
+    constructor(_ref, config, containerInstance) {
+        this._ref = _ref;
+        /** Subject for notifying the user that the drawer has been dismissed. */
+        this._afterDismissed = new Subject();
+        /** Subject for notifying the user that the drawer has opened and appeared. */
+        this._afterOpened = new Subject();
+        this.containerInstance = containerInstance;
+        this.disableClose = config.disableClose;
+        this.id = _ref.id;
+        // Emit when opening animation completes
+        containerInstance._animationStateChanged
+            .pipe(filter((event) => event.phaseName === 'done' && event.toState === 'visible'), take(1))
+            .subscribe(() => {
+            this._afterOpened.next();
+            this._afterOpened.complete();
+        });
+        // Dispose overlay when closing animation is complete
+        containerInstance._animationStateChanged
+            .pipe(filter((event) => event.phaseName === 'done' && event.toState === 'hidden'), take(1))
+            .subscribe(() => {
+            clearTimeout(this._closeFallbackTimeout);
+            this._ref.close(this._result);
+        });
+        _ref.overlayRef.detachments().subscribe(() => {
+            this._ref.close(this._result);
+        });
+        merge(this.backdropClick(), this.keydownEvents().pipe(filter((event) => event.keyCode === ESCAPE))).subscribe((event) => {
+            if (!this.disableClose && (event.type !== 'keydown' || !hasModifierKey(event))) {
+                event.preventDefault();
+                this.dismiss();
+            }
+        });
+    }
+    /**
+     * Dismisses the drawer.
+     * @param result Data to be passed back to the drawer opener.
+     */
+    dismiss(result) {
+        if (this.containerInstance && !this._afterDismissed.closed) {
+            // Transition the backdrop in parallel to the drawer.
+            this.containerInstance._animationStateChanged
+                .pipe(filter((event) => event.phaseName === 'start'), take(1))
+                .subscribe((event) => {
+                // The logic that disposes of the overlay depends on the exit animation completing, however
+                // it isn't guaranteed if the parent view is destroyed while it's running. Add a fallback
+                // timeout which will clean everything up if the animation hasn't fired within the specified
+                // amount of time plus 100ms. We don't need to run this outside the NgZone, because for the
+                // vast majority of cases the timeout will have been cleared before it has fired.
+                this._closeFallbackTimeout = setTimeout(() => {
+                    this._ref.close(this._result);
+                }, event.totalTime + 100);
+                this._ref.overlayRef.detachBackdrop();
+            });
+            this._result = result;
+            this.containerInstance.exit();
+            this.containerInstance = null;
+        }
+    }
+    /** Gets an observable that is notified when the drawer is finished closing. */
+    afterDismissed() {
+        return this._ref.closed;
+    }
+    /** Gets an observable that is notified when the drawer has opened and appeared. */
+    afterOpened() {
+        return this._afterOpened;
+    }
+    /**
+     * Gets an observable that emits when the overlay's backdrop has been clicked.
+     */
+    backdropClick() {
+        return this._ref.backdropClick;
+    }
+    /**
+     * Gets an observable that emits when keydown events are targeted on the overlay.
+     */
+    keydownEvents() {
+        return this._ref.keydownEvents;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drawer-ref.js","sourceRoot":"","sources":["../../../../../../projects/datarailsshared/src/lib/drawer/drawer-ref.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC/D,OAAO,EAAE,KAAK,EAAc,OAAO,EAAE,MAAM,MAAM,CAAC;AAClD,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAK9C;;GAEG;AACH,MAAM,OAAO,SAAS;IAClB,qEAAqE;IACrE,IAAI,QAAQ;QACR,OAAO,IAAI,CAAC,IAAI,CAAC,iBAAkB,CAAC;IACxC,CAAC;IAED;;;OAGG;IACH,IAAI,YAAY;QACZ,OAAO,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC;IAClC,CAAC;IA0BD,YACY,IAAqB,EAC7B,MAAoB,EACpB,iBAAkC;QAF1B,SAAI,GAAJ,IAAI,CAAiB;QAbjC,yEAAyE;QACxD,oBAAe,GAAG,IAAI,OAAO,EAAiB,CAAC;QAEhE,8EAA8E;QAC7D,iBAAY,GAAG,IAAI,OAAO,EAAQ,CAAC;QAahD,IAAI,CAAC,iBAAiB,GAAG,iBAAiB,CAAC;QAC3C,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC,YAAY,CAAC;QACxC,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC;QAElB,wCAAwC;QACxC,iBAAiB,CAAC,sBAAsB;aACnC,IAAI,CACD,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,SAAS,KAAK,MAAM,IAAI,KAAK,CAAC,OAAO,KAAK,SAAS,CAAC,EAC5E,IAAI,CAAC,CAAC,CAAC,CACV;aACA,SAAS,CAAC,GAAG,EAAE;YACZ,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;YACzB,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;QACjC,CAAC,CAAC,CAAC;QAEP,qDAAqD;QACrD,iBAAiB,CAAC,sBAAsB;aACnC,IAAI,CACD,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,SAAS,KAAK,MAAM,IAAI,KAAK,CAAC,OAAO,KAAK,QAAQ,CAAC,EAC3E,IAAI,CAAC,CAAC,CAAC,CACV;aACA,SAAS,CAAC,GAAG,EAAE;YACZ,YAAY,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;YACzC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAClC,CAAC,CAAC,CAAC;QAEP,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE;YACzC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAClC,CAAC,CAAC,CAAC;QAEH,KAAK,CAAC,IAAI,CAAC,aAAa,EAAE,EAAE,IAAI,CAAC,aAAa,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,OAAO,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;YACpH,IAAI,CAAC,IAAI,CAAC,YAAY,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,CAAC,cAAc,CAAC,KAAsB,CAAC,CAAC,EAAE;gBAC7F,KAAK,CAAC,cAAc,EAAE,CAAC;gBACvB,IAAI,CAAC,OAAO,EAAE,CAAC;aAClB;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;;OAGG;IACH,OAAO,CAAC,MAAU;QACd,IAAI,IAAI,CAAC,iBAAiB,IAAI,CAAC,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE;YACxD,qDAAqD;YACrD,IAAI,CAAC,iBAAiB,CAAC,sBAAsB;iBACxC,IAAI,CACD,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,SAAS,KAAK,OAAO,CAAC,EAC9C,IAAI,CAAC,CAAC,CAAC,CACV;iBACA,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;gBACjB,2FAA2F;gBAC3F,yFAAyF;gBACzF,4FAA4F;gBAC5F,2FAA2F;gBAC3F,iFAAiF;gBACjF,IAAI,CAAC,qBAAqB,GAAG,UAAU,CAAC,GAAG,EAAE;oBACzC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;gBAClC,CAAC,EAAE,KAAK,CAAC,SAAS,GAAG,GAAG,CAAC,CAAC;gBAE1B,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,cAAc,EAAE,CAAC;YAC1C,CAAC,CAAC,CAAC;YAEP,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;YACtB,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE,CAAC;YAC9B,IAAI,CAAC,iBAAiB,GAAG,IAAK,CAAC;SAClC;IACL,CAAC;IAED,+EAA+E;IAC/E,cAAc;QACV,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC;IAC5B,CAAC;IAED,mFAAmF;IACnF,WAAW;QACP,OAAO,IAAI,CAAC,YAAY,CAAC;IAC7B,CAAC;IAED;;OAEG;IACH,aAAa;QACT,OAAO,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC;IACnC,CAAC;IAED;;OAEG;IACH,aAAa;QACT,OAAO,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC;IACnC,CAAC;CACJ","sourcesContent":["import { DialogRef } from '@angular/cdk/dialog';\nimport { ESCAPE, hasModifierKey } from '@angular/cdk/keycodes';\nimport { merge, Observable, Subject } from 'rxjs';\nimport { filter, take } from 'rxjs/operators';\nimport { DrawerConfig } from './drawer-config';\nimport { DrawerContainer } from './drawer-container.component';\nimport { ComponentRef } from '@angular/core';\n\n/**\n * Reference to a drawer dispatched from the drawer service.\n */\nexport class DrawerRef<T = any, R = any> {\n    /** Instance of the component making up the content of the drawer. */\n    get instance(): T {\n        return this._ref.componentInstance!;\n    }\n\n    /**\n     * `ComponentRef` of the component opened into the drawer. Will be\n     * null when the drawer is opened using a `TemplateRef`.\n     */\n    get componentRef(): ComponentRef<T> | null {\n        return this._ref.componentRef;\n    }\n\n    /**\n     * Instance of the component into which the drawer content is projected.\n     * @docs-private\n     */\n    containerInstance: DrawerContainer;\n\n    /** Whether the user is allowed to close the drawer. */\n    disableClose: boolean | undefined;\n\n    /** Unique ID for the drawer. */\n    id: string;\n\n    /** Subject for notifying the user that the drawer has been dismissed. */\n    private readonly _afterDismissed = new Subject<R | undefined>();\n\n    /** Subject for notifying the user that the drawer has opened and appeared. */\n    private readonly _afterOpened = new Subject<void>();\n\n    /** Result to be passed down to the `afterDismissed` stream. */\n    private _result: R | undefined;\n\n    /** Handle to the timeout that's running as a fallback in case the exit animation doesn't fire. */\n    private _closeFallbackTimeout: any;\n\n    constructor(\n        private _ref: DialogRef<R, T>,\n        config: DrawerConfig,\n        containerInstance: DrawerContainer,\n    ) {\n        this.containerInstance = containerInstance;\n        this.disableClose = config.disableClose;\n        this.id = _ref.id;\n\n        // Emit when opening animation completes\n        containerInstance._animationStateChanged\n            .pipe(\n                filter((event) => event.phaseName === 'done' && event.toState === 'visible'),\n                take(1),\n            )\n            .subscribe(() => {\n                this._afterOpened.next();\n                this._afterOpened.complete();\n            });\n\n        // Dispose overlay when closing animation is complete\n        containerInstance._animationStateChanged\n            .pipe(\n                filter((event) => event.phaseName === 'done' && event.toState === 'hidden'),\n                take(1),\n            )\n            .subscribe(() => {\n                clearTimeout(this._closeFallbackTimeout);\n                this._ref.close(this._result);\n            });\n\n        _ref.overlayRef.detachments().subscribe(() => {\n            this._ref.close(this._result);\n        });\n\n        merge(this.backdropClick(), this.keydownEvents().pipe(filter((event) => event.keyCode === ESCAPE))).subscribe((event) => {\n            if (!this.disableClose && (event.type !== 'keydown' || !hasModifierKey(event as KeyboardEvent))) {\n                event.preventDefault();\n                this.dismiss();\n            }\n        });\n    }\n\n    /**\n     * Dismisses the drawer.\n     * @param result Data to be passed back to the drawer opener.\n     */\n    dismiss(result?: R): void {\n        if (this.containerInstance && !this._afterDismissed.closed) {\n            // Transition the backdrop in parallel to the drawer.\n            this.containerInstance._animationStateChanged\n                .pipe(\n                    filter((event) => event.phaseName === 'start'),\n                    take(1),\n                )\n                .subscribe((event) => {\n                    // The logic that disposes of the overlay depends on the exit animation completing, however\n                    // it isn't guaranteed if the parent view is destroyed while it's running. Add a fallback\n                    // timeout which will clean everything up if the animation hasn't fired within the specified\n                    // amount of time plus 100ms. We don't need to run this outside the NgZone, because for the\n                    // vast majority of cases the timeout will have been cleared before it has fired.\n                    this._closeFallbackTimeout = setTimeout(() => {\n                        this._ref.close(this._result);\n                    }, event.totalTime + 100);\n\n                    this._ref.overlayRef.detachBackdrop();\n                });\n\n            this._result = result;\n            this.containerInstance.exit();\n            this.containerInstance = null!;\n        }\n    }\n\n    /** Gets an observable that is notified when the drawer is finished closing. */\n    afterDismissed(): Observable<R | undefined> {\n        return this._ref.closed;\n    }\n\n    /** Gets an observable that is notified when the drawer has opened and appeared. */\n    afterOpened(): Observable<void> {\n        return this._afterOpened;\n    }\n\n    /**\n     * Gets an observable that emits when the overlay's backdrop has been clicked.\n     */\n    backdropClick(): Observable<MouseEvent> {\n        return this._ref.backdropClick;\n    }\n\n    /**\n     * Gets an observable that emits when keydown events are targeted on the overlay.\n     */\n    keydownEvents(): Observable<KeyboardEvent> {\n        return this._ref.keydownEvents;\n    }\n}\n"]}

package/esm2022/src/lib/drawer/drawer.module.mjs

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { DrawerContainer } from './drawer-container.component';
+import { Drawer } from './drawer.service';
+import * as i0 from "@angular/core";
+export class DrawerModule {
+    /** @nocollapse */ static { this.ɵfac = function DrawerModule_Factory(t) { return new (t || DrawerModule)(); }; }
+    /** @nocollapse */ static { this.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: DrawerModule }); }
+    /** @nocollapse */ static { this.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [Drawer], imports: [DrawerContainer] }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DrawerModule, [{
+        type: NgModule,
+        args: [{
+                imports: [DrawerContainer],
+                exports: [DrawerContainer],
+                providers: [Drawer],
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(DrawerModule, { imports: [DrawerContainer], exports: [DrawerContainer] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhd2VyLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2RhdGFyYWlsc3NoYXJlZC9zcmMvbGliL2RyYXdlci9kcmF3ZXIubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQy9ELE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQzs7QUFPMUMsTUFBTSxPQUFPLFlBQVk7Z0dBQVosWUFBWTtrR0FBWixZQUFZO3VHQUZWLENBQUMsTUFBTSxDQUFDLFlBRlQsZUFBZTs7dUZBSWhCLFlBQVk7Y0FMeEIsUUFBUTtlQUFDO2dCQUNOLE9BQU8sRUFBRSxDQUFDLGVBQWUsQ0FBQztnQkFDMUIsT0FBTyxFQUFFLENBQUMsZUFBZSxDQUFDO2dCQUMxQixTQUFTLEVBQUUsQ0FBQyxNQUFNLENBQUM7YUFDdEI7O3dGQUNZLFlBQVksY0FKWCxlQUFlLGFBQ2YsZUFBZSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBEcmF3ZXJDb250YWluZXIgfSBmcm9tICcuL2RyYXdlci1jb250YWluZXIuY29tcG9uZW50JztcbmltcG9ydCB7IERyYXdlciB9IGZyb20gJy4vZHJhd2VyLnNlcnZpY2UnO1xuXG5ATmdNb2R1bGUoe1xuICAgIGltcG9ydHM6IFtEcmF3ZXJDb250YWluZXJdLFxuICAgIGV4cG9ydHM6IFtEcmF3ZXJDb250YWluZXJdLFxuICAgIHByb3ZpZGVyczogW0RyYXdlcl0sXG59KVxuZXhwb3J0IGNsYXNzIERyYXdlck1vZHVsZSB7fVxuIl19

package/esm2022/src/lib/drawer/drawer.service.mjs

@@ -0,0 +1,140 @@
+import { coerceCssPixelValue } from '@angular/cdk/coercion';
+import { Dialog, DialogConfig } from '@angular/cdk/dialog';
+import { Overlay } from '@angular/cdk/overlay';
+import { Inject, Injectable, InjectionToken, Injector, Optional, SkipSelf } from '@angular/core';
+import { defer, Subject } from 'rxjs';
+import { startWith } from 'rxjs/operators';
+import { DrawerConfig } from './drawer-config';
+import { DrawerContainer } from './drawer-container.component';
+import { DrawerRef } from './drawer-ref';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "./drawer-config";
+/** Injection token that can be used to access the data that was passed in to a drawer. */
+export const DR_DRAWER_DATA = new InjectionToken('DrDrawerData');
+/** Injection token that can be used to specify default drawer options. */
+export const DR_DRAWER_DEFAULT_OPTIONS = new InjectionToken('dr-drawer-default-options');
+// Counter for unique drawer ids.
+let uniqueId = 0;
+/**
+ * Service to trigger Material Design bottom sheets.
+ */
+export class Drawer {
+    /** Keeps track of the currently-open dialogs. */
+    get openDrawers() {
+        return this._parentDrawer ? this._parentDrawer.openDrawers : this._openDrawersAtThisLevel;
+    }
+    /** Stream that emits when a drawer has been opened. */
+    get afterOpened() {
+        return this._parentDrawer ? this._parentDrawer.afterOpened : this._afterOpenedAtThisLevel;
+    }
+    _getAfterAllDismissed() {
+        const parent = this._parentDrawer;
+        return parent ? parent._getAfterAllDismissed() : this._afterAllDismissedAtThisLevel;
+    }
+    constructor(_overlay, _injector, _parentDrawer, _defaultOptions) {
+        this._overlay = _overlay;
+        this._injector = _injector;
+        this._parentDrawer = _parentDrawer;
+        this._defaultOptions = _defaultOptions;
+        this._openDrawersAtThisLevel = [];
+        this._afterAllDismissedAtThisLevel = new Subject();
+        this._afterOpenedAtThisLevel = new Subject();
+        /**
+         * Stream that emits when all open drawer have finished closing.
+         * Will emit on subscribe if there are no open drawers to begin with.
+         */
+        this.afterAllDismissed = defer(() => this.openDrawers.length ? this._getAfterAllDismissed() : this._getAfterAllDismissed().pipe(startWith(undefined)));
+        this._dialog = _injector.get(Dialog);
+    }
+    open(componentOrTemplateRef, config) {
+        let drawerRef;
+        const _config = { ...(this._defaultOptions || new DrawerConfig()), ...config };
+        _config.id = _config.id || `dr-drawer-${uniqueId++}`;
+        _config.width =
+            _config.position === 'left' || _config.position === 'right' ? coerceCssPixelValue(_config.width) : '100vw';
+        _config.height =
+            _config.position === 'top' || _config.position === 'bottom' ? coerceCssPixelValue(_config.height) : '100vh';
+        this._dialog.open(componentOrTemplateRef, {
+            ..._config,
+            // Disable closing since we need to sync it up to the animation ourselves.
+            disableClose: true,
+            // Disable closing on detachments so that we can sync up the animation.
+            closeOnOverlayDetachments: false,
+            container: {
+                type: DrawerContainer,
+                providers: () => [
+                    // Provide our config as the CDK config as well since it has the same interface as the
+                    // CDK one, but it contains the actual values passed in by the user for things like
+                    // `disableClose` which we disable for the CDK dialog since we handle it ourselves.
+                    { provide: DrawerConfig, useValue: _config },
+                    { provide: DialogConfig, useValue: _config },
+                ],
+            },
+            scrollStrategy: _config.scrollStrategy || this._overlay.scrollStrategies.block(),
+            positionStrategy: this._overlay.position().global()[_config.position]('0'),
+            templateContext: () => ({ drawerRef }),
+            providers: (cdkRef, _cdkConfig, container) => {
+                drawerRef = new DrawerRef(cdkRef, _config, container);
+                return [
+                    { provide: DrawerRef, useValue: drawerRef },
+                    { provide: DR_DRAWER_DATA, useValue: _config.data },
+                ];
+            },
+        });
+        this.openDrawers.push(drawerRef);
+        this.afterOpened.next(drawerRef);
+        drawerRef.afterDismissed().subscribe(() => {
+            const index = this.openDrawers.indexOf(drawerRef);
+            if (index > -1) {
+                this.openDrawers.splice(index, 1);
+                if (!this.openDrawers.length) {
+                    this._getAfterAllDismissed().next();
+                }
+            }
+        });
+        return drawerRef;
+    }
+    /**
+     * Dismisses all of the currently-open drawers.
+     */
+    dismissAll() {
+        this._dismissDrawers(this.openDrawers);
+    }
+    /**
+     * Finds an open drawer by its id.
+     * @param id ID to use when looking up the drawer.
+     */
+    getDrawerById(id) {
+        return this.openDrawers.find((drawer) => drawer.id === id);
+    }
+    ngOnDestroy() {
+        // Only dismiss the drawers at this level on destroy
+        // since the parent service may still be active.
+        this._dismissDrawers(this._openDrawersAtThisLevel);
+        this._afterAllDismissedAtThisLevel.complete();
+        this._afterOpenedAtThisLevel.complete();
+    }
+    _dismissDrawers(drawers) {
+        let i = drawers.length;
+        while (i--) {
+            drawers[i].dismiss();
+        }
+    }
+    /** @nocollapse */ static { this.ɵfac = function Drawer_Factory(t) { return new (t || Drawer)(i0.ɵɵinject(i1.Overlay), i0.ɵɵinject(i0.Injector), i0.ɵɵinject(Drawer, 12), i0.ɵɵinject(DR_DRAWER_DEFAULT_OPTIONS, 8)); }; }
+    /** @nocollapse */ static { this.ɵprov = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjectable({ token: Drawer, factory: Drawer.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(Drawer, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: i1.Overlay }, { type: i0.Injector }, { type: Drawer, decorators: [{
+                type: Optional
+            }, {
+                type: SkipSelf
+            }] }, { type: i2.DrawerConfig, decorators: [{
+                type: Optional
+            }, {
+                type: Inject,
+                args: [DR_DRAWER_DEFAULT_OPTIONS]
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drawer.service.js","sourceRoot":"","sources":["../../../../../../projects/datarailsshared/src/lib/drawer/drawer.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { coerceCssPixelValue } from '@angular/cdk/coercion';\nimport { Dialog, DialogConfig } from '@angular/cdk/dialog';\nimport { Overlay } from '@angular/cdk/overlay';\nimport { ComponentType } from '@angular/cdk/portal';\nimport { Inject, Injectable, InjectionToken, Injector, OnDestroy, Optional, SkipSelf, TemplateRef } from '@angular/core';\nimport { defer, Observable, Subject } from 'rxjs';\nimport { startWith } from 'rxjs/operators';\nimport { DrawerConfig } from './drawer-config';\nimport { DrawerContainer } from './drawer-container.component';\nimport { DrawerRef } from './drawer-ref';\n\n/** Injection token that can be used to access the data that was passed in to a drawer. */\nexport const DR_DRAWER_DATA = new InjectionToken<any>('DrDrawerData');\n\n/** Injection token that can be used to specify default drawer options. */\nexport const DR_DRAWER_DEFAULT_OPTIONS = new InjectionToken<DrawerConfig>('dr-drawer-default-options');\n\n// Counter for unique drawer ids.\nlet uniqueId = 0;\n\n/**\n * Service to trigger Material Design bottom sheets.\n */\n@Injectable({ providedIn: 'root' })\nexport class Drawer implements OnDestroy {\n    private readonly _openDrawersAtThisLevel: DrawerRef<any>[] = [];\n    private readonly _afterAllDismissedAtThisLevel = new Subject<void>();\n    private readonly _afterOpenedAtThisLevel = new Subject<DrawerRef<any>>();\n    private _dialog: Dialog;\n\n    /** Keeps track of the currently-open dialogs. */\n    get openDrawers(): DrawerRef[] {\n        return this._parentDrawer ? this._parentDrawer.openDrawers : this._openDrawersAtThisLevel;\n    }\n\n    /** Stream that emits when a drawer has been opened. */\n    get afterOpened(): Subject<DrawerRef<any>> {\n        return this._parentDrawer ? this._parentDrawer.afterOpened : this._afterOpenedAtThisLevel;\n    }\n\n    private _getAfterAllDismissed(): Subject<void> {\n        const parent = this._parentDrawer;\n        return parent ? parent._getAfterAllDismissed() : this._afterAllDismissedAtThisLevel;\n    }\n\n    /**\n     * Stream that emits when all open drawer have finished closing.\n     * Will emit on subscribe if there are no open drawers to begin with.\n     */\n    readonly afterAllDismissed: Observable<void> = defer(() =>\n        this.openDrawers.length ? this._getAfterAllDismissed() : this._getAfterAllDismissed().pipe(startWith(undefined)),\n    );\n\n    constructor(\n        private _overlay: Overlay,\n        private _injector: Injector,\n        @Optional() @SkipSelf() private _parentDrawer: Drawer,\n        @Optional()\n        @Inject(DR_DRAWER_DEFAULT_OPTIONS)\n        private _defaultOptions?: DrawerConfig,\n    ) {\n        this._dialog = _injector.get(Dialog);\n    }\n\n    /**\n     * Opens a drawer containing the given component.\n     * @param component Type of the component to load into the drawer.\n     * @param config Extra configuration options.\n     * @returns Reference to the newly-opened drawer.\n     */\n    open<T, D = any, R = any>(component: ComponentType<T>, config?: DrawerConfig<D>): DrawerRef<T, R>;\n\n    /**\n     * Opens a drawer containing the given template.\n     * @param template TemplateRef to instantiate as the drawer content.\n     * @param config Extra configuration options.\n     * @returns Reference to the newly-opened drawer.\n     */\n    open<T, D = any, R = any>(template: TemplateRef<T>, config?: DrawerConfig<D>): DrawerRef<T, R>;\n\n    open<T, D = any, R = any>(\n        componentOrTemplateRef: ComponentType<T> | TemplateRef<T>,\n        config?: DrawerConfig<D>,\n    ): DrawerRef<T, R> {\n        let drawerRef!: DrawerRef<T, R>;\n\n        const _config = { ...(this._defaultOptions || new DrawerConfig()), ...config };\n        _config.id = _config.id || `dr-drawer-${uniqueId++}`;\n\n        _config.width =\n            _config.position === 'left' || _config.position === 'right' ? coerceCssPixelValue(_config.width) : '100vw';\n\n        _config.height =\n            _config.position === 'top' || _config.position === 'bottom' ? coerceCssPixelValue(_config.height) : '100vh';\n\n        this._dialog.open<R, D, T>(componentOrTemplateRef, {\n            ..._config,\n            // Disable closing since we need to sync it up to the animation ourselves.\n            disableClose: true,\n            // Disable closing on detachments so that we can sync up the animation.\n            closeOnOverlayDetachments: false,\n            container: {\n                type: DrawerContainer,\n                providers: () => [\n                    // Provide our config as the CDK config as well since it has the same interface as the\n                    // CDK one, but it contains the actual values passed in by the user for things like\n                    // `disableClose` which we disable for the CDK dialog since we handle it ourselves.\n                    { provide: DrawerConfig, useValue: _config },\n                    { provide: DialogConfig, useValue: _config },\n                ],\n            },\n            scrollStrategy: _config.scrollStrategy || this._overlay.scrollStrategies.block(),\n            positionStrategy: this._overlay.position().global()[_config.position!]('0'),\n            templateContext: () => ({ drawerRef }),\n            providers: (cdkRef, _cdkConfig, container) => {\n                drawerRef = new DrawerRef(cdkRef, _config, container as DrawerContainer);\n                return [\n                    { provide: DrawerRef, useValue: drawerRef },\n                    { provide: DR_DRAWER_DATA, useValue: _config.data },\n                ];\n            },\n        });\n\n        this.openDrawers.push(drawerRef);\n        this.afterOpened.next(drawerRef);\n\n        drawerRef.afterDismissed().subscribe(() => {\n            const index = this.openDrawers.indexOf(drawerRef);\n\n            if (index > -1) {\n                this.openDrawers.splice(index, 1);\n\n                if (!this.openDrawers.length) {\n                    this._getAfterAllDismissed().next();\n                }\n            }\n        });\n\n        return drawerRef;\n    }\n\n    /**\n     * Dismisses all of the currently-open drawers.\n     */\n    dismissAll(): void {\n        this._dismissDrawers(this.openDrawers);\n    }\n\n    /**\n     * Finds an open drawer by its id.\n     * @param id ID to use when looking up the drawer.\n     */\n    getDrawerById(id: string): DrawerRef<any> | undefined {\n        return this.openDrawers.find((drawer) => drawer.id === id);\n    }\n\n    ngOnDestroy() {\n        // Only dismiss the drawers at this level on destroy\n        // since the parent service may still be active.\n        this._dismissDrawers(this._openDrawersAtThisLevel);\n        this._afterAllDismissedAtThisLevel.complete();\n        this._afterOpenedAtThisLevel.complete();\n    }\n\n    private _dismissDrawers(drawers: DrawerRef<any>[]) {\n        let i = drawers.length;\n\n        while (i--) {\n            drawers[i].dismiss();\n        }\n    }\n}\n"]}

package/esm2022/src/lib/drawer/public-api.mjs

@@ -0,0 +1,6 @@
+export * from './drawer-config';
+export * from './drawer-container.component';
+export * from './drawer-ref';
+export * from './drawer.service';
+export * from './drawer.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2RhdGFyYWlsc3NoYXJlZC9zcmMvbGliL2RyYXdlci9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsaUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2RyYXdlci1jb25maWcnO1xuZXhwb3J0ICogZnJvbSAnLi9kcmF3ZXItY29udGFpbmVyLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2RyYXdlci1yZWYnO1xuZXhwb3J0ICogZnJvbSAnLi9kcmF3ZXIuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2RyYXdlci5tb2R1bGUnO1xuIl19