@progress/kendo-angular-grid 6.1.3 → 7.0.0-next.202203311511

package/esm2015/rendering/toolbar/toolbar-template.directive.js

@@ -0,0 +1,99 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Directive, Optional, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Represents the toolbar template of the Grid.
+ *
+ * The template context has the following field:
+ * - `position`—The position at which the toolbar template is rendered. The possible values are "top" and "bottom".
+ *
+ * @example
+ * ```ts-preview
+ *
+ * _@Component({
+ *     selector: 'my-app',
+ *     template: `
+ *       <div class="example-config">
+ *         <input type="radio" id="top" name="position" value="top" checked (click)="positionChange($event)"/>
+ *         <label class="k-radio-label" for="top">Top</label><br/>
+ *         <input type="radio" id="bottom" name="position" value="bottom" (click)="positionChange($event)"/>
+ *         <label class="k-radio-label" for="bottom">Bottom</label><br/>
+ *         <input type="radio" id="both" name="position" value="both" (click)="positionChange($event)"/>
+ *         <label class="k-radio-label" for="both">Both</label><br/>
+ *       </div>
+ *       <kendo-grid [data]="gridData" style="height: 200px">
+ *            <ng-template kendoGridToolbarTemplate [position]="position" let-position="position">
+ *                <button (click)="onClick()">Custom action</button>
+ *            </ng-template>
+ *            <kendo-grid-column field="ProductName">
+ *            </kendo-grid-column>
+ *            <kendo-grid-column field="UnitPrice">
+ *            </kendo-grid-column>
+ *        </kendo-grid>
+ *     `
+ * })
+ *
+ * class AppComponent {
+ *     public position: 'top' | 'bottom' | 'both' = 'top';
+ *
+ *     public gridData = [{
+ *         "ProductID": 1,
+ *         "ProductName": "Chai",
+ *         "UnitPrice": 18.0000,
+ *         "Discontinued": false
+ *       }, {
+ *         "ProductID": 2,
+ *         "ProductName": "Chang",
+ *         "UnitPrice": 19.0000,
+ *         "Discontinued": true
+ *       }
+ *     ];
+ *
+ *     public onClick(): void {
+ *         console.log("button was clicked");
+ *     }
+ *
+ *     public positionChange({ target }): void {
+ *        this.position = target.value;
+ *     }
+ * }
+ *
+ * ```
+ */
+export class ToolbarTemplateDirective {
+    constructor(templateRef) {
+        this.templateRef = templateRef;
+        this._position = "top";
+    }
+    /**
+     * The position of the toolbar ([see example]({% slug toolbartemplate_grid %})).
+     *
+     * The possible values are:
+     * - `top`&mdash;Positions the toolbar above the group panel or header.
+     * - `bottom`&mdash;Positions the toolbar below the pager.
+     * - `both`&mdash;Displays two toolbar instances. Positions the first one above
+     * the group panel or header and the second one below the pager.
+     */
+    set position(position) {
+        this._position = position;
+    }
+    get position() {
+        return this._position;
+    }
+}
+ToolbarTemplateDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ToolbarTemplateDirective, deps: [{ token: i0.TemplateRef, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+ToolbarTemplateDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: ToolbarTemplateDirective, selector: "[kendoGridToolbarTemplate]", inputs: { position: "position" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ToolbarTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[kendoGridToolbarTemplate]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { position: [{
+                type: Input,
+                args: ["position"]
+            }] } });

package/esm2015/rendering/toolbar/toolbar.component.js

@@ -0,0 +1,48 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Component, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./../../common/provider.service";
+import * as i2 from "@angular/common";
+/**
+ * @hidden
+ */
+export class ToolbarComponent {
+    constructor(providerService) {
+        this.providerService = providerService;
+        this.context = {};
+    }
+    set position(value) {
+        this.context.position = value;
+    }
+    get toolbarTemplateRef() {
+        return this.providerService.grid.toolbarTemplate ? this.providerService.grid.toolbarTemplate.templateRef : undefined;
+    }
+}
+ToolbarComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ToolbarComponent, deps: [{ token: i1.ProviderService }], target: i0.ɵɵFactoryTarget.Component });
+ToolbarComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: ToolbarComponent, selector: "kendo-grid-toolbar", inputs: { position: "position" }, ngImport: i0, template: `
+        <ng-template
+            *ngIf="toolbarTemplateRef"
+            [ngTemplateOutlet]="toolbarTemplateRef"
+            [ngTemplateOutletContext]="context"
+            >
+        </ng-template>
+    `, isInline: true, directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ToolbarComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'kendo-grid-toolbar',
+                    template: `
+        <ng-template
+            *ngIf="toolbarTemplateRef"
+            [ngTemplateOutlet]="toolbarTemplateRef"
+            [ngTemplateOutletContext]="context"
+            >
+        </ng-template>
+    `
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ProviderService }]; }, propDecorators: { position: [{
+                type: Input
+            }] } });

