@skyux/list-builder 5.7.2 → 6.0.0-beta.2

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

@@ -0,0 +1,160 @@
+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;
+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\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,41 @@
+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.
+ */
+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.2.7", ngImport: i0, type: SkyListFilterButtonComponent, deps: [{ token: i1.ListStateDispatcher }], target: i0.ɵɵFactoryTarget.Component });
+SkyListFilterButtonComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.7", 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.2.7", 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.2.7", ngImport: i0, type: SkyListFilterInlineItemRendererComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+SkyListFilterInlineItemRendererComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.7", 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.2.7", 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+Jyxcbn0pXG5leHBvcnQgY2xhc3MgU2t5TGlzdEZpbHRlcklubGluZUl0ZW1SZW5kZXJlckNvbXBvbmVudCBpbXBsZW1lbnRzIE9uSW5pdCB7XG4gIEBJbnB1dCgpXG4gIHB1YmxpYyB0ZW1wbGF0ZTogVGVtcGxhdGVSZWY8YW55PjtcbiAgQElucHV0KClcbiAgcHVibGljIGZpbHRlcjogYW55O1xuXG4gIEBWaWV3Q2hpbGQoJ2NvbnRhaW5lcicsIHtcbiAgICByZWFkOiBWaWV3Q29udGFpbmVyUmVmLFxuICAgIHN0YXRpYzogdHJ1ZSxcbiAgfSlcbiAgcHJpdmF0ZSBjb250YWluZXI6IFZpZXdDb250YWluZXJSZWY7XG5cbiAgcHVibGljIG5nT25Jbml0KCkge1xuICAgIC8qIGlzdGFuYnVsIGlnbm9yZSBlbHNlICovXG4gICAgLyogc2FuaXR5IGNoZWNrICovXG4gICAgaWYgKHRoaXMudGVtcGxhdGUgIT09IHVuZGVmaW5lZCkge1xuICAgICAgdGhpcy5jb250YWluZXIuY3JlYXRlRW1iZWRkZWRWaWV3KHRoaXMudGVtcGxhdGUsIHRoaXMpO1xuICAgIH1cbiAgfVxufVxuIl19

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

@@ -0,0 +1,45 @@
+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.
+ */
+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.2.7", ngImport: i0, type: SkyListFilterInlineItemComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+SkyListFilterInlineItemComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.7", 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.2.7", 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,71 @@
+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.
+ */
+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.2.7", 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.2.7", 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.2.7", 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,57 @@
+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.
+ */
+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.2.7", 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.2.7", 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.2.7", 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,41 @@
+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";
+export class SkyListFiltersModule {
+}
+SkyListFiltersModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyListFiltersModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SkyListFiltersModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.7", 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.2.7", ngImport: i0, type: SkyListFiltersModule, imports: [[CommonModule, SkyFilterModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", 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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