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

package/esm2020/confirm-dialog/confirm-dialog.service.mjs

@@ -0,0 +1,38 @@
+import { Injectable } from '@angular/core';
+import { ConfirmDialogComponent } from './confirm-dialog.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@theseam/ui-common/modal";
+export class SeamConfirmDialogService {
+    constructor(modal) {
+        this.modal = modal;
+    }
+    open(message, alert) {
+        const modalRef = this.modal.openFromComponent(ConfirmDialogComponent);
+        if (!modalRef.componentInstance) {
+            throw new Error('ConfirmDialogComponent not created.');
+        }
+        const comp = modalRef.componentInstance;
+        if (message) {
+            comp.message = message;
+        }
+        if (alert) {
+            if (typeof alert === 'string') {
+                comp.alertMessage = alert;
+            }
+            else if (alert.message && alert.type) {
+                comp.alertMessage = alert.message;
+                comp.alertType = alert.type;
+            }
+            else {
+                throw new Error('Invalid alert argument.');
+            }
+        }
+        return modalRef;
+    }
+}
+SeamConfirmDialogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SeamConfirmDialogService, deps: [{ token: i1.Modal }], target: i0.ɵɵFactoryTarget.Injectable });
+SeamConfirmDialogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SeamConfirmDialogService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: SeamConfirmDialogService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Modal }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZmlybS1kaWFsb2cuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9jb25maXJtLWRpYWxvZy9jb25maXJtLWRpYWxvZy5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUE7QUFLMUMsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sNEJBQTRCLENBQUE7OztBQUduRSxNQUFNLE9BQU8sd0JBQXdCO0lBRW5DLFlBQ1UsS0FBWTtRQUFaLFVBQUssR0FBTCxLQUFLLENBQU87SUFDbEIsQ0FBQztJQUVFLElBQUksQ0FDVCxPQUFnQixFQUNoQixLQUFzRDtRQUV0RCxNQUFNLFFBQVEsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLGlCQUFpQixDQUFDLHNCQUFzQixDQUFDLENBQUE7UUFFckUsSUFBSSxDQUFDLFFBQVEsQ0FBQyxpQkFBaUIsRUFBRTtZQUMvQixNQUFNLElBQUksS0FBSyxDQUFDLHFDQUFxQyxDQUFDLENBQUE7U0FDdkQ7UUFFRCxNQUFNLElBQUksR0FBMkIsUUFBUSxDQUFDLGlCQUFpQixDQUFBO1FBRS9ELElBQUksT0FBTyxFQUFFO1lBQ1gsSUFBSSxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUE7U0FDdkI7UUFFRCxJQUFJLEtBQUssRUFBRTtZQUNULElBQUksT0FBTyxLQUFLLEtBQUssUUFBUSxFQUFFO2dCQUM3QixJQUFJLENBQUMsWUFBWSxHQUFHLEtBQUssQ0FBQTthQUMxQjtpQkFBTSxJQUFJLEtBQUssQ0FBQyxPQUFPLElBQUksS0FBSyxDQUFDLElBQUksRUFBRTtnQkFDdEMsSUFBSSxDQUFDLFlBQVksR0FBRyxLQUFLLENBQUMsT0FBTyxDQUFBO2dCQUNqQyxJQUFJLENBQUMsU0FBUyxHQUFHLEtBQUssQ0FBQyxJQUFJLENBQUE7YUFDNUI7aUJBQU07Z0JBQ0wsTUFBTSxJQUFJLEtBQUssQ0FBQyx5QkFBeUIsQ0FBQyxDQUFBO2FBQzNDO1NBQ0Y7UUFFRCxPQUFPLFFBQVEsQ0FBQTtJQUNqQixDQUFDOztxSEFsQ1Usd0JBQXdCO3lIQUF4Qix3QkFBd0I7MkZBQXhCLHdCQUF3QjtrQkFEcEMsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuXG5pbXBvcnQgeyBNb2RhbCwgTW9kYWxSZWYgfSBmcm9tICdAdGhlc2VhbS91aS1jb21tb24vbW9kYWwnXG5pbXBvcnQgeyBUaGVtZVR5cGVzIH0gZnJvbSAnQHRoZXNlYW0vdWktY29tbW9uL21vZGVscydcblxuaW1wb3J0IHsgQ29uZmlybURpYWxvZ0NvbXBvbmVudCB9IGZyb20gJy4vY29uZmlybS1kaWFsb2cuY29tcG9uZW50J1xuXG5ASW5qZWN0YWJsZSgpXG5leHBvcnQgY2xhc3MgU2VhbUNvbmZpcm1EaWFsb2dTZXJ2aWNlIHtcblxuICBjb25zdHJ1Y3RvcihcbiAgICBwcml2YXRlIG1vZGFsOiBNb2RhbFxuICApIHsgfVxuXG4gIHB1YmxpYyBvcGVuKFxuICAgIG1lc3NhZ2U/OiBzdHJpbmcsXG4gICAgYWxlcnQ/OiBzdHJpbmcgfCB7IG1lc3NhZ2U6IHN0cmluZywgdHlwZTogVGhlbWVUeXBlcyB9XG4gICk6IE1vZGFsUmVmPENvbmZpcm1EaWFsb2dDb21wb25lbnQsICdjb25maXJtJyB8IHVuZGVmaW5lZD4ge1xuICAgIGNvbnN0IG1vZGFsUmVmID0gdGhpcy5tb2RhbC5vcGVuRnJvbUNvbXBvbmVudChDb25maXJtRGlhbG9nQ29tcG9uZW50KVxuXG4gICAgaWYgKCFtb2RhbFJlZi5jb21wb25lbnRJbnN0YW5jZSkge1xuICAgICAgdGhyb3cgbmV3IEVycm9yKCdDb25maXJtRGlhbG9nQ29tcG9uZW50IG5vdCBjcmVhdGVkLicpXG4gICAgfVxuXG4gICAgY29uc3QgY29tcDogQ29uZmlybURpYWxvZ0NvbXBvbmVudCA9IG1vZGFsUmVmLmNvbXBvbmVudEluc3RhbmNlXG5cbiAgICBpZiAobWVzc2FnZSkge1xuICAgICAgY29tcC5tZXNzYWdlID0gbWVzc2FnZVxuICAgIH1cblxuICAgIGlmIChhbGVydCkge1xuICAgICAgaWYgKHR5cGVvZiBhbGVydCA9PT0gJ3N0cmluZycpIHtcbiAgICAgICAgY29tcC5hbGVydE1lc3NhZ2UgPSBhbGVydFxuICAgICAgfSBlbHNlIGlmIChhbGVydC5tZXNzYWdlICYmIGFsZXJ0LnR5cGUpIHtcbiAgICAgICAgY29tcC5hbGVydE1lc3NhZ2UgPSBhbGVydC5tZXNzYWdlXG4gICAgICAgIGNvbXAuYWxlcnRUeXBlID0gYWxlcnQudHlwZVxuICAgICAgfSBlbHNlIHtcbiAgICAgICAgdGhyb3cgbmV3IEVycm9yKCdJbnZhbGlkIGFsZXJ0IGFyZ3VtZW50LicpXG4gICAgICB9XG4gICAgfVxuXG4gICAgcmV0dXJuIG1vZGFsUmVmXG4gIH1cblxufVxuIl19

