@datarailsshared/datarailsshared 1.4.569 → 1.5.3

package/esm2022/lib/drawer/drawer-container.component.mjs

@@ -0,0 +1,179 @@
+import { FocusMonitor, FocusTrapFactory, InteractivityChecker } from '@angular/cdk/a11y';
+import { CdkDialogContainer, DialogModule } from '@angular/cdk/dialog';
+import { OverlayRef } from '@angular/cdk/overlay';
+import { CdkPortalOutlet, PortalModule } from '@angular/cdk/portal';
+import { CommonModule, DOCUMENT } from '@angular/common';
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ElementRef, EventEmitter, inject, Inject, NgZone, Optional, ViewChild, ViewEncapsulation, } from '@angular/core';
+import { MatCommonModule } from '@angular/material/core';
+import { distinctUntilChanged, finalize, fromEvent, map, Subject, switchMap, takeUntil, tap } from 'rxjs';
+import { drDrawerAnimations } from './drawer-animation';
+import { DrawerConfig } from './drawer-config';
+import { BottomPositionStrategy } from './drawer-position-strategy';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/a11y";
+import * as i2 from "./drawer-config";
+import * as i3 from "@angular/cdk/overlay";
+import * as i4 from "@angular/cdk/portal";
+import * as i5 from "@angular/common";
+const _c0 = ["handleRef"];
+function DrawerContainer_div_0_Template(rf, ctx) { if (rf & 1) {
+    i0.ɵɵelement(0, "div", 3, 4);
+} }
+function DrawerContainer_ng_template_2_Template(rf, ctx) { }
+/**
+ * Internal component that wraps user-provided drawer content.
+ * @docs-private
+ */
+export class DrawerContainer extends CdkDialogContainer {
+    get _drawerPosition() {
+        return `dr-drawer-${this._config.position}`;
+    }
+    constructor(elementRef, focusTrapFactory, document, config, checker, ngZone, overlayRef, focusMonitor) {
+        super(elementRef, focusTrapFactory, document, config, checker, ngZone, overlayRef, focusMonitor);
+        this.overlayRef = overlayRef;
+        /** The state of the drawer animations. */
+        this._animationState = 'void';
+        /** Emits whenever the state of the animation changes. */
+        this._animationStateChanged = new EventEmitter();
+        /** Whether the component has been destroyed. */
+        this._destroyed = false;
+        this._changeDetectorRef = inject(ChangeDetectorRef);
+        this.destroy$ = new Subject();
+    }
+    _contentAttached() {
+        // Delegate to the original dialog-container initialization (i.e. saving the
+        // previous element, setting up the focus trap and moving focus to the container).
+        super._contentAttached();
+        this.enter();
+    }
+    /** Begin animation of bottom sheet entrance into view. */
+    enter() {
+        if (!this._destroyed) {
+            this._animationState = 'visible';
+            this._changeDetectorRef.markForCheck();
+            this._changeDetectorRef.detectChanges();
+        }
+    }
+    /** Begin animation of the bottom sheet exiting from view. */
+    exit() {
+        this._elementRef.nativeElement.style.transition = undefined;
+        if (!this._destroyed) {
+            this._animationState = 'hidden';
+            this._changeDetectorRef.markForCheck();
+        }
+    }
+    ngAfterViewInit() {
+        this.positionStrategy = this.resolvePositionStrategy();
+        if (this.positionStrategy) {
+            this.setupDragListener();
+        }
+    }
+    resolvePositionStrategy() {
+        switch (this._config.position) {
+            case 'bottom':
+                return new BottomPositionStrategy();
+        }
+    }
+    setupDragListener() {
+        const mousedown$ = fromEvent(this._handleRef.nativeElement, 'mousedown');
+        const mousemove$ = fromEvent(document, 'mousemove');
+        const mouseup$ = fromEvent(document, 'mouseup');
+        let lastPosition = 0;
+        let initPosition = 0;
+        let currentPosition = 0;
+        const container = this._elementRef.nativeElement;
+        setTimeout(() => {
+            lastPosition = this.getContainerPosition(container);
+            initPosition = lastPosition;
+        });
+        mousedown$
+            .pipe(switchMap(() => mousemove$.pipe(finalize(() => {
+            const container = this._elementRef.nativeElement;
+            if (this.positionStrategy.shouldClose(currentPosition, initPosition, lastPosition)) {
+                this.overlayRef.dispose();
+                return;
+            }
+            container.style.transition = 'transform 0.5s cubic-bezier(0.32, 0.72, 0, 1)';
+            container.style.transform = `translate3d(0px, 0px, 0px)`;
+        }), takeUntil(mouseup$))), map((event) => this.positionStrategy.extractMousePosition(event)), distinctUntilChanged(), tap((position) => {
+            let containerPosition = this.getContainerPosition(container);
+            containerPosition = Math.min(containerPosition, lastPosition);
+            lastPosition = Math.min(containerPosition, lastPosition);
+            currentPosition = position;
+            container.style.transition = 'none';
+            container.style.transform = this.positionStrategy.calculateTransform(position, containerPosition);
+        }), takeUntil(this.destroy$))
+            .subscribe();
+    }
+    getContainerPosition(container) {
+        return this._config.position === 'bottom' || this._config.position === 'top'
+            ? container.getBoundingClientRect().top
+            : container.getBoundingClientRect().left;
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.destroy$.next();
+        this.destroy$.complete();
+        this._destroyed = true;
+    }
+    _onAnimationDone(event) {
+        if (event.toState === 'visible') {
+            this._trapFocus();
+        }
+        this._animationStateChanged.emit(event);
+    }
+    _onAnimationStart(event) {
+        this._animationStateChanged.emit(event);
+    }
+    _captureInitialFocus() { }
+    /** @nocollapse */ static { this.ɵfac = function DrawerContainer_Factory(t) { return new (t || DrawerContainer)(i0.ɵɵdirectiveInject(i0.ElementRef), i0.ɵɵdirectiveInject(i1.FocusTrapFactory), i0.ɵɵdirectiveInject(DOCUMENT, 8), i0.ɵɵdirectiveInject(i2.DrawerConfig), i0.ɵɵdirectiveInject(i1.InteractivityChecker), i0.ɵɵdirectiveInject(i0.NgZone), i0.ɵɵdirectiveInject(i3.OverlayRef), i0.ɵɵdirectiveInject(i1.FocusMonitor)); }; }
+    /** @nocollapse */ static { this.ɵcmp = /** @pureOrBreakMyCode */ i0.ɵɵdefineComponent({ type: DrawerContainer, selectors: [["dr-drawer-container"]], viewQuery: function DrawerContainer_Query(rf, ctx) { if (rf & 1) {
+            i0.ɵɵviewQuery(CdkPortalOutlet, 7);
+            i0.ɵɵviewQuery(_c0, 5);
+        } if (rf & 2) {
+            let _t;
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx._portalOutlet = _t.first);
+            i0.ɵɵqueryRefresh(_t = i0.ɵɵloadQuery()) && (ctx._handleRef = _t.first);
+        } }, hostAttrs: ["tabindex", "-1", 1, "dr-drawer-container"], hostVars: 7, hostBindings: function DrawerContainer_HostBindings(rf, ctx) { if (rf & 1) {
+            i0.ɵɵsyntheticHostListener("@state.start", function DrawerContainer_animation_state_start_HostBindingHandler($event) { return ctx._onAnimationStart($event); })("@state.done", function DrawerContainer_animation_state_done_HostBindingHandler($event) { return ctx._onAnimationDone($event); });
+        } if (rf & 2) {
+            i0.ɵɵhostProperty("id", ctx._config.id);
+            i0.ɵɵattribute("role", ctx._config.role)("aria-modal", ctx._config.isModal)("aria-label", ctx._config.ariaLabel);
+            i0.ɵɵsyntheticHostProperty("@state", ctx._animationState);
+            i0.ɵɵclassMap(ctx._drawerPosition);
+        } }, standalone: true, features: [i0.ɵɵInheritDefinitionFeature, i0.ɵɵStandaloneFeature], decls: 3, vars: 1, consts: [["class", "handle", 4, "ngIf"], [1, "dr-drawer-container__wrapper"], ["cdkPortalOutlet", ""], [1, "handle"], ["handleRef", ""]], template: function DrawerContainer_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵtemplate(0, DrawerContainer_div_0_Template, 2, 0, "div", 0);
+            i0.ɵɵelementStart(1, "div", 1);
+            i0.ɵɵtemplate(2, DrawerContainer_ng_template_2_Template, 0, 0, "ng-template", 2);
+            i0.ɵɵelementEnd();
+        } if (rf & 2) {
+            i0.ɵɵproperty("ngIf", ctx._config.position === "bottom");
+        } }, dependencies: [PortalModule, i4.CdkPortalOutlet, DialogModule, MatCommonModule, CommonModule, i5.NgIf], styles: [".dr-drawer-container{display:flex;flex-direction:column;width:100%;overflow:auto;outline:0;box-sizing:border-box;background-color:#fff;box-shadow:0 4px 14px #d8d9de80}.dr-drawer-container__wrapper{flex:1;overflow:auto}.cdk-high-contrast-active .dr-drawer-container{outline:1px solid}.handle{position:relative;height:24px;cursor:pointer}.handle:after{content:\"\";position:absolute;top:16px;left:50%;transform:translate(-50%,-50%);background-color:#dfe0e3;height:4px;width:64px;border-radius:16px}.dr-drawer-right{transform:translate(100%);border-top-left-radius:16px;border-bottom-left-radius:16px}.dr-drawer-left{transform:translate(-100%);border-top-right-radius:16px;border-bottom-right-radius:16px}.dr-drawer-bottom{transform:translateY(100%);border-top-left-radius:16px;border-top-right-radius:16px}.dr-drawer-top{transform:translateY(-100%);border-bottom-left-radius:16px;border-bottom-right-radius:16px}\n"], encapsulation: 2, data: { animation: [drDrawerAnimations.drawerState] } }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DrawerContainer, [{
+        type: Component,
+        args: [{ selector: 'dr-drawer-container', changeDetection: ChangeDetectionStrategy.Default, encapsulation: ViewEncapsulation.None, animations: [drDrawerAnimations.drawerState], host: {
+                    class: 'dr-drawer-container',
+                    '[class]': '_drawerPosition',
+                    tabindex: '-1',
+                    '[id]': '_config.id',
+                    '[attr.role]': '_config.role',
+                    '[attr.aria-modal]': '_config.isModal',
+                    '[attr.aria-label]': '_config.ariaLabel',
+                    '[@state]': '_animationState',
+                    '(@state.start)': '_onAnimationStart($event)',
+                    '(@state.done)': '_onAnimationDone($event)',
+                }, standalone: true, imports: [PortalModule, DialogModule, MatCommonModule, CommonModule], template: "<div *ngIf=\"_config.position === 'bottom'\" #handleRef class=\"handle\"></div>\n<div class=\"dr-drawer-container__wrapper\">\n    <ng-template cdkPortalOutlet></ng-template>\n</div>\n", styles: [".dr-drawer-container{display:flex;flex-direction:column;width:100%;overflow:auto;outline:0;box-sizing:border-box;background-color:#fff;box-shadow:0 4px 14px #d8d9de80}.dr-drawer-container__wrapper{flex:1;overflow:auto}.cdk-high-contrast-active .dr-drawer-container{outline:1px solid}.handle{position:relative;height:24px;cursor:pointer}.handle:after{content:\"\";position:absolute;top:16px;left:50%;transform:translate(-50%,-50%);background-color:#dfe0e3;height:4px;width:64px;border-radius:16px}.dr-drawer-right{transform:translate(100%);border-top-left-radius:16px;border-bottom-left-radius:16px}.dr-drawer-left{transform:translate(-100%);border-top-right-radius:16px;border-bottom-right-radius:16px}.dr-drawer-bottom{transform:translateY(100%);border-top-left-radius:16px;border-top-right-radius:16px}.dr-drawer-top{transform:translateY(-100%);border-bottom-left-radius:16px;border-bottom-right-radius:16px}\n"] }]
+    }], function () { return [{ type: i0.ElementRef }, { type: i1.FocusTrapFactory }, { type: Document, decorators: [{
+                type: Optional
+            }, {
+                type: Inject,
+                args: [DOCUMENT]
+            }] }, { type: i2.DrawerConfig }, { type: i1.InteractivityChecker }, { type: i0.NgZone }, { type: i3.OverlayRef }, { type: i1.FocusMonitor }]; }, { _portalOutlet: [{
+            type: ViewChild,
+            args: [CdkPortalOutlet, { static: true }]
+        }], _handleRef: [{
+            type: ViewChild,
+            args: ['handleRef']
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drawer-container.component.js","sourceRoot":"","sources":["../../../../../projects/datarailsshared/src/lib/drawer/drawer-container.component.ts","../../../../../projects/datarailsshared/src/lib/drawer/drawer-container.component.html"],"names":[],"mappings":"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","sourcesContent":["import { AnimationEvent } from '@angular/animations';\nimport { FocusMonitor, FocusTrapFactory, InteractivityChecker } from '@angular/cdk/a11y';\nimport { CdkDialogContainer, DialogModule } from '@angular/cdk/dialog';\nimport { OverlayRef } from '@angular/cdk/overlay';\nimport { CdkPortalOutlet, PortalModule } from '@angular/cdk/portal';\nimport { CommonModule, DOCUMENT } from '@angular/common';\nimport {\n    AfterViewInit,\n    ChangeDetectionStrategy,\n    ChangeDetectorRef,\n    Component,\n    ElementRef,\n    EventEmitter,\n    inject,\n    Inject,\n    NgZone,\n    OnDestroy,\n    Optional,\n    ViewChild,\n    ViewEncapsulation,\n} from '@angular/core';\nimport { MatCommonModule } from '@angular/material/core';\nimport { distinctUntilChanged, finalize, fromEvent, map, Subject, switchMap, takeUntil, tap } from 'rxjs';\nimport { drDrawerAnimations } from './drawer-animation';\nimport { DrawerConfig } from './drawer-config';\nimport { BottomPositionStrategy, DrawerPositionStrategy } from './drawer-position-strategy';\n\n/**\n * Internal component that wraps user-provided drawer content.\n * @docs-private\n */\n@Component({\n    selector: 'dr-drawer-container',\n    templateUrl: 'drawer-container.component.html',\n    styleUrls: ['drawer-container.component.scss'],\n    // In Ivy embedded views will be change detected from their declaration place, rather than where\n    // they were stamped out. This means that we can't have the drawer container be OnPush,\n    // because it might cause the sheets that were opened from a template not to be out of date.\n    changeDetection: ChangeDetectionStrategy.Default,\n    encapsulation: ViewEncapsulation.None,\n    animations: [drDrawerAnimations.drawerState],\n    host: {\n        class: 'dr-drawer-container',\n        '[class]': '_drawerPosition',\n        tabindex: '-1',\n        '[id]': '_config.id',\n        '[attr.role]': '_config.role',\n        '[attr.aria-modal]': '_config.isModal',\n        '[attr.aria-label]': '_config.ariaLabel',\n        '[@state]': '_animationState',\n        '(@state.start)': '_onAnimationStart($event)',\n        '(@state.done)': '_onAnimationDone($event)',\n    },\n    standalone: true,\n    imports: [PortalModule, DialogModule, MatCommonModule, CommonModule],\n})\nexport class DrawerContainer extends CdkDialogContainer<DrawerConfig> implements OnDestroy, AfterViewInit {\n    /** The portal outlet inside of this container into which the content will be loaded. */\n    @ViewChild(CdkPortalOutlet, { static: true })\n    _portalOutlet!: CdkPortalOutlet;\n\n    @ViewChild('handleRef')\n    _handleRef!: ElementRef<HTMLDivElement>;\n\n    /** The state of the drawer animations. */\n    _animationState: 'void' | 'visible' | 'hidden' = 'void';\n\n    /** Emits whenever the state of the animation changes. */\n    readonly _animationStateChanged = new EventEmitter<AnimationEvent>();\n\n    /** Whether the component has been destroyed. */\n    private _destroyed = false;\n\n    get _drawerPosition() {\n        return `dr-drawer-${this._config.position}`;\n    }\n\n    private readonly _changeDetectorRef = inject(ChangeDetectorRef);\n\n    private readonly destroy$ = new Subject<void>();\n\n    positionStrategy!: DrawerPositionStrategy;\n\n    constructor(\n        elementRef: ElementRef<HTMLElement>,\n        focusTrapFactory: FocusTrapFactory,\n        @Optional() @Inject(DOCUMENT) document: Document,\n        config: DrawerConfig,\n        checker: InteractivityChecker,\n        ngZone: NgZone,\n        private overlayRef: OverlayRef,\n        focusMonitor?: FocusMonitor,\n    ) {\n        super(elementRef, focusTrapFactory, document, config, checker, ngZone, overlayRef, focusMonitor);\n    }\n\n    protected override _contentAttached(): void {\n        // Delegate to the original dialog-container initialization (i.e. saving the\n        // previous element, setting up the focus trap and moving focus to the container).\n        super._contentAttached();\n\n        this.enter();\n    }\n\n    /** Begin animation of bottom sheet entrance into view. */\n    enter(): void {\n        if (!this._destroyed) {\n            this._animationState = 'visible';\n            this._changeDetectorRef.markForCheck();\n            this._changeDetectorRef.detectChanges();\n        }\n    }\n\n    /** Begin animation of the bottom sheet exiting from view. */\n    exit(): void {\n        (this._elementRef.nativeElement as HTMLElement).style.transition = undefined;\n        if (!this._destroyed) {\n            this._animationState = 'hidden';\n            this._changeDetectorRef.markForCheck();\n        }\n    }\n\n    ngAfterViewInit(): void {\n        this.positionStrategy = this.resolvePositionStrategy();\n        if (this.positionStrategy) {\n            this.setupDragListener();\n        }\n    }\n\n    private resolvePositionStrategy(): DrawerPositionStrategy {\n        switch (this._config.position) {\n            case 'bottom':\n                return new BottomPositionStrategy();\n        }\n    }\n\n    private setupDragListener(): void {\n        const mousedown$ = fromEvent(this._handleRef.nativeElement, 'mousedown');\n        const mousemove$ = fromEvent(document, 'mousemove');\n        const mouseup$ = fromEvent(document, 'mouseup');\n\n        let lastPosition = 0;\n        let initPosition = 0;\n        let currentPosition = 0;\n        const container = this._elementRef.nativeElement as HTMLElement;\n\n        setTimeout(() => {\n            lastPosition = this.getContainerPosition(container);\n            initPosition = lastPosition;\n        });\n\n        mousedown$\n            .pipe(\n                switchMap(() =>\n                    mousemove$.pipe(\n                        finalize(() => {\n                            const container = this._elementRef.nativeElement as HTMLElement;\n                            if (this.positionStrategy.shouldClose(currentPosition, initPosition, lastPosition)) {\n                                this.overlayRef.dispose();\n                                return;\n                            }\n                            container.style.transition = 'transform 0.5s cubic-bezier(0.32, 0.72, 0, 1)';\n                            container.style.transform = `translate3d(0px, 0px, 0px)`;\n                        }),\n                        takeUntil(mouseup$),\n                    ),\n                ),\n                map((event: MouseEvent) => this.positionStrategy.extractMousePosition(event)),\n                distinctUntilChanged(),\n                tap((position) => {\n                    let containerPosition = this.getContainerPosition(container);\n\n                    containerPosition = Math.min(containerPosition, lastPosition);\n                    lastPosition = Math.min(containerPosition, lastPosition);\n                    currentPosition = position;\n\n                    container.style.transition = 'none';\n                    container.style.transform = this.positionStrategy.calculateTransform(position, containerPosition);\n                }),\n                takeUntil(this.destroy$),\n            )\n            .subscribe();\n    }\n\n    private getContainerPosition(container: HTMLElement): number {\n        return this._config.position === 'bottom' || this._config.position === 'top'\n            ? container.getBoundingClientRect().top\n            : container.getBoundingClientRect().left;\n    }\n\n    override ngOnDestroy() {\n        super.ngOnDestroy();\n\n        this.destroy$.next();\n        this.destroy$.complete();\n        this._destroyed = true;\n    }\n\n    _onAnimationDone(event: AnimationEvent) {\n        if (event.toState === 'visible') {\n            this._trapFocus();\n        }\n\n        this._animationStateChanged.emit(event);\n    }\n\n    _onAnimationStart(event: AnimationEvent) {\n        this._animationStateChanged.emit(event);\n    }\n\n    protected override _captureInitialFocus(): void {}\n}\n","<div *ngIf=\"_config.position === 'bottom'\" #handleRef class=\"handle\"></div>\n<div class=\"dr-drawer-container__wrapper\">\n    <ng-template cdkPortalOutlet></ng-template>\n</div>\n"]}

package/esm2022/lib/drawer/drawer-position-strategy.mjs

@@ -0,0 +1,14 @@
+export class BottomPositionStrategy {
+    extractMousePosition(event) {
+        return event.clientY;
+    }
+    calculateTransform(currentPosition, containerPosition) {
+        return currentPosition > containerPosition
+            ? `translate3d(0px, ${currentPosition - containerPosition}px, 0px)`
+            : `translate3d(0px, 0px, 0px)`;
+    }
+    shouldClose(currentPosition, initPosition, lastPosition) {
+        return Math.abs(currentPosition - initPosition) <= currentPosition - lastPosition;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,106 @@
+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);
+            this._afterDismissed.next(this._result);
+            this._afterDismissed.complete();
+        });
+        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) {
+        this._afterDismissed.next(result);
+        this._afterDismissed.complete();
+        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 dismissed. */
+    afterDismissed() {
+        return this._afterDismissed;
+    }
+    /** Gets an observable that is notified when the drawer is finished closing. */
+    afterClosed() {
+        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":"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","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            this._afterDismissed.next(this._result);\n            this._afterDismissed.complete();\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        this._afterDismissed.next(result);\n        this._afterDismissed.complete();\n\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 dismissed. */\n    afterDismissed(): Observable<R | undefined> {\n        return this._afterDismissed;\n    }\n\n    /** Gets an observable that is notified when the drawer is finished closing. */\n    afterClosed(): 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/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhd2VyLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2RhdGFyYWlsc3NoYXJlZC9zcmMvbGliL2RyYXdlci9kcmF3ZXIubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQy9ELE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQzs7QUFPMUMsTUFBTSxPQUFPLFlBQVk7Z0dBQVosWUFBWTtrR0FBWixZQUFZO3VHQUZWLENBQUMsTUFBTSxDQUFDLFlBRlQsZUFBZTs7dUZBSWhCLFlBQVk7Y0FMeEIsUUFBUTtlQUFDO2dCQUNOLE9BQU8sRUFBRSxDQUFDLGVBQWUsQ0FBQztnQkFDMUIsT0FBTyxFQUFFLENBQUMsZUFBZSxDQUFDO2dCQUMxQixTQUFTLEVBQUUsQ0FBQyxNQUFNLENBQUM7YUFDdEI7O3dGQUNZLFlBQVksY0FKWCxlQUFlLGFBQ2YsZUFBZSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBEcmF3ZXJDb250YWluZXIgfSBmcm9tICcuL2RyYXdlci1jb250YWluZXIuY29tcG9uZW50JztcbmltcG9ydCB7IERyYXdlciB9IGZyb20gJy4vZHJhd2VyLnNlcnZpY2UnO1xuXG5ATmdNb2R1bGUoe1xuICAgIGltcG9ydHM6IFtEcmF3ZXJDb250YWluZXJdLFxuICAgIGV4cG9ydHM6IFtEcmF3ZXJDb250YWluZXJdLFxuICAgIHByb3ZpZGVyczogW0RyYXdlcl0sXG59KVxuZXhwb3J0IGNsYXNzIERyYXdlck1vZHVsZSB7fVxuIl19

package/esm2022/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/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2RhdGFyYWlsc3NoYXJlZC9zcmMvbGliL2RyYXdlci9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsaUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2RyYXdlci1jb25maWcnO1xuZXhwb3J0ICogZnJvbSAnLi9kcmF3ZXItY29udGFpbmVyLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2RyYXdlci1yZWYnO1xuZXhwb3J0ICogZnJvbSAnLi9kcmF3ZXIuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2RyYXdlci5tb2R1bGUnO1xuIl19