package/esm2015/scrolling/content-scroll-event.js

@@ -0,0 +1,5 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+export {};

package/esm2015/scrolling/row-height.service.js

@@ -0,0 +1,75 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+/**
+ * @hidden
+ */
+const update = (arr, idx, value) => ([
+    ...arr.slice(0, idx + 1),
+    ...(arr.slice(idx + 1).map(x => x + value))
+]);
+/**
+ * @hidden
+ */
+export class RowHeightService {
+    constructor(total = 0, rowHeight, detailRowHeight) {
+        this.total = total;
+        this.rowHeight = rowHeight;
+        this.detailRowHeight = detailRowHeight;
+        this.offsets = [];
+        this.heights = [];
+        let agg = 0;
+        for (let idx = 0; idx < total; idx++) {
+            this.offsets.push(agg);
+            agg += rowHeight;
+            this.heights.push(rowHeight);
+        }
+    }
+    height(rowIndex) {
+        return this.heights[rowIndex];
+    }
+    expandDetail(rowIndex) {
+        if (this.height(rowIndex) === this.rowHeight) {
+            this.updateRowHeight(rowIndex, this.detailRowHeight);
+        }
+    }
+    collapseDetail(rowIndex) {
+        if (this.height(rowIndex) > this.rowHeight) {
+            this.updateRowHeight(rowIndex, this.detailRowHeight * -1);
+        }
+    }
+    isExpanded(rowIndex) {
+        return this.height(rowIndex) > this.rowHeight;
+    }
+    index(position) {
+        if (position < 0) {
+            return undefined;
+        }
+        const result = this.offsets.reduce((prev, current, idx) => {
+            if (prev !== undefined) {
+                return prev;
+            }
+            else if (current === position) {
+                return idx;
+            }
+            else if (current > position) {
+                return idx - 1;
+            }
+            return undefined;
+        }, undefined);
+        return result === undefined ? this.total - 1 : result;
+    }
+    offset(rowIndex) {
+        return this.offsets[rowIndex];
+    }
+    totalHeight() {
+        return this.heights.reduce((prev, curr) => prev + curr, 0);
+    }
+    updateRowHeight(rowIndex, value) {
+        if (this.total > 0) {
+            this.heights[rowIndex] += value;
+            this.offsets = update(this.offsets, rowIndex, value);
+        }
+    }
+}

package/esm2015/scrolling/scroll-bottom-event.js

@@ -0,0 +1,5 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+export {};

package/esm2015/scrolling/scroll-request.service.js

@@ -0,0 +1,23 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * @hidden
+ */
+export class ScrollRequestService {
+    constructor() {
+        this.requests = new Subject();
+    }
+    scrollTo(request) {
+        this.requests.next(request);
+    }
+}
+ScrollRequestService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ScrollRequestService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ScrollRequestService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ScrollRequestService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ScrollRequestService, decorators: [{
+            type: Injectable
+        }] });

package/esm2015/scrolling/scroll-sync.service.js