package/esm2020/core/common-behaviors/active.mjs

@@ -0,0 +1,14 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+/** Mixin to augment a directive with a `disabled` property. */
+export function mixinActive(base) {
+    return class extends base {
+        get active() { return this._active; }
+        set active(value) { this._active = coerceBooleanProperty(value); }
+        // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+        constructor(...args) {
+            super(...args);
+            this._active = false;
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdWktY29tbW9uL2NvcmUvY29tbW9uLWJlaGF2aW9ycy9hY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sdUJBQXVCLENBQUE7QUFVN0QsK0RBQStEO0FBQy9ELE1BQU0sVUFBVSxXQUFXLENBQWdDLElBQU87SUFDaEUsT0FBTyxLQUFNLFNBQVEsSUFBSTtRQUd2QixJQUFJLE1BQU0sS0FBSyxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUEsQ0FBQyxDQUFDO1FBQ3BDLElBQUksTUFBTSxDQUFDLEtBQVUsSUFBSSxJQUFJLENBQUMsT0FBTyxHQUFHLHFCQUFxQixDQUFDLEtBQUssQ0FBQyxDQUFBLENBQUMsQ0FBQztRQUV0RSxxRUFBcUU7UUFDckUsWUFBWSxHQUFHLElBQVc7WUFBSSxLQUFLLENBQUMsR0FBRyxJQUFJLENBQUMsQ0FBQTtZQU5wQyxZQUFPLEdBQUcsS0FBSyxDQUFBO1FBTXNCLENBQUM7S0FDL0MsQ0FBQTtBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBjb2VyY2VCb29sZWFuUHJvcGVydHkgfSBmcm9tICdAYW5ndWxhci9jZGsvY29lcmNpb24nXG5pbXBvcnQgeyBDb25zdHJ1Y3RvciB9IGZyb20gJy4vY29uc3RydWN0b3InXG5cbmV4cG9ydCBpbnRlcmZhY2UgQ2FuQmVBY3RpdmUge1xuICAvKiogV2hldGhlciB0aGUgY29tcG9uZW50IGlzIGFjdGl2ZS4gKi9cbiAgYWN0aXZlOiBib29sZWFuXG59XG5cbmV4cG9ydCB0eXBlIENhbkJlQWN0aXZlQ3RvciA9IENvbnN0cnVjdG9yPENhbkJlQWN0aXZlPlxuXG4vKiogTWl4aW4gdG8gYXVnbWVudCBhIGRpcmVjdGl2ZSB3aXRoIGEgYGRpc2FibGVkYCBwcm9wZXJ0eS4gKi9cbmV4cG9ydCBmdW5jdGlvbiBtaXhpbkFjdGl2ZTxUIGV4dGVuZHMgQ29uc3RydWN0b3I8b2JqZWN0Pj4oYmFzZTogVCk6IENhbkJlQWN0aXZlQ3RvciAmIFQge1xuICByZXR1cm4gY2xhc3MgZXh0ZW5kcyBiYXNlIHtcbiAgICBwcml2YXRlIF9hY3RpdmUgPSBmYWxzZVxuXG4gICAgZ2V0IGFjdGl2ZSgpIHsgcmV0dXJuIHRoaXMuX2FjdGl2ZSB9XG4gICAgc2V0IGFjdGl2ZSh2YWx1ZTogYW55KSB7IHRoaXMuX2FjdGl2ZSA9IGNvZXJjZUJvb2xlYW5Qcm9wZXJ0eSh2YWx1ZSkgfVxuXG4gICAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9uby11c2VsZXNzLWNvbnN0cnVjdG9yXG4gICAgY29uc3RydWN0b3IoLi4uYXJnczogYW55W10pIHsgc3VwZXIoLi4uYXJncykgfVxuICB9XG59XG4iXX0=

package/esm2020/core/common-behaviors/disabled.mjs

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+/** Mixin to augment a directive with a `disabled` property. */
+export function mixinDisabled(base) {
+    return class extends base {
+        get disabled() { return this._disabled; }
+        set disabled(value) { this._disabled = coerceBooleanProperty(value); }
+        // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+        constructor(...args) {
+            super(...args);
+            this._disabled = false;
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/common-behaviors/initialized.mjs

@@ -0,0 +1,63 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Observable } from 'rxjs';
+/** Mixin to augment a directive with an initialized property that will emits when ngOnInit ends. */
+export function mixinInitialized(base) {
+    return class extends base {
+        // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+        constructor(...args) {
+            super(...args);
+            /** Whether this directive has been marked as initialized. */
+            this._isInitialized = false;
+            /**
+             * List of subscribers that subscribed before the directive was initialized. Should be notified
+             * during _markInitialized. Set to null after pending subscribers are notified, and should
+             * not expect to be populated after.
+             */
+            this._pendingSubscribers = [];
+            /**
+             * Observable stream that emits when the directive initializes. If already initialized, the
+             * subscriber is stored to be notified once _markInitialized is called.
+             */
+            this.initialized = new Observable(subscriber => {
+                // If initialized, immediately notify the subscriber. Otherwise store the subscriber to notify
+                // when _markInitialized is called.
+                if (this._isInitialized) {
+                    this._notifySubscriber(subscriber);
+                }
+                else {
+                    if (this._pendingSubscribers) {
+                        this._pendingSubscribers.push(subscriber);
+                    }
+                }
+            });
+        }
+        /**
+         * Marks the state as initialized and notifies pending subscribers. Should be called at the end
+         * of ngOnInit.
+         * @docs-private
+         */
+        _markInitialized() {
+            if (this._isInitialized) {
+                throw Error('This directive has already been marked as initialized and ' +
+                    'should not be called twice.');
+            }
+            this._isInitialized = true;
+            if (this._pendingSubscribers) {
+                this._pendingSubscribers.forEach(this._notifySubscriber);
+            }
+            this._pendingSubscribers = null;
+        }
+        /** Emits and completes the subscriber stream (should only emit once). */
+        _notifySubscriber(subscriber) {
+            subscriber.next();
+            subscriber.complete();
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/common-behaviors/size.mjs

@@ -0,0 +1,24 @@
+/** Mixin to augment a directive with a `size` property. */
+export function mixinSize(base, sizePrefix, defaultSize) {
+    return class extends base {
+        get size() { return this._size; }
+        set size(value) {
+            const themePalette = value || defaultSize;
+            if (themePalette !== this._size) {
+                if (this._size) {
+                    this._elementRef.nativeElement.classList.remove(`${sizePrefix}-${this._size}`);
+                }
+                if (themePalette) {
+                    this._elementRef.nativeElement.classList.add(`${sizePrefix}-${themePalette}`);
+                }
+                this._size = themePalette;
+            }
+        }
+        constructor(...args) {
+            super(...args);
+            // Set the default size that can be specified from the mixin.
+            this.size = defaultSize;
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/common-behaviors/tabindex.mjs

@@ -0,0 +1,23 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+/** Mixin to augment a directive with a `tabIndex` property. */
+export function mixinTabIndex(base, defaultTabIndex = 0) {
+    return class extends base {
+        get tabIndex() { return this.disabled ? -1 : this._tabIndex; }
+        set tabIndex(value) {
+            // If the specified tabIndex value is null or undefined, fall back to the default value.
+            this._tabIndex = value != null ? value : defaultTabIndex;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+        constructor(...args) {
+            super(...args);
+            this._tabIndex = defaultTabIndex;
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/common-behaviors/theme.mjs

@@ -0,0 +1,24 @@
+/** Mixin to augment a directive with a `theme` property. */
+export function mixinTheme(base, themePrefix, defaultTheme) {
+    return class extends base {
+        get theme() { return this._theme; }
+        set theme(value) {
+            const themePalette = value || defaultTheme;
+            if (themePalette !== this._theme) {
+                if (this._theme) {
+                    this._elementRef.nativeElement.classList.remove(`${themePrefix}-${this._theme}`);
+                }
+                if (themePalette) {
+                    this._elementRef.nativeElement.classList.add(`${themePrefix}-${themePalette}`);
+                }
+                this._theme = themePalette;
+            }
+        }
+        constructor(...args) {
+            super(...args);
+            // Set the default theme that can be specified from the mixin.
+            this.theme = defaultTheme;
+        }
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/core/input-decorators/input-boolean.decorator.mjs

@@ -0,0 +1,26 @@
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+/**
+ * Use with `@Input()` to coerse the input to a boolean.
+ *
+ * Example:
+ * ```ts
+ * @Component({ template: '' })
+ * class {
+ *     @Input() @InputBoolean() b: boolean
+ * }
+ * ```
+ */
+export function InputBoolean() {
+    const cachedValueKey = Symbol('Cached boolean input value');
+    return function (target, propertyKey, descriptor) {
+        Object.defineProperty(target, propertyKey, {
+            set(value) {
+                this[cachedValueKey] = coerceBooleanProperty(value);
+            },
+            get() {
+                return this[cachedValueKey];
+            },
+        });
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5wdXQtYm9vbGVhbi5kZWNvcmF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vY29yZS9pbnB1dC1kZWNvcmF0b3JzL2lucHV0LWJvb2xlYW4uZGVjb3JhdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHVCQUF1QixDQUFBO0FBRTdEOzs7Ozs7Ozs7O0dBVUc7QUFDSCxNQUFNLFVBQVUsWUFBWTtJQUMxQixNQUFNLGNBQWMsR0FBRyxNQUFNLENBQUMsNEJBQTRCLENBQUMsQ0FBQTtJQUMzRCxPQUFPLFVBQ0wsTUFBVyxFQUNYLFdBQW1CLEVBQ25CLFVBQStCO1FBRS9CLE1BQU0sQ0FBQyxjQUFjLENBQUMsTUFBTSxFQUFFLFdBQVcsRUFBRTtZQUN6QyxHQUFHLENBQUMsS0FBYztnQkFDaEIsSUFBSSxDQUFDLGNBQWMsQ0FBQyxHQUFHLHFCQUFxQixDQUFDLEtBQUssQ0FBQyxDQUFBO1lBQ3JELENBQUM7WUFDRCxHQUFHO2dCQUNELE9BQU8sSUFBSSxDQUFDLGNBQWMsQ0FBQyxDQUFBO1lBQzdCLENBQUM7U0FDRixDQUFDLENBQUE7SUFDSixDQUFDLENBQUE7QUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgY29lcmNlQm9vbGVhblByb3BlcnR5IH0gZnJvbSAnQGFuZ3VsYXIvY2RrL2NvZXJjaW9uJ1xuXG4vKipcbiAqIFVzZSB3aXRoIGBASW5wdXQoKWAgdG8gY29lcnNlIHRoZSBpbnB1dCB0byBhIGJvb2xlYW4uXG4gKlxuICogRXhhbXBsZTpcbiAqIGBgYHRzXG4gKiBAQ29tcG9uZW50KHsgdGVtcGxhdGU6ICcnIH0pXG4gKiBjbGFzcyB7XG4gKiAgICAgQElucHV0KCkgQElucHV0Qm9vbGVhbigpIGI6IGJvb2xlYW5cbiAqIH1cbiAqIGBgYFxuICovXG5leHBvcnQgZnVuY3Rpb24gSW5wdXRCb29sZWFuKCkge1xuICBjb25zdCBjYWNoZWRWYWx1ZUtleSA9IFN5bWJvbCgnQ2FjaGVkIGJvb2xlYW4gaW5wdXQgdmFsdWUnKVxuICByZXR1cm4gZnVuY3Rpb24oXG4gICAgdGFyZ2V0OiBhbnksXG4gICAgcHJvcGVydHlLZXk6IHN0cmluZyxcbiAgICBkZXNjcmlwdG9yPzogUHJvcGVydHlEZXNjcmlwdG9yXG4gICkge1xuICAgIE9iamVjdC5kZWZpbmVQcm9wZXJ0eSh0YXJnZXQsIHByb3BlcnR5S2V5LCB7XG4gICAgICBzZXQodmFsdWU6IGJvb2xlYW4pIHtcbiAgICAgICAgdGhpc1tjYWNoZWRWYWx1ZUtleV0gPSBjb2VyY2VCb29sZWFuUHJvcGVydHkodmFsdWUpXG4gICAgICB9LFxuICAgICAgZ2V0KCkge1xuICAgICAgICByZXR1cm4gdGhpc1tjYWNoZWRWYWx1ZUtleV1cbiAgICAgIH0sXG4gICAgfSlcbiAgfVxufVxuIl19

package/esm2020/core/input-decorators/input-number.decorator.mjs

@@ -0,0 +1,26 @@
+import { coerceNumberProperty } from '@angular/cdk/coercion';
+/**
+ * Use with `@Input()` to coerse the input to a number.
+ *
+ * Example:
+ * ```ts
+ * @Component({ template: '' })
+ * class {
+ *     @Input() @InputNumber() b: number
+ * }
+ * ```
+ */
+export function InputNumber(fallback) {
+    const cachedValueKey = Symbol('Cached input number value');
+    return function (target, propertyKey, descriptor) {
+        Object.defineProperty(target, propertyKey, {
+            set(value) {
+                this[cachedValueKey] = coerceNumberProperty(value, fallback);
+            },
+            get() {
+                return this[cachedValueKey];
+            },
+        });
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5wdXQtbnVtYmVyLmRlY29yYXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi9jb3JlL2lucHV0LWRlY29yYXRvcnMvaW5wdXQtbnVtYmVyLmRlY29yYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQTtBQUU1RDs7Ozs7Ozs7OztHQVVHO0FBQ0gsTUFBTSxVQUFVLFdBQVcsQ0FBWSxRQUFvQjtJQUN6RCxNQUFNLGNBQWMsR0FBRyxNQUFNLENBQUMsMkJBQTJCLENBQUMsQ0FBQTtJQUMxRCxPQUFPLFVBQ0wsTUFBVyxFQUNYLFdBQW1CLEVBQ25CLFVBQStCO1FBRS9CLE1BQU0sQ0FBQyxjQUFjLENBQUMsTUFBTSxFQUFFLFdBQVcsRUFBRTtZQUN6QyxHQUFHLENBQUMsS0FBYTtnQkFDZixJQUFJLENBQUMsY0FBYyxDQUFDLEdBQUcsb0JBQW9CLENBQUMsS0FBSyxFQUFFLFFBQVEsQ0FBQyxDQUFBO1lBQzlELENBQUM7WUFDRCxHQUFHO2dCQUNELE9BQU8sSUFBSSxDQUFDLGNBQWMsQ0FBQyxDQUFBO1lBQzdCLENBQUM7U0FDRixDQUFDLENBQUE7SUFDSixDQUFDLENBQUE7QUFDSCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgY29lcmNlTnVtYmVyUHJvcGVydHkgfSBmcm9tICdAYW5ndWxhci9jZGsvY29lcmNpb24nXG5cbi8qKlxuICogVXNlIHdpdGggYEBJbnB1dCgpYCB0byBjb2Vyc2UgdGhlIGlucHV0IHRvIGEgbnVtYmVyLlxuICpcbiAqIEV4YW1wbGU6XG4gKiBgYGB0c1xuICogQENvbXBvbmVudCh7IHRlbXBsYXRlOiAnJyB9KVxuICogY2xhc3Mge1xuICogICAgIEBJbnB1dCgpIEBJbnB1dE51bWJlcigpIGI6IG51bWJlclxuICogfVxuICogYGBgXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBJbnB1dE51bWJlcjxURmFsbGJhY2s+KGZhbGxiYWNrPzogVEZhbGxiYWNrKSB7XG4gIGNvbnN0IGNhY2hlZFZhbHVlS2V5ID0gU3ltYm9sKCdDYWNoZWQgaW5wdXQgbnVtYmVyIHZhbHVlJylcbiAgcmV0dXJuIGZ1bmN0aW9uKFxuICAgIHRhcmdldDogYW55LFxuICAgIHByb3BlcnR5S2V5OiBzdHJpbmcsXG4gICAgZGVzY3JpcHRvcj86IFByb3BlcnR5RGVzY3JpcHRvclxuICApIHtcbiAgICBPYmplY3QuZGVmaW5lUHJvcGVydHkodGFyZ2V0LCBwcm9wZXJ0eUtleSwge1xuICAgICAgc2V0KHZhbHVlOiBudW1iZXIpIHtcbiAgICAgICAgdGhpc1tjYWNoZWRWYWx1ZUtleV0gPSBjb2VyY2VOdW1iZXJQcm9wZXJ0eSh2YWx1ZSwgZmFsbGJhY2spXG4gICAgICB9LFxuICAgICAgZ2V0KCkge1xuICAgICAgICByZXR1cm4gdGhpc1tjYWNoZWRWYWx1ZUtleV1cbiAgICAgIH0sXG4gICAgfSlcbiAgfVxufVxuIl19

package/esm2020/data-exporter/data-exporter.module.mjs

@@ -0,0 +1,25 @@
+import { NgModule } from '@angular/core';
+import { CSVDataExporter } from './exporters/csv-exporter';
+import { XLSXDataExporter } from './exporters/xlsx-exporter';
+import { THESEAM_DATA_EXPORTER } from './data-exporter';
+import * as i0 from "@angular/core";
+export class TheSeamDataExporterModule {
+}
+TheSeamDataExporterModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamDataExporterModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TheSeamDataExporterModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: TheSeamDataExporterModule });
+TheSeamDataExporterModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamDataExporterModule, providers: [
+        { provide: THESEAM_DATA_EXPORTER, useClass: CSVDataExporter, multi: true },
+        { provide: THESEAM_DATA_EXPORTER, useClass: XLSXDataExporter, multi: true }
+    ] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamDataExporterModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [],
+                    providers: [
+                        { provide: THESEAM_DATA_EXPORTER, useClass: CSVDataExporter, multi: true },
+                        { provide: THESEAM_DATA_EXPORTER, useClass: XLSXDataExporter, multi: true }
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS1leHBvcnRlci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vZGF0YS1leHBvcnRlci9kYXRhLWV4cG9ydGVyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFBO0FBRXhDLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQTtBQUMxRCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQTtBQUU1RCxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQTs7QUFVdkQsTUFBTSxPQUFPLHlCQUF5Qjs7c0hBQXpCLHlCQUF5Qjt1SEFBekIseUJBQXlCO3VIQUF6Qix5QkFBeUIsYUFMekI7UUFDVCxFQUFFLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxRQUFRLEVBQUUsZUFBZSxFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUU7UUFDMUUsRUFBRSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsUUFBUSxFQUFFLGdCQUFnQixFQUFFLEtBQUssRUFBRSxJQUFJLEVBQUU7S0FDNUU7MkZBRVUseUJBQXlCO2tCQVJyQyxRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRSxFQUFFO29CQUNoQixPQUFPLEVBQUUsRUFBRTtvQkFDWCxTQUFTLEVBQUU7d0JBQ1QsRUFBRSxPQUFPLEVBQUUscUJBQXFCLEVBQUUsUUFBUSxFQUFFLGVBQWUsRUFBRSxLQUFLLEVBQUUsSUFBSSxFQUFFO3dCQUMxRSxFQUFFLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxRQUFRLEVBQUUsZ0JBQWdCLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRTtxQkFDNUU7aUJBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnXG5cbmltcG9ydCB7IENTVkRhdGFFeHBvcnRlciB9IGZyb20gJy4vZXhwb3J0ZXJzL2Nzdi1leHBvcnRlcidcbmltcG9ydCB7IFhMU1hEYXRhRXhwb3J0ZXIgfSBmcm9tICcuL2V4cG9ydGVycy94bHN4LWV4cG9ydGVyJ1xuXG5pbXBvcnQgeyBUSEVTRUFNX0RBVEFfRVhQT1JURVIgfSBmcm9tICcuL2RhdGEtZXhwb3J0ZXInXG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogW10sXG4gIGltcG9ydHM6IFtdLFxuICBwcm92aWRlcnM6IFtcbiAgICB7IHByb3ZpZGU6IFRIRVNFQU1fREFUQV9FWFBPUlRFUiwgdXNlQ2xhc3M6IENTVkRhdGFFeHBvcnRlciwgbXVsdGk6IHRydWUgfSxcbiAgICB7IHByb3ZpZGU6IFRIRVNFQU1fREFUQV9FWFBPUlRFUiwgdXNlQ2xhc3M6IFhMU1hEYXRhRXhwb3J0ZXIsIG11bHRpOiB0cnVlIH1cbiAgXVxufSlcbmV4cG9ydCBjbGFzcyBUaGVTZWFtRGF0YUV4cG9ydGVyTW9kdWxlIHsgfVxuIl19

package/esm2020/data-exporter/exporters/csv-exporter.mjs

@@ -0,0 +1,35 @@
+import { Injectable } from '@angular/core';
+import { from } from 'rxjs';
+import { mapTo, switchMap, tap } from 'rxjs/operators';
+import { faFileCsv } from '@fortawesome/free-solid-svg-icons';
+import FileSaver from 'file-saver';
+import { fileDataFromBuffer, wrapIntoObservable } from '@theseam/ui-common/utils';
+import * as i0 from "@angular/core";
+export class CSVDataExporter {
+    constructor() {
+        this.name = 'exporter:csv';
+        this.label = 'CSV';
+        this.icon = faFileCsv;
+    }
+    export(data) {
+        // TODO: Fix typing for the dynamic imports
+        return wrapIntoObservable(import('xlsx')).pipe(switchMap((XLSX) => {
+            const ws = XLSX.utils.json_to_sheet(data);
+            const out = XLSX.utils.sheet_to_csv(ws);
+            // NOTE: `out` should not be passed as a string, but the fileDataFromBuffer
+            // function happens to works with a string. When the build issue about the
+            // function argument is figured out then this should be fixed.
+            return from(fileDataFromBuffer(out))
+                // return from(fileDataFromBuffer(Buffer.from(out)))
+                .pipe(tap(fileData => {
+                FileSaver.saveAs(fileData.blob, `Export.csv`);
+            }), mapTo(true));
+        }));
+    }
+}
+CSVDataExporter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CSVDataExporter, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+CSVDataExporter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CSVDataExporter });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: CSVDataExporter, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/data-exporter/exporters/xlsx-exporter.mjs

@@ -0,0 +1,33 @@
+import { Injectable } from '@angular/core';
+import { from } from 'rxjs';
+import { mapTo, switchMap, tap } from 'rxjs/operators';
+import { faFileExcel } from '@fortawesome/free-solid-svg-icons';
+import { Buffer } from 'buffer/';
+import FileSaver from 'file-saver';
+import { fileDataFromBuffer, wrapIntoObservable } from '@theseam/ui-common/utils';
+import * as i0 from "@angular/core";
+export class XLSXDataExporter {
+    constructor() {
+        this.name = 'exporter:xlsx';
+        this.label = 'XLSX';
+        this.icon = faFileExcel;
+    }
+    export(data) {
+        // TODO: Fix typing for the dynamic imports
+        return wrapIntoObservable(import('xlsx')).pipe(switchMap((XLSX) => {
+            const ws = XLSX.utils.json_to_sheet(data);
+            const wb = { Sheets: { 'data': ws }, SheetNames: ['data'] };
+            const excelBuffer = XLSX.write(wb, { bookType: 'xlsx', type: 'array' });
+            return from(fileDataFromBuffer(Buffer.from(excelBuffer)))
+                .pipe(tap(fileData => {
+                FileSaver.saveAs(fileData.blob, `Export.xlsx`);
+            }), mapTo(true));
+        }));
+    }
+}
+XLSXDataExporter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: XLSXDataExporter, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+XLSXDataExporter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: XLSXDataExporter });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: XLSXDataExporter, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/data-filters/data-filter.mjs

@@ -0,0 +1,25 @@
+import { InjectionToken } from '@angular/core';
+import { combineLatest, of } from 'rxjs';
+import { map, startWith, switchMap } from 'rxjs/operators';
+export const THESEAM_DATA_FILTER = new InjectionToken('TheSeamDataFilter');
+export const THESEAM_DATA_FILTER_OPTIONS = new InjectionToken('TheSeamDataFilterOptions');
+export function filterOperator(filterFn) {
+    return (source$) => source$.pipe(switchMap(filterFn));
+}
+export function composeDataFilters(filters) {
+    const filterFunctions = filters.map(f => filterOperator(f.filter.bind(f)));
+    return (source$) => {
+        let src$ = source$;
+        for (const f of filterFunctions) {
+            src$ = src$.pipe(f);
+        }
+        return src$;
+    };
+}
+export function composeDataFilterStates(filters) {
+    if (filters.length === 0) {
+        return of([]);
+    }
+    return combineLatest(filters.map(f => f.filterStateChanges.pipe(startWith(undefined), map(() => f.filterState()))));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0YS1maWx0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vZGF0YS1maWx0ZXJzL2RhdGEtZmlsdGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxlQUFlLENBQUE7QUFDOUMsT0FBTyxFQUFFLGFBQWEsRUFBYyxFQUFFLEVBQUUsTUFBTSxNQUFNLENBQUE7QUFDcEQsT0FBTyxFQUFFLEdBQUcsRUFBRSxTQUFTLEVBQUUsU0FBUyxFQUFFLE1BQU0sZ0JBQWdCLENBQUE7QUFzRDFELE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUFHLElBQUksY0FBYyxDQUFhLG1CQUFtQixDQUFDLENBQUE7QUFDdEYsTUFBTSxDQUFDLE1BQU0sMkJBQTJCLEdBQUcsSUFBSSxjQUFjLENBQVMsMEJBQTBCLENBQUMsQ0FBQTtBQUVqRyxNQUFNLFVBQVUsY0FBYyxDQUFJLFFBQTRCO0lBQzVELE9BQU8sQ0FBQyxPQUF3QixFQUFFLEVBQUUsQ0FDbEMsT0FBTyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsUUFBUSxDQUFDLENBQUMsQ0FBQTtBQUNyQyxDQUFDO0FBRUQsTUFBTSxVQUFVLGtCQUFrQixDQUFDLE9BQXFCO0lBQ3RELE1BQU0sZUFBZSxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxjQUFjLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFBO0lBQzFFLE9BQU8sQ0FBQyxPQUF3QixFQUFFLEVBQUU7UUFDbEMsSUFBSSxJQUFJLEdBQUcsT0FBTyxDQUFBO1FBQ2xCLEtBQUssTUFBTSxDQUFDLElBQUksZUFBZSxFQUFFO1lBQy9CLElBQUksR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFBO1NBQ3BCO1FBQ0QsT0FBTyxJQUFJLENBQUE7SUFDYixDQUFDLENBQUE7QUFDSCxDQUFDO0FBRUQsTUFBTSxVQUFVLHVCQUF1QixDQUFDLE9BQXFCO0lBQzNELElBQUksT0FBTyxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUU7UUFDeEIsT0FBTyxFQUFFLENBQUMsRUFBRSxDQUFDLENBQUE7S0FDZDtJQUVELE9BQU8sYUFBYSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsa0JBQWtCLENBQUMsSUFBSSxDQUM3RCxTQUFTLENBQUMsU0FBUyxDQUFDLEVBQ3BCLEdBQUcsQ0FBQyxHQUFHLEVBQUUsQ0FBQyxDQUFDLENBQUMsV0FBVyxFQUFFLENBQUMsQ0FDM0IsQ0FBQyxDQUFDLENBQUE7QUFDTCxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4gfSBmcm9tICdAYW5ndWxhci9jb3JlJ1xuaW1wb3J0IHsgY29tYmluZUxhdGVzdCwgT2JzZXJ2YWJsZSwgb2YgfSBmcm9tICdyeGpzJ1xuaW1wb3J0IHsgbWFwLCBzdGFydFdpdGgsIHN3aXRjaE1hcCB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJ1xuXG5leHBvcnQgdHlwZSBEYXRhRmlsdGVyRnVuY3Rpb24gPSA8VD4oZGF0YTogVFtdKSA9PiBPYnNlcnZhYmxlPFRbXT5cblxuLyoqXG4gKiBTdGF0ZSBvZiB0aGUgZmlsdGVyIHRoYXQgd291bGQgYWxsb3cgYW4gZXh0ZXJuYWwgb3BlcmF0aW9uIHRvIGFwcGx5IHRoZVxuICogZmlsdGVyaW5nLlxuICpcbiAqIFRoaXMgaXMgcHJpbWFyaWx5IGZvciBzZXJ2ZXItc2lkZSBmaWx0ZXJpbmcuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRGF0YUZpbHRlclN0YXRlIHtcbiAgLyoqXG4gICAqIERhdGFGaWx0ZXIncyBuYW1lLlxuICAgKi9cbiAgbmFtZTogc3RyaW5nXG5cbiAgLyoqXG4gICAqIEFueXRoaW5nIG5lY2Vzc2FyeSBmb3IgYW4gZXh0ZXJuYWwgaW1wbGVtZW50YXRpb24gdG8gYXBwbHkgdGhpcyBmaWx0ZXIuXG4gICAqL1xuICBzdGF0ZTogeyBba2V5OiBzdHJpbmddOiBhbnkgfVxufVxuXG4vLyBUT0RPOiBDb25zaWRlciBhZGRpbmcgc29tZXRoaW5nLCBzdWNoIGFzIGEgcHJpb3JpdHkgb3Igb3JkZXIsIHRvIGFsbG93IHRoZVxuLy8gb3JkZXIgdGhlIGZpbHRlciBmdW5jdGlvbnMgYXJlIGNhbGxlZCBpbiB0byBiZSBkZWNsYXJlZC9pbmZsdWVuY2VkXG4vLyBleHRlcm5hbGx5LiBUaGlzIHdvdWxkIGFsbG93IHRoZSBmaWx0ZXJzIHRoYXQgd2lsbCBtb3N0IGxpa2VseSBmaWx0ZXIgb3V0XG4vLyBtYW55IHJlY29yZHMgcXVpY2tseSB0byBiZSBydW4gYmVmb3JlIHRoZSBoZWF2eSBwcm9jZXNzaW5nIGZpbHRlcnMuXG5leHBvcnQgaW50ZXJmYWNlIERhdGFGaWx0ZXIge1xuICAvKipcbiAgICogTmFtZSB1c2VkIHdoZW4gcmVmZXJlbmNpbmcgZmlsdGVyIGJ5IHN0cmluZy5cbiAgICovXG4gIG5hbWU6IHN0cmluZ1xuXG4gIC8qKlxuICAgKiBVbmlxdWUgdmFsdWUgdG8gcHJldmVudCBhIGZpbHRlciBiZWluZyB1c2VkIG1vcmUgdGhhbiBvbmNlIGlmIGl0IGVuZHMgdXBcbiAgICogYmVpbmcgcmVnaXN0ZXJlZCBtb3JlIHRoYW4gb25jZS5cbiAgICovXG4gIHVpZDogc3RyaW5nXG5cbiAgLyoqXG4gICAqXG4gICAqL1xuICBmaWx0ZXJTdGF0ZUNoYW5nZXM6IE9ic2VydmFibGU8RGF0YUZpbHRlclN0YXRlPlxuXG4gIC8qKlxuICAgKiBGaWx0ZXJzIHRoZSBkYXRhIGJhc2VkIG9uIHRoZSBjb25kaXRpb25zIG9mIHRoZSBmaWx0ZXIuXG4gICAqL1xuICBmaWx0ZXI8VD4oZGF0YTogVFtdKTogT2JzZXJ2YWJsZTxUW10+XG5cbiAgLyoqXG4gICAqXG4gICAqL1xuICBmaWx0ZXJTdGF0ZSgpOiBEYXRhRmlsdGVyU3RhdGVcbn1cblxuZXhwb3J0IGNvbnN0IFRIRVNFQU1fREFUQV9GSUxURVIgPSBuZXcgSW5qZWN0aW9uVG9rZW48RGF0YUZpbHRlcj4oJ1RoZVNlYW1EYXRhRmlsdGVyJylcbmV4cG9ydCBjb25zdCBUSEVTRUFNX0RBVEFfRklMVEVSX09QVElPTlMgPSBuZXcgSW5qZWN0aW9uVG9rZW48b2JqZWN0PignVGhlU2VhbURhdGFGaWx0ZXJPcHRpb25zJylcblxuZXhwb3J0IGZ1bmN0aW9uIGZpbHRlck9wZXJhdG9yPFQ+KGZpbHRlckZuOiBEYXRhRmlsdGVyRnVuY3Rpb24pIHtcbiAgcmV0dXJuIChzb3VyY2UkOiBPYnNlcnZhYmxlPFRbXT4pID0+XG4gICAgc291cmNlJC5waXBlKHN3aXRjaE1hcChmaWx0ZXJGbikpXG59XG5cbmV4cG9ydCBmdW5jdGlvbiBjb21wb3NlRGF0YUZpbHRlcnMoZmlsdGVyczogRGF0YUZpbHRlcltdKSB7XG4gIGNvbnN0IGZpbHRlckZ1bmN0aW9ucyA9IGZpbHRlcnMubWFwKGYgPT4gZmlsdGVyT3BlcmF0b3IoZi5maWx0ZXIuYmluZChmKSkpXG4gIHJldHVybiAoc291cmNlJDogT2JzZXJ2YWJsZTxhbnk+KSA9PiB7XG4gICAgbGV0IHNyYyQgPSBzb3VyY2UkXG4gICAgZm9yIChjb25zdCBmIG9mIGZpbHRlckZ1bmN0aW9ucykge1xuICAgICAgc3JjJCA9IHNyYyQucGlwZShmKVxuICAgIH1cbiAgICByZXR1cm4gc3JjJFxuICB9XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBjb21wb3NlRGF0YUZpbHRlclN0YXRlcyhmaWx0ZXJzOiBEYXRhRmlsdGVyW10pOiBPYnNlcnZhYmxlPERhdGFGaWx0ZXJTdGF0ZVtdPiB7XG4gIGlmIChmaWx0ZXJzLmxlbmd0aCA9PT0gMCkge1xuICAgIHJldHVybiBvZihbXSlcbiAgfVxuXG4gIHJldHVybiBjb21iaW5lTGF0ZXN0KGZpbHRlcnMubWFwKGYgPT4gZi5maWx0ZXJTdGF0ZUNoYW5nZXMucGlwZShcbiAgICBzdGFydFdpdGgodW5kZWZpbmVkKSxcbiAgICBtYXAoKCkgPT4gZi5maWx0ZXJTdGF0ZSgpKVxuICApKSlcbn1cblxuLyoqIEBkZXByZWNhdGVkIFVzZSBgRGF0YUZpbHRlcmAgaW5zdGVhZC4gKi9cbmV4cG9ydCB0eXBlIElEYXRhRmlsdGVyID0gRGF0YUZpbHRlclxuXG4vKiogQGRlcHJlY2F0ZWQgVXNlIGBJRGF0YUZpbHRlckZ1bmN0aW9uYCBpbnN0ZWFkLiAqL1xuZXhwb3J0IHR5cGUgSURhdGFGaWx0ZXJGdW5jdGlvbiA9IERhdGFGaWx0ZXJGdW5jdGlvblxuIl19

package/esm2020/data-filters/data-filters.module.mjs

@@ -0,0 +1,66 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ReactiveFormsModule } from '@angular/forms';
+import { FontAwesomeModule } from '@fortawesome/angular-fontawesome';
+import { TheSeamFormFieldModule } from '@theseam/ui-common/form-field';
+import { TheSeamIconModule } from '@theseam/ui-common/icon';
+import { TheSeamToggleGroupModule } from '@theseam/ui-common/toggle-group';
+import { THESEAM_DATA_FILTER_DEF } from './data-filter-def';
+import { DataFilterSearchComponent } from './filters/data-filter-search/data-filter-search.component';
+import { DataFilterTextComponent } from './filters/data-filter-text/data-filter-text.component';
+import { DataFilterToggleButtonsComponent } from './filters/data-filter-toggle-buttons/data-filter-toggle-buttons.component';
+import * as i0 from "@angular/core";
+const filterComponents = [
+    DataFilterSearchComponent,
+    DataFilterTextComponent,
+    DataFilterToggleButtonsComponent
+];
+const filterDefProviders = [
+    { provide: THESEAM_DATA_FILTER_DEF, useValue: { name: 'search', component: DataFilterSearchComponent }, multi: true },
+    { provide: THESEAM_DATA_FILTER_DEF, useValue: { name: 'text', component: DataFilterTextComponent }, multi: true },
+    { provide: THESEAM_DATA_FILTER_DEF, useValue: { name: 'toggle-buttons', component: DataFilterToggleButtonsComponent }, multi: true },
+];
+export class TheSeamDataFiltersModule {
+}
+TheSeamDataFiltersModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamDataFiltersModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+TheSeamDataFiltersModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.9", ngImport: i0, type: TheSeamDataFiltersModule, declarations: [DataFilterSearchComponent,
+        DataFilterTextComponent,
+        DataFilterToggleButtonsComponent], imports: [CommonModule,
+        ReactiveFormsModule,
+        TheSeamFormFieldModule,
+        FontAwesomeModule,
+        TheSeamToggleGroupModule,
+        TheSeamIconModule], exports: [DataFilterSearchComponent,
+        DataFilterTextComponent,
+        DataFilterToggleButtonsComponent] });
+TheSeamDataFiltersModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamDataFiltersModule, providers: [
+        ...filterDefProviders
+    ], imports: [CommonModule,
+        ReactiveFormsModule,
+        TheSeamFormFieldModule,
+        FontAwesomeModule,
+        TheSeamToggleGroupModule,
+        TheSeamIconModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.9", ngImport: i0, type: TheSeamDataFiltersModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        ...filterComponents
+                    ],
+                    imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        TheSeamFormFieldModule,
+                        FontAwesomeModule,
+                        TheSeamToggleGroupModule,
+                        TheSeamIconModule
+                    ],
+                    providers: [
+                        ...filterDefProviders
+                    ],
+                    exports: [
+                        ...filterComponents
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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