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

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

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

package/dist/es2015/selection/selection.service.d.ts

@@ -0,0 +1,44 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+import { Subject } from "rxjs";
+import { SelectionChangeEvent } from './selection-change-event';
+/**
+ * @hidden
+ */
+export declare const defaultSelected: (_item: any) => boolean;
+/**
+ * @hidden
+ */
+export declare class SelectionService {
+    changes: Subject<SelectionChangeEvent>;
+    settings: any;
+    readonly enableMarquee: boolean;
+    readonly enableMultiple: boolean;
+    readonly rowSelection: boolean;
+    isSelected: any;
+    isRowSelected: any;
+    isCellSelected: any;
+    enabled: boolean;
+    private view;
+    private columnsContainer;
+    private _settings;
+    private selectionOrigin;
+    private tables;
+    private subscriptions;
+    init(treelist: any): void;
+    ngOnDestroy(): void;
+    registerTable(table: any): void;
+    unregisterTable(table: any): void;
+    click(args: any, toggle?: boolean): void;
+    checkboxClick(args: any): void;
+    toggleAll(select: boolean): void;
+    selectRange(firstPoint: any, secondPoint: any): void;
+    rangeItems(firstPoint: any, secondPoint: any): any[];
+    updateSelectedState(): void;
+    targetArgs(target: any, skipFocusable?: boolean): any;
+    protected rowSelected(dataItem: any): boolean;
+    protected cellSelected(dataItem: any, column: any, columnIndex: any): boolean;
+    protected readonly leafColumns: any[];
+}

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

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

package/dist/es2015/shared.module.d.ts

@@ -0,0 +1,10 @@
+/**-----------------------------------------------------------------------------------------
+* Copyright © 2021 Progress Software Corporation. All rights reserved.
+* Licensed under commercial license. See LICENSE.md in the project root for more information
+*-------------------------------------------------------------------------------------------*/
+/**
+ * @hidden
+ */
+export declare class SharedModule {
+    static exports(): any[];
+}

package/dist/es2015/shared.module.js

@@ -0,0 +1,58 @@
+/**-----------------------------------------------------------------------------------------
+* 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";
+const exportedModules = [
+    ColumnComponent,
+    ColumnGroupComponent,
+    LogicalCellDirective,
+    LogicalRowDirective,
+    FocusableDirective,
+    ColGroupComponent,
+    ResizableContainerDirective,
+    TemplateContextDirective,
+    FieldAccessorPipe,
+    SpanColumnComponent,
+    TableDirective,
+    LoadingComponent,
+    CheckboxColumnComponent
+];
+/**
+ * @hidden
+ */
+let SharedModule = class SharedModule {
+    static exports() {
+        return [
+            ColumnComponent,
+            SpanColumnComponent,
+            CheckboxColumnComponent,
+            ColumnGroupComponent,
+            FocusableDirective
+        ];
+    }
+};
+SharedModule = tslib_1.__decorate([
+    NgModule({
+        declarations: [exportedModules],
+        exports: [exportedModules, DraggableModule],
+        imports: [CommonModule]
+    })
+], SharedModule);
+export { SharedModule };