@theseam/ui-common 0.3.11 → 0.4.0-beta.0

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

@@ -0,0 +1,148 @@
+import { __decorate } from "tslib";
+import { Component, forwardRef, Inject, Input, Optional } from '@angular/core';
+import { UntypedFormControl } from '@angular/forms';
+import { of } from 'rxjs';
+import { map, shareReplay, startWith, switchMap } from 'rxjs/operators';
+import { InputBoolean } from '@theseam/ui-common/core';
+import { isNullOrUndefined } from '@theseam/ui-common/utils';
+import { THESEAM_DATA_FILTER, THESEAM_DATA_FILTER_OPTIONS } from '../../data-filter';
+import { THESEAM_DATA_FILTER_CONTAINER } from '../../data-filter-container';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+import * as i3 from "@theseam/ui-common/form-field";
+export const DATA_FILTER_TEXT = {
+    provide: THESEAM_DATA_FILTER,
+    // tslint:disable-next-line:no-use-before-declare
+    useExisting: forwardRef(() => DataFilterTextComponent),
+    multi: true,
+};
+export const DefaultTextFilterOptions = {
+    properties: undefined,
+    omitProperties: undefined,
+    exact: false,
+    caseSensitive: false,
+};
+export function textDataFilter(data, text, options = DefaultTextFilterOptions) {
+    if (!data || !text) {
+        return data;
+    }
+    if (data.length <= 0) {
+        return data;
+    }
+    let props = options ? options.properties : undefined;
+    if (!props) {
+        props = [];
+        let keys = Object.keys(data[0]);
+        if (options && options.omitProperties) {
+            keys = keys.filter(key => !(options.omitProperties || []).find(p => p === key));
+        }
+        for (const key of keys) {
+            if (data[0].hasOwnProperty(key)) {
+                props.push(key);
+            }
+        }
+    }
+    const filtered = [];
+    for (const item of data) {
+        for (const p of props) {
+            let value1 = `${item[p]}`;
+            let value2 = text;
+            if (!options.caseSensitive) {
+                value1 = value1.toLowerCase();
+                value2 = value2.toLowerCase();
+            }
+            if (item[p] && value1.indexOf(value2) !== (options.exact ? 0 : -1)) {
+                filtered.push(item);
+                break;
+            }
+        }
+    }
+    return filtered;
+}
+let _uid = 0;
+export class DataFilterTextComponent {
+    constructor(_filterContainer, _filterOptions) {
+        this._filterContainer = _filterContainer;
+        this._filterOptions = _filterOptions;
+        this.name = 'text';
+        this.uid = `text__${_uid++}`;
+        this._control = new UntypedFormControl();
+        this.properties = this._optDefault('properties');
+        this.omitProperties = this._optDefault('omitProperties');
+        this.exact = this._optDefault('exact');
+        this.caseSensitive = this._optDefault('caseSensitive');
+        this.filterStateChanges = this._control.valueChanges.pipe(switchMap(() => of(this.filterState())), shareReplay({ bufferSize: 1, refCount: true }));
+    }
+    set value(value) {
+        const _value = !isNullOrUndefined(value) ? `${value}` : '';
+        if (this._control.value !== _value) {
+            this._control.setValue(_value);
+        }
+    }
+    ngOnInit() { this._filterContainer.addFilter(this); }
+    ngOnDestroy() { this._filterContainer.removeFilter(this); }
+    _optDefault(prop) {
+        if (this._filterOptions && this._filterOptions.hasOwnProperty(prop)) {
+            return this._filterOptions[prop];
+        }
+        return DefaultTextFilterOptions[prop];
+    }
+    get options() {
+        return {
+            properties: this.properties ?? undefined,
+            omitProperties: this.omitProperties ?? undefined,
+            exact: this.exact,
+            caseSensitive: this.caseSensitive
+        };
+    }
+    filter(data) {
+        return this._control.valueChanges
+            .pipe(map(v => textDataFilter(data, v, this.options)), startWith(textDataFilter(data, this._control.value, this.options)));
+    }
+    filterState() {
+        return {
+            // id:
+            name: this.name,
+            state: {
+                value: this._control.value,
+                options: this.options
+            }
+        };
+    }
+}
+DataFilterTextComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DataFilterTextComponent, deps: [{ token: THESEAM_DATA_FILTER_CONTAINER }, { token: THESEAM_DATA_FILTER_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+DataFilterTextComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.3", type: DataFilterTextComponent, selector: "seam-data-filter-text", inputs: { properties: "properties", omitProperties: "omitProperties", exact: "exact", caseSensitive: "caseSensitive", placeholder: "placeholder", iconTpl: "iconTpl", value: "value" }, providers: [DATA_FILTER_TEXT], ngImport: i0, template: "<div class=\"position-relative\"\n  [class.data-filter-text-has-icon]=\"iconTpl\"\n  (click)=\"inp.focus()\">\n  <label [attr.for]=\"inp.id\" class=\"sr-only\">Text filter</label>\n  <input seamInput #inp=\"seamInput\" seamInputSize=\"sm\" [formControl]=\"_control\" [placeholder]=\"placeholder\">\n  <ng-container *ngIf=\"iconTpl\">\n    <ng-container *ngTemplateOutlet=\"iconTpl\"></ng-container>\n  </ng-container>\n</div>\n", styles: [":host{display:block}.data-filter-text-has-icon>input{padding-left:30px}.data-filter-text-has-icon ::ng-deep fa-icon{position:absolute;top:3px;left:10px;bottom:0}.data-filter-text-has-icon ::ng-deep fa-icon .svg-inline--fa{vertical-align:middle}\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: "directive", type: i2.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "directive", type: i3.InputDirective, selector: "input[seamInput], textarea[seamInput], ng-select[seamInput], seam-checkbox[seamInput] [ngbRadioGroup], seam-tel-input[seamInput], quill-editor[seamInput], seam-google-maps[seamInput]", inputs: ["seamInputSize", "id", "type", "placeholder", "required", "disabled", "readonly"], exportAs: ["seamInput"] }] });
+__decorate([
+    InputBoolean()
+], DataFilterTextComponent.prototype, "exact", void 0);
+__decorate([
+    InputBoolean()
+], DataFilterTextComponent.prototype, "caseSensitive", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DataFilterTextComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'seam-data-filter-text', providers: [DATA_FILTER_TEXT], template: "<div class=\"position-relative\"\n  [class.data-filter-text-has-icon]=\"iconTpl\"\n  (click)=\"inp.focus()\">\n  <label [attr.for]=\"inp.id\" class=\"sr-only\">Text filter</label>\n  <input seamInput #inp=\"seamInput\" seamInputSize=\"sm\" [formControl]=\"_control\" [placeholder]=\"placeholder\">\n  <ng-container *ngIf=\"iconTpl\">\n    <ng-container *ngTemplateOutlet=\"iconTpl\"></ng-container>\n  </ng-container>\n</div>\n", styles: [":host{display:block}.data-filter-text-has-icon>input{padding-left:30px}.data-filter-text-has-icon ::ng-deep fa-icon{position:absolute;top:3px;left:10px;bottom:0}.data-filter-text-has-icon ::ng-deep fa-icon .svg-inline--fa{vertical-align:middle}\n"] }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [THESEAM_DATA_FILTER_CONTAINER]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [THESEAM_DATA_FILTER_OPTIONS]
+                }] }]; }, propDecorators: { properties: [{
+                type: Input
+            }], omitProperties: [{
+                type: Input
+            }], exact: [{
+                type: Input
+            }], caseSensitive: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], iconTpl: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-filter-text.component.js","sourceRoot":"","sources":["../../../../../../projects/ui-common/data-filters/filters/data-filter-text/data-filter-text.component.ts","../../../../../../projects/ui-common/data-filters/filters/data-filter-text/data-filter-text.component.html"],"names":[],"mappings":"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","sourcesContent":["import { BooleanInput } from '@angular/cdk/coercion'\nimport { Component, forwardRef, Inject, Input, OnDestroy, OnInit, Optional, TemplateRef } from '@angular/core'\nimport { UntypedFormControl } from '@angular/forms'\nimport { Observable, of } from 'rxjs'\nimport { map, shareReplay, startWith, switchMap } from 'rxjs/operators'\n\nimport { InputBoolean } from '@theseam/ui-common/core'\nimport { isNullOrUndefined } from '@theseam/ui-common/utils'\n\nimport { DataFilterState, IDataFilter, THESEAM_DATA_FILTER, THESEAM_DATA_FILTER_OPTIONS } from '../../data-filter'\nimport { THESEAM_DATA_FILTER_CONTAINER } from '../../data-filter-container'\nimport type { DataFilterContainer } from '../../data-filter-container'\nimport { ITextFilterOptions } from './text-filter-options'\n\nexport const DATA_FILTER_TEXT: any = {\n  provide: THESEAM_DATA_FILTER,\n  // tslint:disable-next-line:no-use-before-declare\n  useExisting: forwardRef(() => DataFilterTextComponent),\n  multi: true,\n}\n\nexport const DefaultTextFilterOptions: ITextFilterOptions = {\n  properties: undefined,\n  omitProperties: undefined,\n  exact: false,\n  caseSensitive: false,\n}\n\nexport function textDataFilter(data: any[], text: string, options = DefaultTextFilterOptions) {\n  if (!data || !text) {\n    return data\n  }\n\n  if (data.length <= 0) {\n    return data\n  }\n\n  let props = options ? options.properties : undefined\n  if (!props) {\n    props = []\n    let keys = Object.keys(data[0])\n    if (options && options.omitProperties) {\n      keys = keys.filter(key => !(options.omitProperties || []).find(p => p === key))\n    }\n    for (const key of keys) {\n      if (data[0].hasOwnProperty(key)) {\n        props.push(key)\n      }\n    }\n  }\n\n  const filtered: any[] = []\n\n  for (const item of data) {\n    for (const p of props) {\n      let value1 = `${item[p]}`\n      let value2 = text\n\n      if (!options.caseSensitive) {\n        value1 = value1.toLowerCase()\n        value2 = value2.toLowerCase()\n      }\n\n      if (item[p] && value1.indexOf(value2) !== (options.exact ? 0 : -1)) {\n        filtered.push(item)\n        break\n      }\n    }\n  }\n\n  return filtered\n}\n\nlet _uid = 0\n\n@Component({\n  selector: 'seam-data-filter-text',\n  templateUrl: './data-filter-text.component.html',\n  styleUrls: ['./data-filter-text.component.scss'],\n  providers: [ DATA_FILTER_TEXT ]\n})\nexport class DataFilterTextComponent implements OnInit, OnDestroy, IDataFilter {\n  static ngAcceptInputType_exact: BooleanInput\n  static ngAcceptInputType_caseSensitive: BooleanInput\n\n  public readonly name = 'text'\n  public readonly uid = `text__${_uid++}`\n\n  _control = new UntypedFormControl()\n\n  @Input() properties: string[] | undefined | null = this._optDefault('properties')\n  @Input() omitProperties: string[] | undefined | null = this._optDefault('omitProperties')\n  @Input() @InputBoolean() exact: boolean = this._optDefault('exact')\n  @Input() @InputBoolean() caseSensitive: boolean = this._optDefault('caseSensitive')\n\n  @Input() placeholder: string | undefined | null\n  @Input() iconTpl: TemplateRef<HTMLElement> | undefined | null\n\n  @Input()\n  set value(value: string | string[]) {\n    const _value = !isNullOrUndefined(value) ? `${value}` : ''\n    if (this._control.value !== _value) {\n      this._control.setValue(_value)\n    }\n  }\n\n  public readonly filterStateChanges: Observable<DataFilterState>\n\n  constructor(\n    @Inject(THESEAM_DATA_FILTER_CONTAINER) private _filterContainer: DataFilterContainer,\n    @Optional() @Inject(THESEAM_DATA_FILTER_OPTIONS) private _filterOptions: ITextFilterOptions | null\n  ) {\n    this.filterStateChanges = this._control.valueChanges.pipe(\n      switchMap(() => of(this.filterState())),\n      shareReplay({ bufferSize: 1, refCount: true })\n    )\n  }\n\n  ngOnInit() { this._filterContainer.addFilter(this) }\n\n  ngOnDestroy() { this._filterContainer.removeFilter(this) }\n\n  private _optDefault<K extends keyof ITextFilterOptions>(prop: K) {\n    if (this._filterOptions && this._filterOptions.hasOwnProperty(prop)) {\n      return this._filterOptions[prop]\n    }\n    return DefaultTextFilterOptions[prop]\n  }\n\n  get options(): ITextFilterOptions {\n    return {\n      properties: this.properties ?? undefined,\n      omitProperties: this.omitProperties ?? undefined,\n      exact: this.exact,\n      caseSensitive: this.caseSensitive\n    }\n  }\n\n  public filter<T>(data: T[]): Observable<T[]> {\n    return this._control.valueChanges\n      .pipe(\n        map(v => textDataFilter(data, v, this.options)),\n        startWith(textDataFilter(data, this._control.value, this.options)),\n      )\n  }\n\n  public filterState(): DataFilterState {\n    return {\n      // id:\n      name: this.name,\n      state: {\n        value: this._control.value,\n        options: this.options\n      }\n    }\n  }\n\n}\n","<div class=\"position-relative\"\n  [class.data-filter-text-has-icon]=\"iconTpl\"\n  (click)=\"inp.focus()\">\n  <label [attr.for]=\"inp.id\" class=\"sr-only\">Text filter</label>\n  <input seamInput #inp=\"seamInput\" seamInputSize=\"sm\" [formControl]=\"_control\" [placeholder]=\"placeholder\">\n  <ng-container *ngIf=\"iconTpl\">\n    <ng-container *ngTemplateOutlet=\"iconTpl\"></ng-container>\n  </ng-container>\n</div>\n"]}

package/esm2020/data-filters/filters/data-filter-toggle-buttons/data-filter-toggle-buttons.component.mjs

@@ -0,0 +1,163 @@
+import { coerceArray } from '@angular/cdk/coercion';
+import { Component, forwardRef, Inject, Input, Optional } from '@angular/core';
+import { UntypedFormControl } from '@angular/forms';
+import { of } from 'rxjs';
+import { map, shareReplay, startWith, switchMap, tap } from 'rxjs/operators';
+import { hasProperty, isNullOrUndefined } from '@theseam/ui-common/utils';
+import { THESEAM_DATA_FILTER, THESEAM_DATA_FILTER_OPTIONS } from '../../data-filter';
+import { THESEAM_DATA_FILTER_CONTAINER } from '../../data-filter-container';
+import { textDataFilter } from '../data-filter-text/data-filter-text.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
+import * as i3 from "@theseam/ui-common/toggle-group";
+export const DATA_FILTER_TOGGLE_BUTTON = {
+    provide: THESEAM_DATA_FILTER,
+    // tslint:disable-next-line:no-use-before-declare
+    useExisting: forwardRef(() => DataFilterToggleButtonsComponent),
+    multi: true,
+};
+export const DefaultToggleButtonsFilterOptions = {
+    properties: undefined,
+    omitProperties: undefined,
+    multiple: false,
+    selectionToggleable: false,
+    buttons: [],
+    exact: false,
+    caseSensitive: false
+};
+export function toggleButtonsFilter(data, values, options = DefaultToggleButtonsFilterOptions) {
+    if (!data || !values) {
+        return data;
+    }
+    const customComparatorBtns = [];
+    for (const btn of options.buttons) {
+        if (btn.comparator) {
+            customComparatorBtns.push(btn);
+        }
+    }
+    let _data = data;
+    for (const val of values) {
+        if (val === '') {
+            continue;
+        }
+        let cmp;
+        for (const btn of customComparatorBtns) {
+            if (btn.value === val) {
+                cmp = btn.comparator;
+            }
+        }
+        if (cmp) {
+            const filtered = [];
+            for (let i = 0; i < _data.length; i++) {
+                if (cmp(val, _data[i], i) !== -1) {
+                    filtered.push(_data[i]);
+                }
+            }
+            _data = filtered;
+        }
+        else {
+            _data = textDataFilter(_data, val, {
+                properties: options.properties,
+                omitProperties: options.omitProperties,
+                exact: options.exact,
+                caseSensitive: options.caseSensitive
+            });
+        }
+    }
+    return _data;
+}
+let _uid = 0;
+export class DataFilterToggleButtonsComponent {
+    constructor(_filterContainer, _filterOptions) {
+        this._filterContainer = _filterContainer;
+        this._filterOptions = _filterOptions;
+        this.name = 'toggle-buttons';
+        this.uid = `toggle-buttons__${_uid++}`;
+        this._control = new UntypedFormControl();
+        this.properties = this._optDefault('properties');
+        this.omitProperties = this._optDefault('omitProperties');
+        this.multiple = this._optDefault('multiple');
+        this.selectionToggleable = this._optDefault('selectionToggleable');
+        this.buttons = this._optDefault('buttons');
+        this.exact = this._optDefault('exact');
+        this.caseSensitive = this._optDefault('caseSensitive');
+        this.filterStateChanges = this._control.valueChanges.pipe(tap(v => console.log('v', v)), switchMap(() => of(this.filterState())), tap(v => console.log('v2', v)), shareReplay({ bufferSize: 1, refCount: true }));
+    }
+    set value(value) {
+        const _value = !isNullOrUndefined(value) ? coerceArray(value) : undefined;
+        // console.log('_value', _value, this._control.value)
+        if (this._control.value !== _value) {
+            this._control.setValue(_value);
+        }
+    }
+    ngOnInit() {
+        this._filterContainer.addFilter(this);
+        if (this._filterOptions && hasProperty(this._filterOptions, 'initialValue')) {
+            this.value = this._optDefault('initialValue');
+        }
+    }
+    ngOnDestroy() { this._filterContainer.removeFilter(this); }
+    _optDefault(prop) {
+        if (this._filterOptions && this._filterOptions.hasOwnProperty(prop)) {
+            return this._filterOptions[prop];
+        }
+        return DefaultToggleButtonsFilterOptions[prop];
+    }
+    get options() {
+        return {
+            properties: this.properties,
+            omitProperties: this.omitProperties,
+            multiple: this.multiple,
+            selectionToggleable: this.selectionToggleable,
+            buttons: this.buttons,
+            exact: this.exact,
+            caseSensitive: this.caseSensitive
+        };
+    }
+    filter(data) {
+        return this._control.valueChanges
+            .pipe(map(v => toggleButtonsFilter(data, coerceArray(v), this.options)), startWith(toggleButtonsFilter(data, coerceArray(this._control.value), this.options)));
+    }
+    filterState() {
+        return {
+            // id:
+            name: this.name,
+            state: {
+                value: this._control.value,
+                options: this.options
+            }
+        };
+    }
+}
+DataFilterToggleButtonsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DataFilterToggleButtonsComponent, deps: [{ token: THESEAM_DATA_FILTER_CONTAINER }, { token: THESEAM_DATA_FILTER_OPTIONS, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+DataFilterToggleButtonsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.3", type: DataFilterToggleButtonsComponent, selector: "seam-data-filter-toggle-buttons", inputs: { properties: "properties", omitProperties: "omitProperties", multiple: "multiple", selectionToggleable: "selectionToggleable", buttons: "buttons", exact: "exact", caseSensitive: "caseSensitive", value: "value" }, providers: [DATA_FILTER_TOGGLE_BUTTON], ngImport: i0, template: "<div class=\"btn-group\" role=\"group\" aria-label=\"Progress Filter\"\n  *ngIf=\"options as opts\"\n  [formControl]=\"_control\"\n  seamToggleGroup\n  [multiple]=\"opts.multiple\"\n  [selectionToggleable]=\"opts.selectionToggleable\">\n  <ng-container *ngFor=\"let btn of buttons\">\n    <button type=\"button\" class=\"btn btn-sm px-4\"\n      [seamToggleGroupOption]=\"btn.value\"\n      #opt=\"seamToggleGroupOption\"\n      [class.btn-lightgray]=\"!opt.selected\"\n      [class.btn-primary]=\"opt.selected\"\n      (click)=\"opt.selected=!opt.selected\">\n      {{ btn.name || btn.value }}\n    </button>\n  </ng-container>\n</div>\n", styles: [""], dependencies: [{ kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.FormControlDirective, selector: "[formControl]", inputs: ["formControl", "disabled", "ngModel"], outputs: ["ngModelChange"], exportAs: ["ngForm"] }, { kind: "directive", type: i3.ToggleGroupDirective, selector: "[seamToggleGroup]", inputs: ["value", "disabled", "multiple", "selectionToggleable"], outputs: ["change"], exportAs: ["seamToggleGroup"] }, { kind: "directive", type: i3.ToggleGroupOptionDirective, selector: "[seamToggleGroupOption]", inputs: ["seamToggleGroupOption", "selected"], outputs: ["selectionChange"], exportAs: ["seamToggleGroupOption"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.3", ngImport: i0, type: DataFilterToggleButtonsComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'seam-data-filter-toggle-buttons', providers: [DATA_FILTER_TOGGLE_BUTTON], template: "<div class=\"btn-group\" role=\"group\" aria-label=\"Progress Filter\"\n  *ngIf=\"options as opts\"\n  [formControl]=\"_control\"\n  seamToggleGroup\n  [multiple]=\"opts.multiple\"\n  [selectionToggleable]=\"opts.selectionToggleable\">\n  <ng-container *ngFor=\"let btn of buttons\">\n    <button type=\"button\" class=\"btn btn-sm px-4\"\n      [seamToggleGroupOption]=\"btn.value\"\n      #opt=\"seamToggleGroupOption\"\n      [class.btn-lightgray]=\"!opt.selected\"\n      [class.btn-primary]=\"opt.selected\"\n      (click)=\"opt.selected=!opt.selected\">\n      {{ btn.name || btn.value }}\n    </button>\n  </ng-container>\n</div>\n" }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [THESEAM_DATA_FILTER_CONTAINER]
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [THESEAM_DATA_FILTER_OPTIONS]
+                }] }]; }, propDecorators: { properties: [{
+                type: Input
+            }], omitProperties: [{
+                type: Input
+            }], multiple: [{
+                type: Input
+            }], selectionToggleable: [{
+                type: Input
+            }], buttons: [{
+                type: Input
+            }], exact: [{
+                type: Input
+            }], caseSensitive: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"data-filter-toggle-buttons.component.js","sourceRoot":"","sources":["../../../../../../projects/ui-common/data-filters/filters/data-filter-toggle-buttons/data-filter-toggle-buttons.component.ts","../../../../../../projects/ui-common/data-filters/filters/data-filter-toggle-buttons/data-filter-toggle-buttons.component.html"],"names":[],"mappings":"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","sourcesContent":["import { coerceArray } from '@angular/cdk/coercion'\nimport { Component, forwardRef, Inject, Input, OnDestroy, OnInit, Optional } from '@angular/core'\nimport { UntypedFormControl } from '@angular/forms'\nimport { Observable, of } from 'rxjs'\nimport { map, shareReplay, startWith, switchMap, tap } from 'rxjs/operators'\n\nimport { hasProperty, isNullOrUndefined } from '@theseam/ui-common/utils'\n\nimport { DataFilterState, IDataFilter, THESEAM_DATA_FILTER, THESEAM_DATA_FILTER_OPTIONS } from '../../data-filter'\nimport { THESEAM_DATA_FILTER_CONTAINER } from '../../data-filter-container'\nimport type { DataFilterContainer } from '../../data-filter-container'\nimport { textDataFilter } from '../data-filter-text/data-filter-text.component'\nimport { ITextFilterOptions } from '../data-filter-text/text-filter-options'\n\n\nexport const DATA_FILTER_TOGGLE_BUTTON: any = {\n  provide: THESEAM_DATA_FILTER,\n  // tslint:disable-next-line:no-use-before-declare\n  useExisting: forwardRef(() => DataFilterToggleButtonsComponent),\n  multi: true,\n}\n\nexport interface IToggleButton {\n  name: string\n  value: string\n  comparator?: (value: any, row: any, index: number) => -1 | 0 | 1\n}\n\nexport interface IToggleButtonsFilterOptions extends ITextFilterOptions {\n  selectionToggleable: boolean\n  multiple: boolean\n  buttons: IToggleButton[]\n  initialValue?: any\n}\n\nexport const DefaultToggleButtonsFilterOptions: IToggleButtonsFilterOptions = {\n  properties: undefined,\n  omitProperties: undefined,\n  multiple: false,\n  selectionToggleable: false,\n  buttons: [],\n  exact: false,\n  caseSensitive: false\n}\n\nexport function toggleButtonsFilter(data: any[], values: string[], options = DefaultToggleButtonsFilterOptions) {\n  if (!data || !values) {\n    return data\n  }\n\n  const customComparatorBtns: IToggleButton[] = []\n  for (const btn of options.buttons) {\n    if (btn.comparator) {\n      customComparatorBtns.push(btn)\n    }\n  }\n\n  let _data = data\n  for (const val of values) {\n    if (val === '') { continue }\n\n    let cmp\n    for (const btn of customComparatorBtns) {\n      if (btn.value === val) {\n        cmp = btn.comparator\n      }\n    }\n    if (cmp) {\n      const filtered: any[] = []\n      for (let i = 0; i < _data.length; i++) {\n        if (cmp(val, _data[i], i) !== -1) {\n          filtered.push(_data[i])\n        }\n      }\n      _data = filtered\n    } else {\n      _data = textDataFilter(_data, val, {\n        properties: options.properties,\n        omitProperties: options.omitProperties,\n        exact: options.exact,\n        caseSensitive: options.caseSensitive\n      })\n    }\n  }\n  return _data\n}\n\nlet _uid = 0\n\n@Component({\n  selector: 'seam-data-filter-toggle-buttons',\n  templateUrl: './data-filter-toggle-buttons.component.html',\n  styleUrls: ['./data-filter-toggle-buttons.component.scss'],\n  providers: [ DATA_FILTER_TOGGLE_BUTTON ]\n})\nexport class DataFilterToggleButtonsComponent implements OnInit, OnDestroy, IDataFilter {\n\n  public readonly name = 'toggle-buttons'\n  public readonly uid = `toggle-buttons__${_uid++}`\n\n  _control = new UntypedFormControl()\n\n  @Input() properties = this._optDefault('properties')\n  @Input() omitProperties = this._optDefault('omitProperties')\n  @Input() multiple = this._optDefault('multiple')\n  @Input() selectionToggleable = this._optDefault('selectionToggleable')\n  @Input() buttons = this._optDefault('buttons')\n  @Input() exact = this._optDefault('exact')\n  @Input() caseSensitive = this._optDefault('caseSensitive')\n\n  @Input()\n  set value(value: string | string[]) {\n    const _value = !isNullOrUndefined(value) ? coerceArray(value) : undefined\n    // console.log('_value', _value, this._control.value)\n    if (this._control.value !== _value) {\n      this._control.setValue(_value)\n    }\n  }\n\n  public readonly filterStateChanges: Observable<DataFilterState>\n\n  constructor(\n    @Inject(THESEAM_DATA_FILTER_CONTAINER) private _filterContainer: DataFilterContainer,\n    @Optional() @Inject(THESEAM_DATA_FILTER_OPTIONS) private _filterOptions: IToggleButtonsFilterOptions | null\n  ) {\n    this.filterStateChanges = this._control.valueChanges.pipe(\n      tap(v => console.log('v', v)),\n      switchMap(() => of(this.filterState())),\n      tap(v => console.log('v2', v)),\n      shareReplay({ bufferSize: 1, refCount: true })\n    )\n  }\n\n  ngOnInit() {\n    this._filterContainer.addFilter(this)\n    if (this._filterOptions && hasProperty(this._filterOptions, 'initialValue')) {\n      this.value = this._optDefault('initialValue')\n    }\n  }\n\n  ngOnDestroy() { this._filterContainer.removeFilter(this) }\n\n  private _optDefault<K extends keyof IToggleButtonsFilterOptions>(prop: K) {\n    if (this._filterOptions && this._filterOptions.hasOwnProperty(prop)) {\n      return this._filterOptions[prop]\n    }\n    return DefaultToggleButtonsFilterOptions[prop]\n  }\n\n  get options(): IToggleButtonsFilterOptions {\n    return {\n      properties: this.properties,\n      omitProperties: this.omitProperties,\n      multiple: this.multiple,\n      selectionToggleable: this.selectionToggleable,\n      buttons: this.buttons,\n      exact: this.exact,\n      caseSensitive: this.caseSensitive\n    }\n  }\n\n  public filter<T>(data: T[]): Observable<T[]> {\n    return this._control.valueChanges\n      .pipe(\n        map(v => toggleButtonsFilter(data, coerceArray(v), this.options)),\n        startWith(toggleButtonsFilter(data, coerceArray(this._control.value), this.options)),\n      )\n  }\n\n  public filterState(): DataFilterState {\n    return {\n      // id:\n      name: this.name,\n      state: {\n        value: this._control.value,\n        options: this.options\n      }\n    }\n  }\n\n}\n","<div class=\"btn-group\" role=\"group\" aria-label=\"Progress Filter\"\n  *ngIf=\"options as opts\"\n  [formControl]=\"_control\"\n  seamToggleGroup\n  [multiple]=\"opts.multiple\"\n  [selectionToggleable]=\"opts.selectionToggleable\">\n  <ng-container *ngFor=\"let btn of buttons\">\n    <button type=\"button\" class=\"btn btn-sm px-4\"\n      [seamToggleGroupOption]=\"btn.value\"\n      #opt=\"seamToggleGroupOption\"\n      [class.btn-lightgray]=\"!opt.selected\"\n      [class.btn-primary]=\"opt.selected\"\n      (click)=\"opt.selected=!opt.selected\">\n      {{ btn.name || btn.value }}\n    </button>\n  </ng-container>\n</div>\n"]}