@progress-chef/platform-shared-components 0.0.154 → 0.0.156-rc.1

package/esm2022/lib/atoms/tree-view/tree-view.component.mjs

@@ -0,0 +1,521 @@
+import { Component, Input, Output, EventEmitter, ViewChild } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { of } from 'rxjs';
+import { TreeViewModule } from '@progress/kendo-angular-treeview';
+import { IconsModule } from '@progress/kendo-angular-icons';
+import { ButtonComponent } from '../button/button.component';
+import { IconComponent } from '../icon/icon.component';
+import { LoaderComponent } from '../loader/loader.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@progress/kendo-angular-treeview";
+/**
+ * Custom TreeView component that wraps Kendo's TreeView with design system styling.
+ *
+ * This component provides a hierarchical tree structure for displaying and navigating data.
+ * It supports selection, expansion, icons, and custom templates.
+ */
+export class TreeViewComponent {
+    constructor() {
+        /**
+         * The data source for the tree view
+         */
+        this.data = [];
+        // Basic Properties
+        this.selectable = false;
+        this.filterable = false;
+        this.checkboxes = false;
+        this.checkable = false;
+        this.dragAndDrop = false;
+        this.expandable = true;
+        this.loading = false;
+        this.animate = true;
+        this.size = 'medium';
+        // Field Configuration
+        this.textField = 'text';
+        this.childrenField = 'children';
+        this.hasChildrenField = 'hasChildren';
+        this.expandedField = 'expanded';
+        this.selectedField = 'selected';
+        this.disabledField = 'disabled';
+        this.checkedField = 'checked';
+        this.iconClassField = 'iconClass';
+        this.iconField = 'icon';
+        this.imageUrlField = 'imageUrl';
+        this.spriteCssClassField = 'spriteCssClass';
+        // Selection and Expansion
+        this.disabledKeys = [];
+        this.expandBy = ''; //if expandBy is empty, expandedKeys will use index to track expansion. Otherwise, it will use the field name to decide the expandedKeys.
+        this.expandedKeys = [];
+        this.selectedKeys = [];
+        this.checkedKeys = [];
+        this.expandDisabledNodes = false;
+        this.disableNodes = false;
+        // Checkbox Configuration
+        this.enableCheck = false;
+        this.checkChildren = false;
+        this.checkDisabledChildren = false;
+        this.checkParents = false;
+        this.checkOnClick = false;
+        this.uncheckCollapsedChildren = false;
+        this.checkMode = "multiple";
+        this.pageSize = 0;
+        this.loadOnDemand = false;
+        // Filtering
+        this.filter = '';
+        // Keyboard Navigation
+        this.navigable = true;
+        // Basic Events
+        this.selectionChange = new EventEmitter();
+        this.expand = new EventEmitter();
+        this.collapse = new EventEmitter();
+        this.checkedChange = new EventEmitter();
+        this.nodeClick = new EventEmitter();
+        this.nodeDblClick = new EventEmitter();
+        // Drag and Drop Events
+        this.nodeDragStart = new EventEmitter();
+        this.nodeDrag = new EventEmitter();
+        this.nodeDrop = new EventEmitter();
+        this.nodeDragEnd = new EventEmitter();
+        this.addItem = new EventEmitter();
+        this.removeItem = new EventEmitter();
+        // Key Change Events (Two-way binding support)
+        this.expandedKeysChange = new EventEmitter();
+        this.selectedKeysChange = new EventEmitter();
+        this.checkedKeysChange = new EventEmitter();
+        // Filter Events
+        this.filterChange = new EventEmitter();
+        // Load More Events
+        this.loadMore = new EventEmitter();
+        // Children Loading Events
+        this.childrenLoaded = new EventEmitter();
+        /**
+         * Currently selected items
+         */
+        this.selectedItems = [];
+        /**
+         * Currently checked items
+         */
+        this.checkedItems = [];
+        /**
+         * Extracts and returns child items from a tree node using the configured children field.
+         * Provides a standardized way for the Kendo TreeView to access hierarchical child data
+         * regardless of the actual field name used in the data structure.
+         *
+         * @param dataItem - The tree node data item to extract children from
+         * @returns Observable array of child items or empty array if no children exist
+         */
+        this.children = (dataItem) => of(dataItem[this.childrenField]);
+        /**
+         * Determines whether a tree node has child items for proper expand/collapse icon display.
+         * Checks for the existence of children property and logs the result for debugging purposes.
+         * Used by the TreeView to decide whether to show expansion indicators for each node.
+         *
+         * @param dataItem - The tree node data item to check for children
+         * @returns Boolean indicating whether the node has children that can be expanded
+         */
+        this.hasChildren = (dataItem) => { return !!dataItem[this.childrenField]; };
+    }
+    /**
+     * Generates CSS classes for the tree-view container element based on current component state.
+     * Applies conditional styling classes to reflect loading states and enable appropriate visual feedback.
+     *
+     * @returns A space-separated string of CSS class names to apply to the tree-view container
+     */
+    getTreeViewClasses() {
+        const classes = ['lib-tree-view'];
+        if (this.loading) {
+            classes.push('lib-tree-view--loading');
+        }
+        return classes.join(' ');
+    }
+    /**
+     * Provides comprehensive checkable settings configuration for the Kendo TreeView component.
+     * Aggregates all checkbox-related input properties into a single configuration object
+     * that controls checkbox behavior including parent-child relationships and interaction modes.
+     *
+     * @returns CheckableSettings object with all checkbox configuration options
+     */
+    get checkableSettings() {
+        return {
+            checkChildren: this.checkChildren,
+            checkDisabledChildren: this.checkDisabledChildren,
+            checkParents: this.checkParents,
+            enabled: this.enableCheck,
+            mode: this.checkMode,
+            checkOnClick: this.checkOnClick,
+            uncheckCollapsedChildren: this.uncheckCollapsedChildren,
+        };
+    }
+    // Event Handlers
+    /**
+     * Handles tree node selection changes when users select or deselect nodes.
+     * Updates the internal selected items state and propagates the selection event
+     * to parent components for external handling and synchronization.
+     *
+     * @param event - The selection change event containing the newly selected items array
+     */
+    onSelectionChange(event) {
+        this.selectedItems = event;
+        this.selectionChange.emit(event);
+    }
+    /**
+     * Handles checkbox state changes when users check or uncheck tree nodes.
+     * Updates the internal checked items state and emits the change event to notify
+     * parent components of the new checkbox selections for form validation or data processing.
+     *
+     * @param event - The checked change event containing the newly checked items array
+     */
+    onCheckedChange(event) {
+        this.checkedItems = event;
+        this.checkedChange.emit(event);
+    }
+    /**
+     * Handles tree node expansion events when users click expand icons or use keyboard navigation.
+     * Updates the node's expanded state in the data model and emits the expand event
+     * for parent components to handle lazy loading of child data or state persistence.
+     *
+     * @param event - The expand event containing the expanded node data and context information
+     */
+    onExpand(event) {
+        if (event.dataItem) {
+            event.dataItem[this.expandedField] = true;
+        }
+        this.expand.emit(event);
+    }
+    /**
+     * Handles tree node collapse events when users click collapse icons or use keyboard navigation.
+     * Updates the node's expanded state in the data model and emits the collapse event
+     * for parent components to handle state cleanup or memory optimization.
+     *
+     * @param event - The collapse event containing the collapsed node data and context information
+     */
+    onCollapse(event) {
+        if (event.dataItem) {
+            event.dataItem[this.expandedField] = false;
+        }
+        this.collapse.emit(event);
+    }
+    /**
+     * Handles single-click events on tree nodes for custom interaction handling.
+     * Propagates click events to parent components for navigation, selection logic,
+     * or custom actions based on the clicked node's data and context.
+     *
+     * @param event - The node click event containing clicked node data and mouse event details
+     */
+    onNodeClick(event) {
+        this.nodeClick.emit(event);
+    }
+    /**
+     * Handles double-click events on tree nodes for enhanced interaction patterns.
+     * Typically used for opening detailed views, editing modes, or quick actions
+     * that differ from single-click behavior. Emits event for parent component handling.
+     *
+     * @param event - The node double-click event containing node data and mouse event details
+     */
+    onNodeDblClick(event) {
+        this.nodeDblClick.emit(event);
+    }
+    /**
+     * Handles the initiation of drag operations when users start dragging tree nodes.
+     * Validates that drag-and-drop functionality is enabled before proceeding and
+     * emits the drag start event for parent components to handle drag state setup.
+     *
+     * @param event - The tree item drag start event containing source node and drag context
+     */
+    onNodeDragStart(event) {
+        if (!this.dragAndDrop) {
+            return;
+        }
+        this.nodeDragStart.emit(event);
+    }
+    /**
+     * Handles ongoing drag operations as users move nodes during drag-and-drop actions.
+     * Provides real-time feedback and validation during the drag process, allowing
+     * parent components to update UI indicators or validate drop targets.
+     *
+     * @param event - The tree item drag event containing current drag position and target information
+     */
+    onNodeDrag(event) {
+        this.nodeDrag.emit(event);
+    }
+    /**
+     * Handles the completion of drag operations when users finish dragging nodes.
+     * Provides cleanup and final processing for drag-and-drop operations, allowing
+     * parent components to finalize data updates and reset drag-related UI states.
+     *
+     * @param event - The tree item drag end event containing final drag state and completion context
+     */
+    onNodeDragEnd(event) {
+        this.nodeDragEnd.emit(event);
+    }
+    /**
+     * Handles item addition events when new nodes are added to the tree structure.
+     * Propagates add events to parent components for data persistence, validation,
+     * and tree structure updates to maintain data integrity.
+     *
+     * @param event - The tree item add event containing new item data and insertion context
+     */
+    onAddItem(event) {
+        this.addItem.emit(event);
+    }
+    /**
+     * Handles item removal events when nodes are deleted from the tree structure.
+     * Propagates remove events to parent components for confirmation dialogs, data cleanup,
+     * and cascading deletions of child nodes when necessary.
+     *
+     * @param event - The tree item remove event containing deleted item data and context
+     */
+    onRemoveItem(event) {
+        this.removeItem.emit(event);
+    }
+    /**
+     * Handles expanded keys changes for two-way binding support with parent components.
+     * Synchronizes internal expanded state with external data binding, enabling
+     * programmatic control of tree expansion and state persistence across component updates.
+     *
+     * @param keys - Array of string keys representing currently expanded tree nodes
+     */
+    onExpandedKeysChange(keys) {
+        this.expandedKeys = keys;
+        this.expandedKeysChange.emit(keys);
+    }
+    /**
+     * Handles selected keys changes for two-way binding support with parent components.
+     * Synchronizes internal selection state with external data binding, enabling
+     * programmatic control of tree selection and form integration capabilities.
+     *
+     * @param keys - Array of string keys representing currently selected tree nodes
+     */
+    onSelectedKeysChange(keys) {
+        this.selectedKeys = keys;
+        this.selectedKeysChange.emit(keys);
+    }
+    /**
+     * Handles checked keys changes for two-way binding support with parent components.
+     * Synchronizes internal checkbox state with external data binding, enabling
+     * programmatic control of checkbox selections and form validation integration.
+     *
+     * @param keys - Array of string keys representing currently checked tree nodes
+     */
+    onCheckedKeysChange(keys) {
+        this.checkedKeys = keys;
+        this.checkedKeysChange.emit(keys);
+    }
+    /**
+     * Handles filter text changes when users type in search fields or apply filtering criteria.
+     * Updates the internal filter state and propagates changes to parent components
+     * for server-side filtering or custom search logic implementation.
+     *
+     * @param filter - The filter string entered by the user for tree node searching
+     */
+    onFilterChange(filter) {
+        this.filter = filter;
+        this.filterChange.emit(filter);
+    }
+    /**
+     * Handle load more event
+     */
+    onLoadMore(event) {
+        this.loadMore.emit(event);
+    }
+    /**
+     * Handle children loaded event
+     */
+    onChildrenLoaded(event) {
+        this.childrenLoaded.emit(event);
+    }
+    // Utility Methods
+    /**
+     * Expand all nodes
+     */
+    expandAll() {
+        if (this.treeViewElement) {
+            // Implementation depends on Kendo TreeView API
+        }
+    }
+    /**
+     * Get item from lookup
+     */
+    itemLookup(index) {
+        if (this.treeViewElement) {
+            return this.treeViewElement.itemLookup(index);
+        }
+        return undefined;
+    }
+    /**
+     * Log function for debugging events
+     */
+    log(eventName, event) {
+        console.log(`${eventName}:`, event);
+    }
+    /**
+     * Handle drop event with custom logic
+     */
+    handleDrop(event) {
+        console.log('handleDrop:', event);
+        // Add custom drop handling logic here
+        this.nodeDrop.emit(event);
+    }
+    /**
+     * Handle node drag start event
+     */
+    onDragStart(event) {
+        if (!this.dragAndDrop) {
+            event.preventDefault();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: TreeViewComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.18", type: TreeViewComponent, isStandalone: true, selector: "lib-tree-view", inputs: { data: "data", selectable: "selectable", filterable: "filterable", checkboxes: "checkboxes", checkable: "checkable", dragAndDrop: "dragAndDrop", expandable: "expandable", loading: "loading", animate: "animate", size: "size", textField: "textField", childrenField: "childrenField", hasChildrenField: "hasChildrenField", expandedField: "expandedField", selectedField: "selectedField", disabledField: "disabledField", checkedField: "checkedField", iconClassField: "iconClassField", iconField: "iconField", imageUrlField: "imageUrlField", spriteCssClassField: "spriteCssClassField", disabledKeys: "disabledKeys", expandBy: "expandBy", expandedKeys: "expandedKeys", selectedKeys: "selectedKeys", checkedKeys: "checkedKeys", expandDisabledNodes: "expandDisabledNodes", disableNodes: "disableNodes", enableCheck: "enableCheck", checkChildren: "checkChildren", checkDisabledChildren: "checkDisabledChildren", checkParents: "checkParents", checkOnClick: "checkOnClick", uncheckCollapsedChildren: "uncheckCollapsedChildren", checkMode: "checkMode", fetchChildren: "fetchChildren", isChecked: "isChecked", isDisabled: "isDisabled", isExpanded: "isExpanded", isSelected: "isSelected", isVisible: "isVisible", nodeTemplate: "nodeTemplate", loadMoreButtonTemplate: "loadMoreButtonTemplate", loadMoreService: "loadMoreService", pageSize: "pageSize", loadOnDemand: "loadOnDemand", filter: "filter", filterSettings: "filterSettings", navigable: "navigable", trackBy: "trackBy" }, outputs: { selectionChange: "selectionChange", expand: "expand", collapse: "collapse", checkedChange: "checkedChange", nodeClick: "nodeClick", nodeDblClick: "nodeDblClick", nodeDragStart: "nodeDragStart", nodeDrag: "nodeDrag", nodeDrop: "nodeDrop", nodeDragEnd: "nodeDragEnd", addItem: "addItem", removeItem: "removeItem", expandedKeysChange: "expandedKeysChange", selectedKeysChange: "selectedKeysChange", checkedKeysChange: "checkedKeysChange", filterChange: "filterChange", loadMore: "loadMore", childrenLoaded: "childrenLoaded" }, viewQueries: [{ propertyName: "treeViewElement", first: true, predicate: ["treeViewElement"], descendants: true }], ngImport: i0, template: "<div [class]=\"getTreeViewClasses()\">\n\n  <div class=\"treeview-panel\">\n\n    <ng-container [ngSwitch]=\"checkable\">\n\n      <kendo-treeview #treeViewElement *ngSwitchCase=\"true\" [children]=\"children\" kendoTreeViewHierarchyBinding\n        kendoTreeViewExpandable [kendoTreeViewCheckable]=\"checkableSettings\" kendoTreeViewDragAndDrop\n        kendoTreeViewDragAndDropEditing [nodes]=\"data\" [textField]=\"textField\" [childrenField]=\"childrenField\"\n        [filterable]=\"filterable\" [expandBy]=\"expandBy\" [(expandedKeys)]=\"expandedKeys\"\n        [expandDisabledNodes]=\"expandDisabledNodes\" (selectionChange)=\"onSelectionChange($event)\"\n        (checkedChange)=\"onCheckedChange($event)\" (expand)=\"onExpand($event)\" (collapse)=\"onCollapse($event)\"\n        (nodeClick)=\"onNodeClick($event)\" (expandedKeysChange)=\"onExpandedKeysChange($event)\"\n        (nodeDragStart)=\"onDragStart($event)\" (nodeDrop)=\"handleDrop($event)\" (addItem)=\"log('addItem', $event)\"\n        (removeItem)=\"log('removeItem', $event)\" (nodeDragEnd)=\"log('nodeDragEnd', $event)\"\n        (nodeDrag)=\"onNodeDrag($event)\" class=\"lib-tree-view__kendo-tree\" [kendoTreeViewSelectable]=\"selectable\"\n        [filter]=\"filter\" [size]=\"size\" [navigable]=\"navigable\" [loadOnDemand]=\"loadOnDemand\" [trackBy]=\"trackBy\"\n        [hasChildren]=\"hasChildren\" [(selectedKeys)]=\"selectedKeys\" (filterChange)=\"onFilterChange($event)\">\n\n        <!-- Custom Node Template -->\n        <ng-template *ngIf=\"nodeTemplate\" kendoTreeViewNodeTemplate let-dataItem=\"dataItem\" let-index=\"index\">\n          <ng-container [ngTemplateOutlet]=\"nodeTemplate\" [ngTemplateOutletContext]=\"{ \n        $implicit: dataItem, \n        dataItem: dataItem, \n        index: index \n      }\">\n          </ng-container>\n        </ng-template>\n\n        <!-- Load More Button Template -->\n        <ng-template *ngIf=\"loadMoreButtonTemplate\" kendoTreeViewLoadMoreButtonTemplate let-dataItem=\"dataItem\">\n          <ng-container [ngTemplateOutlet]=\"loadMoreButtonTemplate\" [ngTemplateOutletContext]=\"{ \n        $implicit: dataItem, \n        dataItem: dataItem \n      }\">\n          </ng-container>\n        </ng-template>\n\n      </kendo-treeview>\n\n      <!-- TreeView without checkable functionality -->\n      <kendo-treeview #treeViewElement *ngSwitchDefault kendoTreeViewHierarchyBinding kendoTreeViewExpandable\n        kendoTreeViewDragAndDrop kendoTreeViewDragAndDropEditing [nodes]=\"data\" [textField]=\"textField\"\n        [childrenField]=\"childrenField\" [filterable]=\"filterable\" [expandBy]=\"expandBy\" [(expandedKeys)]=\"expandedKeys\"\n        [expandDisabledNodes]=\"expandDisabledNodes\" (selectionChange)=\"onSelectionChange($event)\"\n        (checkedChange)=\"onCheckedChange($event)\" (expand)=\"onExpand($event)\" (collapse)=\"onCollapse($event)\"\n        (nodeClick)=\"onNodeClick($event)\" (expandedKeysChange)=\"onExpandedKeysChange($event)\"\n        (nodeDragStart)=\"onDragStart($event)\" (nodeDrag)=\"onNodeDrag($event)\" (nodeDrop)=\"handleDrop($event)\"\n        (addItem)=\"log('addItem', $event)\" (removeItem)=\"log('removeItem', $event)\"\n        (nodeDragEnd)=\"log('nodeDragEnd', $event)\" class=\"lib-tree-view__kendo-tree\"\n        [kendoTreeViewSelectable]=\"selectable\" [size]=\"size\" [navigable]=\"navigable\" [loadOnDemand]=\"loadOnDemand\"\n        [trackBy]=\"trackBy\" [hasChildren]=\"hasChildren\" [(selectedKeys)]=\"selectedKeys\"\n        (filterChange)=\"onFilterChange($event)\">\n\n        <!-- Custom Node Template -->\n        <ng-template *ngIf=\"nodeTemplate\" kendoTreeViewNodeTemplate let-dataItem=\"dataItem\" let-index=\"index\">\n          <ng-container [ngTemplateOutlet]=\"nodeTemplate\" [ngTemplateOutletContext]=\"{ \n        $implicit: dataItem, \n        dataItem: dataItem, \n        index: index \n      }\">\n          </ng-container>\n        </ng-template>\n\n        <!-- Load More Button Template -->\n        <ng-template *ngIf=\"loadMoreButtonTemplate\" kendoTreeViewLoadMoreButtonTemplate let-dataItem=\"dataItem\">\n          <ng-container [ngTemplateOutlet]=\"loadMoreButtonTemplate\" [ngTemplateOutletContext]=\"{ \n        $implicit: dataItem, \n        dataItem: dataItem \n      }\">\n          </ng-container>\n        </ng-template>\n\n      </kendo-treeview>\n    </ng-container>\n\n    <!-- Loading indicator -->\n    <div *ngIf=\"loading\" class=\"lib-tree-view__loading\">\n      <lib-loader size=\"medium\" type=\"pulsing\" themeColor=\"primary\"></lib-loader>\n    </div>\n  </div>\n", styles: [".lib-tree-view{position:relative;width:100%}.lib-tree-view__loading{position:absolute;inset:0;z-index:10;display:flex;align-items:center;justify-content:center;background-color:#fffc}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "directive", type: i1.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { kind: "directive", type: i1.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { kind: "directive", type: i1.NgSwitchDefault, selector: "[ngSwitchDefault]" }, { kind: "ngmodule", type: TreeViewModule }, { kind: "component", type: i2.TreeViewComponent, selector: "kendo-treeview", inputs: ["filterInputPlaceholder", "expandDisabledNodes", "animate", "nodeTemplate", "loadMoreButtonTemplate", "trackBy", "nodes", "textField", "hasChildren", "isChecked", "isDisabled", "hasCheckbox", "isExpanded", "isSelected", "isVisible", "navigable", "children", "loadOnDemand", "filterable", "filter", "size", "disableParentNodesOnly"], outputs: ["childrenLoaded", "blur", "focus", "expand", "collapse", "nodeDragStart", "nodeDrag", "filterStateChange", "nodeDrop", "nodeDragEnd", "addItem", "removeItem", "checkedChange", "selectionChange", "filterChange", "nodeClick", "nodeDblClick"], exportAs: ["kendoTreeView"] }, { kind: "directive", type: i2.NodeTemplateDirective, selector: "[kendoTreeViewNodeTemplate]" }, { kind: "directive", type: i2.CheckDirective, selector: "[kendoTreeViewCheckable]", inputs: ["isChecked", "checkBy", "checkedKeys", "kendoTreeViewCheckable"], outputs: ["checkedKeysChange"] }, { kind: "directive", type: i2.ExpandDirective, selector: "[kendoTreeViewExpandable]", inputs: ["isExpanded", "expandBy", "expandOnFilter", "expandedKeys"], outputs: ["expandedKeysChange"] }, { kind: "directive", type: i2.SelectDirective, selector: "[kendoTreeViewSelectable]", inputs: ["isSelected", "selectBy", "kendoTreeViewSelectable", "selectedKeys"], outputs: ["selectedKeysChange"] }, { kind: "directive", type: i2.HierarchyBindingDirective, selector: "[kendoTreeViewHierarchyBinding]", inputs: ["childrenField", "nodes", "isVisible", "loadOnDemand"] }, { kind: "directive", type: i2.DragAndDropDirective, selector: "[kendoTreeViewDragAndDrop]", inputs: ["allowCopy", "dropZoneTreeViews", "startDragAfter", "autoScroll"] }, { kind: "directive", type: i2.DragAndDropEditingDirective, selector: "[kendoTreeViewDragAndDropEditing]", inputs: ["editService"] }, { kind: "directive", type: i2.LoadMoreButtonTemplateDirective, selector: "[kendoTreeViewLoadMoreButtonTemplate]" }, { kind: "ngmodule", type: IconsModule }, { kind: "component", type: LoaderComponent, selector: "lib-loader", inputs: ["size", "type", "themeColor"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.18", ngImport: i0, type: TreeViewComponent, decorators: [{
+            type: Component,
+            args: [{ standalone: true, selector: 'lib-tree-view', imports: [
+                        CommonModule,
+                        TreeViewModule,
+                        IconsModule,
+                        ButtonComponent,
+                        IconComponent,
+                        LoaderComponent
+                    ], template: "<div [class]=\"getTreeViewClasses()\">\n\n  <div class=\"treeview-panel\">\n\n    <ng-container [ngSwitch]=\"checkable\">\n\n      <kendo-treeview #treeViewElement *ngSwitchCase=\"true\" [children]=\"children\" kendoTreeViewHierarchyBinding\n        kendoTreeViewExpandable [kendoTreeViewCheckable]=\"checkableSettings\" kendoTreeViewDragAndDrop\n        kendoTreeViewDragAndDropEditing [nodes]=\"data\" [textField]=\"textField\" [childrenField]=\"childrenField\"\n        [filterable]=\"filterable\" [expandBy]=\"expandBy\" [(expandedKeys)]=\"expandedKeys\"\n        [expandDisabledNodes]=\"expandDisabledNodes\" (selectionChange)=\"onSelectionChange($event)\"\n        (checkedChange)=\"onCheckedChange($event)\" (expand)=\"onExpand($event)\" (collapse)=\"onCollapse($event)\"\n        (nodeClick)=\"onNodeClick($event)\" (expandedKeysChange)=\"onExpandedKeysChange($event)\"\n        (nodeDragStart)=\"onDragStart($event)\" (nodeDrop)=\"handleDrop($event)\" (addItem)=\"log('addItem', $event)\"\n        (removeItem)=\"log('removeItem', $event)\" (nodeDragEnd)=\"log('nodeDragEnd', $event)\"\n        (nodeDrag)=\"onNodeDrag($event)\" class=\"lib-tree-view__kendo-tree\" [kendoTreeViewSelectable]=\"selectable\"\n        [filter]=\"filter\" [size]=\"size\" [navigable]=\"navigable\" [loadOnDemand]=\"loadOnDemand\" [trackBy]=\"trackBy\"\n        [hasChildren]=\"hasChildren\" [(selectedKeys)]=\"selectedKeys\" (filterChange)=\"onFilterChange($event)\">\n\n        <!-- Custom Node Template -->\n        <ng-template *ngIf=\"nodeTemplate\" kendoTreeViewNodeTemplate let-dataItem=\"dataItem\" let-index=\"index\">\n          <ng-container [ngTemplateOutlet]=\"nodeTemplate\" [ngTemplateOutletContext]=\"{ \n        $implicit: dataItem, \n        dataItem: dataItem, \n        index: index \n      }\">\n          </ng-container>\n        </ng-template>\n\n        <!-- Load More Button Template -->\n        <ng-template *ngIf=\"loadMoreButtonTemplate\" kendoTreeViewLoadMoreButtonTemplate let-dataItem=\"dataItem\">\n          <ng-container [ngTemplateOutlet]=\"loadMoreButtonTemplate\" [ngTemplateOutletContext]=\"{ \n        $implicit: dataItem, \n        dataItem: dataItem \n      }\">\n          </ng-container>\n        </ng-template>\n\n      </kendo-treeview>\n\n      <!-- TreeView without checkable functionality -->\n      <kendo-treeview #treeViewElement *ngSwitchDefault kendoTreeViewHierarchyBinding kendoTreeViewExpandable\n        kendoTreeViewDragAndDrop kendoTreeViewDragAndDropEditing [nodes]=\"data\" [textField]=\"textField\"\n        [childrenField]=\"childrenField\" [filterable]=\"filterable\" [expandBy]=\"expandBy\" [(expandedKeys)]=\"expandedKeys\"\n        [expandDisabledNodes]=\"expandDisabledNodes\" (selectionChange)=\"onSelectionChange($event)\"\n        (checkedChange)=\"onCheckedChange($event)\" (expand)=\"onExpand($event)\" (collapse)=\"onCollapse($event)\"\n        (nodeClick)=\"onNodeClick($event)\" (expandedKeysChange)=\"onExpandedKeysChange($event)\"\n        (nodeDragStart)=\"onDragStart($event)\" (nodeDrag)=\"onNodeDrag($event)\" (nodeDrop)=\"handleDrop($event)\"\n        (addItem)=\"log('addItem', $event)\" (removeItem)=\"log('removeItem', $event)\"\n        (nodeDragEnd)=\"log('nodeDragEnd', $event)\" class=\"lib-tree-view__kendo-tree\"\n        [kendoTreeViewSelectable]=\"selectable\" [size]=\"size\" [navigable]=\"navigable\" [loadOnDemand]=\"loadOnDemand\"\n        [trackBy]=\"trackBy\" [hasChildren]=\"hasChildren\" [(selectedKeys)]=\"selectedKeys\"\n        (filterChange)=\"onFilterChange($event)\">\n\n        <!-- Custom Node Template -->\n        <ng-template *ngIf=\"nodeTemplate\" kendoTreeViewNodeTemplate let-dataItem=\"dataItem\" let-index=\"index\">\n          <ng-container [ngTemplateOutlet]=\"nodeTemplate\" [ngTemplateOutletContext]=\"{ \n        $implicit: dataItem, \n        dataItem: dataItem, \n        index: index \n      }\">\n          </ng-container>\n        </ng-template>\n\n        <!-- Load More Button Template -->\n        <ng-template *ngIf=\"loadMoreButtonTemplate\" kendoTreeViewLoadMoreButtonTemplate let-dataItem=\"dataItem\">\n          <ng-container [ngTemplateOutlet]=\"loadMoreButtonTemplate\" [ngTemplateOutletContext]=\"{ \n        $implicit: dataItem, \n        dataItem: dataItem \n      }\">\n          </ng-container>\n        </ng-template>\n\n      </kendo-treeview>\n    </ng-container>\n\n    <!-- Loading indicator -->\n    <div *ngIf=\"loading\" class=\"lib-tree-view__loading\">\n      <lib-loader size=\"medium\" type=\"pulsing\" themeColor=\"primary\"></lib-loader>\n    </div>\n  </div>\n", styles: [".lib-tree-view{position:relative;width:100%}.lib-tree-view__loading{position:absolute;inset:0;z-index:10;display:flex;align-items:center;justify-content:center;background-color:#fffc}\n"] }]
+        }], propDecorators: { treeViewElement: [{
+                type: ViewChild,
+                args: ['treeViewElement', { static: false }]
+            }], data: [{
+                type: Input
+            }], selectable: [{
+                type: Input
+            }], filterable: [{
+                type: Input
+            }], checkboxes: [{
+                type: Input
+            }], checkable: [{
+                type: Input
+            }], dragAndDrop: [{
+                type: Input
+            }], expandable: [{
+                type: Input
+            }], loading: [{
+                type: Input
+            }], animate: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], textField: [{
+                type: Input
+            }], childrenField: [{
+                type: Input
+            }], hasChildrenField: [{
+                type: Input
+            }], expandedField: [{
+                type: Input
+            }], selectedField: [{
+                type: Input
+            }], disabledField: [{
+                type: Input
+            }], checkedField: [{
+                type: Input
+            }], iconClassField: [{
+                type: Input
+            }], iconField: [{
+                type: Input
+            }], imageUrlField: [{
+                type: Input
+            }], spriteCssClassField: [{
+                type: Input
+            }], disabledKeys: [{
+                type: Input
+            }], expandBy: [{
+                type: Input
+            }], expandedKeys: [{
+                type: Input
+            }], selectedKeys: [{
+                type: Input
+            }], checkedKeys: [{
+                type: Input
+            }], expandDisabledNodes: [{
+                type: Input
+            }], disableNodes: [{
+                type: Input
+            }], enableCheck: [{
+                type: Input
+            }], checkChildren: [{
+                type: Input
+            }], checkDisabledChildren: [{
+                type: Input
+            }], checkParents: [{
+                type: Input
+            }], checkOnClick: [{
+                type: Input
+            }], uncheckCollapsedChildren: [{
+                type: Input
+            }], checkMode: [{
+                type: Input
+            }], fetchChildren: [{
+                type: Input
+            }], isChecked: [{
+                type: Input
+            }], isDisabled: [{
+                type: Input
+            }], isExpanded: [{
+                type: Input
+            }], isSelected: [{
+                type: Input
+            }], isVisible: [{
+                type: Input
+            }], nodeTemplate: [{
+                type: Input
+            }], loadMoreButtonTemplate: [{
+                type: Input
+            }], loadMoreService: [{
+                type: Input
+            }], pageSize: [{
+                type: Input
+            }], loadOnDemand: [{
+                type: Input
+            }], filter: [{
+                type: Input
+            }], filterSettings: [{
+                type: Input
+            }], navigable: [{
+                type: Input
+            }], trackBy: [{
+                type: Input
+            }], selectionChange: [{
+                type: Output
+            }], expand: [{
+                type: Output
+            }], collapse: [{
+                type: Output
+            }], checkedChange: [{
+                type: Output
+            }], nodeClick: [{
+                type: Output
+            }], nodeDblClick: [{
+                type: Output
+            }], nodeDragStart: [{
+                type: Output
+            }], nodeDrag: [{
+                type: Output
+            }], nodeDrop: [{
+                type: Output
+            }], nodeDragEnd: [{
+                type: Output
+            }], addItem: [{
+                type: Output
+            }], removeItem: [{
+                type: Output
+            }], expandedKeysChange: [{
+                type: Output
+            }], selectedKeysChange: [{
+                type: Output
+            }], checkedKeysChange: [{
+                type: Output
+            }], filterChange: [{
+                type: Output
+            }], loadMore: [{
+                type: Output
+            }], childrenLoaded: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-view.component.js","sourceRoot":"","sources":["../../../../../../projects/shared/src/lib/atoms/tree-view/tree-view.component.ts","../../../../../../projects/shared/src/lib/atoms/tree-view/tree-view.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, Output, EventEmitter, ViewChild, Renderer2, TemplateRef } from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { Observable, of } from 'rxjs';\nimport {\n  TreeViewModule,\n  TreeViewComponent as KendoTreeViewComponent,\n  TreeItemLookup,\n  TreeItemAddRemoveArgs,\n  TreeItemDropEvent,\n  TreeItemDragStartEvent,\n  TreeItemDragEvent,\n  CheckableSettings,\n  CheckMode\n} from '@progress/kendo-angular-treeview';\nimport { IconsModule } from '@progress/kendo-angular-icons';\nimport { ButtonComponent } from '../button/button.component';\nimport { IconComponent } from '../icon/icon.component';\nimport { LoaderComponent } from '../loader/loader.component';\nimport { TreeViewNode } from './tree-view.interfaces';\n\n/**\n * Custom TreeView component that wraps Kendo's TreeView with design system styling.\n * \n * This component provides a hierarchical tree structure for displaying and navigating data.\n * It supports selection, expansion, icons, and custom templates.\n */\n@Component({\n  standalone: true,\n  selector: 'lib-tree-view',\n  templateUrl: './tree-view.component.html',\n  styleUrls: ['./tree-view.component.scss'],\n  imports: [\n    CommonModule,\n    TreeViewModule,\n    IconsModule,\n    ButtonComponent,\n    IconComponent,\n    LoaderComponent\n  ]\n})\nexport class TreeViewComponent {\n\n  /**\n   * ViewChild reference to the Kendo TreeView component instance\n   */\n  @ViewChild('treeViewElement', { static: false }) treeViewElement!: any;\n\n  /**\n   * The data source for the tree view\n   */\n  @Input() data: TreeViewNode[] = [];\n\n  // Basic Properties\n  @Input() selectable: boolean = false;\n  @Input() filterable: boolean = false;\n  @Input() checkboxes: boolean = false;\n  @Input() checkable: boolean = false;\n  @Input() dragAndDrop: boolean = false;\n  @Input() expandable: boolean = true;\n  @Input() loading: boolean = false;\n  @Input() animate: boolean = true;\n  @Input() size: 'small' | 'medium' | 'large' | 'none' = 'medium';\n\n  // Field Configuration\n  @Input() textField: string = 'text';\n  @Input() childrenField: string = 'children';\n  @Input() hasChildrenField: string = 'hasChildren';\n  @Input() expandedField: string = 'expanded';\n  @Input() selectedField: string = 'selected';\n  @Input() disabledField: string = 'disabled';\n  @Input() checkedField: string = 'checked';\n  @Input() iconClassField: string = 'iconClass';\n  @Input() iconField: string = 'icon';\n  @Input() imageUrlField: string = 'imageUrl';\n  @Input() spriteCssClassField: string = 'spriteCssClass';\n\n  // Selection and Expansion\n  @Input() disabledKeys: string[] = [];\n  @Input() expandBy: string | ((item: TreeViewNode) => string) = '';//if expandBy is empty, expandedKeys will use index to track expansion. Otherwise, it will use the field name to decide the expandedKeys.\n  @Input() expandedKeys: string[] = [];\n  @Input() selectedKeys: string[] = [];\n  @Input() checkedKeys: string[] = [];\n  @Input() expandDisabledNodes: boolean = false;\n  @Input() disableNodes: boolean = false;\n\n  // Checkbox Configuration\n  @Input() enableCheck: boolean = false;\n  @Input() checkChildren: boolean = false;\n  @Input() checkDisabledChildren: boolean = false;\n  @Input() checkParents: boolean = false;\n  @Input() checkOnClick: boolean = false;\n  @Input() uncheckCollapsedChildren: boolean = false;\n  @Input() checkMode: CheckMode = \"multiple\";\n\n  // Data Loading\n  @Input() fetchChildren: ((item: any) => any[]) | undefined;\n  @Input() isChecked: ((item: any) => boolean) | undefined;\n  @Input() isDisabled: ((item: any) => boolean) | undefined;\n  @Input() isExpanded: ((item: any) => boolean) | undefined;\n  @Input() isSelected: ((item: any) => boolean) | undefined;\n  @Input() isVisible: ((item: any) => boolean) | undefined;\n\n  // Templates\n  @Input() nodeTemplate: TemplateRef<any> | undefined;\n  @Input() loadMoreButtonTemplate: TemplateRef<any> | undefined;\n\n  // Load More Configuration\n  @Input() loadMoreService: ((item: any) => any[]) | undefined;\n  @Input() pageSize: number = 0;\n  @Input() loadOnDemand: boolean = false;\n\n  // Filtering\n  @Input() filter: string = '';\n  @Input() filterSettings: any;\n\n  // Keyboard Navigation\n  @Input() navigable: boolean = true;\n\n  // Track by function\n  @Input() trackBy: ((index: number, item: TreeViewNode) => any) | undefined;\n\n  // Basic Events\n  @Output() selectionChange = new EventEmitter<any>();\n  @Output() expand = new EventEmitter<any>();\n  @Output() collapse = new EventEmitter<any>();\n  @Output() checkedChange = new EventEmitter<any>();\n  @Output() nodeClick = new EventEmitter<any>();\n  @Output() nodeDblClick = new EventEmitter<any>();\n\n  // Drag and Drop Events\n  @Output() nodeDragStart = new EventEmitter<TreeItemDragStartEvent>();\n  @Output() nodeDrag = new EventEmitter<TreeItemDragEvent>();\n  @Output() nodeDrop = new EventEmitter<TreeItemDropEvent>();\n  @Output() nodeDragEnd = new EventEmitter<TreeItemDragEvent>();\n  @Output() addItem = new EventEmitter<TreeItemAddRemoveArgs>();\n  @Output() removeItem = new EventEmitter<TreeItemAddRemoveArgs>();\n\n  // Key Change Events (Two-way binding support)\n  @Output() expandedKeysChange = new EventEmitter<string[]>();\n  @Output() selectedKeysChange = new EventEmitter<string[]>();\n  @Output() checkedKeysChange = new EventEmitter<string[]>();\n\n  // Filter Events\n  @Output() filterChange = new EventEmitter<string>();\n\n  // Load More Events\n  @Output() loadMore = new EventEmitter<any>();\n\n  // Children Loading Events\n  @Output() childrenLoaded = new EventEmitter<any>();\n  /**\n   * Currently selected items\n   */\n  selectedItems: TreeViewNode[] = [];\n\n  /**\n   * Currently checked items\n   */\n  checkedItems: TreeViewNode[] = [];\n\n  /**\n   * Generates CSS classes for the tree-view container element based on current component state.\n   * Applies conditional styling classes to reflect loading states and enable appropriate visual feedback.\n   * \n   * @returns A space-separated string of CSS class names to apply to the tree-view container\n   */\n  getTreeViewClasses(): string {\n    const classes = ['lib-tree-view'];\n\n    if (this.loading) {\n      classes.push('lib-tree-view--loading');\n    }\n\n    return classes.join(' ');\n  }\n\n  /**\n   * Provides comprehensive checkable settings configuration for the Kendo TreeView component.\n   * Aggregates all checkbox-related input properties into a single configuration object\n   * that controls checkbox behavior including parent-child relationships and interaction modes.\n   * \n   * @returns CheckableSettings object with all checkbox configuration options\n   */\n  public get checkableSettings(): CheckableSettings {\n    return {\n      checkChildren: this.checkChildren,\n      checkDisabledChildren: this.checkDisabledChildren,\n      checkParents: this.checkParents,\n      enabled: this.enableCheck,\n      mode: this.checkMode,\n      checkOnClick: this.checkOnClick,\n      uncheckCollapsedChildren: this.uncheckCollapsedChildren,\n    };\n  }\n\n  /**\n   * Extracts and returns child items from a tree node using the configured children field.\n   * Provides a standardized way for the Kendo TreeView to access hierarchical child data\n   * regardless of the actual field name used in the data structure.\n   * \n   * @param dataItem - The tree node data item to extract children from\n   * @returns Observable array of child items or empty array if no children exist\n   */\n  public children = (dataItem: any): Observable<any[]> => of(dataItem[this.childrenField]);\n\n  /**\n   * Determines whether a tree node has child items for proper expand/collapse icon display.\n   * Checks for the existence of children property and logs the result for debugging purposes.\n   * Used by the TreeView to decide whether to show expansion indicators for each node.\n   * \n   * @param dataItem - The tree node data item to check for children\n   * @returns Boolean indicating whether the node has children that can be expanded\n   */\n  public hasChildren = (dataItem: any): boolean => { return !!dataItem[this.childrenField] };\n\n  // Event Handlers\n\n  /**\n   * Handles tree node selection changes when users select or deselect nodes.\n   * Updates the internal selected items state and propagates the selection event\n   * to parent components for external handling and synchronization.\n   * \n   * @param event - The selection change event containing the newly selected items array\n   */\n  onSelectionChange(event: any): void {\n    this.selectedItems = event;\n    this.selectionChange.emit(event);\n  }\n\n  /**\n   * Handles checkbox state changes when users check or uncheck tree nodes.\n   * Updates the internal checked items state and emits the change event to notify\n   * parent components of the new checkbox selections for form validation or data processing.\n   * \n   * @param event - The checked change event containing the newly checked items array\n   */\n  onCheckedChange(event: any): void {\n    this.checkedItems = event;\n    this.checkedChange.emit(event);\n  }\n\n  /**\n   * Handles tree node expansion events when users click expand icons or use keyboard navigation.\n   * Updates the node's expanded state in the data model and emits the expand event\n   * for parent components to handle lazy loading of child data or state persistence.\n   * \n   * @param event - The expand event containing the expanded node data and context information\n   */\n  onExpand(event: any): void {\n    if (event.dataItem) {\n      event.dataItem[this.expandedField] = true;\n    }\n    this.expand.emit(event);\n  }\n\n  /**\n   * Handles tree node collapse events when users click collapse icons or use keyboard navigation.\n   * Updates the node's expanded state in the data model and emits the collapse event\n   * for parent components to handle state cleanup or memory optimization.\n   * \n   * @param event - The collapse event containing the collapsed node data and context information\n   */\n  onCollapse(event: any): void {\n    if (event.dataItem) {\n      event.dataItem[this.expandedField] = false;\n    }\n    this.collapse.emit(event);\n  }\n\n  /**\n   * Handles single-click events on tree nodes for custom interaction handling.\n   * Propagates click events to parent components for navigation, selection logic,\n   * or custom actions based on the clicked node's data and context.\n   * \n   * @param event - The node click event containing clicked node data and mouse event details\n   */\n  onNodeClick(event: any): void {\n    this.nodeClick.emit(event);\n  }\n\n  /**\n   * Handles double-click events on tree nodes for enhanced interaction patterns.\n   * Typically used for opening detailed views, editing modes, or quick actions\n   * that differ from single-click behavior. Emits event for parent component handling.\n   * \n   * @param event - The node double-click event containing node data and mouse event details\n   */\n  onNodeDblClick(event: any): void {\n    this.nodeDblClick.emit(event);\n  }\n\n  /**\n   * Handles the initiation of drag operations when users start dragging tree nodes.\n   * Validates that drag-and-drop functionality is enabled before proceeding and\n   * emits the drag start event for parent components to handle drag state setup.\n   * \n   * @param event - The tree item drag start event containing source node and drag context\n   */\n  onNodeDragStart(event: TreeItemDragStartEvent): void {\n    if (!this.dragAndDrop) {\n      return;\n    }\n    this.nodeDragStart.emit(event);\n  }\n\n  /**\n   * Handles ongoing drag operations as users move nodes during drag-and-drop actions.\n   * Provides real-time feedback and validation during the drag process, allowing\n   * parent components to update UI indicators or validate drop targets.\n   * \n   * @param event - The tree item drag event containing current drag position and target information\n   */\n  onNodeDrag(event: TreeItemDragEvent): void {\n    this.nodeDrag.emit(event);\n  }\n\n\n  /**\n   * Handles the completion of drag operations when users finish dragging nodes.\n   * Provides cleanup and final processing for drag-and-drop operations, allowing\n   * parent components to finalize data updates and reset drag-related UI states.\n   * \n   * @param event - The tree item drag end event containing final drag state and completion context\n   */\n  onNodeDragEnd(event: TreeItemDragEvent): void {\n    this.nodeDragEnd.emit(event);\n  }\n\n  /**\n   * Handles item addition events when new nodes are added to the tree structure.\n   * Propagates add events to parent components for data persistence, validation,\n   * and tree structure updates to maintain data integrity.\n   * \n   * @param event - The tree item add event containing new item data and insertion context\n   */\n  onAddItem(event: TreeItemAddRemoveArgs): void {\n    this.addItem.emit(event);\n  }\n\n  /**\n   * Handles item removal events when nodes are deleted from the tree structure.\n   * Propagates remove events to parent components for confirmation dialogs, data cleanup,\n   * and cascading deletions of child nodes when necessary.\n   * \n   * @param event - The tree item remove event containing deleted item data and context\n   */\n  onRemoveItem(event: TreeItemAddRemoveArgs): void {\n    this.removeItem.emit(event);\n  }\n\n  /**\n   * Handles expanded keys changes for two-way binding support with parent components.\n   * Synchronizes internal expanded state with external data binding, enabling\n   * programmatic control of tree expansion and state persistence across component updates.\n   * \n   * @param keys - Array of string keys representing currently expanded tree nodes\n   */\n  onExpandedKeysChange(keys: string[]): void {\n    this.expandedKeys = keys;\n    this.expandedKeysChange.emit(keys);\n  }\n\n  /**\n   * Handles selected keys changes for two-way binding support with parent components.\n   * Synchronizes internal selection state with external data binding, enabling\n   * programmatic control of tree selection and form integration capabilities.\n   * \n   * @param keys - Array of string keys representing currently selected tree nodes\n   */\n  onSelectedKeysChange(keys: string[]): void {\n    this.selectedKeys = keys;\n    this.selectedKeysChange.emit(keys);\n  }\n\n  /**\n   * Handles checked keys changes for two-way binding support with parent components.\n   * Synchronizes internal checkbox state with external data binding, enabling\n   * programmatic control of checkbox selections and form validation integration.\n   * \n   * @param keys - Array of string keys representing currently checked tree nodes\n   */\n  onCheckedKeysChange(keys: string[]): void {\n    this.checkedKeys = keys;\n    this.checkedKeysChange.emit(keys);\n  }\n\n  /**\n   * Handles filter text changes when users type in search fields or apply filtering criteria.\n   * Updates the internal filter state and propagates changes to parent components\n   * for server-side filtering or custom search logic implementation.\n   * \n   * @param filter - The filter string entered by the user for tree node searching\n   */\n  onFilterChange(filter: string): void {\n    this.filter = filter;\n    this.filterChange.emit(filter);\n  }\n\n  /**\n   * Handle load more event\n   */\n  onLoadMore(event: any): void {\n    this.loadMore.emit(event);\n  }\n\n  /**\n   * Handle children loaded event\n   */\n  onChildrenLoaded(event: any): void {\n    this.childrenLoaded.emit(event);\n  }\n\n  // Utility Methods\n\n  /**\n   * Expand all nodes\n   */\n  expandAll(): void {\n    if (this.treeViewElement) {\n      // Implementation depends on Kendo TreeView API\n    }\n  }\n\n  /**\n   * Get item from lookup\n   */\n  itemLookup(index: string): TreeItemLookup | undefined {\n    if (this.treeViewElement) {\n      return this.treeViewElement.itemLookup(index);\n    }\n    return undefined;\n  }\n\n  /**\n   * Log function for debugging events\n   */\n  log(eventName: string, event: any): void {\n    console.log(`${eventName}:`, event);\n  }\n\n  /**\n   * Handle drop event with custom logic\n   */\n  handleDrop(event: any): void {\n    console.log('handleDrop:', event);\n    // Add custom drop handling logic here\n    this.nodeDrop.emit(event);\n  }\n\n  /**\n   * Handle node drag start event\n   */\n  onDragStart(event: any): void {\n    if (!this.dragAndDrop) {\n      event.preventDefault();\n    }\n  }\n}\n","<div [class]=\"getTreeViewClasses()\">\n\n  <div class=\"treeview-panel\">\n\n    <ng-container [ngSwitch]=\"checkable\">\n\n      <kendo-treeview #treeViewElement *ngSwitchCase=\"true\" [children]=\"children\" kendoTreeViewHierarchyBinding\n        kendoTreeViewExpandable [kendoTreeViewCheckable]=\"checkableSettings\" kendoTreeViewDragAndDrop\n        kendoTreeViewDragAndDropEditing [nodes]=\"data\" [textField]=\"textField\" [childrenField]=\"childrenField\"\n        [filterable]=\"filterable\" [expandBy]=\"expandBy\" [(expandedKeys)]=\"expandedKeys\"\n        [expandDisabledNodes]=\"expandDisabledNodes\" (selectionChange)=\"onSelectionChange($event)\"\n        (checkedChange)=\"onCheckedChange($event)\" (expand)=\"onExpand($event)\" (collapse)=\"onCollapse($event)\"\n        (nodeClick)=\"onNodeClick($event)\" (expandedKeysChange)=\"onExpandedKeysChange($event)\"\n        (nodeDragStart)=\"onDragStart($event)\" (nodeDrop)=\"handleDrop($event)\" (addItem)=\"log('addItem', $event)\"\n        (removeItem)=\"log('removeItem', $event)\" (nodeDragEnd)=\"log('nodeDragEnd', $event)\"\n        (nodeDrag)=\"onNodeDrag($event)\" class=\"lib-tree-view__kendo-tree\" [kendoTreeViewSelectable]=\"selectable\"\n        [filter]=\"filter\" [size]=\"size\" [navigable]=\"navigable\" [loadOnDemand]=\"loadOnDemand\" [trackBy]=\"trackBy\"\n        [hasChildren]=\"hasChildren\" [(selectedKeys)]=\"selectedKeys\" (filterChange)=\"onFilterChange($event)\">\n\n        <!-- Custom Node Template -->\n        <ng-template *ngIf=\"nodeTemplate\" kendoTreeViewNodeTemplate let-dataItem=\"dataItem\" let-index=\"index\">\n          <ng-container [ngTemplateOutlet]=\"nodeTemplate\" [ngTemplateOutletContext]=\"{ \n        $implicit: dataItem, \n        dataItem: dataItem, \n        index: index \n      }\">\n          </ng-container>\n        </ng-template>\n\n        <!-- Load More Button Template -->\n        <ng-template *ngIf=\"loadMoreButtonTemplate\" kendoTreeViewLoadMoreButtonTemplate let-dataItem=\"dataItem\">\n          <ng-container [ngTemplateOutlet]=\"loadMoreButtonTemplate\" [ngTemplateOutletContext]=\"{ \n        $implicit: dataItem, \n        dataItem: dataItem \n      }\">\n          </ng-container>\n        </ng-template>\n\n      </kendo-treeview>\n\n      <!-- TreeView without checkable functionality -->\n      <kendo-treeview #treeViewElement *ngSwitchDefault kendoTreeViewHierarchyBinding kendoTreeViewExpandable\n        kendoTreeViewDragAndDrop kendoTreeViewDragAndDropEditing [nodes]=\"data\" [textField]=\"textField\"\n        [childrenField]=\"childrenField\" [filterable]=\"filterable\" [expandBy]=\"expandBy\" [(expandedKeys)]=\"expandedKeys\"\n        [expandDisabledNodes]=\"expandDisabledNodes\" (selectionChange)=\"onSelectionChange($event)\"\n        (checkedChange)=\"onCheckedChange($event)\" (expand)=\"onExpand($event)\" (collapse)=\"onCollapse($event)\"\n        (nodeClick)=\"onNodeClick($event)\" (expandedKeysChange)=\"onExpandedKeysChange($event)\"\n        (nodeDragStart)=\"onDragStart($event)\" (nodeDrag)=\"onNodeDrag($event)\" (nodeDrop)=\"handleDrop($event)\"\n        (addItem)=\"log('addItem', $event)\" (removeItem)=\"log('removeItem', $event)\"\n        (nodeDragEnd)=\"log('nodeDragEnd', $event)\" class=\"lib-tree-view__kendo-tree\"\n        [kendoTreeViewSelectable]=\"selectable\" [size]=\"size\" [navigable]=\"navigable\" [loadOnDemand]=\"loadOnDemand\"\n        [trackBy]=\"trackBy\" [hasChildren]=\"hasChildren\" [(selectedKeys)]=\"selectedKeys\"\n        (filterChange)=\"onFilterChange($event)\">\n\n        <!-- Custom Node Template -->\n        <ng-template *ngIf=\"nodeTemplate\" kendoTreeViewNodeTemplate let-dataItem=\"dataItem\" let-index=\"index\">\n          <ng-container [ngTemplateOutlet]=\"nodeTemplate\" [ngTemplateOutletContext]=\"{ \n        $implicit: dataItem, \n        dataItem: dataItem, \n        index: index \n      }\">\n          </ng-container>\n        </ng-template>\n\n        <!-- Load More Button Template -->\n        <ng-template *ngIf=\"loadMoreButtonTemplate\" kendoTreeViewLoadMoreButtonTemplate let-dataItem=\"dataItem\">\n          <ng-container [ngTemplateOutlet]=\"loadMoreButtonTemplate\" [ngTemplateOutletContext]=\"{ \n        $implicit: dataItem, \n        dataItem: dataItem \n      }\">\n          </ng-container>\n        </ng-template>\n\n      </kendo-treeview>\n    </ng-container>\n\n    <!-- Loading indicator -->\n    <div *ngIf=\"loading\" class=\"lib-tree-view__loading\">\n      <lib-loader size=\"medium\" type=\"pulsing\" themeColor=\"primary\"></lib-loader>\n    </div>\n  </div>\n"]}

package/esm2022/lib/atoms/tree-view/tree-view.interfaces.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZS12aWV3LmludGVyZmFjZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9zaGFyZWQvc3JjL2xpYi9hdG9tcy90cmVlLXZpZXcvdHJlZS12aWV3LmludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogVHJlZVZpZXcgbm9kZSBpbnRlcmZhY2Ugd2l0aCBjb21wcmVoZW5zaXZlIHByb3BlcnRpZXNcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBUcmVlVmlld05vZGUge1xuICAvLyBDb3JlIFByb3BlcnRpZXNcbiAgdGV4dDogc3RyaW5nO1xuICB2YWx1ZT86IGFueTtcbiAgaWQ/OiBzdHJpbmcgfCBudW1iZXI7XG5cbiAgLy8gU3RhdGUgUHJvcGVydGllc1xuICBleHBhbmRlZD86IGJvb2xlYW47XG4gIHNlbGVjdGVkPzogYm9vbGVhbjtcbiAgZGlzYWJsZWQ/OiBib29sZWFuO1xuICBjaGVja2VkPzogYm9vbGVhbjtcbiAgdmlzaWJsZT86IGJvb2xlYW47XG5cbiAgLy8gSGllcmFyY2h5IFByb3BlcnRpZXNcbiAgY2hpbGRyZW4/OiBUcmVlVmlld05vZGVbXTtcbiAgcGFyZW50SWQ/OiBzdHJpbmcgfCBudW1iZXI7XG5cbiAgLy8gVmlzdWFsIFByb3BlcnRpZXNcbiAgaWNvbj86IHN0cmluZztcbiAgaWNvbkNsYXNzPzogc3RyaW5nO1xuICBpbWFnZVVybD86IHN0cmluZztcbiAgc3ByaXRlQ3NzQ2xhc3M/OiBzdHJpbmc7XG4gIGNzc0NsYXNzPzogc3RyaW5nO1xuXG4gIC8vIExvYWQgTW9yZSBQcm9wZXJ0aWVzXG4gIGhhc01vcmU/OiBib29sZWFuO1xuICBsb2FkTW9yZVRleHQ/OiBzdHJpbmc7XG5cbiAgLy8gQ3VzdG9tIFByb3BlcnRpZXNcbiAgW2tleTogc3RyaW5nXTogYW55O1xufVxuIl19