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

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

@@ -1,297 +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
- */
-let CellSelectionService = 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 = tslib_1.__decorate([
-    Injectable(),
-    tslib_1.__metadata("design:paramtypes", [DomEventsService,
-        LocalDataChangesService,
-        NavigationService])
-], CellSelectionService);
-export { CellSelectionService };

package/dist/es2015/selection/marquee.directive.d.ts

@@ -1,34 +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 { DomEventsService } from './../common/dom-events.service';
-import { DraggableDirective } from '@progress/kendo-angular-common';
-import { SelectionService } from './selection.service';
-import { CellSelectionService } from './cell-selection.service';
-/**
- * @hidden
- */
-export declare class GridMarqueeDirective {
-    private draggable;
-    private selection;
-    private cellSelection;
-    private domEvents;
-    readonly webkitUserSelection: string;
-    readonly userSelection: boolean;
-    private pressArgs;
-    private marqueeElement;
-    private pressTarget;
-    private subscriptions;
-    private selectionStarted;
-    private dragEndSubscription;
-    constructor(draggable: DraggableDirective, selection: SelectionService, cellSelection: CellSelectionService, domEvents: DomEventsService);
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    private start;
-    private moveMarquee;
-    private endSelection;
-    private clean;
-    private initMarquee;
-    private getMarqueeQuadrant;
-}

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

@@ -1,171 +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';
-const createElement = () => {
-    const marquee = document.createElement("div");
-    marquee.className = "k-marquee";
-    const marqueeColor = document.createElement("div");
-    marqueeColor.className = "k-marquee-color";
-    marquee.appendChild(marqueeColor);
-    return marquee;
-};
-const ɵ0 = createElement;
-const POINTER_OFFSET = 2;
-const MINIMAL_DRAG_DISTANCE = 5;
-const 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
- */
-let GridMarqueeDirective = class GridMarqueeDirective {
-    constructor(draggable, selection, cellSelection, domEvents) {
-        this.draggable = draggable;
-        this.selection = selection;
-        this.cellSelection = cellSelection;
-        this.domEvents = domEvents;
-        this.selectionStarted = false;
-    }
-    get webkitUserSelection() {
-        return (this.cellSelection.enableMarquee || this.selection.enableMarquee) ? 'none' : null;
-    }
-    get userSelection() {
-        return (this.cellSelection.enableMarquee || this.selection.enableMarquee);
-    }
-    ngOnInit() {
-        this.subscriptions = (this.draggable.kendoPress.subscribe(this.start.bind(this)));
-        this.subscriptions.add(this.draggable.kendoDrag.subscribe(this.moveMarquee.bind(this)));
-    }
-    ngOnDestroy() {
-        this.subscriptions.unsubscribe();
-        this.clean();
-    }
-    start(args) {
-        if (args.originalEvent.target.classList.contains('k-checkbox')) {
-            this.pressArgs = null;
-            return;
-        }
-        this.pressArgs = args;
-        this.pressTarget = null;
-    }
-    moveMarquee(args) {
-        if (!this.pressTarget) {
-            this.pressTarget = this.cellSelection.active ? this.cellSelection.mouseDownEventArgs : this.selection.mouseDownEventArgs;
-        }
-        const press = this.pressArgs;
-        if (!press) {
-            return;
-        }
-        if (!this.selectionStarted) {
-            const 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();
-        const element = this.marqueeElement;
-        const marqueeQuadrant = this.getMarqueeQuadrant(args.pageX, args.pageY, press.pageX, press.pageY);
-        let left = Math.min(args.pageX, press.pageX);
-        let top = Math.min(args.pageY, press.pageY);
-        const width = Math.abs(args.pageX - press.pageX);
-        const 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`;
-    }
-    endSelection(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();
-    }
-    clean() {
-        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;
-    }
-    initMarquee() {
-        if (!this.marqueeElement) {
-            this.marqueeElement = createElement();
-            document.body.appendChild(this.marqueeElement);
-        }
-    }
-    getMarqueeQuadrant(pointerX, pointerY, startX, startY) {
-        const leftHalf = pointerX < startX;
-        const rightHalf = pointerX > startX;
-        const topHalf = pointerY < startY;
-        const 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);
-export { GridMarqueeDirective };
-export { ɵ0 };

package/dist/es2015/selection/pair-set.d.ts

@@ -1,50 +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).
- */
-export declare class PairSet {
-    /**
-     * Gets the total number of X/Y key pairs.
-     */
-    readonly size: number;
-    /**
-     * 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]
-     */
-    private keysX;
-    /**
-     * Count the each added or deleted key manually to avoid iterating over all items when calling `this.size`.
-     */
-    private totalKeysCount;
-    constructor(items?: any[], keyXField?: string, keyYField?: string);
-    /**
-     * Adds a couple of items identified as a combination.
-     */
-    add(keyX: any, keyY: any): void;
-    /**
-     * Adds a combination of a couple of items identified together.
-     */
-    delete(keyX: any, keyY: any): void;
-    /**
-     * Checks whether the defined combination is stored.
-     */
-    has(keyX: any, keyY: any): boolean;
-    /**
-     * Clears all key combinations.
-     */
-    clear(): void;
-    /**
-     * Converts the persisted data structure to an array of objects,
-     * using the provided field names for the object props.
-     */
-    toArray(keyXField: string, keyYField: string): any[];
-}

package/dist/es2015/selection/selectall-checkbox.directive.d.ts

@@ -1,44 +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 { Renderer2, ElementRef, OnDestroy, AfterContentChecked, OnChanges, EventEmitter, NgZone } from '@angular/core';
-import { SelectionService } from './selection.service';
-import { SelectAllCheckboxState } from "./types";
-/**
- * Represents the select-all checkbox feature of the Grid ([see example]({% slug selection_grid %}#toc-select-all-feature)).
- */
-export declare class SelectAllCheckboxDirective implements AfterContentChecked, OnDestroy, OnChanges {
-    private selectionService;
-    private el;
-    private renderer;
-    private ngZone;
-    /**
-     * Explicitly overrides the state of the select-all checkbox.
-     */
-    state: SelectAllCheckboxState;
-    /**
-     * Fires when the user clicks the `kendoGridSelectAllCheckbox` select-all checkbox
-     * ([see example]({% slug selection_grid %}#toc-select-all-feature)).
-     */
-    selectAllChange: EventEmitter<SelectAllCheckboxState>;
-    type: string;
-    private destroyClick;
-    private stateSet;
-    ngAfterContentChecked(): void;
-    ngOnChanges(): void;
-    constructor(selectionService: SelectionService, el: ElementRef, renderer: Renderer2, ngZone: NgZone);
-    ngOnDestroy(): void;
-    /**
-     * @hidden
-     */
-    onClick(): void;
-    /**
-     * @hidden
-     */
-    private setState;
-    /**
-     * @hidden
-     */
-    private stateToBool;
-}