@progress/kendo-angular-grid 7.0.0-dev.202201261657 → 7.0.0-next.202204010918

package/dist/es/selection/cell-selection.service.js

@@ -1,318 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
-import { Injectable, EventEmitter } from '@angular/core';
-import { iterator } from '../utils';
-import { isPresent } from '../utils';
-import { DomEventsService } from '../common/dom-events.service';
-import { LocalDataChangesService } from '../editing/local-data-changes.service';
-import { NavigationService } from '../navigation/navigation.service';
-/**
- * @hidden
- */
-var CellSelectionService = /** @class */ (function () {
-    function CellSelectionService(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();
-    }
-    Object.defineProperty(CellSelectionService.prototype, "enableMarquee", {
-        get: function () {
-            var checkboxOnly = this.settings && typeof this.settings === 'object' && this.settings.checkboxOnly;
-            if (!this.settings || checkboxOnly) {
-                return false;
-            }
-            var selectableSettings = this.settings.selectable;
-            var dragAndMultiple = typeof (selectableSettings) === 'object' &&
-                isPresent(selectableSettings) &&
-                selectableSettings.mode === 'multiple' &&
-                selectableSettings.cell &&
-                selectableSettings.enabled !== false &&
-                selectableSettings.drag;
-            return this.active && dragAndMultiple;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    CellSelectionService.prototype.init = function (settings) {
-        var _this = this;
-        this.settings = settings;
-        this.currentSelection = [];
-        if (settings.selectable && settings.selectable.enabled !== false) {
-            var iterator_1 = this.getIterator();
-            var item = iterator_1.next();
-            var _loop_1 = function () {
-                if (item.value && item.value.type === "data") {
-                    var rowArgs_1 = {
-                        dataItem: item.value.data,
-                        index: item.value.index
-                    };
-                    settings.columns.forEach(function (col) {
-                        var selectedCellArgs = settings.cellSelected(rowArgs_1, col, col.leafIndex);
-                        if (selectedCellArgs.selected) {
-                            _this.currentSelection.push(selectedCellArgs.item);
-                        }
-                    });
-                }
-                item = iterator_1.next();
-            };
-            while (!item.done) {
-                _loop_1();
-            }
-        }
-    };
-    CellSelectionService.prototype.isCellSelected = function (item, col) {
-        if (this.settings && this.active) {
-            var selectedCellArgs = this.settings.cellSelected({ dataItem: item.data, index: item.index }, col, col.leafIndex);
-            return this.options.enabled && selectedCellArgs.selected;
-        }
-        return false;
-    };
-    CellSelectionService.prototype.handleClick = function (item, event) {
-        if (this.dragging) {
-            this.dragging = false;
-            return;
-        }
-        var ev;
-        var 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) {
-                var startRowIndex = Math.min(this.lastSelectionItemRowIndex, item.index);
-                var startColIndex = Math.min(this.lastSelectionItemColIndex, item.column.leafIndex);
-                var endRowIndex = Math.max(this.lastSelectionItemRowIndex, item.index);
-                var 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);
-    };
-    CellSelectionService.prototype.toggle = function (item) {
-        var selectedCells = [];
-        var 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: deselectedCells,
-            selectedCells: selectedCells
-        };
-    };
-    CellSelectionService.prototype.select = function (item) {
-        var _this = this;
-        var selectedCells = [];
-        var 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(function (selectedItem) {
-            if (selectedItem.itemKey !== _this.lastSelectionItem.itemKey || selectedItem.columnKey !== _this.lastSelectionItem.columnKey) {
-                deselectedCells.push(selectedItem);
-            }
-        });
-        return {
-            deselectedCells: deselectedCells,
-            selectedCells: selectedCells
-        };
-    };
-    //Used to manually deselect removed items
-    CellSelectionService.prototype.deselect = function (removedItem) {
-        var _this = this;
-        var iterator = this.getIterator();
-        var item = iterator.next();
-        var 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) {
-            var cellsToRemove = this.currentSelection.filter(function (selectedItem) {
-                var contender = _this.settings.cellSelected(rowArgs, null, null).item;
-                return selectedItem.itemKey === contender.itemKey;
-            });
-            if (cellsToRemove.length) {
-                var ev = {
-                    ctrlKey: false,
-                    deselectedCells: cellsToRemove,
-                    selectedCells: []
-                };
-                this.changes.emit(ev);
-            }
-        }
-    };
-    CellSelectionService.prototype.selectRange = function (startRowIndex, startColIndex, endRowIndex, endColIndex) {
-        var _this = this;
-        var selectedCells = [];
-        var deselectedCells = [];
-        var selectionStartRow = Math.min(startRowIndex, endRowIndex);
-        var selectionStartCol = Math.min(startColIndex, endColIndex);
-        var selectionEndRow = Math.max(startRowIndex, endRowIndex);
-        var selectionEndCol = Math.max(startColIndex, endColIndex);
-        var iterator = this.getIterator();
-        var next = iterator.next();
-        var _loop_2 = function () {
-            if (next.value && next.value.type === "data") {
-                var idx_1 = next.value.index;
-                var data = next.value.data;
-                var rowArgs_2 = {
-                    dataItem: data,
-                    index: idx_1
-                };
-                this_1.settings.columns.forEach(function (col) {
-                    var item = _this.settings.cellSelected(rowArgs_2, col, col.leafIndex).item;
-                    var selected = _this.isCellSelected(next.value, col);
-                    var isInRowRange = selectionStartRow <= idx_1 && idx_1 <= selectionEndRow;
-                    var isInColRange = selectionStartCol <= col.leafIndex && col.leafIndex <= selectionEndCol;
-                    var isInSelectionRect = isInRowRange && isInColRange;
-                    if (!isInSelectionRect && selected) {
-                        deselectedCells.push(item);
-                    }
-                    if (isInSelectionRect && !selected) {
-                        selectedCells.push(item);
-                    }
-                });
-            }
-            next = iterator.next();
-        };
-        var this_1 = this;
-        while (!next.done) {
-            _loop_2();
-        }
-        return {
-            deselectedCells: deselectedCells,
-            selectedCells: selectedCells
-        };
-    };
-    Object.defineProperty(CellSelectionService.prototype, "options", {
-        get: function () {
-            var 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);
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    CellSelectionService.prototype.ngOnDestroy = function () {
-        this.removeSubscriptions();
-    };
-    CellSelectionService.prototype.addSubscriptions = function () {
-        var _this = this;
-        if (!this.cellClickSubscription) {
-            this.cellClickSubscription = this.domEvents.cellClick.subscribe(function (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(function (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(function (args) {
-                if (_this.active) {
-                    if (isPresent(args.action) && args.action === 'remove') {
-                        _this.deselect(args.item);
-                    }
-                }
-            });
-        }
-    };
-    CellSelectionService.prototype.getIterator = function () {
-        var accessor = this.settings.view.accessor();
-        if (!accessor) {
-            return;
-        }
-        return accessor[iterator]();
-    };
-    CellSelectionService.prototype.removeSubscriptions = function () {
-        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 = tslib_1.__decorate([
-        Injectable(),
-        tslib_1.__metadata("design:paramtypes", [DomEventsService,
-            LocalDataChangesService,
-            NavigationService])
-    ], CellSelectionService);
-    return CellSelectionService;
-}());
-export { CellSelectionService };

package/dist/es/selection/marquee.directive.js

@@ -1,180 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
-import { DomEventsService } from './../common/dom-events.service';
-import { Directive, HostBinding } from '@angular/core';
-import { DraggableDirective } from '@progress/kendo-angular-common';
-import { SelectionService } from './selection.service';
-import { CellSelectionService } from './cell-selection.service';
-import { take, delay } from 'rxjs/operators';
-import { merge } from 'rxjs';
-var createElement = function () {
-    var marquee = document.createElement("div");
-    marquee.className = "k-marquee";
-    var marqueeColor = document.createElement("div");
-    marqueeColor.className = "k-marquee-color";
-    marquee.appendChild(marqueeColor);
-    return marquee;
-};
-var ɵ0 = createElement;
-var POINTER_OFFSET = 2;
-var MINIMAL_DRAG_DISTANCE = 5;
-var offsets = {
-    topLeft: { x: POINTER_OFFSET, y: POINTER_OFFSET },
-    topRight: { x: -POINTER_OFFSET, y: POINTER_OFFSET },
-    bottomLeft: { x: POINTER_OFFSET, y: -POINTER_OFFSET },
-    bottomRight: { x: -POINTER_OFFSET, y: -POINTER_OFFSET }
-};
-/**
- * @hidden
- */
-var GridMarqueeDirective = /** @class */ (function () {
-    function GridMarqueeDirective(draggable, selection, cellSelection, domEvents) {
-        this.draggable = draggable;
-        this.selection = selection;
-        this.cellSelection = cellSelection;
-        this.domEvents = domEvents;
-        this.selectionStarted = false;
-    }
-    Object.defineProperty(GridMarqueeDirective.prototype, "webkitUserSelection", {
-        get: function () {
-            return (this.cellSelection.enableMarquee || this.selection.enableMarquee) ? 'none' : null;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(GridMarqueeDirective.prototype, "userSelection", {
-        get: function () {
-            return (this.cellSelection.enableMarquee || this.selection.enableMarquee);
-        },
-        enumerable: true,
-        configurable: true
-    });
-    GridMarqueeDirective.prototype.ngOnInit = function () {
-        this.subscriptions = (this.draggable.kendoPress.subscribe(this.start.bind(this)));
-        this.subscriptions.add(this.draggable.kendoDrag.subscribe(this.moveMarquee.bind(this)));
-    };
-    GridMarqueeDirective.prototype.ngOnDestroy = function () {
-        this.subscriptions.unsubscribe();
-        this.clean();
-    };
-    GridMarqueeDirective.prototype.start = function (args) {
-        if (args.originalEvent.target.classList.contains('k-checkbox')) {
-            this.pressArgs = null;
-            return;
-        }
-        this.pressArgs = args;
-        this.pressTarget = null;
-    };
-    GridMarqueeDirective.prototype.moveMarquee = function (args) {
-        if (!this.pressTarget) {
-            this.pressTarget = this.cellSelection.active ? this.cellSelection.mouseDownEventArgs : this.selection.mouseDownEventArgs;
-        }
-        var press = this.pressArgs;
-        if (!press) {
-            return;
-        }
-        if (!this.selectionStarted) {
-            var distance = Math.sqrt(Math.pow((args.pageX - press.pageX), 2) + Math.pow((args.pageY - press.pageY), 2));
-            if (distance > MINIMAL_DRAG_DISTANCE) {
-                this.selectionStarted = true;
-                this.dragEndSubscription = merge(this.domEvents.cellMouseup.pipe(take(1)), this.draggable.kendoRelease.pipe(delay(1), take(1)))
-                    .subscribe(this.endSelection.bind(this));
-            }
-            else {
-                return;
-            }
-        }
-        this.initMarquee();
-        var element = this.marqueeElement;
-        var marqueeQuadrant = this.getMarqueeQuadrant(args.pageX, args.pageY, press.pageX, press.pageY);
-        var left = Math.min(args.pageX, press.pageX);
-        var top = Math.min(args.pageY, press.pageY);
-        var width = Math.abs(args.pageX - press.pageX);
-        var height = Math.abs(args.pageY - press.pageY);
-        if (marqueeQuadrant) {
-            left += offsets[marqueeQuadrant].x;
-            top += offsets[marqueeQuadrant].y;
-        }
-        element.style.left = left + "px";
-        element.style.top = top + "px";
-        element.style.width = width + "px";
-        element.style.height = height + "px";
-    };
-    GridMarqueeDirective.prototype.endSelection = function (args) {
-        if (args.type === 'mouseup' || args.type === 'touchend') {
-            if (this.cellSelection.active) {
-                this.cellSelection.dragging = true;
-                this.cellSelection.changes.emit(this.cellSelection.selectRange(this.pressTarget.rowIndex, this.pressTarget.column.leafIndex, args.rowIndex, args.column.leafIndex));
-            }
-            else if (this.selection.active) {
-                this.selection.dragging = true;
-                this.selection.changes.emit(this.selection.selectRange(this.pressTarget.rowIndex, args.rowIndex));
-            }
-        }
-        this.clean();
-    };
-    GridMarqueeDirective.prototype.clean = function () {
-        if (this.marqueeElement) {
-            document.body.removeChild(this.marqueeElement);
-            this.marqueeElement = null;
-        }
-        if (this.dragEndSubscription) {
-            this.dragEndSubscription.unsubscribe();
-        }
-        this.dragEndSubscription = null;
-        this.pressTarget = null;
-        this.pressArgs = null;
-        this.selectionStarted = false;
-        this.cellSelection.active ? this.cellSelection.dragging = false : this.selection.dragging = false;
-    };
-    GridMarqueeDirective.prototype.initMarquee = function () {
-        if (!this.marqueeElement) {
-            this.marqueeElement = createElement();
-            document.body.appendChild(this.marqueeElement);
-        }
-    };
-    GridMarqueeDirective.prototype.getMarqueeQuadrant = function (pointerX, pointerY, startX, startY) {
-        var leftHalf = pointerX < startX;
-        var rightHalf = pointerX > startX;
-        var topHalf = pointerY < startY;
-        var bottomHalf = pointerY > startY;
-        if (leftHalf && topHalf) {
-            return 'topLeft';
-        }
-        if (leftHalf && bottomHalf) {
-            return 'bottomLeft';
-        }
-        if (rightHalf && topHalf) {
-            return 'topRight';
-        }
-        if (rightHalf && bottomHalf) {
-            return 'bottomRight';
-        }
-        return null;
-    };
-    tslib_1.__decorate([
-        HostBinding('style.-webkit-user-select'),
-        tslib_1.__metadata("design:type", String),
-        tslib_1.__metadata("design:paramtypes", [])
-    ], GridMarqueeDirective.prototype, "webkitUserSelection", null);
-    tslib_1.__decorate([
-        HostBinding('class.user-select-none'),
-        tslib_1.__metadata("design:type", Boolean),
-        tslib_1.__metadata("design:paramtypes", [])
-    ], GridMarqueeDirective.prototype, "userSelection", null);
-    GridMarqueeDirective = tslib_1.__decorate([
-        Directive({
-            selector: '[kendoGridSelectionMarquee]'
-        }),
-        tslib_1.__metadata("design:paramtypes", [DraggableDirective,
-            SelectionService,
-            CellSelectionService,
-            DomEventsService])
-    ], GridMarqueeDirective);
-    return GridMarqueeDirective;
-}());
-export { GridMarqueeDirective };
-export { ɵ0 };

package/dist/es/selection/pair-set.js

@@ -1,91 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-/**
- * @hidden
- *
- * Quick look-up structure for combinations of keys.
- * Similar to the native JS Set, however, working with a couple of keys instead of with a single key.
- * Supports both primitive keys and object keys (compared by reference).
- */
-var PairSet = /** @class */ (function () {
-    function PairSet(items, keyXField, keyYField) {
-        var _this = this;
-        /**
-         * Holds a set of Y keys for each defined X key.
-         * Each X key creates a map which holds a set of Y keys.
-         *
-         * Map { 1 => Set { 1, 2, 3 } } // pairs: [1, 1], [1, 2], [1, 3]
-         */
-        this.keysX = new Map();
-        /**
-         * Count the each added or deleted key manually to avoid iterating over all items when calling `this.size`.
-         */
-        this.totalKeysCount = 0;
-        if (items && keyXField && keyYField) {
-            items.forEach(function (item) { return _this.add(item[keyXField], item[keyYField]); });
-        }
-    }
-    Object.defineProperty(PairSet.prototype, "size", {
-        /**
-         * Gets the total number of X/Y key pairs.
-         */
-        get: function () {
-            return this.totalKeysCount;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    /**
-     * Adds a couple of items identified as a combination.
-     */
-    PairSet.prototype.add = function (keyX, keyY) {
-        if (!this.keysX.has(keyX)) {
-            this.keysX.set(keyX, new Set());
-        }
-        if (!this.has(keyX, keyY)) {
-            this.keysX.get(keyX).add(keyY);
-            this.totalKeysCount += 1;
-        }
-    };
-    /**
-     * Adds a combination of a couple of items identified together.
-     */
-    PairSet.prototype.delete = function (keyX, keyY) {
-        if (this.has(keyX, keyY)) {
-            this.keysX.get(keyX).delete(keyY);
-            this.totalKeysCount -= 1;
-        }
-    };
-    /**
-     * Checks whether the defined combination is stored.
-     */
-    PairSet.prototype.has = function (keyX, keyY) {
-        return this.keysX.has(keyX) && this.keysX.get(keyX).has(keyY);
-    };
-    /**
-     * Clears all key combinations.
-     */
-    PairSet.prototype.clear = function () {
-        this.keysX.clear();
-        this.totalKeysCount = 0;
-    };
-    /**
-     * Converts the persisted data structure to an array of objects,
-     * using the provided field names for the object props.
-     */
-    PairSet.prototype.toArray = function (keyXField, keyYField) {
-        return Array.from(this.keysX).reduce(function (pairs, pair) {
-            // Array.from(mapInstance) returns an array of arrays [[itemKey1, columnKeysSet1], [itemKey2, columnKeysSet2]]
-            var keyX = pair[0], keysY = pair[1];
-            Array.from(keysY).forEach(function (keyY) {
-                var _a;
-                return pairs.push((_a = {}, _a[keyXField] = keyX, _a[keyYField] = keyY, _a));
-            });
-            return pairs;
-        }, []);
-    };
-    return PairSet;
-}());
-export { PairSet };

package/dist/es/selection/selectall-checkbox.directive.js

@@ -1,103 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import * as tslib_1 from "tslib";
-import { detectIE } from './../utils';
-import { Directive, HostBinding, Renderer2, ElementRef, Input, Output, EventEmitter, NgZone } from '@angular/core';
-import { SelectionService } from './selection.service';
-import { isPresent } from "../utils";
-/**
- * Represents the select-all checkbox feature of the Grid ([see example]({% slug selection_grid %}#toc-select-all-feature)).
- */
-var SelectAllCheckboxDirective = /** @class */ (function () {
-    function SelectAllCheckboxDirective(selectionService, el, renderer, ngZone) {
-        var _this = this;
-        this.selectionService = selectionService;
-        this.el = el;
-        this.renderer = renderer;
-        this.ngZone = ngZone;
-        /**
-         * Fires when the user clicks the `kendoGridSelectAllCheckbox` select-all checkbox
-         * ([see example]({% slug selection_grid %}#toc-select-all-feature)).
-         */
-        this.selectAllChange = new EventEmitter();
-        this.type = "checkbox";
-        this.stateSet = false;
-        this.ngZone.runOutsideAngular(function () {
-            _this.destroyClick = _this.renderer.listen(_this.el.nativeElement, "click", _this.onClick.bind(_this));
-        });
-    }
-    SelectAllCheckboxDirective.prototype.ngAfterContentChecked = function () {
-        this.setState();
-    };
-    SelectAllCheckboxDirective.prototype.ngOnChanges = function () {
-        this.stateSet = true;
-    };
-    SelectAllCheckboxDirective.prototype.ngOnDestroy = function () {
-        if (this.destroyClick) {
-            this.destroyClick();
-        }
-    };
-    /**
-     * @hidden
-     */
-    SelectAllCheckboxDirective.prototype.onClick = function () {
-        var _this = this;
-        // yields consistent cross-browser behavior when clicking an "indeterminate" checkbox
-        var undefinedCheckedStateInIE = detectIE() && this.selectionService.selectAllState === undefined;
-        var isChecked = undefinedCheckedStateInIE ? true : this.el.nativeElement.checked;
-        var options = this.selectionService.options;
-        this.selectAllChange.emit(isChecked ? "checked" : "unchecked");
-        if (options.enabled && options.mode === "multiple") {
-            this.ngZone.run(function () {
-                _this.selectionService.updateAll(isChecked);
-            });
-        }
-    };
-    /**
-     * @hidden
-     */
-    SelectAllCheckboxDirective.prototype.setState = function () {
-        var state = this.stateSet ? this.stateToBool() : this.selectionService.selectAllState;
-        var elem = this.el.nativeElement;
-        this.renderer.setProperty(elem, "indeterminate", !isPresent(state));
-        this.renderer.setProperty(elem, "checked", isPresent(state) ? state : false);
-    };
-    /**
-     * @hidden
-     */
-    SelectAllCheckboxDirective.prototype.stateToBool = function () {
-        switch (this.state) {
-            case "checked":
-                return true;
-            case "unchecked":
-                return false;
-            default:
-                return undefined;
-        }
-    };
-    tslib_1.__decorate([
-        Input(),
-        tslib_1.__metadata("design:type", String)
-    ], SelectAllCheckboxDirective.prototype, "state", void 0);
-    tslib_1.__decorate([
-        Output(),
-        tslib_1.__metadata("design:type", EventEmitter)
-    ], SelectAllCheckboxDirective.prototype, "selectAllChange", void 0);
-    tslib_1.__decorate([
-        HostBinding('attr.type'),
-        tslib_1.__metadata("design:type", String)
-    ], SelectAllCheckboxDirective.prototype, "type", void 0);
-    SelectAllCheckboxDirective = tslib_1.__decorate([
-        Directive({
-            selector: '[kendoGridSelectAllCheckbox]'
-        }),
-        tslib_1.__metadata("design:paramtypes", [SelectionService,
-            ElementRef,
-            Renderer2,
-            NgZone])
-    ], SelectAllCheckboxDirective);
-    return SelectAllCheckboxDirective;
-}());
-export { SelectAllCheckboxDirective };