@progress/kendo-angular-treelist 3.1.3-dev.202110041229

package/dist/es/selection/selection-state.js

@@ -0,0 +1,115 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+/**
+ * @hidden
+ */
+var RowSelectionState = /** @class */ (function () {
+    function RowSelectionState() {
+        this.keys = new Set();
+    }
+    RowSelectionState.prototype.clear = function () {
+        this.keys.clear();
+    };
+    RowSelectionState.prototype.has = function (key) {
+        return this.keys.has(key);
+    };
+    RowSelectionState.prototype.add = function (key) {
+        this.keys.add(key);
+    };
+    RowSelectionState.prototype.remove = function (key) {
+        this.keys.delete(key);
+    };
+    RowSelectionState.prototype.toArray = function () {
+        var result = [];
+        this.keys.forEach(function (key) {
+            result.push({ itemKey: key });
+        });
+        return result;
+    };
+    RowSelectionState.prototype.fromArray = function (arr) {
+        var _this = this;
+        this.keys.clear();
+        arr.forEach(function (item) {
+            _this.add(item.itemKey);
+        });
+    };
+    return RowSelectionState;
+}());
+export { RowSelectionState };
+/**
+ * @hidden
+ */
+var CellSelectionState = /** @class */ (function () {
+    function CellSelectionState() {
+        this.keys = new Map();
+    }
+    CellSelectionState.prototype.clear = function () {
+        this.keys.clear();
+    };
+    CellSelectionState.prototype.has = function (key, columnKey) {
+        return this.keys.has(key) && this.keys.get(key).has(columnKey);
+    };
+    CellSelectionState.prototype.add = function (key, columnKey) {
+        if (!this.keys.has(key)) {
+            this.keys.set(key, new Set());
+        }
+        var columnSet = this.keys.get(key);
+        columnSet.add(columnKey);
+    };
+    CellSelectionState.prototype.remove = function (key, columnKey) {
+        if (this.keys.has(key)) {
+            var columnSet = this.keys.get(key);
+            columnSet.delete(columnKey);
+            if (!columnSet.size) {
+                this.keys.delete(key);
+            }
+        }
+    };
+    CellSelectionState.prototype.toArray = function () {
+        var result = [];
+        this.forEach(function (itemKey, columnKey) {
+            result.push({ itemKey: itemKey, columnKey: columnKey });
+        });
+        return result;
+    };
+    CellSelectionState.prototype.fromArray = function (state) {
+        var _this = this;
+        this.keys.clear();
+        state.forEach(function (item) {
+            _this.add(item.itemKey, item.columnKey);
+        });
+    };
+    CellSelectionState.prototype.updateColumKeys = function (changes) {
+        var _this = this;
+        var hasChanges = false;
+        this.keys.forEach(function (value, key) {
+            var newKeys = [];
+            value.forEach(function (columnKey) {
+                if (changes.has(columnKey)) {
+                    newKeys.push(changes.get(columnKey));
+                    hasChanges = true;
+                }
+                else {
+                    newKeys.push(columnKey);
+                }
+            });
+            _this.keys.set(key, new Set(newKeys));
+        });
+        return hasChanges;
+    };
+    CellSelectionState.prototype.forEach = function (callback) {
+        this.keys.forEach(function (value, key) {
+            value.forEach(function (columnKey) {
+                callback(key, columnKey);
+            });
+        });
+    };
+    return CellSelectionState;
+}());
+export { CellSelectionState };
+/**
+ * @hidden
+ */
+export var createState = function (settings) { return settings.mode === 'cell' ? new CellSelectionState() : new RowSelectionState(); };

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

