@clr/angular 12.0.11 → 13.0.1

package/esm2020/data/datagrid/providers/selection.mjs

@@ -0,0 +1,374 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { SelectionType } from '../enums/selection-type';
+import { debounceTime } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "./items";
+import * as i2 from "./filters";
+let nbSelection = 0;
+export class Selection {
+    constructor(_items, _filters, _zone) {
+        this._items = _items;
+        this._filters = _filters;
+        this._zone = _zone;
+        this.preserveSelection = false;
+        this.prevSelectionRefs = []; // Refs of selected items
+        this.lockedRefs = []; // Ref of locked items
+        this._selectionType = SelectionType.None;
+        /** @deprecated since 2.0, remove in 3.0 */
+        this.rowSelectionMode = false;
+        /**
+         * Subscriptions to the other providers changes.
+         */
+        this.subscriptions = [];
+        this.valueCollector = new Subject();
+        /**
+         * The Observable that lets other classes subscribe to selection changes
+         */
+        this._change = new Subject();
+        this.id = 'clr-dg-selection' + nbSelection++;
+        this.subscriptions.push(this._filters.change.subscribe(() => {
+            if (!this._selectable || this.preserveSelection) {
+                return;
+            }
+            this.clearSelection();
+        }));
+        this.subscriptions.push(this._items.allChanges.subscribe(updatedItems => {
+            // Reset the lockedRefs;
+            const updateLockedRef = [];
+            switch (this.selectionType) {
+                case SelectionType.None: {
+                    break;
+                }
+                case SelectionType.Single: {
+                    let newSingle;
+                    const trackBy = this._items.trackBy;
+                    let selectionUpdated = false;
+                    // if the currentSingle has been set before data was loaded, we look up and save the ref from current data set
+                    if (this.currentSingle && !this.prevSingleSelectionRef) {
+                        if (this._items.all && this._items.trackBy) {
+                            const lookup = this._items.all.findIndex(maybe => maybe === this.currentSingle);
+                            this.prevSingleSelectionRef = this._items.trackBy(lookup, this.currentSingle);
+                        }
+                    }
+                    updatedItems.forEach((item, index) => {
+                        const ref = trackBy(index, item);
+                        // If one of the updated items is the previously selectedSingle, set it as the new one
+                        if (this.prevSingleSelectionRef === ref) {
+                            newSingle = item;
+                            selectionUpdated = true;
+                        }
+                        if (this.lockedRefs.indexOf(ref) > -1) {
+                            updateLockedRef.push(ref);
+                        }
+                    });
+                    // If we're using smart datagrids, we expect all items to be present in the updatedItems array.
+                    // Therefore, we should delete the currentSingle if it used to be defined but doesn't exist anymore.
+                    // No explicit "delete" is required, since newSingle would be undefined at this point.
+                    // Marking it as selectionUpdated here will set currentSingle to undefined below in the setTimeout.
+                    if (this._items.smart && !newSingle) {
+                        selectionUpdated = true;
+                    }
+                    // TODO: Discussed this with Eudes and this is fine for now.
+                    // But we need to figure out a different pattern for the
+                    // child triggering the parent change detection problem.
+                    // Using setTimeout for now to fix this.
+                    setTimeout(() => {
+                        if (selectionUpdated) {
+                            this.currentSingle = newSingle;
+                        }
+                    }, 0);
+                    break;
+                }
+                case SelectionType.Multi: {
+                    let leftOver = this.current.slice();
+                    const trackBy = this._items.trackBy;
+                    let selectionUpdated = false;
+                    // if the current has been set before data was loaded, we look up and save the ref from current data set
+                    if (this.current.length > 0 && this.prevSelectionRefs.length !== this.current.length) {
+                        if (this._items.all && this._items.trackBy) {
+                            this.prevSelectionRefs = [];
+                            this.current.forEach(item => {
+                                const lookup = this._items.all.findIndex(maybe => maybe === item);
+                                this.prevSelectionRefs.push(this._items.trackBy(lookup, item));
+                            });
+                        }
+                    }
+                    // Duplicate loop, when the issue is issue#2342 is revisited keep in mind that
+                    // we need to go over every updated item and check to see if there are valid to be
+                    // locked or not and update it. When only add items that are found in the lockedRefs back.
+                    //
+                    // The both loops below that goes over updatedItems could be combined into one.
+                    updatedItems.forEach((item, index) => {
+                        const ref = trackBy(index, item);
+                        if (this.lockedRefs.indexOf(ref) > -1) {
+                            updateLockedRef.push(ref);
+                        }
+                    });
+                    // TODO: revisit this when we work on https://github.com/vmware/clarity/issues/2342
+                    // currently, the selection is cleared when filter is applied, so the logic inside
+                    // the if statement below results in broken behavior.
+                    if (leftOver.length > 0) {
+                        updatedItems.forEach((item, index) => {
+                            const ref = trackBy(index, item);
+                            // Look in current selected refs array if item is selected, and update actual value
+                            const selectedIndex = this.prevSelectionRefs.indexOf(ref);
+                            if (selectedIndex > -1) {
+                                leftOver[selectedIndex] = item;
+                                selectionUpdated = true;
+                            }
+                        });
+                        // Filter out any unmatched items if we're using smart datagrids where we expect all items to be
+                        // present
+                        if (this._items.smart) {
+                            leftOver = leftOver.filter(selected => updatedItems.indexOf(selected) > -1);
+                            if (this.current.length !== leftOver.length) {
+                                selectionUpdated = true;
+                            }
+                        }
+                        // TODO: Discussed this with Eudes and this is fine for now.
+                        // But we need to figure out a different pattern for the
+                        // child triggering the parent change detection problem.
+                        // Using setTimeout for now to fix this.
+                        setTimeout(() => {
+                            if (selectionUpdated) {
+                                this.current = leftOver;
+                            }
+                        }, 0);
+                    }
+                    break;
+                }
+                default: {
+                    break;
+                }
+            }
+            // Sync locked items
+            this.lockedRefs = updateLockedRef;
+        }));
+        this.subscriptions.push(this.valueCollector.pipe(debounceTime(0)).subscribe(() => this.emitChange()));
+    }
+    clearSelection() {
+        this._current = [];
+        this.prevSelectionRefs = [];
+        this.prevSingleSelectionRef = null;
+        this._currentSingle = null;
+        this.emitChange();
+    }
+    get selectionType() {
+        return this._selectionType;
+    }
+    set selectionType(value) {
+        if (value === this.selectionType) {
+            return;
+        }
+        this._selectionType = value;
+        if (value === SelectionType.None) {
+            delete this.current;
+        }
+        else {
+            this.updateCurrent([], false);
+        }
+    }
+    get _selectable() {
+        return this._selectionType === SelectionType.Multi || this._selectionType === SelectionType.Single;
+    }
+    /**
+     * Cleans up our subscriptions to other providers
+     */
+    destroy() {
+        this.subscriptions.forEach(sub => sub.unsubscribe());
+    }
+    get currentSingle() {
+        return this._currentSingle;
+    }
+    set currentSingle(value) {
+        if (value === this._currentSingle) {
+            return;
+        }
+        this._currentSingle = value;
+        if (this._items.all && this._items.trackBy && value) {
+            const lookup = this._items.all.findIndex(maybe => maybe === value);
+            this.prevSingleSelectionRef = this._items.trackBy(lookup, value);
+        }
+        this.emitChange();
+    }
+    get current() {
+        return this._current;
+    }
+    set current(value) {
+        this.updateCurrent(value, true);
+    }
+    updateCurrent(value, emit) {
+        this._current = value;
+        if (emit) {
+            this.valueCollector.next(value);
+        }
+    }
+    emitChange() {
+        if (this._selectionType === SelectionType.Single) {
+            this._change.next(this.currentSingle);
+        }
+        else if (this._selectionType === SelectionType.Multi) {
+            this._change.next(this.current);
+        }
+    }
+    // We do not want to expose the Subject itself, but the Observable which is read-only
+    get change() {
+        return this._change.asObservable();
+    }
+    /**
+     * Checks if an item is currently selected
+     */
+    isSelected(item) {
+        if (this._selectionType === SelectionType.Single) {
+            return this.currentSingle === item;
+        }
+        else if (this._selectionType === SelectionType.Multi) {
+            return this.current.indexOf(item) >= 0;
+        }
+        return false;
+    }
+    /**
+     * Selects an item
+     */
+    selectItem(item) {
+        this.current = this.current.concat(item);
+        if (this._items.trackBy && this._items.all) {
+            // Push selected ref onto array
+            const lookup = this._items.all.findIndex(maybe => maybe === item);
+            this.prevSelectionRefs.push(this._items.trackBy(lookup, item));
+        }
+    }
+    /**
+     * Deselects an item
+     */
+    deselectItem(indexOfItem) {
+        this.current = this.current.slice(0, indexOfItem).concat(this.current.slice(indexOfItem + 1));
+        if (this._items.trackBy && indexOfItem < this.prevSelectionRefs.length) {
+            // Keep selected refs array in sync
+            const removedItems = this.prevSelectionRefs.splice(indexOfItem, 1);
+            // locked reference is no longer needed (if any)
+            this.lockedRefs = this.lockedRefs.filter(locked => locked !== removedItems[0]);
+        }
+    }
+    /**
+     * Selects or deselects an item
+     */
+    setSelected(item, selected) {
+        const index = this.current ? this.current.indexOf(item) : -1;
+        switch (this._selectionType) {
+            case SelectionType.None:
+                break;
+            case SelectionType.Single:
+                // in single selection, set currentSingle method should be used
+                break;
+            case SelectionType.Multi:
+                if (index >= 0 && !selected) {
+                    this.deselectItem(index);
+                }
+                else if (index < 0 && selected) {
+                    this.selectItem(item);
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    /**
+     * Checks if all currently displayed items are selected
+     */
+    isAllSelected() {
+        if (this._selectionType !== SelectionType.Multi || !this._items.displayed) {
+            return false;
+        }
+        // make sure to exclude the locked items from the list when counting
+        const displayedItems = this._items.displayed.filter(item => {
+            return this.isLocked(item) === false;
+        });
+        const nbDisplayed = displayedItems.length;
+        if (nbDisplayed < 1) {
+            return false;
+        }
+        const temp = displayedItems.filter(item => this.current.indexOf(item) > -1);
+        return temp.length === displayedItems.length;
+    }
+    /**
+     * Make sure that it could be locked
+     *
+     * @remark
+     * Check also is items.all an array, if not there is no nothing to lock or compare to
+     *
+     */
+    canItBeLocked() {
+        // We depend on the trackBy and all so there are part of the requirment of is item could be locked
+        return this._selectionType !== SelectionType.None && Array.isArray(this._items.all);
+    }
+    /**
+     * Lock and unlock item
+     */
+    lockItem(item, lock) {
+        if (this.canItBeLocked()) {
+            const ref = this._items.trackBy(this._items.all.findIndex(maybe => maybe === item), item);
+            if (lock === true) {
+                // Add to lockedRef
+                this.lockedRefs.push(ref);
+            }
+            else {
+                // Remove from lockedRef
+                this.lockedRefs = this.lockedRefs.filter(lockedItem => ref !== lockedItem);
+            }
+        }
+    }
+    /**
+     * Check is item locked or not by searcing into lockedRefs for entry
+     */
+    isLocked(item) {
+        /**
+         * The check for selectionType will boost the performence by NOT searching
+         * into the array when there is no need for that.
+         */
+        if (this.canItBeLocked()) {
+            const ref = this._items.trackBy(this._items.all.findIndex(maybe => maybe === item), item);
+            return this.lockedRefs.indexOf(ref) > -1;
+        }
+        return false;
+    }
+    /**
+     * Selects or deselects all currently displayed items
+     */
+    toggleAll() {
+        if (this._selectionType === SelectionType.None || this._selectionType === SelectionType.Single) {
+            return;
+        }
+        /**
+         * If every currently displayed item is already selected, we clear them.
+         * If at least one item isn't selected, we select every currently displayed item.
+         */
+        if (this.isAllSelected()) {
+            this._items.displayed.forEach(item => {
+                const currentIndex = this.current.indexOf(item);
+                if (currentIndex > -1 && this.isLocked(item) === false) {
+                    this.deselectItem(currentIndex);
+                }
+            });
+        }
+        else {
+            this._items.displayed.forEach(item => {
+                if (this.current.indexOf(item) < 0 && this.isLocked(item) === false) {
+                    this.selectItem(item);
+                }
+            });
+        }
+    }
+}
+Selection.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: Selection, deps: [{ token: i1.Items }, { token: i2.FiltersProvider }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+Selection.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: Selection });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: Selection, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Items }, { type: i2.FiltersProvider }, { type: i0.NgZone }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"selection.js","sourceRoot":"","sources":["../../../../../../projects/angular/src/data/datagrid/providers/selection.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.\n * This software is released under MIT license.\n * The full license information can be found in LICENSE in the root directory of this project.\n */\nimport { Injectable, TrackByFunction, NgZone } from '@angular/core';\nimport { Observable, Subject, Subscription } from 'rxjs';\n\nimport { FiltersProvider } from './filters';\nimport { Items } from './items';\nimport { SelectionType } from '../enums/selection-type';\nimport { debounceTime } from 'rxjs/operators';\n\nlet nbSelection = 0;\n\n@Injectable()\nexport class Selection<T = any> {\n  public id: string;\n  public preserveSelection = false;\n  private prevSelectionRefs: T[] = []; // Refs of selected items\n  private prevSingleSelectionRef: T; // Ref of single selected item\n  private lockedRefs: T[] = []; // Ref of locked items\n\n  constructor(private _items: Items<T>, private _filters: FiltersProvider<T>, private _zone: NgZone) {\n    this.id = 'clr-dg-selection' + nbSelection++;\n\n    this.subscriptions.push(\n      this._filters.change.subscribe(() => {\n        if (!this._selectable || this.preserveSelection) {\n          return;\n        }\n        this.clearSelection();\n      })\n    );\n\n    this.subscriptions.push(\n      this._items.allChanges.subscribe(updatedItems => {\n        // Reset the lockedRefs;\n        const updateLockedRef: T[] = [];\n\n        switch (this.selectionType) {\n          case SelectionType.None: {\n            break;\n          }\n\n          case SelectionType.Single: {\n            let newSingle: any;\n            const trackBy: TrackByFunction<T> = this._items.trackBy;\n            let selectionUpdated = false;\n\n            // if the currentSingle has been set before data was loaded, we look up and save the ref from current data set\n            if (this.currentSingle && !this.prevSingleSelectionRef) {\n              if (this._items.all && this._items.trackBy) {\n                const lookup = this._items.all.findIndex(maybe => maybe === this.currentSingle);\n                this.prevSingleSelectionRef = this._items.trackBy(lookup, this.currentSingle);\n              }\n            }\n\n            updatedItems.forEach((item, index) => {\n              const ref = trackBy(index, item);\n              // If one of the updated items is the previously selectedSingle, set it as the new one\n              if (this.prevSingleSelectionRef === ref) {\n                newSingle = item;\n                selectionUpdated = true;\n              }\n              if (this.lockedRefs.indexOf(ref) > -1) {\n                updateLockedRef.push(ref);\n              }\n            });\n\n            // If we're using smart datagrids, we expect all items to be present in the updatedItems array.\n            // Therefore, we should delete the currentSingle if it used to be defined but doesn't exist anymore.\n            // No explicit \"delete\" is required, since newSingle would be undefined at this point.\n            // Marking it as selectionUpdated here will set currentSingle to undefined below in the setTimeout.\n            if (this._items.smart && !newSingle) {\n              selectionUpdated = true;\n            }\n\n            // TODO: Discussed this with Eudes and this is fine for now.\n            // But we need to figure out a different pattern for the\n            // child triggering the parent change detection problem.\n            // Using setTimeout for now to fix this.\n            setTimeout(() => {\n              if (selectionUpdated) {\n                this.currentSingle = newSingle;\n              }\n            }, 0);\n            break;\n          }\n\n          case SelectionType.Multi: {\n            let leftOver: any[] = this.current.slice();\n            const trackBy: TrackByFunction<any> = this._items.trackBy;\n            let selectionUpdated = false;\n\n            // if the current has been set before data was loaded, we look up and save the ref from current data set\n            if (this.current.length > 0 && this.prevSelectionRefs.length !== this.current.length) {\n              if (this._items.all && this._items.trackBy) {\n                this.prevSelectionRefs = [];\n                this.current.forEach(item => {\n                  const lookup = this._items.all.findIndex(maybe => maybe === item);\n                  this.prevSelectionRefs.push(this._items.trackBy(lookup, item));\n                });\n              }\n            }\n\n            // Duplicate loop, when the issue is issue#2342 is revisited keep in mind that\n            // we need to go over every updated item and check to see if there are valid to be\n            // locked or not and update it. When only add items that are found in the lockedRefs back.\n            //\n            // The both loops below that goes over updatedItems could be combined into one.\n            updatedItems.forEach((item, index) => {\n              const ref = trackBy(index, item);\n              if (this.lockedRefs.indexOf(ref) > -1) {\n                updateLockedRef.push(ref);\n              }\n            });\n\n            // TODO: revisit this when we work on https://github.com/vmware/clarity/issues/2342\n            // currently, the selection is cleared when filter is applied, so the logic inside\n            // the if statement below results in broken behavior.\n            if (leftOver.length > 0) {\n              updatedItems.forEach((item, index) => {\n                const ref = trackBy(index, item);\n                // Look in current selected refs array if item is selected, and update actual value\n                const selectedIndex = this.prevSelectionRefs.indexOf(ref);\n                if (selectedIndex > -1) {\n                  leftOver[selectedIndex] = item;\n                  selectionUpdated = true;\n                }\n              });\n\n              // Filter out any unmatched items if we're using smart datagrids where we expect all items to be\n              // present\n              if (this._items.smart) {\n                leftOver = leftOver.filter(selected => updatedItems.indexOf(selected) > -1);\n                if (this.current.length !== leftOver.length) {\n                  selectionUpdated = true;\n                }\n              }\n\n              // TODO: Discussed this with Eudes and this is fine for now.\n              // But we need to figure out a different pattern for the\n              // child triggering the parent change detection problem.\n              // Using setTimeout for now to fix this.\n              setTimeout(() => {\n                if (selectionUpdated) {\n                  this.current = leftOver;\n                }\n              }, 0);\n            }\n            break;\n          }\n\n          default: {\n            break;\n          }\n        }\n        // Sync locked items\n        this.lockedRefs = updateLockedRef;\n      })\n    );\n\n    this.subscriptions.push(this.valueCollector.pipe(debounceTime(0)).subscribe(() => this.emitChange()));\n  }\n\n  public clearSelection(): void {\n    this._current = [];\n    this.prevSelectionRefs = [];\n    this.prevSingleSelectionRef = null;\n    this._currentSingle = null;\n    this.emitChange();\n  }\n\n  private _selectionType: SelectionType = SelectionType.None;\n  public get selectionType(): SelectionType {\n    return this._selectionType;\n  }\n  public set selectionType(value: SelectionType) {\n    if (value === this.selectionType) {\n      return;\n    }\n    this._selectionType = value;\n    if (value === SelectionType.None) {\n      delete this.current;\n    } else {\n      this.updateCurrent([], false);\n    }\n  }\n\n  /** @deprecated since 2.0, remove in 3.0 */\n  public rowSelectionMode = false;\n\n  private get _selectable(): boolean {\n    return this._selectionType === SelectionType.Multi || this._selectionType === SelectionType.Single;\n  }\n\n  /**\n   * Subscriptions to the other providers changes.\n   */\n  private subscriptions: Subscription[] = [];\n\n  /**\n   * Cleans up our subscriptions to other providers\n   */\n  public destroy() {\n    this.subscriptions.forEach(sub => sub.unsubscribe());\n  }\n\n  /**\n   * The current selection in single selection type\n   */\n  private _currentSingle: T;\n  public get currentSingle(): T {\n    return this._currentSingle;\n  }\n  public set currentSingle(value: T) {\n    if (value === this._currentSingle) {\n      return;\n    }\n\n    this._currentSingle = value;\n    if (this._items.all && this._items.trackBy && value) {\n      const lookup = this._items.all.findIndex(maybe => maybe === value);\n      this.prevSingleSelectionRef = this._items.trackBy(lookup, value);\n    }\n    this.emitChange();\n  }\n\n  /**\n   * The current selection\n   */\n  private _current: T[];\n  public get current(): T[] {\n    return this._current;\n  }\n  public set current(value: T[]) {\n    this.updateCurrent(value, true);\n  }\n\n  private valueCollector: Subject<T[]> = new Subject<T[]>();\n  public updateCurrent(value: T[], emit: boolean) {\n    this._current = value;\n\n    if (emit) {\n      this.valueCollector.next(value);\n    }\n  }\n\n  /**\n   * The Observable that lets other classes subscribe to selection changes\n   */\n  private _change = new Subject<T[] | T>();\n  private emitChange() {\n    if (this._selectionType === SelectionType.Single) {\n      this._change.next(this.currentSingle);\n    } else if (this._selectionType === SelectionType.Multi) {\n      this._change.next(this.current);\n    }\n  }\n  // We do not want to expose the Subject itself, but the Observable which is read-only\n  public get change(): Observable<T[] | T> {\n    return this._change.asObservable();\n  }\n\n  /**\n   * Checks if an item is currently selected\n   */\n  public isSelected(item: T): boolean {\n    if (this._selectionType === SelectionType.Single) {\n      return this.currentSingle === item;\n    } else if (this._selectionType === SelectionType.Multi) {\n      return this.current.indexOf(item) >= 0;\n    }\n    return false;\n  }\n\n  /**\n   * Selects an item\n   */\n  private selectItem(item: T): void {\n    this.current = this.current.concat(item);\n    if (this._items.trackBy && this._items.all) {\n      // Push selected ref onto array\n      const lookup = this._items.all.findIndex(maybe => maybe === item);\n      this.prevSelectionRefs.push(this._items.trackBy(lookup, item));\n    }\n  }\n\n  /**\n   * Deselects an item\n   */\n  private deselectItem(indexOfItem: number): void {\n    this.current = this.current.slice(0, indexOfItem).concat(this.current.slice(indexOfItem + 1));\n    if (this._items.trackBy && indexOfItem < this.prevSelectionRefs.length) {\n      // Keep selected refs array in sync\n      const removedItems = this.prevSelectionRefs.splice(indexOfItem, 1);\n      // locked reference is no longer needed (if any)\n      this.lockedRefs = this.lockedRefs.filter(locked => locked !== removedItems[0]);\n    }\n  }\n\n  /**\n   * Selects or deselects an item\n   */\n  public setSelected(item: T, selected: boolean) {\n    const index = this.current ? this.current.indexOf(item) : -1;\n\n    switch (this._selectionType) {\n      case SelectionType.None:\n        break;\n      case SelectionType.Single:\n        // in single selection, set currentSingle method should be used\n        break;\n      case SelectionType.Multi:\n        if (index >= 0 && !selected) {\n          this.deselectItem(index);\n        } else if (index < 0 && selected) {\n          this.selectItem(item);\n        }\n        break;\n      default:\n        break;\n    }\n  }\n\n  /**\n   * Checks if all currently displayed items are selected\n   */\n  public isAllSelected(): boolean {\n    if (this._selectionType !== SelectionType.Multi || !this._items.displayed) {\n      return false;\n    }\n    // make sure to exclude the locked items from the list when counting\n    const displayedItems: T[] = this._items.displayed.filter(item => {\n      return this.isLocked(item) === false;\n    });\n\n    const nbDisplayed = displayedItems.length;\n    if (nbDisplayed < 1) {\n      return false;\n    }\n    const temp: T[] = displayedItems.filter(item => this.current.indexOf(item) > -1);\n    return temp.length === displayedItems.length;\n  }\n\n  /**\n   * Make sure that it could be locked\n   *\n   * @remark\n   * Check also is items.all an array, if not there is no nothing to lock or compare to\n   *\n   */\n  private canItBeLocked(): boolean {\n    // We depend on the trackBy and all so there are part of the requirment of is item could be locked\n    return this._selectionType !== SelectionType.None && Array.isArray(this._items.all);\n  }\n\n  /**\n   * Lock and unlock item\n   */\n  public lockItem(item: T, lock: boolean) {\n    if (this.canItBeLocked()) {\n      const ref = this._items.trackBy(\n        this._items.all.findIndex(maybe => maybe === item),\n        item\n      );\n      if (lock === true) {\n        // Add to lockedRef\n        this.lockedRefs.push(ref);\n      } else {\n        // Remove from lockedRef\n        this.lockedRefs = this.lockedRefs.filter(lockedItem => ref !== lockedItem);\n      }\n    }\n  }\n\n  /**\n   * Check is item locked or not by searcing into lockedRefs for entry\n   */\n  public isLocked(item: T): boolean {\n    /**\n     * The check for selectionType will boost the performence by NOT searching\n     * into the array when there is no need for that.\n     */\n    if (this.canItBeLocked()) {\n      const ref = this._items.trackBy(\n        this._items.all.findIndex(maybe => maybe === item),\n        item\n      );\n      return this.lockedRefs.indexOf(ref) > -1;\n    }\n\n    return false;\n  }\n\n  /**\n   * Selects or deselects all currently displayed items\n   */\n  public toggleAll() {\n    if (this._selectionType === SelectionType.None || this._selectionType === SelectionType.Single) {\n      return;\n    }\n    /**\n     * If every currently displayed item is already selected, we clear them.\n     * If at least one item isn't selected, we select every currently displayed item.\n     */\n    if (this.isAllSelected()) {\n      this._items.displayed.forEach(item => {\n        const currentIndex = this.current.indexOf(item);\n        if (currentIndex > -1 && this.isLocked(item) === false) {\n          this.deselectItem(currentIndex);\n        }\n      });\n    } else {\n      this._items.displayed.forEach(item => {\n        if (this.current.indexOf(item) < 0 && this.isLocked(item) === false) {\n          this.selectItem(item);\n        }\n      });\n    }\n  }\n}\n"]}

