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

package/esm2020/index.mjs

@@ -0,0 +1,78 @@
+export * from './lib/modules/list/list-data-request.model';
+export * from './lib/modules/list/list-data-response.model';
+export * from './lib/modules/list/list-data.provider';
+export * from './lib/modules/list/list.module';
+export * from './lib/modules/list/state/list-state-action.type';
+export * from './lib/modules/list/state/list-state.model';
+export * from './lib/modules/list/state/list-state.rxstate';
+export * from './lib/modules/list/state/list-state.state-node';
+export * from './lib/modules/list/state/filters/filters.orchestrator';
+export * from './lib/modules/list/state/filters/update.action';
+export * from './lib/modules/list/state/items/items.orchestrator';
+export * from './lib/modules/list/state/items/load.action';
+export * from './lib/modules/list/state/items/set-items-selected.action';
+export * from './lib/modules/list/state/items/set-loading.action';
+export * from './lib/modules/list/state/paging/paging.model';
+export * from './lib/modules/list/state/paging/paging.orchestrator';
+export * from './lib/modules/list/state/paging/set-items-per-page.action';
+export * from './lib/modules/list/state/paging/set-max-pages.action';
+export * from './lib/modules/list/state/paging/set-page-number.action';
+export * from './lib/modules/list/state/search/search.model';
+export * from './lib/modules/list/state/search/search.orchestrator';
+export * from './lib/modules/list/state/search/set-field-selectors.action';
+export * from './lib/modules/list/state/search/set-functions.action';
+export * from './lib/modules/list/state/search/set-options.action';
+export * from './lib/modules/list/state/search/set-search-text.action';
+export * from './lib/modules/list/state/selected/load.action';
+export * from './lib/modules/list/state/selected/selected.model';
+export * from './lib/modules/list/state/selected/selected.orchestrator';
+export * from './lib/modules/list/state/selected/set-item-selected.action';
+export * from './lib/modules/list/state/selected/set-items-selected.action';
+export * from './lib/modules/list/state/selected/set-loading.action';
+export * from './lib/modules/list/state/sort/label.model';
+export * from './lib/modules/list/state/sort/set-available.action';
+export * from './lib/modules/list/state/sort/set-field-selectors.action';
+export * from './lib/modules/list/state/sort/set-global.action';
+export * from './lib/modules/list/state/sort/sort.model';
+export * from './lib/modules/list/state/sort/sort.orchestrator';
+export * from './lib/modules/list/state/toolbar/disable.action';
+export * from './lib/modules/list/state/toolbar/load.action';
+export * from './lib/modules/list/state/toolbar/remove.action';
+export * from './lib/modules/list/state/toolbar/set-exists.action';
+export * from './lib/modules/list/state/toolbar/set-type.action';
+export * from './lib/modules/list/state/toolbar/show-multiselect-toolbar.action';
+export * from './lib/modules/list/state/toolbar/toolbar-item.model';
+export * from './lib/modules/list/state/toolbar/toolbar.model';
+export * from './lib/modules/list/state/toolbar/toolbar.orchestrator';
+export * from './lib/modules/list/state/views/load.action';
+export * from './lib/modules/list/state/views/set-active.action';
+export * from './lib/modules/list/state/views/view.model';
+export * from './lib/modules/list/state/views/views.model';
+export * from './lib/modules/list/state/views/views.orchestrator';
+export * from './lib/modules/list-data-provider-in-memory/list-data-in-memory.provider';
+export * from './lib/modules/list-filters/filter.model';
+export * from './lib/modules/list-filters/list-filter-inline.model';
+export * from './lib/modules/list-filters/list-filters.module';
+export * from './lib/modules/list-paging/list-paging.module';
+export * from './lib/modules/list-toolbar/list-secondary-actions/list-secondary-action';
+export * from './lib/modules/list-toolbar/list-secondary-actions/list-secondary-actions.module';
+export * from './lib/modules/list-toolbar/list-toolbar.module';
+// The following exports are used internally by `@skyux/list-builder-view-grids`.
+export * from './lib/modules/list/list-view.component';
+export * from './lib/modules/list/list.component';
+export * from './lib/modules/list-toolbar/list-secondary-actions/list-secondary-actions.component';
+export * from './lib/modules/list-toolbar/list-toolbar.component';
+// Components and directives must be exported to support Angular's "partial" Ivy compiler.
+// Obscure names are used to indicate types are not part of the public API.
+export { SkyListFilterButtonComponent as λ1 } from './lib/modules/list-filters/list-filter-button.component';
+export { SkyListFilterSummaryComponent as λ2 } from './lib/modules/list-filters/list-filter-summary.component';
+export { SkyListFilterInlineItemComponent as λ3 } from './lib/modules/list-filters/list-filter-inline-item.component';
+export { SkyListFilterInlineComponent as λ4 } from './lib/modules/list-filters/list-filter-inline.component';
+export { SkyListPagingComponent as λ5 } from './lib/modules/list-paging/list-paging.component';
+export { SkyListSecondaryActionComponent as λ6 } from './lib/modules/list-toolbar/list-secondary-actions/list-secondary-action.component';
+export { SkyListSecondaryActionsComponent as λ7 } from './lib/modules/list-toolbar/list-secondary-actions/list-secondary-actions.component';
+export { SkyListToolbarItemComponent as λ8 } from './lib/modules/list-toolbar/list-toolbar-item.component';
+export { SkyListToolbarSortComponent as λ9 } from './lib/modules/list-toolbar/list-toolbar-sort.component';
+export { SkyListToolbarViewActionsComponent as λ10 } from './lib/modules/list-toolbar/list-toolbar-view-actions.component';
+export { SkyListToolbarSearchActionsComponent as λ11 } from './lib/modules/list-toolbar/list-toolbar-search-actions.component';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../libs/components/list-builder/src/index.ts"],"names":[],"mappings":"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","sourcesContent":["export * from './lib/modules/list/list-data-request.model';\nexport * from './lib/modules/list/list-data-response.model';\nexport * from './lib/modules/list/list-data.provider';\nexport * from './lib/modules/list/list.module';\n\nexport * from './lib/modules/list/state/list-state-action.type';\nexport * from './lib/modules/list/state/list-state.model';\nexport * from './lib/modules/list/state/list-state.rxstate';\nexport * from './lib/modules/list/state/list-state.state-node';\n\nexport * from './lib/modules/list/state/filters/filters.orchestrator';\nexport * from './lib/modules/list/state/filters/update.action';\n\nexport * from './lib/modules/list/state/items/items.orchestrator';\nexport * from './lib/modules/list/state/items/load.action';\nexport * from './lib/modules/list/state/items/set-items-selected.action';\nexport * from './lib/modules/list/state/items/set-loading.action';\n\nexport * from './lib/modules/list/state/paging/paging.model';\nexport * from './lib/modules/list/state/paging/paging.orchestrator';\nexport * from './lib/modules/list/state/paging/set-items-per-page.action';\nexport * from './lib/modules/list/state/paging/set-max-pages.action';\nexport * from './lib/modules/list/state/paging/set-page-number.action';\n\nexport * from './lib/modules/list/state/search/search.model';\nexport * from './lib/modules/list/state/search/search.orchestrator';\nexport * from './lib/modules/list/state/search/set-field-selectors.action';\nexport * from './lib/modules/list/state/search/set-functions.action';\nexport * from './lib/modules/list/state/search/set-options.action';\nexport * from './lib/modules/list/state/search/set-search-text.action';\n\nexport * from './lib/modules/list/state/selected/load.action';\nexport * from './lib/modules/list/state/selected/selected.model';\nexport * from './lib/modules/list/state/selected/selected.orchestrator';\nexport * from './lib/modules/list/state/selected/set-item-selected.action';\nexport * from './lib/modules/list/state/selected/set-items-selected.action';\nexport * from './lib/modules/list/state/selected/set-loading.action';\n\nexport * from './lib/modules/list/state/sort/label.model';\nexport * from './lib/modules/list/state/sort/set-available.action';\nexport * from './lib/modules/list/state/sort/set-field-selectors.action';\nexport * from './lib/modules/list/state/sort/set-global.action';\nexport * from './lib/modules/list/state/sort/sort.model';\nexport * from './lib/modules/list/state/sort/sort.orchestrator';\n\nexport * from './lib/modules/list/state/toolbar/disable.action';\nexport * from './lib/modules/list/state/toolbar/load.action';\nexport * from './lib/modules/list/state/toolbar/remove.action';\nexport * from './lib/modules/list/state/toolbar/set-exists.action';\nexport * from './lib/modules/list/state/toolbar/set-type.action';\nexport * from './lib/modules/list/state/toolbar/show-multiselect-toolbar.action';\nexport * from './lib/modules/list/state/toolbar/toolbar-item.model';\nexport * from './lib/modules/list/state/toolbar/toolbar.model';\nexport * from './lib/modules/list/state/toolbar/toolbar.orchestrator';\n\nexport * from './lib/modules/list/state/views/load.action';\nexport * from './lib/modules/list/state/views/set-active.action';\nexport * from './lib/modules/list/state/views/view.model';\nexport * from './lib/modules/list/state/views/views.model';\nexport * from './lib/modules/list/state/views/views.orchestrator';\n\nexport * from './lib/modules/list-data-provider-in-memory/list-data-in-memory.provider';\n\nexport * from './lib/modules/list-filters/filter.model';\nexport * from './lib/modules/list-filters/list-filter-inline.model';\nexport * from './lib/modules/list-filters/list-filters.module';\n\nexport * from './lib/modules/list-paging/list-paging.module';\n\nexport * from './lib/modules/list-toolbar/list-secondary-actions/list-secondary-action';\nexport * from './lib/modules/list-toolbar/list-secondary-actions/list-secondary-actions.module';\n\nexport * from './lib/modules/list-toolbar/list-toolbar.module';\n\n// The following exports are used internally by `@skyux/list-builder-view-grids`.\nexport * from './lib/modules/list/list-view.component';\nexport * from './lib/modules/list/list.component';\nexport * from './lib/modules/list-toolbar/list-secondary-actions/list-secondary-actions.component';\nexport * from './lib/modules/list-toolbar/list-toolbar.component';\n\n// Components and directives must be exported to support Angular's \"partial\" Ivy compiler.\n// Obscure names are used to indicate types are not part of the public API.\nexport { SkyListFilterButtonComponent as λ1 } from './lib/modules/list-filters/list-filter-button.component';\nexport { SkyListFilterSummaryComponent as λ2 } from './lib/modules/list-filters/list-filter-summary.component';\nexport { SkyListFilterInlineItemComponent as λ3 } from './lib/modules/list-filters/list-filter-inline-item.component';\nexport { SkyListFilterInlineComponent as λ4 } from './lib/modules/list-filters/list-filter-inline.component';\nexport { SkyListPagingComponent as λ5 } from './lib/modules/list-paging/list-paging.component';\nexport { SkyListSecondaryActionComponent as λ6 } from './lib/modules/list-toolbar/list-secondary-actions/list-secondary-action.component';\nexport { SkyListSecondaryActionsComponent as λ7 } from './lib/modules/list-toolbar/list-secondary-actions/list-secondary-actions.component';\nexport { SkyListToolbarItemComponent as λ8 } from './lib/modules/list-toolbar/list-toolbar-item.component';\nexport { SkyListToolbarSortComponent as λ9 } from './lib/modules/list-toolbar/list-toolbar-sort.component';\nexport { SkyListToolbarViewActionsComponent as λ10 } from './lib/modules/list-toolbar/list-toolbar-view-actions.component';\nexport { SkyListToolbarSearchActionsComponent as λ11 } from './lib/modules/list-toolbar/list-toolbar-search-actions.component';\n"]}

