concepto-user-controls 0.0.8 → 0.0.9

package/esm2022/lib/concepto-tree/concepto-tree.component.mjs

@@ -1,19 +1,220 @@
-import { Component } from '@angular/core';
+import { Component, Input, Output, EventEmitter, ViewChild, ChangeDetectionStrategy, signal } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { TreeRootComponent } from './components/tree-root/tree-root.component';
 import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@angular/forms";
 export class ConceptoTreeComponent {
+    nodes = [];
+    options = {};
+    initialized = new EventEmitter();
+    toggleExpanded = new EventEmitter();
+    activate = new EventEmitter();
+    deactivate = new EventEmitter();
+    select = new EventEmitter();
+    deselect = new EventEmitter();
+    focus = new EventEmitter();
+    blur = new EventEmitter();
+    moveNode = new EventEmitter();
+    loadChildren = new EventEmitter();
+    treeEvent = new EventEmitter();
+    treeRoot;
+    isDropdownOpen = signal(false);
+    searchTerm = '';
+    selectedNode = signal(null);
+    // All nodes flattened
+    allNodes = [];
+    filteredNodes = signal([]);
+    get displayField() {
+        return this.options.displayField || 'name';
+    }
+    toggleDropdown() {
+        this.isDropdownOpen.update(v => !v);
+        if (this.isDropdownOpen()) {
+            this.searchTerm = '';
+            this.filterNodes();
+        }
+    }
+    closeDropdown() {
+        this.isDropdownOpen.set(false);
+    }
+    filterNodes() {
+        if (!this.searchTerm) {
+            this.filteredNodes.set(this.allNodes);
+        }
+        else {
+            const term = this.searchTerm.toLowerCase();
+            this.filteredNodes.set(this.allNodes.filter(node => String(node.data[this.displayField]).toLowerCase().includes(term)));
+        }
+    }
+    selectNode(node) {
+        this.selectedNode.set(node);
+        this.isDropdownOpen.set(false);
+        // Activate in tree
+        if (this.treeRoot && this.treeRoot.treeModel) {
+            this.treeRoot.treeModel.activateNode(node);
+            node.ensureVisible();
+        }
+    }
+    onTreeInitialized(event) {
+        this.initialized.emit(event);
+        // Get all nodes for the dropdown
+        if (event.treeModel) {
+            this.allNodes = event.treeModel.getAllNodes();
+            this.filteredNodes.set(this.allNodes);
+        }
+    }
+    onNodeActivated(event) {
+        this.activate.emit(event);
+        if (event.node) {
+            this.selectedNode.set(event.node);
+        }
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ConceptoTreeComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: ConceptoTreeComponent, isStandalone: true, selector: "lib-concepto-tree", ngImport: i0, template: `
-    <p>
-      concepto-tree works!
-    </p>
-  `, isInline: true, styles: [""] });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: ConceptoTreeComponent, isStandalone: true, selector: "lib-concepto-tree", inputs: { nodes: "nodes", options: "options" }, outputs: { initialized: "initialized", toggleExpanded: "toggleExpanded", activate: "activate", deactivate: "deactivate", select: "select", deselect: "deselect", focus: "focus", blur: "blur", moveNode: "moveNode", loadChildren: "loadChildren", treeEvent: "treeEvent" }, viewQueries: [{ propertyName: "treeRoot", first: true, predicate: TreeRootComponent, descendants: true }], ngImport: i0, template: `
+    <div class="concepto-tree-container">
+      <div class="search-bar-container">
+        <div class="custom-select" [class.open]="isDropdownOpen()" (click)="toggleDropdown()">
+           <div class="selected-option">
+             {{ selectedNode() ? selectedNode()?.data?.[displayField] : 'Buscar nodo...' }}
+           </div>
+           <div class="arrow">▼</div>
+        </div>
+        
+        <div class="backdrop" *ngIf="isDropdownOpen()" (click)="closeDropdown()"></div>
+
+        <div class="dropdown-menu" *ngIf="isDropdownOpen()">
+           <div class="search-input-wrapper" (click)="$event.stopPropagation()">
+             <input 
+               type="text" 
+               [(ngModel)]="searchTerm" 
+               (ngModelChange)="filterNodes()"
+               placeholder="Buscar..."
+               class="search-input"
+               #searchInput
+               autofocus
+             >
+           </div>
+           <div class="options-list">
+             <div 
+               *ngFor="let node of filteredNodes()" 
+               class="option-item" 
+               (click)="selectNode(node); $event.stopPropagation()"
+             >
+               {{ node.data[displayField] }}
+             </div>
+             <div *ngIf="filteredNodes().length === 0" class="no-results">
+               No se encontraron resultados
+             </div>
+           </div>
+        </div>
+      </div>
+
+      <tree-root
+        [nodes]="nodes"
+        [options]="options"
+        (initialized)="onTreeInitialized($event)"
+        (toggleExpanded)="toggleExpanded.emit($event)"
+        (activate)="onNodeActivated($event)"
+        (deactivate)="deactivate.emit($event)"
+        (select)="select.emit($event)"
+        (deselect)="deselect.emit($event)"
+        (focus)="focus.emit($event)"
+        (blur)="blur.emit($event)"
+        (moveNode)="moveNode.emit($event)"
+        (loadChildren)="loadChildren.emit($event)"
+        (treeEvent)="treeEvent.emit($event)"
+      ></tree-root>
+    </div>
+  `, isInline: true, styles: [".concepto-tree-container{display:flex;flex-direction:column;height:100%;gap:10px}.search-bar-container{position:relative;width:100%;z-index:100}.custom-select{display:flex;justify-content:space-between;align-items:center;padding:8px 12px;border:1px solid #ccc;border-radius:4px;cursor:pointer;background:#fff;-webkit-user-select:none;user-select:none;transition:border-color .2s}.custom-select:hover{border-color:#888}.custom-select.open{border-color:#007bff;border-bottom-left-radius:0;border-bottom-right-radius:0}.backdrop{position:fixed;top:0;left:0;width:100%;height:100%;z-index:101;background:transparent}.dropdown-menu{position:absolute;top:100%;left:0;width:100%;background:#fff;border:1px solid #ccc;border-top:none;border-radius:0 0 4px 4px;box-shadow:0 4px 6px #0000001a;margin-top:0;max-height:300px;overflow-y:auto;z-index:102}.search-input-wrapper{padding:8px;position:sticky;top:0;background:#fff;border-bottom:1px solid #eee;z-index:103}.search-input{width:100%;padding:8px;border:1px solid #ddd;border-radius:4px;box-sizing:border-box;outline:none}.search-input:focus{border-color:#007bff}.options-list{max-height:250px;overflow-y:auto}.option-item{padding:8px 12px;cursor:pointer;transition:background-color .1s}.option-item:hover{background-color:#f5f5f5}.no-results{padding:12px;color:#888;font-style:italic;text-align:center}tree-root{flex:1;overflow:hidden}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i2.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "component", type: TreeRootComponent, selector: "tree-root", inputs: ["nodes", "options"], outputs: ["initialized", "toggleExpanded", "activate", "deactivate", "select", "deselect", "focus", "blur", "moveNode", "loadChildren", "treeEvent"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ConceptoTreeComponent, decorators: [{
             type: Component,
-            args: [{ selector: 'lib-concepto-tree', standalone: true, imports: [], template: `
-    <p>
-      concepto-tree works!
-    </p>
-  ` }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uY2VwdG8tdHJlZS5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25jZXB0by11c2VyLWNvbnRyb2xzL3NyYy9saWIvY29uY2VwdG8tdHJlZS9jb25jZXB0by10cmVlLmNvbXBvbmVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQWExQyxNQUFNLE9BQU8scUJBQXFCO3dHQUFyQixxQkFBcUI7NEZBQXJCLHFCQUFxQiw2RUFQdEI7Ozs7R0FJVDs7NEZBR1UscUJBQXFCO2tCQVhqQyxTQUFTOytCQUNFLG1CQUFtQixjQUNqQixJQUFJLFdBQ1AsRUFBRSxZQUNEOzs7O0dBSVQiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21wb25lbnQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbkBDb21wb25lbnQoe1xyXG4gIHNlbGVjdG9yOiAnbGliLWNvbmNlcHRvLXRyZWUnLFxyXG4gIHN0YW5kYWxvbmU6IHRydWUsXHJcbiAgaW1wb3J0czogW10sXHJcbiAgdGVtcGxhdGU6IGBcclxuICAgIDxwPlxyXG4gICAgICBjb25jZXB0by10cmVlIHdvcmtzIVxyXG4gICAgPC9wPlxyXG4gIGAsXHJcbiAgc3R5bGVzOiBgYFxyXG59KVxyXG5leHBvcnQgY2xhc3MgQ29uY2VwdG9UcmVlQ29tcG9uZW50IHtcclxuXHJcbn1cclxuIl19
+            args: [{ selector: 'lib-concepto-tree', standalone: true, imports: [CommonModule, FormsModule, TreeRootComponent], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div class="concepto-tree-container">
+      <div class="search-bar-container">
+        <div class="custom-select" [class.open]="isDropdownOpen()" (click)="toggleDropdown()">
+           <div class="selected-option">
+             {{ selectedNode() ? selectedNode()?.data?.[displayField] : 'Buscar nodo...' }}
+           </div>
+           <div class="arrow">▼</div>
+        </div>
+        
+        <div class="backdrop" *ngIf="isDropdownOpen()" (click)="closeDropdown()"></div>
+
+        <div class="dropdown-menu" *ngIf="isDropdownOpen()">
+           <div class="search-input-wrapper" (click)="$event.stopPropagation()">
+             <input 
+               type="text" 
+               [(ngModel)]="searchTerm" 
+               (ngModelChange)="filterNodes()"
+               placeholder="Buscar..."
+               class="search-input"
+               #searchInput
+               autofocus
+             >
+           </div>
+           <div class="options-list">
+             <div 
+               *ngFor="let node of filteredNodes()" 
+               class="option-item" 
+               (click)="selectNode(node); $event.stopPropagation()"
+             >
+               {{ node.data[displayField] }}
+             </div>
+             <div *ngIf="filteredNodes().length === 0" class="no-results">
+               No se encontraron resultados
+             </div>
+           </div>
+        </div>
+      </div>
+
+      <tree-root
+        [nodes]="nodes"
+        [options]="options"
+        (initialized)="onTreeInitialized($event)"
+        (toggleExpanded)="toggleExpanded.emit($event)"
+        (activate)="onNodeActivated($event)"
+        (deactivate)="deactivate.emit($event)"
+        (select)="select.emit($event)"
+        (deselect)="deselect.emit($event)"
+        (focus)="focus.emit($event)"
+        (blur)="blur.emit($event)"
+        (moveNode)="moveNode.emit($event)"
+        (loadChildren)="loadChildren.emit($event)"
+        (treeEvent)="treeEvent.emit($event)"
+      ></tree-root>
+    </div>
+  `, styles: [".concepto-tree-container{display:flex;flex-direction:column;height:100%;gap:10px}.search-bar-container{position:relative;width:100%;z-index:100}.custom-select{display:flex;justify-content:space-between;align-items:center;padding:8px 12px;border:1px solid #ccc;border-radius:4px;cursor:pointer;background:#fff;-webkit-user-select:none;user-select:none;transition:border-color .2s}.custom-select:hover{border-color:#888}.custom-select.open{border-color:#007bff;border-bottom-left-radius:0;border-bottom-right-radius:0}.backdrop{position:fixed;top:0;left:0;width:100%;height:100%;z-index:101;background:transparent}.dropdown-menu{position:absolute;top:100%;left:0;width:100%;background:#fff;border:1px solid #ccc;border-top:none;border-radius:0 0 4px 4px;box-shadow:0 4px 6px #0000001a;margin-top:0;max-height:300px;overflow-y:auto;z-index:102}.search-input-wrapper{padding:8px;position:sticky;top:0;background:#fff;border-bottom:1px solid #eee;z-index:103}.search-input{width:100%;padding:8px;border:1px solid #ddd;border-radius:4px;box-sizing:border-box;outline:none}.search-input:focus{border-color:#007bff}.options-list{max-height:250px;overflow-y:auto}.option-item{padding:8px 12px;cursor:pointer;transition:background-color .1s}.option-item:hover{background-color:#f5f5f5}.no-results{padding:12px;color:#888;font-style:italic;text-align:center}tree-root{flex:1;overflow:hidden}\n"] }]
+        }], propDecorators: { nodes: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], initialized: [{
+                type: Output
+            }], toggleExpanded: [{
+                type: Output
+            }], activate: [{
+                type: Output
+            }], deactivate: [{
+                type: Output
+            }], select: [{
+                type: Output
+            }], deselect: [{
+                type: Output
+            }], focus: [{
+                type: Output
+            }], blur: [{
+                type: Output
+            }], moveNode: [{
+                type: Output
+            }], loadChildren: [{
+                type: Output
+            }], treeEvent: [{
+                type: Output
+            }], treeRoot: [{
+                type: ViewChild,
+                args: [TreeRootComponent]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"concepto-tree.component.js","sourceRoot":"","sources":["../../../../../projects/concepto-user-controls/src/lib/concepto-tree/concepto-tree.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,SAAS,EAAE,uBAAuB,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACnH,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,4CAA4C,CAAC;;;;AAmL/E,MAAM,OAAO,qBAAqB;IACvB,KAAK,GAAU,EAAE,CAAC;IAClB,OAAO,GAAyB,EAAE,CAAC;IAElC,WAAW,GAAG,IAAI,YAAY,EAAa,CAAC;IAC5C,cAAc,GAAG,IAAI,YAAY,EAAa,CAAC;IAC/C,QAAQ,GAAG,IAAI,YAAY,EAAa,CAAC;IACzC,UAAU,GAAG,IAAI,YAAY,EAAa,CAAC;IAC3C,MAAM,GAAG,IAAI,YAAY,EAAa,CAAC;IACvC,QAAQ,GAAG,IAAI,YAAY,EAAa,CAAC;IACzC,KAAK,GAAG,IAAI,YAAY,EAAa,CAAC;IACtC,IAAI,GAAG,IAAI,YAAY,EAAa,CAAC;IACrC,QAAQ,GAAG,IAAI,YAAY,EAAa,CAAC;IACzC,YAAY,GAAG,IAAI,YAAY,EAAa,CAAC;IAC7C,SAAS,GAAG,IAAI,YAAY,EAAa,CAAC;IAEtB,QAAQ,CAAqB;IAE3D,cAAc,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAC/B,UAAU,GAAG,EAAE,CAAC;IAChB,YAAY,GAAG,MAAM,CAAkB,IAAI,CAAC,CAAC;IAE7C,sBAAsB;IACd,QAAQ,GAAe,EAAE,CAAC;IAClC,aAAa,GAAG,MAAM,CAAa,EAAE,CAAC,CAAC;IAEvC,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,OAAO,CAAC,YAAY,IAAI,MAAM,CAAC;IAC7C,CAAC;IAED,cAAc;QACZ,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACpC,IAAI,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC;YAC1B,IAAI,CAAC,UAAU,GAAG,EAAE,CAAC;YACrB,IAAI,CAAC,WAAW,EAAE,CAAC;QACrB,CAAC;IACH,CAAC;IAED,aAAa;QACX,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IACjC,CAAC;IAED,WAAW;QACT,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YACrB,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACxC,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE,CAAC;YAC3C,IAAI,CAAC,aAAa,CAAC,GAAG,CACpB,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAC1B,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAClE,CACF,CAAC;QACJ,CAAC;IACH,CAAC;IAED,UAAU,CAAC,IAAc;QACvB,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC5B,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QAE/B,mBAAmB;QACnB,IAAI,IAAI,CAAC,QAAQ,IAAI,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;YAC7C,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;YAC3C,IAAI,CAAC,aAAa,EAAE,CAAC;QACvB,CAAC;IACH,CAAC;IAED,iBAAiB,CAAC,KAAgB;QAChC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC7B,iCAAiC;QACjC,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;YACpB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC;YAC9C,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACxC,CAAC;IACH,CAAC;IAED,eAAe,CAAC,KAAgB;QAC9B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAC1B,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;YACf,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACpC,CAAC;IACH,CAAC;wGAhFU,qBAAqB;4FAArB,qBAAqB,obAgBrB,iBAAiB,gDAzLlB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDT,+6CAzDS,YAAY,+PAAE,WAAW,+mBAAE,iBAAiB;;4FA2K3C,qBAAqB;kBA9KjC,SAAS;+BACE,mBAAmB,cACjB,IAAI,WACP,CAAC,YAAY,EAAE,WAAW,EAAE,iBAAiB,CAAC,mBACtC,uBAAuB,CAAC,MAAM,YACrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDT;8BAmHQ,KAAK;sBAAb,KAAK;gBACG,OAAO;sBAAf,KAAK;gBAEI,WAAW;sBAApB,MAAM;gBACG,cAAc;sBAAvB,MAAM;gBACG,QAAQ;sBAAjB,MAAM;gBACG,UAAU;sBAAnB,MAAM;gBACG,MAAM;sBAAf,MAAM;gBACG,QAAQ;sBAAjB,MAAM;gBACG,KAAK;sBAAd,MAAM;gBACG,IAAI;sBAAb,MAAM;gBACG,QAAQ;sBAAjB,MAAM;gBACG,YAAY;sBAArB,MAAM;gBACG,SAAS;sBAAlB,MAAM;gBAEuB,QAAQ;sBAArC,SAAS;uBAAC,iBAAiB","sourcesContent":["import { Component, Input, Output, EventEmitter, ViewChild, ChangeDetectionStrategy, signal } from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\nimport { FormsModule } from '@angular/forms';\r\nimport { TreeRootComponent } from './components/tree-root/tree-root.component';\r\nimport { TreeOptions } from './core/models/tree-options.model';\r\nimport { TreeEvent } from './core/models/tree-events.model';\r\nimport { TreeNode } from './core/models/tree-node.model';\r\n\r\n@Component({\r\n  selector: 'lib-concepto-tree',\r\n  standalone: true,\r\n  imports: [CommonModule, FormsModule, TreeRootComponent],\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n  template: `\r\n    <div class=\"concepto-tree-container\">\r\n      <div class=\"search-bar-container\">\r\n        <div class=\"custom-select\" [class.open]=\"isDropdownOpen()\" (click)=\"toggleDropdown()\">\r\n           <div class=\"selected-option\">\r\n             {{ selectedNode() ? selectedNode()?.data?.[displayField] : 'Buscar nodo...' }}\r\n           </div>\r\n           <div class=\"arrow\">▼</div>\r\n        </div>\r\n        \r\n        <div class=\"backdrop\" *ngIf=\"isDropdownOpen()\" (click)=\"closeDropdown()\"></div>\r\n\r\n        <div class=\"dropdown-menu\" *ngIf=\"isDropdownOpen()\">\r\n           <div class=\"search-input-wrapper\" (click)=\"$event.stopPropagation()\">\r\n             <input \r\n               type=\"text\" \r\n               [(ngModel)]=\"searchTerm\" \r\n               (ngModelChange)=\"filterNodes()\"\r\n               placeholder=\"Buscar...\"\r\n               class=\"search-input\"\r\n               #searchInput\r\n               autofocus\r\n             >\r\n           </div>\r\n           <div class=\"options-list\">\r\n             <div \r\n               *ngFor=\"let node of filteredNodes()\" \r\n               class=\"option-item\" \r\n               (click)=\"selectNode(node); $event.stopPropagation()\"\r\n             >\r\n               {{ node.data[displayField] }}\r\n             </div>\r\n             <div *ngIf=\"filteredNodes().length === 0\" class=\"no-results\">\r\n               No se encontraron resultados\r\n             </div>\r\n           </div>\r\n        </div>\r\n      </div>\r\n\r\n      <tree-root\r\n        [nodes]=\"nodes\"\r\n        [options]=\"options\"\r\n        (initialized)=\"onTreeInitialized($event)\"\r\n        (toggleExpanded)=\"toggleExpanded.emit($event)\"\r\n        (activate)=\"onNodeActivated($event)\"\r\n        (deactivate)=\"deactivate.emit($event)\"\r\n        (select)=\"select.emit($event)\"\r\n        (deselect)=\"deselect.emit($event)\"\r\n        (focus)=\"focus.emit($event)\"\r\n        (blur)=\"blur.emit($event)\"\r\n        (moveNode)=\"moveNode.emit($event)\"\r\n        (loadChildren)=\"loadChildren.emit($event)\"\r\n        (treeEvent)=\"treeEvent.emit($event)\"\r\n      ></tree-root>\r\n    </div>\r\n  `,\r\n  styles: [`\r\n    .concepto-tree-container {\r\n      display: flex;\r\n      flex-direction: column;\r\n      height: 100%;\r\n      gap: 10px;\r\n    }\r\n    \r\n    .search-bar-container {\r\n      position: relative;\r\n      width: 100%;\r\n      z-index: 100;\r\n    }\r\n\r\n    .custom-select {\r\n      display: flex;\r\n      justify-content: space-between;\r\n      align-items: center;\r\n      padding: 8px 12px;\r\n      border: 1px solid #ccc;\r\n      border-radius: 4px;\r\n      cursor: pointer;\r\n      background: white;\r\n      user-select: none;\r\n      transition: border-color 0.2s;\r\n    }\r\n\r\n    .custom-select:hover {\r\n      border-color: #888;\r\n    }\r\n    \r\n    .custom-select.open {\r\n      border-color: #007bff;\r\n      border-bottom-left-radius: 0;\r\n      border-bottom-right-radius: 0;\r\n    }\r\n\r\n    .backdrop {\r\n      position: fixed;\r\n      top: 0;\r\n      left: 0;\r\n      width: 100%;\r\n      height: 100%;\r\n      z-index: 101;\r\n      background: transparent;\r\n    }\r\n\r\n    .dropdown-menu {\r\n      position: absolute;\r\n      top: 100%;\r\n      left: 0;\r\n      width: 100%;\r\n      background: white;\r\n      border: 1px solid #ccc;\r\n      border-top: none;\r\n      border-radius: 0 0 4px 4px;\r\n      box-shadow: 0 4px 6px rgba(0,0,0,0.1);\r\n      margin-top: 0;\r\n      max-height: 300px;\r\n      overflow-y: auto;\r\n      z-index: 102;\r\n    }\r\n\r\n    .search-input-wrapper {\r\n      padding: 8px;\r\n      position: sticky;\r\n      top: 0;\r\n      background: white;\r\n      border-bottom: 1px solid #eee;\r\n      z-index: 103;\r\n    }\r\n\r\n    .search-input {\r\n      width: 100%;\r\n      padding: 8px;\r\n      border: 1px solid #ddd;\r\n      border-radius: 4px;\r\n      box-sizing: border-box;\r\n      outline: none;\r\n    }\r\n    \r\n    .search-input:focus {\r\n      border-color: #007bff;\r\n    }\r\n\r\n    .options-list {\r\n      max-height: 250px;\r\n      overflow-y: auto;\r\n    }\r\n\r\n    .option-item {\r\n      padding: 8px 12px;\r\n      cursor: pointer;\r\n      transition: background-color 0.1s;\r\n    }\r\n\r\n    .option-item:hover {\r\n      background-color: #f5f5f5;\r\n    }\r\n\r\n    .no-results {\r\n      padding: 12px;\r\n      color: #888;\r\n      font-style: italic;\r\n      text-align: center;\r\n    }\r\n    \r\n    tree-root {\r\n      flex: 1;\r\n      overflow: hidden;\r\n    }\r\n  `]\r\n})\r\nexport class ConceptoTreeComponent {\r\n  @Input() nodes: any[] = [];\r\n  @Input() options: Partial<TreeOptions> = {};\r\n\r\n  @Output() initialized = new EventEmitter<TreeEvent>();\r\n  @Output() toggleExpanded = new EventEmitter<TreeEvent>();\r\n  @Output() activate = new EventEmitter<TreeEvent>();\r\n  @Output() deactivate = new EventEmitter<TreeEvent>();\r\n  @Output() select = new EventEmitter<TreeEvent>();\r\n  @Output() deselect = new EventEmitter<TreeEvent>();\r\n  @Output() focus = new EventEmitter<TreeEvent>();\r\n  @Output() blur = new EventEmitter<TreeEvent>();\r\n  @Output() moveNode = new EventEmitter<TreeEvent>();\r\n  @Output() loadChildren = new EventEmitter<TreeEvent>();\r\n  @Output() treeEvent = new EventEmitter<TreeEvent>();\r\n\r\n  @ViewChild(TreeRootComponent) treeRoot!: TreeRootComponent;\r\n\r\n  isDropdownOpen = signal(false);\r\n  searchTerm = '';\r\n  selectedNode = signal<TreeNode | null>(null);\r\n\r\n  // All nodes flattened\r\n  private allNodes: TreeNode[] = [];\r\n  filteredNodes = signal<TreeNode[]>([]);\r\n\r\n  get displayField(): string {\r\n    return this.options.displayField || 'name';\r\n  }\r\n\r\n  toggleDropdown() {\r\n    this.isDropdownOpen.update(v => !v);\r\n    if (this.isDropdownOpen()) {\r\n      this.searchTerm = '';\r\n      this.filterNodes();\r\n    }\r\n  }\r\n\r\n  closeDropdown() {\r\n    this.isDropdownOpen.set(false);\r\n  }\r\n\r\n  filterNodes() {\r\n    if (!this.searchTerm) {\r\n      this.filteredNodes.set(this.allNodes);\r\n    } else {\r\n      const term = this.searchTerm.toLowerCase();\r\n      this.filteredNodes.set(\r\n        this.allNodes.filter(node =>\r\n          String(node.data[this.displayField]).toLowerCase().includes(term)\r\n        )\r\n      );\r\n    }\r\n  }\r\n\r\n  selectNode(node: TreeNode) {\r\n    this.selectedNode.set(node);\r\n    this.isDropdownOpen.set(false);\r\n\r\n    // Activate in tree\r\n    if (this.treeRoot && this.treeRoot.treeModel) {\r\n      this.treeRoot.treeModel.activateNode(node);\r\n      node.ensureVisible();\r\n    }\r\n  }\r\n\r\n  onTreeInitialized(event: TreeEvent) {\r\n    this.initialized.emit(event);\r\n    // Get all nodes for the dropdown\r\n    if (event.treeModel) {\r\n      this.allNodes = event.treeModel.getAllNodes();\r\n      this.filteredNodes.set(this.allNodes);\r\n    }\r\n  }\r\n\r\n  onNodeActivated(event: TreeEvent) {\r\n    this.activate.emit(event);\r\n    if (event.node) {\r\n      this.selectedNode.set(event.node);\r\n    }\r\n  }\r\n}\r\n"]}

package/esm2022/lib/concepto-tree/core/models/tree-events.model.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZS1ldmVudHMubW9kZWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb25jZXB0by11c2VyLWNvbnRyb2xzL3NyYy9saWIvY29uY2VwdG8tdHJlZS9jb3JlL21vZGVscy90cmVlLWV2ZW50cy5tb2RlbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLy8gbGliL2NvcmUvbW9kZWxzL3RyZWUtZXZlbnRzLm1vZGVsLnRzXHJcbmltcG9ydCB7IFRyZWVOb2RlIH0gZnJvbSAnLi90cmVlLW5vZGUubW9kZWwnO1xyXG5pbXBvcnQgeyBUcmVlTW9kZWwgfSBmcm9tICcuL3RyZWUubW9kZWwnO1xyXG5cclxuZXhwb3J0IHR5cGUgVHJlZUV2ZW50VHlwZSA9XHJcbiAgfCAnaW5pdGlhbGl6ZWQnXHJcbiAgfCAndXBkYXRlJ1xyXG4gIHwgJ2V4cGFuZCdcclxuICB8ICdjb2xsYXBzZSdcclxuICB8ICdleHBhbmRBbGwnXHJcbiAgfCAnY29sbGFwc2VBbGwnXHJcbiAgfCAnYWN0aXZhdGUnXHJcbiAgfCAnZGVhY3RpdmF0ZSdcclxuICB8ICdzZWxlY3QnXHJcbiAgfCAnZGVzZWxlY3QnXHJcbiAgfCAnZm9jdXMnXHJcbiAgfCAnYmx1cidcclxuICB8ICdtb3ZlTm9kZSdcclxuICB8ICdsb2FkQ2hpbGRyZW4nXHJcbiAgfCAnbG9hZENoaWxkcmVuRXJyb3InXHJcbiAgfCAnZmlsdGVyJ1xyXG4gIHwgJ2NsZWFyRmlsdGVyJztcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgVHJlZUV2ZW50IHtcclxuICB0eXBlOiBUcmVlRXZlbnRUeXBlO1xyXG4gIHRyZWVNb2RlbD86IFRyZWVNb2RlbDtcclxuICBub2RlPzogVHJlZU5vZGU7XHJcbiAgdG8/OiB7IHBhcmVudDogVHJlZU5vZGU7IGluZGV4OiBudW1iZXIgfTtcclxuICBlcnJvcj86IGFueTtcclxufSJdfQ==

package/esm2022/lib/concepto-tree/core/models/tree-node.model.mjs

@@ -0,0 +1,102 @@
+// lib/core/models/tree-node.model.ts
+import { signal, computed } from '@angular/core';
+export class TreeNode {
+    // Signals for reactive state
+    isExpanded = signal(false);
+    isActive = signal(false);
+    isSelected = signal(false);
+    isFocused = signal(false);
+    isHidden = signal(false);
+    isLoading = signal(false);
+    // Computed signals
+    isCollapsed = computed(() => !this.isExpanded());
+    isLeaf = computed(() => !this.hasChildren);
+    isVisible = computed(() => !this.isHidden());
+    id;
+    data;
+    parent;
+    children = [];
+    level;
+    path;
+    index;
+    hasChildren;
+    icon;
+    constructor(data, parent, level, index, options) {
+        this.data = data;
+        this.parent = parent;
+        this.level = level;
+        this.index = index;
+        this.id = data[options.idField || 'id'];
+        this.icon = data[options.iconField || 'icon'];
+        const childrenData = data[options.childrenField || 'children'];
+        this.hasChildren = Array.isArray(childrenData) && childrenData.length > 0;
+        // Initialize expanded state
+        if (options.isExpandedField && data[options.isExpandedField]) {
+            this.isExpanded.set(true);
+        }
+        // Build path
+        this.path = parent ? [...parent.path, this.id] : [this.id];
+    }
+    // Actions
+    expand() {
+        if (this.hasChildren) {
+            this.isExpanded.set(true);
+        }
+    }
+    collapse() {
+        this.isExpanded.set(false);
+    }
+    toggle() {
+        this.isExpanded.update(value => !value);
+    }
+    setActive(value) {
+        this.isActive.set(value);
+    }
+    setSelected(value) {
+        this.isSelected.set(value);
+    }
+    setFocus(value) {
+        this.isFocused.set(value);
+    }
+    setHidden(value) {
+        this.isHidden.set(value);
+    }
+    setLoading(value) {
+        this.isLoading.set(value);
+    }
+    // Helper methods
+    ensureVisible() {
+        let node = this.parent;
+        while (node) {
+            node.expand();
+            node = node.parent;
+        }
+    }
+    setActiveAndVisible() {
+        this.ensureVisible();
+        this.setActive(true);
+    }
+    // Get all ancestors
+    getAncestors() {
+        const ancestors = [];
+        let node = this.parent;
+        while (node) {
+            ancestors.unshift(node);
+            node = node.parent;
+        }
+        return ancestors;
+    }
+    // Get all descendants
+    getDescendants() {
+        const descendants = [];
+        const traverse = (node) => {
+            node.children.forEach(child => {
+                descendants.push(child);
+                traverse(child);
+            });
+        };
+        traverse(this);
+        return descendants;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-node.model.js","sourceRoot":"","sources":["../../../../../../../projects/concepto-user-controls/src/lib/concepto-tree/core/models/tree-node.model.ts"],"names":[],"mappings":"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","sourcesContent":["// lib/core/models/tree-node.model.ts\r\nimport { signal, computed, Signal } from '@angular/core';\r\nimport { TreeOptions } from './tree-options.model';\r\n\r\nexport interface TreeNodeData {\r\n  id: string | number;\r\n  [key: string]: any;\r\n}\r\n\r\nexport class TreeNode {\r\n  // Signals for reactive state\r\n  readonly isExpanded = signal(false);\r\n  readonly isActive = signal(false);\r\n  readonly isSelected = signal(false);\r\n  readonly isFocused = signal(false);\r\n  readonly isHidden = signal(false);\r\n  readonly isLoading = signal(false);\r\n  \r\n  // Computed signals\r\n  readonly isCollapsed = computed(() => !this.isExpanded());\r\n  readonly isLeaf = computed(() => !this.hasChildren);\r\n  readonly isVisible = computed(() => !this.isHidden());\r\n  \r\n  id: string | number;\r\n  data: TreeNodeData;\r\n  parent: TreeNode | null;\r\n  children: TreeNode[] = [];\r\n  level: number;\r\n  path: Array<string | number>;\r\n  index: number;\r\n  hasChildren: boolean;\r\n  icon?: string;\r\n  \r\n  constructor(\r\n    data: TreeNodeData,\r\n    parent: TreeNode | null,\r\n    level: number,\r\n    index: number,\r\n    options: TreeOptions\r\n  ) {\r\n    this.data = data;\r\n    this.parent = parent;\r\n    this.level = level;\r\n    this.index = index;\r\n    this.id = data[options.idField || 'id'];\r\n    this.icon = data[options.iconField || 'icon'];\r\n\r\n    const childrenData = data[options.childrenField || 'children'];\r\n    this.hasChildren = Array.isArray(childrenData) && childrenData.length > 0;\r\n    \r\n    // Initialize expanded state\r\n    if (options.isExpandedField && data[options.isExpandedField]) {\r\n      this.isExpanded.set(true);\r\n    }\r\n    \r\n    // Build path\r\n    this.path = parent ? [...parent.path, this.id] : [this.id];\r\n  }\r\n  \r\n  // Actions\r\n  expand(): void {\r\n    if (this.hasChildren) {\r\n      this.isExpanded.set(true);\r\n    }\r\n  }\r\n  \r\n  collapse(): void {\r\n    this.isExpanded.set(false);\r\n  }\r\n  \r\n  toggle(): void {\r\n    this.isExpanded.update(value => !value);\r\n  }\r\n  \r\n  setActive(value: boolean): void {\r\n    this.isActive.set(value);\r\n  }\r\n  \r\n  setSelected(value: boolean): void {\r\n    this.isSelected.set(value);\r\n  }\r\n  \r\n  setFocus(value: boolean): void {\r\n    this.isFocused.set(value);\r\n  }\r\n  \r\n  setHidden(value: boolean): void {\r\n    this.isHidden.set(value);\r\n  }\r\n  \r\n  setLoading(value: boolean): void {\r\n    this.isLoading.set(value);\r\n  }\r\n  \r\n  // Helper methods\r\n  ensureVisible(): void {\r\n    let node: TreeNode | null = this.parent;\r\n    while (node) {\r\n      node.expand();\r\n      node = node.parent;\r\n    }\r\n  }\r\n  \r\n  setActiveAndVisible(): void {\r\n    this.ensureVisible();\r\n    this.setActive(true);\r\n  }\r\n  \r\n  // Get all ancestors\r\n  getAncestors(): TreeNode[] {\r\n    const ancestors: TreeNode[] = [];\r\n    let node: TreeNode | null = this.parent;\r\n    while (node) {\r\n      ancestors.unshift(node);\r\n      node = node.parent;\r\n    }\r\n    return ancestors;\r\n  }\r\n  \r\n  // Get all descendants\r\n  getDescendants(): TreeNode[] {\r\n    const descendants: TreeNode[] = [];\r\n    const traverse = (node: TreeNode) => {\r\n      node.children.forEach(child => {\r\n        descendants.push(child);\r\n        traverse(child);\r\n      });\r\n    };\r\n    traverse(this);\r\n    return descendants;\r\n  }\r\n}"]}

package/esm2022/lib/concepto-tree/core/models/tree-options.model.mjs

@@ -0,0 +1,24 @@
+export const DEFAULT_TREE_OPTIONS = {
+    idField: 'id',
+    childrenField: 'children',
+    displayField: 'name',
+    isExpandedField: 'isExpanded',
+    hasChildrenField: 'hasChildren',
+    iconField: 'icon',
+    allowDrag: false,
+    allowDrop: false,
+    useCheckbox: false,
+    useTriState: false,
+    levelPadding: 20,
+    useVirtualScroll: false,
+    nodeHeight: 22,
+    bufferAmount: 5,
+    animateExpand: false,
+    animateSpeed: 1,
+    animateAcceleration: 1.2,
+    scrollOnActivate: true,
+    rtl: false,
+    multiSelect: false,
+    useMetaKey: true,
+};
+//# sourceMappingURL=data:application/json;base64,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