@progress/kendo-angular-treelist 21.4.1-develop.1 → 22.0.0-develop.1

package/esm2022/selection/selectable.directive.mjs

@@ -1,223 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { Directive, Input, Output, EventEmitter } from '@angular/core';
-import { TreeListComponent } from '../treelist.component';
-import { getter } from '@progress/kendo-common';
-import { isString } from '../utils';
-import { createState, RowSelectionState } from './selection-state';
-import { SelectionService } from './selection.service';
-import * as i0 from "@angular/core";
-import * as i1 from "../treelist.component";
-import * as i2 from "./selection.service";
-const defaultColumnKeyGetter = (_column, columnIndex) => columnIndex;
-/**
- * A directive which controls the selection state. [See example](slug:selection_treelist).
- *
- * @example
- * ```html
- * <kendo-treelist
- *   [kendoTreeListSelectable]="{ mode: 'row' }"
- *   [selectedItems]="selectedItems">
- *     <kendo-treelist-column field="name" title="Name"></kendo-treelist-column>
- *     <kendo-treelist-column field="age" title="Age"></kendo-treelist-column>
- * </kendo-treelist>
- * ```
- * @remarks
- * Applied to: {@link TreeListComponent}.
- */
-export class SelectableDirective {
-    treelist;
-    selectionService;
-    /**
-     * @hidden
-     */
-    set selectable(value) {
-        if (typeof value === 'object') { // add method to normalize this
-            this._settings = value;
-        }
-        else {
-            this._settings = {
-                enabled: value
-            };
-        }
-        this.state = createState(this._settings);
-        this.state.fromArray(this._selectedItems || []);
-        if (this._settings.enabled !== false) {
-            this.treelist.isSelected = this._settings.mode === 'cell' ? this.cellSelected : this.rowSelected;
-            this.subscribeSelection();
-        }
-        else {
-            this.treelist.isSelected = () => false;
-            this.unsubscribeSelection();
-        }
-        this.treelist.updateView();
-    }
-    /**
-     * Specifies the selected items.
-     */
-    set selectedItems(value) {
-        if (!value) {
-            this.state.clear();
-        }
-        else if (value !== this.lastChange) {
-            this.state.fromArray(value);
-            this.treelist.updateView();
-        }
-        this._selectedItems = value;
-        const currentValue = value || [];
-        const previousState = this.selectionService.selectAllCheckedState;
-        if (currentValue.length > 0 && currentValue.length >= this.treelist.view.flatData.length) {
-            this.selectionService.selectAllCheckedState = true;
-        }
-        else if (currentValue.length === 0) {
-            this.selectionService.selectAllCheckedState = false;
-        }
-        else {
-            this.selectionService.selectAllCheckedState = 'indeterminate';
-        }
-        if (previousState !== this.selectionService.selectAllCheckedState) {
-            this.selectionService.selectAllCheckedStateChange.next(this.selectionService.selectAllCheckedState);
-        }
-    }
-    /**
-     * Fires when the selected items are changed.
-     */
-    selectedItemsChange = new EventEmitter();
-    /**
-     * The field name or a function that specify the dataItems key.
-     */
-    set itemKey(value) {
-        if (isString(value)) {
-            this._keyGetter = getter(String(value));
-        }
-        else {
-            this._keyGetter = value;
-        }
-    }
-    /**
-     * The field name or a function that specify the columns key.
-     */
-    set columnKey(value) {
-        if (isString(value)) {
-            this._columnKeyGetter = getter(String(value));
-        }
-        else if (value) {
-            this._columnKeyGetter = value;
-        }
-    }
-    get keyGetter() {
-        return this._keyGetter || this.treelist.idGetter;
-    }
-    get columnKeyGetter() {
-        return this._columnKeyGetter || defaultColumnKeyGetter;
-    }
-    subscriptions;
-    state = new RowSelectionState();
-    _settings;
-    lastChange;
-    _columnKeyGetter;
-    _keyGetter;
-    _selectedItems = [];
-    constructor(treelist, selectionService) {
-        this.treelist = treelist;
-        this.selectionService = selectionService;
-        this.cellSelected = this.cellSelected.bind(this);
-        this.rowSelected = this.rowSelected.bind(this);
-        this.selectionChange = this.selectionChange.bind(this);
-        this.updateColumnIndices = this.updateColumnIndices.bind(this);
-        this.treelist.selectable = this.selectable = true;
-    }
-    ngOnDestroy() {
-        this.unsubscribeSelection();
-    }
-    /**
-     * @hidden
-     */
-    cellSelected(dataItem, column, columnIndex) {
-        return this.state.has(this.keyGetter(dataItem), this.columnKeyGetter(column, columnIndex));
-    }
-    /**
-     * @hidden
-     */
-    rowSelected(dataItem) {
-        return this.state.has(this.keyGetter(dataItem));
-    }
-    selectionChange({ action, items }) {
-        if (action === 'select' || action === 'add') {
-            if (action === 'select') {
-                this.state.clear();
-            }
-            items.forEach(item => {
-                this.state.add(this.keyGetter(item.dataItem), this.columnKeyGetter(item.column, item.columnIndex));
-            });
-        }
-        else {
-            items.forEach(item => {
-                this.state.remove(this.keyGetter(item.dataItem), this.columnKeyGetter(item.column, item.columnIndex));
-            });
-        }
-        this.emitSelectedItemsChange();
-    }
-    emitSelectedItemsChange() {
-        this.selectionService.state = this.lastChange = this.state.toArray();
-        this.selectedItemsChange.emit(this.lastChange);
-    }
-    subscribeSelection() {
-        this.unsubscribeSelection();
-        this.subscriptions = this.treelist.selectionChange.subscribe(this.selectionChange);
-        if (this._settings.mode === 'cell') {
-            this.subscriptions.add(this.treelist.columnOrderChange.subscribe(this.updateColumnIndices));
-            this.subscriptions.add(this.treelist.columnLockedChange.subscribe(this.updateColumnIndices));
-        }
-    }
-    unsubscribeSelection() {
-        if (this.subscriptions) {
-            this.subscriptions.unsubscribe();
-            this.subscriptions = null;
-        }
-    }
-    updateColumnIndices() {
-        if (!this._columnKeyGetter) {
-            const changes = new Map();
-            const currentIndices = [];
-            this.leafColumns.forEach((column) => {
-                currentIndices.push(column);
-            });
-            this.treelist.columnsContainer.refresh();
-            const leafColumns = this.leafColumns;
-            currentIndices.forEach((column, index) => {
-                if (column !== leafColumns[index]) {
-                    changes.set(index, leafColumns.indexOf(column));
-                }
-            });
-            if (changes.size && this.state.updateColumKeys(changes)) {
-                this.emitSelectedItemsChange();
-            }
-        }
-    }
-    get leafColumns() {
-        return this.treelist.lockedLeafColumns.toArray().concat(this.treelist.nonLockedLeafColumns.toArray());
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SelectableDirective, deps: [{ token: i1.TreeListComponent }, { token: i2.SelectionService }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: SelectableDirective, isStandalone: true, selector: "[kendoTreeListSelectable]", inputs: { selectable: "selectable", selectedItems: "selectedItems", itemKey: "itemKey", columnKey: "columnKey" }, outputs: { selectedItemsChange: "selectedItemsChange" }, exportAs: ["kendoTreeListSelectable"], ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SelectableDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    exportAs: 'kendoTreeListSelectable',
-                    selector: '[kendoTreeListSelectable]',
-                    standalone: true
-                }]
-        }], ctorParameters: () => [{ type: i1.TreeListComponent }, { type: i2.SelectionService }], propDecorators: { selectable: [{
-                type: Input
-            }], selectedItems: [{
-                type: Input
-            }], selectedItemsChange: [{
-                type: Output
-            }], itemKey: [{
-                type: Input
-            }], columnKey: [{
-                type: Input
-            }] } });

