@theseam/ui-common 0.3.14-beta.2 → 0.3.15-beta.1

package/esm2020/progress/progress.module.mjs

@@ -0,0 +1,24 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ProgressCircleComponent } from './progress-circle/progress-circle.component';
+import * as i0 from "@angular/core";
+export class TheSeamProgressModule {
+}
+TheSeamProgressModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamProgressModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TheSeamProgressModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: TheSeamProgressModule, declarations: [ProgressCircleComponent], imports: [CommonModule], exports: [ProgressCircleComponent] });
+TheSeamProgressModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamProgressModule, imports: [CommonModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamProgressModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        ProgressCircleComponent
+                    ],
+                    imports: [
+                        CommonModule
+                    ],
+                    exports: [
+                        ProgressCircleComponent
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZ3Jlc3MubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvdWktY29tbW9uL3Byb2dyZXNzL3Byb2dyZXNzLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUE7QUFDOUMsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQTtBQUV4QyxPQUFPLEVBQUUsdUJBQXVCLEVBQUUsTUFBTSw2Q0FBNkMsQ0FBQTs7QUFhckYsTUFBTSxPQUFPLHFCQUFxQjs7a0hBQXJCLHFCQUFxQjttSEFBckIscUJBQXFCLGlCQVQ5Qix1QkFBdUIsYUFHdkIsWUFBWSxhQUdaLHVCQUF1QjttSEFHZCxxQkFBcUIsWUFOOUIsWUFBWTsyRkFNSCxxQkFBcUI7a0JBWGpDLFFBQVE7bUJBQUM7b0JBQ1IsWUFBWSxFQUFFO3dCQUNaLHVCQUF1QjtxQkFDeEI7b0JBQ0QsT0FBTyxFQUFFO3dCQUNQLFlBQVk7cUJBQ2I7b0JBQ0QsT0FBTyxFQUFFO3dCQUNQLHVCQUF1QjtxQkFDeEI7aUJBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nXG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5cbmltcG9ydCB7IFByb2dyZXNzQ2lyY2xlQ29tcG9uZW50IH0gZnJvbSAnLi9wcm9ncmVzcy1jaXJjbGUvcHJvZ3Jlc3MtY2lyY2xlLmNvbXBvbmVudCdcblxuQE5nTW9kdWxlKHtcbiAgZGVjbGFyYXRpb25zOiBbXG4gICAgUHJvZ3Jlc3NDaXJjbGVDb21wb25lbnRcbiAgXSxcbiAgaW1wb3J0czogW1xuICAgIENvbW1vbk1vZHVsZVxuICBdLFxuICBleHBvcnRzOiBbXG4gICAgUHJvZ3Jlc3NDaXJjbGVDb21wb25lbnRcbiAgXVxufSlcbmV4cG9ydCBjbGFzcyBUaGVTZWFtUHJvZ3Jlc3NNb2R1bGUgeyB9XG4iXX0=

package/esm2020/public_api.mjs

@@ -0,0 +1,2 @@
+export default {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9wdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGVBQWUsRUFBRSxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IGRlZmF1bHQge31cbiJdfQ==

package/esm2020/scrollbar/overlay-scrollbar.directive.mjs

@@ -0,0 +1,60 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./overlay-scrollbars.service";
+export class OverlayScrollbarDirective {
+    set seamOverlayScrollbar(value) { this.options = value; }
+    get overlayScrollbarEnabled() {
+        return this._scrollbars.isInstanceEnabled(this._ref.nativeElement);
+    }
+    set overlayScrollbarEnabled(value) {
+        this._disabled = !coerceBooleanProperty(value);
+        if (!this._disabled) {
+            this._scrollbars.initializeInstance(this._ref.nativeElement, this._options);
+        }
+        else {
+            this._scrollbars.destroyInstance(this._ref.nativeElement);
+        }
+    }
+    set options(value) {
+        this._options = value || {};
+        this._scrollbars.setOptions(this._ref.nativeElement, this._options);
+    }
+    get options() {
+        if (this._scrollbars.isInstanceEnabled(this._ref.nativeElement)) {
+            return this._scrollbars.getOptions(this._ref.nativeElement);
+        }
+        return this._options;
+    }
+    constructor(_ref, _scrollbars) {
+        this._ref = _ref;
+        this._scrollbars = _scrollbars;
+        this._disabled = false;
+        this._options = {};
+    }
+    ngAfterViewInit() {
+        if (!this._disabled) {
+            this._scrollbars.initializeInstance(this._ref.nativeElement, this._options);
+        }
+    }
+    ngOnDestroy() {
+        this._scrollbars.destroyInstance(this._ref.nativeElement);
+    }
+    get instance() {
+        return this._scrollbars.getInstance(this._ref.nativeElement);
+    }
+}
+OverlayScrollbarDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: OverlayScrollbarDirective, deps: [{ token: i0.ElementRef }, { token: i1.OverlayScrollbarsService }], target: i0.ɵɵFactoryTarget.Directive });
+OverlayScrollbarDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: OverlayScrollbarDirective, selector: "[seamOverlayScrollbar]", inputs: { seamOverlayScrollbar: "seamOverlayScrollbar", overlayScrollbarEnabled: "overlayScrollbarEnabled" }, exportAs: ["seamOverlayScrollbar"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: OverlayScrollbarDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[seamOverlayScrollbar]',
+                    exportAs: 'seamOverlayScrollbar'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.OverlayScrollbarsService }]; }, propDecorators: { seamOverlayScrollbar: [{
+                type: Input
+            }], overlayScrollbarEnabled: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/scrollbar/overlay-scrollbars-config.mjs

@@ -0,0 +1,13 @@
+import { InjectionToken } from '@angular/core';
+export const _OverlayScrollbarDefaults = {
+    className: 'os-theme-dark os-theme-no-hover',
+    sizeAutoCapable: false,
+    paddingAbsolute: true,
+    autoUpdate: true
+};
+export function mergeOverlayScrollbarsConfigs(a, b) {
+    return { ...a, ...b };
+}
+/** Injection token that can be used to specify overlayscrollbars options. */
+export const LIB_OVERLAY_SCROLLBARS_CONFIG = new InjectionToken('seamOverlayScrollbarsConfig');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3ZlcmxheS1zY3JvbGxiYXJzLWNvbmZpZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9zY3JvbGxiYXIvb3ZlcmxheS1zY3JvbGxiYXJzLWNvbmZpZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFBO0FBSTlDLE1BQU0sQ0FBQyxNQUFNLHlCQUF5QixHQUE2QjtJQUNqRSxTQUFTLEVBQUUsaUNBQWlDO0lBQzVDLGVBQWUsRUFBRSxLQUFLO0lBQ3RCLGVBQWUsRUFBRSxJQUFJO0lBQ3JCLFVBQVUsRUFBRSxJQUFJO0NBQ2pCLENBQUE7QUFFRCxNQUFNLFVBQVUsNkJBQTZCLENBQUMsQ0FBMkIsRUFBRSxDQUEyQjtJQUNwRyxPQUFPLEVBQUUsR0FBRyxDQUFDLEVBQUUsR0FBRyxDQUFDLEVBQUUsQ0FBQTtBQUN2QixDQUFDO0FBRUQsNkVBQTZFO0FBQzdFLE1BQU0sQ0FBQyxNQUFNLDZCQUE2QixHQUFHLElBQUksY0FBYyxDQUEyQiw2QkFBNkIsQ0FBQyxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuXG5pbXBvcnQgeyBJT3ZlcmxheVNjcm9sbGJhcnNDb25maWcgfSBmcm9tICcuL292ZXJsYXktc2Nyb2xsYmFycy1jb25maWctbW9kZWwnXG5cbmV4cG9ydCBjb25zdCBfT3ZlcmxheVNjcm9sbGJhckRlZmF1bHRzOiBJT3ZlcmxheVNjcm9sbGJhcnNDb25maWcgPSB7XG4gIGNsYXNzTmFtZTogJ29zLXRoZW1lLWRhcmsgb3MtdGhlbWUtbm8taG92ZXInLFxuICBzaXplQXV0b0NhcGFibGU6IGZhbHNlLFxuICBwYWRkaW5nQWJzb2x1dGU6IHRydWUsXG4gIGF1dG9VcGRhdGU6IHRydWVcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIG1lcmdlT3ZlcmxheVNjcm9sbGJhcnNDb25maWdzKGE6IElPdmVybGF5U2Nyb2xsYmFyc0NvbmZpZywgYjogSU92ZXJsYXlTY3JvbGxiYXJzQ29uZmlnKSB7XG4gIHJldHVybiB7IC4uLmEsIC4uLmIgfVxufVxuXG4vKiogSW5qZWN0aW9uIHRva2VuIHRoYXQgY2FuIGJlIHVzZWQgdG8gc3BlY2lmeSBvdmVybGF5c2Nyb2xsYmFycyBvcHRpb25zLiAqL1xuZXhwb3J0IGNvbnN0IExJQl9PVkVSTEFZX1NDUk9MTEJBUlNfQ09ORklHID0gbmV3IEluamVjdGlvblRva2VuPElPdmVybGF5U2Nyb2xsYmFyc0NvbmZpZz4oJ3NlYW1PdmVybGF5U2Nyb2xsYmFyc0NvbmZpZycpXG4iXX0=

package/esm2020/scrollbar/overlay-scrollbars.service.mjs

@@ -0,0 +1,83 @@
+import { Injectable } from '@angular/core';
+import { fromEvent, Subscription } from 'rxjs';
+import OverlayScrollbars from 'overlayscrollbars';
+import { LIB_OVERLAY_SCROLLBARS_CONFIG, _OverlayScrollbarDefaults } from './overlay-scrollbars-config';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/platform";
+export class OverlayScrollbarsService {
+    constructor(_ngZone, injector, _platform) {
+        this._ngZone = _ngZone;
+        this.injector = injector;
+        this._platform = _platform;
+        this._inputEventSubscription = Subscription.EMPTY;
+    }
+    initializeInstance(element, options) {
+        if (!this.isInstanceEnabled(element) &&
+            // The 'overlayscrollbars' library is causing an issue on iOS. Since iOS
+            // already has native overlay scrollbars it shouldn't really effect the
+            // app layout.
+            !(this._isTextarea(element) && this._platform.IOS)) {
+            this._ngZone.runOutsideAngular(() => {
+                OverlayScrollbars(element, this._applyConfigDefaults(options));
+                if (this._isTextarea(element)) {
+                    // TODO: Make this more accurate. Right now this is just relying on
+                    // the fact that timing out for 100ms is usually enough time to wait
+                    // for update to correctly calculate.
+                    // NOTE: This may be fixed in a newer version to not need this hack.
+                    fromEvent(element, 'change').subscribe(_ => {
+                        this._ngZone.run(() => {
+                            setTimeout(() => {
+                                if (this.isInstanceEnabled(element)) {
+                                    this.getInstance(element).update();
+                                }
+                            }, 100);
+                        });
+                    });
+                }
+            });
+        }
+    }
+    destroyInstance(element) {
+        if (this.isInstanceEnabled(element)) {
+            this._ngZone.runOutsideAngular(() => {
+                this.getInstance(element).destroy();
+                if (this._inputEventSubscription && !this._inputEventSubscription.closed) {
+                    this._inputEventSubscription.unsubscribe();
+                }
+            });
+        }
+    }
+    getInstance(element) {
+        return OverlayScrollbars(element);
+    }
+    isInstanceEnabled(element) {
+        return !!this.getInstance(element);
+    }
+    setOptions(element, options) {
+        if (!this.isInstanceEnabled(element)) {
+            return false;
+        }
+        this.getInstance(element).options(this._applyConfigDefaults(options));
+        return true;
+    }
+    getOptions(element) {
+        return this.getInstance(element).options();
+    }
+    _applyConfigDefaults(config) {
+        const _config = this.injector.get(LIB_OVERLAY_SCROLLBARS_CONFIG, _OverlayScrollbarDefaults);
+        return { ..._config, ...config };
+    }
+    /** Determines if the component host is a textarea. */
+    _isTextarea(element) {
+        return element.nodeName.toLowerCase() === 'textarea';
+    }
+}
+OverlayScrollbarsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: OverlayScrollbarsService, deps: [{ token: i0.NgZone }, { token: i0.Injector }, { token: i1.Platform }], target: i0.ɵɵFactoryTarget.Injectable });
+OverlayScrollbarsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: OverlayScrollbarsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: OverlayScrollbarsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i0.Injector }, { type: i1.Platform }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/scrollbar/scrollbar.module.mjs

