concepto-user-controls 0.0.8 → 0.0.9

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

@@ -0,0 +1,230 @@
+// lib/components/tree-root/tree-root.component.ts
+import { Component, Input, Output, EventEmitter, HostListener, signal, contentChild, TemplateRef, ChangeDetectionStrategy, } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { TreeModel } from '../../core/models/tree.model';
+import { DEFAULT_TREE_OPTIONS } from '../../core/models/tree-options.model';
+import { TreeNodeComponent } from '../tree-node/tree-node.component';
+import { TreeViewportComponent } from '../tree-viewport/tree-viewport.component';
+import { TreeNodeTemplateDirective } from '../../directives/tree-node-template.directive';
+import * as i0 from "@angular/core";
+export class TreeRootComponent {
+    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();
+    // Content queries
+    nodeTemplate = contentChild(TreeNodeTemplateDirective, {
+        read: TemplateRef
+    });
+    treeModel;
+    mergedOptions;
+    isFocused = signal(false);
+    eventsSubscription;
+    ngOnInit() {
+        this.initializeTreeModel();
+    }
+    ngOnChanges(changes) {
+        if (changes['options'] && !changes['options'].firstChange) {
+            this.initializeTreeModel();
+        }
+        if (changes['nodes'] && !changes['nodes'].firstChange) {
+            this.treeModel.setData(this.nodes);
+        }
+    }
+    initializeTreeModel() {
+        // Unsubscribe from previous subscription if exists
+        this.eventsSubscription?.unsubscribe();
+        this.mergedOptions = {
+            ...DEFAULT_TREE_OPTIONS,
+            ...this.options,
+        };
+        this.treeModel = new TreeModel(this.mergedOptions);
+        this.treeModel.setData(this.nodes);
+        // Subscribe to tree events
+        this.eventsSubscription = this.treeModel.events$.subscribe(event => {
+            this.handleTreeEvent(event);
+        });
+    }
+    ngOnDestroy() {
+        // Clean up subscription
+        this.eventsSubscription?.unsubscribe();
+    }
+    handleTreeEvent(event) {
+        this.treeEvent.emit(event);
+        switch (event.type) {
+            case 'initialized':
+                this.initialized.emit(event);
+                break;
+            case 'expand':
+            case 'collapse':
+                this.toggleExpanded.emit(event);
+                break;
+            case 'activate':
+                this.activate.emit(event);
+                break;
+            case 'deactivate':
+                this.deactivate.emit(event);
+                break;
+            case 'select':
+                this.select.emit(event);
+                break;
+            case 'deselect':
+                this.deselect.emit(event);
+                break;
+            case 'focus':
+                this.focus.emit(event);
+                break;
+            case 'blur':
+                this.blur.emit(event);
+                break;
+            case 'moveNode':
+                this.moveNode.emit(event);
+                break;
+            case 'loadChildren':
+                this.loadChildren.emit(event);
+                break;
+        }
+    }
+    // Keyboard navigation
+    onKeydown(event) {
+        if (!this.isFocused())
+            return;
+        const key = event.key;
+        const isRtl = this.options.rtl;
+        switch (key) {
+            case 'ArrowDown':
+                this.treeModel.focusNextNode();
+                event.preventDefault();
+                break;
+            case 'ArrowUp':
+                this.treeModel.focusPreviousNode();
+                event.preventDefault();
+                break;
+            case 'ArrowRight':
+                isRtl ? this.treeModel.focusDrillUp() : this.treeModel.focusDrillDown();
+                event.preventDefault();
+                break;
+            case 'ArrowLeft':
+                isRtl ? this.treeModel.focusDrillDown() : this.treeModel.focusDrillUp();
+                event.preventDefault();
+                break;
+            case 'Enter':
+            case ' ':
+                const focused = this.treeModel.focusedNode();
+                if (focused) {
+                    this.treeModel.activateNode(focused);
+                }
+                event.preventDefault();
+                break;
+        }
+    }
+    onFocus() {
+        this.isFocused.set(true);
+    }
+    onBlur() {
+        this.isFocused.set(false);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeRootComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: TreeRootComponent, isStandalone: true, selector: "tree-root", 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" }, host: { listeners: { "keydown": "onKeydown($event)", "focus": "onFocus()", "blur": "onBlur()" }, properties: { "class.tree-focused": "isFocused()" } }, queries: [{ propertyName: "nodeTemplate", first: true, predicate: TreeNodeTemplateDirective, descendants: true, read: TemplateRef, isSignal: true }], usesOnChanges: true, ngImport: i0, template: `
+    <div
+      class="tree-container"
+      [class.tree-rtl]="mergedOptions?.rtl"
+      tabindex="0">
+
+      @if (mergedOptions?.useVirtualScroll) {
+        <tree-viewport
+          [treeModel]="treeModel"
+          [options]="mergedOptions"
+          [nodeTemplate]="nodeTemplate()">
+        </tree-viewport>
+      } @else {
+        @for (root of treeModel.roots(); track root.id) {
+          <tree-node
+            [node]="root"
+            [treeModel]="treeModel"
+            [options]="mergedOptions"
+            [nodeTemplate]="nodeTemplate()">
+          </tree-node>
+        }
+      }
+    </div>
+  `, isInline: true, styles: [".tree-container{width:100%;height:100%;outline:none}.tree-rtl{direction:rtl}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: TreeNodeComponent, selector: "tree-node", inputs: ["node", "treeModel", "options", "nodeTemplate"] }, { kind: "component", type: TreeViewportComponent, selector: "tree-viewport", inputs: ["treeModel", "options", "nodeTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeRootComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tree-root', standalone: true, imports: [
+                        CommonModule,
+                        TreeNodeComponent,
+                        TreeViewportComponent,
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div
+      class="tree-container"
+      [class.tree-rtl]="mergedOptions?.rtl"
+      tabindex="0">
+
+      @if (mergedOptions?.useVirtualScroll) {
+        <tree-viewport
+          [treeModel]="treeModel"
+          [options]="mergedOptions"
+          [nodeTemplate]="nodeTemplate()">
+        </tree-viewport>
+      } @else {
+        @for (root of treeModel.roots(); track root.id) {
+          <tree-node
+            [node]="root"
+            [treeModel]="treeModel"
+            [options]="mergedOptions"
+            [nodeTemplate]="nodeTemplate()">
+          </tree-node>
+        }
+      }
+    </div>
+  `, host: {
+                        '[class.tree-focused]': 'isFocused()',
+                    }, styles: [".tree-container{width:100%;height:100%;outline:none}.tree-rtl{direction:rtl}\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
+            }], onKeydown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }], onFocus: [{
+                type: HostListener,
+                args: ['focus']
+            }], onBlur: [{
+                type: HostListener,
+                args: ['blur']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-root.component.js","sourceRoot":"","sources":["../../../../../../../projects/concepto-user-controls/src/lib/concepto-tree/components/tree-root/tree-root.component.ts"],"names":[],"mappings":"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","sourcesContent":["// lib/components/tree-root/tree-root.component.ts\r\nimport {\r\n  Component,\r\n  Input,\r\n  Output,\r\n  EventEmitter,\r\n  OnInit,\r\n  OnChanges,\r\n  OnDestroy,\r\n  SimpleChanges,\r\n  HostListener,\r\n  signal,\r\n  contentChild,\r\n  TemplateRef,\r\n  ChangeDetectionStrategy,\r\n} from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\nimport { Subscription } from 'rxjs';\r\nimport { TreeModel } from '../../core/models/tree.model';\r\nimport { TreeOptions, DEFAULT_TREE_OPTIONS } from '../../core/models/tree-options.model';\r\nimport { TreeEvent } from '../../core/models/tree-events.model';\r\nimport { TreeNodeComponent } from '../tree-node/tree-node.component';\r\nimport { TreeViewportComponent } from '../tree-viewport/tree-viewport.component';\r\nimport { TreeNodeTemplateDirective } from '../../directives/tree-node-template.directive';\r\n\r\n@Component({\r\n  selector: 'tree-root',\r\n  standalone: true,\r\n  imports: [\r\n    CommonModule,\r\n    TreeNodeComponent,\r\n    TreeViewportComponent,\r\n  ],\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n  template: `\r\n    <div\r\n      class=\"tree-container\"\r\n      [class.tree-rtl]=\"mergedOptions?.rtl\"\r\n      tabindex=\"0\">\r\n\r\n      @if (mergedOptions?.useVirtualScroll) {\r\n        <tree-viewport\r\n          [treeModel]=\"treeModel\"\r\n          [options]=\"mergedOptions\"\r\n          [nodeTemplate]=\"nodeTemplate()\">\r\n        </tree-viewport>\r\n      } @else {\r\n        @for (root of treeModel.roots(); track root.id) {\r\n          <tree-node\r\n            [node]=\"root\"\r\n            [treeModel]=\"treeModel\"\r\n            [options]=\"mergedOptions\"\r\n            [nodeTemplate]=\"nodeTemplate()\">\r\n          </tree-node>\r\n        }\r\n      }\r\n    </div>\r\n  `,\r\n  styles: [`\r\n    .tree-container {\r\n      width: 100%;\r\n      height: 100%;\r\n      outline: none;\r\n    }\r\n    \r\n    .tree-rtl {\r\n      direction: rtl;\r\n    }\r\n  `],\r\n  host: {\r\n    '[class.tree-focused]': 'isFocused()',\r\n  },\r\n})\r\nexport class TreeRootComponent implements OnInit, OnChanges, OnDestroy {\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  // Content queries\r\n  readonly nodeTemplate = contentChild(TreeNodeTemplateDirective, {\r\n    read: TemplateRef\r\n  });\r\n  \r\n  treeModel!: TreeModel;\r\n  mergedOptions!: TreeOptions;\r\n  isFocused = signal(false);\r\n\r\n  private eventsSubscription?: Subscription;\r\n  \r\n  ngOnInit(): void {\r\n    this.initializeTreeModel();\r\n  }\r\n  \r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    if (changes['options'] && !changes['options'].firstChange) {\r\n      this.initializeTreeModel();\r\n    }\r\n    \r\n    if (changes['nodes'] && !changes['nodes'].firstChange) {\r\n      this.treeModel.setData(this.nodes);\r\n    }\r\n  }\r\n  \r\n  private initializeTreeModel(): void {\r\n    // Unsubscribe from previous subscription if exists\r\n    this.eventsSubscription?.unsubscribe();\r\n\r\n    this.mergedOptions = {\r\n      ...DEFAULT_TREE_OPTIONS,\r\n      ...this.options,\r\n    };\r\n\r\n    this.treeModel = new TreeModel(this.mergedOptions);\r\n    this.treeModel.setData(this.nodes);\r\n\r\n    // Subscribe to tree events\r\n    this.eventsSubscription = this.treeModel.events$.subscribe(event => {\r\n      this.handleTreeEvent(event);\r\n    });\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    // Clean up subscription\r\n    this.eventsSubscription?.unsubscribe();\r\n  }\r\n  \r\n  private handleTreeEvent(event: TreeEvent): void {\r\n    this.treeEvent.emit(event);\r\n    \r\n    switch (event.type) {\r\n      case 'initialized':\r\n        this.initialized.emit(event);\r\n        break;\r\n      case 'expand':\r\n      case 'collapse':\r\n        this.toggleExpanded.emit(event);\r\n        break;\r\n      case 'activate':\r\n        this.activate.emit(event);\r\n        break;\r\n      case 'deactivate':\r\n        this.deactivate.emit(event);\r\n        break;\r\n      case 'select':\r\n        this.select.emit(event);\r\n        break;\r\n      case 'deselect':\r\n        this.deselect.emit(event);\r\n        break;\r\n      case 'focus':\r\n        this.focus.emit(event);\r\n        break;\r\n      case 'blur':\r\n        this.blur.emit(event);\r\n        break;\r\n      case 'moveNode':\r\n        this.moveNode.emit(event);\r\n        break;\r\n      case 'loadChildren':\r\n        this.loadChildren.emit(event);\r\n        break;\r\n    }\r\n  }\r\n  \r\n  // Keyboard navigation\r\n  @HostListener('keydown', ['$event'])\r\n  onKeydown(event: KeyboardEvent): void {\r\n    if (!this.isFocused()) return;\r\n    \r\n    const key = event.key;\r\n    const isRtl = this.options.rtl;\r\n    \r\n    switch (key) {\r\n      case 'ArrowDown':\r\n        this.treeModel.focusNextNode();\r\n        event.preventDefault();\r\n        break;\r\n      case 'ArrowUp':\r\n        this.treeModel.focusPreviousNode();\r\n        event.preventDefault();\r\n        break;\r\n      case 'ArrowRight':\r\n        isRtl ? this.treeModel.focusDrillUp() : this.treeModel.focusDrillDown();\r\n        event.preventDefault();\r\n        break;\r\n      case 'ArrowLeft':\r\n        isRtl ? this.treeModel.focusDrillDown() : this.treeModel.focusDrillUp();\r\n        event.preventDefault();\r\n        break;\r\n      case 'Enter':\r\n      case ' ':\r\n        const focused = this.treeModel.focusedNode();\r\n        if (focused) {\r\n          this.treeModel.activateNode(focused);\r\n        }\r\n        event.preventDefault();\r\n        break;\r\n    }\r\n  }\r\n  \r\n  @HostListener('focus')\r\n  onFocus(): void {\r\n    this.isFocused.set(true);\r\n  }\r\n  \r\n  @HostListener('blur')\r\n  onBlur(): void {\r\n    this.isFocused.set(false);\r\n  }\r\n}"]}

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

@@ -0,0 +1,216 @@
+// lib/components/tree-viewport/tree-viewport.component.ts
+import { Component, Input, ViewChild, ChangeDetectionStrategy, signal, computed, effect, } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { TreeNodeComponent } from '../tree-node/tree-node.component';
+import { fromEvent, Subject, takeUntil } from 'rxjs';
+import { debounceTime } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class TreeViewportComponent {
+    treeModel;
+    options;
+    nodeTemplate;
+    scrollContainer;
+    destroy$ = new Subject();
+    scrollTop = signal(0);
+    viewportHeight = signal(0);
+    flattenedNodes = computed(() => {
+        return this.treeModel.flattenedNodes();
+    });
+    totalHeight = computed(() => {
+        const nodes = this.flattenedNodes();
+        const nodeHeight = this.options.nodeHeight || 22;
+        if (typeof nodeHeight === 'number') {
+            return nodes.length * nodeHeight;
+        }
+        return nodes.reduce((sum, node) => sum + nodeHeight(node), 0);
+    });
+    visibleRange = computed(() => {
+        const scrollTop = this.scrollTop();
+        const viewportHeight = this.viewportHeight();
+        const nodes = this.flattenedNodes();
+        const nodeHeight = this.options.nodeHeight || 22;
+        const bufferAmount = this.options.bufferAmount || 5;
+        let startIndex = 0;
+        let accumulatedHeight = 0;
+        // Find start index
+        for (let i = 0; i < nodes.length; i++) {
+            const height = typeof nodeHeight === 'number'
+                ? nodeHeight
+                : nodeHeight(nodes[i]);
+            if (accumulatedHeight + height > scrollTop) {
+                startIndex = Math.max(0, i - bufferAmount);
+                break;
+            }
+            accumulatedHeight += height;
+        }
+        // Find end index
+        let endIndex = startIndex;
+        accumulatedHeight = 0;
+        for (let i = startIndex; i < nodes.length; i++) {
+            const height = typeof nodeHeight === 'number'
+                ? nodeHeight
+                : nodeHeight(nodes[i]);
+            accumulatedHeight += height;
+            if (accumulatedHeight > viewportHeight + (bufferAmount * (typeof nodeHeight === 'number' ? nodeHeight : 22))) {
+                endIndex = i;
+                break;
+            }
+        }
+        if (endIndex === startIndex) {
+            endIndex = nodes.length;
+        }
+        return { startIndex, endIndex };
+    });
+    visibleNodes = computed(() => {
+        const range = this.visibleRange();
+        const nodes = this.flattenedNodes();
+        return nodes.slice(range.startIndex, range.endIndex);
+    });
+    paddingTop = computed(() => {
+        const range = this.visibleRange();
+        const nodes = this.flattenedNodes();
+        const nodeHeight = this.options.nodeHeight || 22;
+        let height = 0;
+        for (let i = 0; i < range.startIndex; i++) {
+            height += typeof nodeHeight === 'number'
+                ? nodeHeight
+                : nodeHeight(nodes[i]);
+        }
+        return height;
+    });
+    paddingBottom = computed(() => {
+        const range = this.visibleRange();
+        const nodes = this.flattenedNodes();
+        const nodeHeight = this.options.nodeHeight || 22;
+        const totalHeight = this.totalHeight();
+        let visibleHeight = this.paddingTop();
+        for (let i = range.startIndex; i < range.endIndex; i++) {
+            visibleHeight += typeof nodeHeight === 'number'
+                ? nodeHeight
+                : nodeHeight(nodes[i]);
+        }
+        return Math.max(0, totalHeight - visibleHeight);
+    });
+    constructor() {
+        // Update viewport when tree changes
+        effect(() => {
+            this.flattenedNodes(); // Subscribe to changes
+            this.updateViewport();
+        });
+    }
+    ngOnInit() {
+        this.setupScrollListener();
+        this.updateViewportHeight();
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    setupScrollListener() {
+        fromEvent(this.scrollContainer.nativeElement, 'scroll')
+            .pipe(debounceTime(10), takeUntil(this.destroy$))
+            .subscribe(() => {
+            this.onScroll();
+        });
+    }
+    updateViewportHeight() {
+        const height = this.scrollContainer.nativeElement.clientHeight;
+        this.viewportHeight.set(height);
+    }
+    onScroll() {
+        const scrollTop = this.scrollContainer.nativeElement.scrollTop;
+        this.scrollTop.set(scrollTop);
+    }
+    updateViewport() {
+        // Force recalculation
+        this.scrollTop.set(this.scrollContainer.nativeElement.scrollTop);
+    }
+    scrollToNode(node) {
+        const nodes = this.flattenedNodes();
+        const index = nodes.findIndex(n => n.id === node.id);
+        if (index === -1)
+            return;
+        const nodeHeight = this.options.nodeHeight || 22;
+        let targetScrollTop = 0;
+        for (let i = 0; i < index; i++) {
+            targetScrollTop += typeof nodeHeight === 'number'
+                ? nodeHeight
+                : nodeHeight(nodes[i]);
+        }
+        this.scrollContainer.nativeElement.scrollTop = targetScrollTop;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeViewportComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: TreeViewportComponent, isStandalone: true, selector: "tree-viewport", inputs: { treeModel: "treeModel", options: "options", nodeTemplate: "nodeTemplate" }, viewQueries: [{ propertyName: "scrollContainer", first: true, predicate: ["scrollContainer"], descendants: true, static: true }], ngImport: i0, template: `
+    <div 
+      #scrollContainer
+      class="tree-viewport-container"
+      [style.height.px]="options.scrollContainerHeight || 400"
+      (scroll)="onScroll()">
+      
+      <div class="tree-viewport-content"
+           [style.height.px]="totalHeight()">
+        
+        <div class="tree-viewport-padding-top"
+             [style.height.px]="paddingTop()">
+        </div>
+        
+        @for (node of visibleNodes(); track node.id) {
+          <tree-node
+            [node]="node"
+            [treeModel]="treeModel"
+            [options]="options"
+            [nodeTemplate]="nodeTemplate">
+          </tree-node>
+        }
+        
+        <div class="tree-viewport-padding-bottom"
+             [style.height.px]="paddingBottom()">
+        </div>
+      </div>
+    </div>
+  `, isInline: true, styles: [".tree-viewport-container{overflow-y:auto;overflow-x:hidden;position:relative}.tree-viewport-content{position:relative;width:100%}.tree-viewport-padding-top,.tree-viewport-padding-bottom{width:100%}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "component", type: TreeNodeComponent, selector: "tree-node", inputs: ["node", "treeModel", "options", "nodeTemplate"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeViewportComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'tree-viewport', standalone: true, imports: [CommonModule, TreeNodeComponent], changeDetection: ChangeDetectionStrategy.OnPush, template: `
+    <div 
+      #scrollContainer
+      class="tree-viewport-container"
+      [style.height.px]="options.scrollContainerHeight || 400"
+      (scroll)="onScroll()">
+      
+      <div class="tree-viewport-content"
+           [style.height.px]="totalHeight()">
+        
+        <div class="tree-viewport-padding-top"
+             [style.height.px]="paddingTop()">
+        </div>
+        
+        @for (node of visibleNodes(); track node.id) {
+          <tree-node
+            [node]="node"
+            [treeModel]="treeModel"
+            [options]="options"
+            [nodeTemplate]="nodeTemplate">
+          </tree-node>
+        }
+        
+        <div class="tree-viewport-padding-bottom"
+             [style.height.px]="paddingBottom()">
+        </div>
+      </div>
+    </div>
+  `, styles: [".tree-viewport-container{overflow-y:auto;overflow-x:hidden;position:relative}.tree-viewport-content{position:relative;width:100%}.tree-viewport-padding-top,.tree-viewport-padding-bottom{width:100%}\n"] }]
+        }], ctorParameters: () => [], propDecorators: { treeModel: [{
+                type: Input,
+                args: [{ required: true }]
+            }], options: [{
+                type: Input,
+                args: [{ required: true }]
+            }], nodeTemplate: [{
+                type: Input
+            }], scrollContainer: [{
+                type: ViewChild,
+                args: ['scrollContainer', { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-viewport.component.js","sourceRoot":"","sources":["../../../../../../../projects/concepto-user-controls/src/lib/concepto-tree/components/tree-viewport/tree-viewport.component.ts"],"names":[],"mappings":"AAAA,0DAA0D;AAC1D,OAAO,EACL,SAAS,EACT,KAAK,EAGL,SAAS,EAET,uBAAuB,EACvB,MAAM,EACN,QAAQ,EAER,MAAM,GACP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAI/C,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AACrD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;;AAsD9C,MAAM,OAAO,qBAAqB;IACL,SAAS,CAAa;IACtB,OAAO,CAAe;IACxC,YAAY,CAAoB;IAGzC,eAAe,CAA2B;IAElC,QAAQ,GAAG,IAAI,OAAO,EAAQ,CAAC;IAE9B,SAAS,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IACtB,cAAc,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IAE3B,cAAc,GAAG,QAAQ,CAAC,GAAG,EAAE;QACtC,OAAO,IAAI,CAAC,SAAS,CAAC,cAAc,EAAE,CAAC;IACzC,CAAC,CAAC,CAAC;IAEM,WAAW,GAAG,QAAQ,CAAC,GAAG,EAAE;QACnC,MAAM,KAAK,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;QACpC,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,IAAI,EAAE,CAAC;QAEjD,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,CAAC;YACnC,OAAO,KAAK,CAAC,MAAM,GAAG,UAAU,CAAC;QACnC,CAAC;QAED,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE,CAAC,GAAG,GAAG,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;IAChE,CAAC,CAAC,CAAC;IAEM,YAAY,GAAG,QAAQ,CAAC,GAAG,EAAE;QACpC,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;QACnC,MAAM,cAAc,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;QAC7C,MAAM,KAAK,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;QACpC,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,IAAI,EAAE,CAAC;QACjD,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,IAAI,CAAC,CAAC;QAEpD,IAAI,UAAU,GAAG,CAAC,CAAC;QACnB,IAAI,iBAAiB,GAAG,CAAC,CAAC;QAE1B,mBAAmB;QACnB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACtC,MAAM,MAAM,GAAG,OAAO,UAAU,KAAK,QAAQ;gBAC3C,CAAC,CAAC,UAAU;gBACZ,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;YAEzB,IAAI,iBAAiB,GAAG,MAAM,GAAG,SAAS,EAAE,CAAC;gBAC3C,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC;gBAC3C,MAAM;YACR,CAAC;YACD,iBAAiB,IAAI,MAAM,CAAC;QAC9B,CAAC;QAED,iBAAiB;QACjB,IAAI,QAAQ,GAAG,UAAU,CAAC;QAC1B,iBAAiB,GAAG,CAAC,CAAC;QAEtB,KAAK,IAAI,CAAC,GAAG,UAAU,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC/C,MAAM,MAAM,GAAG,OAAO,UAAU,KAAK,QAAQ;gBAC3C,CAAC,CAAC,UAAU;gBACZ,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;YAEzB,iBAAiB,IAAI,MAAM,CAAC;YAE5B,IAAI,iBAAiB,GAAG,cAAc,GAAG,CAAC,YAAY,GAAG,CAAC,OAAO,UAAU,KAAK,QAAQ,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;gBAC7G,QAAQ,GAAG,CAAC,CAAC;gBACb,MAAM;YACR,CAAC;QACH,CAAC;QAED,IAAI,QAAQ,KAAK,UAAU,EAAE,CAAC;YAC5B,QAAQ,GAAG,KAAK,CAAC,MAAM,CAAC;QAC1B,CAAC;QAED,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,CAAC;IAClC,CAAC,CAAC,CAAC;IAEM,YAAY,GAAG,QAAQ,CAAC,GAAG,EAAE;QACpC,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;QAClC,MAAM,KAAK,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;QACpC,OAAO,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;IACvD,CAAC,CAAC,CAAC;IAEM,UAAU,GAAG,QAAQ,CAAC,GAAG,EAAE;QAClC,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;QAClC,MAAM,KAAK,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;QACpC,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,IAAI,EAAE,CAAC;QAEjD,IAAI,MAAM,GAAG,CAAC,CAAC;QACf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC;YAC1C,MAAM,IAAI,OAAO,UAAU,KAAK,QAAQ;gBACtC,CAAC,CAAC,UAAU;gBACZ,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3B,CAAC;QAED,OAAO,MAAM,CAAC;IAChB,CAAC,CAAC,CAAC;IAEM,aAAa,GAAG,QAAQ,CAAC,GAAG,EAAE;QACrC,MAAM,KAAK,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;QAClC,MAAM,KAAK,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;QACpC,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,IAAI,EAAE,CAAC;QACjD,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QAEvC,IAAI,aAAa,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;QAEtC,KAAK,IAAI,CAAC,GAAG,KAAK,CAAC,UAAU,EAAE,CAAC,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC;YACvD,aAAa,IAAI,OAAO,UAAU,KAAK,QAAQ;gBAC7C,CAAC,CAAC,UAAU;gBACZ,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3B,CAAC;QAED,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,WAAW,GAAG,aAAa,CAAC,CAAC;IAClD,CAAC,CAAC,CAAC;IAEH;QACE,oCAAoC;QACpC,MAAM,CAAC,GAAG,EAAE;YACV,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC,uBAAuB;YAC9C,IAAI,CAAC,cAAc,EAAE,CAAC;QACxB,CAAC,CAAC,CAAC;IACL,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC9B,CAAC;IAED,WAAW;QACT,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;QACrB,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;IAEO,mBAAmB;QACzB,SAAS,CAAC,IAAI,CAAC,eAAe,CAAC,aAAa,EAAE,QAAQ,CAAC;aACpD,IAAI,CACH,YAAY,CAAC,EAAE,CAAC,EAChB,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CACzB;aACA,SAAS,CAAC,GAAG,EAAE;YACd,IAAI,CAAC,QAAQ,EAAE,CAAC;QAClB,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,oBAAoB;QAC1B,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,YAAY,CAAC;QAC/D,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAClC,CAAC;IAED,QAAQ;QACN,MAAM,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,SAAS,CAAC;QAC/D,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IAChC,CAAC;IAEO,cAAc;QACpB,sBAAsB;QACtB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;IACnE,CAAC;IAED,YAAY,CAAC,IAAc;QACzB,MAAM,KAAK,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;QACpC,MAAM,KAAK,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC,CAAC;QAErD,IAAI,KAAK,KAAK,CAAC,CAAC;YAAE,OAAO;QAEzB,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,IAAI,EAAE,CAAC;QACjD,IAAI,eAAe,GAAG,CAAC,CAAC;QAExB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;YAC/B,eAAe,IAAI,OAAO,UAAU,KAAK,QAAQ;gBAC/C,CAAC,CAAC,UAAU;gBACZ,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAC3B,CAAC;QAED,IAAI,CAAC,eAAe,CAAC,aAAa,CAAC,SAAS,GAAG,eAAe,CAAC;IACjE,CAAC;wGA7KU,qBAAqB;4FAArB,qBAAqB,iSA/CtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BT,gRA9BS,YAAY,+BAAE,iBAAiB;;4FAiD9B,qBAAqB;kBApDjC,SAAS;+BACE,eAAe,cACb,IAAI,WACP,CAAC,YAAY,EAAE,iBAAiB,CAAC,mBACzB,uBAAuB,CAAC,MAAM,YACrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BT;wDAoB0B,SAAS;sBAAnC,KAAK;uBAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;gBACE,OAAO;sBAAjC,KAAK;uBAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;gBAChB,YAAY;sBAApB,KAAK;gBAGN,eAAe;sBADd,SAAS;uBAAC,iBAAiB,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE","sourcesContent":["// lib/components/tree-viewport/tree-viewport.component.ts\r\nimport {\r\n  Component,\r\n  Input,\r\n  OnInit,\r\n  OnDestroy,\r\n  ViewChild,\r\n  ElementRef,\r\n  ChangeDetectionStrategy,\r\n  signal,\r\n  computed,\r\n  TemplateRef,\r\n  effect,\r\n} from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\nimport { TreeModel } from '../../core/models/tree.model';\r\nimport { TreeNode } from '../../core/models/tree-node.model';\r\nimport { TreeOptions } from '../../core/models/tree-options.model';\r\nimport { TreeNodeComponent } from '../tree-node/tree-node.component';\r\nimport { fromEvent, Subject, takeUntil } from 'rxjs';\r\nimport { debounceTime } from 'rxjs/operators';\r\n\r\n@Component({\r\n  selector: 'tree-viewport',\r\n  standalone: true,\r\n  imports: [CommonModule, TreeNodeComponent],\r\n  changeDetection: ChangeDetectionStrategy.OnPush,\r\n  template: `\r\n    <div \r\n      #scrollContainer\r\n      class=\"tree-viewport-container\"\r\n      [style.height.px]=\"options.scrollContainerHeight || 400\"\r\n      (scroll)=\"onScroll()\">\r\n      \r\n      <div class=\"tree-viewport-content\"\r\n           [style.height.px]=\"totalHeight()\">\r\n        \r\n        <div class=\"tree-viewport-padding-top\"\r\n             [style.height.px]=\"paddingTop()\">\r\n        </div>\r\n        \r\n        @for (node of visibleNodes(); track node.id) {\r\n          <tree-node\r\n            [node]=\"node\"\r\n            [treeModel]=\"treeModel\"\r\n            [options]=\"options\"\r\n            [nodeTemplate]=\"nodeTemplate\">\r\n          </tree-node>\r\n        }\r\n        \r\n        <div class=\"tree-viewport-padding-bottom\"\r\n             [style.height.px]=\"paddingBottom()\">\r\n        </div>\r\n      </div>\r\n    </div>\r\n  `,\r\n  styles: [`\r\n    .tree-viewport-container {\r\n      overflow-y: auto;\r\n      overflow-x: hidden;\r\n      position: relative;\r\n    }\r\n    \r\n    .tree-viewport-content {\r\n      position: relative;\r\n      width: 100%;\r\n    }\r\n    \r\n    .tree-viewport-padding-top,\r\n    .tree-viewport-padding-bottom {\r\n      width: 100%;\r\n    }\r\n  `],\r\n})\r\nexport class TreeViewportComponent implements OnInit, OnDestroy {\r\n  @Input({ required: true }) treeModel!: TreeModel;\r\n  @Input({ required: true }) options!: TreeOptions;\r\n  @Input() nodeTemplate?: TemplateRef<any>;\r\n  \r\n  @ViewChild('scrollContainer', { static: true }) \r\n  scrollContainer!: ElementRef<HTMLElement>;\r\n  \r\n  private destroy$ = new Subject<void>();\r\n  \r\n  readonly scrollTop = signal(0);\r\n  readonly viewportHeight = signal(0);\r\n  \r\n  readonly flattenedNodes = computed(() => {\r\n    return this.treeModel.flattenedNodes();\r\n  });\r\n  \r\n  readonly totalHeight = computed(() => {\r\n    const nodes = this.flattenedNodes();\r\n    const nodeHeight = this.options.nodeHeight || 22;\r\n    \r\n    if (typeof nodeHeight === 'number') {\r\n      return nodes.length * nodeHeight;\r\n    }\r\n    \r\n    return nodes.reduce((sum, node) => sum + nodeHeight(node), 0);\r\n  });\r\n  \r\n  readonly visibleRange = computed(() => {\r\n    const scrollTop = this.scrollTop();\r\n    const viewportHeight = this.viewportHeight();\r\n    const nodes = this.flattenedNodes();\r\n    const nodeHeight = this.options.nodeHeight || 22;\r\n    const bufferAmount = this.options.bufferAmount || 5;\r\n    \r\n    let startIndex = 0;\r\n    let accumulatedHeight = 0;\r\n    \r\n    // Find start index\r\n    for (let i = 0; i < nodes.length; i++) {\r\n      const height = typeof nodeHeight === 'number' \r\n        ? nodeHeight \r\n        : nodeHeight(nodes[i]);\r\n      \r\n      if (accumulatedHeight + height > scrollTop) {\r\n        startIndex = Math.max(0, i - bufferAmount);\r\n        break;\r\n      }\r\n      accumulatedHeight += height;\r\n    }\r\n    \r\n    // Find end index\r\n    let endIndex = startIndex;\r\n    accumulatedHeight = 0;\r\n    \r\n    for (let i = startIndex; i < nodes.length; i++) {\r\n      const height = typeof nodeHeight === 'number'\r\n        ? nodeHeight\r\n        : nodeHeight(nodes[i]);\r\n      \r\n      accumulatedHeight += height;\r\n      \r\n      if (accumulatedHeight > viewportHeight + (bufferAmount * (typeof nodeHeight === 'number' ? nodeHeight : 22))) {\r\n        endIndex = i;\r\n        break;\r\n      }\r\n    }\r\n    \r\n    if (endIndex === startIndex) {\r\n      endIndex = nodes.length;\r\n    }\r\n    \r\n    return { startIndex, endIndex };\r\n  });\r\n  \r\n  readonly visibleNodes = computed(() => {\r\n    const range = this.visibleRange();\r\n    const nodes = this.flattenedNodes();\r\n    return nodes.slice(range.startIndex, range.endIndex);\r\n  });\r\n  \r\n  readonly paddingTop = computed(() => {\r\n    const range = this.visibleRange();\r\n    const nodes = this.flattenedNodes();\r\n    const nodeHeight = this.options.nodeHeight || 22;\r\n    \r\n    let height = 0;\r\n    for (let i = 0; i < range.startIndex; i++) {\r\n      height += typeof nodeHeight === 'number' \r\n        ? nodeHeight \r\n        : nodeHeight(nodes[i]);\r\n    }\r\n    \r\n    return height;\r\n  });\r\n  \r\n  readonly paddingBottom = computed(() => {\r\n    const range = this.visibleRange();\r\n    const nodes = this.flattenedNodes();\r\n    const nodeHeight = this.options.nodeHeight || 22;\r\n    const totalHeight = this.totalHeight();\r\n    \r\n    let visibleHeight = this.paddingTop();\r\n    \r\n    for (let i = range.startIndex; i < range.endIndex; i++) {\r\n      visibleHeight += typeof nodeHeight === 'number'\r\n        ? nodeHeight\r\n        : nodeHeight(nodes[i]);\r\n    }\r\n    \r\n    return Math.max(0, totalHeight - visibleHeight);\r\n  });\r\n  \r\n  constructor() {\r\n    // Update viewport when tree changes\r\n    effect(() => {\r\n      this.flattenedNodes(); // Subscribe to changes\r\n      this.updateViewport();\r\n    });\r\n  }\r\n  \r\n  ngOnInit(): void {\r\n    this.setupScrollListener();\r\n    this.updateViewportHeight();\r\n  }\r\n  \r\n  ngOnDestroy(): void {\r\n    this.destroy$.next();\r\n    this.destroy$.complete();\r\n  }\r\n  \r\n  private setupScrollListener(): void {\r\n    fromEvent(this.scrollContainer.nativeElement, 'scroll')\r\n      .pipe(\r\n        debounceTime(10),\r\n        takeUntil(this.destroy$)\r\n      )\r\n      .subscribe(() => {\r\n        this.onScroll();\r\n      });\r\n  }\r\n  \r\n  private updateViewportHeight(): void {\r\n    const height = this.scrollContainer.nativeElement.clientHeight;\r\n    this.viewportHeight.set(height);\r\n  }\r\n  \r\n  onScroll(): void {\r\n    const scrollTop = this.scrollContainer.nativeElement.scrollTop;\r\n    this.scrollTop.set(scrollTop);\r\n  }\r\n  \r\n  private updateViewport(): void {\r\n    // Force recalculation\r\n    this.scrollTop.set(this.scrollContainer.nativeElement.scrollTop);\r\n  }\r\n  \r\n  scrollToNode(node: TreeNode): void {\r\n    const nodes = this.flattenedNodes();\r\n    const index = nodes.findIndex(n => n.id === node.id);\r\n    \r\n    if (index === -1) return;\r\n    \r\n    const nodeHeight = this.options.nodeHeight || 22;\r\n    let targetScrollTop = 0;\r\n    \r\n    for (let i = 0; i < index; i++) {\r\n      targetScrollTop += typeof nodeHeight === 'number'\r\n        ? nodeHeight\r\n        : nodeHeight(nodes[i]);\r\n    }\r\n    \r\n    this.scrollContainer.nativeElement.scrollTop = targetScrollTop;\r\n  }\r\n}"]}