@energycap/components 0.31.5 → 0.32.0

package/esm2020/lib/display/resizable/resizable-base.mjs

@@ -0,0 +1,120 @@
+import { Inject, Input, Directive } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/cache.service";
+/**
+ * Base class for handling click and drag resizing of elements with a mouse.
+ * Derived classes must provide the element to be resized and implement the setWidth function.
+ */
+export class ResizableBase {
+    constructor(renderer, cacheService, document) {
+        this.renderer = renderer;
+        this.cacheService = cacheService;
+        this.document = document;
+        /**Set to true if the resizable should remember its width. Requires the element to have an ID*/
+        this.rememberWidth = false;
+        /**The id of the resizable, used for GI and for remembering the width  */
+        this.id = '';
+        /** The element that is current being resized */
+        this.currentEl = null;
+        /** The x position of the mouse when dragging starts. Relative to the viewport. */
+        this.startScreenX = 0;
+        /** The width of the current element when dragging starts. */
+        this.startElWidth = 0;
+    }
+    ngAfterViewInit() {
+        if (this.rememberWidth && this.id) {
+            let cached = this.cacheService.getItem('resizable-' + this.id);
+            if (cached && cached.widths && cached.widths.length > 0) {
+                this.restoreWidths(cached.widths);
+            }
+        }
+    }
+    /**
+     * On a mousedown event
+     * * store the width of the current element to calculate the new width
+     * * store the horizontal position of the pointer to calculate the new width.
+     * * add the 'is-active' class to the current element
+     * * set up listeners on the document to know when dragging starts and stops.
+     * Mouse event listeners are added to the document because the cursor may move
+     * off the current element while dragging.
+     */
+    startDrag(event) {
+        if (this.currentEl) {
+            this.startElWidth = this.currentEl.offsetWidth;
+            this.startScreenX = event.screenX;
+            this.renderer.addClass(this.currentEl, 'is-active');
+            this.renderer.setStyle(this.document.body, 'cursor', 'col-resize');
+            // Remove any listeners that may have not been cleaned up before we register new listeners.
+            if (this.mouseupListener) {
+                this.mouseupListener();
+                this.mouseupListener = undefined;
+            }
+            if (this.mousemoveListener) {
+                this.mousemoveListener();
+                this.mousemoveListener = undefined;
+            }
+            this.mouseupListener = this.renderer.listen(this.document, 'mouseup', this.stopDrag.bind(this));
+            this.mousemoveListener = this.renderer.listen(this.document, 'mousemove', this.drag.bind(this));
+        }
+        else {
+            throw new Error(`currentEl is ${this.currentEl}. currentEl must be assigned before startDrag() is called.`);
+        }
+    }
+    /**
+     * On a mousemove event, calculate the new width of the current element by
+     * adding the difference of the start pageX position and the current pageX
+     * position to the width of the element when we started dragging. Pass the
+     * calculated with to the setWidth method.
+     */
+    drag(event) {
+        this.setWidth(this.startElWidth + (event.screenX - this.startScreenX));
+    }
+    /**
+     * On a mouseup event
+     * * remove the mouse event listeners on the document.
+     * * remove the 'is-active' class from the current element
+     * * reset the cursor style on the body
+     */
+    stopDrag(event) {
+        if (this.mousemoveListener) {
+            this.mousemoveListener();
+            this.mousemoveListener = undefined;
+        }
+        if (this.mouseupListener) {
+            this.mouseupListener();
+            this.mouseupListener = undefined;
+        }
+        if (this.currentEl) {
+            this.renderer.removeClass(this.currentEl, 'is-active');
+        }
+        this.renderer.removeStyle(this.document.body, 'cursor');
+    }
+    /**Called after the view initializes if the component supports restoring widths and there are cached widths to restore.
+     * To be overridden in a derived class if it supports restoring widths, defaults to a no-op*/
+    restoreWidths(widths) { }
+    /** Store the provided widths in cache so they can be retrieved later */
+    saveWidths(widths) {
+        if (this.rememberWidth && this.id) {
+            this.cacheService.setItem('resizable-' + this.id, {
+                widths: widths
+            });
+        }
+        else if (this.rememberWidth) {
+            console.error('rememberWidth is set but will not take effect unless ID is also set');
+        }
+    }
+}
+ResizableBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: ResizableBase, deps: [{ token: i0.Renderer2 }, { token: i1.CacheService }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Directive });
+ResizableBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.0", type: ResizableBase, inputs: { rememberWidth: "rememberWidth", id: "id" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: ResizableBase, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i1.CacheService }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; }, propDecorators: { rememberWidth: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resizable-base.js","sourceRoot":"","sources":["../../../../../../projects/components/src/lib/display/resizable/resizable-base.ts"],"names":[],"mappings":"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","sourcesContent":["import { Renderer2, Inject, Input, AfterViewInit, Directive } from '@angular/core';\r\nimport { DOCUMENT } from '@angular/common';\r\nimport { CacheService } from '../../core/cache.service';\r\n\r\nexport type ResizeCacheEntry = { widths: number[] };\r\n\r\n/**\r\n * Base class for handling click and drag resizing of elements with a mouse. \r\n * Derived classes must provide the element to be resized and implement the setWidth function.\r\n */\r\n@Directive()\r\nexport abstract class ResizableBase implements AfterViewInit {\r\n  ngAfterViewInit(): void {\r\n    if(this.rememberWidth && this.id){\r\n      let cached = this.cacheService.getItem<ResizeCacheEntry>('resizable-' + this.id);\r\n      if(cached && cached.widths && cached.widths.length > 0){\r\n        this.restoreWidths(cached.widths);\r\n      }\r\n    }\r\n  }\r\n\r\n  /**Set to true if the resizable should remember its width. Requires the element to have an ID*/\r\n  @Input()\r\n  public rememberWidth: boolean = false;\r\n\r\n  /**The id of the resizable, used for GI and for remembering the width  */\r\n  @Input() \r\n  public id: string = '';\r\n\r\n  /** The element that is current being resized */\r\n  protected currentEl: HTMLElement | null = null;\r\n\r\n  /** The x position of the mouse when dragging starts. Relative to the viewport. */\r\n  protected startScreenX: number = 0;\r\n\r\n   /** The width of the current element when dragging starts. */\r\n  protected startElWidth: number = 0;\r\n\r\n  /** \r\n   * Stored 'unlisten' functions that remove their respective listeners when called \r\n   */\r\n  protected mouseupListener?: () => void;\r\n  protected mousemoveListener?: () => void;\r\n\r\n  constructor(\r\n    protected renderer: Renderer2, \r\n    private cacheService: CacheService,\r\n    @Inject(DOCUMENT) protected document: Document\r\n  ){}\r\n\r\n  /** \r\n   * On a mousedown event\r\n   * * store the width of the current element to calculate the new width\r\n   * * store the horizontal position of the pointer to calculate the new width. \r\n   * * add the 'is-active' class to the current element\r\n   * * set up listeners on the document to know when dragging starts and stops. \r\n   * Mouse event listeners are added to the document because the cursor may move \r\n   * off the current element while dragging.\r\n   */\r\n  public startDrag(event: MouseEvent): void {\r\n    if (this.currentEl) {\r\n      this.startElWidth = this.currentEl.offsetWidth;\r\n      this.startScreenX = event.screenX;\r\n      this.renderer.addClass(this.currentEl, 'is-active');\r\n      this.renderer.setStyle(this.document.body, 'cursor', 'col-resize');\r\n\r\n      // Remove any listeners that may have not been cleaned up before we register new listeners.\r\n      if (this.mouseupListener) {\r\n        this.mouseupListener();\r\n        this.mouseupListener = undefined;\r\n      }\r\n      if (this.mousemoveListener) {\r\n        this.mousemoveListener();\r\n        this.mousemoveListener = undefined;\r\n      }\r\n\r\n      this.mouseupListener = this.renderer.listen(this.document, 'mouseup', this.stopDrag.bind(this));\r\n      this.mousemoveListener = this.renderer.listen(this.document, 'mousemove', this.drag.bind(this));\r\n    } else {\r\n      throw new Error(`currentEl is ${this.currentEl}. currentEl must be assigned before startDrag() is called.`);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * On a mousemove event, calculate the new width of the current element by \r\n   * adding the difference of the start pageX position and the current pageX \r\n   * position to the width of the element when we started dragging. Pass the \r\n   * calculated with to the setWidth method.\r\n   */\r\n  protected drag(event: MouseEvent): void {\r\n    this.setWidth(this.startElWidth + (event.screenX - this.startScreenX));\r\n  }\r\n\r\n  /**\r\n   * Update the current element's width. Called after a mousemove event.\r\n   */\r\n  protected abstract setWidth(width: number): void;\r\n\r\n  /**\r\n   * On a mouseup event\r\n   * * remove the mouse event listeners on the document.\r\n   * * remove the 'is-active' class from the current element\r\n   * * reset the cursor style on the body\r\n   */\r\n  protected stopDrag(event: MouseEvent): void {\r\n    if (this.mousemoveListener) {\r\n      this.mousemoveListener();\r\n      this.mousemoveListener = undefined;\r\n    }\r\n    \r\n    if (this.mouseupListener) {\r\n      this.mouseupListener();\r\n      this.mouseupListener = undefined;\r\n    }\r\n    \r\n    if (this.currentEl) {\r\n      this.renderer.removeClass(this.currentEl, 'is-active');\r\n    }\r\n\r\n    this.renderer.removeStyle(this.document.body, 'cursor');\r\n  }\r\n\r\n  /**Called after the view initializes if the component supports restoring widths and there are cached widths to restore. \r\n   * To be overridden in a derived class if it supports restoring widths, defaults to a no-op*/\r\n  protected restoreWidths(widths: number[]): void { }\r\n\r\n  /** Store the provided widths in cache so they can be retrieved later */\r\n  protected saveWidths(widths: number[]){\r\n    if(this.rememberWidth && this.id){\r\n      this.cacheService.setItem('resizable-' + this.id, <ResizeCacheEntry> {\r\n        widths: widths\r\n      });\r\n    } else if(this.rememberWidth){\r\n      console.error('rememberWidth is set but will not take effect unless ID is also set');\r\n    }\r\n  }\r\n}"]}

