@theseam/ui-common 0.3.15-beta.0 → 0.3.15-beta.1

package/esm2020/viewers/pdf-viewer/pdf-viewer.component.mjs

@@ -0,0 +1,164 @@
+import { __decorate } from "tslib";
+import { coerceArray, coerceNumberProperty } from '@angular/cdk/coercion';
+import { Component, Input } from '@angular/core';
+import { BehaviorSubject, from, of, ReplaySubject } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+import { InputBoolean } from '@theseam/ui-common/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./pdf-renderer.service";
+import * as i2 from "@angular/common";
+import * as i3 from "./pdf-page/pdf-page.component";
+export class TheSeamPdfViewerComponent {
+    get pdfUrl() { return this._pdfUrl; }
+    set pdfUrl(value) {
+        this._pdfUrl = value;
+        this._documentSubject.next(value);
+    }
+    /**
+     * The canvas will be rerendered if the canvas size changes by this many
+     * pixels from the last render.
+     *
+     * To make the canvas responsive using only the initial size for its render
+     * set the threshold to `-1`. You can still trigger a rerender by calling the
+     * `render()` method.
+     *
+     * NOTE: Only used when `responsive` is `true`.
+     */
+    set renderUpdateThreshold(value) { this._renderUpdateThreshold = coerceNumberProperty(value); }
+    get renderUpdateThreshold() { return this._renderUpdateThreshold; }
+    /**
+     * Range of pages to render.
+     *
+     * Example(page 1 to page 3):
+     *  [pageRange]="[1,3]"
+     */
+    get pageRange() { return this._pageRange; }
+    set pageRange(value) {
+        this._pageRange = value;
+        if (!this._pageRange) {
+            this._pageNumbersSubject.next(undefined);
+        }
+        try {
+            const range = coerceArray(this._pageRange);
+            if (range.length !== 2) {
+                throw new Error('[pdf-viewer] Invalid Page Range. Range array must have two numbers only.');
+            }
+            if (range[0] > range[1]) {
+                throw new Error('[pdf-viewer] Invalid Page Range. Start of the range must be less than or equal to the end.');
+            }
+            const nums = [];
+            for (let i = range[0]; i <= range[1]; i++) {
+                nums.push(i);
+            }
+            this._pageNumbersSubject.next(nums);
+        }
+        catch (err) {
+            // TODO: Decide how to conveniently display these errors.
+            // eslint-disable-next-line no-console
+            console.error(err);
+            this._pageNumbersSubject.next([]);
+        }
+    }
+    /**
+     * Render a specific page.
+     */
+    get pageNumber() { return this._pageNumber; }
+    set pageNumber(value) {
+        this._pageNumber = coerceNumberProperty(value, -1);
+        this._pageNumbersSubject.next(this._pageNumber === -1 ? undefined : [this._pageNumber]);
+    }
+    /**
+     * Specific page numbers to render.
+     */
+    get pageNumbers() { return this._pageNumbers; }
+    set pageNumbers(value) {
+        this._pageNumbers = value;
+        if (Array.isArray(this._pageNumbers)) {
+            this._pageNumbersSubject.next(this._pageNumbers);
+        }
+        else {
+            this._pageNumbersSubject.next(undefined);
+        }
+    }
+    constructor(_pdfRenderer) {
+        this._pdfRenderer = _pdfRenderer;
+        this.shadow = false;
+        /**
+         * Canvas will responsively scale and rerender if scaled more than
+         * `renderUpdateThreshold` pixels.
+         */
+        this.responsive = false;
+        this._renderUpdateThreshold = 100;
+        this._pageRange = [];
+        this._pageNumber = -1;
+        this._pageNumbers = [];
+        this._documentSubject = new ReplaySubject(1);
+        /**
+         * Undefined means all a pages
+         */
+        this._pageNumbersSubject = new BehaviorSubject(undefined);
+        this.document$ = this._documentSubject.asObservable().pipe(switchMap(url => {
+            if (!url) {
+                return of();
+            }
+            return this._pdfRenderer.getDocument(url);
+        }));
+        const pageNumbers$ = this._pageNumbersSubject.asObservable();
+        this.pages$ = this.document$.pipe(switchMap(doc => pageNumbers$.pipe(map(pageNumbers => {
+            const pages = [];
+            for (let i = 0; i < doc.numPages; i++) {
+                if (!pageNumbers || pageNumbers.indexOf(i + 1) !== -1) {
+                    pages.push(from(doc.getPage(i + 1)));
+                }
+            }
+            return pages;
+        }))));
+    }
+}
+TheSeamPdfViewerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamPdfViewerComponent, deps: [{ token: i1.PdfRendererService }], target: i0.ɵɵFactoryTarget.Component });
+TheSeamPdfViewerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.9", type: TheSeamPdfViewerComponent, selector: "seam-pdf-viewer", inputs: { pdfUrl: "pdfUrl", shadow: "shadow", responsive: "responsive", renderUpdateThreshold: "renderUpdateThreshold", pageRange: "pageRange", pageNumber: "pageNumber", pageNumbers: "pageNumbers" }, ngImport: i0, template: `
+  <ng-container *ngFor="let page of pages$ | async">
+    <seam-pdf-page
+      class="mb-2"
+      [page]="page | async"
+      [responsive]="responsive"
+      [shadow]="shadow"
+      [renderUpdateThreshold]="renderUpdateThreshold">
+    </seam-pdf-page>
+  </ng-container>
+  `, isInline: true, styles: [":host{display:block}\n"], dependencies: [{ kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "component", type: i3.TheSeamPdfPageComponent, selector: "seam-pdf-page", inputs: ["page", "shadow", "responsive", "renderUpdateThreshold"] }, { kind: "pipe", type: i2.AsyncPipe, name: "async" }] });
+__decorate([
+    InputBoolean()
+], TheSeamPdfViewerComponent.prototype, "shadow", void 0);
+__decorate([
+    InputBoolean()
+], TheSeamPdfViewerComponent.prototype, "responsive", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamPdfViewerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'seam-pdf-viewer', template: `
+  <ng-container *ngFor="let page of pages$ | async">
+    <seam-pdf-page
+      class="mb-2"
+      [page]="page | async"
+      [responsive]="responsive"
+      [shadow]="shadow"
+      [renderUpdateThreshold]="renderUpdateThreshold">
+    </seam-pdf-page>
+  </ng-container>
+  `, styles: [":host{display:block}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.PdfRendererService }]; }, propDecorators: { pdfUrl: [{
+                type: Input
+            }], shadow: [{
+                type: Input
+            }], responsive: [{
+                type: Input
+            }], renderUpdateThreshold: [{
+                type: Input
+            }], pageRange: [{
+                type: Input
+            }], pageNumber: [{
+                type: Input
+            }], pageNumbers: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pdf-viewer.component.js","sourceRoot":"","sources":["../../../../../projects/ui-common/viewers/pdf-viewer/pdf-viewer.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { BooleanInput, coerceArray, coerceNumberProperty } from '@angular/cdk/coercion'\nimport { Component, Input } from '@angular/core'\nimport { BehaviorSubject, from, Observable, of, ReplaySubject } from 'rxjs'\nimport { map, shareReplay, switchMap, tap } from 'rxjs/operators'\n\nimport { InputBoolean } from '@theseam/ui-common/core'\nimport { wrapIntoObservable } from '@theseam/ui-common/utils'\n\nimport { PdfRendererService } from './pdf-renderer.service'\n\n@Component({\n  selector: 'seam-pdf-viewer',\n  template: `\n  <ng-container *ngFor=\"let page of pages$ | async\">\n    <seam-pdf-page\n      class=\"mb-2\"\n      [page]=\"page | async\"\n      [responsive]=\"responsive\"\n      [shadow]=\"shadow\"\n      [renderUpdateThreshold]=\"renderUpdateThreshold\">\n    </seam-pdf-page>\n  </ng-container>\n  `,\n  styles: [`:host { display: block; }`]\n})\nexport class TheSeamPdfViewerComponent {\n  static ngAcceptInputType_shadow: BooleanInput\n  static ngAcceptInputType_responsive: BooleanInput\n\n  @Input()\n  get pdfUrl(): string | undefined | null { return this._pdfUrl }\n  set pdfUrl(value: string | undefined | null) {\n    this._pdfUrl = value\n    this._documentSubject.next(value)\n  }\n  private _pdfUrl: string | undefined | null\n\n  @Input() @InputBoolean() shadow = false\n\n  /**\n   * Canvas will responsively scale and rerender if scaled more than\n   * `renderUpdateThreshold` pixels.\n   */\n  @Input() @InputBoolean() responsive = false\n\n  /**\n   * The canvas will be rerendered if the canvas size changes by this many\n   * pixels from the last render.\n   *\n   * To make the canvas responsive using only the initial size for its render\n   * set the threshold to `-1`. You can still trigger a rerender by calling the\n   * `render()` method.\n   *\n   * NOTE: Only used when `responsive` is `true`.\n   */\n  @Input()\n  set renderUpdateThreshold(value: number) { this._renderUpdateThreshold = coerceNumberProperty(value) }\n  get renderUpdateThreshold(): number { return this._renderUpdateThreshold }\n  private _renderUpdateThreshold = 100\n\n  /**\n   * Range of pages to render.\n   *\n   * Example(page 1 to page 3):\n   *  [pageRange]=\"[1,3]\"\n   */\n  @Input()\n  get pageRange(): number[] { return this._pageRange }\n  set pageRange(value: number[]) {\n    this._pageRange = value\n\n    if (!this._pageRange) {\n      this._pageNumbersSubject.next(undefined)\n    }\n\n    try {\n      const range = coerceArray(this._pageRange)\n      if (range.length !== 2) {\n        throw new Error('[pdf-viewer] Invalid Page Range. Range array must have two numbers only.')\n      }\n      if (range[0] > range[1]) {\n        throw new Error('[pdf-viewer] Invalid Page Range. Start of the range must be less than or equal to the end.')\n      }\n\n      const nums: number[] = []\n      for (let i = range[0]; i <= range[1]; i++) {\n        nums.push(i)\n      }\n      this._pageNumbersSubject.next(nums)\n    } catch (err) {\n      // TODO: Decide how to conveniently display these errors.\n      // eslint-disable-next-line no-console\n      console.error(err)\n      this._pageNumbersSubject.next([])\n    }\n  }\n  private _pageRange: number[] = []\n\n  /**\n   * Render a specific page.\n   */\n  @Input()\n  get pageNumber(): number { return this._pageNumber }\n  set pageNumber(value: number) {\n    this._pageNumber = coerceNumberProperty(value, -1)\n    this._pageNumbersSubject.next(this._pageNumber === -1 ? undefined : [ this._pageNumber ])\n  }\n  private _pageNumber = -1\n\n  /**\n   * Specific page numbers to render.\n   */\n  @Input()\n  get pageNumbers(): number[] { return this._pageNumbers }\n  set pageNumbers(value: number[]) {\n    this._pageNumbers = value\n    if (Array.isArray(this._pageNumbers)) {\n      this._pageNumbersSubject.next(this._pageNumbers)\n    } else {\n      this._pageNumbersSubject.next(undefined)\n    }\n  }\n  private _pageNumbers: number[] = []\n\n  private _documentSubject = new ReplaySubject<any>(1)\n  public document$: Observable<any>\n  public pages$: Observable<any[]>\n\n  /**\n   * Undefined means all a pages\n   */\n  private _pageNumbersSubject = new BehaviorSubject<number[] | undefined>(undefined)\n\n  constructor(\n    private readonly _pdfRenderer: PdfRendererService\n  ) {\n    this.document$ = this._documentSubject.asObservable().pipe(\n      switchMap(url => {\n        if (!url) {\n          return of()\n        }\n        return this._pdfRenderer.getDocument(url)\n      })\n    )\n\n    const pageNumbers$ = this._pageNumbersSubject.asObservable()\n\n    this.pages$ = this.document$.pipe(\n      switchMap(doc => pageNumbers$.pipe(\n        map(pageNumbers => {\n          const pages: any[] = []\n          for (let i = 0; i < doc.numPages; i++) {\n            if (!pageNumbers || pageNumbers.indexOf(i + 1) !== -1) {\n              pages.push(from(doc.getPage(i + 1)))\n            }\n          }\n          return pages\n        })\n      ))\n    )\n  }\n\n}\n"]}