@@ -0,0 +1,78 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Injectable } from '@angular/core';
+import { Subscription, Subject, fromEvent } from 'rxjs';
+import { distinctUntilChanged, filter, map, tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+/**
+ * @hidden
+ */
+export class ScrollSyncService {
+    constructor(ngZone) {
+        this.ngZone = ngZone;
+        this.changes = new Subject();
+        this.elements = [];
+        this.subscriptions = new Subscription();
+        this.headerSubscription = new Subscription();
+        this.bodySubscription = new Subscription();
+        this.subscriptions.add(this.changes.subscribe(args => this.scrollLeft(args)));
+    }
+    registerEmitter(el, sourceType) {
+        this.unregister(sourceType);
+        this.elements.push({ element: el, sourceType });
+        if (sourceType === "body" || sourceType === "header") {
+            this.ngZone.runOutsideAngular(() => {
+                const obs = fromEvent(el, "scroll").pipe(map(({ target: { scrollLeft } }) => ({
+                    scrollLeft,
+                    sourceType
+                })));
+                const subscription = obs.pipe(distinctUntilChanged((x, y) => (x.scrollLeft === y.scrollLeft)), filter(x => !this.source || this.source === x.sourceType), tap(x => this.source = x.sourceType))
+                    .subscribe((x) => this.changes.next(x));
+                subscription.add(obs.pipe(filter(x => this.source && this.source !== x.sourceType))
+                    .subscribe(() => this.source = undefined));
+                if (sourceType === "body") {
+                    this.bodySubscription.add(subscription);
+                }
+                else {
+                    this.headerSubscription.add(subscription);
+                }
+            });
+        }
+    }
+    /**
+     * destroy
+     */
+    destroy() {
+        this.subscriptions.unsubscribe();
+        this.headerSubscription.unsubscribe();
+        this.bodySubscription.unsubscribe();
+    }
+    scrollLeft({ scrollLeft, sourceType }) {
+        this.ngZone.runOutsideAngular(() => {
+            this.elements
+                .filter(x => sourceType !== x.sourceType)
+                .forEach(({ element }) => element.scrollLeft = scrollLeft);
+        });
+    }
+    unregister(sourceType) {
+        const index = this.elements.findIndex(x => x.sourceType === sourceType);
+        if (index > -1) {
+            if (sourceType === "header") {
+                this.headerSubscription.unsubscribe();
+                this.headerSubscription = new Subscription();
+            }
+            else if (sourceType === "body") {
+                this.bodySubscription.unsubscribe();
+                this.bodySubscription = new Subscription();
+            }
+            this.elements.splice(index, 1);
+        }
+    }
+}
+ScrollSyncService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ScrollSyncService, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+ScrollSyncService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ScrollSyncService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: ScrollSyncService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.NgZone }]; } });

package/esm2015/scrolling/scrollmode.js

@@ -0,0 +1,5 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+export {};

package/esm2015/scrolling/suspend.service.js

@@ -0,0 +1,19 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * @hidden
+ */
+export class SuspendService {
+    constructor() {
+        this.scroll = false;
+    }
+}
+SuspendService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SuspendService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+SuspendService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SuspendService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SuspendService, decorators: [{
+            type: Injectable
+        }] });

package/esm2015/selection/cell-selection.service.js