package/esm2020/lib/display/resizable/resizable.component.mjs

@@ -0,0 +1,57 @@
+import { DOCUMENT } from '@angular/common';
+import { Component, Inject } from '@angular/core';
+import { ResizableBase } from './resizable-base';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/cache.service";
+/**
+ * Make an element resizable horizontally by wrapping it in the ResizableComponent.
+ * Default widths / limits are applied but you can optionally override them
+ * with min-width and max-width with style attributes
+ * @example
+ * <ec-resizable [style.width.px]="200"
+ *               [style.min-width.px]="75"
+ *               [style.max-width.px]="300">
+ *    <div> ... </div>
+ * </ec-resizable>
+ */
+export class ResizableComponent extends ResizableBase {
+    constructor(el, renderer, cacheService, document) {
+        super(renderer, cacheService, document);
+        this.el = el;
+        //default rememberWidth to true for standard resizable, resizable tables default to false
+        this.rememberWidth = true;
+    }
+    /** Store the host element to reference later */
+    ngOnInit() {
+        this.currentEl = this.el.nativeElement;
+    }
+    /**
+     * Set the new width of the element and emit the new width to subscribers
+     */
+    setWidth(width) {
+        this.renderer.setStyle(this.currentEl, 'width', width + 'px');
+        this.saveWidths([width]);
+    }
+    /**Called from the base class when cached widths are available and restoring
+     * width is enabled. We only care about the first one because we only have one width
+     */
+    restoreWidths(widths) {
+        this.setWidth(widths[0]);
+    }
+}
+ResizableComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: ResizableComponent, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.CacheService }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Component });
+ResizableComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.0", type: ResizableComponent, selector: "ec-resizable", usesInheritance: true, ngImport: i0, template: `<div class="content">
+              <ng-content></ng-content>
+            </div>
+            <div class="handle" (mousedown)="startDrag($event)"></div>`, isInline: true, styles: [":root{--ec-font-size-icon: 1rem;--ec-color-icon: rgba(26, 26, 35, .66)}@keyframes spin{0%{transform:rotate(0)}to{transform:rotate(1turn)}}:host{width:240px;max-width:480px;min-width:100px;position:relative;border-right:1px solid var(--ec-border-color-legacy);display:flex}:host.is-active{-webkit-user-select:none;user-select:none}:host.is-active .handle:after{background-color:var(--ec-color-interactive)}.handle{position:absolute;right:-7px;width:13px;height:100%;top:0;padding:0 5px;z-index:var(--ec-z-index-splitter)}.handle:after{content:\"\";display:block;transition:background-color .3s ease;height:100%;position:relative}.handle:hover{cursor:col-resize}.handle:hover:after{background-color:var(--ec-color-interactive)}.content{overflow:hidden;display:flex;flex:1 1;min-height:0;min-width:0}.content ::ng-deep>*{flex:1 1;min-height:0;min-width:0}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: ResizableComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ec-resizable', template: `<div class="content">
+              <ng-content></ng-content>
+            </div>
+            <div class="handle" (mousedown)="startDrag($event)"></div>`, styles: [":root{--ec-font-size-icon: 1rem;--ec-color-icon: rgba(26, 26, 35, .66)}@keyframes spin{0%{transform:rotate(0)}to{transform:rotate(1turn)}}:host{width:240px;max-width:480px;min-width:100px;position:relative;border-right:1px solid var(--ec-border-color-legacy);display:flex}:host.is-active{-webkit-user-select:none;user-select:none}:host.is-active .handle:after{background-color:var(--ec-color-interactive)}.handle{position:absolute;right:-7px;width:13px;height:100%;top:0;padding:0 5px;z-index:var(--ec-z-index-splitter)}.handle:after{content:\"\";display:block;transition:background-color .3s ease;height:100%;position:relative}.handle:hover{cursor:col-resize}.handle:hover:after{background-color:var(--ec-color-interactive)}.content{overflow:hidden;display:flex;flex:1 1;min-height:0;min-width:0}.content ::ng-deep>*{flex:1 1;min-height:0;min-width:0}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.CacheService }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/display/spinner/spinner.component.mjs

@@ -0,0 +1,12 @@
+import { Component } from '@angular/core';
+import * as i0 from "@angular/core";
+/** Exposes the markup and styles that represent the spinner. No inputs or outputs defined because it is just a visual component*/
+export class SpinnerComponent {
+}
+SpinnerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: SpinnerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+SpinnerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.0", type: SpinnerComponent, selector: "ec-spinner", ngImport: i0, template: "<div class=\"spinner\">\r\n  <span class=\"spinner-dot\"></span>\r\n  <span class=\"spinner-dot\"></span>\r\n  <span class=\"spinner-dot\"></span>\r\n  <span class=\"spinner-dot\"></span>\r\n</div>", styles: ["@keyframes sk-bouncedelay{0%,80%,to{opacity:0}40%{opacity:1}}.spinner{display:flex}.spinner-dot{width:.75rem;height:.75rem;background-color:var(--ec-color-interactive);animation:sk-bouncedelay 1.7s infinite ease-in-out both;margin-right:.25rem}.spinner-dot:nth-child(1){animation-delay:-.6s}.spinner-dot:nth-child(2){animation-delay:-.4s}.spinner-dot:nth-child(3){animation-delay:-.2s}:host(.spinner-small) .spinner-dot{width:.5rem;height:.5rem;background-color:var(--ec-color-interactive);animation:sk-bouncedelay 1.7s infinite ease-in-out both;margin-right:.1666666667rem}:host(.spinner-small) .spinner-dot:nth-child(1){animation-delay:-.6s}:host(.spinner-small) .spinner-dot:nth-child(2){animation-delay:-.4s}:host(.spinner-small) .spinner-dot:nth-child(3){animation-delay:-.2s}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: SpinnerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ec-spinner', template: "<div class=\"spinner\">\r\n  <span class=\"spinner-dot\"></span>\r\n  <span class=\"spinner-dot\"></span>\r\n  <span class=\"spinner-dot\"></span>\r\n  <span class=\"spinner-dot\"></span>\r\n</div>", styles: ["@keyframes sk-bouncedelay{0%,80%,to{opacity:0}40%{opacity:1}}.spinner{display:flex}.spinner-dot{width:.75rem;height:.75rem;background-color:var(--ec-color-interactive);animation:sk-bouncedelay 1.7s infinite ease-in-out both;margin-right:.25rem}.spinner-dot:nth-child(1){animation-delay:-.6s}.spinner-dot:nth-child(2){animation-delay:-.4s}.spinner-dot:nth-child(3){animation-delay:-.2s}:host(.spinner-small) .spinner-dot{width:.5rem;height:.5rem;background-color:var(--ec-color-interactive);animation:sk-bouncedelay 1.7s infinite ease-in-out both;margin-right:.1666666667rem}:host(.spinner-small) .spinner-dot:nth-child(1){animation-delay:-.6s}:host(.spinner-small) .spinner-dot:nth-child(2){animation-delay:-.4s}:host(.spinner-small) .spinner-dot:nth-child(3){animation-delay:-.2s}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3Bpbm5lci5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb21wb25lbnRzL3NyYy9saWIvZGlzcGxheS9zcGlubmVyL3NwaW5uZXIuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY29tcG9uZW50cy9zcmMvbGliL2Rpc3BsYXkvc3Bpbm5lci9zcGlubmVyLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBUTFDLGtJQUFrSTtBQUNsSSxNQUFNLE9BQU8sZ0JBQWdCOzs2R0FBaEIsZ0JBQWdCO2lHQUFoQixnQkFBZ0Isa0RDVDdCLHVNQUtNOzJGRElPLGdCQUFnQjtrQkFQNUIsU0FBUzsrQkFDRSxZQUFZIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcblxyXG5AQ29tcG9uZW50KHtcclxuICBzZWxlY3RvcjogJ2VjLXNwaW5uZXInLFxyXG4gIHRlbXBsYXRlVXJsOiAnLi9zcGlubmVyLmNvbXBvbmVudC5odG1sJyxcclxuICBzdHlsZVVybHM6IFsnLi9zcGlubmVyLmNvbXBvbmVudC5zY3NzJ11cclxufSlcclxuXHJcbi8qKiBFeHBvc2VzIHRoZSBtYXJrdXAgYW5kIHN0eWxlcyB0aGF0IHJlcHJlc2VudCB0aGUgc3Bpbm5lci4gTm8gaW5wdXRzIG9yIG91dHB1dHMgZGVmaW5lZCBiZWNhdXNlIGl0IGlzIGp1c3QgYSB2aXN1YWwgY29tcG9uZW50Ki9cclxuZXhwb3J0IGNsYXNzIFNwaW5uZXJDb21wb25lbnQgeyB9XHJcbiIsIjxkaXYgY2xhc3M9XCJzcGlubmVyXCI+XHJcbiAgPHNwYW4gY2xhc3M9XCJzcGlubmVyLWRvdFwiPjwvc3Bhbj5cclxuICA8c3BhbiBjbGFzcz1cInNwaW5uZXItZG90XCI+PC9zcGFuPlxyXG4gIDxzcGFuIGNsYXNzPVwic3Bpbm5lci1kb3RcIj48L3NwYW4+XHJcbiAgPHNwYW4gY2xhc3M9XCJzcGlubmVyLWRvdFwiPjwvc3Bhbj5cclxuPC9kaXY+Il19

package/esm2020/lib/display/splash/splash.component.mjs

@@ -0,0 +1,42 @@
+import { Component } from '@angular/core';
+import { Subject, timer } from 'rxjs';
+import { takeUntil, tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./splash.service";
+export class SplashComponent {
+    constructor(splashService) {
+        this.splashService = splashService;
+        /** Sets the visibility of the splash display */
+        this.isVisible = true;
+        this.stopAnimation = false;
+        /** Emits when the service is destroyed */
+        this.destroyed = new Subject();
+    }
+    ngOnInit() {
+        this.splashService.splashVisibility.pipe(takeUntil(this.destroyed), tap(async (value) => {
+            if (value) {
+                this.stopAnimation = false;
+            }
+            else {
+                // Prevent animation from continuing after splash screen is hidden
+                // but if we hide it then show while the timer is running, don't stop the animation after all
+                timer(1000).pipe(takeUntil(this.splashService.splashVisibility)).subscribe(() => {
+                    this.stopAnimation = true;
+                });
+            }
+        })).subscribe(showSplash => {
+            this.isVisible = showSplash;
+        });
+    }
+    ngOnDestroy() {
+        this.destroyed.next();
+        this.destroyed.unsubscribe();
+    }
+}
+SplashComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: SplashComponent, deps: [{ token: i1.SplashService }], target: i0.ɵɵFactoryTarget.Component });
+SplashComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.0", type: SplashComponent, selector: "ec-splash", ngImport: i0, template: "<div class=\"app-splash\"\r\n     [class.app-loaded]=\"!isVisible\">\r\n\r\n    <!-- This is the raw icon.svg file so we can animate it -->\r\n    <svg [class.d-none]=\"stopAnimation\" \r\n         xmlns=\"http://www.w3.org/2000/svg\"\r\n         width=\"50\"\r\n         height=\"50\"\r\n         viewBox=\"0 0 50 50\">\r\n        <g>\r\n            <g>\r\n                <path fill=\"#A0AD39\"\r\n                fill-rule=\"nonzero\"\r\n                d=\"M34.93,32.25 L34.93,37.25 L15.21,37.25 L15.21,32.25 L34.93,32.25 Z M28.45,22.48 L28.45,27.48 L15.21,27.48 L15.21,22.48 L28.45,22.48 Z M34.93,12.71 L34.93,17.71 L15.21,17.71 L15.21,12.71 L34.93,12.71 Z\" />\r\n                <path fill=\"#A0AD39\"\r\n                d=\"M24.99,5 C31.1,5 36.56,7.75 40.23,12.07 L44.33,9.16 C39.75,3.57 32.78,0 24.99,0 C17.2,0 10.23,3.57 5.65,9.16 L9.75,12.07 C13.42,7.75 18.88,5 24.99,5 Z\" />\r\n            </g>\r\n            <path fill=\"#17303B\"\r\n                  d=\"M40.24,37.93 C36.57,42.25 31.11,45 25,45 C18.89,45 13.43,42.25 9.76,37.93 L9.78,37.92 C6.82,34.43 5,29.94 5,25 C5,21.86 5.74,18.91 7.03,16.26 L2.89,13.33 C1.05,16.81 0,20.78 0,25 C0,31.01 2.13,36.52 5.66,40.83 L5.66,40.83 C10.24,46.42 17.21,49.99 25,49.99 C32.79,49.99 39.76,46.42 44.34,40.83 L40.24,37.93 Z\" />\r\n        </g>\r\n\r\n    </svg>\r\n</div>" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: SplashComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ec-splash', template: "<div class=\"app-splash\"\r\n     [class.app-loaded]=\"!isVisible\">\r\n\r\n    <!-- This is the raw icon.svg file so we can animate it -->\r\n    <svg [class.d-none]=\"stopAnimation\" \r\n         xmlns=\"http://www.w3.org/2000/svg\"\r\n         width=\"50\"\r\n         height=\"50\"\r\n         viewBox=\"0 0 50 50\">\r\n        <g>\r\n            <g>\r\n                <path fill=\"#A0AD39\"\r\n                fill-rule=\"nonzero\"\r\n                d=\"M34.93,32.25 L34.93,37.25 L15.21,37.25 L15.21,32.25 L34.93,32.25 Z M28.45,22.48 L28.45,27.48 L15.21,27.48 L15.21,22.48 L28.45,22.48 Z M34.93,12.71 L34.93,17.71 L15.21,17.71 L15.21,12.71 L34.93,12.71 Z\" />\r\n                <path fill=\"#A0AD39\"\r\n                d=\"M24.99,5 C31.1,5 36.56,7.75 40.23,12.07 L44.33,9.16 C39.75,3.57 32.78,0 24.99,0 C17.2,0 10.23,3.57 5.65,9.16 L9.75,12.07 C13.42,7.75 18.88,5 24.99,5 Z\" />\r\n            </g>\r\n            <path fill=\"#17303B\"\r\n                  d=\"M40.24,37.93 C36.57,42.25 31.11,45 25,45 C18.89,45 13.43,42.25 9.76,37.93 L9.78,37.92 C6.82,34.43 5,29.94 5,25 C5,21.86 5.74,18.91 7.03,16.26 L2.89,13.33 C1.05,16.81 0,20.78 0,25 C0,31.01 2.13,36.52 5.66,40.83 L5.66,40.83 C10.24,46.42 17.21,49.99 25,49.99 C32.79,49.99 39.76,46.42 44.34,40.83 L40.24,37.93 Z\" />\r\n        </g>\r\n\r\n    </svg>\r\n</div>" }]
+        }], ctorParameters: function () { return [{ type: i1.SplashService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/display/splash/splash.service.mjs

@@ -0,0 +1,35 @@
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class SplashService {
+    constructor() {
+        /** Used to interact with the splash component
+         *  The splash component will subscribe to this and any components
+         *  that wish to bring the splash visible can use this to communicate
+         *  with the splash component.
+         */
+        this._splashVisibility = new Subject();
+        this.splashVisibility = this._splashVisibility;
+    }
+    /**
+     * Shows the splash screen
+     */
+    showSplash() {
+        this._splashVisibility.next(true);
+    }
+    /**
+     * Hides the splash screen
+     */
+    hideSplash() {
+        this._splashVisibility.next(false);
+    }
+}
+SplashService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: SplashService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+SplashService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: SplashService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: SplashService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/display/table/resizable-column.component.mjs

@@ -0,0 +1,20 @@
+import { Component, EventEmitter, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ResizableColumnComponent {
+    constructor(el) {
+        this.el = el;
+        this.onResize = new EventEmitter();
+    }
+    emitWidth(width) {
+        this.onResize.emit(width);
+    }
+}
+ResizableColumnComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: ResizableColumnComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+ResizableColumnComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.0", type: ResizableColumnComponent, selector: "th.is-resizable", outputs: { onResize: "onResize" }, ngImport: i0, template: "<div class=\"content-wrapper\">\r\n  <div class=\"content\">\r\n    <ng-content></ng-content>\r\n  </div>\r\n</div>\r\n<div class=\"handle\"></div>\r\n" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: ResizableColumnComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'th.is-resizable', template: "<div class=\"content-wrapper\">\r\n  <div class=\"content\">\r\n    <ng-content></ng-content>\r\n  </div>\r\n</div>\r\n<div class=\"handle\"></div>\r\n" }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { onResize: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzaXphYmxlLWNvbHVtbi5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb21wb25lbnRzL3NyYy9saWIvZGlzcGxheS90YWJsZS9yZXNpemFibGUtY29sdW1uLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvbXBvbmVudHMvc3JjL2xpYi9kaXNwbGF5L3RhYmxlL3Jlc2l6YWJsZS1jb2x1bW4uY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBYyxZQUFZLEVBQUUsTUFBTSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQU01RSxNQUFNLE9BQU8sd0JBQXdCO0lBSW5DLFlBQW1CLEVBQWM7UUFBZCxPQUFFLEdBQUYsRUFBRSxDQUFZO1FBRnZCLGFBQVEsR0FBRyxJQUFJLFlBQVksRUFBVSxDQUFDO0lBRVgsQ0FBQztJQUUvQixTQUFTLENBQUMsS0FBYTtRQUM1QixJQUFJLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUM1QixDQUFDOztxSEFSVSx3QkFBd0I7eUdBQXhCLHdCQUF3QiwwRkNOckMseUpBTUE7MkZEQWEsd0JBQXdCO2tCQUpwQyxTQUFTOytCQUNFLGlCQUFpQjtpR0FLakIsUUFBUTtzQkFBakIsTUFBTSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudCwgRWxlbWVudFJlZiwgRXZlbnRFbWl0dGVyLCBPdXRwdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbkBDb21wb25lbnQoe1xyXG4gIHNlbGVjdG9yOiAndGguaXMtcmVzaXphYmxlJyxcclxuICB0ZW1wbGF0ZVVybDogJy4vcmVzaXphYmxlLWNvbHVtbi5jb21wb25lbnQuaHRtbCdcclxufSlcclxuZXhwb3J0IGNsYXNzIFJlc2l6YWJsZUNvbHVtbkNvbXBvbmVudCB7XHJcblxyXG4gIEBPdXRwdXQoKSBvblJlc2l6ZSA9IG5ldyBFdmVudEVtaXR0ZXI8bnVtYmVyPigpO1xyXG5cclxuICBjb25zdHJ1Y3RvcihwdWJsaWMgZWw6IEVsZW1lbnRSZWYpIHsgfVxyXG5cclxuICBwdWJsaWMgZW1pdFdpZHRoKHdpZHRoOiBudW1iZXIpIHtcclxuICAgIHRoaXMub25SZXNpemUuZW1pdCh3aWR0aCk7XHJcbiAgfVxyXG59XHJcbiIsIjxkaXYgY2xhc3M9XCJjb250ZW50LXdyYXBwZXJcIj5cclxuICA8ZGl2IGNsYXNzPVwiY29udGVudFwiPlxyXG4gICAgPG5nLWNvbnRlbnQ+PC9uZy1jb250ZW50PlxyXG4gIDwvZGl2PlxyXG48L2Rpdj5cclxuPGRpdiBjbGFzcz1cImhhbmRsZVwiPjwvZGl2PlxyXG4iXX0=

package/esm2020/lib/display/table/resizable-table.directive.mjs

@@ -0,0 +1,227 @@
+import { Directive, Inject, Input } from '@angular/core';
+import { DOCUMENT } from '@angular/common';
+import { ResizableBase } from '../resizable/resizable-base';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "../../core/cache.service";
+/**
+ * Add the ability to resize columns to a standard HTML table.
+ * Specify a column as resizable by adding the .is-resizable class to a <th>.
+ *
+ * Usage:
+  ```html
+  <table [ecResizableTable]>
+    <colgroup><col><col><col></colgroup>
+    <thead>
+      <tr>
+        <th class="is-resizable">Resizable</th>
+        <th class="is-resizable">Resizable</th>
+        <th>Static</th>
+      </tr>
+    </thead>
+    ...
+  </table>
+
+  ```
+  * Note: this directive is meant to be used internally with the TableComponent
+  * and is not exposed in the public-api of the library
+ */
+export class ResizableTableDirective extends ResizableBase {
+    constructor(el, renderer, cacheService, document) {
+        super(renderer, cacheService, document);
+        this.el = el;
+        this.sortableTable = false;
+        /**
+         * Stored reference to the <col> element children. Will throw if none are found. Will
+         * warn if the number of <col> elements do not match the number of <th> elements
+         */
+        this.cols = [];
+        /**
+         * The widths of each table column. These are updated as columns are resized and
+         * are used to calculate the new table width.
+         */
+        this.colWidths = [];
+        /**
+         * The current table width
+         */
+        this.currentTableWidth = 0;
+        /**
+         * The width of the table when the component was initialized. The table cannot
+         * be shrunk below this width. If a column resize would cause the current table
+         * width to be below this value, the last column is widened instead.
+         */
+        this.minTableWidth = 0;
+        /**
+         * The width the column can not be resized below.
+         */
+        this.minColWidth = 32;
+        this.destroyed = new Subject();
+    }
+    ngOnInit() {
+        this.initResizableColumns();
+        this.resizableColumns.changes.pipe(takeUntil(this.destroyed)).subscribe(() => this.initResizableColumns());
+    }
+    ngOnDestroy() {
+        this.destroyed.next();
+        this.destroyed.complete();
+    }
+    /**
+     * Initialize
+     * * Check that the host element is a table and that <col> elements are present
+     * * Save the initial width of table as the minimum table width
+     * * Store a reference to all <col> elements
+     * * Add a handle to each resizable column and set up mousedown listeners to start dragging
+     */
+    initResizableColumns() {
+        if (this.isResizable !== false) {
+            this.tableEl = this.el.nativeElement;
+            if (this.tableEl.tagName !== 'TABLE') {
+                throw new Error(`The 'ecResizableTable' directive can only be placed on a <table> element.`);
+            }
+            if (this.sortableTable) {
+                this.minColWidth = 48;
+            }
+            const headers = this.tableEl.querySelectorAll('th');
+            const cols = this.tableEl.querySelectorAll('col');
+            this.cols = [];
+            this.colWidths = [];
+            if (cols.length === 0) {
+                const fragment = this.document.createDocumentFragment();
+                const colgroup = this.renderer.createElement('colgroup');
+                headers.forEach(() => {
+                    const col = this.renderer.createElement('col');
+                    this.cols.push(col);
+                    this.renderer.appendChild(fragment, col);
+                });
+                this.renderer.appendChild(colgroup, fragment);
+                this.renderer.insertBefore(this.tableEl, colgroup, this.tableEl.firstElementChild);
+            }
+            else {
+                cols.forEach(colEl => {
+                    this.cols.push(colEl);
+                });
+                if (headers.length !== cols.length) {
+                    console.warn(`There are ${headers.length} <th> elements and ${this.cols.length} <col> elements in this this table. The number of columns and table headers must match. <th> elements with a 'colspan' attribute are currently not supported.`);
+                }
+            }
+            const lastResizableIndex = Array.from(headers).reverse().findIndex(el => el.classList.contains('is-resizable')) + 1;
+            this.lastColIndex = this.cols.length - lastResizableIndex;
+            headers.forEach(th => {
+                if (th.classList.contains('is-resizable')) {
+                    const handle = th.querySelector('.handle');
+                    this.renderer.listen(handle, 'mousedown', (event) => {
+                        this.currentEl = th;
+                        this.startDrag(event);
+                    });
+                }
+            });
+            // We need to wait a tick for a view that was previously loaded to be removed
+            // from the DOM and allow this directive's parent view to fully expand in the 
+            // viewport before getting widths.
+            window.setTimeout(() => {
+                this.setInitialWidths(headers);
+            });
+        }
+    }
+    /**
+     * Update the column with the calculated width while resizing.
+     * If the column is narrowed so that the table would be narrower than the min-width,
+     * expand the last column. If the table is then widened, return the last column
+     * to its initial width.
+     * @param width
+     */
+    setWidth(width) {
+        if (this.currentEl) {
+            const cellIndex = this.currentEl.cellIndex;
+            width = Math.max(width, this.minColWidth);
+            this.colWidths[cellIndex] = width;
+            this.renderer.setStyle(this.cols[cellIndex], 'width', width + 'px');
+            let totalColWidths = 0;
+            this.colWidths.forEach(w => {
+                totalColWidths += w;
+            });
+            const containerWidth = this.containerEl.nativeElement.clientWidth;
+            if (this.minTableWidth !== containerWidth) {
+                this.minTableWidth = containerWidth;
+            }
+            const diff = totalColWidths - this.minTableWidth;
+            if (diff < 0) {
+                const colIndex = cellIndex === this.lastColIndex ? this.lastColIndex - 1 : this.lastColIndex;
+                const colWidth = Math.max(this.colWidths[colIndex] + Math.abs(diff), this.minColWidth);
+                this.renderer.setStyle(this.cols[colIndex], 'width', colWidth + 'px');
+                this.renderer.setStyle(this.tableEl, 'width', this.minTableWidth + 'px');
+            }
+            else {
+                this.renderer.setStyle(this.tableEl, 'width', totalColWidths + 'px');
+            }
+        }
+    }
+    stopDrag(event) {
+        super.stopDrag(event);
+        if (this.currentEl) {
+            const cellIndex = this.currentEl.cellIndex;
+            const currentCol = this.resizableColumns.find(col => col.el.nativeElement.cellIndex === cellIndex);
+            if (currentCol) {
+                currentCol.emitWidth(Math.round(this.colWidths[cellIndex]));
+            }
+        }
+    }
+    /**
+     * Capture the initial width of the table and the table headers.
+     * @param headers
+     */
+    setInitialWidths(headers) {
+        this.currentTableWidth = this.tableEl.offsetWidth;
+        this.minTableWidth = this.containerEl.nativeElement.clientWidth;
+        headers.forEach(th => {
+            this.colWidths[th.cellIndex] = th.offsetWidth;
+            const width = th.style.width;
+            if (width) {
+                this.renderer.setStyle(this.cols[th.cellIndex], 'width', width);
+                this.renderer.removeStyle(th, 'width');
+            }
+        });
+        let totalColWidths = 0;
+        this.colWidths.forEach(w => {
+            totalColWidths += w;
+        });
+        // Check to see if our total column widths is greater than our table width
+        let colWidthDifference = totalColWidths - this.currentTableWidth;
+        // If the total column widths is greater than zero then its larger than our table container
+        // To prevent a horizontal scroll we will bump a columns width down to match the table size
+        if (colWidthDifference > 0) {
+            // Ideally we will choose the second to the last column, but if there is only one that'll do
+            let columnToReduce = headers.length > 1 ? headers.length - 2 : 0;
+            // Shrink the column
+            let th = headers[columnToReduce];
+            this.colWidths[th.cellIndex] = th.offsetWidth - colWidthDifference;
+            this.renderer.setStyle(this.cols[th.cellIndex], 'width', this.colWidths[th.cellIndex] + 'px');
+            // Reduce our totalColWidths to reflect
+            totalColWidths = totalColWidths - colWidthDifference;
+        }
+        this.renderer.setStyle(this.tableEl, 'width', Math.max(this.currentTableWidth, totalColWidths) + 'px');
+        this.renderer.setStyle(this.tableEl, 'minWidth', '100%');
+    }
+}
+ResizableTableDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: ResizableTableDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.CacheService }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Directive });
+ResizableTableDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.0", type: ResizableTableDirective, selector: "[ecResizableTable]", inputs: { isResizable: ["ecResizableTable", "isResizable"], containerEl: "containerEl", sortableTable: "sortableTable", resizableColumns: "resizableColumns" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.0", ngImport: i0, type: ResizableTableDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ecResizableTable]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.CacheService }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; }, propDecorators: { isResizable: [{
+                type: Input,
+                args: ['ecResizableTable']
+            }], containerEl: [{
+                type: Input
+            }], sortableTable: [{
+                type: Input
+            }], resizableColumns: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resizable-table.directive.js","sourceRoot":"","sources":["../../../../../../projects/components/src/lib/display/table/resizable-table.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, OnInit, Renderer2, Inject, Input, OnDestroy, QueryList } from '@angular/core';\r\nimport { DOCUMENT } from '@angular/common';\r\nimport { ResizableBase } from '../resizable/resizable-base';\r\nimport { CacheService } from '../../core/cache.service';\r\nimport { Subject } from 'rxjs';\r\nimport { takeUntil } from 'rxjs/operators';\r\nimport { ResizableColumnComponent } from './resizable-column.component';\r\n\r\n/**\r\n * Add the ability to resize columns to a standard HTML table.\r\n * Specify a column as resizable by adding the .is-resizable class to a <th>.\r\n * \r\n * Usage:\r\n  ```html\r\n  <table [ecResizableTable]>\r\n    <colgroup><col><col><col></colgroup>\r\n    <thead>\r\n      <tr>\r\n        <th class=\"is-resizable\">Resizable</th>\r\n        <th class=\"is-resizable\">Resizable</th>\r\n        <th>Static</th>\r\n      </tr>\r\n    </thead>\r\n    ...\r\n  </table>\r\n\r\n  ```\r\n  * Note: this directive is meant to be used internally with the TableComponent\r\n  * and is not exposed in the public-api of the library\r\n */\r\n@Directive({\r\n  selector: '[ecResizableTable]'\r\n})\r\nexport class ResizableTableDirective extends ResizableBase implements OnInit, OnDestroy {\r\n  @Input('ecResizableTable') isResizable: boolean | undefined;\r\n  @Input() containerEl!: ElementRef;\r\n  @Input() sortableTable: boolean = false;\r\n\r\n  /** \r\n   * Used to notify the resizable directive that the columns are ready to be configured.\r\n   * Must be used if the number of columns can change over the table's lifecycle.\r\n   */\r\n  @Input() resizableColumns!: QueryList<ResizableColumnComponent>;\r\n\r\n  /** The host <table> element. Will throw if host element is not a <table> */\r\n  private tableEl!: HTMLTableElement;\r\n\r\n  /** \r\n   * Stored reference to the <col> element children. Will throw if none are found. Will\r\n   * warn if the number of <col> elements do not match the number of <th> elements\r\n   */\r\n  private cols: HTMLTableColElement[] = [];\r\n\r\n  /**\r\n   * The widths of each table column. These are updated as columns are resized and\r\n   * are used to calculate the new table width.\r\n   */\r\n  private colWidths: number[] = [];\r\n\r\n  /**\r\n   * The current table width\r\n   */\r\n  private currentTableWidth: number = 0;\r\n\r\n  /**\r\n   * The width of the table when the component was initialized. The table cannot\r\n   * be shrunk below this width. If a column resize would cause the current table\r\n   * width to be below this value, the last column is widened instead.\r\n   */\r\n  private minTableWidth: number = 0;\r\n\r\n  /**\r\n   * The width the column can not be resized below.\r\n   */\r\n  private minColWidth: number = 32;\r\n\r\n  private lastColIndex!: number;\r\n\r\n  private destroyed: Subject<void> = new Subject();\r\n\r\n  constructor(\r\n    private el: ElementRef,\r\n    renderer: Renderer2,\r\n    cacheService: CacheService,\r\n    @Inject(DOCUMENT) document: Document\r\n  ) {\r\n    super(renderer, cacheService, document);\r\n  }\r\n\r\n  public ngOnInit(): void {\r\n    this.initResizableColumns();\r\n\r\n    this.resizableColumns.changes.pipe(takeUntil(this.destroyed)).subscribe(() => this.initResizableColumns());\r\n  }\r\n\r\n  ngOnDestroy() {\r\n    this.destroyed.next();\r\n    this.destroyed.complete();\r\n  }\r\n\r\n  /**\r\n   * Initialize\r\n   * * Check that the host element is a table and that <col> elements are present\r\n   * * Save the initial width of table as the minimum table width\r\n   * * Store a reference to all <col> elements\r\n   * * Add a handle to each resizable column and set up mousedown listeners to start dragging\r\n   */\r\n  private initResizableColumns() {\r\n    if (this.isResizable !== false) {\r\n\r\n      this.tableEl = this.el.nativeElement;\r\n      if (this.tableEl.tagName !== 'TABLE') {\r\n        throw new Error(`The 'ecResizableTable' directive can only be placed on a <table> element.`);\r\n      }\r\n\r\n      if (this.sortableTable) {\r\n        this.minColWidth = 48;\r\n      }\r\n  \r\n      const headers = this.tableEl.querySelectorAll('th');\r\n      const cols = this.tableEl.querySelectorAll('col');\r\n      this.cols = [];\r\n      this.colWidths = [];\r\n  \r\n      if (cols.length === 0) {\r\n        const fragment = this.document.createDocumentFragment();\r\n        const colgroup: HTMLElement = this.renderer.createElement('colgroup');\r\n        headers.forEach(() => {\r\n          const col = this.renderer.createElement('col');\r\n          this.cols.push(col);\r\n          this.renderer.appendChild(fragment, col);\r\n        });\r\n        this.renderer.appendChild(colgroup, fragment);\r\n        this.renderer.insertBefore(this.tableEl, colgroup, this.tableEl.firstElementChild);\r\n      } else {\r\n        cols.forEach(colEl => {\r\n          this.cols.push(colEl);\r\n        });\r\n  \r\n        if (headers.length !== cols.length) {\r\n          console.warn(`There are ${headers.length} <th> elements and ${this.cols.length} <col> elements in this this table. The number of columns and table headers must match. <th> elements with a 'colspan' attribute are currently not supported.`);\r\n        }\r\n      }\r\n\r\n      const lastResizableIndex = Array.from(headers).reverse().findIndex(el => el.classList.contains('is-resizable')) + 1;\r\n      this.lastColIndex = this.cols.length - lastResizableIndex;\r\n  \r\n      headers.forEach(th => {\r\n        if (th.classList.contains('is-resizable')) {\r\n          const handle = th.querySelector('.handle');\r\n\r\n          this.renderer.listen(handle, 'mousedown', (event: MouseEvent) => {\r\n            this.currentEl = th;\r\n            this.startDrag(event);\r\n          });\r\n        }\r\n      });\r\n  \r\n      // We need to wait a tick for a view that was previously loaded to be removed\r\n      // from the DOM and allow this directive's parent view to fully expand in the \r\n      // viewport before getting widths.\r\n      window.setTimeout(() => {\r\n        this.setInitialWidths(headers);\r\n      });\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Update the column with the calculated width while resizing.\r\n   * If the column is narrowed so that the table would be narrower than the min-width,\r\n   * expand the last column. If the table is then widened, return the last column\r\n   * to its initial width.\r\n   * @param width \r\n   */\r\n  protected setWidth(width: number): void {\r\n    if (this.currentEl) {\r\n      const cellIndex: number = (<HTMLTableHeaderCellElement>this.currentEl).cellIndex;\r\n      width = Math.max(width, this.minColWidth);\r\n      this.colWidths[cellIndex] = width;\r\n      this.renderer.setStyle(this.cols[cellIndex], 'width', width + 'px');\r\n\r\n      let totalColWidths = 0;\r\n      this.colWidths.forEach(w => {\r\n        totalColWidths += w;\r\n      });\r\n\r\n      const containerWidth = (<HTMLDivElement>this.containerEl.nativeElement).clientWidth;\r\n      if (this.minTableWidth !== containerWidth) {\r\n        this.minTableWidth = containerWidth;\r\n      }\r\n\r\n      const diff = totalColWidths - this.minTableWidth;      \r\n      if (diff < 0) {\r\n        const colIndex = cellIndex === this.lastColIndex ? this.lastColIndex - 1 : this.lastColIndex;\r\n        const colWidth = Math.max(this.colWidths[colIndex] + Math.abs(diff), this.minColWidth);\r\n        this.renderer.setStyle(this.cols[colIndex], 'width', colWidth + 'px');\r\n        this.renderer.setStyle(this.tableEl, 'width', this.minTableWidth + 'px');\r\n      } else {\r\n        this.renderer.setStyle(this.tableEl, 'width', totalColWidths + 'px');\r\n      }\r\n    }\r\n  }\r\n\r\n  protected stopDrag(event: MouseEvent) {\r\n    super.stopDrag(event);\r\n    \r\n    if (this.currentEl) {\r\n      const cellIndex = (<HTMLTableHeaderCellElement>this.currentEl).cellIndex;\r\n      const currentCol = this.resizableColumns.find(col => (<HTMLTableHeaderCellElement>col.el.nativeElement).cellIndex === cellIndex);\r\n      if (currentCol) {\r\n        currentCol.emitWidth(Math.round(this.colWidths[cellIndex]));\r\n      }\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Capture the initial width of the table and the table headers.\r\n   * @param headers \r\n   */\r\n  private setInitialWidths(headers: NodeListOf<HTMLTableHeaderCellElement>): void {\r\n    this.currentTableWidth = this.tableEl.offsetWidth;\r\n    this.minTableWidth = this.containerEl.nativeElement.clientWidth;\r\n\r\n    headers.forEach(th => {\r\n      this.colWidths[th.cellIndex] = th.offsetWidth;\r\n      const width = th.style.width;\r\n      if (width) {\r\n        this.renderer.setStyle(this.cols[th.cellIndex], 'width', width);\r\n        this.renderer.removeStyle(th, 'width');\r\n      }\r\n    });\r\n\r\n    let totalColWidths = 0;\r\n    this.colWidths.forEach(w => {\r\n      totalColWidths += w;\r\n    });\r\n\r\n    // Check to see if our total column widths is greater than our table width\r\n    let colWidthDifference = totalColWidths - this.currentTableWidth;\r\n   \r\n    // If the total column widths is greater than zero then its larger than our table container\r\n    // To prevent a horizontal scroll we will bump a columns width down to match the table size\r\n    if (colWidthDifference > 0) {\r\n      // Ideally we will choose the second to the last column, but if there is only one that'll do\r\n      let columnToReduce = headers.length > 1 ? headers.length - 2 : 0;\r\n\r\n      // Shrink the column\r\n      let th = headers[columnToReduce];\r\n      this.colWidths[th.cellIndex] = th.offsetWidth - colWidthDifference;\r\n      this.renderer.setStyle(this.cols[th.cellIndex], 'width', this.colWidths[th.cellIndex] + 'px');\r\n    \r\n      // Reduce our totalColWidths to reflect\r\n      totalColWidths = totalColWidths - colWidthDifference;\r\n    }\r\n\r\n    this.renderer.setStyle(this.tableEl, 'width', Math.max(this.currentTableWidth, totalColWidths) + 'px');\r\n    this.renderer.setStyle(this.tableEl, 'minWidth', '100%');\r\n  }\r\n}\r\n"]}