package/esm2022/selection/selection-change-event.mjs

@@ -1,28 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-/**
- * Arguments for the TreeList `selectionChange` event.
- */
-export class SelectionChangeEvent {
-    /**
-     * Specifies how the selection was changed.
-     */
-    action;
-    /**
-     * Specifies which items were changed.
-     */
-    items;
-    /**
-     * The TreeList component that triggered the event.
-     */
-    sender;
-    /**
-     * @hidden
-     */
-    constructor(action, items) {
-        this.action = action;
-        this.items = items;
-    }
-}

package/esm2022/selection/selection-state.mjs

@@ -1,104 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-/**
- * @hidden
- */
-export class RowSelectionState {
-    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 {
-    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/esm2022/selection/selection.service.mjs

@@ -1,264 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 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, Subscription, merge } from "rxjs";
-import { ViewCollection } from '../data/data.collection';
-import { SelectionChangeEvent } from './selection-change-event';
-import { hasClasses, isPresent, Keys } from '@progress/kendo-angular-common';
-import * as i0 from "@angular/core";
-/**
- * @hidden
- */
-export const defaultSelected = (_item) => false;
-const noop = () => false;
-/**
- * @hidden
- */
-export class SelectionService {
-    changes = new Subject();
-    selectAllCheckedStateChange = new Subject();
-    state = [];
-    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() {
-        const checkboxOnly = this.settings?.checkboxOnly;
-        if (!this.settings || checkboxOnly) {
-            return false;
-        }
-        const dragAndMultiple = typeof (this.settings) === 'object' &&
-            isPresent(this.settings) &&
-            this.settings.multiple &&
-            this.settings.enabled !== false &&
-            !this.settings.checkboxOnly &&
-            this.settings.drag !== false;
-        return this.enabled && dragAndMultiple;
-    }
-    get enableMultiple() {
-        return this.enabled && this.settings.multiple;
-    }
-    get rowSelection() {
-        return this.settings.mode !== 'cell';
-    }
-    isSelected = defaultSelected;
-    isRowSelected = noop;
-    isCellSelected = noop;
-    enabled = false;
-    dragging = false;
-    selectAllCheckedState = false;
-    view;
-    columnsContainer;
-    _settings = {};
-    selectionOrigin;
-    tables = [];
-    subscriptions = new Subscription();
-    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) {
-        if (this.dragging) {
-            this.dragging = false;
-            return;
-        }
-        const isCheckbox = args.originalEvent.target ? hasClasses(args.originalEvent.target, 'k-checkbox') : true;
-        if (this.rowSelection && this.settings.checkboxOnly && !isCheckbox) {
-            return;
-        }
-        const { dataItem, column, columnIndex, originalEvent } = args;
-        const ctrlKey = originalEvent.ctrlKey || originalEvent.metaKey;
-        if (((originalEvent.code === Keys.Enter || originalEvent.code === Keys.NumpadEnter) && !ctrlKey) || (originalEvent.button && originalEvent.button !== 0)) {
-            return;
-        }
-        const selected = this.isSelected(dataItem, column, columnIndex);
-        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 (this.dragging) {
-            this.dragging = false;
-            return;
-        }
-        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));
-            this.selectAllCheckedState = select;
-            this.selectAllCheckedStateChange.next(select);
-        });
-    }
-    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());
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SelectionService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SelectionService });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: SelectionService, decorators: [{
-            type: Injectable
-        }] });