package/esm2020/lib/modules/list/list-data-request.model.mjs

@@ -0,0 +1,21 @@
+/**
+ * @deprecated
+ */
+export class ListDataRequestModel {
+    constructor(data) {
+        /**
+         * Indicates whether to disable the search bar and filter button.
+         * @default false
+         */
+        this.isToolbarDisabled = false;
+        if (data !== undefined) {
+            this.filters = data.filters;
+            this.pageSize = data.pageSize;
+            this.pageNumber = data.pageNumber;
+            this.search = data.search;
+            this.sort = data.sort;
+            this.isToolbarDisabled = data.isToolbarDisabled;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/list/list-data-response.model.mjs

@@ -0,0 +1,12 @@
+/**
+ * @deprecated
+ */
+export class ListDataResponseModel {
+    constructor(data) {
+        if (data !== undefined) {
+            this.count = data.count;
+            this.items = data.items;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlzdC1kYXRhLXJlc3BvbnNlLm1vZGVsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21wb25lbnRzL2xpc3QtYnVpbGRlci9zcmMvbGliL21vZHVsZXMvbGlzdC9saXN0LWRhdGEtcmVzcG9uc2UubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7O0dBRUc7QUFDSCxNQUFNLE9BQU8scUJBQXFCO0lBV2hDLFlBQVksSUFBVTtRQUNwQixJQUFJLElBQUksS0FBSyxTQUFTLEVBQUU7WUFDdEIsSUFBSSxDQUFDLEtBQUssR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDO1lBQ3hCLElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQztTQUN6QjtJQUNILENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IExpc3RJdGVtTW9kZWwgfSBmcm9tICdAc2t5dXgvbGlzdC1idWlsZGVyLWNvbW1vbic7XG5cbi8qKlxuICogQGRlcHJlY2F0ZWRcbiAqL1xuZXhwb3J0IGNsYXNzIExpc3REYXRhUmVzcG9uc2VNb2RlbCB7XG4gIC8qKlxuICAgKiBUaGUgdG90YWwgbnVtYmVyIG9mIHJlY29yZHMgaW4gdGhlIGxpc3QuXG4gICAqL1xuICBwdWJsaWMgY291bnQ6IG51bWJlcjtcbiAgLyoqXG4gICAqIEFuIGFycmF5IG9mIHRoZSBpdGVtcyByZXR1cm5lZC4gRm9yIGluZm9ybWF0aW9uIGFib3V0IGBMaXN0SXRlbU1vZGVsYCwgc2VlIHRoZVxuICAgKiBbc2hhcmVkIGNsYXNzZXMgZm9yIGxpc3RzXShodHRwczovL2RldmVsb3Blci5ibGFja2JhdWQuY29tL3NreXV4LWxpc3QtYnVpbGRlci1jb21tb24vZG9jcy9saXN0LWJ1aWxkZXItY29tbW9uKS5cbiAgICovXG4gIHB1YmxpYyBpdGVtczogTGlzdEl0ZW1Nb2RlbFtdO1xuXG4gIGNvbnN0cnVjdG9yKGRhdGE/OiBhbnkpIHtcbiAgICBpZiAoZGF0YSAhPT0gdW5kZWZpbmVkKSB7XG4gICAgICB0aGlzLmNvdW50ID0gZGF0YS5jb3VudDtcbiAgICAgIHRoaXMuaXRlbXMgPSBkYXRhLml0ZW1zO1xuICAgIH1cbiAgfVxufVxuIl19

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

@@ -0,0 +1,10 @@
+/**
+ * @internal
+ * @deprecated
+ */
+export class ListDataProvider {
+    constructor(data) {
+        this.data = data;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlzdC1kYXRhLnByb3ZpZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21wb25lbnRzL2xpc3QtYnVpbGRlci9zcmMvbGliL21vZHVsZXMvbGlzdC9saXN0LWRhdGEucHJvdmlkZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBS0E7OztHQUdHO0FBQ0gsTUFBTSxPQUFnQixnQkFBZ0I7SUFDcEMsWUFBbUIsSUFBd0I7UUFBeEIsU0FBSSxHQUFKLElBQUksQ0FBb0I7SUFBRyxDQUFDO0NBT2hEIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuXG5pbXBvcnQgeyBMaXN0RGF0YVJlcXVlc3RNb2RlbCB9IGZyb20gJy4vbGlzdC1kYXRhLXJlcXVlc3QubW9kZWwnO1xuaW1wb3J0IHsgTGlzdERhdGFSZXNwb25zZU1vZGVsIH0gZnJvbSAnLi9saXN0LWRhdGEtcmVzcG9uc2UubW9kZWwnO1xuXG4vKipcbiAqIEBpbnRlcm5hbFxuICogQGRlcHJlY2F0ZWRcbiAqL1xuZXhwb3J0IGFic3RyYWN0IGNsYXNzIExpc3REYXRhUHJvdmlkZXIge1xuICBjb25zdHJ1Y3RvcihwdWJsaWMgZGF0YT86IE9ic2VydmFibGU8YW55W10+KSB7fVxuXG4gIHB1YmxpYyBhYnN0cmFjdCBnZXQoXG4gICAgcmVxdWVzdDogTGlzdERhdGFSZXF1ZXN0TW9kZWxcbiAgKTogT2JzZXJ2YWJsZTxMaXN0RGF0YVJlc3BvbnNlTW9kZWw+O1xuXG4gIHB1YmxpYyBhYnN0cmFjdCBjb3VudCgpOiBPYnNlcnZhYmxlPG51bWJlcj47XG59XG4iXX0=

package/esm2020/lib/modules/list/list-paging.component.mjs

@@ -0,0 +1,14 @@
+import { BehaviorSubject } from 'rxjs';
+/**
+ * Provides a SKY UX-themed pagination control to display list data across multiple pages.
+ * @internal
+ * @deprecated
+ */
+export class ListPagingComponent {
+    constructor(state, dispatcher) {
+        this.initialized = new BehaviorSubject(false);
+        this.state = state;
+        this.dispatcher = dispatcher;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlzdC1wYWdpbmcuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21wb25lbnRzL2xpc3QtYnVpbGRlci9zcmMvbGliL21vZHVsZXMvbGlzdC9saXN0LXBhZ2luZy5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUt2Qzs7OztHQUlHO0FBQ0gsTUFBTSxPQUFnQixtQkFBbUI7SUFLdkMsWUFBWSxLQUFnQixFQUFFLFVBQStCO1FBSm5ELGdCQUFXLEdBQTZCLElBQUksZUFBZSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBSzNFLElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO1FBQ25CLElBQUksQ0FBQyxVQUFVLEdBQUcsVUFBVSxDQUFDO0lBQy9CLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJlaGF2aW9yU3ViamVjdCB9IGZyb20gJ3J4anMnO1xuXG5pbXBvcnQgeyBMaXN0U3RhdGVEaXNwYXRjaGVyIH0gZnJvbSAnLi9zdGF0ZS9saXN0LXN0YXRlLnJ4c3RhdGUnO1xuaW1wb3J0IHsgTGlzdFN0YXRlIH0gZnJvbSAnLi9zdGF0ZS9saXN0LXN0YXRlLnN0YXRlLW5vZGUnO1xuXG4vKipcbiAqIFByb3ZpZGVzIGEgU0tZIFVYLXRoZW1lZCBwYWdpbmF0aW9uIGNvbnRyb2wgdG8gZGlzcGxheSBsaXN0IGRhdGEgYWNyb3NzIG11bHRpcGxlIHBhZ2VzLlxuICogQGludGVybmFsXG4gKiBAZGVwcmVjYXRlZFxuICovXG5leHBvcnQgYWJzdHJhY3QgY2xhc3MgTGlzdFBhZ2luZ0NvbXBvbmVudCB7XG4gIHByb3RlY3RlZCBpbml0aWFsaXplZDogQmVoYXZpb3JTdWJqZWN0PGJvb2xlYW4+ID0gbmV3IEJlaGF2aW9yU3ViamVjdChmYWxzZSk7XG4gIHByb3RlY3RlZCBzdGF0ZTogTGlzdFN0YXRlO1xuICBwcm90ZWN0ZWQgZGlzcGF0Y2hlcjogTGlzdFN0YXRlRGlzcGF0Y2hlcjtcblxuICBjb25zdHJ1Y3RvcihzdGF0ZTogTGlzdFN0YXRlLCBkaXNwYXRjaGVyOiBMaXN0U3RhdGVEaXNwYXRjaGVyKSB7XG4gICAgdGhpcy5zdGF0ZSA9IHN0YXRlO1xuICAgIHRoaXMuZGlzcGF0Y2hlciA9IGRpc3BhdGNoZXI7XG4gIH1cbn1cbiJdfQ==

package/esm2020/lib/modules/list/list-view.component.mjs

@@ -0,0 +1,30 @@
+import { distinctUntilChanged, map as observableMap } from 'rxjs/operators';
+let idIndex = 0;
+/**
+ * @internal
+ * @deprecated
+ */
+export class ListViewComponent {
+    constructor(state, defaultName) {
+        this.viewId = `sky-list-view-cmp-${++idIndex}`;
+        this.state = state;
+        this.viewName = defaultName;
+        /* istanbul ignore next */
+        this.hasToolbar = this.state.pipe(observableMap((s) => s.toolbar.exists));
+        this.active = this.state.pipe(observableMap((s) => s.views.active === this.viewId));
+        this.active
+            .pipe(distinctUntilChanged())
+            .subscribe((isActive) => isActive ? this.onViewActive() : this.onViewInactive());
+    }
+    get id() {
+        return this.viewId;
+    }
+    get label() {
+        return this.viewName;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    onViewActive() { }
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    onViewInactive() { }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/modules/list/list.component.mjs

@@ -0,0 +1,315 @@
+import { ChangeDetectionStrategy, Component, ContentChildren, EventEmitter, Input, Output, QueryList, } from '@angular/core';
+import { SkyLogService } from '@skyux/core';
+import { getValue } from '@skyux/list-builder-common';
+import { ListItemModel, isObservable, } from '@skyux/list-builder-common';
+import { Subject, combineLatest as observableCombineLatest, of as observableOf, } from 'rxjs';
+import { distinctUntilChanged, flatMap, map as observableMap, skip, take, takeUntil, } from 'rxjs/operators';
+import { SkyListInMemoryDataProvider } from '../list-data-provider-in-memory/list-data-in-memory.provider';
+import { ListDataRequestModel } from './list-data-request.model';
+import { ListDataResponseModel } from './list-data-response.model';
+import { ListDataProvider } from './list-data.provider';
+import { ListViewComponent } from './list-view.component';
+import { ListItemsLoadAction } from './state/items/load.action';
+import { ListItemsSetLoadingAction } from './state/items/set-loading.action';
+import { ListStateDispatcher } from './state/list-state.rxstate';
+import { ListState } from './state/list-state.state-node';
+import { ListPagingSetPageNumberAction } from './state/paging/set-page-number.action';
+import { ListSelectedLoadAction } from './state/selected/load.action';
+import { ListSelectedSetLoadingAction } from './state/selected/set-loading.action';
+import { ListSortSetFieldSelectorsAction } from './state/sort/set-field-selectors.action';
+import { ListSortModel } from './state/sort/sort.model';
+import { ListViewsLoadAction } from './state/views/load.action';
+import { ListViewsSetActiveAction } from './state/views/set-active.action';
+import { ListViewModel } from './state/views/view.model';
+import * as i0 from "@angular/core";
+import * as i1 from "./state/list-state.state-node";
+import * as i2 from "./state/list-state.rxstate";
+import * as i3 from "@skyux/core";
+let idIndex = 0;
+/**
+ * @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 SkyListComponent {
+    constructor(state, dispatcher, logger) {
+        this.state = state;
+        this.dispatcher = dispatcher;
+        this.id = `sky-list-cmp-${++idIndex}`;
+        /**
+         * Specifies the data to display. The list component requires this property or the
+         * `dataProvider` property. For checklist or multiselect grids, each row requires an
+         * `id` property to manage selected items with the `selectedIds` input and the
+         * `selectedIdsChange` event. If you do not provide an `id`, the list automatically
+         * generates one. To update data in your view outside of a `dataProvider`, you must use
+         * an observable instead of a static array.
+         */
+        this.data = [];
+        /**
+         * Specifies a set of filters to apply to list data.
+         * These filters create a filter summary when the list includes the
+         * [`sky-list-filter-summary`](https://developer.blackbaud.com/skyux/components/list/filters)
+         * component.
+         */
+        this.appliedFilters = [];
+        /**
+         * For list views that support item selection, emits the selected entries.
+         */
+        this.selectedIdsChange = new EventEmitter();
+        /**
+         * Emits the filters applied to the list.
+         */
+        this.appliedFiltersChange = new EventEmitter();
+        this.dataFirstLoad = false;
+        this.lastSelectedIds = [];
+        this.lastFilters = [];
+        this.ngUnsubscribe = new Subject();
+        logger.deprecated('SkyListComponent', {
+            deprecationMajorVersion: 6,
+            moreInfoUrl: 'https://developer.blackbaud.com/skyux/components/data-manager',
+            replacementRecommendation: 'Use data manager instead.',
+        });
+    }
+    ngAfterContentInit() {
+        if (this.data && this.dataProvider && this.initialTotal) {
+            this.dataFirstLoad = true;
+        }
+        if (this.listViews.length > 0) {
+            const defaultView = this.defaultView === undefined
+                ? this.listViews.first
+                : this.defaultView;
+            this.dispatcher.next(new ListViewsLoadAction(this.listViews.map((v) => new ListViewModel(v.id, v.label))));
+            // activate the default view
+            this.dispatcher.next(new ListViewsSetActiveAction(defaultView.id));
+        }
+        else {
+            return;
+        }
+        // set sort fields
+        getValue(this.sortFields, (sortFields) => {
+            let sortArray;
+            if (!Array.isArray(sortFields) && sortFields) {
+                sortArray = [sortFields];
+            }
+            else {
+                sortArray = sortFields;
+            }
+            this.dispatcher.next(new ListSortSetFieldSelectorsAction(sortArray || []));
+        });
+        this.displayedItems.subscribe((result) => {
+            this.dispatcher.next(new ListItemsSetLoadingAction());
+            this.dispatcher.next(new ListItemsLoadAction(result.items, true, true, result.count));
+        });
+        // Watch for selection changes.
+        this.state
+            .pipe(observableMap((current) => current.selected), takeUntil(this.ngUnsubscribe), distinctUntilChanged())
+            .subscribe((selected) => {
+            // Update lastSelectedIds to help us retain user selections.
+            const selectedIdsList = [];
+            selected.item.selectedIdMap.forEach((value, key) => {
+                if (value === true) {
+                    selectedIdsList.push(key);
+                }
+            });
+            // If changes are distinct, emit selectedIdsChange.
+            const distinctChanges = !this.arraysEqual(this.lastSelectedIds, selectedIdsList);
+            if (this.selectedIdsChange.observers.length > 0 && distinctChanges) {
+                this.selectedIdsChange.emit(selected.item.selectedIdMap);
+            }
+            this.lastSelectedIds = selectedIdsList;
+        });
+        if (this.appliedFiltersChange.observers.length > 0) {
+            this.state
+                .pipe(observableMap((current) => current.filters), takeUntil(this.ngUnsubscribe), skip(1))
+                .subscribe((filters) => {
+                /**
+                 * We are doing this instead of a distinctUntilChange due to memory allocation issues
+                 * with the javascript array. To fix fully the array should be changed to an object in
+                 * a breaking change.
+                 */
+                if (!this.arraysEqual(filters, this.lastFilters)) {
+                    this.lastFilters = filters.slice(0);
+                    this.appliedFiltersChange.emit(filters);
+                }
+            });
+        }
+    }
+    ngOnChanges(changes) {
+        if (changes['appliedFilters'] &&
+            changes['appliedFilters'].currentValue !==
+                changes['appliedFilters'].previousValue) {
+            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.appliedFilters);
+            });
+        }
+        if (changes['selectedIds']) {
+            // Only send selection changes to dispatcher if changes are distinct.
+            const newSelectedIds = changes['selectedIds'].currentValue;
+            if (!this.arraysEqual(newSelectedIds, this.lastSelectedIds)) {
+                this.dispatcher.setSelected(newSelectedIds, true, true);
+            }
+        }
+    }
+    ngOnDestroy() {
+        this.ngUnsubscribe.next();
+        this.ngUnsubscribe.complete();
+    }
+    refreshDisplayedItems() {
+        this.displayedItems.pipe(take(1)).subscribe((result) => {
+            this.dispatcher.next(new ListItemsSetLoadingAction());
+            this.dispatcher.next(new ListItemsLoadAction(result.items, true, true, result.count));
+        });
+    }
+    get displayedItems() {
+        if (!this.data && !this.dataProvider) {
+            throw new Error('List requires data or dataProvider to be set.');
+        }
+        let data = this.data;
+        if (!isObservable(data)) {
+            data = observableOf(this.data);
+        }
+        if (!this.dataProvider) {
+            this.dataProvider = new SkyListInMemoryDataProvider(data, this.searchFunction);
+        }
+        let selectedIds = this.selectedIds || observableOf([]);
+        if (!isObservable(selectedIds)) {
+            selectedIds = observableOf(selectedIds);
+        }
+        let selectedChanged = false;
+        // This subject is used to cancel previous request to the list's data provider when a new change
+        // to the list's state occurs. In a future breaking change this should be replaced or coupled
+        // with adding a debounce time to the Observable which watches for state changes.
+        const cancelLastRequest = new Subject();
+        return observableCombineLatest([
+            this.state.pipe(observableMap((s) => s.filters), distinctUntilChanged()),
+            this.state.pipe(observableMap((s) => s.search), distinctUntilChanged()),
+            this.state.pipe(observableMap((s) => s.sort.fieldSelectors), distinctUntilChanged()),
+            this.state.pipe(observableMap((s) => s.paging.itemsPerPage), distinctUntilChanged()),
+            this.state.pipe(observableMap((s) => s.paging.pageNumber), distinctUntilChanged()),
+            this.state.pipe(observableMap((s) => s.toolbar.disabled), distinctUntilChanged()),
+            selectedIds.pipe(distinctUntilChanged(), observableMap((selected) => {
+                selectedChanged = true;
+                return selected;
+            })),
+            data.pipe(distinctUntilChanged()),
+        ], (filters, search, sortFieldSelectors, itemsPerPage, pageNumber, isToolbarDisabled, selected, itemsData) => {
+            cancelLastRequest.next();
+            cancelLastRequest.complete();
+            if (selectedChanged) {
+                this.dispatcher.next(new ListSelectedSetLoadingAction());
+                this.dispatcher.next(new ListSelectedLoadAction(selected));
+                this.dispatcher.next(new ListSelectedSetLoadingAction(false));
+                selectedChanged = false;
+            }
+            let response;
+            if (this.dataFirstLoad) {
+                this.dataFirstLoad = false;
+                const initialItems = itemsData.map((d) => new ListItemModel(d.id || `sky-list-item-model-${++idIndex}`, d));
+                response = observableOf(new ListDataResponseModel({
+                    count: this.initialTotal,
+                    items: initialItems,
+                })).pipe(takeUntil(cancelLastRequest));
+            }
+            else {
+                response = this.dataProvider
+                    .get(new ListDataRequestModel({
+                    filters: filters,
+                    pageSize: itemsPerPage,
+                    pageNumber: pageNumber,
+                    search: search,
+                    sort: new ListSortModel({ fieldSelectors: sortFieldSelectors }),
+                    isToolbarDisabled: isToolbarDisabled,
+                }))
+                    .pipe(takeUntil(cancelLastRequest));
+            }
+            return response;
+        }).pipe(takeUntil(this.ngUnsubscribe), 
+        // Retain user selections from previous state.
+        // This is only necessary for grids component (based on item.isSelected).
+        observableMap((response) => {
+            return response.pipe(observableMap((listDataResponseModel) => {
+                return new ListDataResponseModel({
+                    count: listDataResponseModel.count,
+                    items: this.getItemsAndRetainSelections(listDataResponseModel.items, this.lastSelectedIds),
+                });
+            }));
+        }), flatMap((value) => value));
+    }
+    get selectedItems() {
+        return observableCombineLatest(this.state.pipe(observableMap((current) => current.items.items), distinctUntilChanged()), this.state.pipe(observableMap((current) => current.selected), distinctUntilChanged()), (items, selected) => {
+            return items.filter((i) => selected.item.selectedIdMap.get(i.id));
+        }).pipe(takeUntil(this.ngUnsubscribe));
+    }
+    get lastUpdate() {
+        return this.state.pipe(takeUntil(this.ngUnsubscribe), observableMap((s) => s.items.lastUpdate ? new Date(s.items.lastUpdate) : undefined));
+    }
+    get views() {
+        return this.listViews.toArray();
+    }
+    get itemCount() {
+        return this.dataProvider.count();
+    }
+    getItemsAndRetainSelections(newList, selectedIds) {
+        const updatedListModel = newList.slice();
+        updatedListModel.forEach((item) => {
+            item.isSelected = selectedIds.indexOf(item.id) > -1 ? true : false;
+        });
+        return updatedListModel;
+    }
+    arraysEqual(arrayA, arrayB) {
+        /* istanbul ignore next */
+        if (arrayA === arrayB) {
+            return true;
+        }
+        if (arrayA === undefined || arrayB === undefined) {
+            return false;
+        }
+        if (arrayA.length !== arrayB.length) {
+            return false;
+        }
+        for (let i = 0; i < arrayA.length; ++i) {
+            if (arrayA[i] !== arrayB[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+SkyListComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyListComponent, deps: [{ token: i1.ListState }, { token: i2.ListStateDispatcher }, { token: i3.SkyLogService }], target: i0.ɵɵFactoryTarget.Component });
+SkyListComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.2", type: SkyListComponent, selector: "sky-list", inputs: { data: "data", dataProvider: "dataProvider", defaultView: "defaultView", initialTotal: "initialTotal", selectedIds: "selectedIds", sortFields: "sortFields", appliedFilters: "appliedFilters", searchFunction: ["search", "searchFunction"] }, outputs: { selectedIdsChange: "selectedIdsChange", appliedFiltersChange: "appliedFiltersChange" }, providers: [ListState, ListStateDispatcher], queries: [{ propertyName: "listViews", predicate: ListViewComponent }], usesOnChanges: true, ngImport: i0, template: '<ng-content></ng-content>', isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.2", ngImport: i0, type: SkyListComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'sky-list',
+                    template: '<ng-content></ng-content>',
+                    providers: [ListState, ListStateDispatcher],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ListState }, { type: i2.ListStateDispatcher }, { type: i3.SkyLogService }]; }, propDecorators: { data: [{
+                type: Input
+            }], dataProvider: [{
+                type: Input
+            }], defaultView: [{
+                type: Input
+            }], initialTotal: [{
+                type: Input
+            }], selectedIds: [{
+                type: Input
+            }], sortFields: [{
+                type: Input
+            }], appliedFilters: [{
+                type: Input
+            }], selectedIdsChange: [{
+                type: Output
+            }], appliedFiltersChange: [{
+                type: Output
+            }], searchFunction: [{
+                type: Input,
+                args: ['search']
+            }], listViews: [{
+                type: ContentChildren,
+                args: [ListViewComponent]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list.component.js","sourceRoot":"","sources":["../../../../../../../../libs/components/list-builder/src/lib/modules/list/list.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterContentInit,\n  ChangeDetectionStrategy,\n  Component,\n  ContentChildren,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Output,\n  QueryList,\n  SimpleChanges,\n} from '@angular/core';\nimport { SkyLogService } from '@skyux/core';\nimport { AsyncItem, getValue } from '@skyux/list-builder-common';\nimport {\n  ListItemModel,\n  ListSortFieldSelectorModel,\n  isObservable,\n} from '@skyux/list-builder-common';\n\nimport {\n  Observable,\n  Subject,\n  combineLatest as observableCombineLatest,\n  of as observableOf,\n} from 'rxjs';\nimport {\n  distinctUntilChanged,\n  flatMap,\n  map as observableMap,\n  skip,\n  take,\n  takeUntil,\n} from 'rxjs/operators';\n\nimport { SkyListInMemoryDataProvider } from '../list-data-provider-in-memory/list-data-in-memory.provider';\nimport { ListFilterModel } from '../list-filters/filter.model';\n\nimport { ListDataRequestModel } from './list-data-request.model';\nimport { ListDataResponseModel } from './list-data-response.model';\nimport { ListDataProvider } from './list-data.provider';\nimport { ListViewComponent } from './list-view.component';\nimport { ListItemsLoadAction } from './state/items/load.action';\nimport { ListItemsSetLoadingAction } from './state/items/set-loading.action';\nimport { ListStateDispatcher } from './state/list-state.rxstate';\nimport { ListState } from './state/list-state.state-node';\nimport { ListPagingSetPageNumberAction } from './state/paging/set-page-number.action';\nimport { ListSearchModel } from './state/search/search.model';\nimport { ListSelectedLoadAction } from './state/selected/load.action';\nimport { ListSelectedModel } from './state/selected/selected.model';\nimport { ListSelectedSetLoadingAction } from './state/selected/set-loading.action';\nimport { ListSortSetFieldSelectorsAction } from './state/sort/set-field-selectors.action';\nimport { ListSortModel } from './state/sort/sort.model';\nimport { ListViewsLoadAction } from './state/views/load.action';\nimport { ListViewsSetActiveAction } from './state/views/set-active.action';\nimport { ListViewModel } from './state/views/view.model';\n\nlet idIndex = 0;\n\n/**\n * @deprecated List builder and its features are deprecated. Use data manager instead. For more information, see https://developer.blackbaud.com/skyux/components/data-manager.\n */\n@Component({\n  selector: 'sky-list',\n  template: '<ng-content></ng-content>',\n  providers: [ListState, ListStateDispatcher],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class SkyListComponent\n  implements AfterContentInit, OnChanges, OnDestroy\n{\n  public id = `sky-list-cmp-${++idIndex}`;\n  /**\n   * Specifies the data to display. The list component requires this property or the\n   * `dataProvider` property. For checklist or multiselect grids, each row requires an\n   * `id` property to manage selected items with the `selectedIds` input and the\n   * `selectedIdsChange` event. If you do not provide an `id`, the list automatically\n   * generates one. To update data in your view outside of a `dataProvider`, you must use\n   * an observable instead of a static array.\n   */\n  @Input()\n  public data?: Array<any> | Observable<Array<any>> = [];\n\n  /**\n   * Specifies a data provider to obtain the data to display. The list component requires\n   * this property or the `data` property. For lists that use `dataProvider` instead of `data`,\n   * consumers are responsible for managing all `ListDataRequestModel` properties.\n   * @default SkyListInMemoryDataProvider\n   */\n  @Input()\n  public dataProvider?: ListDataProvider;\n\n  /**\n   * @internal\n   */\n  @Input()\n  public defaultView?: ListViewComponent;\n\n  /**\n   * Specifies the total number of items for the initial data set when initialized. When\n   * used in conjunction with `data` and `dataProvider`, it allows an initial data to be\n   * set with the need to call the `dataProvider`.\n   */\n  @Input()\n  public initialTotal?: number;\n\n  /**\n   * Specifies a set of IDs for the items to select in a checklist or multiselect grid.\n   * The IDs match the `id` properties of the `data` objects. Items with IDs that are not\n   * included are de-selected in the checklist or multiselect grid.\n   */\n  @Input()\n  public selectedIds?: Array<string> | Observable<Array<string>>;\n\n  /**\n   * Specifies a set of fields to sort by. If array of fields then sorted by order of array.\n   * For information about `ListSortFieldSelectorModel`, see the\n   * [shared classes for lists](https://developer.blackbaud.com/skyux-list-builder-common/docs/list-builder-common).\n   */\n  @Input()\n  public sortFields?:\n    | ListSortFieldSelectorModel\n    | Array<ListSortFieldSelectorModel>\n    | Observable<Array<ListSortFieldSelectorModel>>\n    | Observable<ListSortFieldSelectorModel>;\n\n  /**\n   * Specifies a set of filters to apply to list data.\n   * These filters create a filter summary when the list includes the\n   * [`sky-list-filter-summary`](https://developer.blackbaud.com/skyux/components/list/filters)\n   * component.\n   */\n  @Input()\n  public appliedFilters: Array<ListFilterModel> = [];\n\n  /**\n   * For list views that support item selection, emits the selected entries.\n   */\n  @Output()\n  public selectedIdsChange = new EventEmitter<Map<string, boolean>>();\n\n  /**\n   * Emits the filters applied to the list.\n   */\n  @Output()\n  public appliedFiltersChange = new EventEmitter<Array<ListFilterModel>>();\n\n  /**\n   * Specifies a function to apply as a global sort on the list.\n   */\n  // eslint-disable-next-line @angular-eslint/no-input-rename\n  @Input('search')\n  public searchFunction: (data: any, searchText: string) => boolean;\n\n  private dataFirstLoad = false;\n\n  @ContentChildren(ListViewComponent)\n  private listViews: QueryList<ListViewComponent>;\n\n  private lastSelectedIds: string[] = [];\n\n  private lastFilters: ListFilterModel[] = [];\n\n  private ngUnsubscribe = new Subject<void>();\n\n  constructor(\n    private state: ListState,\n    private dispatcher: ListStateDispatcher,\n    logger: SkyLogService\n  ) {\n    logger.deprecated('SkyListComponent', {\n      deprecationMajorVersion: 6,\n      moreInfoUrl:\n        'https://developer.blackbaud.com/skyux/components/data-manager',\n      replacementRecommendation: 'Use data manager instead.',\n    });\n  }\n\n  public ngAfterContentInit(): void {\n    if (this.data && this.dataProvider && this.initialTotal) {\n      this.dataFirstLoad = true;\n    }\n\n    if (this.listViews.length > 0) {\n      const defaultView: ListViewComponent =\n        this.defaultView === undefined\n          ? this.listViews.first\n          : this.defaultView;\n\n      this.dispatcher.next(\n        new ListViewsLoadAction(\n          this.listViews.map((v) => new ListViewModel(v.id, v.label))\n        )\n      );\n\n      // activate the default view\n      this.dispatcher.next(new ListViewsSetActiveAction(defaultView.id));\n    } else {\n      return;\n    }\n\n    // set sort fields\n    getValue(\n      this.sortFields,\n      (\n        sortFields: ListSortFieldSelectorModel[] | ListSortFieldSelectorModel\n      ) => {\n        let sortArray: ListSortFieldSelectorModel[];\n        if (!Array.isArray(sortFields) && sortFields) {\n          sortArray = [sortFields];\n        } else {\n          sortArray = sortFields as ListSortFieldSelectorModel[];\n        }\n        this.dispatcher.next(\n          new ListSortSetFieldSelectorsAction(sortArray || [])\n        );\n      }\n    );\n\n    this.displayedItems.subscribe((result) => {\n      this.dispatcher.next(new ListItemsSetLoadingAction());\n      this.dispatcher.next(\n        new ListItemsLoadAction(result.items, true, true, result.count)\n      );\n    });\n\n    // Watch for selection changes.\n    this.state\n      .pipe(\n        observableMap((current) => current.selected),\n        takeUntil(this.ngUnsubscribe),\n        distinctUntilChanged()\n      )\n      .subscribe((selected) => {\n        // Update lastSelectedIds to help us retain user selections.\n        const selectedIdsList: string[] = [];\n        selected.item.selectedIdMap.forEach((value, key) => {\n          if (value === true) {\n            selectedIdsList.push(key);\n          }\n        });\n\n        // If changes are distinct, emit selectedIdsChange.\n        const distinctChanges = !this.arraysEqual(\n          this.lastSelectedIds,\n          selectedIdsList\n        );\n        if (this.selectedIdsChange.observers.length > 0 && distinctChanges) {\n          this.selectedIdsChange.emit(selected.item.selectedIdMap);\n        }\n\n        this.lastSelectedIds = selectedIdsList;\n      });\n\n    if (this.appliedFiltersChange.observers.length > 0) {\n      this.state\n        .pipe(\n          observableMap((current) => current.filters),\n          takeUntil(this.ngUnsubscribe),\n          skip(1)\n        )\n        .subscribe((filters) => {\n          /**\n           * We are doing this instead of a distinctUntilChange due to memory allocation issues\n           * with the javascript array. To fix fully the array should be changed to an object in\n           * a breaking change.\n           */\n          if (!this.arraysEqual(filters, this.lastFilters)) {\n            this.lastFilters = filters.slice(0);\n            this.appliedFiltersChange.emit(filters);\n          }\n        });\n    }\n  }\n\n  public ngOnChanges(changes: SimpleChanges): void {\n    if (\n      changes['appliedFilters'] &&\n      changes['appliedFilters'].currentValue !==\n        changes['appliedFilters'].previousValue\n    ) {\n      this.state.pipe(take(1)).subscribe((currentState) => {\n        if (\n          currentState.paging.pageNumber &&\n          currentState.paging.pageNumber !== 1\n        ) {\n          this.dispatcher.next(new ListPagingSetPageNumberAction(Number(1)));\n        }\n\n        this.dispatcher.filtersUpdate(this.appliedFilters);\n      });\n    }\n    if (changes['selectedIds']) {\n      // Only send selection changes to dispatcher if changes are distinct.\n      const newSelectedIds = changes['selectedIds'].currentValue;\n      if (!this.arraysEqual(newSelectedIds, this.lastSelectedIds)) {\n        this.dispatcher.setSelected(newSelectedIds, true, true);\n      }\n    }\n  }\n\n  public ngOnDestroy(): void {\n    this.ngUnsubscribe.next();\n    this.ngUnsubscribe.complete();\n  }\n\n  public refreshDisplayedItems(): void {\n    this.displayedItems.pipe(take(1)).subscribe((result) => {\n      this.dispatcher.next(new ListItemsSetLoadingAction());\n      this.dispatcher.next(\n        new ListItemsLoadAction(result.items, true, true, result.count)\n      );\n    });\n  }\n\n  get displayedItems(): Observable<ListDataResponseModel> {\n    if (!this.data && !this.dataProvider) {\n      throw new Error('List requires data or dataProvider to be set.');\n    }\n\n    let data: any = this.data;\n    if (!isObservable(data)) {\n      data = observableOf(this.data);\n    }\n\n    if (!this.dataProvider) {\n      this.dataProvider = new SkyListInMemoryDataProvider(\n        data,\n        this.searchFunction\n      );\n    }\n\n    let selectedIds = this.selectedIds || observableOf([]);\n    if (!isObservable(selectedIds)) {\n      selectedIds = observableOf(selectedIds);\n    }\n\n    let selectedChanged = false;\n\n    // This subject is used to cancel previous request to the list's data provider when a new change\n    // to the list's state occurs. In a future breaking change this should be replaced or coupled\n    // with adding a debounce time to the Observable which watches for state changes.\n    const cancelLastRequest = new Subject<void>();\n\n    return observableCombineLatest(\n      [\n        this.state.pipe(\n          observableMap((s) => s.filters),\n          distinctUntilChanged()\n        ),\n        this.state.pipe(\n          observableMap((s) => s.search),\n          distinctUntilChanged()\n        ),\n        this.state.pipe(\n          observableMap((s) => s.sort.fieldSelectors),\n          distinctUntilChanged()\n        ),\n        this.state.pipe(\n          observableMap((s) => s.paging.itemsPerPage),\n          distinctUntilChanged()\n        ),\n        this.state.pipe(\n          observableMap((s) => s.paging.pageNumber),\n          distinctUntilChanged()\n        ),\n        this.state.pipe(\n          observableMap((s) => s.toolbar.disabled),\n          distinctUntilChanged()\n        ),\n        selectedIds.pipe(\n          distinctUntilChanged(),\n          observableMap((selected) => {\n            selectedChanged = true;\n            return selected;\n          })\n        ),\n        data.pipe(distinctUntilChanged()),\n      ],\n      (\n        filters: ListFilterModel[],\n        search: ListSearchModel,\n        sortFieldSelectors: Array<ListSortFieldSelectorModel>,\n        itemsPerPage: number,\n        pageNumber: number,\n        isToolbarDisabled: boolean,\n        selected: Array<string>,\n        itemsData: Array<any>\n      ) => {\n        cancelLastRequest.next();\n        cancelLastRequest.complete();\n        if (selectedChanged) {\n          this.dispatcher.next(new ListSelectedSetLoadingAction());\n          this.dispatcher.next(new ListSelectedLoadAction(selected));\n          this.dispatcher.next(new ListSelectedSetLoadingAction(false));\n          selectedChanged = false;\n        }\n\n        let response: Observable<ListDataResponseModel>;\n        if (this.dataFirstLoad) {\n          this.dataFirstLoad = false;\n          const initialItems = itemsData.map(\n            (d) =>\n              new ListItemModel(d.id || `sky-list-item-model-${++idIndex}`, d)\n          );\n          response = observableOf(\n            new ListDataResponseModel({\n              count: this.initialTotal,\n              items: initialItems,\n            })\n          ).pipe(takeUntil(cancelLastRequest));\n        } else {\n          response = this.dataProvider\n            .get(\n              new ListDataRequestModel({\n                filters: filters,\n                pageSize: itemsPerPage,\n                pageNumber: pageNumber,\n                search: search,\n                sort: new ListSortModel({ fieldSelectors: sortFieldSelectors }),\n                isToolbarDisabled: isToolbarDisabled,\n              })\n            )\n            .pipe(takeUntil(cancelLastRequest));\n        }\n\n        return response;\n      }\n    ).pipe(\n      takeUntil(this.ngUnsubscribe),\n\n      // Retain user selections from previous state.\n      // This is only necessary for grids component (based on item.isSelected).\n      observableMap((response) => {\n        return response.pipe(\n          observableMap((listDataResponseModel) => {\n            return new ListDataResponseModel({\n              count: listDataResponseModel.count,\n              items: this.getItemsAndRetainSelections(\n                listDataResponseModel.items,\n                this.lastSelectedIds\n              ),\n            });\n          })\n        );\n      }),\n      flatMap((value) => value)\n    );\n  }\n\n  public get selectedItems(): Observable<Array<ListItemModel>> {\n    return observableCombineLatest(\n      this.state.pipe(\n        observableMap((current) => current.items.items),\n        distinctUntilChanged()\n      ),\n      this.state.pipe(\n        observableMap((current) => current.selected),\n        distinctUntilChanged()\n      ),\n      (items: Array<ListItemModel>, selected: AsyncItem<ListSelectedModel>) => {\n        return items.filter((i) => selected.item.selectedIdMap.get(i.id));\n      }\n    ).pipe(takeUntil(this.ngUnsubscribe));\n  }\n\n  public get lastUpdate(): Observable<Date> {\n    return this.state.pipe(\n      takeUntil(this.ngUnsubscribe),\n      observableMap((s) =>\n        s.items.lastUpdate ? new Date(s.items.lastUpdate) : undefined\n      )\n    );\n  }\n\n  public get views(): Array<ListViewComponent> {\n    return this.listViews.toArray();\n  }\n\n  public get itemCount(): Observable<number> {\n    return this.dataProvider.count();\n  }\n\n  private getItemsAndRetainSelections(\n    newList: ListItemModel[],\n    selectedIds: string[]\n  ): ListItemModel[] {\n    const updatedListModel = newList.slice();\n    updatedListModel.forEach((item) => {\n      item.isSelected = selectedIds.indexOf(item.id) > -1 ? true : false;\n    });\n    return updatedListModel;\n  }\n\n  private arraysEqual(arrayA: any[], arrayB: any[]): boolean {\n    /* istanbul ignore next */\n    if (arrayA === arrayB) {\n      return true;\n    }\n    if (arrayA === undefined || arrayB === undefined) {\n      return false;\n    }\n    if (arrayA.length !== arrayB.length) {\n      return false;\n    }\n    for (let i = 0; i < arrayA.length; ++i) {\n      if (arrayA[i] !== arrayB[i]) {\n        return false;\n      }\n    }\n    return true;\n  }\n}\n"]}