package/esm2020/viewers/pdf-viewer/pdf-viewer.module.mjs

@@ -0,0 +1,33 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { TheSeamSharedModule } from '@theseam/ui-common/shared';
+import { TheSeamPdfPageComponent } from './pdf-page/pdf-page.component';
+import { TheSeamPdfViewerComponent } from './pdf-viewer.component';
+import * as i0 from "@angular/core";
+export class TheSeamPdfViewerModule {
+}
+TheSeamPdfViewerModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamPdfViewerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TheSeamPdfViewerModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: TheSeamPdfViewerModule, declarations: [TheSeamPdfViewerComponent,
+        TheSeamPdfPageComponent], imports: [CommonModule,
+        TheSeamSharedModule], exports: [TheSeamPdfViewerComponent,
+        TheSeamPdfPageComponent] });
+TheSeamPdfViewerModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamPdfViewerModule, imports: [CommonModule,
+        TheSeamSharedModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamPdfViewerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        TheSeamSharedModule
+                    ],
+                    declarations: [
+                        TheSeamPdfViewerComponent,
+                        TheSeamPdfPageComponent
+                    ],
+                    exports: [
+                        TheSeamPdfViewerComponent,
+                        TheSeamPdfPageComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGRmLXZpZXdlci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vdmlld2Vycy9wZGYtdmlld2VyL3BkZi12aWV3ZXIubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQTtBQUM5QyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFBO0FBRXhDLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDJCQUEyQixDQUFBO0FBRS9ELE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLCtCQUErQixDQUFBO0FBQ3ZFLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLHdCQUF3QixDQUFBOztBQWdCbEUsTUFBTSxPQUFPLHNCQUFzQjs7bUhBQXRCLHNCQUFzQjtvSEFBdEIsc0JBQXNCLGlCQVIvQix5QkFBeUI7UUFDekIsdUJBQXVCLGFBTHZCLFlBQVk7UUFDWixtQkFBbUIsYUFPbkIseUJBQXlCO1FBQ3pCLHVCQUF1QjtvSEFHZCxzQkFBc0IsWUFaL0IsWUFBWTtRQUNaLG1CQUFtQjsyRkFXVixzQkFBc0I7a0JBZGxDLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFO3dCQUNQLFlBQVk7d0JBQ1osbUJBQW1CO3FCQUNwQjtvQkFDRCxZQUFZLEVBQUU7d0JBQ1oseUJBQXlCO3dCQUN6Qix1QkFBdUI7cUJBQ3hCO29CQUNELE9BQU8sRUFBRTt3QkFDUCx5QkFBeUI7d0JBQ3pCLHVCQUF1QjtxQkFDeEI7aUJBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nXG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5cbmltcG9ydCB7IFRoZVNlYW1TaGFyZWRNb2R1bGUgfSBmcm9tICdAdGhlc2VhbS91aS1jb21tb24vc2hhcmVkJ1xuXG5pbXBvcnQgeyBUaGVTZWFtUGRmUGFnZUNvbXBvbmVudCB9IGZyb20gJy4vcGRmLXBhZ2UvcGRmLXBhZ2UuY29tcG9uZW50J1xuaW1wb3J0IHsgVGhlU2VhbVBkZlZpZXdlckNvbXBvbmVudCB9IGZyb20gJy4vcGRmLXZpZXdlci5jb21wb25lbnQnXG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtcbiAgICBDb21tb25Nb2R1bGUsXG4gICAgVGhlU2VhbVNoYXJlZE1vZHVsZVxuICBdLFxuICBkZWNsYXJhdGlvbnM6IFtcbiAgICBUaGVTZWFtUGRmVmlld2VyQ29tcG9uZW50LFxuICAgIFRoZVNlYW1QZGZQYWdlQ29tcG9uZW50XG4gIF0sXG4gIGV4cG9ydHM6IFtcbiAgICBUaGVTZWFtUGRmVmlld2VyQ29tcG9uZW50LFxuICAgIFRoZVNlYW1QZGZQYWdlQ29tcG9uZW50XG4gIF1cbn0pXG5leHBvcnQgY2xhc3MgVGhlU2VhbVBkZlZpZXdlck1vZHVsZSB7IH1cbiJdfQ==

package/esm2020/widget/directives/widget-drag-handle.directive.mjs

@@ -0,0 +1,150 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Directive, Inject, InjectionToken, Input, Optional } from '@angular/core';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { auditTime, filter, switchMap, take, takeUntil } from 'rxjs/operators';
+import { getClosestWidgetCdkDrag } from '@theseam/ui-common/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/drag-drop";
+export function extendStyles(dest, source) {
+    for (const key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            dest[key] = source[key];
+        }
+    }
+    return dest;
+}
+export function toggleNativeDragInteractions(element, enable) {
+    const userSelect = enable ? '' : 'none';
+    extendStyles(element.style, {
+        touchAction: enable ? '' : 'none',
+        webkitUserDrag: enable ? '' : 'none',
+        userSelect,
+        msUserSelect: userSelect,
+        webkitUserSelect: userSelect,
+        MozUserSelect: userSelect
+    });
+}
+export const THESEAM_WIDGET_ACCESSOR = new InjectionToken('TheSeamWidgetAccessor');
+export class WidgetDragHandleDirective {
+    /** Needed because CdkDrag reads this variable */
+    get _parentDrag() { return this.getParentCdkDrag(); }
+    /** Whether starting to drag through this handle is disabled. */
+    get disabled() { return this._disabled; }
+    set disabled(value) {
+        this._disabled = coerceBooleanProperty(value);
+        this._stateChanges.next(this);
+    }
+    constructor(element, _ngZone, _dashboardWidgets, __parentDrag) {
+        this.element = element;
+        this._ngZone = _ngZone;
+        this._dashboardWidgets = _dashboardWidgets;
+        this.__parentDrag = __parentDrag;
+        this._ngUnsubscribe = new Subject();
+        this._attachedToDom = new BehaviorSubject(false);
+        this._doneCheckingAttached = false;
+        /** Emits when the state of the handle has changed. */
+        this._stateChanges = new Subject();
+        this._disabled = false;
+        toggleNativeDragInteractions(element.nativeElement, false);
+    }
+    ngOnInit() {
+        if (this._dashboardWidgets) {
+            this._dashboardWidgets.widgetsChange.pipe(auditTime(0), takeUntil(this._ngUnsubscribe)).subscribe(() => {
+                if (this._knownParentDrag) {
+                    const isAttached = this.isAttachedToDom();
+                    if (isAttached) {
+                        const parent = this.getParentCdkDrag();
+                        if (this._knownParentDrag !== parent) {
+                            this._attachedToDom.next(isAttached);
+                        }
+                    }
+                }
+            });
+        }
+    }
+    ngAfterViewInit() {
+        if (this.__parentDrag || this._dashboardWidgets) {
+            // FIXME: This only works until the widget is moved to another template
+            // outlet. Now that the component isn't reinitialized when moving between
+            // lists the handle needs to now reflex that change to its new CdkDrag
+            // parent and possibly tell its previous parent to forget it.
+            // HACK: This is a hack to allow the `CdkDrag` directive to manage a
+            // handle that is not visible to `ContentChildren` query.
+            this._ngZone.onStable.asObservable()
+                // .pipe(take(1), untilDestroyed(this))
+                .pipe(take(1), 
+            // With the weird trick being done to keep widgets initialized when switching columns
+            switchMap(() => this._attachedToDom.pipe(filter(v => v === true))), 
+            // take(1)
+            takeUntil(this._ngUnsubscribe))
+                .subscribe(() => {
+                const parent = this.getParentCdkDrag();
+                if (this._knownParentDrag && this._knownParentDrag !== parent) {
+                    this._knownParentDrag._dragRef.disableHandle(this.element.nativeElement);
+                    this._knownParentDrag = undefined;
+                }
+                if (parent) {
+                    this._knownParentDrag = parent;
+                    parent._handles.reset([...parent._handles._results, this]);
+                    parent._handles.notifyOnChanges();
+                    parent._dragRef.enableHandle(this.element.nativeElement);
+                }
+            });
+        }
+    }
+    ngOnDestroy() {
+        this._stateChanges.complete();
+        this._attachedToDom.complete();
+        this._ngUnsubscribe.next(undefined);
+        this._ngUnsubscribe.complete();
+    }
+    ngDoCheck() {
+        // The attached observable only emits once, so we can stop checking if
+        // attached.
+        if (this._doneCheckingAttached) {
+            return;
+        }
+        const isAttached = this.isAttachedToDom();
+        if (isAttached !== this._attachedToDom.value) {
+            this._attachedToDom.next(isAttached);
+            this._doneCheckingAttached = true;
+        }
+    }
+    isAttachedToDom() {
+        return document.body.contains(this.element.nativeElement);
+    }
+    /** Closest parent draggable instance. */
+    getParentCdkDrag() {
+        if (this.__parentDrag) {
+            return this.__parentDrag;
+        }
+        else if (this._dashboardWidgets && this._dashboardWidgets.cdkDragDirectives) {
+            const dragsArr = this._dashboardWidgets.cdkDragDirectives.toArray();
+            const closest = getClosestWidgetCdkDrag(this.element, dragsArr);
+            return (closest !== undefined && closest !== null) ? closest : undefined;
+        }
+    }
+}
+WidgetDragHandleDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: WidgetDragHandleDirective, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }, { token: THESEAM_WIDGET_ACCESSOR, optional: true }, { token: i1.CdkDrag, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+WidgetDragHandleDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: WidgetDragHandleDirective, selector: "[seamWidgetDragHandle]", inputs: { disabled: ["cdkDragHandleDisabled", "disabled"] }, host: { classAttribute: "cdk-drag-handle" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: WidgetDragHandleDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[seamWidgetDragHandle]',
+                    host: {
+                        'class': 'cdk-drag-handle'
+                    }
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [THESEAM_WIDGET_ACCESSOR]
+                }] }, { type: i1.CdkDrag, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { disabled: [{
+                type: Input,
+                args: ['cdkDragHandleDisabled']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget-drag-handle.directive.js","sourceRoot":"","sources":["../../../../../projects/ui-common/widget/directives/widget-drag-handle.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { BooleanInput, coerceBooleanProperty } from '@angular/cdk/coercion'\nimport { CdkDrag, CdkDragHandle } from '@angular/cdk/drag-drop'\nimport {\n  AfterViewInit,\n  Directive,\n  DoCheck,\n  ElementRef,\n  EventEmitter,\n  Inject,\n  InjectionToken,\n  Input,\n  NgZone,\n  OnDestroy,\n  OnInit,\n  Optional,\n  QueryList\n} from '@angular/core'\nimport { BehaviorSubject, Subject } from 'rxjs'\nimport { auditTime, filter, switchMap, take, takeUntil } from 'rxjs/operators'\n\nimport { getClosestWidgetCdkDrag } from '@theseam/ui-common/utils'\n\n//\n// NOTE: This will probably NOT be used long term, unless more of the\n// CdkDragDrop code is rewritten.\n//\n// This directive is meant to be a HACK replacement directive for CdkDragHandle.\n// The reason this was made is because CdkDragHandle doesn't work in child\n// components, since it uses ContentChildren to query for the handles.\n//\n// This could easily break, because I am forcing the handles query list to emit\n// changes manually. So, if the query list actually changes, then my changes\n// will be broken.\n//\n\n// Helper type that ignores `readonly` properties. This is used in\n// `extendStyles` to ignore the readonly properties on CSSStyleDeclaration\n// since we won't be touching those anyway.\ntype Writeable<T> = { -readonly [P in keyof T]-?: T[P] }\n\n/**\n * Extended CSSStyleDeclaration that includes a couple of drag-related\n * properties that aren't in the built-in TS typings.\n */\ninterface DragCSSStyleDeclaration extends CSSStyleDeclaration {\n  webkitUserDrag: string\n  MozUserSelect: string // For some reason the Firefox property is in PascalCase.\n  msScrollSnapType: string\n  scrollSnapType: string\n  msUserSelect: string\n}\n\nexport function extendStyles(\n  dest: Writeable<CSSStyleDeclaration>,\n  source: Partial<DragCSSStyleDeclaration>\n) {\n  for (const key in source) {\n    if (Object.prototype.hasOwnProperty.call(source, key)) {\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      dest[key] = source[key]!\n    }\n  }\n\n  return dest\n}\n\nexport function toggleNativeDragInteractions(element: HTMLElement, enable: boolean) {\n  const userSelect = enable ? '' : 'none'\n\n  extendStyles(element.style, {\n    touchAction: enable ? '' : 'none',\n    webkitUserDrag: enable ? '' : 'none',\n    userSelect,\n    msUserSelect: userSelect,\n    webkitUserSelect: userSelect,\n    MozUserSelect: userSelect\n  })\n}\n\nexport interface TheSeamWidgetAccessor<TItem> {\n  widgetsChange: EventEmitter<TItem[]>\n  cdkDragDirectives: QueryList<CdkDrag>\n}\n\nexport const THESEAM_WIDGET_ACCESSOR = new InjectionToken<TheSeamWidgetAccessor<any>>(\n  'TheSeamWidgetAccessor'\n)\n\n@Directive({\n  selector: '[seamWidgetDragHandle]',\n  host: {\n    'class': 'cdk-drag-handle'\n  }\n})\nexport class WidgetDragHandleDirective implements OnInit, OnDestroy, AfterViewInit, DoCheck {\n  static ngAcceptInputType_disabled: BooleanInput\n\n  private readonly _ngUnsubscribe = new Subject<void>()\n\n  private _attachedToDom = new BehaviorSubject<boolean>(false)\n  private _doneCheckingAttached = false\n  private _knownParentDrag: any /* CdkDrag | undefined */\n\n  /** Needed because CdkDrag reads this variable */\n  get _parentDrag() { return this.getParentCdkDrag() }\n\n  /** Emits when the state of the handle has changed. */\n  _stateChanges = new Subject<CdkDragHandle>()\n\n  /** Whether starting to drag through this handle is disabled. */\n  @Input('cdkDragHandleDisabled')\n  get disabled(): boolean { return this._disabled }\n  set disabled(value: boolean) {\n    this._disabled = coerceBooleanProperty(value)\n    this._stateChanges.next(this as any)\n  }\n  private _disabled = false\n\n  constructor(\n    public element: ElementRef<HTMLElement>,\n    private _ngZone: NgZone,\n    @Optional() @Inject(THESEAM_WIDGET_ACCESSOR) private _dashboardWidgets?: TheSeamWidgetAccessor<any>,\n    @Optional() private __parentDrag?: CdkDrag\n  ) {\n    toggleNativeDragInteractions(element.nativeElement, false)\n  }\n\n  ngOnInit() {\n    if (this._dashboardWidgets) {\n      this._dashboardWidgets.widgetsChange.pipe(\n        auditTime(0),\n        takeUntil(this._ngUnsubscribe)\n      ).subscribe(() => {\n        if (this._knownParentDrag) {\n          const isAttached = this.isAttachedToDom()\n          if (isAttached) {\n            const parent = this.getParentCdkDrag() as any\n            if (this._knownParentDrag !== parent) {\n              this._attachedToDom.next(isAttached)\n            }\n          }\n        }\n      })\n    }\n  }\n\n  ngAfterViewInit() {\n    if (this.__parentDrag || this._dashboardWidgets) {\n      // FIXME: This only works until the widget is moved to another template\n      // outlet. Now that the component isn't reinitialized when moving between\n      // lists the handle needs to now reflex that change to its new CdkDrag\n      // parent and possibly tell its previous parent to forget it.\n\n      // HACK: This is a hack to allow the `CdkDrag` directive to manage a\n      // handle that is not visible to `ContentChildren` query.\n      this._ngZone.onStable.asObservable()\n        // .pipe(take(1), untilDestroyed(this))\n        .pipe(\n          take(1),\n          // With the weird trick being done to keep widgets initialized when switching columns\n          switchMap(() => this._attachedToDom.pipe(filter(v => v === true))),\n          // take(1)\n          takeUntil(this._ngUnsubscribe)\n        )\n        .subscribe(() => {\n          const parent = this.getParentCdkDrag() as any\n\n          if (this._knownParentDrag && this._knownParentDrag !== parent) {\n            this._knownParentDrag._dragRef.disableHandle(this.element.nativeElement)\n            this._knownParentDrag = undefined\n          }\n\n          if (parent) {\n            this._knownParentDrag = parent\n            parent._handles.reset([ ...parent._handles._results, this ])\n            parent._handles.notifyOnChanges()\n            parent._dragRef.enableHandle(this.element.nativeElement)\n          }\n        })\n    }\n  }\n\n  ngOnDestroy() {\n    this._stateChanges.complete()\n    this._attachedToDom.complete()\n\n    this._ngUnsubscribe.next(undefined)\n    this._ngUnsubscribe.complete()\n  }\n\n  ngDoCheck() {\n    // The attached observable only emits once, so we can stop checking if\n    // attached.\n    if (this._doneCheckingAttached) { return }\n\n    const isAttached = this.isAttachedToDom()\n    if (isAttached !== this._attachedToDom.value) {\n      this._attachedToDom.next(isAttached)\n      this._doneCheckingAttached = true\n    }\n  }\n\n  public isAttachedToDom(): boolean {\n    return document.body.contains(this.element.nativeElement)\n  }\n\n  /** Closest parent draggable instance. */\n  public getParentCdkDrag(): CdkDrag | undefined {\n    if (this.__parentDrag) {\n      return this.__parentDrag\n    } else if (this._dashboardWidgets && this._dashboardWidgets.cdkDragDirectives) {\n      const dragsArr = this._dashboardWidgets.cdkDragDirectives.toArray()\n      const closest = getClosestWidgetCdkDrag(this.element, dragsArr)\n      return (closest !== undefined && closest !== null) ? closest : undefined\n    }\n  }\n\n}\n"]}

package/esm2020/widget/directives/widget-icon-tpl.directive.mjs

@@ -0,0 +1,16 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class WidgetIconTplDirective {
+    constructor(template) {
+        this.template = template;
+    }
+}
+WidgetIconTplDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: WidgetIconTplDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+WidgetIconTplDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: WidgetIconTplDirective, selector: "[seamWidgetIconTpl]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: WidgetIconTplDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[seamWidgetIconTpl]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2lkZ2V0LWljb24tdHBsLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi93aWRnZXQvZGlyZWN0aXZlcy93aWRnZXQtaWNvbi10cGwuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQWUsTUFBTSxlQUFlLENBQUE7O0FBS3RELE1BQU0sT0FBTyxzQkFBc0I7SUFFakMsWUFBbUIsUUFBMEI7UUFBMUIsYUFBUSxHQUFSLFFBQVEsQ0FBa0I7SUFBSSxDQUFDOzttSEFGdkMsc0JBQXNCO3VHQUF0QixzQkFBc0I7MkZBQXRCLHNCQUFzQjtrQkFIbEMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUscUJBQXFCO2lCQUNoQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgVGVtcGxhdGVSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbc2VhbVdpZGdldEljb25UcGxdJ1xufSlcbmV4cG9ydCBjbGFzcyBXaWRnZXRJY29uVHBsRGlyZWN0aXZlIHtcblxuICBjb25zdHJ1Y3RvcihwdWJsaWMgdGVtcGxhdGU6IFRlbXBsYXRlUmVmPGFueT4pIHsgfVxuXG59XG4iXX0=

package/esm2020/widget/directives/widget-title-tpl.directive.mjs

@@ -0,0 +1,16 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class WidgetTitleTplDirective {
+    constructor(template) {
+        this.template = template;
+    }
+}
+WidgetTitleTplDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: WidgetTitleTplDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+WidgetTitleTplDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: WidgetTitleTplDirective, selector: "[seamWidgetTitleTpl]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: WidgetTitleTplDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[seamWidgetTitleTpl]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2lkZ2V0LXRpdGxlLXRwbC5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vd2lkZ2V0L2RpcmVjdGl2ZXMvd2lkZ2V0LXRpdGxlLXRwbC5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBZSxNQUFNLGVBQWUsQ0FBQTs7QUFLdEQsTUFBTSxPQUFPLHVCQUF1QjtJQUVsQyxZQUFtQixRQUEwQjtRQUExQixhQUFRLEdBQVIsUUFBUSxDQUFrQjtJQUFJLENBQUM7O29IQUZ2Qyx1QkFBdUI7d0dBQXZCLHVCQUF1QjsyRkFBdkIsdUJBQXVCO2tCQUhuQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxzQkFBc0I7aUJBQ2pDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBUZW1wbGF0ZVJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ1tzZWFtV2lkZ2V0VGl0bGVUcGxdJ1xufSlcbmV4cG9ydCBjbGFzcyBXaWRnZXRUaXRsZVRwbERpcmVjdGl2ZSB7XG5cbiAgY29uc3RydWN0b3IocHVibGljIHRlbXBsYXRlOiBUZW1wbGF0ZVJlZjxhbnk+KSB7IH1cblxufVxuIl19

package/esm2020/widget/widget/widget.component.mjs

@@ -0,0 +1,142 @@
+import { __decorate } from "tslib";
+import { animate, style, transition, trigger } from '@angular/animations';
+import { Component, ContentChild, Input, ViewEncapsulation } from '@angular/core';
+import { faAngleDown, faCog } from '@fortawesome/free-solid-svg-icons';
+import { InputBoolean } from '@theseam/ui-common/core';
+import { WidgetIconTplDirective } from '../directives/widget-icon-tpl.directive';
+import { WidgetTitleTplDirective } from '../directives/widget-title-tpl.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@fortawesome/angular-fontawesome";
+import * as i3 from "@theseam/ui-common/icon";
+import * as i4 from "@theseam/ui-common/loading";
+import * as i5 from "@theseam/ui-common/buttons";
+import * as i6 from "../directives/widget-drag-handle.directive";
+/**
+ * Widget
+ *
+ * Widgets are designed with the intention of being on a dashboard. Other uses
+ * may be supported as the need arises.
+ *
+ * The only HTML/CSS use should be a widget content component, unless there is a
+ * case requiring more advanced design. This is so that we can manage a common
+ * style for our widgets. If a case requiring non widget content components is
+ * used then the situation should be considered for becoming a widget component.
+ */
+export class WidgetComponent {
+    constructor() {
+        /** @ignore */
+        this.configIcon = faCog;
+        /** @ignore */
+        this.collapseIcon = faAngleDown;
+        this.collapsed = false;
+        /**
+         * Toggles the top header bar of a widget. This should be true for most
+         * widgets.
+         */
+        this.hasHeader = true;
+        /** Shows widget loading instead of content. */
+        this.loading = false;
+        /** @ignore */
+        // NOTE: Config is still being worked on.
+        this.hasConfig = false;
+        /** @ignore */
+        // NOTE: Collapse is still being worked on.
+        this.canCollapse = false;
+    }
+    /**
+     * Icon displayed in the top header.
+     *
+     * If a more advanced icon is needed you can use `seamWidgetIconTpl` template
+     * directive, but a `SeamIcon` input is recommended, because allowing custom
+     * icons that do not follow the tested types can lead to inconsitency quickly
+     * as different developers keep making tweaks.
+     */
+    get icon() { return this._iconUrl || this._iconObj; }
+    set icon(value) {
+        if (typeof value === 'string') {
+            this._iconUrl = value;
+            this._iconObj = undefined;
+        }
+        else {
+            this._iconUrl = undefined;
+            this._iconObj = value;
+        }
+    }
+    /**
+     * Toggles a widget's collapsed state.
+     *
+     * NOTE: Collapse is still being worked on.
+     * @depracated
+     * @ignore
+     */
+    collapse() {
+        this.collapsed = !this.collapsed;
+    }
+}
+WidgetComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: WidgetComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+WidgetComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.9", type: WidgetComponent, selector: "seam-widget", inputs: { collapsed: "collapsed", hasHeader: "hasHeader", titleText: "titleText", icon: "icon", iconClass: "iconClass", loading: "loading", hasConfig: "hasConfig", canCollapse: "canCollapse" }, queries: [{ propertyName: "iconTpl", first: true, predicate: WidgetIconTplDirective, descendants: true, static: true }, { propertyName: "titleTpl", first: true, predicate: WidgetTitleTplDirective, descendants: true, static: true }], ngImport: i0, template: "<div class=\"seam-widget border rounded overflow-hidden\">\n  <div class=\"widget-header\" seamWidgetDragHandle *ngIf=\"hasHeader\">\n    <div class=\"widget-header-content p-2 text-nowrap\">\n      <span class=\"mr-1 widget-header-icon\">\n        <ng-container *ngIf=\"iconTpl; else noIconTpl\">\n          <ng-template\n            [ngTemplateOutlet]=\"iconTpl.template\"\n            [ngTemplateOutletContext]=\"{ $implicit: icon, icon: icon, title: titleText }\">\n          </ng-template>\n        </ng-container>\n        <ng-template #noIconTpl>\n          <fa-icon *ngIf=\"_iconObj\"\n            class=\"widget-header-icon--fa {{ iconClass }}\"\n            [icon]=\"_iconObj\"></fa-icon>\n          <img *ngIf=\"_iconUrl\"\n            class=\"widget-header-icon--img {{ iconClass }}\"\n            [src]=\"_iconUrl\" [alt]=\"titleText\">\n        </ng-template>\n      </span>\n      <span class=\"widget-header-title text-truncate\">\n        <ng-container *ngIf=\"titleTpl; else noTitleTpl\">\n          <ng-template\n            [ngTemplateOutlet]=\"titleTpl.template\"\n            [ngTemplateOutletContext]=\"{ $implicit: titleText, icon: icon, title: titleText }\">\n          </ng-template>\n        </ng-container>\n        <ng-template #noTitleTpl>{{ titleText }}</ng-template>\n      </span>\n    </div>\n    <div class=\"widget-header-btns-container\" *ngIf=\"hasConfig || canCollapse\">\n      <div *ngIf=\"hasConfig\">\n        <!-- <button seamIconBtn [icon]=\"configIcon\"\n          class=\"widget-header-btn-config\"\n          iconType=\"\">\n          <span class=\"sr-only\">Widget configuration menu</span>\n        </button> -->\n        <button seamButton class=\"widget-header-btn-config p-0\">\n          <seam-icon class=\"d-block\" [icon]=\"configIcon\" iconClass=\"text-secondary\"></seam-icon>\n          <span class=\"sr-only\">Widget configuration menu</span>\n        </button>\n      </div>\n\n      <div *ngIf=\"canCollapse\" class=\"px-0\">\n        <button seamButton class=\"widget-header-btn-collapse p-0\" (click)=\"collapse()\">\n          <seam-icon class=\"d-block\" [icon]=\"collapseIcon\" iconClass=\"text-secondary\" style=\"margin-left: -10px; margin-right: -5px;\"></seam-icon>\n          <span class=\"sr-only\">Widget collapse</span>\n        </button>\n      </div>\n    </div>\n  </div>\n  <div class=\"position-relative\" [style.height.px]=\"loading ? 150 : undefined\">\n    <ng-container *ngIf=\"!collapsed\">\n      <div class=\"p-2\" *ngIf=\"!loading else loadingTpl\">\n        <ng-content></ng-content>\n      </div>\n      <ng-content select=\"seam-widget-footer\"></ng-content>\n      <ng-template #loadingTpl>\n        <div class=\"position-absolute\" @loadingAnim style=\"top:0;right:0;bottom:0;left:0\">\n          <seam-loading [theme]=\"'primary'\"></seam-loading>\n        </div>\n      </ng-template>\n    </ng-container>\n  </div>\n</div>\n", styles: ["seam-widget{display:block;font-size:15px}seam-widget .seam-widget{background:#FFFFFF;box-shadow:none}seam-widget .widget-header{display:flex;flex-direction:row;border-bottom:1px solid #dee2e6;background:#F4F4F4;font-size:17px}seam-widget .widget-header .widget-header-content{flex:1 1 100%}seam-widget .widget-header .widget-header-btns-container{display:flex;flex-direction:row}seam-widget .widget-header .widget-header-btns-container>div{display:flex;flex-direction:column;justify-content:center;padding:4px}seam-widget .widget-header .widget-header-btns-container .widget-header-btn-config .seam-icon--fa{display:flex;flex-direction:row;justify-content:center;text-align:center;height:25px;width:30px}seam-widget .widget-header .widget-header-btns-container .widget-header-btn-config .seam-icon--fa .svg-inline--fa{max-width:100%;height:100%;width:100%}seam-widget .widget-header .widget-header-btns-container .widget-header-btn-collapse .seam-icon--fa{display:flex;flex-direction:row;justify-content:center;text-align:center;height:15px;width:30px}seam-widget .widget-header .widget-header-btns-container .widget-header-btn-collapse .seam-icon--fa .svg-inline--fa{max-width:100%;height:100%;width:100%}seam-widget .widget-header .widget-header-title{font-size:17px}seam-widget .widget-header-icon{display:inline-block;vertical-align:top;max-height:20px;max-width:20px;height:20px;width:20px;color:currentColor}seam-widget .widget-header-icon .widget-header-icon--fa{display:flex;flex-direction:row;justify-content:center;text-align:center;max-height:20px;max-width:20px;height:20px;width:20px}seam-widget .widget-header-icon .widget-header-icon--fa .svg-inline--fa{max-width:100%;height:100%;width:100%}seam-widget .widget-header-icon .widget-header-icon--img{height:100%;max-height:20px;max-width:20px}\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: i2.FaIconComponent, selector: "fa-icon", inputs: ["classes", "icon", "title", "spin", "pulse", "mask", "styles", "flip", "size", "pull", "border", "inverse", "symbol", "rotate", "fixedWidth", "transform", "a11yRole"] }, { kind: "component", type: i3.IconComponent, selector: "seam-icon", inputs: ["grayscaleOnDisable", "disabled", "iconClass", "icon", "size", "showDefaultOnError", "defaultIcon", "iconType"] }, { kind: "component", type: i4.LoadingComponent, selector: "seam-loading", inputs: ["theme"] }, { kind: "component", type: i5.ButtonComponent, selector: "button[seamButton]", inputs: ["disabled", "theme", "size", "type"], exportAs: ["seamButton"] }, { kind: "directive", type: i6.WidgetDragHandleDirective, selector: "[seamWidgetDragHandle]", inputs: ["cdkDragHandleDisabled"] }], animations: [
+        trigger('loadingAnim', [
+            transition(':enter', [
+                style({ opacity: 0 }),
+                animate('250ms ease-in-out', style({ opacity: 1 })),
+            ]),
+            transition(':leave', [
+                style({ opacity: 1 }),
+                animate('250ms ease-in-out', style({ opacity: 0 })),
+            ]),
+        ]),
+    ], encapsulation: i0.ViewEncapsulation.None });
+__decorate([
+    InputBoolean()
+], WidgetComponent.prototype, "collapsed", void 0);
+__decorate([
+    InputBoolean()
+], WidgetComponent.prototype, "hasHeader", void 0);
+__decorate([
+    InputBoolean()
+], WidgetComponent.prototype, "loading", void 0);
+__decorate([
+    InputBoolean()
+], WidgetComponent.prototype, "hasConfig", void 0);
+__decorate([
+    InputBoolean()
+], WidgetComponent.prototype, "canCollapse", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: WidgetComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'seam-widget', encapsulation: ViewEncapsulation.None, animations: [
+                        trigger('loadingAnim', [
+                            transition(':enter', [
+                                style({ opacity: 0 }),
+                                animate('250ms ease-in-out', style({ opacity: 1 })),
+                            ]),
+                            transition(':leave', [
+                                style({ opacity: 1 }),
+                                animate('250ms ease-in-out', style({ opacity: 0 })),
+                            ]),
+                        ]),
+                    ], template: "<div class=\"seam-widget border rounded overflow-hidden\">\n  <div class=\"widget-header\" seamWidgetDragHandle *ngIf=\"hasHeader\">\n    <div class=\"widget-header-content p-2 text-nowrap\">\n      <span class=\"mr-1 widget-header-icon\">\n        <ng-container *ngIf=\"iconTpl; else noIconTpl\">\n          <ng-template\n            [ngTemplateOutlet]=\"iconTpl.template\"\n            [ngTemplateOutletContext]=\"{ $implicit: icon, icon: icon, title: titleText }\">\n          </ng-template>\n        </ng-container>\n        <ng-template #noIconTpl>\n          <fa-icon *ngIf=\"_iconObj\"\n            class=\"widget-header-icon--fa {{ iconClass }}\"\n            [icon]=\"_iconObj\"></fa-icon>\n          <img *ngIf=\"_iconUrl\"\n            class=\"widget-header-icon--img {{ iconClass }}\"\n            [src]=\"_iconUrl\" [alt]=\"titleText\">\n        </ng-template>\n      </span>\n      <span class=\"widget-header-title text-truncate\">\n        <ng-container *ngIf=\"titleTpl; else noTitleTpl\">\n          <ng-template\n            [ngTemplateOutlet]=\"titleTpl.template\"\n            [ngTemplateOutletContext]=\"{ $implicit: titleText, icon: icon, title: titleText }\">\n          </ng-template>\n        </ng-container>\n        <ng-template #noTitleTpl>{{ titleText }}</ng-template>\n      </span>\n    </div>\n    <div class=\"widget-header-btns-container\" *ngIf=\"hasConfig || canCollapse\">\n      <div *ngIf=\"hasConfig\">\n        <!-- <button seamIconBtn [icon]=\"configIcon\"\n          class=\"widget-header-btn-config\"\n          iconType=\"\">\n          <span class=\"sr-only\">Widget configuration menu</span>\n        </button> -->\n        <button seamButton class=\"widget-header-btn-config p-0\">\n          <seam-icon class=\"d-block\" [icon]=\"configIcon\" iconClass=\"text-secondary\"></seam-icon>\n          <span class=\"sr-only\">Widget configuration menu</span>\n        </button>\n      </div>\n\n      <div *ngIf=\"canCollapse\" class=\"px-0\">\n        <button seamButton class=\"widget-header-btn-collapse p-0\" (click)=\"collapse()\">\n          <seam-icon class=\"d-block\" [icon]=\"collapseIcon\" iconClass=\"text-secondary\" style=\"margin-left: -10px; margin-right: -5px;\"></seam-icon>\n          <span class=\"sr-only\">Widget collapse</span>\n        </button>\n      </div>\n    </div>\n  </div>\n  <div class=\"position-relative\" [style.height.px]=\"loading ? 150 : undefined\">\n    <ng-container *ngIf=\"!collapsed\">\n      <div class=\"p-2\" *ngIf=\"!loading else loadingTpl\">\n        <ng-content></ng-content>\n      </div>\n      <ng-content select=\"seam-widget-footer\"></ng-content>\n      <ng-template #loadingTpl>\n        <div class=\"position-absolute\" @loadingAnim style=\"top:0;right:0;bottom:0;left:0\">\n          <seam-loading [theme]=\"'primary'\"></seam-loading>\n        </div>\n      </ng-template>\n    </ng-container>\n  </div>\n</div>\n", styles: ["seam-widget{display:block;font-size:15px}seam-widget .seam-widget{background:#FFFFFF;box-shadow:none}seam-widget .widget-header{display:flex;flex-direction:row;border-bottom:1px solid #dee2e6;background:#F4F4F4;font-size:17px}seam-widget .widget-header .widget-header-content{flex:1 1 100%}seam-widget .widget-header .widget-header-btns-container{display:flex;flex-direction:row}seam-widget .widget-header .widget-header-btns-container>div{display:flex;flex-direction:column;justify-content:center;padding:4px}seam-widget .widget-header .widget-header-btns-container .widget-header-btn-config .seam-icon--fa{display:flex;flex-direction:row;justify-content:center;text-align:center;height:25px;width:30px}seam-widget .widget-header .widget-header-btns-container .widget-header-btn-config .seam-icon--fa .svg-inline--fa{max-width:100%;height:100%;width:100%}seam-widget .widget-header .widget-header-btns-container .widget-header-btn-collapse .seam-icon--fa{display:flex;flex-direction:row;justify-content:center;text-align:center;height:15px;width:30px}seam-widget .widget-header .widget-header-btns-container .widget-header-btn-collapse .seam-icon--fa .svg-inline--fa{max-width:100%;height:100%;width:100%}seam-widget .widget-header .widget-header-title{font-size:17px}seam-widget .widget-header-icon{display:inline-block;vertical-align:top;max-height:20px;max-width:20px;height:20px;width:20px;color:currentColor}seam-widget .widget-header-icon .widget-header-icon--fa{display:flex;flex-direction:row;justify-content:center;text-align:center;max-height:20px;max-width:20px;height:20px;width:20px}seam-widget .widget-header-icon .widget-header-icon--fa .svg-inline--fa{max-width:100%;height:100%;width:100%}seam-widget .widget-header-icon .widget-header-icon--img{height:100%;max-height:20px;max-width:20px}\n"] }]
+        }], propDecorators: { collapsed: [{
+                type: Input
+            }], hasHeader: [{
+                type: Input
+            }], titleText: [{
+                type: Input
+            }], icon: [{
+                type: Input
+            }], iconClass: [{
+                type: Input
+            }], loading: [{
+                type: Input
+            }], hasConfig: [{
+                type: Input
+            }], canCollapse: [{
+                type: Input
+            }], iconTpl: [{
+                type: ContentChild,
+                args: [WidgetIconTplDirective, { static: true }]
+            }], titleTpl: [{
+                type: ContentChild,
+                args: [WidgetTitleTplDirective, { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"widget.component.js","sourceRoot":"","sources":["../../../../../projects/ui-common/widget/widget/widget.component.ts","../../../../../projects/ui-common/widget/widget/widget.component.html"],"names":[],"mappings":"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","sourcesContent":["import { animate, style, transition, trigger } from '@angular/animations'\nimport { BooleanInput } from '@angular/cdk/coercion'\nimport { Component, ContentChild, Input, ViewEncapsulation } from '@angular/core'\n\nimport { IconProp } from '@fortawesome/fontawesome-svg-core'\nimport { faAngleDown, faCog } from '@fortawesome/free-solid-svg-icons'\nimport { InputBoolean } from '@theseam/ui-common/core'\nimport { SeamIcon } from '@theseam/ui-common/icon'\n\nimport { WidgetIconTplDirective } from '../directives/widget-icon-tpl.directive'\nimport { WidgetTitleTplDirective } from '../directives/widget-title-tpl.directive'\n\n/**\n * Widget\n *\n * Widgets are designed with the intention of being on a dashboard. Other uses\n * may be supported as the need arises.\n *\n * The only HTML/CSS use should be a widget content component, unless there is a\n * case requiring more advanced design. This is so that we can manage a common\n * style for our widgets. If a case requiring non widget content components is\n * used then the situation should be considered for becoming a widget component.\n */\n@Component({\n  selector: 'seam-widget',\n  templateUrl: './widget.component.html',\n  styleUrls: ['./widget.component.scss'],\n  encapsulation: ViewEncapsulation.None,\n  animations: [\n    trigger('loadingAnim', [\n      transition(':enter', [\n        style({ opacity: 0 }),\n        animate('250ms ease-in-out', style({ opacity: 1 })),\n      ]),\n      transition(':leave', [\n        style({ opacity: 1 }),\n        animate('250ms ease-in-out', style({ opacity: 0 })),\n      ]),\n    ]),\n  ],\n})\nexport class WidgetComponent {\n\n  static ngAcceptInputType_hasHeader: BooleanInput\n  static ngAcceptInputType_loading: BooleanInput\n  static ngAcceptInputType_hasConfig: BooleanInput\n  static ngAcceptInputType_canCollapse: BooleanInput\n\n  /** @ignore */\n  configIcon = faCog\n  /** @ignore */\n  collapseIcon = faAngleDown\n\n  @Input() @InputBoolean() collapsed = false\n\n  /**\n   * Toggles the top header bar of a widget. This should be true for most\n   * widgets.\n   */\n  @Input() @InputBoolean() hasHeader = true\n\n  /**\n   * Title displayed in the top header.\n   *\n   * If a more advanced title is needed you can use `seamWidgetTitleTpl`\n   * template directive, but text is recommended, because allowing custom styles\n   * can lead to inconsitency quickly as different developers keep making\n   * tweaks.\n   */\n  @Input() titleText: string | undefined | null\n\n  /**\n   * Icon displayed in the top header.\n   *\n   * If a more advanced icon is needed you can use `seamWidgetIconTpl` template\n   * directive, but a `SeamIcon` input is recommended, because allowing custom\n   * icons that do not follow the tested types can lead to inconsitency quickly\n   * as different developers keep making tweaks.\n   */\n  @Input()\n  get icon(): SeamIcon | undefined { return this._iconUrl || this._iconObj }\n  set icon(value: SeamIcon | undefined) {\n    if (typeof value === 'string') {\n      this._iconUrl = value\n      this._iconObj = undefined\n    } else {\n      this._iconUrl = undefined\n      this._iconObj = value\n    }\n  }\n\n  /** @ignore */\n  public _iconUrl: string | undefined\n  /** @ignore */\n  public _iconObj: IconProp | undefined\n\n  /** Add a css class to the header icon. */\n  @Input() iconClass: string | undefined | null\n\n  /** Shows widget loading instead of content. */\n  @Input() @InputBoolean() loading = false\n\n  /** @ignore */\n  // NOTE: Config is still being worked on.\n  @Input() @InputBoolean() hasConfig = false\n  /** @ignore */\n  // NOTE: Collapse is still being worked on.\n  @Input() @InputBoolean() canCollapse = false\n\n  @ContentChild(WidgetIconTplDirective, { static: true }) iconTpl?: WidgetIconTplDirective\n  @ContentChild(WidgetTitleTplDirective, { static: true }) titleTpl?: WidgetTitleTplDirective\n\n  /**\n   * Toggles a widget's collapsed state.\n   *\n   * NOTE: Collapse is still being worked on.\n   * @depracated\n   * @ignore\n   */\n  collapse() {\n    this.collapsed = !this.collapsed\n  }\n\n}\n","<div class=\"seam-widget border rounded overflow-hidden\">\n  <div class=\"widget-header\" seamWidgetDragHandle *ngIf=\"hasHeader\">\n    <div class=\"widget-header-content p-2 text-nowrap\">\n      <span class=\"mr-1 widget-header-icon\">\n        <ng-container *ngIf=\"iconTpl; else noIconTpl\">\n          <ng-template\n            [ngTemplateOutlet]=\"iconTpl.template\"\n            [ngTemplateOutletContext]=\"{ $implicit: icon, icon: icon, title: titleText }\">\n          </ng-template>\n        </ng-container>\n        <ng-template #noIconTpl>\n          <fa-icon *ngIf=\"_iconObj\"\n            class=\"widget-header-icon--fa {{ iconClass }}\"\n            [icon]=\"_iconObj\"></fa-icon>\n          <img *ngIf=\"_iconUrl\"\n            class=\"widget-header-icon--img {{ iconClass }}\"\n            [src]=\"_iconUrl\" [alt]=\"titleText\">\n        </ng-template>\n      </span>\n      <span class=\"widget-header-title text-truncate\">\n        <ng-container *ngIf=\"titleTpl; else noTitleTpl\">\n          <ng-template\n            [ngTemplateOutlet]=\"titleTpl.template\"\n            [ngTemplateOutletContext]=\"{ $implicit: titleText, icon: icon, title: titleText }\">\n          </ng-template>\n        </ng-container>\n        <ng-template #noTitleTpl>{{ titleText }}</ng-template>\n      </span>\n    </div>\n    <div class=\"widget-header-btns-container\" *ngIf=\"hasConfig || canCollapse\">\n      <div *ngIf=\"hasConfig\">\n        <!-- <button seamIconBtn [icon]=\"configIcon\"\n          class=\"widget-header-btn-config\"\n          iconType=\"\">\n          <span class=\"sr-only\">Widget configuration menu</span>\n        </button> -->\n        <button seamButton class=\"widget-header-btn-config p-0\">\n          <seam-icon class=\"d-block\" [icon]=\"configIcon\" iconClass=\"text-secondary\"></seam-icon>\n          <span class=\"sr-only\">Widget configuration menu</span>\n        </button>\n      </div>\n\n      <div *ngIf=\"canCollapse\" class=\"px-0\">\n        <button seamButton class=\"widget-header-btn-collapse p-0\" (click)=\"collapse()\">\n          <seam-icon class=\"d-block\" [icon]=\"collapseIcon\" iconClass=\"text-secondary\" style=\"margin-left: -10px; margin-right: -5px;\"></seam-icon>\n          <span class=\"sr-only\">Widget collapse</span>\n        </button>\n      </div>\n    </div>\n  </div>\n  <div class=\"position-relative\" [style.height.px]=\"loading ? 150 : undefined\">\n    <ng-container *ngIf=\"!collapsed\">\n      <div class=\"p-2\" *ngIf=\"!loading else loadingTpl\">\n        <ng-content></ng-content>\n      </div>\n      <ng-content select=\"seam-widget-footer\"></ng-content>\n      <ng-template #loadingTpl>\n        <div class=\"position-absolute\" @loadingAnim style=\"top:0;right:0;bottom:0;left:0\">\n          <seam-loading [theme]=\"'primary'\"></seam-loading>\n        </div>\n      </ng-template>\n    </ng-container>\n  </div>\n</div>\n"]}