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

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

@@ -0,0 +1,460 @@
+import { ChangeDetectionStrategy, Component, ContentChildren, EventEmitter, Input, Output, QueryList, ViewChild, forwardRef, } from '@angular/core';
+import { SkyGridColumnComponent, SkyGridColumnModel, SkyGridComponent, SkyGridMessageType, SkyGridSelectedRowsSource, } from '@skyux/grids';
+import { ListSearchModel, ListState, ListStateDispatcher, ListViewComponent, } from '@skyux/list-builder';
+import { getValue } from '@skyux/list-builder-common';
+import { getData, isObservable, } from '@skyux/list-builder-common';
+import { Subject, of as observableOf } from 'rxjs';
+import { distinctUntilChanged, map as observableMap, scan, take, takeUntil, } from 'rxjs/operators';
+import { ListViewGridColumnsLoadAction } from './state/columns/load.action';
+import { ListViewDisplayedGridColumnsLoadAction } from './state/displayed-columns/load.action';
+import { GridStateModel } from './state/grid-state.model';
+import { GridStateDispatcher } from './state/grid-state.rxstate';
+import { GridState } from './state/grid-state.state-node';
+import { SkyListViewGridMessageType } from './types/list-view-grid-message-type';
+import * as i0 from "@angular/core";
+import * as i1 from "@skyux/list-builder";
+import * as i2 from "./state/grid-state.state-node";
+import * as i3 from "./state/grid-state.rxstate";
+import * as i4 from "@skyux/grids";
+import * as i5 from "@skyux/indicators";
+import * as i6 from "@angular/common";
+/**
+ * Displays a grid for a
+ * [SKY UX-themed list of data](https://developer.blackbaud.com/skyux/components/list/overview)
+ * using the [grid component](https://developer.blackbaud.com/skyux/components/grid).
+ * You must install `SkyListModule` as a dependency.
+ */
+export class SkyListViewGridComponent extends ListViewComponent {
+    constructor(state, dispatcher, gridState, gridDispatcher) {
+        super(state, 'Grid View');
+        this.dispatcher = dispatcher;
+        this.gridState = gridState;
+        this.gridDispatcher = gridDispatcher;
+        /**
+         * Specifies how the grid fits to its parent. `"width"` fits the grid to the parent's full
+         * width, and `"scroll"` allows the grid to exceed the parent's width. If the grid does not have
+         * enough columns to fill the parent's width, it always stretches to the parent's full width.
+         * @default "width"
+         */
+        this.fit = 'width';
+        /**
+         * Indicates whether to highlight search text within the grid.
+         * @default true
+         */
+        this.highlightSearchText = true;
+        /**
+         * Indicates whether to enable the multiselect feature to display a column of checkboxes
+         * on the left side of the grid. Multiselect also displays an action bar with buttons to
+         * select and clear all checkboxes. Multiselect defaults to the `id` property on the list's
+         * `data` object.
+         * @default false
+         */
+        this.enableMultiselect = false;
+        /**
+         * Fires when users cancel the deletion of a row.
+         */
+        this.rowDeleteCancel = new EventEmitter();
+        /**
+         * Fires when users confirm the deletion of a row.
+         */
+        this.rowDeleteConfirm = new EventEmitter();
+        /**
+         * Fires when columns change. This includes changes to the displayed columns and changes
+         * to the order of columns. The event emits an array of IDs for the displayed columns that
+         * reflects the column order.
+         */
+        this.selectedColumnIdsChange = new EventEmitter();
+        /**
+         * Message stream for communicating with the internal grid instance
+         * @interal
+         */
+        this.gridMessageStream = new Subject();
+        this.multiselectSelectedIds = [];
+        this.ngUnsubscribe = new Subject();
+        this._messageStream = new Subject();
+    }
+    /**
+     * Specifies the name of the view.
+     * @required
+     */
+    set name(value) {
+        this.viewName = value;
+    }
+    /**
+     * Provides an observable to send commands to the grid.
+     * The commands should respect the `SkyListViewGridMessage` type.
+     */
+    set messageStream(stream) {
+        /* istanbul ignore else */
+        if (this._messageStream) {
+            this._messageStream.unsubscribe();
+        }
+        this._messageStream = stream;
+        this.initInlineDeleteMessages();
+    }
+    get messageStream() {
+        return this._messageStream;
+    }
+    get gridHeight() {
+        /* istanbul ignore next */
+        return typeof this.height === 'number'
+            ? observableOf(this.height)
+            : this.height;
+    }
+    get gridWidth() {
+        /* istanbul ignore next */
+        return typeof this.width === 'number'
+            ? observableOf(this.width)
+            : this.width;
+    }
+    ngAfterContentInit() {
+        // Watch for selection changes and update multiselectSelectedIds for local comparison.
+        this.state
+            .pipe(observableMap((s) => s.selected.item), takeUntil(this.ngUnsubscribe), distinctUntilChanged(this.selectedMapEqual))
+            .subscribe((items) => {
+            const selectedIds = [];
+            items.selectedIdMap.forEach((isSelected, id) => {
+                if (items.selectedIdMap.get(id) === true) {
+                    selectedIds.push(id);
+                }
+            });
+            this.multiselectSelectedIds = selectedIds;
+        });
+        /* istanbul ignore next */
+        if (this.columnComponents.length === 0) {
+            throw new Error('Grid view requires at least one sky-grid-column to render.');
+        }
+        const columnModels = this.columnComponents.map((columnComponent) => {
+            return new SkyGridColumnModel(columnComponent.template, columnComponent);
+        });
+        if (this.width && !isObservable(this.width)) {
+            this.width = observableOf(this.width);
+        }
+        if (this.height && !isObservable(this.height)) {
+            this.height = observableOf(this.height);
+        }
+        // Setup Observables for template
+        this.columns = this.gridState.pipe(observableMap((s) => s.columns.items), distinctUntilChanged(this.arraysEqual), takeUntil(this.ngUnsubscribe));
+        this.selectedColumnIds = this.getSelectedIds();
+        this.items = this.getGridItems();
+        this.loading = this.state.pipe(observableMap((s) => {
+            return s.items.loading;
+        }), distinctUntilChanged(), takeUntil(this.ngUnsubscribe));
+        this.sortField = this.state.pipe(observableMap((s) => {
+            /* istanbul ignore else */
+            /* sanity check */
+            if (s.sort && s.sort.fieldSelectors) {
+                return s.sort.fieldSelectors[0];
+            }
+            /* istanbul ignore next */
+            /* sanity check */
+            return undefined;
+        }), distinctUntilChanged(), takeUntil(this.ngUnsubscribe));
+        this.gridState
+            .pipe(observableMap((s) => s.columns.items), takeUntil(this.ngUnsubscribe), distinctUntilChanged(this.arraysEqual))
+            .subscribe((columns) => {
+            /* istanbul ignore else */
+            if (this.hiddenColumns) {
+                getValue(this.hiddenColumns, (hiddenColumns) => {
+                    this.gridDispatcher.next(new ListViewDisplayedGridColumnsLoadAction(columns.filter((x) => {
+                        /* istanbul ignore next */
+                        /* sanity check */
+                        const id = x.id || x.field;
+                        return hiddenColumns.indexOf(id) === -1;
+                    }), true));
+                });
+            }
+            else if (this.displayedColumns) {
+                /* istanbul ignore next */
+                getValue(this.displayedColumns, (displayedColumns) => {
+                    this.gridDispatcher.next(new ListViewDisplayedGridColumnsLoadAction(columns.filter((x) => displayedColumns.indexOf(x.id || x.field) !== -1), true));
+                });
+            }
+            else {
+                this.gridDispatcher.next(new ListViewDisplayedGridColumnsLoadAction(columns.filter((x) => !x.hidden), true));
+            }
+        });
+        this.currentSearchText = this.state.pipe(observableMap((s) => s.search.searchText), distinctUntilChanged(), takeUntil(this.ngUnsubscribe));
+        this.gridDispatcher.next(new ListViewGridColumnsLoadAction(columnModels, true));
+        this.handleColumnChange();
+        if (this.enableMultiselect) {
+            this.dispatcher.toolbarShowMultiselectToolbar(true);
+        }
+        this.initInlineDeleteMessages();
+    }
+    ngOnDestroy() {
+        this.ngUnsubscribe.next();
+        this.ngUnsubscribe.complete();
+    }
+    /**
+     * If user makes selection, tell list-builder to update the list state.
+     * This logic should only run on user interaction - NOT programmatic updates.
+     */
+    onMultiselectSelectionChange(event) {
+        if (event.source === SkyGridSelectedRowsSource.CheckboxChange ||
+            event.source === SkyGridSelectedRowsSource.RowClick) {
+            this.state
+                .pipe(observableMap((s) => s.items.items), take(1))
+                .subscribe((items) => {
+                const newItemIds = this.arrayIntersection(items.map((i) => i.id), this.multiselectSelectedIds);
+                const newIds = items.filter((i) => i.isSelected).map((i) => i.id);
+                // Check for deselected ids & send message to dispatcher.
+                const deselectedIds = this.arrayDiff(newItemIds, newIds);
+                if (deselectedIds.length > 0) {
+                    this.dispatcher.setSelected(deselectedIds, false);
+                }
+                // Check for selected ids & send message to dispatcher.
+                const selectedIds = this.arrayDiff(newIds, newItemIds);
+                if (selectedIds.length > 0) {
+                    this.dispatcher.setSelected(selectedIds, true);
+                }
+            });
+        }
+    }
+    columnIdsChanged(selectedColumnIds) {
+        this.selectedColumnIds.pipe(take(1)).subscribe((currentIds) => {
+            if (!this.arraysEqual(selectedColumnIds, currentIds)) {
+                this.gridState
+                    .pipe(observableMap((s) => s.columns.items), take(1))
+                    .subscribe((columns) => {
+                    const displayedColumns = selectedColumnIds.map((columnId) => columns.filter((c) => c.id === columnId)[0]);
+                    this.gridDispatcher.next(new ListViewDisplayedGridColumnsLoadAction(displayedColumns, true));
+                });
+            }
+        });
+    }
+    cancelRowDelete(args) {
+        this.rowDeleteCancel.emit(args);
+    }
+    confirmRowDelete(args) {
+        this.rowDeleteConfirm.emit(args);
+    }
+    sortFieldChanged(sortField) {
+        this.dispatcher.sortSetFieldSelectors([sortField]);
+    }
+    onViewActive() {
+        /*
+          Ran into problem where state updates were consumed out of order. For example, on search text
+          update, the searchText update was consumed after the resulting list item update. Scanning the
+          previous value of items lastUpdate ensures that we only receive the latest items.
+        */
+        this.gridState
+            .pipe(takeUntil(this.ngUnsubscribe), scan((previousValue, newValue) => {
+            if (previousValue.displayedColumns.lastUpdate >
+                newValue.displayedColumns.lastUpdate) {
+                return previousValue;
+            }
+            else {
+                return newValue;
+            }
+        }), observableMap((s) => s.displayedColumns.items), distinctUntilChanged(this.arraysEqual))
+            .subscribe((displayedColumns) => {
+            const setFunctions = this.searchFunction !== undefined
+                ? [this.searchFunction]
+                : displayedColumns
+                    .map((column) => (data, searchText) => column.searchFunction(getData(data, column.field), searchText))
+                    .filter((c) => c !== undefined);
+            this.state.pipe(take(1)).subscribe((s) => {
+                this.dispatcher.searchSetOptions(new ListSearchModel({
+                    searchText: s.search.searchText,
+                    functions: setFunctions,
+                    fieldSelectors: displayedColumns.map((d) => d.field),
+                }));
+            });
+        });
+    }
+    initInlineDeleteMessages() {
+        /* istanbul ignore next */
+        if (this.messageStream) {
+            this.messageStream.subscribe((message) => {
+                if (message.type === SkyListViewGridMessageType.AbortDeleteRow) {
+                    this.gridMessageStream.next({
+                        type: SkyGridMessageType.AbortDeleteRow,
+                        data: {
+                            abortDeleteRow: message.data.abortDeleteRow,
+                        },
+                    });
+                }
+                else if (message.type === SkyListViewGridMessageType.PromptDeleteRow) {
+                    this.gridMessageStream.next({
+                        type: SkyGridMessageType.PromptDeleteRow,
+                        data: {
+                            promptDeleteRow: message.data.promptDeleteRow,
+                        },
+                    });
+                }
+            });
+        }
+    }
+    handleColumnChange() {
+        // watch for changes in column components
+        this.columnComponents.changes
+            .pipe(takeUntil(this.ngUnsubscribe))
+            .subscribe((columnComponents) => {
+            const columnModels = this.columnComponents.map((column) => {
+                return new SkyGridColumnModel(column.template, column);
+            });
+            this.gridDispatcher.next(new ListViewGridColumnsLoadAction(columnModels, true));
+        });
+        // Watch for column heading changes:
+        this.columnComponents.forEach((comp) => {
+            comp.headingModelChanges
+                .pipe(takeUntil(this.ngUnsubscribe))
+                .subscribe((change) => {
+                this.gridComponent.updateColumnHeading(change);
+            });
+            comp.descriptionModelChanges
+                .pipe(takeUntil(this.ngUnsubscribe))
+                .subscribe((change) => {
+                this.gridComponent.updateColumnDescription(change);
+            });
+        });
+    }
+    getGridItems() {
+        /*
+          Same problem as above. We should move from having a state object observable with a bunch of
+          static properties to a static state object with observable properties that you can subscribe
+          to.
+        */
+        return this.state.pipe(observableMap((s) => {
+            return s.items;
+        }), scan((previousValue, newValue) => {
+            if (previousValue.lastUpdate > newValue.lastUpdate) {
+                return previousValue;
+            }
+            else {
+                return newValue;
+            }
+        }), observableMap((result) => {
+            return result.items;
+        }), distinctUntilChanged());
+    }
+    getSelectedIds() {
+        /*
+          Same problem as above. We should move from having a state object observable with a bunch of
+          static properties to a static state object with observable properties that you can subscribe
+          to.
+        */
+        return this.gridState.pipe(observableMap((s) => s.displayedColumns), scan((previousValue, newValue) => {
+            if (previousValue.lastUpdate > newValue.lastUpdate) {
+                return previousValue;
+            }
+            else {
+                return newValue;
+            }
+        }), observableMap((result) => {
+            /* istanbul ignore next */
+            /* sanity check */
+            return result.items.map((column) => {
+                return column.id || column.field;
+            });
+        }), distinctUntilChanged((previousValue, newValue) => {
+            return this.haveColumnIdsChanged(previousValue, newValue);
+        }));
+    }
+    haveColumnIdsChanged(previousValue, newValue) {
+        if (previousValue.length !== newValue.length) {
+            this.selectedColumnIdsChange.emit(newValue);
+            return false;
+        }
+        for (let i = 0; i < previousValue.length; i++) {
+            /* istanbul ignore if */
+            if (previousValue[i] !== newValue[i]) {
+                this.selectedColumnIdsChange.emit(newValue);
+                return false;
+            }
+        }
+        return true;
+    }
+    selectedMapEqual(prev, next) {
+        if (prev.selectedIdMap.size !== next.selectedIdMap.size) {
+            return false;
+        }
+        const keys = [];
+        next.selectedIdMap.forEach((value, key) => {
+            keys.push(key);
+        });
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const value = next.selectedIdMap.get(key);
+            if (value !== prev.selectedIdMap.get(key)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    arrayDiff(arrA, arrB) {
+        return arrA.filter((i) => arrB.indexOf(i) < 0);
+    }
+    arrayIntersection(arrA, arrB) {
+        return arrA.filter((value) => -1 !== arrB.indexOf(value));
+    }
+    arraysEqual(arrayA, arrayB) {
+        return (arrayA.length === arrayB.length &&
+            arrayA.every((value, index) => value === arrayB[index]));
+    }
+}
+SkyListViewGridComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyListViewGridComponent, deps: [{ token: i1.ListState }, { token: i1.ListStateDispatcher }, { token: i2.GridState }, { token: i3.GridStateDispatcher }], target: i0.ɵɵFactoryTarget.Component });
+SkyListViewGridComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.7", type: SkyListViewGridComponent, selector: "sky-list-view-grid", inputs: { name: "name", displayedColumns: "displayedColumns", hiddenColumns: "hiddenColumns", fit: "fit", width: "width", height: "height", highlightSearchText: "highlightSearchText", messageStream: "messageStream", rowHighlightedId: "rowHighlightedId", enableMultiselect: "enableMultiselect", settingsKey: "settingsKey", searchFunction: ["search", "searchFunction"] }, outputs: { rowDeleteCancel: "rowDeleteCancel", rowDeleteConfirm: "rowDeleteConfirm", selectedColumnIdsChange: "selectedColumnIdsChange" }, providers: [
+        /* tslint:disable */
+        {
+            provide: ListViewComponent,
+            useExisting: forwardRef(() => SkyListViewGridComponent),
+        },
+        /* tslint:enable */
+        GridState,
+        GridStateDispatcher,
+        GridStateModel,
+    ], queries: [{ propertyName: "columnComponents", predicate: SkyGridColumnComponent }], viewQueries: [{ propertyName: "gridComponent", first: true, predicate: SkyGridComponent, descendants: true }], usesInheritance: true, ngImport: i0, template: "<div *ngIf=\"active | async\">\n  <sky-grid\n    [columns]=\"columns | async\"\n    [data]=\"items | async\"\n    [enableMultiselect]=\"enableMultiselect\"\n    [fit]=\"fit\"\n    [height]=\"gridHeight | async\"\n    [highlightText]=\"\n      highlightSearchText ? (currentSearchText | async) : undefined\n    \"\n    [rowHighlightedId]=\"rowHighlightedId\"\n    [messageStream]=\"gridMessageStream\"\n    [selectedColumnIds]=\"selectedColumnIds | async\"\n    [selectedRowIds]=\"multiselectSelectedIds\"\n    [settingsKey]=\"settingsKey\"\n    [sortField]=\"sortField | async\"\n    [width]=\"gridWidth | async\"\n    (multiselectSelectionChange)=\"onMultiselectSelectionChange($event)\"\n    (rowDeleteCancel)=\"cancelRowDelete($event)\"\n    (rowDeleteConfirm)=\"confirmRowDelete($event)\"\n    (selectedColumnIdsChange)=\"columnIdsChanged($event)\"\n    (sortFieldChange)=\"sortFieldChanged($event)\"\n    #skyGrid\n  >\n  </sky-grid>\n  <sky-wait [isWaiting]=\"loading | async\"> </sky-wait>\n</div>\n", styles: [":host ::ng-deep .sky-grid-heading{border-top:0!important}\n"], components: [{ type: i4.SkyGridComponent, selector: "sky-grid", inputs: ["columns", "data", "enableMultiselect", "fit", "hasToolbar", "height", "highlightText", "messageStream", "multiselectRowId", "rowHighlightedId", "selectedColumnIds", "selectedRowIds", "settingsKey", "sortField", "width"], outputs: ["columnWidthChange", "multiselectSelectionChange", "rowDeleteCancel", "rowDeleteConfirm", "selectedColumnIdsChange", "sortFieldChange"] }, { type: i5.λ14, selector: "sky-wait", inputs: ["ariaLabel", "isWaiting", "isFullPage", "isNonBlocking"] }], directives: [{ type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "async": i6.AsyncPipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyListViewGridComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'sky-list-view-grid', providers: [
+                        /* tslint:disable */
+                        {
+                            provide: ListViewComponent,
+                            useExisting: forwardRef(() => SkyListViewGridComponent),
+                        },
+                        /* tslint:enable */
+                        GridState,
+                        GridStateDispatcher,
+                        GridStateModel,
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div *ngIf=\"active | async\">\n  <sky-grid\n    [columns]=\"columns | async\"\n    [data]=\"items | async\"\n    [enableMultiselect]=\"enableMultiselect\"\n    [fit]=\"fit\"\n    [height]=\"gridHeight | async\"\n    [highlightText]=\"\n      highlightSearchText ? (currentSearchText | async) : undefined\n    \"\n    [rowHighlightedId]=\"rowHighlightedId\"\n    [messageStream]=\"gridMessageStream\"\n    [selectedColumnIds]=\"selectedColumnIds | async\"\n    [selectedRowIds]=\"multiselectSelectedIds\"\n    [settingsKey]=\"settingsKey\"\n    [sortField]=\"sortField | async\"\n    [width]=\"gridWidth | async\"\n    (multiselectSelectionChange)=\"onMultiselectSelectionChange($event)\"\n    (rowDeleteCancel)=\"cancelRowDelete($event)\"\n    (rowDeleteConfirm)=\"confirmRowDelete($event)\"\n    (selectedColumnIdsChange)=\"columnIdsChanged($event)\"\n    (sortFieldChange)=\"sortFieldChanged($event)\"\n    #skyGrid\n  >\n  </sky-grid>\n  <sky-wait [isWaiting]=\"loading | async\"> </sky-wait>\n</div>\n", styles: [":host ::ng-deep .sky-grid-heading{border-top:0!important}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.ListState }, { type: i1.ListStateDispatcher }, { type: i2.GridState }, { type: i3.GridStateDispatcher }]; }, propDecorators: { name: [{
+                type: Input
+            }], displayedColumns: [{
+                type: Input
+            }], hiddenColumns: [{
+                type: Input
+            }], fit: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], highlightSearchText: [{
+                type: Input
+            }], messageStream: [{
+                type: Input
+            }], rowHighlightedId: [{
+                type: Input
+            }], enableMultiselect: [{
+                type: Input
+            }], settingsKey: [{
+                type: Input
+            }], rowDeleteCancel: [{
+                type: Output
+            }], rowDeleteConfirm: [{
+                type: Output
+            }], selectedColumnIdsChange: [{
+                type: Output
+            }], gridComponent: [{
+                type: ViewChild,
+                args: [SkyGridComponent]
+            }], searchFunction: [{
+                type: Input,
+                args: ['search']
+            }], columnComponents: [{
+                type: ContentChildren,
+                args: [SkyGridColumnComponent]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list-view-grid.component.js","sourceRoot":"","sources":["../../../../../../../../libs/components/list-builder-view-grids/src/lib/modules/list-view-grid/list-view-grid.component.ts","../../../../../../../../libs/components/list-builder-view-grids/src/lib/modules/list-view-grid/list-view-grid.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterContentInit,\n  ChangeDetectionStrategy,\n  Component,\n  ContentChildren,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  Output,\n  QueryList,\n  ViewChild,\n  forwardRef,\n} from '@angular/core';\nimport {\n  SkyGridColumnComponent,\n  SkyGridColumnDescriptionModelChange,\n  SkyGridColumnHeadingModelChange,\n  SkyGridColumnModel,\n  SkyGridComponent,\n  SkyGridMessage,\n  SkyGridMessageType,\n  SkyGridSelectedRowsModelChange,\n  SkyGridSelectedRowsSource,\n} from '@skyux/grids';\nimport {\n  ListSearchModel,\n  ListSelectedModel,\n  ListState,\n  ListStateDispatcher,\n  ListViewComponent,\n} from '@skyux/list-builder';\nimport { AsyncList, getValue } from '@skyux/list-builder-common';\nimport {\n  ListItemModel,\n  ListSortFieldSelectorModel,\n  getData,\n  isObservable,\n} from '@skyux/list-builder-common';\n\nimport { Observable, Subject, of as observableOf } from 'rxjs';\nimport {\n  distinctUntilChanged,\n  map as observableMap,\n  scan,\n  take,\n  takeUntil,\n} from 'rxjs/operators';\n\nimport { ListViewGridColumnsLoadAction } from './state/columns/load.action';\nimport { ListViewDisplayedGridColumnsLoadAction } from './state/displayed-columns/load.action';\nimport { GridStateModel } from './state/grid-state.model';\nimport { GridStateDispatcher } from './state/grid-state.rxstate';\nimport { GridState } from './state/grid-state.state-node';\nimport { SkyListViewGridMessage } from './types/list-view-grid-message';\nimport { SkyListViewGridMessageType } from './types/list-view-grid-message-type';\nimport { SkyListViewGridRowDeleteCancelArgs } from './types/list-view-grid-row-delete-cancel-args';\nimport { SkyListViewGridRowDeleteConfirmArgs } from './types/list-view-grid-row-delete-confirm-args';\n\n/**\n * Displays a grid for a\n * [SKY UX-themed list of data](https://developer.blackbaud.com/skyux/components/list/overview)\n * using the [grid component](https://developer.blackbaud.com/skyux/components/grid).\n * You must install `SkyListModule` as a dependency.\n */\n@Component({\n  selector: 'sky-list-view-grid',\n  templateUrl: './list-view-grid.component.html',\n  styleUrls: ['./list-view-grid.component.scss'],\n  providers: [\n    /* tslint:disable */\n    {\n      provide: ListViewComponent,\n      useExisting: forwardRef(() => SkyListViewGridComponent),\n    },\n    /* tslint:enable */\n    GridState,\n    GridStateDispatcher,\n    GridStateModel,\n  ],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class SkyListViewGridComponent\n  extends ListViewComponent\n  implements AfterContentInit, OnDestroy\n{\n  /**\n   * Specifies the name of the view.\n   * @required\n   */\n  @Input()\n  public set name(value: string) {\n    this.viewName = value;\n  }\n\n  /**\n   * Specifies the columns to display by default based on the ID or field of the item.\n   */\n  @Input()\n  public displayedColumns: Array<string> | Observable<Array<string>>;\n\n  /**\n   * Specifies the columns to hide by default based on the ID or field of the item.\n   */\n  @Input()\n  public hiddenColumns: Array<string> | Observable<Array<string>>;\n\n  /**\n   * Specifies how the grid fits to its parent. `\"width\"` fits the grid to the parent's full\n   * width, and `\"scroll\"` allows the grid to exceed the parent's width. If the grid does not have\n   * enough columns to fill the parent's width, it always stretches to the parent's full width.\n   * @default \"width\"\n   */\n  @Input()\n  public fit = 'width';\n\n  /**\n   * Specifies the width of the grid.\n   */\n  @Input()\n  public width: number | Observable<number>;\n\n  /**\n   * Specifies the height of the grid.\n   */\n  @Input()\n  public height: number | Observable<number>;\n\n  /**\n   * Indicates whether to highlight search text within the grid.\n   * @default true\n   */\n  @Input()\n  public highlightSearchText = true;\n\n  /**\n   * Provides an observable to send commands to the grid.\n   * The commands should respect the `SkyListViewGridMessage` type.\n   */\n  @Input()\n  public set messageStream(stream: Subject<SkyListViewGridMessage>) {\n    /* istanbul ignore else */\n    if (this._messageStream) {\n      this._messageStream.unsubscribe();\n    }\n\n    this._messageStream = stream;\n\n    this.initInlineDeleteMessages();\n  }\n\n  public get messageStream(): Subject<SkyListViewGridMessage> {\n    return this._messageStream;\n  }\n\n  /**\n   * Specifies the ID of the row to highlight. The ID matches the `id` property of\n   * the `data` object. Typically, this property is used in conjunction with the\n   * [flyout component](https://developer.blackbaud.com/skyux/components/flyout) to\n   * indicate the currently selected row.\n   */\n  @Input()\n  public rowHighlightedId: string;\n\n  /**\n   * Indicates whether to enable the multiselect feature to display a column of checkboxes\n   * on the left side of the grid. Multiselect also displays an action bar with buttons to\n   * select and clear all checkboxes. Multiselect defaults to the `id` property on the list's\n   * `data` object.\n   * @default false\n   */\n  @Input()\n  public enableMultiselect = false;\n\n  /**\n   * Specifies a unique key for the UI Config Service to retrieve stored settings from\n   * a database. The service saves configuration settings for users and returns `selectedColumnIds`\n   * for the columns to display and the preferred column order. For more information, see the\n   * [sticky settings documentation](https://developer.blackbaud.com/skyux/learn/get-started/advanced/sticky-settings).\n   */\n  @Input()\n  public settingsKey: string;\n\n  /**\n   * Fires when users cancel the deletion of a row.\n   */\n  @Output()\n  public rowDeleteCancel = new EventEmitter<SkyListViewGridRowDeleteCancelArgs>();\n\n  /**\n   * Fires when users confirm the deletion of a row.\n   */\n  @Output()\n  public rowDeleteConfirm = new EventEmitter<SkyListViewGridRowDeleteConfirmArgs>();\n\n  /**\n   * Fires when columns change. This includes changes to the displayed columns and changes\n   * to the order of columns. The event emits an array of IDs for the displayed columns that\n   * reflects the column order.\n   */\n  @Output()\n  public selectedColumnIdsChange = new EventEmitter<Array<string>>();\n\n  @ViewChild(SkyGridComponent)\n  public gridComponent: SkyGridComponent;\n\n  public get gridHeight(): Observable<number> {\n    /* istanbul ignore next */\n    return typeof this.height === 'number'\n      ? observableOf(this.height)\n      : this.height;\n  }\n\n  public get gridWidth(): Observable<number> {\n    /* istanbul ignore next */\n    return typeof this.width === 'number'\n      ? observableOf(this.width)\n      : this.width;\n  }\n\n  public columns: Observable<Array<SkyGridColumnModel>>;\n\n  public selectedColumnIds: Observable<Array<string>>;\n\n  public items: Observable<ListItemModel[]>;\n\n  /**\n   * Message stream for communicating with the internal grid instance\n   * @interal\n   */\n  public gridMessageStream = new Subject<SkyGridMessage>();\n\n  public loading: Observable<boolean>;\n\n  public sortField: Observable<ListSortFieldSelectorModel>;\n\n  public currentSearchText: Observable<string>;\n\n  public multiselectSelectedIds: string[] = [];\n\n  /**\n   * Specifies a search function to apply on the view data.\n   * @param data Specifies the data to search.\n   * @param searchText Specifies a text string to search for.\n   */\n  // eslint-disable-next-line @angular-eslint/no-input-rename\n  @Input('search')\n  public searchFunction: (data: any, searchText: string) => boolean;\n\n  @ContentChildren(SkyGridColumnComponent)\n  private columnComponents: QueryList<SkyGridColumnComponent>;\n\n  private ngUnsubscribe = new Subject();\n\n  private _messageStream = new Subject<SkyListViewGridMessage>();\n\n  constructor(\n    state: ListState,\n    private dispatcher: ListStateDispatcher,\n    public gridState: GridState,\n    public gridDispatcher: GridStateDispatcher\n  ) {\n    super(state, 'Grid View');\n  }\n\n  public ngAfterContentInit() {\n    // Watch for selection changes and update multiselectSelectedIds for local comparison.\n    this.state\n      .pipe(\n        observableMap((s) => s.selected.item),\n        takeUntil(this.ngUnsubscribe),\n        distinctUntilChanged(this.selectedMapEqual)\n      )\n      .subscribe((items: ListSelectedModel) => {\n        const selectedIds: string[] = [];\n\n        items.selectedIdMap.forEach((isSelected, id) => {\n          if (items.selectedIdMap.get(id) === true) {\n            selectedIds.push(id);\n          }\n        });\n\n        this.multiselectSelectedIds = selectedIds;\n      });\n\n    /* istanbul ignore next */\n    if (this.columnComponents.length === 0) {\n      throw new Error(\n        'Grid view requires at least one sky-grid-column to render.'\n      );\n    }\n\n    const columnModels = this.columnComponents.map((columnComponent) => {\n      return new SkyGridColumnModel(columnComponent.template, columnComponent);\n    });\n\n    if (this.width && !isObservable(this.width)) {\n      this.width = observableOf(this.width);\n    }\n\n    if (this.height && !isObservable(this.height)) {\n      this.height = observableOf(this.height);\n    }\n\n    // Setup Observables for template\n    this.columns = this.gridState.pipe(\n      observableMap((s) => s.columns.items),\n      distinctUntilChanged(this.arraysEqual),\n      takeUntil(this.ngUnsubscribe)\n    );\n\n    this.selectedColumnIds = this.getSelectedIds();\n\n    this.items = this.getGridItems();\n\n    this.loading = this.state.pipe(\n      observableMap((s) => {\n        return s.items.loading;\n      }),\n      distinctUntilChanged(),\n      takeUntil(this.ngUnsubscribe)\n    );\n\n    this.sortField = this.state.pipe(\n      observableMap((s) => {\n        /* istanbul ignore else */\n        /* sanity check */\n        if (s.sort && s.sort.fieldSelectors) {\n          return s.sort.fieldSelectors[0];\n        }\n        /* istanbul ignore next */\n        /* sanity check */\n        return undefined;\n      }),\n      distinctUntilChanged(),\n      takeUntil(this.ngUnsubscribe)\n    );\n\n    this.gridState\n      .pipe(\n        observableMap((s) => s.columns.items),\n        takeUntil(this.ngUnsubscribe),\n        distinctUntilChanged(this.arraysEqual)\n      )\n      .subscribe((columns) => {\n        /* istanbul ignore else */\n        if (this.hiddenColumns) {\n          getValue(this.hiddenColumns, (hiddenColumns: string[]) => {\n            this.gridDispatcher.next(\n              new ListViewDisplayedGridColumnsLoadAction(\n                columns.filter((x) => {\n                  /* istanbul ignore next */\n                  /* sanity check */\n                  const id = x.id || x.field;\n                  return hiddenColumns.indexOf(id) === -1;\n                }),\n                true\n              )\n            );\n          });\n        } else if (this.displayedColumns) {\n          /* istanbul ignore next */\n          getValue(this.displayedColumns, (displayedColumns: string[]) => {\n            this.gridDispatcher.next(\n              new ListViewDisplayedGridColumnsLoadAction(\n                columns.filter(\n                  (x) => displayedColumns.indexOf(x.id || x.field) !== -1\n                ),\n                true\n              )\n            );\n          });\n        } else {\n          this.gridDispatcher.next(\n            new ListViewDisplayedGridColumnsLoadAction(\n              columns.filter((x) => !x.hidden),\n              true\n            )\n          );\n        }\n      });\n\n    this.currentSearchText = this.state.pipe(\n      observableMap((s) => s.search.searchText),\n      distinctUntilChanged(),\n      takeUntil(this.ngUnsubscribe)\n    );\n\n    this.gridDispatcher.next(\n      new ListViewGridColumnsLoadAction(columnModels, true)\n    );\n\n    this.handleColumnChange();\n\n    if (this.enableMultiselect) {\n      this.dispatcher.toolbarShowMultiselectToolbar(true);\n    }\n\n    this.initInlineDeleteMessages();\n  }\n\n  public ngOnDestroy() {\n    this.ngUnsubscribe.next();\n    this.ngUnsubscribe.complete();\n  }\n\n  /**\n   * If user makes selection, tell list-builder to update the list state.\n   * This logic should only run on user interaction - NOT programmatic updates.\n   */\n  public onMultiselectSelectionChange(\n    event: SkyGridSelectedRowsModelChange\n  ): void {\n    if (\n      event.source === SkyGridSelectedRowsSource.CheckboxChange ||\n      event.source === SkyGridSelectedRowsSource.RowClick\n    ) {\n      this.state\n        .pipe(\n          observableMap((s) => s.items.items),\n          take(1)\n        )\n        .subscribe((items: ListItemModel[]) => {\n          const newItemIds = this.arrayIntersection(\n            items.map((i) => i.id),\n            this.multiselectSelectedIds\n          );\n          const newIds = items.filter((i) => i.isSelected).map((i) => i.id);\n\n          // Check for deselected ids & send message to dispatcher.\n          const deselectedIds = this.arrayDiff(newItemIds, newIds);\n          if (deselectedIds.length > 0) {\n            this.dispatcher.setSelected(deselectedIds, false);\n          }\n\n          // Check for selected ids & send message to dispatcher.\n          const selectedIds = this.arrayDiff(newIds, newItemIds);\n          if (selectedIds.length > 0) {\n            this.dispatcher.setSelected(selectedIds, true);\n          }\n        });\n    }\n  }\n\n  public columnIdsChanged(selectedColumnIds: Array<string>) {\n    this.selectedColumnIds.pipe(take(1)).subscribe((currentIds) => {\n      if (!this.arraysEqual(selectedColumnIds, currentIds)) {\n        this.gridState\n          .pipe(\n            observableMap((s) => s.columns.items),\n            take(1)\n          )\n          .subscribe((columns) => {\n            const displayedColumns = selectedColumnIds.map(\n              (columnId) => columns.filter((c) => c.id === columnId)[0]\n            );\n            this.gridDispatcher.next(\n              new ListViewDisplayedGridColumnsLoadAction(displayedColumns, true)\n            );\n          });\n      }\n    });\n  }\n\n  public cancelRowDelete(args: SkyListViewGridRowDeleteCancelArgs): void {\n    this.rowDeleteCancel.emit(args);\n  }\n\n  public confirmRowDelete(args: SkyListViewGridRowDeleteConfirmArgs): void {\n    this.rowDeleteConfirm.emit(args);\n  }\n\n  public sortFieldChanged(sortField: ListSortFieldSelectorModel) {\n    this.dispatcher.sortSetFieldSelectors([sortField]);\n  }\n\n  public onViewActive() {\n    /*\n      Ran into problem where state updates were consumed out of order. For example, on search text\n      update, the searchText update was consumed after the resulting list item update. Scanning the\n      previous value of items lastUpdate ensures that we only receive the latest items.\n    */\n    this.gridState\n      .pipe(\n        takeUntil(this.ngUnsubscribe),\n        scan((previousValue: GridStateModel, newValue: GridStateModel) => {\n          if (\n            previousValue.displayedColumns.lastUpdate >\n            newValue.displayedColumns.lastUpdate\n          ) {\n            return previousValue;\n          } else {\n            return newValue;\n          }\n        }),\n        observableMap((s) => s.displayedColumns.items),\n        distinctUntilChanged(this.arraysEqual)\n      )\n      .subscribe((displayedColumns) => {\n        const setFunctions =\n          this.searchFunction !== undefined\n            ? [this.searchFunction]\n            : displayedColumns\n                .map(\n                  (column) => (data: any, searchText: string) =>\n                    column.searchFunction(\n                      getData(data, column.field),\n                      searchText\n                    )\n                )\n                .filter((c) => c !== undefined);\n\n        this.state.pipe(take(1)).subscribe((s) => {\n          this.dispatcher.searchSetOptions(\n            new ListSearchModel({\n              searchText: s.search.searchText,\n              functions: setFunctions,\n              fieldSelectors: displayedColumns.map((d) => d.field),\n            })\n          );\n        });\n      });\n  }\n\n  private initInlineDeleteMessages(): void {\n    /* istanbul ignore next */\n    if (this.messageStream) {\n      this.messageStream.subscribe((message: SkyListViewGridMessage) => {\n        if (message.type === SkyListViewGridMessageType.AbortDeleteRow) {\n          this.gridMessageStream.next({\n            type: SkyGridMessageType.AbortDeleteRow,\n            data: {\n              abortDeleteRow: message.data.abortDeleteRow,\n            },\n          });\n        } else if (\n          message.type === SkyListViewGridMessageType.PromptDeleteRow\n        ) {\n          this.gridMessageStream.next({\n            type: SkyGridMessageType.PromptDeleteRow,\n            data: {\n              promptDeleteRow: message.data.promptDeleteRow,\n            },\n          });\n        }\n      });\n    }\n  }\n\n  private handleColumnChange() {\n    // watch for changes in column components\n    this.columnComponents.changes\n      .pipe(takeUntil(this.ngUnsubscribe))\n      .subscribe((columnComponents) => {\n        const columnModels = this.columnComponents.map((column) => {\n          return new SkyGridColumnModel(column.template, column);\n        });\n        this.gridDispatcher.next(\n          new ListViewGridColumnsLoadAction(columnModels, true)\n        );\n      });\n\n    // Watch for column heading changes:\n    this.columnComponents.forEach((comp) => {\n      comp.headingModelChanges\n        .pipe(takeUntil(this.ngUnsubscribe))\n        .subscribe((change: SkyGridColumnHeadingModelChange) => {\n          this.gridComponent.updateColumnHeading(change);\n        });\n      comp.descriptionModelChanges\n        .pipe(takeUntil(this.ngUnsubscribe))\n        .subscribe((change: SkyGridColumnDescriptionModelChange) => {\n          this.gridComponent.updateColumnDescription(change);\n        });\n    });\n  }\n\n  private getGridItems(): Observable<Array<ListItemModel>> {\n    /*\n      Same problem as above. We should move from having a state object observable with a bunch of\n      static properties to a static state object with observable properties that you can subscribe\n      to.\n    */\n    return this.state.pipe(\n      observableMap((s) => {\n        return s.items;\n      }),\n      scan(\n        (\n          previousValue: AsyncList<ListItemModel>,\n          newValue: AsyncList<ListItemModel>\n        ) => {\n          if (previousValue.lastUpdate > newValue.lastUpdate) {\n            return previousValue;\n          } else {\n            return newValue;\n          }\n        }\n      ),\n      observableMap((result: AsyncList<ListItemModel>) => {\n        return result.items;\n      }),\n      distinctUntilChanged()\n    );\n  }\n\n  private getSelectedIds(): Observable<Array<string>> {\n    /*\n      Same problem as above. We should move from having a state object observable with a bunch of\n      static properties to a static state object with observable properties that you can subscribe\n      to.\n    */\n    return this.gridState.pipe(\n      observableMap((s) => s.displayedColumns),\n      scan(\n        (\n          previousValue: AsyncList<SkyGridColumnModel>,\n          newValue: AsyncList<SkyGridColumnModel>\n        ) => {\n          if (previousValue.lastUpdate > newValue.lastUpdate) {\n            return previousValue;\n          } else {\n            return newValue;\n          }\n        }\n      ),\n      observableMap((result: AsyncList<SkyGridColumnModel>) => {\n        /* istanbul ignore next */\n        /* sanity check */\n        return result.items.map((column: SkyGridColumnModel) => {\n          return column.id || column.field;\n        });\n      }),\n      distinctUntilChanged((previousValue: string[], newValue: string[]) => {\n        return this.haveColumnIdsChanged(previousValue, newValue);\n      })\n    );\n  }\n\n  private haveColumnIdsChanged(previousValue: string[], newValue: string[]) {\n    if (previousValue.length !== newValue.length) {\n      this.selectedColumnIdsChange.emit(newValue);\n      return false;\n    }\n\n    for (let i = 0; i < previousValue.length; i++) {\n      /* istanbul ignore if */\n      if (previousValue[i] !== newValue[i]) {\n        this.selectedColumnIdsChange.emit(newValue);\n        return false;\n      }\n    }\n    return true;\n  }\n\n  private selectedMapEqual(\n    prev: ListSelectedModel,\n    next: ListSelectedModel\n  ): boolean {\n    if (prev.selectedIdMap.size !== next.selectedIdMap.size) {\n      return false;\n    }\n\n    const keys: string[] = [];\n    next.selectedIdMap.forEach((value, key) => {\n      keys.push(key);\n    });\n\n    for (let i = 0; i < keys.length; i++) {\n      const key = keys[i];\n\n      const value = next.selectedIdMap.get(key);\n      if (value !== prev.selectedIdMap.get(key)) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  private arrayDiff(arrA: Array<any>, arrB: Array<any>): Array<any> {\n    return arrA.filter((i) => arrB.indexOf(i) < 0);\n  }\n\n  private arrayIntersection(arrA: Array<any>, arrB: Array<any>): Array<any> {\n    return arrA.filter((value) => -1 !== arrB.indexOf(value));\n  }\n\n  private arraysEqual(arrayA: any[], arrayB: any[]) {\n    return (\n      arrayA.length === arrayB.length &&\n      arrayA.every((value, index) => value === arrayB[index])\n    );\n  }\n}\n","<div *ngIf=\"active | async\">\n  <sky-grid\n    [columns]=\"columns | async\"\n    [data]=\"items | async\"\n    [enableMultiselect]=\"enableMultiselect\"\n    [fit]=\"fit\"\n    [height]=\"gridHeight | async\"\n    [highlightText]=\"\n      highlightSearchText ? (currentSearchText | async) : undefined\n    \"\n    [rowHighlightedId]=\"rowHighlightedId\"\n    [messageStream]=\"gridMessageStream\"\n    [selectedColumnIds]=\"selectedColumnIds | async\"\n    [selectedRowIds]=\"multiselectSelectedIds\"\n    [settingsKey]=\"settingsKey\"\n    [sortField]=\"sortField | async\"\n    [width]=\"gridWidth | async\"\n    (multiselectSelectionChange)=\"onMultiselectSelectionChange($event)\"\n    (rowDeleteCancel)=\"cancelRowDelete($event)\"\n    (rowDeleteConfirm)=\"confirmRowDelete($event)\"\n    (selectedColumnIdsChange)=\"columnIdsChanged($event)\"\n    (sortFieldChange)=\"sortFieldChanged($event)\"\n    #skyGrid\n  >\n  </sky-grid>\n  <sky-wait [isWaiting]=\"loading | async\"> </sky-wait>\n</div>\n"]}

package/esm2020/lib/modules/list-view-grid/list-view-grid.module.mjs

@@ -0,0 +1,42 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { SkyGridModule } from '@skyux/grids';
+import { SkyWaitModule } from '@skyux/indicators';
+import { SkyListColumnSelectorActionModule } from '../list-column-selector-action/list-column-selector-action.module';
+import { SkyListBuilderViewGridsResourcesModule } from '../shared/sky-list-builder-view-grids-resources.module';
+import { SkyListViewGridComponent } from './list-view-grid.component';
+import * as i0 from "@angular/core";
+export class SkyListViewGridModule {
+}
+SkyListViewGridModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyListViewGridModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SkyListViewGridModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyListViewGridModule, declarations: [SkyListViewGridComponent], imports: [CommonModule,
+        SkyWaitModule,
+        SkyGridModule,
+        SkyListBuilderViewGridsResourcesModule], exports: [SkyListViewGridComponent,
+        SkyListColumnSelectorActionModule,
+        SkyGridModule] });
+SkyListViewGridModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyListViewGridModule, imports: [[
+            CommonModule,
+            SkyWaitModule,
+            SkyGridModule,
+            SkyListBuilderViewGridsResourcesModule,
+        ], SkyListColumnSelectorActionModule,
+        SkyGridModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.7", ngImport: i0, type: SkyListViewGridModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [SkyListViewGridComponent],
+                    imports: [
+                        CommonModule,
+                        SkyWaitModule,
+                        SkyGridModule,
+                        SkyListBuilderViewGridsResourcesModule,
+                    ],
+                    exports: [
+                        SkyListViewGridComponent,
+                        SkyListColumnSelectorActionModule,
+                        SkyGridModule,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlzdC12aWV3LWdyaWQubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21wb25lbnRzL2xpc3QtYnVpbGRlci12aWV3LWdyaWRzL3NyYy9saWIvbW9kdWxlcy9saXN0LXZpZXctZ3JpZC9saXN0LXZpZXctZ3JpZC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGNBQWMsQ0FBQztBQUM3QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFFbEQsT0FBTyxFQUFFLGlDQUFpQyxFQUFFLE1BQU0sbUVBQW1FLENBQUM7QUFDdEgsT0FBTyxFQUFFLHNDQUFzQyxFQUFFLE1BQU0sd0RBQXdELENBQUM7QUFFaEgsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sNEJBQTRCLENBQUM7O0FBZ0J0RSxNQUFNLE9BQU8scUJBQXFCOztrSEFBckIscUJBQXFCO21IQUFyQixxQkFBcUIsaUJBYmpCLHdCQUF3QixhQUVyQyxZQUFZO1FBQ1osYUFBYTtRQUNiLGFBQWE7UUFDYixzQ0FBc0MsYUFHdEMsd0JBQXdCO1FBQ3hCLGlDQUFpQztRQUNqQyxhQUFhO21IQUdKLHFCQUFxQixZQVp2QjtZQUNQLFlBQVk7WUFDWixhQUFhO1lBQ2IsYUFBYTtZQUNiLHNDQUFzQztTQUN2QyxFQUdDLGlDQUFpQztRQUNqQyxhQUFhOzJGQUdKLHFCQUFxQjtrQkFkakMsUUFBUTttQkFBQztvQkFDUixZQUFZLEVBQUUsQ0FBQyx3QkFBd0IsQ0FBQztvQkFDeEMsT0FBTyxFQUFFO3dCQUNQLFlBQVk7d0JBQ1osYUFBYTt3QkFDYixhQUFhO3dCQUNiLHNDQUFzQztxQkFDdkM7b0JBQ0QsT0FBTyxFQUFFO3dCQUNQLHdCQUF3Qjt3QkFDeEIsaUNBQWlDO3dCQUNqQyxhQUFhO3FCQUNkO2lCQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBTa3lHcmlkTW9kdWxlIH0gZnJvbSAnQHNreXV4L2dyaWRzJztcbmltcG9ydCB7IFNreVdhaXRNb2R1bGUgfSBmcm9tICdAc2t5dXgvaW5kaWNhdG9ycyc7XG5cbmltcG9ydCB7IFNreUxpc3RDb2x1bW5TZWxlY3RvckFjdGlvbk1vZHVsZSB9IGZyb20gJy4uL2xpc3QtY29sdW1uLXNlbGVjdG9yLWFjdGlvbi9saXN0LWNvbHVtbi1zZWxlY3Rvci1hY3Rpb24ubW9kdWxlJztcbmltcG9ydCB7IFNreUxpc3RCdWlsZGVyVmlld0dyaWRzUmVzb3VyY2VzTW9kdWxlIH0gZnJvbSAnLi4vc2hhcmVkL3NreS1saXN0LWJ1aWxkZXItdmlldy1ncmlkcy1yZXNvdXJjZXMubW9kdWxlJztcblxuaW1wb3J0IHsgU2t5TGlzdFZpZXdHcmlkQ29tcG9uZW50IH0gZnJvbSAnLi9saXN0LXZpZXctZ3JpZC5jb21wb25lbnQnO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtTa3lMaXN0Vmlld0dyaWRDb21wb25lbnRdLFxuICBpbXBvcnRzOiBbXG4gICAgQ29tbW9uTW9kdWxlLFxuICAgIFNreVdhaXRNb2R1bGUsXG4gICAgU2t5R3JpZE1vZHVsZSxcbiAgICBTa3lMaXN0QnVpbGRlclZpZXdHcmlkc1Jlc291cmNlc01vZHVsZSxcbiAgXSxcbiAgZXhwb3J0czogW1xuICAgIFNreUxpc3RWaWV3R3JpZENvbXBvbmVudCxcbiAgICBTa3lMaXN0Q29sdW1uU2VsZWN0b3JBY3Rpb25Nb2R1bGUsXG4gICAgU2t5R3JpZE1vZHVsZSxcbiAgXSxcbn0pXG5leHBvcnQgY2xhc3MgU2t5TGlzdFZpZXdHcmlkTW9kdWxlIHt9XG4iXX0=

package/esm2020/lib/modules/list-view-grid/state/columns/columns.orchestrator.mjs

@@ -0,0 +1,22 @@
+import { SkyGridColumnModel } from '@skyux/grids';
+import { AsyncList } from '@skyux/list-builder-common';
+import { GridStateOrchestrator } from '../grid-state.rxstate';
+import { ListViewGridColumnsLoadAction } from './load.action';
+/**
+ * @internal
+ */
+export class ListViewGridColumnsOrchestrator extends GridStateOrchestrator {
+    /* istanbul ignore next */
+    constructor() {
+        super();
+        this.register(ListViewGridColumnsLoadAction, this.load);
+    }
+    load(state, action) {
+        const newColumns = action.columns.map((g) => new SkyGridColumnModel(g.template, g));
+        if (action.refresh) {
+            return new AsyncList([...newColumns], new Date());
+        }
+        return new AsyncList([...state.items, ...newColumns], new Date());
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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