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

package/filtering-base.d.ts

@@ -34,5 +34,5 @@ export declare abstract class FilteringBase {
     protected updateVisibleNodes(items: TreeItemFilterState[]): void;
     protected resetNodesVisibility(items: TreeItemFilterState[]): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<FilteringBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<FilteringBase, never, never, { "filterSettings": { "alias": "filterSettings"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FilteringBase, never, never, { "filterSettings": { "alias": "filterSettings"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; }, {}, never, never, true, never>;
 }

package/localization/messages.d.ts

@@ -13,5 +13,5 @@ export declare class TreeViewMessages extends ComponentMessages {
      */
     loadMore: string;
     static ɵfac: i0.ɵɵFactoryDeclaration<TreeViewMessages, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeViewMessages, "kendo-treeview-messages-base", never, { "loadMore": { "alias": "loadMore"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeViewMessages, "kendo-treeview-messages-base", never, { "loadMore": { "alias": "loadMore"; "required": false; }; }, {}, never, never, true, never>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@progress/kendo-angular-treeview",
-  "version": "21.4.1-develop.1",
+  "version": "22.0.0-develop.1",
   "description": "Kendo UI TreeView for Angular",
   "license": "SEE LICENSE IN LICENSE.md",
   "author": "Progress",
@@ -15,29 +15,23 @@
     "TreeView"
   ],
   "@progress": {
-    "friendlyName": "TreeView",
-    "package": {
-      "productName": "Kendo UI for Angular",
-      "productCode": "KENDOUIANGULAR",
-      "publishDate": 1768386450,
-      "licensingDocsUrl": "https://www.telerik.com/kendo-angular-ui/my-license/"
-    }
+    "friendlyName": "TreeView"
   },
   "peerDependencies": {
-    "@angular/animations": "18 - 21",
-    "@angular/common": "18 - 21",
-    "@angular/core": "18 - 21",
-    "@angular/platform-browser": "18 - 21",
+    "@angular/animations": "19 - 21",
+    "@angular/common": "19 - 21",
+    "@angular/core": "19 - 21",
+    "@angular/platform-browser": "19 - 21",
     "@progress/kendo-licensing": "^1.7.0",
-    "@progress/kendo-angular-common": "21.4.1-develop.1",
-    "@progress/kendo-angular-inputs": "21.4.1-develop.1",
-    "@progress/kendo-angular-icons": "21.4.1-develop.1",
-    "@progress/kendo-angular-l10n": "21.4.1-develop.1",
+    "@progress/kendo-angular-common": "22.0.0-develop.1",
+    "@progress/kendo-angular-inputs": "22.0.0-develop.1",
+    "@progress/kendo-angular-icons": "22.0.0-develop.1",
+    "@progress/kendo-angular-l10n": "22.0.0-develop.1",
     "rxjs": "^6.5.3 || ^7.0.0"
   },
   "dependencies": {
     "tslib": "^2.3.1",
-    "@progress/kendo-angular-schematics": "21.4.1-develop.1",
+    "@progress/kendo-angular-schematics": "22.0.0-develop.1",
     "@progress/kendo-common": "^1.0.1",
     "@progress/kendo-draggable": "^3.0.2"
   },
@@ -50,8 +44,6 @@
     },
     ".": {
       "types": "./index.d.ts",
-      "esm2022": "./esm2022/progress-kendo-angular-treeview.mjs",
-      "esm": "./esm2022/progress-kendo-angular-treeview.mjs",
       "default": "./fesm2022/progress-kendo-angular-treeview.mjs"
     }
   },

package/schematics/ngAdd/index.js

@@ -9,10 +9,10 @@ const schematics_1 = require("@angular-devkit/schematics");
 function default_1(options) {
     const finalOptions = Object.assign(Object.assign({}, options), { mainNgModule: 'TreeViewModule', package: 'treeview', peerDependencies: {
             // Peers of kendo-angular-inputs
-            '@progress/kendo-angular-buttons': '21.4.1-develop.1',
-            '@progress/kendo-angular-dialog': '21.4.1-develop.1',
-            '@progress/kendo-angular-intl': '21.4.1-develop.1',
-            '@progress/kendo-angular-popup': '21.4.1-develop.1',
+            '@progress/kendo-angular-buttons': '22.0.0-develop.1',
+            '@progress/kendo-angular-dialog': '22.0.0-develop.1',
+            '@progress/kendo-angular-intl': '22.0.0-develop.1',
+            '@progress/kendo-angular-popup': '22.0.0-develop.1',
             '@progress/kendo-drawing': '^1.9.3',
             // Peer dependency of icons
             '@progress/kendo-svg-icons': '^4.0.0'

package/esm2022/check-mode.mjs

@@ -1,5 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-export {};

package/esm2022/check.directive.mjs

@@ -1,334 +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, EventEmitter, Input, Output, NgZone } from '@angular/core';
-import { TreeViewComponent } from './treeview.component';
-import { fetchLoadedDescendants, isBoolean, isPresent, noop } from './utils';
-import { Subscription } from 'rxjs';
-import { filter, take, switchMap, tap } from 'rxjs/operators';
-import { isChanged } from '@progress/kendo-angular-common';
-import * as i0 from "@angular/core";
-import * as i1 from "./treeview.component";
-const indexChecked = (keys, index) => keys.filter(k => k === index).length > 0;
-const matchKey = index => k => {
-    if (index === k) {
-        return true;
-    }
-    if (!k.split) {
-        return false;
-    }
-    return k.split('_').reduce(({ key, result }, part) => {
-        key += part;
-        if (index === key || result) {
-            return { result: true };
-        }
-        key += "_";
-        return { key, result: false };
-    }, { key: "", result: false }).result;
-};
-/**
- * Represents a directive that manages the in-memory checked state of the TreeView node
- * ([see example](slug:checkboxes_treeview)).
- *
- * @example
- * ```html
- * <kendo-treeview
- *      kendoTreeViewCheckable
- *      checkBy="id"
- *      [(checkedKeys)]="checkedKeys"
- *      [nodes]="data">
- *  </kendo-treeview>
- * ```
- *
- * @remarks
- * Applied to: {@link TreeViewComponent}
- */
-export class CheckDirective {
-    treeView;
-    zone;
-    /**
-     * @hidden
-     */
-    set isChecked(value) {
-        this.treeView.isChecked = value;
-    }
-    /**
-     * Defines the item key stored in the `checkedKeys` collection.
-     */
-    checkKey;
-    /**
-     * Defines the collection that stores the checked keys
-     * ([see example](slug:checkboxes_treeview)).
-     */
-    checkedKeys;
-    /**
-     * Defines the checkable settings
-     * ([see example](slug:checkboxes_treeview#setup)).
-     * If you do not provide a value, the default [`CheckableSettings`](slug:api_treeview_checkablesettings) apply.
-     */
-    checkable;
-    /**
-     * Fires when the `checkedKeys` collection updates.
-     */
-    checkedKeysChange = new EventEmitter();
-    subscriptions = new Subscription();
-    get options() {
-        const defaultOptions = {
-            checkChildren: true,
-            checkParents: true,
-            enabled: true,
-            mode: "multiple",
-            uncheckCollapsedChildren: false
-        };
-        if (!isPresent(this.checkable) || typeof this.checkable === 'string') {
-            return defaultOptions;
-        }
-        const checkSettings = isBoolean(this.checkable)
-            ? { enabled: this.checkable }
-            : this.checkable;
-        return Object.assign(defaultOptions, checkSettings);
-    }
-    checkActions = {
-        'multiple': (e) => this.checkMultiple(e),
-        'single': (e) => this.checkSingle(e)
-    };
-    /**
-     * Reflects the internal `checkedKeys` state.
-     */
-    state = new Set();
-    clickSubscription;
-    /**
-     * Holds the last emitted `checkedKeys` collection.
-     */
-    lastChange;
-    constructor(treeView, zone) {
-        this.treeView = treeView;
-        this.zone = zone;
-        this.subscriptions.add(this.treeView.checkedChange
-            .subscribe((e) => this.check(e)));
-        const expandedItems = [];
-        this.subscriptions.add(this.treeView.childrenLoaded
-            .pipe(filter(() => this.options.checkChildren && this.treeView.loadOnDemand), tap(item => expandedItems.push(item)), switchMap(() => this.zone.onStable.pipe(take(1))))
-            .subscribe(() => this.addCheckedItemsChildren(expandedItems)));
-        this.treeView.isChecked = this.isItemChecked.bind(this);
-    }
-    ngOnChanges(changes) {
-        if (changes.checkable) {
-            this.treeView.checkboxes = this.options.enabled;
-            this.toggleCheckOnClick();
-        }
-        if (isChanged('checkedKeys', changes, false) && changes.checkedKeys.currentValue !== this.lastChange) {
-            this.state = new Set(changes.checkedKeys.currentValue);
-        }
-    }
-    ngOnDestroy() {
-        this.subscriptions.unsubscribe();
-        this.unsubscribeClick();
-    }
-    isItemChecked(dataItem, index) {
-        if (!this.checkKey) {
-            return this.isIndexChecked(index);
-        }
-        const hasKey = this.state.has(this.itemKey({ dataItem, index }));
-        return hasKey ? 'checked' : 'none';
-    }
-    isIndexChecked(index) {
-        const checkedKeys = Array.from(this.state).filter(matchKey(index));
-        if (indexChecked(checkedKeys, index)) {
-            return 'checked';
-        }
-        const { mode, checkParents } = this.options;
-        if (mode === 'multiple' && checkParents && checkedKeys.length) {
-            return 'indeterminate';
-        }
-        return 'none';
-    }
-    itemKey(item) {
-        if (!isPresent(this.checkKey)) {
-            return item.index;
-        }
-        if (typeof this.checkKey === "string" && isPresent(item.dataItem)) {
-            return item.dataItem[this.checkKey];
-        }
-        if (typeof this.checkKey === "function") {
-            return this.checkKey(item);
-        }
-    }
-    check(e) {
-        const { enabled, mode } = this.options;
-        const performSelection = this.checkActions[mode] || noop;
-        if (!enabled) {
-            return;
-        }
-        performSelection(e);
-    }
-    checkSingle(node) {
-        const key = this.itemKey(node.item);
-        const hasKey = this.state.has(key);
-        this.state.clear();
-        if (!hasKey) {
-            this.state.add(key);
-        }
-        this.notify();
-    }
-    checkMultiple(node) {
-        this.checkNode(node);
-        if (this.options.checkParents) {
-            this.checkParents(node.parent);
-        }
-        this.notify();
-    }
-    toggleCheckOnClick() {
-        this.unsubscribeClick();
-        if (this.options.checkOnClick) {
-            this.clickSubscription = this.treeView.nodeClick.subscribe(args => {
-                if (args.type === 'click') {
-                    const lookup = this.treeView.itemLookup(args.item.index);
-                    this.check(lookup);
-                }
-            });
-        }
-    }
-    unsubscribeClick() {
-        if (this.clickSubscription) {
-            this.clickSubscription.unsubscribe();
-            this.clickSubscription = null;
-        }
-    }
-    checkNode(node) {
-        if (!isPresent(node.item.dataItem) ||
-            this.treeView.isDisabled(node.item.dataItem, node.item.index) ||
-            !this.treeView.hasCheckbox(node.item.dataItem, node.item.index)) {
-            return;
-        }
-        const currentKey = this.itemKey(node.item);
-        if (!isPresent(currentKey)) {
-            return;
-        }
-        const pendingCheck = [currentKey];
-        if (this.options.checkChildren) {
-            const descendants = fetchLoadedDescendants(node, ({ item }) => (this.treeView.disableParentNodesOnly || this.options.checkDisabledChildren ?
-                this.treeView.isVisible(item.dataItem, item.index) :
-                this.treeView.isVisible(item.dataItem, item.index) &&
-                    !this.treeView.isDisabled(item.dataItem, item.index) &&
-                    this.treeView.hasCheckbox(item.dataItem, item.index)));
-            pendingCheck.push(...descendants.filter((item) => this.options.checkDisabledChildren ||
-                !this.treeView.isDisabled(item.item.dataItem, item.item.index) ||
-                this.treeView.hasCheckbox(item.item.dataItem, item.item.index))
-                .map(({ item }) => this.itemKey(item)));
-        }
-        const shouldCheck = !this.state.has(currentKey);
-        pendingCheck.forEach(key => {
-            if (shouldCheck) {
-                this.state.add(key);
-            }
-            else {
-                this.state.delete(key);
-                if (this.options.uncheckCollapsedChildren &&
-                    this.options.mode === 'multiple' &&
-                    this.treeView.loadOnDemand) {
-                    if (this.checkKey && this.treeView.hasChildren(node.item.dataItem)) {
-                        this.uncheckChildren(node.item.dataItem, node.item.index);
-                        return;
-                    }
-                    const checkedKeys = Array.from(this.state).filter(matchKey(node.item.index));
-                    checkedKeys.forEach(key => this.state.delete(key));
-                }
-            }
-        });
-    }
-    uncheckChildren(dataItem, parentNodeIndex) {
-        this.treeView.children(dataItem).subscribe(children => children.forEach((item, index) => {
-            const nodeIndex = `${parentNodeIndex}_${index}`;
-            this.state.delete(this.itemKey({ dataItem: item, index: nodeIndex }));
-            if (this.treeView.hasChildren(item)) {
-                this.uncheckChildren(item, nodeIndex);
-            }
-        }));
-    }
-    checkParents(parent) {
-        if (!isPresent(parent)) {
-            return;
-        }
-        let currentParent = parent;
-        while (currentParent) {
-            const parentKey = this.itemKey(currentParent.item);
-            const isDisabled = this.treeView.isDisabled(currentParent.item.dataItem, currentParent.item.index);
-            const allChildrenSelected = currentParent.children.every(item => this.state.has(this.itemKey(item)));
-            const hasCheckbox = this.treeView.hasCheckbox(currentParent.item.dataItem, currentParent.item.index);
-            if (hasCheckbox && (!isDisabled || this.options.checkDisabledChildren) && allChildrenSelected) {
-                this.state.add(parentKey);
-            }
-            else {
-                this.state.delete(parentKey);
-            }
-            currentParent = currentParent.parent;
-        }
-    }
-    allChildrenSelected(children) {
-        return children.every(item => {
-            const childrenSel = this.allChildrenSelected(item.children);
-            return this.state.has(this.itemKey(item.item)) && childrenSel;
-        });
-    }
-    notify() {
-        this.lastChange = Array.from(this.state);
-        this.checkedKeysChange.emit(this.lastChange);
-    }
-    addCheckedItemsChildren(lookups) {
-        if (!isPresent(lookups) || lookups.length === 0) {
-            return;
-        }
-        const initiallyCheckedItemsCount = this.state.size;
-        const disabledItems = new Set();
-        lookups.forEach(lookup => {
-            const itemKey = this.itemKey(lookup.item);
-            if (!this.state.has(itemKey)) {
-                return;
-            }
-            lookup.children.forEach(item => {
-                // ensure both the parent item and each child node is enabled
-                if ((!this.treeView.isDisabled(lookup.item.dataItem, lookup.item.index) &&
-                    !this.treeView.isDisabled(item.dataItem, item.index)) &&
-                    (this.treeView.hasCheckbox(lookup.item.dataItem, lookup.item.index) &&
-                        this.treeView.hasCheckbox(item.dataItem, item.index)) ||
-                    this.treeView.disableParentNodesOnly || this.options.checkDisabledChildren) {
-                    this.state.add(this.itemKey(item));
-                }
-                if (this.treeView.disableParentNodesOnly &&
-                    !this.options.checkDisabledChildren &&
-                    (this.treeView.isDisabled(item.dataItem, item.index) ||
-                        !this.treeView.hasCheckbox(item.dataItem, item.index))) {
-                    disabledItems.add(this.itemKey(item));
-                }
-            });
-        });
-        disabledItems.forEach(item => this.state.delete(item));
-        const hasNewlyCheckedItems = initiallyCheckedItemsCount !== this.state.size;
-        if (hasNewlyCheckedItems) {
-            this.zone.run(() => this.notify());
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CheckDirective, deps: [{ token: i1.TreeViewComponent }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: CheckDirective, isStandalone: true, selector: "[kendoTreeViewCheckable]", inputs: { isChecked: "isChecked", checkKey: ["checkBy", "checkKey"], checkedKeys: "checkedKeys", checkable: ["kendoTreeViewCheckable", "checkable"] }, outputs: { checkedKeysChange: "checkedKeysChange" }, usesOnChanges: true, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: CheckDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[kendoTreeViewCheckable]',
-                    standalone: true
-                }]
-        }], ctorParameters: () => [{ type: i1.TreeViewComponent }, { type: i0.NgZone }], propDecorators: { isChecked: [{
-                type: Input
-            }], checkKey: [{
-                type: Input,
-                args: ["checkBy"]
-            }], checkedKeys: [{
-                type: Input
-            }], checkable: [{
-                type: Input,
-                args: ['kendoTreeViewCheckable']
-            }], checkedKeysChange: [{
-                type: Output
-            }] } });

package/esm2022/checkable-settings.mjs

@@ -1,5 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-export {};

package/esm2022/checkbox/checked-state.mjs

@@ -1,5 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2026 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-export {};

package/esm2022/data-bound-component.mjs

@@ -1,19 +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 * as i0 from "@angular/core";
-/**
- * @hidden
- *
- * An injection token used by the data binding directives to interface with
- * the TreeView or the DropDownTree components.
- */
-export class DataBoundComponent {
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DataBoundComponent, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DataBoundComponent });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DataBoundComponent, decorators: [{
-            type: Injectable
-        }] });

package/esm2022/data-change-notification.service.mjs

@@ -1,14 +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 { EventEmitter } from '@angular/core';
-/**
- * @hidden
- */
-export class DataChangeNotificationService {
-    changes = new EventEmitter();
-    notify() {
-        this.changes.emit();
-    }
-}

package/esm2022/default-callbacks.mjs

@@ -1,36 +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 const hasChildren = () => false;
-/**
- * @hidden
- */
-export const isChecked = () => 'none';
-/**
- * @hidden
- */
-export const isDisabled = () => false;
-/**
- * @hidden
- */
-export const hasCheckbox = () => true;
-/**
- * @hidden
- */
-export const isExpanded = () => true;
-/**
- * @hidden
- */
-export const isSelected = () => false;
-/**
- * @hidden
- */
-export const isVisible = () => true;
-/**
- * @hidden
- */
-export const trackBy = (_, item) => item;

package/esm2022/directives.mjs

@@ -1,53 +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 { CheckDirective } from "./check.directive";
-import { DisableDirective } from "./disable.directive";
-import { DragAndDropEditingDirective } from "./drag-and-drop/drag-and-drop-editing.directive";
-import { DragAndDropDirective } from "./drag-and-drop/drag-and-drop.directive";
-import { DragClueTemplateDirective } from "./drag-and-drop/drag-clue/drag-clue-template.directive";
-import { DropHintTemplateDirective } from "./drag-and-drop/drop-hint/drop-hint-template.directive";
-import { ExpandDirective } from "./expand.directive";
-import { FlatDataBindingDirective } from "./flat-binding.directive";
-import { HierarchyBindingDirective } from "./hierarchy-binding.directive";
-import { LoadMoreButtonTemplateDirective } from "./load-more/load-more-button-template.directive";
-import { LoadMoreDirective } from "./load-more/load-more.directive";
-import { CustomMessagesComponent } from "./localization/custom-messages.component";
-import { NodeTemplateDirective } from "./node-template.directive";
-import { SelectDirective } from "./selection/select.directive";
-import { TreeViewComponent } from "./treeview.component";
-/**
- * Use the `KENDO_TREEVIEW` utility array to add all `@progress/kendo-angular-treeview`-related components and directives to a standalone Angular component.
- *
- * @example
- * ```typescript
- * import { Component } from '@angular/core';
- * import { KENDO_TREEVIEW } from '@progress/kendo-angular-treeview';
- *
- * @Component({
- *   selector: 'my-app',
- *   standalone: true,
- *   imports: [KENDO_TREEVIEW],
- *   template: `<kendo-treeview></kendo-treeview>`
- * })
- * export class AppComponent {}
- * ```
- */
-export const KENDO_TREEVIEW = [
-    TreeViewComponent,
-    NodeTemplateDirective,
-    CheckDirective,
-    DisableDirective,
-    ExpandDirective,
-    SelectDirective,
-    HierarchyBindingDirective,
-    FlatDataBindingDirective,
-    DragAndDropDirective,
-    DragClueTemplateDirective,
-    DropHintTemplateDirective,
-    DragAndDropEditingDirective,
-    LoadMoreDirective,
-    LoadMoreButtonTemplateDirective,
-    CustomMessagesComponent
-];

package/esm2022/disable.directive.mjs

@@ -1,83 +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 { ChangeDetectorRef, Directive, Input } from '@angular/core';
-import { TreeViewComponent } from './treeview.component';
-import * as i0 from "@angular/core";
-import * as i1 from "./treeview.component";
-/**
- * Represents a directive which manages the disabled in-memory state of the TreeView node
- * ([see example]({% slug disabledstate_treeview %})).
- *
- * @example
- * ```html
- * <kendo-treeview
- *      [nodes]="data"
- *      textField="text"
- *      [hasChildren]="hasChildren"
- *      [children]="fetchChildren"
- *      kendoTreeViewDisable
- *      [disabledKeys]="disabledKeys">
- *  </kendo-treeview>
- * ```
- *
- * @remarks
- * Applied to: {@link TreeViewComponent}
- */
-export class DisableDirective {
-    treeView;
-    cdr;
-    /**
-     * @hidden
-     */
-    set isDisabled(value) {
-        this.treeView.isDisabled = value;
-    }
-    /**
-     * Defines the item key that will be stored in the `disabledKeys` collection.
-     */
-    disableKey;
-    /**
-     * Defines the collection that will store the disabled keys.
-     */
-    disabledKeys = [];
-    constructor(treeView, cdr) {
-        this.treeView = treeView;
-        this.cdr = cdr;
-        this.treeView.isDisabled = (dataItem, index) => (this.disabledKeys.indexOf(this.itemKey({ dataItem, index })) > -1);
-    }
-    ngOnChanges(changes = {}) {
-        const { disabledKeys } = changes;
-        if (disabledKeys && !disabledKeys.firstChange) {
-            this.cdr.markForCheck();
-        }
-    }
-    itemKey(e) {
-        if (!this.disableKey) {
-            return e.index;
-        }
-        if (typeof this.disableKey === "string") {
-            return e.dataItem[this.disableKey];
-        }
-        if (typeof this.disableKey === "function") {
-            return this.disableKey(e);
-        }
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DisableDirective, deps: [{ token: i1.TreeViewComponent }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
-    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.14", type: DisableDirective, isStandalone: true, selector: "[kendoTreeViewDisable]", inputs: { isDisabled: "isDisabled", disableKey: ["kendoTreeViewDisable", "disableKey"], disabledKeys: "disabledKeys" }, usesOnChanges: true, ngImport: i0 });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: DisableDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: '[kendoTreeViewDisable]',
-                    standalone: true
-                }]
-        }], ctorParameters: () => [{ type: i1.TreeViewComponent }, { type: i0.ChangeDetectorRef }], propDecorators: { isDisabled: [{
-                type: Input
-            }], disableKey: [{
-                type: Input,
-                args: ["kendoTreeViewDisable"]
-            }], disabledKeys: [{
-                type: Input
-            }] } });