@skyux/list-builder 5.9.4 → 6.0.0-beta.10

package/esm2020/lib/modules/list-data-provider-in-memory/list-data-in-memory.provider.mjs

@@ -0,0 +1,163 @@
+import { ListItemModel, compare, getData } from '@skyux/list-builder-common';
+import { BehaviorSubject } from 'rxjs';
+import { map as observableMap } from 'rxjs/operators';
+import { ListDataResponseModel } from '../list/list-data-response.model';
+import { ListDataProvider } from '../list/list-data.provider';
+import { ListSearchModel } from '../list/state/search/search.model';
+let idIndex = 0;
+/**
+ * @deprecated
+ */
+export class SkyListInMemoryDataProvider extends ListDataProvider {
+    constructor(data, searchFunction) {
+        super(data);
+        this.items = new BehaviorSubject([]);
+        this.searchFunction = searchFunction;
+        if (data) {
+            data.subscribe((items) => {
+                this.items.next(items.map((d) => new ListItemModel(d.id || `sky-list-data-in-memory-provider-item-${++idIndex}`, d)));
+            });
+        }
+    }
+    count() {
+        return this.items.pipe(observableMap((items) => items.length));
+    }
+    get(request) {
+        return this.filteredItems(request).pipe(observableMap((result) => {
+            if (request.pageNumber && request.pageSize) {
+                const itemStart = (request.pageNumber - 1) * request.pageSize;
+                const pagedResult = result.slice(itemStart, itemStart + request.pageSize);
+                return new ListDataResponseModel({
+                    count: result.length,
+                    items: pagedResult,
+                });
+            }
+            else {
+                return new ListDataResponseModel({
+                    count: result.length,
+                    items: result,
+                });
+            }
+        }));
+    }
+    filteredItems(request) {
+        const showSelectedId = ['show-selected'];
+        return this.items.pipe(observableMap((items) => {
+            let dataChanged = false;
+            let search = request.search;
+            const sort = request.sort;
+            let filters = request.filters;
+            if (this.lastItems === undefined || this.lastItems !== items) {
+                dataChanged = true;
+                this.lastItems = items;
+            }
+            let searchChanged = false;
+            let filtersChanged = false;
+            if (request.isToolbarDisabled) {
+                searchChanged = true;
+                search = new ListSearchModel();
+                filters = filters.filter((f) => showSelectedId.indexOf(f.name) >= 0);
+                filtersChanged = true;
+            }
+            else {
+                if (this.lastSearch === undefined || this.lastSearch !== search) {
+                    searchChanged = true;
+                }
+                if (this.lastFilters === undefined || this.lastFilters !== filters) {
+                    filtersChanged = true;
+                }
+            }
+            this.lastSearch = search;
+            this.lastFilters = filters;
+            let result = items;
+            // Apply filters.
+            if (!dataChanged &&
+                !filtersChanged &&
+                this.lastFilterResults !== undefined) {
+                result = this.lastFilterResults;
+            }
+            else if (filters && filters.length > 0) {
+                result = result.filter((item) => {
+                    for (let i = 0; i < filters.length; i++) {
+                        const filter = filters[i];
+                        if (filter.value === undefined ||
+                            filter.value === '' ||
+                            filter.value === false ||
+                            filter.value === filter.defaultValue) {
+                            continue;
+                        }
+                        if (!filter.filterFunction(item, filter.value)) {
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+                this.lastFilterResults = result;
+            }
+            else {
+                this.lastFilterResults = undefined;
+            }
+            // Apply search.
+            /* istanbul ignore next */
+            if (!dataChanged &&
+                !searchChanged &&
+                this.lastSearchResults !== undefined &&
+                !filtersChanged) {
+                result = this.lastSearchResults;
+            }
+            else if (search &&
+                search.searchText !== undefined &&
+                search.searchText.length > 0) {
+                const searchText = search.searchText.toLowerCase();
+                let searchFunctions;
+                if (this.searchFunction !== undefined) {
+                    searchFunctions = [this.searchFunction];
+                }
+                else {
+                    searchFunctions = search.functions;
+                }
+                result = result.filter((item) => {
+                    let isMatch = false;
+                    for (let i = 0; i < searchFunctions.length; i++) {
+                        const searchFunction = searchFunctions[i];
+                        const searchResult = searchFunction(item.data, searchText);
+                        if ((typeof searchResult === 'string' &&
+                            searchResult.indexOf(searchText) !== -1) ||
+                            searchResult === true) {
+                            isMatch = true;
+                            break;
+                        }
+                    }
+                    return isMatch;
+                });
+                this.lastSearchResults = result;
+            }
+            else {
+                this.lastSearchResults = undefined;
+            }
+            // Apply sort.
+            if (sort && sort.fieldSelectors.length > 0) {
+                result = result
+                    .slice()
+                    .sort((item1, item2) => {
+                    let compareResult = 0;
+                    for (let i = 0; i < sort.fieldSelectors.length; i++) {
+                        const selector = sort.fieldSelectors[i];
+                        const value1 = getData(item1.data, selector.fieldSelector);
+                        const value2 = getData(item2.data, selector.fieldSelector);
+                        compareResult = compare(value1, value2);
+                        if (selector.descending && compareResult !== 0) {
+                            compareResult *= -1;
+                        }
+                        if (compareResult !== 0) {
+                            break;
+                        }
+                    }
+                    return compareResult;
+                });
+            }
+            return result;
+        }));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list-data-in-memory.provider.js","sourceRoot":"","sources":["../../../../../../../../libs/components/list-builder/src/lib/modules/list-data-provider-in-memory/list-data-in-memory.provider.ts"],"names":[],"mappings":"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","sourcesContent":["import { ListItemModel, compare, getData } from '@skyux/list-builder-common';\n\nimport { BehaviorSubject, Observable } from 'rxjs';\nimport { map as observableMap } from 'rxjs/operators';\n\nimport { ListFilterModel } from '../list-filters/filter.model';\nimport { ListDataRequestModel } from '../list/list-data-request.model';\nimport { ListDataResponseModel } from '../list/list-data-response.model';\nimport { ListDataProvider } from '../list/list-data.provider';\nimport { ListSearchModel } from '../list/state/search/search.model';\n\nlet idIndex = 0;\n\n/**\n * @deprecated\n */\nexport class SkyListInMemoryDataProvider extends ListDataProvider {\n  public items: BehaviorSubject<Array<ListItemModel>> = new BehaviorSubject<\n    Array<ListItemModel>\n  >([]);\n\n  private lastItems: ListItemModel[];\n  private lastSearch: ListSearchModel;\n  private lastSearchResults: ListItemModel[];\n  private searchFunction: (data: any, searchText: string) => boolean;\n\n  private lastFilters: ListFilterModel[];\n  private lastFilterResults: ListItemModel[];\n\n  constructor(\n    data?: Observable<Array<any>>,\n    searchFunction?: (data: any, searchText: string) => boolean\n  ) {\n    super(data);\n\n    this.searchFunction = searchFunction;\n\n    if (data) {\n      data.subscribe((items) => {\n        this.items.next(\n          items.map(\n            (d) =>\n              new ListItemModel(\n                d.id || `sky-list-data-in-memory-provider-item-${++idIndex}`,\n                d\n              )\n          )\n        );\n      });\n    }\n  }\n\n  public count(): Observable<number> {\n    return this.items.pipe(observableMap((items) => items.length));\n  }\n\n  public get(request: ListDataRequestModel): Observable<ListDataResponseModel> {\n    return this.filteredItems(request).pipe(\n      observableMap((result) => {\n        if (request.pageNumber && request.pageSize) {\n          const itemStart = (request.pageNumber - 1) * request.pageSize;\n          const pagedResult = result.slice(\n            itemStart,\n            itemStart + request.pageSize\n          );\n          return new ListDataResponseModel({\n            count: result.length,\n            items: pagedResult,\n          });\n        } else {\n          return new ListDataResponseModel({\n            count: result.length,\n            items: result,\n          });\n        }\n      })\n    );\n  }\n\n  private filteredItems(\n    request: ListDataRequestModel\n  ): Observable<Array<ListItemModel>> {\n    const showSelectedId = ['show-selected'];\n\n    return this.items.pipe(\n      observableMap((items) => {\n        let dataChanged = false;\n        let search = request.search;\n        const sort = request.sort;\n        let filters: ListFilterModel[] = request.filters;\n\n        if (this.lastItems === undefined || this.lastItems !== items) {\n          dataChanged = true;\n          this.lastItems = items;\n        }\n\n        let searchChanged = false;\n        let filtersChanged = false;\n\n        if (request.isToolbarDisabled) {\n          searchChanged = true;\n          search = new ListSearchModel();\n\n          filters = filters.filter((f) => showSelectedId.indexOf(f.name) >= 0);\n          filtersChanged = true;\n        } else {\n          if (this.lastSearch === undefined || this.lastSearch !== search) {\n            searchChanged = true;\n          }\n\n          if (this.lastFilters === undefined || this.lastFilters !== filters) {\n            filtersChanged = true;\n          }\n        }\n\n        this.lastSearch = search;\n        this.lastFilters = filters;\n\n        let result = items;\n\n        // Apply filters.\n        if (\n          !dataChanged &&\n          !filtersChanged &&\n          this.lastFilterResults !== undefined\n        ) {\n          result = this.lastFilterResults;\n        } else if (filters && filters.length > 0) {\n          result = result.filter((item) => {\n            for (let i = 0; i < filters.length; i++) {\n              const filter = filters[i];\n              if (\n                filter.value === undefined ||\n                filter.value === '' ||\n                filter.value === false ||\n                filter.value === filter.defaultValue\n              ) {\n                continue;\n              }\n\n              if (!filter.filterFunction(item, filter.value)) {\n                return false;\n              }\n            }\n            return true;\n          });\n\n          this.lastFilterResults = result;\n        } else {\n          this.lastFilterResults = undefined;\n        }\n\n        // Apply search.\n        /* istanbul ignore next */\n        if (\n          !dataChanged &&\n          !searchChanged &&\n          this.lastSearchResults !== undefined &&\n          !filtersChanged\n        ) {\n          result = this.lastSearchResults;\n        } else if (\n          search &&\n          search.searchText !== undefined &&\n          search.searchText.length > 0\n        ) {\n          const searchText = search.searchText.toLowerCase();\n          let searchFunctions: any[];\n          if (this.searchFunction !== undefined) {\n            searchFunctions = [this.searchFunction];\n          } else {\n            searchFunctions = search.functions;\n          }\n\n          result = result.filter((item) => {\n            let isMatch = false;\n\n            for (let i = 0; i < searchFunctions.length; i++) {\n              const searchFunction = searchFunctions[i];\n              const searchResult = searchFunction(item.data, searchText);\n\n              if (\n                (typeof searchResult === 'string' &&\n                  searchResult.indexOf(searchText) !== -1) ||\n                searchResult === true\n              ) {\n                isMatch = true;\n                break;\n              }\n            }\n\n            return isMatch;\n          });\n\n          this.lastSearchResults = result;\n        } else {\n          this.lastSearchResults = undefined;\n        }\n\n        // Apply sort.\n        if (sort && sort.fieldSelectors.length > 0) {\n          result = result\n            .slice()\n            .sort((item1: ListItemModel, item2: ListItemModel) => {\n              let compareResult = 0;\n              for (let i = 0; i < sort.fieldSelectors.length; i++) {\n                const selector = sort.fieldSelectors[i];\n                const value1 = getData(item1.data, selector.fieldSelector);\n                const value2 = getData(item2.data, selector.fieldSelector);\n\n                compareResult = compare(value1, value2);\n\n                if (selector.descending && compareResult !== 0) {\n                  compareResult *= -1;\n                }\n\n                if (compareResult !== 0) {\n                  break;\n                }\n              }\n\n              return compareResult;\n            });\n        }\n        return result;\n      })\n    );\n  }\n}\n"]}

package/esm2020/lib/modules/list-filters/filter.model.mjs

@@ -0,0 +1,18 @@
+export class ListFilterModel {
+    constructor(data) {
+        /**
+         * Indicates whether users can dismiss the filter's summary item.
+         * @default true
+         */
+        this.dismissible = true;
+        if (data) {
+            this.name = data.name;
+            this.label = data.label;
+            this.filterFunction = data.filterFunction;
+            this.value = data.value;
+            this.dismissible = data.dismissible;
+            this.defaultValue = data.defaultValue;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/list-filters/list-filter-button.component.mjs

@@ -0,0 +1,42 @@
+import { Component, TemplateRef, ViewChild, } from '@angular/core';
+import { ListStateDispatcher } from '../list/state/list-state.rxstate';
+import { ListToolbarItemModel } from '../list/state/toolbar/toolbar-item.model';
+import * as i0 from "@angular/core";
+import * as i1 from "../list/state/list-state.rxstate";
+/**
+ * Contains a filter button for the list toolbar. Place a
+ * [`sky-filter-button`](https://developer.blackbaud.com/skyux/components/filter)
+ * component inside this component to open a modal with filtering options.
+ * To apply filter options, use the
+ * [list component's](https://developer.blackbaud.com/skyux/components/list/overview#list-properties)
+ * `appliedFilters` property.
+ * @deprecated
+ */
+export class SkyListFilterButtonComponent {
+    constructor(dispatcher) {
+        this.dispatcher = dispatcher;
+        this.filterButtonItemToolbarIndex = 5000;
+    }
+    ngAfterViewInit() {
+        this.dispatcher.toolbarAddItems([
+            new ListToolbarItemModel({
+                template: this.filterButtonTemplate,
+                location: 'left',
+                index: this.filterButtonItemToolbarIndex,
+            }),
+        ]);
+    }
+}
+SkyListFilterButtonComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyListFilterButtonComponent, deps: [{ token: i1.ListStateDispatcher }], target: i0.ɵɵFactoryTarget.Component });
+SkyListFilterButtonComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.2", type: SkyListFilterButtonComponent, selector: "sky-list-filter-button", viewQueries: [{ propertyName: "filterButtonTemplate", first: true, predicate: ["filterButton"], descendants: true, read: TemplateRef, static: true }], ngImport: i0, template: "<ng-template #filterButton>\n  <ng-content></ng-content>\n</ng-template>\n" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyListFilterButtonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sky-list-filter-button', template: "<ng-template #filterButton>\n  <ng-content></ng-content>\n</ng-template>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.ListStateDispatcher }]; }, propDecorators: { filterButtonTemplate: [{
+                type: ViewChild,
+                args: ['filterButton', {
+                        read: TemplateRef,
+                        static: true,
+                    }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/list-filters/list-filter-inline-item-renderer.component.mjs

@@ -0,0 +1,34 @@
+import { Component, Input, TemplateRef, ViewChild, ViewContainerRef, } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * @internal
+ */
+export class SkyListFilterInlineItemRendererComponent {
+    ngOnInit() {
+        /* istanbul ignore else */
+        /* sanity check */
+        if (this.template !== undefined) {
+            this.container.createEmbeddedView(this.template, this);
+        }
+    }
+}
+SkyListFilterInlineItemRendererComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyListFilterInlineItemRendererComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+SkyListFilterInlineItemRendererComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.2", type: SkyListFilterInlineItemRendererComponent, selector: "sky-list-filter-inline-item-renderer", inputs: { template: "template", filter: "filter" }, viewQueries: [{ propertyName: "container", first: true, predicate: ["container"], descendants: true, read: ViewContainerRef, static: true }], ngImport: i0, template: '<ng-template #container></ng-template>', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyListFilterInlineItemRendererComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'sky-list-filter-inline-item-renderer',
+                    template: '<ng-template #container></ng-template>',
+                }]
+        }], propDecorators: { template: [{
+                type: Input
+            }], filter: [{
+                type: Input
+            }], container: [{
+                type: ViewChild,
+                args: ['container', {
+                        read: ViewContainerRef,
+                        static: true,
+                    }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlzdC1maWx0ZXItaW5saW5lLWl0ZW0tcmVuZGVyZXIuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21wb25lbnRzL2xpc3QtYnVpbGRlci9zcmMvbGliL21vZHVsZXMvbGlzdC1maWx0ZXJzL2xpc3QtZmlsdGVyLWlubGluZS1pdGVtLXJlbmRlcmVyLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsU0FBUyxFQUNULEtBQUssRUFFTCxXQUFXLEVBQ1gsU0FBUyxFQUNULGdCQUFnQixHQUNqQixNQUFNLGVBQWUsQ0FBQzs7QUFFdkI7O0dBRUc7QUFLSCxNQUFNLE9BQU8sd0NBQXdDO0lBWTVDLFFBQVE7UUFDYiwwQkFBMEI7UUFDMUIsa0JBQWtCO1FBQ2xCLElBQUksSUFBSSxDQUFDLFFBQVEsS0FBSyxTQUFTLEVBQUU7WUFDL0IsSUFBSSxDQUFDLFNBQVMsQ0FBQyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsUUFBUSxFQUFFLElBQUksQ0FBQyxDQUFDO1NBQ3hEO0lBQ0gsQ0FBQzs7cUlBbEJVLHdDQUF3Qzt5SEFBeEMsd0NBQXdDLG1OQU8zQyxnQkFBZ0IsMkNBVGQsd0NBQXdDOzJGQUV2Qyx3Q0FBd0M7a0JBSnBELFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLHNDQUFzQztvQkFDaEQsUUFBUSxFQUFFLHdDQUF3QztpQkFDbkQ7OEJBR1EsUUFBUTtzQkFEZCxLQUFLO2dCQUdDLE1BQU07c0JBRFosS0FBSztnQkFPRSxTQUFTO3NCQUpoQixTQUFTO3VCQUFDLFdBQVcsRUFBRTt3QkFDdEIsSUFBSSxFQUFFLGdCQUFnQjt3QkFDdEIsTUFBTSxFQUFFLElBQUk7cUJBQ2IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICBDb21wb25lbnQsXG4gIElucHV0LFxuICBPbkluaXQsXG4gIFRlbXBsYXRlUmVmLFxuICBWaWV3Q2hpbGQsXG4gIFZpZXdDb250YWluZXJSZWYsXG59IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG4vKipcbiAqIEBpbnRlcm5hbFxuICovXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdza3ktbGlzdC1maWx0ZXItaW5saW5lLWl0ZW0tcmVuZGVyZXInLFxuICB0ZW1wbGF0ZTogJzxuZy10ZW1wbGF0ZSAjY29udGFpbmVyPjwvbmctdGVtcGxhdGU+Jyxcbn0pXG5leHBvcnQgY2xhc3MgU2t5TGlzdEZpbHRlcklubGluZUl0ZW1SZW5kZXJlckNvbXBvbmVudCBpbXBsZW1lbnRzIE9uSW5pdCB7XG4gIEBJbnB1dCgpXG4gIHB1YmxpYyB0ZW1wbGF0ZTogVGVtcGxhdGVSZWY8dW5rbm93bj47XG4gIEBJbnB1dCgpXG4gIHB1YmxpYyBmaWx0ZXI6IGFueTtcblxuICBAVmlld0NoaWxkKCdjb250YWluZXInLCB7XG4gICAgcmVhZDogVmlld0NvbnRhaW5lclJlZixcbiAgICBzdGF0aWM6IHRydWUsXG4gIH0pXG4gIHByaXZhdGUgY29udGFpbmVyOiBWaWV3Q29udGFpbmVyUmVmO1xuXG4gIHB1YmxpYyBuZ09uSW5pdCgpIHtcbiAgICAvKiBpc3RhbmJ1bCBpZ25vcmUgZWxzZSAqL1xuICAgIC8qIHNhbml0eSBjaGVjayAqL1xuICAgIGlmICh0aGlzLnRlbXBsYXRlICE9PSB1bmRlZmluZWQpIHtcbiAgICAgIHRoaXMuY29udGFpbmVyLmNyZWF0ZUVtYmVkZGVkVmlldyh0aGlzLnRlbXBsYXRlLCB0aGlzKTtcbiAgICB9XG4gIH1cbn1cbiJdfQ==

package/esm2020/lib/modules/list-filters/list-filter-inline-item.component.mjs

@@ -0,0 +1,46 @@
+import { Component, ContentChildren, EventEmitter, Input, QueryList, TemplateRef, } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Creates a filter in the list's inline filter area.
+ * @deprecated
+ */
+export class SkyListFilterInlineItemComponent {
+    constructor() {
+        this.onChange = new EventEmitter();
+    }
+    ngOnInit() {
+        if (this.name === undefined || this.name.length === 0) {
+            throw new Error('Inline filter requires a name.');
+        }
+    }
+    get template() {
+        return this.templates.length > 0
+            ? this.templates.first
+            : this.templateInput;
+    }
+}
+SkyListFilterInlineItemComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyListFilterInlineItemComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+SkyListFilterInlineItemComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.2", type: SkyListFilterInlineItemComponent, selector: "sky-list-filter-inline-item", inputs: { name: "name", value: "value", defaultValue: "defaultValue", filterFunction: ["filter", "filterFunction"], templateInput: ["template", "templateInput"] }, queries: [{ propertyName: "templates", predicate: TemplateRef }], ngImport: i0, template: '<ng-content></ng-content>', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyListFilterInlineItemComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'sky-list-filter-inline-item',
+                    template: '<ng-content></ng-content>',
+                }]
+        }], propDecorators: { name: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], defaultValue: [{
+                type: Input
+            }], filterFunction: [{
+                type: Input,
+                args: ['filter']
+            }], templateInput: [{
+                type: Input,
+                args: ['template']
+            }], templates: [{
+                type: ContentChildren,
+                args: [TemplateRef]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/list-filters/list-filter-inline.component.mjs

@@ -0,0 +1,72 @@
+import { Component, ContentChildren, QueryList, } from '@angular/core';
+import { take } from 'rxjs/operators';
+import { ListStateDispatcher } from '../list/state/list-state.rxstate';
+import { ListState } from '../list/state/list-state.state-node';
+import { ListPagingSetPageNumberAction } from '../list/state/paging/set-page-number.action';
+import { ListFilterModel } from './filter.model';
+import { SkyListFilterInlineItemComponent } from './list-filter-inline-item.component';
+import { SkyListFilterInlineModel } from './list-filter-inline.model';
+import * as i0 from "@angular/core";
+import * as i1 from "../list/state/list-state.rxstate";
+import * as i2 from "../list/state/list-state.state-node";
+import * as i3 from "@skyux/lists";
+import * as i4 from "./list-filter-inline-item-renderer.component";
+import * as i5 from "@angular/common";
+/**
+ * Creates an inline filter area for the list. Place each filter
+ * in a `sky-list-filter-inline-item` component.
+ * @deprecated
+ */
+export class SkyListFilterInlineComponent {
+    constructor(dispatcher, state) {
+        this.dispatcher = dispatcher;
+        this.state = state;
+        this.inlineFilters = [];
+    }
+    ngAfterContentInit() {
+        this.inlineFilters = this.filters.map((filter) => {
+            return new SkyListFilterInlineModel({
+                name: filter.name,
+                filterFunction: filter.filterFunction,
+                template: filter.template,
+                value: filter.value,
+                defaultValue: filter.defaultValue,
+            });
+        });
+        this.inlineFilters.forEach((filter) => {
+            filter.onChange.subscribe((value) => {
+                this.applyFilters();
+            });
+        });
+        this.dispatcher.filtersUpdate(this.getFilterModelFromInline(this.inlineFilters));
+    }
+    applyFilters() {
+        this.state.pipe(take(1)).subscribe((currentState) => {
+            if (currentState.paging.pageNumber &&
+                currentState.paging.pageNumber !== 1) {
+                this.dispatcher.next(new ListPagingSetPageNumberAction(Number(1)));
+            }
+            this.dispatcher.filtersUpdate(this.getFilterModelFromInline(this.inlineFilters));
+        });
+    }
+    getFilterModelFromInline(inlineFilters) {
+        return inlineFilters.map((filter) => {
+            return new ListFilterModel({
+                name: filter.name,
+                value: filter.value,
+                filterFunction: filter.filterFunction,
+                defaultValue: filter.defaultValue,
+            });
+        });
+    }
+}
+SkyListFilterInlineComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyListFilterInlineComponent, deps: [{ token: i1.ListStateDispatcher }, { token: i2.ListState }], target: i0.ɵɵFactoryTarget.Component });
+SkyListFilterInlineComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.2", type: SkyListFilterInlineComponent, selector: "sky-list-filter-inline", queries: [{ propertyName: "filters", predicate: SkyListFilterInlineItemComponent }], ngImport: i0, template: "<ng-content></ng-content>\n\n<sky-filter-inline>\n  <sky-filter-inline-item *ngFor=\"let filter of inlineFilters\">\n    <sky-list-filter-inline-item-renderer\n      [template]=\"filter.template\"\n      [filter]=\"filter\"\n    >\n    </sky-list-filter-inline-item-renderer>\n  </sky-filter-inline-item>\n</sky-filter-inline>\n", components: [{ type: i3.λ2, selector: "sky-filter-inline" }, { type: i3.λ3, selector: "sky-filter-inline-item" }, { type: i4.SkyListFilterInlineItemRendererComponent, selector: "sky-list-filter-inline-item-renderer", inputs: ["template", "filter"] }], directives: [{ type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyListFilterInlineComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sky-list-filter-inline', template: "<ng-content></ng-content>\n\n<sky-filter-inline>\n  <sky-filter-inline-item *ngFor=\"let filter of inlineFilters\">\n    <sky-list-filter-inline-item-renderer\n      [template]=\"filter.template\"\n      [filter]=\"filter\"\n    >\n    </sky-list-filter-inline-item-renderer>\n  </sky-filter-inline-item>\n</sky-filter-inline>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.ListStateDispatcher }, { type: i2.ListState }]; }, propDecorators: { filters: [{
+                type: ContentChildren,
+                args: [SkyListFilterInlineItemComponent]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/list-filters/list-filter-inline.model.mjs

@@ -0,0 +1,21 @@
+import { EventEmitter } from '@angular/core';
+/**
+ * @internal
+ */
+export class SkyListFilterInlineModel {
+    constructor(data) {
+        this.onChange = new EventEmitter();
+        if (data) {
+            this.name = data.name;
+            this.filterFunction = data.filterFunction;
+            this.value = data.value;
+            this.template = data.template;
+            this.defaultValue = data.defaultValue;
+        }
+    }
+    changed(value) {
+        this.value = value;
+        this.onChange.emit(value);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/list-filters/list-filter-summary.component.mjs

@@ -0,0 +1,58 @@
+import { Component, EventEmitter, Output, } from '@angular/core';
+import { map as observableMap, take } from 'rxjs/operators';
+import { ListStateDispatcher } from '../list/state/list-state.rxstate';
+import { ListState } from '../list/state/list-state.state-node';
+import * as i0 from "@angular/core";
+import * as i1 from "../list/state/list-state.state-node";
+import * as i2 from "../list/state/list-state.rxstate";
+import * as i3 from "@skyux/lists";
+import * as i4 from "@angular/common";
+/**
+ * Creates a filter summary based on the
+ * [list component's](https://developer.blackbaud.com/skyux/components/list/overview#list-properties)
+ * `appliedFilters` property. Place this component within the
+ * [`sky-list-toolbar`](https://developer.blackbaud.com/skyux/components/list/toolbar) component.
+ * @deprecated
+ */
+export class SkyListFilterSummaryComponent {
+    constructor(state, dispatcher) {
+        this.state = state;
+        this.dispatcher = dispatcher;
+        /**
+         * Emits a `ListFilterModel` when users select a summary item. A common use case is
+         * to open a filter modal when this event is received.
+         */
+        this.summaryItemClick = new EventEmitter();
+    }
+    ngAfterContentInit() {
+        // The setTimeout here is to ensure we avoid any ExpressionChangedAfterItHasBeenCheckedError issues.
+        setTimeout(() => {
+            this.appliedFilters = this.state.pipe(observableMap((state) => {
+                return state.filters.filter((filter) => {
+                    return (filter.value !== '' &&
+                        filter.value !== undefined &&
+                        filter.value !== false &&
+                        filter.value !== filter.defaultValue);
+                });
+            }));
+        });
+    }
+    filterSummaryItemDismiss(index) {
+        this.appliedFilters.pipe(take(1)).subscribe((filters) => {
+            filters.splice(index, 1);
+            this.dispatcher.filtersUpdate(filters.slice());
+        });
+    }
+    filterSummaryItemClick(item) {
+        this.summaryItemClick.emit(item);
+    }
+}
+SkyListFilterSummaryComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyListFilterSummaryComponent, deps: [{ token: i1.ListState }, { token: i2.ListStateDispatcher }], target: i0.ɵɵFactoryTarget.Component });
+SkyListFilterSummaryComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.2", type: SkyListFilterSummaryComponent, selector: "sky-list-filter-summary", outputs: { summaryItemClick: "summaryItemClick" }, ngImport: i0, template: "<sky-filter-summary>\n  <sky-filter-summary-item\n    *ngFor=\"let item of appliedFilters | async; let i = index\"\n    (dismiss)=\"filterSummaryItemDismiss(i)\"\n    (itemClick)=\"filterSummaryItemClick(item)\"\n    [dismissible]=\"item.dismissible\"\n  >\n    {{ item.label || item.value }}\n  </sky-filter-summary-item>\n</sky-filter-summary>\n", components: [{ type: i3.λ5, selector: "sky-filter-summary" }, { type: i3.λ4, selector: "sky-filter-summary-item", inputs: ["dismissible"], outputs: ["dismiss", "itemClick"] }], directives: [{ type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }], pipes: { "async": i4.AsyncPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyListFilterSummaryComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sky-list-filter-summary', template: "<sky-filter-summary>\n  <sky-filter-summary-item\n    *ngFor=\"let item of appliedFilters | async; let i = index\"\n    (dismiss)=\"filterSummaryItemDismiss(i)\"\n    (itemClick)=\"filterSummaryItemClick(item)\"\n    [dismissible]=\"item.dismissible\"\n  >\n    {{ item.label || item.value }}\n  </sky-filter-summary-item>\n</sky-filter-summary>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.ListState }, { type: i2.ListStateDispatcher }]; }, propDecorators: { summaryItemClick: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/list-filters/list-filters.module.mjs

@@ -0,0 +1,44 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { SkyFilterModule } from '@skyux/lists';
+import { SkyListFilterButtonComponent } from './list-filter-button.component';
+import { SkyListFilterInlineItemRendererComponent } from './list-filter-inline-item-renderer.component';
+import { SkyListFilterInlineItemComponent } from './list-filter-inline-item.component';
+import { SkyListFilterInlineComponent } from './list-filter-inline.component';
+import { SkyListFilterSummaryComponent } from './list-filter-summary.component';
+import * as i0 from "@angular/core";
+/**
+ * @deprecated List builder and its features are deprecated. Use data manager instead. For more information, see https://developer.blackbaud.com/skyux/components/data-manager.
+ */
+export class SkyListFiltersModule {
+}
+SkyListFiltersModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyListFiltersModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SkyListFiltersModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyListFiltersModule, declarations: [SkyListFilterButtonComponent,
+        SkyListFilterSummaryComponent,
+        SkyListFilterInlineItemComponent,
+        SkyListFilterInlineComponent,
+        SkyListFilterInlineItemRendererComponent], imports: [CommonModule, SkyFilterModule], exports: [SkyListFilterButtonComponent,
+        SkyListFilterSummaryComponent,
+        SkyListFilterInlineItemComponent,
+        SkyListFilterInlineComponent] });
+SkyListFiltersModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyListFiltersModule, imports: [[CommonModule, SkyFilterModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyListFiltersModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        SkyListFilterButtonComponent,
+                        SkyListFilterSummaryComponent,
+                        SkyListFilterInlineItemComponent,
+                        SkyListFilterInlineComponent,
+                        SkyListFilterInlineItemRendererComponent,
+                    ],
+                    imports: [CommonModule, SkyFilterModule],
+                    exports: [
+                        SkyListFilterButtonComponent,
+                        SkyListFilterSummaryComponent,
+                        SkyListFilterInlineItemComponent,
+                        SkyListFilterInlineComponent,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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