@covalent/core 4.0.0-alpha.0 → 4.0.0-beta.1

package/esm2020/dialogs/resizable-draggable-dialog/resizable-draggable-dialog.mjs

@@ -0,0 +1,199 @@
+import { merge, fromEvent } from 'rxjs';
+var corners;
+(function (corners) {
+    corners["topRight"] = "topRight";
+    corners["bottomRight"] = "bottomRight";
+    corners["bottomLeft"] = "bottomLeft";
+    corners["topLeft"] = "topLeft";
+})(corners || (corners = {}));
+var cursors;
+(function (cursors) {
+    cursors["nesw"] = "nesw-resize";
+    cursors["nwse"] = "nwse-resize";
+})(cursors || (cursors = {}));
+var verticalAlignment;
+(function (verticalAlignment) {
+    verticalAlignment["top"] = "top";
+    verticalAlignment["bottom"] = "bottom";
+})(verticalAlignment || (verticalAlignment = {}));
+var horizontalAlignment;
+(function (horizontalAlignment) {
+    horizontalAlignment["right"] = "right";
+    horizontalAlignment["left"] = "left";
+})(horizontalAlignment || (horizontalAlignment = {}));
+const cornerWidth = '16px';
+const offset = '0px';
+const minWidth = 200;
+const minHeight = 200;
+function getPixels(sizeString) {
+    return parseFloat((sizeString || '').replace('px', ''));
+}
+function clamp(min, num, max) {
+    return Math.min(Math.max(num, min), max);
+}
+export class ResizableDraggableDialog {
+    constructor(_document, _renderer2, _dialogRef, _dragRef) {
+        this._document = _document;
+        this._renderer2 = _renderer2;
+        this._dialogRef = _dialogRef;
+        this._dragRef = _dragRef;
+        this.cornerElements = [];
+        this.pointerDownSubs = [];
+        this._initialPositionReset();
+        this._attachCorners();
+    }
+    attach() {
+        this.detach();
+        this._attachCorners();
+    }
+    detach() {
+        this.pointerDownSubs.forEach((sub) => sub.unsubscribe());
+        this.pointerDownSubs = [];
+        this.cornerElements.forEach((elem) => this._renderer2.removeChild(this._getDialogWrapper(), elem));
+        this.cornerElements = [];
+    }
+    _getDialogWrapper() {
+        return (this._document.getElementById(this._dialogRef.id) || {}).parentElement;
+    }
+    _getViewportDimensions() {
+        return this._getDialogWrapper().parentElement.getBoundingClientRect();
+    }
+    _getDialogWrapperDimensions() {
+        const dimensions = getComputedStyle(this._getDialogWrapper());
+        return {
+            width: getPixels(dimensions.width),
+            height: getPixels(dimensions.height),
+        };
+    }
+    _initialPositionReset() {
+        const { right: viewportWidth, bottom: viewportHeight } = this._getViewportDimensions();
+        const { width, height } = this._getDialogWrapperDimensions();
+        const { marginRight: originalDialogRight, marginLeft: originalDialogLeft, marginBottom: originalDialogBottom, marginTop: originalDialogTop, } = this._getDialogWrapper().style;
+        let x;
+        if (originalDialogLeft) {
+            x = getPixels(originalDialogLeft);
+        }
+        else if (originalDialogRight) {
+            x = viewportWidth - getPixels(originalDialogRight) - width;
+        }
+        else {
+            x = (viewportWidth - width) / 2;
+        }
+        let y;
+        if (originalDialogTop) {
+            y = getPixels(originalDialogTop);
+        }
+        else if (originalDialogBottom) {
+            y = viewportHeight - getPixels(originalDialogBottom) - height;
+        }
+        else {
+            y = (viewportHeight - height) / 2;
+        }
+        // use drag ref's mechanisms for positioning instead of the dialog's
+        this._dialogRef.updatePosition({ top: '0px', right: '0px', bottom: '0px', left: '0px' });
+        this._dragRef.setFreeDragPosition({ x, y });
+    }
+    _attachCorners() {
+        Object.values(corners).forEach((corner) => {
+            const element = this._renderer2.createElement('div');
+            this.cornerElements = [...this.cornerElements, element];
+            this._renderer2.setStyle(element, 'position', 'absolute');
+            this._renderer2.setStyle(element, 'width', cornerWidth);
+            this._renderer2.setStyle(element, 'height', cornerWidth);
+            this._renderer2.appendChild(this._getDialogWrapper(), element);
+            let cursor;
+            let topBottom;
+            let rightLeft;
+            if (corner === corners.topRight) {
+                cursor = cursors.nesw;
+                topBottom = verticalAlignment.top;
+                rightLeft = horizontalAlignment.right;
+            }
+            else if (corner === corners.bottomRight) {
+                cursor = cursors.nwse;
+                topBottom = verticalAlignment.bottom;
+                rightLeft = horizontalAlignment.right;
+                const icon = this._renderer2.createElement('i');
+                this._renderer2.addClass(icon, 'material-icons');
+                this._renderer2.appendChild(icon, this._renderer2.createText('filter_list'));
+                this._renderer2.appendChild(element, icon);
+                this._renderer2.setStyle(icon, 'transform', `rotate(${315}deg) translate(0px, ${offset})`);
+                this._renderer2.setStyle(icon, 'font-size', cornerWidth);
+            }
+            else if (corner === corners.bottomLeft) {
+                cursor = cursors.nesw;
+                topBottom = verticalAlignment.bottom;
+                rightLeft = horizontalAlignment.left;
+            }
+            else if (corner === corners.topLeft) {
+                cursor = cursors.nwse;
+                topBottom = verticalAlignment.top;
+                rightLeft = horizontalAlignment.left;
+            }
+            this._renderer2.setStyle(element, topBottom, offset);
+            this._renderer2.setStyle(element, rightLeft, offset);
+            this._renderer2.setStyle(element, 'cursor', cursor);
+            const pointerDownSub = fromEvent(element, 'pointerdown').subscribe((event) => {
+                this._handleMouseDown(event, corner);
+            });
+            this.pointerDownSubs = [...this.pointerDownSubs, pointerDownSub];
+        });
+    }
+    _handleMouseDown(event, corner) {
+        this._renderer2.setStyle(this._document.body, 'user-select', 'none');
+        const { width: originalWidth, height: originalHeight } = this._getDialogWrapperDimensions();
+        const originalMouseX = event.pageX;
+        const originalMouseY = event.pageY;
+        const { x: currentTransformX, y: currentTransformY } = this._dragRef.getFreeDragPosition();
+        const { bottom: distanceFromBottom, right: distanceFromRight } = this._getDialogWrapper().getBoundingClientRect();
+        const { right: viewportWidth, bottom: viewportHeight } = this._getViewportDimensions();
+        const mouseMoveSub = fromEvent(window, 'pointermove').subscribe((e) => {
+            e.preventDefault(); // prevent highlighting of text when dragging
+            const yDelta = clamp(0, e.pageY, viewportHeight) - originalMouseY;
+            const xDelta = clamp(0, e.pageX, viewportWidth) - originalMouseX;
+            let newHeight;
+            let newWidth;
+            let newTransformY = 0;
+            let newTransformX = 0;
+            // top right
+            if (corner === corners.topRight) {
+                newHeight = clamp(minHeight, originalHeight - yDelta, viewportHeight);
+                newWidth = clamp(minWidth, originalWidth + xDelta, viewportWidth);
+                newTransformY = clamp(0, currentTransformY + yDelta, distanceFromBottom - newHeight);
+                newTransformX = currentTransformX;
+            }
+            // bottom right
+            else if (corner === corners.bottomRight) {
+                newHeight = clamp(minHeight, originalHeight + yDelta, viewportHeight);
+                newWidth = clamp(minWidth, originalWidth + xDelta, viewportWidth);
+                newTransformY = currentTransformY;
+                newTransformX = currentTransformX;
+            }
+            // bottom left
+            else if (corner === corners.bottomLeft) {
+                newHeight = clamp(minHeight, originalHeight + yDelta, viewportHeight);
+                newWidth = clamp(minWidth, originalWidth - xDelta, viewportWidth);
+                newTransformY = currentTransformY;
+                newTransformX = clamp(0, currentTransformX + xDelta, distanceFromRight - newWidth);
+            }
+            // top left
+            else if (corner === corners.topLeft) {
+                newHeight = clamp(minHeight, originalHeight - yDelta, viewportHeight);
+                newWidth = clamp(minWidth, originalWidth - xDelta, viewportWidth);
+                newTransformX = clamp(0, currentTransformX + xDelta, distanceFromRight - newWidth);
+                newTransformY = clamp(0, currentTransformY + yDelta, distanceFromBottom - newHeight);
+            }
+            this._dialogRef.updateSize(`${newWidth}px`, `${newHeight}px`);
+            this._dragRef.setFreeDragPosition({
+                x: newTransformX,
+                y: newTransformY,
+            });
+        });
+        const mouseUpSub = merge(fromEvent(window, 'pointerup'), fromEvent(window, 'pointercancel')).subscribe(() => {
+            this._renderer2.removeStyle(this._document.body, 'user-select');
+            mouseMoveSub.unsubscribe();
+            mouseUpSub.unsubscribe();
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resizable-draggable-dialog.js","sourceRoot":"","sources":["../../../../../../src/platform/core/dialogs/resizable-draggable-dialog/resizable-draggable-dialog.ts"],"names":[],"mappings":"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","sourcesContent":["import { Renderer2 } from '@angular/core';\nimport { MatDialogRef } from '@angular/material/dialog';\nimport { DragRef } from '@angular/cdk/drag-drop';\nimport { merge, Subscription, fromEvent } from 'rxjs';\nimport { Point } from '@angular/cdk/drag-drop/drag-ref';\n\nenum corners {\n  topRight = 'topRight',\n  bottomRight = 'bottomRight',\n  bottomLeft = 'bottomLeft',\n  topLeft = 'topLeft',\n}\nenum cursors {\n  nesw = 'nesw-resize',\n  nwse = 'nwse-resize',\n}\nenum verticalAlignment {\n  top = 'top',\n  bottom = 'bottom',\n}\nenum horizontalAlignment {\n  right = 'right',\n  left = 'left',\n}\n\nconst cornerWidth: string = '16px';\nconst offset: string = '0px';\nconst minWidth: number = 200;\nconst minHeight: number = 200;\n\nfunction getPixels(sizeString: string): number {\n  return parseFloat((sizeString || '').replace('px', ''));\n}\n\nfunction clamp(min: number, num: number, max: number): number {\n  return Math.min(Math.max(num, min), max);\n}\n\nexport class ResizableDraggableDialog {\n  cornerElements: HTMLElement[] = [];\n  pointerDownSubs: Subscription[] = [];\n\n  constructor(\n    private _document: any,\n    private _renderer2: Renderer2,\n    private _dialogRef: MatDialogRef<any>,\n    private _dragRef: DragRef,\n  ) {\n    this._initialPositionReset();\n    this._attachCorners();\n  }\n\n  public attach(): void {\n    this.detach();\n    this._attachCorners();\n  }\n\n  public detach(): void {\n    this.pointerDownSubs.forEach((sub: Subscription) => sub.unsubscribe());\n    this.pointerDownSubs = [];\n    this.cornerElements.forEach((elem: HTMLElement) => this._renderer2.removeChild(this._getDialogWrapper(), elem));\n    this.cornerElements = [];\n  }\n\n  private _getDialogWrapper(): HTMLElement {\n    return (<HTMLElement>this._document.getElementById(this._dialogRef.id) || {}).parentElement;\n  }\n\n  private _getViewportDimensions(): ClientRect {\n    return this._getDialogWrapper().parentElement.getBoundingClientRect();\n  }\n\n  private _getDialogWrapperDimensions(): { width: number; height: number } {\n    const dimensions: CSSStyleDeclaration = getComputedStyle(this._getDialogWrapper());\n    return {\n      width: getPixels(dimensions.width),\n      height: getPixels(dimensions.height),\n    };\n  }\n\n  private _initialPositionReset(): void {\n    const { right: viewportWidth, bottom: viewportHeight }: ClientRect = this._getViewportDimensions();\n    const { width, height } = this._getDialogWrapperDimensions();\n    const {\n      marginRight: originalDialogRight,\n      marginLeft: originalDialogLeft,\n      marginBottom: originalDialogBottom,\n      marginTop: originalDialogTop,\n    } = this._getDialogWrapper().style;\n    let x: number;\n    if (originalDialogLeft) {\n      x = getPixels(originalDialogLeft);\n    } else if (originalDialogRight) {\n      x = viewportWidth - getPixels(originalDialogRight) - width;\n    } else {\n      x = (viewportWidth - width) / 2;\n    }\n    let y: number;\n    if (originalDialogTop) {\n      y = getPixels(originalDialogTop);\n    } else if (originalDialogBottom) {\n      y = viewportHeight - getPixels(originalDialogBottom) - height;\n    } else {\n      y = (viewportHeight - height) / 2;\n    }\n    // use drag ref's mechanisms for positioning instead of the dialog's\n    this._dialogRef.updatePosition({ top: '0px', right: '0px', bottom: '0px', left: '0px' });\n    this._dragRef.setFreeDragPosition({ x, y });\n  }\n\n  private _attachCorners(): void {\n    Object.values(corners).forEach((corner: corners) => {\n      const element: HTMLElement = this._renderer2.createElement('div');\n      this.cornerElements = [...this.cornerElements, element];\n      this._renderer2.setStyle(element, 'position', 'absolute');\n      this._renderer2.setStyle(element, 'width', cornerWidth);\n      this._renderer2.setStyle(element, 'height', cornerWidth);\n      this._renderer2.appendChild(this._getDialogWrapper(), element);\n\n      let cursor: cursors;\n      let topBottom: verticalAlignment;\n      let rightLeft: horizontalAlignment;\n\n      if (corner === corners.topRight) {\n        cursor = cursors.nesw;\n        topBottom = verticalAlignment.top;\n        rightLeft = horizontalAlignment.right;\n      } else if (corner === corners.bottomRight) {\n        cursor = cursors.nwse;\n        topBottom = verticalAlignment.bottom;\n        rightLeft = horizontalAlignment.right;\n\n        const icon: HTMLElement = this._renderer2.createElement('i');\n        this._renderer2.addClass(icon, 'material-icons');\n        this._renderer2.appendChild(icon, this._renderer2.createText('filter_list'));\n        this._renderer2.appendChild(element, icon);\n        this._renderer2.setStyle(icon, 'transform', `rotate(${315}deg) translate(0px, ${offset})`);\n        this._renderer2.setStyle(icon, 'font-size', cornerWidth);\n      } else if (corner === corners.bottomLeft) {\n        cursor = cursors.nesw;\n        topBottom = verticalAlignment.bottom;\n        rightLeft = horizontalAlignment.left;\n      } else if (corner === corners.topLeft) {\n        cursor = cursors.nwse;\n        topBottom = verticalAlignment.top;\n        rightLeft = horizontalAlignment.left;\n      }\n      this._renderer2.setStyle(element, topBottom, offset);\n      this._renderer2.setStyle(element, rightLeft, offset);\n      this._renderer2.setStyle(element, 'cursor', cursor);\n\n      const pointerDownSub: Subscription = fromEvent(element, 'pointerdown').subscribe((event: PointerEvent) => {\n        this._handleMouseDown(event, corner);\n      });\n      this.pointerDownSubs = [...this.pointerDownSubs, pointerDownSub];\n    });\n  }\n\n  private _handleMouseDown(event: PointerEvent, corner: corners): void {\n    this._renderer2.setStyle(<HTMLElement>this._document.body, 'user-select', 'none');\n    const { width: originalWidth, height: originalHeight } = this._getDialogWrapperDimensions();\n    const originalMouseX: number = event.pageX;\n    const originalMouseY: number = event.pageY;\n    const { x: currentTransformX, y: currentTransformY }: Point = this._dragRef.getFreeDragPosition();\n    const { bottom: distanceFromBottom, right: distanceFromRight }: ClientRect =\n      this._getDialogWrapper().getBoundingClientRect();\n    const { right: viewportWidth, bottom: viewportHeight }: ClientRect = this._getViewportDimensions();\n\n    const mouseMoveSub: Subscription = fromEvent(window, 'pointermove').subscribe((e: PointerEvent) => {\n      e.preventDefault(); // prevent highlighting of text when dragging\n\n      const yDelta: number = clamp(0, e.pageY, viewportHeight) - originalMouseY;\n      const xDelta: number = clamp(0, e.pageX, viewportWidth) - originalMouseX;\n      let newHeight: number;\n      let newWidth: number;\n      let newTransformY: number = 0;\n      let newTransformX: number = 0;\n\n      // top right\n      if (corner === corners.topRight) {\n        newHeight = clamp(minHeight, originalHeight - yDelta, viewportHeight);\n        newWidth = clamp(minWidth, originalWidth + xDelta, viewportWidth);\n        newTransformY = clamp(0, currentTransformY + yDelta, distanceFromBottom - newHeight);\n        newTransformX = currentTransformX;\n      }\n      // bottom right\n      else if (corner === corners.bottomRight) {\n        newHeight = clamp(minHeight, originalHeight + yDelta, viewportHeight);\n        newWidth = clamp(minWidth, originalWidth + xDelta, viewportWidth);\n        newTransformY = currentTransformY;\n        newTransformX = currentTransformX;\n      }\n      // bottom left\n      else if (corner === corners.bottomLeft) {\n        newHeight = clamp(minHeight, originalHeight + yDelta, viewportHeight);\n        newWidth = clamp(minWidth, originalWidth - xDelta, viewportWidth);\n        newTransformY = currentTransformY;\n        newTransformX = clamp(0, currentTransformX + xDelta, distanceFromRight - newWidth);\n      }\n      // top left\n      else if (corner === corners.topLeft) {\n        newHeight = clamp(minHeight, originalHeight - yDelta, viewportHeight);\n        newWidth = clamp(minWidth, originalWidth - xDelta, viewportWidth);\n\n        newTransformX = clamp(0, currentTransformX + xDelta, distanceFromRight - newWidth);\n        newTransformY = clamp(0, currentTransformY + yDelta, distanceFromBottom - newHeight);\n      }\n      this._dialogRef.updateSize(`${newWidth}px`, `${newHeight}px`);\n      this._dragRef.setFreeDragPosition({\n        x: newTransformX,\n        y: newTransformY,\n      });\n    });\n\n    const mouseUpSub: Subscription = merge(\n      fromEvent(window, 'pointerup'),\n      fromEvent(window, 'pointercancel'),\n    ).subscribe(() => {\n      this._renderer2.removeStyle(<HTMLElement>this._document.body, 'user-select');\n      mouseMoveSub.unsubscribe();\n      mouseUpSub.unsubscribe();\n    });\n  }\n}\n"]}

package/esm2020/dialogs/services/dialog.service.mjs

@@ -0,0 +1,168 @@
+import { Injectable, Inject, RendererFactory2 } from '@angular/core';
+import { MatDialog, MatDialogConfig } from '@angular/material/dialog';
+import { TdAlertDialogComponent } from '../alert-dialog/alert-dialog.component';
+import { TdConfirmDialogComponent } from '../confirm-dialog/confirm-dialog.component';
+import { TdPromptDialogComponent } from '../prompt-dialog/prompt-dialog.component';
+import { DragDrop } from '@angular/cdk/drag-drop';
+import { DOCUMENT } from '@angular/common';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "@angular/cdk/drag-drop";
+export class TdDialogService {
+    constructor(_document, _dialogService, _dragDrop, rendererFactory) {
+        this._document = _document;
+        this._dialogService = _dialogService;
+        this._dragDrop = _dragDrop;
+        this.rendererFactory = rendererFactory;
+        this._renderer2 = rendererFactory.createRenderer(undefined, undefined);
+    }
+    /**
+     * params:
+     * - component: ComponentType<T>
+     * - config: MatDialogConfig
+     * Wrapper function over the open() method in MatDialog.
+     * Opens a modal dialog containing the given component.
+     */
+    open(component, config) {
+        return this._dialogService.open(component, config);
+    }
+    /**
+     * Wrapper function over the closeAll() method in MatDialog.
+     * Closes all of the currently-open dialogs.
+     */
+    closeAll() {
+        this._dialogService.closeAll();
+    }
+    /**
+     * params:
+     * - config: IAlertConfig {
+     *     message: string;
+     *     title?: string;
+     *     viewContainerRef?: ViewContainerRef;
+     *     closeButton?: string;
+     * }
+     *
+     * Opens an alert dialog with the provided config.
+     * Returns an MatDialogRef<TdAlertDialogComponent> object.
+     */
+    openAlert(config) {
+        const dialogConfig = this._createConfig(config);
+        const dialogRef = this._dialogService.open(TdAlertDialogComponent, dialogConfig);
+        const alertDialogComponent = dialogRef.componentInstance;
+        alertDialogComponent.title = config.title;
+        alertDialogComponent.message = config.message;
+        if (config.closeButton) {
+            alertDialogComponent.closeButton = config.closeButton;
+        }
+        return dialogRef;
+    }
+    /**
+     * params:
+     * - config: IConfirmConfig {
+     *     message: string;
+     *     title?: string;
+     *     viewContainerRef?: ViewContainerRef;
+     *     acceptButton?: string;
+     *     cancelButton?: string;
+     *     isDestructive?: boolean;
+     * }
+     *
+     * Opens a confirm dialog with the provided config.
+     * Returns an MatDialogRef<TdConfirmDialogComponent> object.
+     */
+    openConfirm(config) {
+        const dialogConfig = this._createConfig(config);
+        const dialogRef = this._dialogService.open(TdConfirmDialogComponent, dialogConfig);
+        const confirmDialogComponent = dialogRef.componentInstance;
+        confirmDialogComponent.title = config.title;
+        confirmDialogComponent.message = config.message;
+        if (config.acceptButton) {
+            confirmDialogComponent.acceptButton = config.acceptButton;
+        }
+        if (config.isDestructive) {
+            confirmDialogComponent.isDestructive = config.isDestructive;
+        }
+        if (config.cancelButton) {
+            confirmDialogComponent.cancelButton = config.cancelButton;
+        }
+        return dialogRef;
+    }
+    /**
+     * params:
+     * - config: IPromptConfig {
+     *     message: string;
+     *     title?: string;
+     *     value?: string;
+     *     viewContainerRef?: ViewContainerRef;
+     *     acceptButton?: string;
+     *     cancelButton?: string;
+     * }
+     *
+     * Opens a prompt dialog with the provided config.
+     * Returns an MatDialogRef<TdPromptDialogComponent> object.
+     */
+    openPrompt(config) {
+        const dialogConfig = this._createConfig(config);
+        const dialogRef = this._dialogService.open(TdPromptDialogComponent, dialogConfig);
+        const promptDialogComponent = dialogRef.componentInstance;
+        promptDialogComponent.title = config.title;
+        promptDialogComponent.message = config.message;
+        promptDialogComponent.value = config.value;
+        if (config.acceptButton) {
+            promptDialogComponent.acceptButton = config.acceptButton;
+        }
+        if (config.cancelButton) {
+            promptDialogComponent.cancelButton = config.cancelButton;
+        }
+        return dialogRef;
+    }
+    /**
+     * Opens a draggable dialog containing the given component.
+     */
+    openDraggable({ component, config, dragHandleSelectors, draggableClass, }) {
+        const matDialogRef = this._dialogService.open(component, config);
+        const dragRefSubject = new Subject();
+        const CDK_OVERLAY_PANE_SELECTOR = '.cdk-overlay-pane';
+        const CDK_OVERLAY_CONTAINER_SELECTOR = '.cdk-overlay-container';
+        matDialogRef.afterOpened().subscribe(() => {
+            const dialogElement = this._document.getElementById(matDialogRef.id);
+            const draggableElement = this._dragDrop.createDrag(dialogElement);
+            if (draggableClass) {
+                const childComponent = dialogElement.firstElementChild;
+                this._renderer2.addClass(childComponent, draggableClass);
+            }
+            if (dragHandleSelectors && dragHandleSelectors.length) {
+                const dragHandles = dragHandleSelectors.reduce((acc, curr) => [...acc, ...Array.from(dialogElement.querySelectorAll(curr))], []);
+                if (dragHandles.length > 0) {
+                    draggableElement.withHandles(dragHandles);
+                }
+            }
+            const rootElement = dialogElement.closest(CDK_OVERLAY_PANE_SELECTOR);
+            if (rootElement) {
+                draggableElement.withRootElement(rootElement);
+            }
+            const boundaryElement = dialogElement.closest(CDK_OVERLAY_CONTAINER_SELECTOR);
+            if (boundaryElement) {
+                draggableElement.withBoundaryElement(boundaryElement);
+            }
+            dragRefSubject.next(draggableElement);
+        });
+        return { matDialogRef, dragRefSubject };
+    }
+    _createConfig(config) {
+        const dialogConfig = new MatDialogConfig();
+        dialogConfig.width = '400px';
+        Object.assign(dialogConfig, config);
+        return dialogConfig;
+    }
+}
+/** @nocollapse */ /** @nocollapse */ TdDialogService.ɵfac = function TdDialogService_Factory(t) { return new (t || TdDialogService)(i0.ɵɵinject(DOCUMENT), i0.ɵɵinject(i1.MatDialog), i0.ɵɵinject(i2.DragDrop), i0.ɵɵinject(i0.RendererFactory2)); };
+/** @nocollapse */ /** @nocollapse */ TdDialogService.ɵprov = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjectable({ token: TdDialogService, factory: TdDialogService.ɵfac });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TdDialogService, [{
+        type: Injectable
+    }], function () { return [{ type: undefined, decorators: [{
+                type: Inject,
+                args: [DOCUMENT]
+            }] }, { type: i1.MatDialog }, { type: i2.DragDrop }, { type: i0.RendererFactory2 }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dialog.service.js","sourceRoot":"","sources":["../../../../../../src/platform/core/dialogs/services/dialog.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject, Renderer2, RendererFactory2 } from '@angular/core';\nimport { MatDialog, MatDialogRef, MatDialogConfig } from '@angular/material/dialog';\nimport { ComponentType } from '@angular/cdk/portal';\n\nimport { TdAlertDialogComponent } from '../alert-dialog/alert-dialog.component';\nimport { TdConfirmDialogComponent } from '../confirm-dialog/confirm-dialog.component';\nimport { TdPromptDialogComponent } from '../prompt-dialog/prompt-dialog.component';\nimport { DragDrop, DragRef } from '@angular/cdk/drag-drop';\nimport { DOCUMENT } from '@angular/common';\nimport { Subject } from 'rxjs';\n\nexport interface IDialogConfig extends MatDialogConfig {\n  title?: string;\n  message: string;\n}\n\nexport interface IAlertConfig extends IDialogConfig {\n  closeButton?: string;\n}\n\nexport interface IConfirmConfig extends IDialogConfig {\n  acceptButton?: string;\n  cancelButton?: string;\n  isDestructive?: boolean;\n}\n\nexport interface IPromptConfig extends IConfirmConfig {\n  value?: string;\n}\n\nexport interface IDraggableConfig<T> {\n  component: ComponentType<T>;\n  config?: MatDialogConfig;\n  // CSS selectors of element(s) inside the component meant to be drag handle(s)\n  dragHandleSelectors?: string[];\n  // Class that will be added to the component signifying drag-ability\n  draggableClass?: string;\n}\n\nexport interface IDraggableRefs<T> {\n  matDialogRef: MatDialogRef<T>;\n  dragRefSubject: Subject<DragRef>;\n}\n\n@Injectable()\nexport class TdDialogService {\n  private _renderer2: Renderer2;\n\n  constructor(\n    @Inject(DOCUMENT) private _document: any,\n    private _dialogService: MatDialog,\n    private _dragDrop: DragDrop,\n    private rendererFactory: RendererFactory2,\n  ) {\n    this._renderer2 = rendererFactory.createRenderer(undefined, undefined);\n  }\n\n  /**\n   * params:\n   * - component: ComponentType<T>\n   * - config: MatDialogConfig\n   * Wrapper function over the open() method in MatDialog.\n   * Opens a modal dialog containing the given component.\n   */\n  public open<T>(component: ComponentType<T>, config?: MatDialogConfig): MatDialogRef<T> {\n    return this._dialogService.open(component, config);\n  }\n\n  /**\n   * Wrapper function over the closeAll() method in MatDialog.\n   * Closes all of the currently-open dialogs.\n   */\n  public closeAll(): void {\n    this._dialogService.closeAll();\n  }\n\n  /**\n   * params:\n   * - config: IAlertConfig {\n   *     message: string;\n   *     title?: string;\n   *     viewContainerRef?: ViewContainerRef;\n   *     closeButton?: string;\n   * }\n   *\n   * Opens an alert dialog with the provided config.\n   * Returns an MatDialogRef<TdAlertDialogComponent> object.\n   */\n  public openAlert(config: IAlertConfig): MatDialogRef<TdAlertDialogComponent> {\n    const dialogConfig: MatDialogConfig = this._createConfig(config);\n    const dialogRef: MatDialogRef<TdAlertDialogComponent> = this._dialogService.open(\n      TdAlertDialogComponent,\n      dialogConfig,\n    );\n    const alertDialogComponent: TdAlertDialogComponent = dialogRef.componentInstance;\n    alertDialogComponent.title = config.title;\n    alertDialogComponent.message = config.message;\n    if (config.closeButton) {\n      alertDialogComponent.closeButton = config.closeButton;\n    }\n    return dialogRef;\n  }\n\n  /**\n   * params:\n   * - config: IConfirmConfig {\n   *     message: string;\n   *     title?: string;\n   *     viewContainerRef?: ViewContainerRef;\n   *     acceptButton?: string;\n   *     cancelButton?: string;\n   *     isDestructive?: boolean;\n   * }\n   *\n   * Opens a confirm dialog with the provided config.\n   * Returns an MatDialogRef<TdConfirmDialogComponent> object.\n   */\n  public openConfirm(config: IConfirmConfig): MatDialogRef<TdConfirmDialogComponent> {\n    const dialogConfig: MatDialogConfig = this._createConfig(config);\n    const dialogRef: MatDialogRef<TdConfirmDialogComponent> = this._dialogService.open(\n      TdConfirmDialogComponent,\n      dialogConfig,\n    );\n    const confirmDialogComponent: TdConfirmDialogComponent = dialogRef.componentInstance;\n    confirmDialogComponent.title = config.title;\n    confirmDialogComponent.message = config.message;\n    if (config.acceptButton) {\n      confirmDialogComponent.acceptButton = config.acceptButton;\n    }\n    if (config.isDestructive) {\n      confirmDialogComponent.isDestructive = config.isDestructive;\n    }\n    if (config.cancelButton) {\n      confirmDialogComponent.cancelButton = config.cancelButton;\n    }\n    return dialogRef;\n  }\n\n  /**\n   * params:\n   * - config: IPromptConfig {\n   *     message: string;\n   *     title?: string;\n   *     value?: string;\n   *     viewContainerRef?: ViewContainerRef;\n   *     acceptButton?: string;\n   *     cancelButton?: string;\n   * }\n   *\n   * Opens a prompt dialog with the provided config.\n   * Returns an MatDialogRef<TdPromptDialogComponent> object.\n   */\n  public openPrompt(config: IPromptConfig): MatDialogRef<TdPromptDialogComponent> {\n    const dialogConfig: MatDialogConfig = this._createConfig(config);\n    const dialogRef: MatDialogRef<TdPromptDialogComponent> = this._dialogService.open(\n      TdPromptDialogComponent,\n      dialogConfig,\n    );\n    const promptDialogComponent: TdPromptDialogComponent = dialogRef.componentInstance;\n    promptDialogComponent.title = config.title;\n    promptDialogComponent.message = config.message;\n    promptDialogComponent.value = config.value;\n    if (config.acceptButton) {\n      promptDialogComponent.acceptButton = config.acceptButton;\n    }\n    if (config.cancelButton) {\n      promptDialogComponent.cancelButton = config.cancelButton;\n    }\n    return dialogRef;\n  }\n\n  /**\n   * Opens a draggable dialog containing the given component.\n   */\n  public openDraggable<T>({\n    component,\n    config,\n    dragHandleSelectors,\n    draggableClass,\n  }: IDraggableConfig<T>): IDraggableRefs<T> {\n    const matDialogRef: MatDialogRef<T, any> = this._dialogService.open(component, config);\n\n    const dragRefSubject: Subject<DragRef> = new Subject<DragRef>();\n\n    const CDK_OVERLAY_PANE_SELECTOR: string = '.cdk-overlay-pane';\n    const CDK_OVERLAY_CONTAINER_SELECTOR: string = '.cdk-overlay-container';\n\n    matDialogRef.afterOpened().subscribe(() => {\n      const dialogElement: HTMLElement = <HTMLElement>this._document.getElementById(matDialogRef.id);\n      const draggableElement: DragRef = this._dragDrop.createDrag(dialogElement);\n\n      if (draggableClass) {\n        const childComponent: Element = dialogElement.firstElementChild;\n        this._renderer2.addClass(childComponent, draggableClass);\n      }\n      if (dragHandleSelectors && dragHandleSelectors.length) {\n        const dragHandles: Element[] = dragHandleSelectors.reduce(\n          (acc: Element[], curr: string) => [...acc, ...Array.from(dialogElement.querySelectorAll(curr))],\n          [],\n        );\n        if (dragHandles.length > 0) {\n          draggableElement.withHandles(<HTMLElement[]>dragHandles);\n        }\n      }\n      const rootElement: Element = dialogElement.closest(CDK_OVERLAY_PANE_SELECTOR);\n      if (rootElement) {\n        draggableElement.withRootElement(<HTMLElement>rootElement);\n      }\n\n      const boundaryElement: Element = dialogElement.closest(CDK_OVERLAY_CONTAINER_SELECTOR);\n      if (boundaryElement) {\n        draggableElement.withBoundaryElement(<HTMLElement>boundaryElement);\n      }\n      dragRefSubject.next(draggableElement);\n    });\n\n    return { matDialogRef, dragRefSubject };\n  }\n\n  private _createConfig(config: IDialogConfig): MatDialogConfig {\n    const dialogConfig: MatDialogConfig = new MatDialogConfig();\n    dialogConfig.width = '400px';\n    Object.assign(dialogConfig, config);\n    return dialogConfig;\n  }\n}\n"]}

package/esm2020/dialogs/window-dialog/window-dialog.component.mjs

@@ -0,0 +1,69 @@
+import { Component, Input, Output, EventEmitter, ChangeDetectionStrategy } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/toolbar";
+import * as i2 from "@angular/material/button";
+import * as i3 from "@angular/material/tooltip";
+import * as i4 from "@angular/material/icon";
+const _c0 = ["*"];
+export class TdWindowDialogComponent {
+    constructor() {
+        this.docked = false;
+        this.dockToggled = new EventEmitter();
+        this.closed = new EventEmitter();
+        this.toolbarHeight = 56;
+    }
+    toggleDockedState() {
+        this.dockToggled.emit(this.docked);
+    }
+}
+/** @nocollapse */ /** @nocollapse */ TdWindowDialogComponent.ɵfac = function TdWindowDialogComponent_Factory(t) { return new (t || TdWindowDialogComponent)(); };
+/** @nocollapse */ /** @nocollapse */ TdWindowDialogComponent.ɵcmp = /** @pureOrBreakMyCode */ i0.ɵɵdefineComponent({ type: TdWindowDialogComponent, selectors: [["td-window-dialog"]], inputs: { toolbarColor: "toolbarColor", docked: "docked", title: "title", toggleDockedStateLabel: "toggleDockedStateLabel", closeLabel: "closeLabel" }, outputs: { dockToggled: "dockToggled", closed: "closed" }, ngContentSelectors: _c0, decls: 9, vars: 11, consts: [[1, "td-window-dialog-toolbar", 3, "color"], ["layout", "row", "layout-align", "start center", "flex", ""], ["flex", "", 1, "mat-title", "td-window-dialog-title", "truncate"], ["mat-icon-button", "", 1, "td-window-dialog-close", 3, "matTooltip", "click"]], template: function TdWindowDialogComponent_Template(rf, ctx) { if (rf & 1) {
+        i0.ɵɵprojectionDef();
+        i0.ɵɵelementStart(0, "mat-toolbar", 0);
+        i0.ɵɵelementStart(1, "mat-toolbar-row");
+        i0.ɵɵelementStart(2, "div", 1);
+        i0.ɵɵelementStart(3, "span", 2);
+        i0.ɵɵtext(4);
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementStart(5, "button", 3);
+        i0.ɵɵlistener("click", function TdWindowDialogComponent_Template_button_click_5_listener() { return ctx.closed.emit(); });
+        i0.ɵɵelementStart(6, "mat-icon");
+        i0.ɵɵtext(7, "close");
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵelementEnd();
+        i0.ɵɵprojection(8);
+    } if (rf & 2) {
+        i0.ɵɵstyleProp("min-height", ctx.toolbarHeight, "px")("cursor", ctx.docked ? "inherit" : "move");
+        i0.ɵɵproperty("color", ctx.toolbarColor);
+        i0.ɵɵadvance(1);
+        i0.ɵɵstyleProp("height", ctx.toolbarHeight, "px");
+        i0.ɵɵadvance(3);
+        i0.ɵɵtextInterpolate1(" ", ctx.title, " ");
+        i0.ɵɵadvance(1);
+        i0.ɵɵproperty("matTooltip", ctx.closeLabel);
+        i0.ɵɵattribute("data-test", "close-button");
+        i0.ɵɵadvance(1);
+        i0.ɵɵattribute("aria-label", ctx.closeLabel);
+    } }, directives: [i1.MatToolbar, i1.MatToolbarRow, i2.MatButton, i3.MatTooltip, i4.MatIcon], styles: ["[_nghost-%COMP%]{height:100%;display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column}.truncate[_ngcontent-%COMP%]{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.td-window-dialog-toolbar[_ngcontent-%COMP%]{background:none}.td-window-dialog-title[_ngcontent-%COMP%]{margin-bottom:0}.td-window-dialog-close[_ngcontent-%COMP%]{margin-right:-8px}  .td-window-dialog .mat-dialog-container{padding:0}"], changeDetection: 0 });
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TdWindowDialogComponent, [{
+        type: Component,
+        args: [{ selector: 'td-window-dialog', changeDetection: ChangeDetectionStrategy.OnPush, template: "<mat-toolbar\n  [color]=\"toolbarColor\"\n  class=\"td-window-dialog-toolbar\"\n  [style.min-height.px]=\"toolbarHeight\"\n  [style.cursor]=\"docked ? 'inherit' : 'move'\"\n>\n  <mat-toolbar-row [style.height.px]=\"toolbarHeight\">\n    <div layout=\"row\" layout-align=\"start center\" flex>\n      <span class=\"mat-title td-window-dialog-title truncate\" flex>\n        {{ title }}\n      </span>\n      <!-- TODO: Resizing a drag-and-drop element was not working so removed docking/undocking for now-->\n      <!-- <button mat-icon-button [matTooltip]=\"toggleDockedStateLabel\" (click)=\"toggleDockedState()\">\n        <mat-icon [attr.aria-label]=\"toggleDockedStateLabel\">\n          {{ docked ? 'unfold_more' : 'unfold_less' }}\n        </mat-icon>\n      </button> -->\n\n      <button\n        mat-icon-button\n        [matTooltip]=\"closeLabel\"\n        (click)=\"closed.emit()\"\n        class=\"td-window-dialog-close\"\n        [attr.data-test]=\"'close-button'\"\n      >\n        <mat-icon [attr.aria-label]=\"closeLabel\">close</mat-icon>\n      </button>\n    </div>\n  </mat-toolbar-row>\n</mat-toolbar>\n<ng-content></ng-content>\n", styles: [":host{height:100%;display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column}.truncate{white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.td-window-dialog-toolbar{background:none}.td-window-dialog-title{margin-bottom:0}.td-window-dialog-close{margin-right:-8px}::ng-deep .td-window-dialog .mat-dialog-container{padding:0}\n"] }]
+    }], null, { toolbarColor: [{
+            type: Input
+        }], docked: [{
+            type: Input
+        }], title: [{
+            type: Input
+        }], toggleDockedStateLabel: [{
+            type: Input
+        }], closeLabel: [{
+            type: Input
+        }], dockToggled: [{
+            type: Output
+        }], closed: [{
+            type: Output
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/dynamic-menu/covalent-core-dynamic-menu.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY292YWxlbnQtY29yZS1keW5hbWljLW1lbnUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvcGxhdGZvcm0vY29yZS9keW5hbWljLW1lbnUvY292YWxlbnQtY29yZS1keW5hbWljLW1lbnUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=