@@ -0,0 +1,260 @@
+/**-----------------------------------------------------------------------------------------
+* 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 } from '@angular/core';
+import { Subject, Subscription, merge } from "rxjs";
+import { ViewCollection } from '../data/data.collection';
+import { SelectionChangeEvent } from './selection-change-event';
+import { Keys } from '@progress/kendo-angular-common';
+/**
+ * @hidden
+ */
+export var defaultSelected = function (_item) { return false; };
+var noop = function () { return false; };
+var ɵ0 = noop;
+/**
+ * @hidden
+ */
+var SelectionService = /** @class */ (function () {
+    function SelectionService() {
+        this.changes = new Subject();
+        this.isSelected = defaultSelected;
+        this.isRowSelected = noop;
+        this.isCellSelected = noop;
+        this.enabled = false;
+        this._settings = {};
+        this.tables = [];
+        this.subscriptions = new Subscription();
+    }
+    Object.defineProperty(SelectionService.prototype, "settings", {
+        get: function () {
+            return this._settings;
+        },
+        set: function (value) {
+            if (typeof value === 'object') {
+                this._settings = value;
+            }
+            else {
+                this._settings = {
+                    enabled: value
+                };
+            }
+            this.enabled = this._settings.enabled !== false && !this._settings.readonly;
+            if (this._settings.enabled !== false) {
+                if (this._settings.mode === 'cell') {
+                    this.isCellSelected = this.cellSelected;
+                    this.isRowSelected = noop;
+                }
+                else {
+                    this.isCellSelected = noop;
+                    this.isRowSelected = this.rowSelected;
+                }
+            }
+            else {
+                this.isCellSelected = noop;
+                this.isRowSelected = noop;
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(SelectionService.prototype, "enableMarquee", {
+        get: function () {
+            return this.enabled && this.settings.drag !== false && this.settings.multiple;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(SelectionService.prototype, "enableMultiple", {
+        get: function () {
+            return this.enabled && this.settings.multiple;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    Object.defineProperty(SelectionService.prototype, "rowSelection", {
+        get: function () {
+            return this.settings.mode !== 'cell';
+        },
+        enumerable: true,
+        configurable: true
+    });
+    SelectionService.prototype.init = function (treelist) {
+        var _this = this;
+        this.view = treelist.view;
+        this.columnsContainer = treelist.columnsContainer;
+        this.subscriptions.add(merge(treelist.pageChange, treelist.dataStateChange).subscribe(function () {
+            _this.selectionOrigin = null;
+        }));
+        this.subscriptions.add(treelist.domEvents.cellMousedown.subscribe(function (args) {
+            if (_this.enabled && _this._settings.multiple && args.originalEvent.shiftKey) {
+                args.originalEvent.preventDefault();
+            }
+        }));
+    };
+    SelectionService.prototype.ngOnDestroy = function () {
+        this.subscriptions.unsubscribe();
+    };
+    SelectionService.prototype.registerTable = function (table) {
+        this.tables.push(table);
+    };
+    SelectionService.prototype.unregisterTable = function (table) {
+        this.tables = this.tables.filter(function (t) { return t !== table; });
+    };
+    SelectionService.prototype.click = function (args, toggle) {
+        var dataItem = args.dataItem, column = args.column, columnIndex = args.columnIndex, originalEvent = args.originalEvent;
+        if (originalEvent.keyCode === Keys.Enter) {
+            return;
+        }
+        var selected = this.isSelected(dataItem, column, columnIndex);
+        var ctrlKey = originalEvent.ctrlKey || originalEvent.metaKey;
+        var toggleSelected = ctrlKey || toggle;
+        if (this._settings.multiple) {
+            if (originalEvent.shiftKey) {
+                var origin_1 = this.selectionOrigin || {
+                    columnIndex: 0,
+                    column: this.leafColumns[0],
+                    item: this.view.firstItem.data
+                };
+                this.selectRange({ item: dataItem, column: column, columnIndex: columnIndex }, origin_1);
+            }
+            else {
+                this.selectionOrigin = {
+                    item: dataItem,
+                    column: column,
+                    columnIndex: columnIndex
+                };
+                var action = toggleSelected ? (selected ? 'remove' : 'add') : 'select';
+                this.changes.next(new SelectionChangeEvent(action, [{
+                        dataItem: dataItem,
+                        column: column,
+                        columnIndex: columnIndex
+                    }]));
+            }
+        }
+        else if (!selected || toggleSelected) {
+            var action = selected && toggleSelected ? 'remove' : 'select';
+            this.changes.next(new SelectionChangeEvent(action, [{
+                    dataItem: dataItem,
+                    column: column,
+                    columnIndex: columnIndex
+                }]));
+        }
+        if (ctrlKey) {
+            originalEvent.preventDefault();
+        }
+    };
+    SelectionService.prototype.checkboxClick = function (args) {
+        var _this = this;
+        if (args.column.checkChildren && args.viewItem.hasChildren && !args.originalEvent.shiftKey && !args.originalEvent.ctrlKey) {
+            var data = [args.dataItem];
+            var selected_1 = Boolean(args.viewItem.selected);
+            ViewCollection.loadView({
+                fields: Object.assign({}, this.view.fieldAccessor(), {
+                    data: data,
+                    hasFooter: false,
+                    pageable: false,
+                    isVirtual: false
+                }),
+                loaded: this.view.loaded,
+                selectionState: this.view.selectionState
+            }).subscribe(function (view) {
+                if (!view) {
+                    return;
+                }
+                var selectedItems = view.data.filter(function (item) { return Boolean(item.selected) === selected_1; }).map(function (item) { return ({
+                    dataItem: item.data
+                }); });
+                _this.changes.next(new SelectionChangeEvent(selected_1 ? 'remove' : 'add', selectedItems));
+            });
+        }
+        else {
+            this.click(args, true);
+        }
+    };
+    SelectionService.prototype.toggleAll = function (select) {
+        var _this = this;
+        ViewCollection.loadView({
+            fields: Object.assign({}, this.view.fieldAccessor(), {
+                hasFooter: false,
+                pageable: false,
+                isVirtual: false
+            }),
+            loaded: this.view.loaded,
+            selectionState: this.view.selectionState
+        }).subscribe(function (view) {
+            if (!view) {
+                return;
+            }
+            var selectedItems = view.data.filter(function (item) { return Boolean(item.selected) !== select; }).map(function (item) { return ({
+                dataItem: item.data
+            }); });
+            _this.changes.next(new SelectionChangeEvent(select ? 'add' : 'remove', selectedItems));
+        });
+    };
+    SelectionService.prototype.selectRange = function (firstPoint, secondPoint) {
+        var rangeItems = this.rangeItems(firstPoint, secondPoint);
+        this.changes.next(new SelectionChangeEvent('select', rangeItems));
+    };
+    SelectionService.prototype.rangeItems = function (firstPoint, secondPoint) {
+        var firstIndex = this.view.findIndex(function (item) { return item.data === firstPoint.item || item === firstPoint.item; });
+        var secondIndex = this.view.findIndex(function (item) { return item.data === secondPoint.item || item === secondPoint.item; });
+        var startIndex = Math.min(firstIndex, secondIndex);
+        var endIndex = Math.max(firstIndex, secondIndex);
+        var rangeItems = this.view.data.slice(startIndex, endIndex + 1).filter(function (item) { return item.type === 'data'; });
+        if (this._settings.mode === 'cell') {
+            var leafColumns = this.leafColumns;
+            var startColumnIndex = Math.min(firstPoint.columnIndex, secondPoint.columnIndex);
+            var endColumnIndex = Math.max(firstPoint.columnIndex, secondPoint.columnIndex);
+            var selectedItems = [];
+            for (var idx = 0; idx < rangeItems.length; idx++) {
+                for (var columnIdx = startColumnIndex; columnIdx <= endColumnIndex; columnIdx++) {
+                    selectedItems.push({
+                        dataItem: rangeItems[idx].data,
+                        column: leafColumns[columnIdx],
+                        columnIndex: columnIdx
+                    });
+                }
+            }
+            return selectedItems;
+        }
+        return rangeItems.map(function (item) { return ({
+            dataItem: item.data
+        }); });
+    };
+    SelectionService.prototype.updateSelectedState = function () {
+        if (this.rowSelection) {
+            this.view.updateSelectedState();
+        }
+    };
+    SelectionService.prototype.targetArgs = function (target, skipFocusable) {
+        var result;
+        this.tables.some(function (t) {
+            result = t.targetArgs(target, skipFocusable);
+            return result;
+        });
+        return result;
+    };
+    SelectionService.prototype.rowSelected = function (dataItem) {
+        return this.isSelected(dataItem);
+    };
+    SelectionService.prototype.cellSelected = function (dataItem, column, columnIndex) {
+        return this.isSelected(dataItem, column, columnIndex);
+    };
+    Object.defineProperty(SelectionService.prototype, "leafColumns", {
+        // expose in the treelist?
+        get: function () {
+            return this.columnsContainer.lockedLeafColumns.toArray().concat(this.columnsContainer.nonLockedLeafColumns.toArray());
+        },
+        enumerable: true,
+        configurable: true
+    });
+    SelectionService = tslib_1.__decorate([
+        Injectable()
+    ], SelectionService);
+    return SelectionService;
+}());
+export { SelectionService };
+export { ɵ0 };

package/dist/es/shared.module.js

@@ -0,0 +1,61 @@
+/**-----------------------------------------------------------------------------------------
+* 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 { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ColumnComponent } from './columns/column.component';
+import { CheckboxColumnComponent } from './columns/checkbox-column.component';
+import { SpanColumnComponent } from './columns/span-column.component';
+import { ColumnGroupComponent } from './columns/column-group.component';
+import { ColGroupComponent } from './rendering/common/col-group.component';
+import { LoadingComponent } from './rendering/common/loading.component';
+import { ResizableContainerDirective } from './layout/resizable.directive';
+import { TemplateContextDirective } from './rendering/common/template-context.directive';
+import { DraggableModule } from '@progress/kendo-angular-common';
+import { LogicalCellDirective } from './navigation/logical-cell.directive';
+import { LogicalRowDirective } from './navigation/logical-row.directive';
+import { FieldAccessorPipe } from "./rendering/common/field-accessor.pipe";
+import { TableDirective } from "./column-resizing/table.directive";
+import { FocusableDirective } from "./navigation/focusable.directive";
+var exportedModules = [
+    ColumnComponent,
+    ColumnGroupComponent,
+    LogicalCellDirective,
+    LogicalRowDirective,
+    FocusableDirective,
+    ColGroupComponent,
+    ResizableContainerDirective,
+    TemplateContextDirective,
+    FieldAccessorPipe,
+    SpanColumnComponent,
+    TableDirective,
+    LoadingComponent,
+    CheckboxColumnComponent
+];
+/**
+ * @hidden
+ */
+var SharedModule = /** @class */ (function () {
+    function SharedModule() {
+    }
+    SharedModule.exports = function () {
+        return [
+            ColumnComponent,
+            SpanColumnComponent,
+            CheckboxColumnComponent,
+            ColumnGroupComponent,
+            FocusableDirective
+        ];
+    };
+    SharedModule = tslib_1.__decorate([
+        NgModule({
+            declarations: [exportedModules],
+            exports: [exportedModules, DraggableModule],
+            imports: [CommonModule]
+        })
+    ], SharedModule);
+    return SharedModule;
+}());
+export { SharedModule };