@@ -0,0 +1,30 @@
+import { PlatformModule } from '@angular/cdk/platform';
+import { NgModule } from '@angular/core';
+import { OverlayScrollbarDirective } from './overlay-scrollbar.directive';
+import { LIB_OVERLAY_SCROLLBARS_CONFIG, _OverlayScrollbarDefaults } from './overlay-scrollbars-config';
+import * as i0 from "@angular/core";
+export class TheSeamScrollbarModule {
+}
+TheSeamScrollbarModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamScrollbarModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TheSeamScrollbarModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: TheSeamScrollbarModule, declarations: [OverlayScrollbarDirective], imports: [PlatformModule], exports: [OverlayScrollbarDirective] });
+TheSeamScrollbarModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamScrollbarModule, providers: [
+        { provide: LIB_OVERLAY_SCROLLBARS_CONFIG, useValue: _OverlayScrollbarDefaults }
+    ], imports: [PlatformModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamScrollbarModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        OverlayScrollbarDirective
+                    ],
+                    imports: [
+                        PlatformModule
+                    ],
+                    providers: [
+                        { provide: LIB_OVERLAY_SCROLLBARS_CONFIG, useValue: _OverlayScrollbarDefaults }
+                    ],
+                    exports: [
+                        OverlayScrollbarDirective
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2Nyb2xsYmFyLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9zY3JvbGxiYXIvc2Nyb2xsYmFyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sdUJBQXVCLENBQUE7QUFDdEQsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQTtBQUV4QyxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQTtBQUN6RSxPQUFPLEVBQUUsNkJBQTZCLEVBQUUseUJBQXlCLEVBQUUsTUFBTSw2QkFBNkIsQ0FBQTs7QUFnQnRHLE1BQU0sT0FBTyxzQkFBc0I7O21IQUF0QixzQkFBc0I7b0hBQXRCLHNCQUFzQixpQkFaL0IseUJBQXlCLGFBR3pCLGNBQWMsYUFNZCx5QkFBeUI7b0hBR2hCLHNCQUFzQixhQVB0QjtRQUNULEVBQUUsT0FBTyxFQUFFLDZCQUE2QixFQUFFLFFBQVEsRUFBRSx5QkFBeUIsRUFBRTtLQUNoRixZQUpDLGNBQWM7MkZBU0wsc0JBQXNCO2tCQWRsQyxRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRTt3QkFDWix5QkFBeUI7cUJBQzFCO29CQUNELE9BQU8sRUFBRTt3QkFDUCxjQUFjO3FCQUNmO29CQUNELFNBQVMsRUFBRTt3QkFDVCxFQUFFLE9BQU8sRUFBRSw2QkFBNkIsRUFBRSxRQUFRLEVBQUUseUJBQXlCLEVBQUU7cUJBQ2hGO29CQUNELE9BQU8sRUFBRTt3QkFDUCx5QkFBeUI7cUJBQzFCO2lCQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgUGxhdGZvcm1Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jZGsvcGxhdGZvcm0nXG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5cbmltcG9ydCB7IE92ZXJsYXlTY3JvbGxiYXJEaXJlY3RpdmUgfSBmcm9tICcuL292ZXJsYXktc2Nyb2xsYmFyLmRpcmVjdGl2ZSdcbmltcG9ydCB7IExJQl9PVkVSTEFZX1NDUk9MTEJBUlNfQ09ORklHLCBfT3ZlcmxheVNjcm9sbGJhckRlZmF1bHRzIH0gZnJvbSAnLi9vdmVybGF5LXNjcm9sbGJhcnMtY29uZmlnJ1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtcbiAgICBPdmVybGF5U2Nyb2xsYmFyRGlyZWN0aXZlXG4gIF0sXG4gIGltcG9ydHM6IFtcbiAgICBQbGF0Zm9ybU1vZHVsZVxuICBdLFxuICBwcm92aWRlcnM6IFtcbiAgICB7IHByb3ZpZGU6IExJQl9PVkVSTEFZX1NDUk9MTEJBUlNfQ09ORklHLCB1c2VWYWx1ZTogX092ZXJsYXlTY3JvbGxiYXJEZWZhdWx0cyB9XG4gIF0sXG4gIGV4cG9ydHM6IFtcbiAgICBPdmVybGF5U2Nyb2xsYmFyRGlyZWN0aXZlXG4gIF1cbn0pXG5leHBvcnQgY2xhc3MgVGhlU2VhbVNjcm9sbGJhck1vZHVsZSB7IH1cbiJdfQ==

package/esm2020/services/asset-loader.service.mjs

@@ -0,0 +1,32 @@
+import { Injectable } from '@angular/core';
+import { defer } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { loadStyle, loadStyleSheet } from '@theseam/ui-common/utils';
+import * as i0 from "@angular/core";
+export class LoadedAssetRef {
+    constructor(nativeElement, path, content) {
+        this.nativeElement = nativeElement;
+        this.path = path;
+        this.content = content;
+    }
+    destroy() {
+        this.nativeElement.parentElement?.removeChild(this.nativeElement);
+    }
+}
+export class AssetLoaderService {
+    loadStyleSheet(path) {
+        return defer(() => loadStyleSheet(path)).pipe(map(v => new LoadedAssetRef(v, path)));
+    }
+    loadStyle(content) {
+        return defer(() => loadStyle(content)).pipe(map(v => new LoadedAssetRef(v, undefined, content)));
+    }
+}
+AssetLoaderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AssetLoaderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+AssetLoaderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AssetLoaderService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AssetLoaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/services/font-loader.service.mjs

@@ -0,0 +1,83 @@
+import { Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import WebFont from 'webfontloader';
+import { hasProperty } from '@theseam/ui-common/utils';
+import * as i0 from "@angular/core";
+/**
+ * Service to help loading fonts.
+ *
+ * Currently this is just a wrapper for the parts of webfontloader that we need.
+ * Eventually this should be generic enough that we can switch loaders without
+ * config differences being confusing.
+ */
+export class TheSeamFontLoaderService {
+    /**
+     * Since this method is just a wrapper for webfontloader right now it accepts
+     * anything webfontloader's config accepts, so the event callbacks can still
+     * be used, but you should us the emitted objects instead. If we decide to
+     * support other font loaders then the event callbacks will most likely be
+     * removed.
+     *
+     * NOTE: If you need to use the events callbacks for some reason, this
+     * method's returned observable will still need to be subscribed to, because
+     * it doesn't start till subscribed to.
+     */
+    load(config) {
+        return new Observable((subscriber) => {
+            WebFont.load({
+                ...config,
+                /** This event is triggered when all fonts have been requested. */
+                loading: () => {
+                    if (hasProperty(config, 'loading')) {
+                        config.loading();
+                    }
+                    subscriber.next({ type: 'loading' });
+                },
+                /** This event is triggered when the fonts have rendered. */
+                active: () => {
+                    if (hasProperty(config, 'active')) {
+                        config.active();
+                    }
+                    subscriber.next({ type: 'active' });
+                },
+                /** This event is triggered when the browser does not support linked fonts or if none of the fonts could be loaded. */
+                inactive: () => {
+                    if (hasProperty(config, 'inactive')) {
+                        config.inactive();
+                    }
+                    subscriber.next({ type: 'inactive' });
+                },
+                /** This event is triggered once for each font that's loaded. */
+                fontloading: (familyName, fvd) => {
+                    if (hasProperty(config, 'fontloading')) {
+                        config.fontloading(familyName, fvd);
+                    }
+                    subscriber.next({ type: 'fontloading', familyName, fvd });
+                },
+                /** This event is triggered once for each font that renders. */
+                fontactive: (familyName, fvd) => {
+                    if (hasProperty(config, 'fontactive')) {
+                        config.fontactive(familyName, fvd);
+                    }
+                    subscriber.next({ type: 'fontactive', familyName, fvd });
+                },
+                /** This event is triggered if the font can't be loaded. */
+                fontinactive: (familyName, fvd) => {
+                    if (hasProperty(config, 'fontinactive')) {
+                        config.fontinactive(familyName, fvd);
+                    }
+                    subscriber.next({ type: 'fontinactive', familyName, fvd });
+                },
+            });
+        });
+    }
+}
+TheSeamFontLoaderService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamFontLoaderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TheSeamFontLoaderService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamFontLoaderService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamFontLoaderService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/services/router-helpers.service.mjs

@@ -0,0 +1,25 @@
+import { Injectable } from '@angular/core';
+import { NavigationEnd } from '@angular/router';
+import { filter, map, startWith } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class RouterHelpersService {
+    constructor(_router) {
+        this._router = _router;
+    }
+    isActive(url, exact) {
+        const opts = exact
+            ? { paths: 'exact', queryParams: 'exact', fragment: 'ignored', matrixParams: 'ignored' }
+            : { paths: 'subset', queryParams: 'subset', fragment: 'ignored', matrixParams: 'ignored' };
+        return this._router.events.pipe(filter(event => event instanceof NavigationEnd), map(event => this._router.isActive(url, opts)), startWith(this._router.isActive(url, opts)));
+    }
+}
+RouterHelpersService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: RouterHelpersService, deps: [{ token: i1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+RouterHelpersService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: RouterHelpersService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: RouterHelpersService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGVyLWhlbHBlcnMuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9zZXJ2aWNlcy9yb3V0ZXItaGVscGVycy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUE7QUFDMUMsT0FBTyxFQUF3QixhQUFhLEVBQW1CLE1BQU0saUJBQWlCLENBQUE7QUFFdEYsT0FBTyxFQUFFLE1BQU0sRUFBRSxHQUFHLEVBQUUsU0FBUyxFQUFFLE1BQU0sZ0JBQWdCLENBQUE7OztBQUt2RCxNQUFNLE9BQU8sb0JBQW9CO0lBRS9CLFlBQ1UsT0FBZTtRQUFmLFlBQU8sR0FBUCxPQUFPLENBQVE7SUFDckIsQ0FBQztJQUVFLFFBQVEsQ0FBQyxHQUFxQixFQUFFLEtBQWM7UUFDbkQsTUFBTSxJQUFJLEdBQXlCLEtBQUs7WUFDdEMsQ0FBQyxDQUFDLEVBQUUsS0FBSyxFQUFFLE9BQU8sRUFBRSxXQUFXLEVBQUUsT0FBTyxFQUFFLFFBQVEsRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLFNBQVMsRUFBRTtZQUN4RixDQUFDLENBQUMsRUFBRSxLQUFLLEVBQUUsUUFBUSxFQUFFLFdBQVcsRUFBRSxRQUFRLEVBQUUsUUFBUSxFQUFFLFNBQVMsRUFBRSxZQUFZLEVBQUUsU0FBUyxFQUFFLENBQUE7UUFFNUYsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQzdCLE1BQU0sQ0FBQyxLQUFLLENBQUMsRUFBRSxDQUFDLEtBQUssWUFBWSxhQUFhLENBQUMsRUFDL0MsR0FBRyxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsR0FBRyxFQUFFLElBQUksQ0FBQyxDQUFDLEVBQzlDLFNBQVMsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxHQUFHLEVBQUUsSUFBSSxDQUFDLENBQUMsQ0FDNUMsQ0FBQTtJQUNILENBQUM7O2lIQWhCVSxvQkFBb0I7cUhBQXBCLG9CQUFvQixjQUZuQixNQUFNOzJGQUVQLG9CQUFvQjtrQkFIaEMsVUFBVTttQkFBQztvQkFDVixVQUFVLEVBQUUsTUFBTTtpQkFDbkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSdcbmltcG9ydCB7IElzQWN0aXZlTWF0Y2hPcHRpb25zLCBOYXZpZ2F0aW9uRW5kLCBSb3V0ZXIsIFVybFRyZWUgfSBmcm9tICdAYW5ndWxhci9yb3V0ZXInXG5pbXBvcnQgeyBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcydcbmltcG9ydCB7IGZpbHRlciwgbWFwLCBzdGFydFdpdGggfSBmcm9tICdyeGpzL29wZXJhdG9ycydcblxuQEluamVjdGFibGUoe1xuICBwcm92aWRlZEluOiAncm9vdCdcbn0pXG5leHBvcnQgY2xhc3MgUm91dGVySGVscGVyc1NlcnZpY2Uge1xuXG4gIGNvbnN0cnVjdG9yKFxuICAgIHByaXZhdGUgX3JvdXRlcjogUm91dGVyXG4gICkgeyB9XG5cbiAgcHVibGljIGlzQWN0aXZlKHVybDogc3RyaW5nIHwgVXJsVHJlZSwgZXhhY3Q6IGJvb2xlYW4pOiBPYnNlcnZhYmxlPGJvb2xlYW4+IHtcbiAgICBjb25zdCBvcHRzOiBJc0FjdGl2ZU1hdGNoT3B0aW9ucyA9IGV4YWN0XG4gICAgICA/IHsgcGF0aHM6ICdleGFjdCcsIHF1ZXJ5UGFyYW1zOiAnZXhhY3QnLCBmcmFnbWVudDogJ2lnbm9yZWQnLCBtYXRyaXhQYXJhbXM6ICdpZ25vcmVkJyB9XG4gICAgICA6IHsgcGF0aHM6ICdzdWJzZXQnLCBxdWVyeVBhcmFtczogJ3N1YnNldCcsIGZyYWdtZW50OiAnaWdub3JlZCcsIG1hdHJpeFBhcmFtczogJ2lnbm9yZWQnIH1cblxuICAgIHJldHVybiB0aGlzLl9yb3V0ZXIuZXZlbnRzLnBpcGUoXG4gICAgICBmaWx0ZXIoZXZlbnQgPT4gZXZlbnQgaW5zdGFuY2VvZiBOYXZpZ2F0aW9uRW5kKSxcbiAgICAgIG1hcChldmVudCA9PiB0aGlzLl9yb3V0ZXIuaXNBY3RpdmUodXJsLCBvcHRzKSksXG4gICAgICBzdGFydFdpdGgodGhpcy5fcm91dGVyLmlzQWN0aXZlKHVybCwgb3B0cykpXG4gICAgKVxuICB9XG59XG4iXX0=

package/esm2020/shared/components/password-input-reveal/password-input-reveal.component.mjs

@@ -0,0 +1,49 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Component, Input } from '@angular/core';
+import { faEye, faEyeSlash } from '@fortawesome/free-regular-svg-icons';
+import * as i0 from "@angular/core";
+import * as i1 from "@fortawesome/angular-fontawesome";
+export class PasswordInputRevealComponent {
+    constructor() {
+        this.faEye = faEye;
+        this.faEyeSlash = faEyeSlash;
+        this._passwordVisible = false;
+    }
+    get inputRef() { return this._passwordInput; }
+    set inputRef(value) {
+        this._passwordInput = value;
+        this.updateRevealState();
+        if (this._passwordInput) {
+            this._passwordInput.style.paddingRight = '40px';
+            this._passwordInput.classList.add('no-native-eye');
+        }
+    }
+    get passwordVisible() { return this._passwordVisible; }
+    set passwordVisible(value) {
+        this._passwordVisible = coerceBooleanProperty(value);
+        this.updateRevealState();
+    }
+    updateRevealState() {
+        if (this._passwordInput) {
+            this._passwordInput.type = this.passwordVisible ? 'text' : 'password';
+        }
+    }
+    revealPassword() {
+        this.passwordVisible = !this.passwordVisible;
+    }
+}
+PasswordInputRevealComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: PasswordInputRevealComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+PasswordInputRevealComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.9", type: PasswordInputRevealComponent, selector: "seam-password-input-reveal", inputs: { inputRef: "inputRef", passwordVisible: "passwordVisible" }, ngImport: i0, template: `
+    <fa-icon [icon]="passwordVisible ? faEyeSlash : faEye" class="password-reveal-icon" (click)="revealPassword()"></fa-icon>
+  `, isInline: true, styles: [":host{display:flex;align-items:center;position:absolute;top:0;right:0;bottom:0;width:30px;transform:translateZ(0);z-index:50}:host fa-icon{opacity:1;color:#bababa;margin-top:3px;cursor:pointer}:host fa-icon ::ng-deep .svg-inline--fa{vertical-align:middle}\n"], dependencies: [{ kind: "component", type: i1.FaIconComponent, selector: "fa-icon", inputs: ["classes", "icon", "title", "spin", "pulse", "mask", "styles", "flip", "size", "pull", "border", "inverse", "symbol", "rotate", "fixedWidth", "transform", "a11yRole"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: PasswordInputRevealComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'seam-password-input-reveal', template: `
+    <fa-icon [icon]="passwordVisible ? faEyeSlash : faEye" class="password-reveal-icon" (click)="revealPassword()"></fa-icon>
+  `, styles: [":host{display:flex;align-items:center;position:absolute;top:0;right:0;bottom:0;width:30px;transform:translateZ(0);z-index:50}:host fa-icon{opacity:1;color:#bababa;margin-top:3px;cursor:pointer}:host fa-icon ::ng-deep .svg-inline--fa{vertical-align:middle}\n"] }]
+        }], propDecorators: { inputRef: [{
+                type: Input
+            }], passwordVisible: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFzc3dvcmQtaW5wdXQtcmV2ZWFsLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9zaGFyZWQvY29tcG9uZW50cy9wYXNzd29yZC1pbnB1dC1yZXZlYWwvcGFzc3dvcmQtaW5wdXQtcmV2ZWFsLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQWdCLHFCQUFxQixFQUFFLE1BQU0sdUJBQXVCLENBQUE7QUFDM0UsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsTUFBTSxlQUFlLENBQUE7QUFFaEQsT0FBTyxFQUFFLEtBQUssRUFBRSxVQUFVLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQTs7O0FBa0N2RSxNQUFNLE9BQU8sNEJBQTRCO0lBaEN6QztRQW1DRSxVQUFLLEdBQUcsS0FBSyxDQUFBO1FBQ2IsZUFBVSxHQUFHLFVBQVUsQ0FBQTtRQW9CaEIscUJBQWdCLEdBQUcsS0FBSyxDQUFBO0tBWWhDO0lBOUJDLElBQ0ksUUFBUSxLQUEwQyxPQUFPLElBQUksQ0FBQyxjQUFjLENBQUEsQ0FBQyxDQUFDO0lBQ2xGLElBQUksUUFBUSxDQUFDLEtBQTBDO1FBQ3JELElBQUksQ0FBQyxjQUFjLEdBQUcsS0FBSyxDQUFBO1FBQzNCLElBQUksQ0FBQyxpQkFBaUIsRUFBRSxDQUFBO1FBQ3hCLElBQUksSUFBSSxDQUFDLGNBQWMsRUFBRTtZQUN2QixJQUFJLENBQUMsY0FBYyxDQUFDLEtBQUssQ0FBQyxZQUFZLEdBQUcsTUFBTSxDQUFBO1lBQy9DLElBQUksQ0FBQyxjQUFjLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyxlQUFlLENBQUMsQ0FBQTtTQUNuRDtJQUNILENBQUM7SUFHRCxJQUNJLGVBQWUsS0FBSyxPQUFPLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQSxDQUFDLENBQUM7SUFDdEQsSUFBSSxlQUFlLENBQUMsS0FBYztRQUNoQyxJQUFJLENBQUMsZ0JBQWdCLEdBQUcscUJBQXFCLENBQUMsS0FBSyxDQUFDLENBQUE7UUFDcEQsSUFBSSxDQUFDLGlCQUFpQixFQUFFLENBQUE7SUFDMUIsQ0FBQztJQUdNLGlCQUFpQjtRQUN0QixJQUFJLElBQUksQ0FBQyxjQUFjLEVBQUU7WUFDdkIsSUFBSSxDQUFDLGNBQWMsQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFDLGVBQWUsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxVQUFVLENBQUE7U0FDdEU7SUFDSCxDQUFDO0lBRU0sY0FBYztRQUNuQixJQUFJLENBQUMsZUFBZSxHQUFHLENBQUMsSUFBSSxDQUFDLGVBQWUsQ0FBQTtJQUM5QyxDQUFDOzt5SEFsQ1UsNEJBQTRCOzZHQUE1Qiw0QkFBNEIsd0lBOUI3Qjs7R0FFVDsyRkE0QlUsNEJBQTRCO2tCQWhDeEMsU0FBUzsrQkFDRSw0QkFBNEIsWUFDNUI7O0dBRVQ7OEJBbUNHLFFBQVE7c0JBRFgsS0FBSztnQkFhRixlQUFlO3NCQURsQixLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQm9vbGVhbklucHV0LCBjb2VyY2VCb29sZWFuUHJvcGVydHkgfSBmcm9tICdAYW5ndWxhci9jZGsvY29lcmNpb24nXG5pbXBvcnQgeyBDb21wb25lbnQsIElucHV0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSdcblxuaW1wb3J0IHsgZmFFeWUsIGZhRXllU2xhc2ggfSBmcm9tICdAZm9ydGF3ZXNvbWUvZnJlZS1yZWd1bGFyLXN2Zy1pY29ucydcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnc2VhbS1wYXNzd29yZC1pbnB1dC1yZXZlYWwnLFxuICB0ZW1wbGF0ZTogYFxuICAgIDxmYS1pY29uIFtpY29uXT1cInBhc3N3b3JkVmlzaWJsZSA/IGZhRXllU2xhc2ggOiBmYUV5ZVwiIGNsYXNzPVwicGFzc3dvcmQtcmV2ZWFsLWljb25cIiAoY2xpY2spPVwicmV2ZWFsUGFzc3dvcmQoKVwiPjwvZmEtaWNvbj5cbiAgYCxcbiAgc3R5bGVzOiBbXG4gICAgYFxuICAgIDpob3N0IHtcbiAgICAgIGRpc3BsYXk6IGZsZXg7XG4gICAgICBhbGlnbi1pdGVtczogY2VudGVyO1xuICAgICAgcG9zaXRpb246IGFic29sdXRlO1xuICAgICAgdG9wOiAwO1xuICAgICAgcmlnaHQ6IDA7XG4gICAgICBib3R0b206IDA7XG4gICAgICB3aWR0aDogMzBweDtcbiAgICAgIHRyYW5zZm9ybTogdHJhbnNsYXRlWigwKTtcbiAgICAgIHotaW5kZXg6IDUwO1xuICAgIH1cblxuICAgIDpob3N0IGZhLWljb24ge1xuICAgICAgb3BhY2l0eTogMTtcbiAgICAgIGNvbG9yOiAjYmFiYWJhO1xuICAgICAgbWFyZ2luLXRvcDogM3B4O1xuICAgICAgY3Vyc29yOiBwb2ludGVyO1xuICAgIH1cblxuICAgIDpob3N0IGZhLWljb24gOjpuZy1kZWVwIC5zdmctaW5saW5lLS1mYSB7XG4gICAgICB2ZXJ0aWNhbC1hbGlnbjogbWlkZGxlO1xuICAgIH1cbiAgICBgXG4gIF1cbn0pXG5leHBvcnQgY2xhc3MgUGFzc3dvcmRJbnB1dFJldmVhbENvbXBvbmVudCB7XG4gIHN0YXRpYyBuZ0FjY2VwdElucHV0VHlwZV9wYXNzd29yZFZpc2libGU6IEJvb2xlYW5JbnB1dFxuXG4gIGZhRXllID0gZmFFeWVcbiAgZmFFeWVTbGFzaCA9IGZhRXllU2xhc2hcblxuICBASW5wdXQoKVxuICBnZXQgaW5wdXRSZWYoKTogSFRNTElucHV0RWxlbWVudCB8IHVuZGVmaW5lZCB8IG51bGwgeyByZXR1cm4gdGhpcy5fcGFzc3dvcmRJbnB1dCB9XG4gIHNldCBpbnB1dFJlZih2YWx1ZTogSFRNTElucHV0RWxlbWVudCB8IHVuZGVmaW5lZCB8IG51bGwpIHtcbiAgICB0aGlzLl9wYXNzd29yZElucHV0ID0gdmFsdWVcbiAgICB0aGlzLnVwZGF0ZVJldmVhbFN0YXRlKClcbiAgICBpZiAodGhpcy5fcGFzc3dvcmRJbnB1dCkge1xuICAgICAgdGhpcy5fcGFzc3dvcmRJbnB1dC5zdHlsZS5wYWRkaW5nUmlnaHQgPSAnNDBweCdcbiAgICAgIHRoaXMuX3Bhc3N3b3JkSW5wdXQuY2xhc3NMaXN0LmFkZCgnbm8tbmF0aXZlLWV5ZScpXG4gICAgfVxuICB9XG4gIHByaXZhdGUgX3Bhc3N3b3JkSW5wdXQ6IEhUTUxJbnB1dEVsZW1lbnQgfCB1bmRlZmluZWQgfCBudWxsXG5cbiAgQElucHV0KClcbiAgZ2V0IHBhc3N3b3JkVmlzaWJsZSgpIHsgcmV0dXJuIHRoaXMuX3Bhc3N3b3JkVmlzaWJsZSB9XG4gIHNldCBwYXNzd29yZFZpc2libGUodmFsdWU6IGJvb2xlYW4pIHtcbiAgICB0aGlzLl9wYXNzd29yZFZpc2libGUgPSBjb2VyY2VCb29sZWFuUHJvcGVydHkodmFsdWUpXG4gICAgdGhpcy51cGRhdGVSZXZlYWxTdGF0ZSgpXG4gIH1cbiAgcHVibGljIF9wYXNzd29yZFZpc2libGUgPSBmYWxzZVxuXG4gIHB1YmxpYyB1cGRhdGVSZXZlYWxTdGF0ZSgpOiB2b2lkIHtcbiAgICBpZiAodGhpcy5fcGFzc3dvcmRJbnB1dCkge1xuICAgICAgdGhpcy5fcGFzc3dvcmRJbnB1dC50eXBlID0gdGhpcy5wYXNzd29yZFZpc2libGUgPyAndGV4dCcgOiAncGFzc3dvcmQnXG4gICAgfVxuICB9XG5cbiAgcHVibGljIHJldmVhbFBhc3N3b3JkKCk6IHZvaWQge1xuICAgIHRoaXMucGFzc3dvcmRWaXNpYmxlID0gIXRoaXMucGFzc3dvcmRWaXNpYmxlXG4gIH1cblxufVxuIl19

package/esm2020/shared/directives/auto-focus.directive.mjs

@@ -0,0 +1,54 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { Directive, Input, Optional } from '@angular/core';
+import { getClosestModal } from '@theseam/ui-common/modal';
+import * as i0 from "@angular/core";
+import * as i1 from "@theseam/ui-common/modal";
+export class AutoFocusDirective {
+    constructor(_elementRef, _modal, _modalRef) {
+        this._elementRef = _elementRef;
+        this._modal = _modal;
+        this._modalRef = _modalRef;
+        this._focus = true;
+        this.modalRef = _modalRef;
+    }
+    ngOnInit() {
+        if (!this.modalRef) {
+            // When this directive is included in a dialog via TemplateRef (rather than being
+            // in a Component), the DialogRef isn't available via injection because embedded
+            // views cannot be given a custom injector. Instead, we look up the DialogRef by
+            // ID. This must occur in `onInit`, as the ID binding for the dialog container won't
+            // be resolved at constructor time.
+            this.modalRef = getClosestModal(this._elementRef, this._modal.openDialogs);
+        }
+        if (!this.modalRef) {
+            if (this._focus) {
+                setTimeout(() => { this.focus(); });
+            }
+        }
+        else {
+            this.modalRef.afterOpened().subscribe(() => {
+                setTimeout(() => { this.focus(); });
+            });
+        }
+    }
+    set seamAutoFocus(condition) {
+        this._focus = coerceBooleanProperty(condition) !== false;
+    }
+    focus() {
+        this._elementRef.nativeElement.focus();
+    }
+}
+AutoFocusDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AutoFocusDirective, deps: [{ token: i0.ElementRef }, { token: i1.Modal }, { token: i1.ModalRef, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+AutoFocusDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: AutoFocusDirective, selector: "[seamAutoFocus]", inputs: { seamAutoFocus: "seamAutoFocus" }, exportAs: ["seamAutoFocus"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: AutoFocusDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[seamAutoFocus]',
+                    exportAs: 'seamAutoFocus'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.Modal }, { type: i1.ModalRef, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { seamAutoFocus: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/shared/directives/click-outside.directive.mjs

@@ -0,0 +1,52 @@
+import { Directive, EventEmitter, HostListener, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ClickOutsideDirective {
+    get seamClickOutsideActive() {
+        return this._active;
+    }
+    set seamClickOutsideActive(value) {
+        if (this._active === value) {
+            return;
+        }
+        if (value) {
+            // `setTimeout` is used to avoid the click event triggering when the value
+            // changes if the value was changed with a click.
+            setTimeout(() => { this._active = value; });
+        }
+        else {
+            this._active = value;
+        }
+    }
+    // NOTE: This should probably be changed from a `HostListener` to allow the
+    // subscription to be unsubscribed.
+    onDocumentClick(event) {
+        if (this._active) {
+            const targetElement = event.target;
+            // Check if the click was outside the element
+            if (targetElement && !this.elementRef.nativeElement.contains(targetElement)) {
+                this.seamClickOutside.emit(event);
+            }
+        }
+    }
+    constructor(elementRef) {
+        this.elementRef = elementRef;
+        this._active = true;
+        this.seamClickOutside = new EventEmitter();
+    }
+}
+ClickOutsideDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ClickOutsideDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+ClickOutsideDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.9", type: ClickOutsideDirective, selector: "[seamClickOutside]", inputs: { seamClickOutsideActive: "seamClickOutsideActive" }, outputs: { seamClickOutside: "seamClickOutside" }, host: { listeners: { "document:click": "onDocumentClick($event)" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: ClickOutsideDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[seamClickOutside]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { seamClickOutsideActive: [{
+                type: Input
+            }], seamClickOutside: [{
+                type: Output
+            }], onDocumentClick: [{
+                type: HostListener,
+                args: ['document:click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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