@clr/angular
Version:
Angular components for Clarity
360 lines • 45.3 kB
JavaScript
/*
* Copyright (c) 2016-2025 Broadcom. All Rights Reserved.
* The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries.
* 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 { debounceTime } from 'rxjs/operators';
import { SelectionType } from '../enums/selection-type';
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) {
this._items = _items;
this.preserveSelection = false;
/**
* Shift key state, for use in range selection.
*/
this.shiftPressed = false;
/** @deprecated since 2.0, remove in 3.0 */
this.rowSelectionMode = false;
this.prevSelectionRefs = []; // Refs of selected items
this.lockedRefs = []; // Ref of locked items
this.valueCollector = new Subject();
this._selectionType = SelectionType.None;
/**
* The Observable that lets other classes subscribe to selection changes
*/
this._change = new Subject();
/**
* Subscriptions to the other providers changes.
*/
this.subscriptions = [];
this.id = 'clr-dg-selection' + nbSelection++;
this.subscriptions.push(filters.change.subscribe(() => {
if (!this._selectable || this.preserveSelection) {
return;
}
this.clearSelection();
}));
this.subscriptions.push(_items.allChanges.subscribe(updatedItems => {
// Reset the lockedRefs;
const updateLockedRef = [];
switch (this.selectionType) {
case SelectionType.None: {
break;
}
case SelectionType.Single: {
let newSingle;
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) {
this.prevSingleSelectionRef = _items.trackBy(this.currentSingle);
}
updatedItems.forEach(item => {
const ref = _items.trackBy(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 (_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();
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) {
this.prevSelectionRefs = [];
this.current.forEach(item => {
this.prevSelectionRefs.push(_items.trackBy(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 => {
const ref = _items.trackBy(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 => {
const ref = _items.trackBy(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 (_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()));
}
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 current() {
return this._current;
}
set current(value) {
this.updateCurrent(value, true);
}
get currentSingle() {
return this._currentSingle;
}
set currentSingle(value) {
if (value === this._currentSingle) {
return;
}
this._currentSingle = value;
if (value) {
this.prevSingleSelectionRef = this._items.trackBy(value);
}
this.emitChange();
}
// We do not want to expose the Subject itself, but the Observable which is read-only
get change() {
return this._change.asObservable();
}
get _selectable() {
return this._selectionType === SelectionType.Multi || this._selectionType === SelectionType.Single;
}
clearSelection() {
this._current = [];
this.prevSelectionRefs = [];
this.prevSingleSelectionRef = null;
this._currentSingle = null;
this.emitChange();
}
/**
* Cleans up our subscriptions to other providers
*/
destroy() {
this.subscriptions.forEach(sub => sub.unsubscribe());
}
updateCurrent(value, emit) {
this._current = value;
if (emit) {
this.valueCollector.next(value);
}
}
/**
* 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 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;
}
/**
* Lock and unlock item
*/
lockItem(item, lock) {
if (this.canItBeLocked()) {
const ref = this._items.trackBy(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 searching into lockedRefs for entry
*/
isLocked(item) {
/**
* The check for selectionType will boost the performance by NOT searching
* into the array when there is no need for that.
*/
if (this.canItBeLocked()) {
const ref = this._items.trackBy(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);
}
});
}
}
/**
* Selects an item
*/
selectItem(item) {
this.current = this.current.concat(item);
// Push selected ref onto array
this.prevSelectionRefs.push(this._items.trackBy(item));
}
/**
* Deselects an item
*/
deselectItem(indexOfItem) {
this.current = this.current.slice(0, indexOfItem).concat(this.current.slice(indexOfItem + 1));
if (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]);
}
}
/**
* Make sure that it could be locked
*/
canItBeLocked() {
return this._selectionType !== SelectionType.None;
}
emitChange() {
if (this._selectionType === SelectionType.Single) {
this._change.next(this.currentSingle);
}
else if (this._selectionType === SelectionType.Multi) {
this._change.next(this.current);
}
}
}
Selection.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: Selection, deps: [{ token: i1.Items }, { token: i2.FiltersProvider }], target: i0.ɵɵFactoryTarget.Injectable });
Selection.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: Selection });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.2", ngImport: i0, type: Selection, decorators: [{
type: Injectable
}], ctorParameters: function () { return [{ type: i1.Items }, { type: i2.FiltersProvider }]; } });
//# 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-2025 Broadcom. All Rights Reserved.\n * The term \"Broadcom\" refers to Broadcom Inc. and/or its subsidiaries.\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 */\n\nimport { Injectable } from '@angular/core';\nimport { Observable, Subject, Subscription } from 'rxjs';\nimport { debounceTime } from 'rxjs/operators';\n\nimport { SelectionType } from '../enums/selection-type';\nimport { FiltersProvider } from './filters';\nimport { Items } from './items';\n\nlet nbSelection = 0;\n\n@Injectable()\nexport class Selection<T = any> {\n  id: string;\n  preserveSelection = false;\n\n  /**\n   * Last selection, for use in range selection.\n   */\n  rangeStart: T;\n\n  /**\n   * Shift key state, for use in range selection.\n   */\n  shiftPressed = false;\n\n  /** @deprecated since 2.0, remove in 3.0 */\n  rowSelectionMode = false;\n\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  private valueCollector = new Subject<T[]>();\n  private _selectionType: SelectionType = SelectionType.None;\n\n  /**\n   * The current selection\n   */\n  private _current: T[];\n\n  /**\n   * The current selection in single selection type\n   */\n  private _currentSingle: T;\n\n  /**\n   * The Observable that lets other classes subscribe to selection changes\n   */\n  private _change = new Subject<T[] | T>();\n\n  /**\n   * Subscriptions to the other providers changes.\n   */\n  private subscriptions: Subscription[] = [];\n\n  constructor(private _items: Items<T>, filters: FiltersProvider<T>) {\n    this.id = 'clr-dg-selection' + nbSelection++;\n\n    this.subscriptions.push(\n      filters.change.subscribe(() => {\n        if (!this._selectable || this.preserveSelection) {\n          return;\n        }\n        this.clearSelection();\n      })\n    );\n\n    this.subscriptions.push(\n      _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            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              this.prevSingleSelectionRef = _items.trackBy(this.currentSingle);\n            }\n\n            updatedItems.forEach(item => {\n              const ref = _items.trackBy(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 (_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            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              this.prevSelectionRefs = [];\n              this.current.forEach(item => {\n                this.prevSelectionRefs.push(_items.trackBy(item));\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 => {\n              const ref = _items.trackBy(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 => {\n                const ref = _items.trackBy(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 (_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  get selectionType(): SelectionType {\n    return this._selectionType;\n  }\n  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  get current(): T[] {\n    return this._current;\n  }\n  set current(value: T[]) {\n    this.updateCurrent(value, true);\n  }\n\n  get currentSingle(): T {\n    return this._currentSingle;\n  }\n  set currentSingle(value: T) {\n    if (value === this._currentSingle) {\n      return;\n    }\n\n    this._currentSingle = value;\n    if (value) {\n      this.prevSingleSelectionRef = this._items.trackBy(value);\n    }\n    this.emitChange();\n  }\n\n  // We do not want to expose the Subject itself, but the Observable which is read-only\n  get change(): Observable<T[] | T> {\n    return this._change.asObservable();\n  }\n\n  private get _selectable(): boolean {\n    return this._selectionType === SelectionType.Multi || this._selectionType === SelectionType.Single;\n  }\n\n  clearSelection(): void {\n    this._current = [];\n    this.prevSelectionRefs = [];\n    this.prevSingleSelectionRef = null;\n    this._currentSingle = null;\n    this.emitChange();\n  }\n\n  /**\n   * Cleans up our subscriptions to other providers\n   */\n  destroy() {\n    this.subscriptions.forEach(sub => sub.unsubscribe());\n  }\n\n  updateCurrent(value: T[], emit: boolean) {\n    this._current = value;\n\n    if (emit) {\n      this.valueCollector.next(value);\n    }\n  }\n\n  /**\n   * Checks if an item is currently selected\n   */\n  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 or deselects an item\n   */\n  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  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   * Lock and unlock item\n   */\n  lockItem(item: T, lock: boolean) {\n    if (this.canItBeLocked()) {\n      const ref = this._items.trackBy(item);\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 searching into lockedRefs for entry\n   */\n  isLocked(item: T): boolean {\n    /**\n     * The check for selectionType will boost the performance 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(item);\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  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  /**\n   * Selects an item\n   */\n  private selectItem(item: T): void {\n    this.current = this.current.concat(item);\n    // Push selected ref onto array\n    this.prevSelectionRefs.push(this._items.trackBy(item));\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 (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   * Make sure that it could be locked\n   */\n  private canItBeLocked(): boolean {\n    return this._selectionType !== SelectionType.None;\n  }\n\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}\n"]}