@@ -0,0 +1,295 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Injectable, EventEmitter } from '@angular/core';
+import { iterator } from '../utils';
+import { isPresent } from '../utils';
+import * as i0 from "@angular/core";
+import * as i1 from "../common/dom-events.service";
+import * as i2 from "../editing/local-data-changes.service";
+import * as i3 from "../navigation/navigation.service";
+/**
+ * @hidden
+ */
+export class CellSelectionService {
+    constructor(domEvents, localDataChangesService, navigationService) {
+        this.domEvents = domEvents;
+        this.localDataChangesService = localDataChangesService;
+        this.navigationService = navigationService;
+        this.changes = new EventEmitter();
+        this.mouseUpEvent = new EventEmitter();
+        this.currentSelection = [];
+        this.active = false;
+        this.dragging = false;
+        this.dragSelectDeselect = false;
+        this.lastSelectionItem = { itemKey: 0, columnKey: 0 };
+        this.lastSelectionItemRowIndex = 0;
+        this.lastSelectionItemColIndex = 0;
+        this.addSubscriptions();
+    }
+    get enableMarquee() {
+        const checkboxOnly = this.settings && typeof this.settings === 'object' && this.settings.checkboxOnly;
+        if (!this.settings || checkboxOnly) {
+            return false;
+        }
+        const selectableSettings = this.settings.selectable;
+        const dragAndMultiple = typeof (selectableSettings) === 'object' &&
+            isPresent(selectableSettings) &&
+            selectableSettings.mode === 'multiple' &&
+            selectableSettings.cell &&
+            selectableSettings.enabled !== false &&
+            selectableSettings.drag;
+        return this.active && dragAndMultiple;
+    }
+    init(settings) {
+        this.settings = settings;
+        this.currentSelection = [];
+        if (settings.selectable && settings.selectable.enabled !== false) {
+            const iterator = this.getIterator();
+            let item = iterator.next();
+            while (!item.done) {
+                if (item.value && item.value.type === "data") {
+                    const rowArgs = {
+                        dataItem: item.value.data,
+                        index: item.value.index
+                    };
+                    settings.columns.forEach(col => {
+                        const selectedCellArgs = settings.cellSelected(rowArgs, col, col.leafIndex);
+                        if (selectedCellArgs.selected) {
+                            this.currentSelection.push(selectedCellArgs.item);
+                        }
+                    });
+                }
+                item = iterator.next();
+            }
+        }
+    }
+    isCellSelected(item, col) {
+        if (this.settings && this.active) {
+            const selectedCellArgs = this.settings.cellSelected({ dataItem: item.data, index: item.index }, col, col.leafIndex);
+            return this.options.enabled && selectedCellArgs.selected;
+        }
+        return false;
+    }
+    handleClick(item, event) {
+        if (this.dragging) {
+            this.dragging = false;
+            return;
+        }
+        let ev;
+        const ctrlKey = event.ctrlKey || event.metaKey;
+        if (this.options.mode === "single" && ctrlKey && this.isCellSelected(item, item.column)) {
+            ev = this.toggle(item);
+        }
+        else if (this.options.mode === "multiple") {
+            if (ctrlKey && !event.shiftKey) {
+                ev = this.toggle(item);
+            }
+            else if (event.shiftKey) {
+                const startRowIndex = Math.min(this.lastSelectionItemRowIndex, item.index);
+                const startColIndex = Math.min(this.lastSelectionItemColIndex, item.column.leafIndex);
+                const endRowIndex = Math.max(this.lastSelectionItemRowIndex, item.index);
+                const endColIndex = Math.max(this.lastSelectionItemColIndex, item.column.leafIndex);
+                ev = this.selectRange(startRowIndex, startColIndex, endRowIndex, endColIndex);
+            }
+        }
+        if (!isPresent(ev)) {
+            ev = this.select(item);
+            this.currentSelection = [this.lastSelectionItem];
+        }
+        if (!ev.selectedCells.length && !ev.deselectedCells.length) {
+            return;
+        }
+        ev.ctrlKey = ctrlKey;
+        ev.shiftKey = event.shiftKey;
+        this.changes.emit(ev);
+    }
+    toggle(item) {
+        let selectedCells = [];
+        let deselectedCells = [];
+        this.lastSelectionItem =
+            this.settings.cellSelected({ dataItem: item.data, index: item.index }, item.column, item.column.leafIndex).item;
+        this.lastSelectionItemRowIndex = item.index;
+        this.lastSelectionItemColIndex = item.column.leafIndex;
+        if (this.isCellSelected(item, item.column)) {
+            deselectedCells.push(this.lastSelectionItem);
+        }
+        else {
+            selectedCells.push(this.lastSelectionItem);
+        }
+        return {
+            deselectedCells,
+            selectedCells
+        };
+    }
+    select(item) {
+        const selectedCells = [];
+        const deselectedCells = [];
+        this.lastSelectionItem =
+            this.settings.cellSelected({ dataItem: item.data, index: item.index }, item.column, item.column.leafIndex).item;
+        this.lastSelectionItemRowIndex = item.index;
+        this.lastSelectionItemColIndex = item.column.leafIndex;
+        if (!this.isCellSelected(item, item.column)) {
+            selectedCells.push(this.lastSelectionItem);
+        }
+        this.currentSelection.forEach((selectedItem) => {
+            if (selectedItem.itemKey !== this.lastSelectionItem.itemKey || selectedItem.columnKey !== this.lastSelectionItem.columnKey) {
+                deselectedCells.push(selectedItem);
+            }
+        });
+        return {
+            deselectedCells,
+            selectedCells
+        };
+    }
+    //Used to manually deselect removed items
+    deselect(removedItem) {
+        const iterator = this.getIterator();
+        let item = iterator.next();
+        let rowArgs;
+        while (!item.done) {
+            if (item.value && item.value.type === "data" && item.value.data === removedItem) {
+                rowArgs = {
+                    dataItem: item.value.data,
+                    index: item.value.index
+                };
+                break;
+            }
+            item = iterator.next();
+        }
+        if (rowArgs) {
+            const cellsToRemove = this.currentSelection.filter(selectedItem => {
+                const contender = this.settings.cellSelected(rowArgs, null, null).item;
+                return selectedItem.itemKey === contender.itemKey;
+            });
+            if (cellsToRemove.length) {
+                let ev = {
+                    ctrlKey: false,
+                    deselectedCells: cellsToRemove,
+                    selectedCells: []
+                };
+                this.changes.emit(ev);
+            }
+        }
+    }
+    selectRange(startRowIndex, startColIndex, endRowIndex, endColIndex) {
+        const selectedCells = [];
+        const deselectedCells = [];
+        const selectionStartRow = Math.min(startRowIndex, endRowIndex);
+        const selectionStartCol = Math.min(startColIndex, endColIndex);
+        const selectionEndRow = Math.max(startRowIndex, endRowIndex);
+        const selectionEndCol = Math.max(startColIndex, endColIndex);
+        const iterator = this.getIterator();
+        let next = iterator.next();
+        while (!next.done) {
+            if (next.value && next.value.type === "data") {
+                const idx = next.value.index;
+                const data = next.value.data;
+                const rowArgs = {
+                    dataItem: data,
+                    index: idx
+                };
+                this.settings.columns.forEach(col => {
+                    const { item } = this.settings.cellSelected(rowArgs, col, col.leafIndex);
+                    const selected = this.isCellSelected(next.value, col);
+                    const isInRowRange = selectionStartRow <= idx && idx <= selectionEndRow;
+                    const isInColRange = selectionStartCol <= col.leafIndex && col.leafIndex <= selectionEndCol;
+                    const isInSelectionRect = isInRowRange && isInColRange;
+                    if (!isInSelectionRect && selected) {
+                        deselectedCells.push(item);
+                    }
+                    if (isInSelectionRect && !selected) {
+                        selectedCells.push(item);
+                    }
+                });
+            }
+            next = iterator.next();
+        }
+        return {
+            deselectedCells,
+            selectedCells
+        };
+    }
+    get options() {
+        const defaultOptions = {
+            checkboxOnly: false,
+            enabled: true,
+            mode: "multiple"
+        };
+        if (!isPresent(this.settings)) {
+            return defaultOptions;
+        }
+        if (typeof this.settings.selectable === 'boolean') {
+            return {
+                checkboxOnly: false,
+                enabled: this.settings.selectable,
+                mode: "multiple"
+            };
+        }
+        else {
+            return Object.assign(defaultOptions, this.settings.selectable);
+        }
+    }
+    ngOnDestroy() {
+        this.removeSubscriptions();
+    }
+    addSubscriptions() {
+        if (!this.cellClickSubscription) {
+            this.cellClickSubscription = this.domEvents.cellClick.subscribe((args) => {
+                if (this.options.enabled && !this.options.checkboxOnly && args.type !== 'contextmenu') {
+                    if (this.active) {
+                        this.handleClick({ index: args.rowIndex, data: args.dataItem, column: args.column }, args.originalEvent);
+                    }
+                }
+            });
+        }
+        if (!this.mousedownSubscription) {
+            this.mousedownSubscription = this.domEvents.cellMousedown.subscribe((args) => {
+                this.mouseDownEventArgs = args;
+                if (this.options.enabled && (!this.options.mode || this.options.mode === "multiple") &&
+                    !this.options.checkboxOnly && args.originalEvent.shiftKey) {
+                    if (this.active) {
+                        args.originalEvent.preventDefault();
+                        this.navigationService.focusCellByElement(args.originalEvent.target);
+                    }
+                }
+            });
+        }
+        if (this.localDataChangesService && !this.dataChangedSubscription) {
+            this.dataChangedSubscription = this.localDataChangesService.changes.subscribe((args) => {
+                if (this.active) {
+                    if (isPresent(args.action) && args.action === 'remove') {
+                        this.deselect(args.item);
+                    }
+                }
+            });
+        }
+    }
+    getIterator() {
+        const accessor = this.settings.view.accessor();
+        if (!accessor) {
+            return;
+        }
+        return accessor[iterator]();
+    }
+    removeSubscriptions() {
+        if (this.cellClickSubscription) {
+            this.cellClickSubscription.unsubscribe();
+            this.cellClickSubscription = null;
+        }
+        if (this.mousedownSubscription) {
+            this.mousedownSubscription.unsubscribe();
+            this.mousedownSubscription = null;
+        }
+        if (this.dataChangedSubscription) {
+            this.dataChangedSubscription.unsubscribe();
+            this.dataChangedSubscription = null;
+        }
+    }
+}
+CellSelectionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: CellSelectionService, deps: [{ token: i1.DomEventsService }, { token: i2.LocalDataChangesService }, { token: i3.NavigationService }], target: i0.ɵɵFactoryTarget.Injectable });
+CellSelectionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: CellSelectionService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: CellSelectionService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.DomEventsService }, { type: i2.LocalDataChangesService }, { type: i3.NavigationService }]; } });