package/esm2020/data/datagrid/providers/sort.mjs

@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./state-debouncer.provider";
+export class Sort {
+    constructor(stateDebouncer) {
+        this.stateDebouncer = stateDebouncer;
+        /**
+         * Ascending order if false, descending if true
+         */
+        this._reverse = false;
+        /**
+         * The Observable that lets other classes subscribe to sort changes
+         */
+        this._change = new Subject();
+    }
+    get comparator() {
+        return this._comparator;
+    }
+    set comparator(value) {
+        this.stateDebouncer.changeStart();
+        this._comparator = value;
+        this.emitChange();
+        this.stateDebouncer.changeDone();
+    }
+    get reverse() {
+        return this._reverse;
+    }
+    set reverse(value) {
+        this.stateDebouncer.changeStart();
+        this._reverse = value;
+        this.emitChange();
+        this.stateDebouncer.changeDone();
+    }
+    emitChange() {
+        this._change.next(this);
+    }
+    // We do not want to expose the Subject itself, but the Observable which is read-only
+    get change() {
+        return this._change.asObservable();
+    }
+    /**
+     * Sets a comparator as the current one, or toggles reverse if the comparator is already used. The
+     * optional forceReverse input parameter allows to override that toggling behavior by sorting in
+     * reverse order if `true`.
+     *
+     * @memberof Sort
+     */
+    toggle(sortBy, forceReverse) {
+        this.stateDebouncer.changeStart();
+        // We modify private properties directly, to batch the change event
+        if (this.comparator === sortBy) {
+            this._reverse = typeof forceReverse !== 'undefined' ? forceReverse || !this._reverse : !this._reverse;
+        }
+        else {
+            this._comparator = sortBy;
+            this._reverse = typeof forceReverse !== 'undefined' ? forceReverse : false;
+        }
+        this.emitChange();
+        this.stateDebouncer.changeDone();
+    }
+    /**
+     * Clears the current sorting order
+     */
+    clear() {
+        this.comparator = null;
+    }
+    /**
+     * Compares two objects according to the current comparator
+     */
+    compare(a, b) {
+        return (this.reverse ? -1 : 1) * this.comparator.compare(a, b);
+    }
+}
+Sort.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: Sort, deps: [{ token: i1.StateDebouncer }], target: i0.ɵɵFactoryTarget.Injectable });
+Sort.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: Sort });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: Sort, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.StateDebouncer }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/data/datagrid/providers/state-debouncer.provider.mjs

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/*
+ * This provider implements some form of synchronous debouncing through a lock pattern
+ * to avoid emitting multiple state changes for a single user action.
+ */
+export class StateDebouncer {
+    constructor() {
+        /**
+         * The Observable that lets other classes subscribe to global state changes
+         */
+        this._change = new Subject();
+        /*
+         * This is the lock, to only emit once all the changes have finished processing
+         */
+        this.nbChanges = 0;
+    }
+    // We do not want to expose the Subject itself, but the Observable which is read-only
+    get change() {
+        return this._change.asObservable();
+    }
+    changeStart() {
+        this.nbChanges++;
+    }
+    changeDone() {
+        if (--this.nbChanges === 0) {
+            this._change.next();
+        }
+    }
+}
+StateDebouncer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: StateDebouncer, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+StateDebouncer.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: StateDebouncer });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: StateDebouncer, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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