concepto-user-controls 0.0.7 → 0.0.9

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

@@ -0,0 +1,313 @@
+// lib/core/models/tree.model.ts
+import { signal, computed } from '@angular/core';
+import { Subject } from 'rxjs';
+import { TreeNode } from './tree-node.model';
+export class TreeModel {
+    options;
+    // Reactive state with signals
+    roots = signal([]);
+    focusedNodeId = signal(null);
+    expandedNodeIds = signal(new Set());
+    activeNodeIds = signal(new Set());
+    selectedNodeIds = signal(new Set());
+    hiddenNodeIds = signal(new Set());
+    // Computed signals
+    focusedNode = computed(() => {
+        const id = this.focusedNodeId();
+        return id ? this.getNodeById(id) : null;
+    });
+    expandedNodes = computed(() => this.getAllNodes().filter(node => this.expandedNodeIds().has(node.id)));
+    activeNodes = computed(() => this.getAllNodes().filter(node => this.activeNodeIds().has(node.id)));
+    selectedNodes = computed(() => this.getAllNodes().filter(node => this.selectedNodeIds().has(node.id)));
+    visibleNodes = computed(() => this.getAllNodes().filter(node => !node.isHidden()));
+    flattenedNodes = computed(() => {
+        const flattened = [];
+        const traverse = (nodes) => {
+            nodes.forEach(node => {
+                if (!node.isHidden()) {
+                    flattened.push(node);
+                    if (node.isExpanded() && node.children.length > 0) {
+                        traverse(node.children);
+                    }
+                }
+            });
+        };
+        traverse(this.roots());
+        return flattened;
+    });
+    // Event streams
+    events$ = new Subject();
+    // Virtual root for unified handling
+    virtualRoot = null;
+    // Node registry for quick lookup
+    nodeRegistry = new Map();
+    constructor(options) {
+        this.options = options;
+        // Constructor sin effects - se sincronizan en las operaciones
+    }
+    // Data management
+    setData(data) {
+        this.nodeRegistry.clear();
+        const roots = this.buildNodes(data, null, 0);
+        this.roots.set(roots);
+        this.emitEvent({ type: 'initialized', treeModel: this });
+    }
+    buildNodes(data, parent, level) {
+        return data.map((item, index) => {
+            const node = new TreeNode(item, parent, level, index, this.options);
+            this.nodeRegistry.set(node.id, node);
+            // Recursively build children
+            const childrenData = item[this.options.childrenField || 'children'];
+            if (Array.isArray(childrenData) && childrenData.length > 0) {
+                node.children = this.buildNodes(childrenData, node, level + 1);
+            }
+            return node;
+        });
+    }
+    update() {
+        // Trigger change detection by creating new signal values
+        this.roots.set([...this.roots()]);
+        this.emitEvent({ type: 'update', treeModel: this });
+    }
+    // Node lookup
+    getNodeById(id) {
+        return this.nodeRegistry.get(id) || null;
+    }
+    getNodeBy(predicate) {
+        return this.getAllNodes().find(predicate) || null;
+    }
+    getAllNodes() {
+        const nodes = [];
+        const traverse = (nodeList) => {
+            nodeList.forEach(node => {
+                nodes.push(node);
+                if (node.children.length > 0) {
+                    traverse(node.children);
+                }
+            });
+        };
+        traverse(this.roots());
+        return nodes;
+    }
+    // Navigation
+    focusNode(node) {
+        if (this.focusedNode()) {
+            this.focusedNode().setFocus(false);
+        }
+        if (node) {
+            this.focusedNodeId.set(node.id);
+            node.setFocus(true);
+            this.emitEvent({ type: 'focus', node });
+        }
+        else {
+            this.focusedNodeId.set(null);
+        }
+    }
+    focusNextNode() {
+        const flattened = this.flattenedNodes();
+        const currentIndex = flattened.findIndex(n => n.id === this.focusedNodeId());
+        if (currentIndex < flattened.length - 1) {
+            this.focusNode(flattened[currentIndex + 1]);
+        }
+    }
+    focusPreviousNode() {
+        const flattened = this.flattenedNodes();
+        const currentIndex = flattened.findIndex(n => n.id === this.focusedNodeId());
+        if (currentIndex > 0) {
+            this.focusNode(flattened[currentIndex - 1]);
+        }
+    }
+    focusDrillDown() {
+        const focused = this.focusedNode();
+        if (focused) {
+            if (!focused.isExpanded() && focused.hasChildren) {
+                focused.expand();
+            }
+            else if (focused.children.length > 0) {
+                this.focusNode(focused.children[0]);
+            }
+        }
+    }
+    focusDrillUp() {
+        const focused = this.focusedNode();
+        if (focused) {
+            if (focused.isExpanded() && focused.hasChildren) {
+                focused.collapse();
+            }
+            else if (focused.parent) {
+                this.focusNode(focused.parent);
+            }
+        }
+    }
+    // Operations
+    expandAll() {
+        const ids = new Set(this.getAllNodes().map(n => n.id));
+        this.expandedNodeIds.set(ids);
+        this.emitEvent({ type: 'expandAll', treeModel: this });
+    }
+    collapseAll() {
+        this.expandedNodeIds.set(new Set());
+        this.emitEvent({ type: 'collapseAll', treeModel: this });
+    }
+    expandNode(node) {
+        this.expandedNodeIds.update(ids => {
+            const newIds = new Set(ids);
+            newIds.add(node.id);
+            return newIds;
+        });
+        node.isExpanded.set(true);
+        this.emitEvent({ type: 'expand', node });
+    }
+    collapseNode(node) {
+        this.expandedNodeIds.update(ids => {
+            const newIds = new Set(ids);
+            newIds.delete(node.id);
+            return newIds;
+        });
+        node.isExpanded.set(false);
+        this.emitEvent({ type: 'collapse', node });
+    }
+    activateNode(node, multi = false) {
+        if (!multi) {
+            this.activeNodeIds.set(new Set([node.id]));
+            this.getAllNodes().forEach(n => n.isActive.set(n.id === node.id));
+        }
+        else {
+            this.activeNodeIds.update(ids => {
+                const newIds = new Set(ids);
+                newIds.add(node.id);
+                return newIds;
+            });
+            node.isActive.set(true);
+        }
+        this.emitEvent({ type: 'activate', node });
+    }
+    deactivateNode(node) {
+        this.activeNodeIds.update(ids => {
+            const newIds = new Set(ids);
+            newIds.delete(node.id);
+            return newIds;
+        });
+        node.isActive.set(false);
+        this.emitEvent({ type: 'deactivate', node });
+    }
+    selectNode(node, multi = false) {
+        if (!multi) {
+            this.selectedNodeIds.set(new Set([node.id]));
+        }
+        else {
+            this.selectedNodeIds.update(ids => {
+                const newIds = new Set(ids);
+                if (ids.has(node.id)) {
+                    newIds.delete(node.id);
+                }
+                else {
+                    newIds.add(node.id);
+                }
+                return newIds;
+            });
+        }
+        this.emitEvent({ type: 'select', node });
+    }
+    // Filtering
+    filterNodes(filterFn, autoShow = true) {
+        const hiddenIds = new Set();
+        this.getAllNodes().forEach(node => {
+            const matches = filterFn(node);
+            if (!matches) {
+                hiddenIds.add(node.id);
+            }
+            else if (autoShow) {
+                // Show ancestors of matching nodes
+                node.getAncestors().forEach(ancestor => {
+                    hiddenIds.delete(ancestor.id);
+                });
+            }
+        });
+        this.hiddenNodeIds.set(hiddenIds);
+        this.emitEvent({ type: 'filter', treeModel: this });
+    }
+    clearFilter() {
+        this.hiddenNodeIds.set(new Set());
+        this.emitEvent({ type: 'clearFilter', treeModel: this });
+    }
+    // Drag & Drop
+    canMoveNode(node, to) {
+        // Prevent moving to itself or descendants
+        if (node === to.parent)
+            return false;
+        if (to.parent.getAncestors().includes(node))
+            return false;
+        // Custom validation
+        if (this.options.allowDrop) {
+            if (typeof this.options.allowDrop === 'function') {
+                return this.options.allowDrop(node, to);
+            }
+            return this.options.allowDrop;
+        }
+        return true;
+    }
+    moveNode(node, to) {
+        if (!this.canMoveNode(node, to))
+            return;
+        // Remove from old parent
+        if (node.parent) {
+            const oldIndex = node.parent.children.indexOf(node);
+            if (oldIndex !== -1) {
+                // Create new array to trigger change detection
+                node.parent.children = [
+                    ...node.parent.children.slice(0, oldIndex),
+                    ...node.parent.children.slice(oldIndex + 1)
+                ];
+            }
+        }
+        else {
+            // Handle root nodes
+            const rootIndex = this.roots().indexOf(node);
+            if (rootIndex !== -1) {
+                this.roots.set([
+                    ...this.roots().slice(0, rootIndex),
+                    ...this.roots().slice(rootIndex + 1)
+                ]);
+            }
+        }
+        // Add to new parent - create new array to trigger change detection
+        const newChildren = [...to.parent.children];
+        newChildren.splice(to.index, 0, node);
+        to.parent.children = newChildren;
+        node.parent = to.parent;
+        // Update levels
+        this.updateNodeLevels(node);
+        this.emitEvent({ type: 'moveNode', node, to });
+        this.update();
+    }
+    updateNodeLevels(node) {
+        const newLevel = node.parent ? node.parent.level + 1 : 0;
+        node.level = newLevel;
+        node.children.forEach(child => this.updateNodeLevels(child));
+    }
+    // Async children loading
+    async loadChildren(node) {
+        if (!this.options.getChildren)
+            return;
+        node.setLoading(true);
+        try {
+            const childrenData = await this.options.getChildren(node);
+            node.children = this.buildNodes(childrenData, node, node.level + 1);
+            node.hasChildren = node.children.length > 0;
+            this.emitEvent({ type: 'loadChildren', node });
+            this.update();
+        }
+        catch (error) {
+            this.emitEvent({ type: 'loadChildrenError', node, error });
+        }
+        finally {
+            node.setLoading(false);
+        }
+    }
+    // Events
+    emitEvent(event) {
+        this.events$.next(event);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree.model.js","sourceRoot":"","sources":["../../../../../../../projects/concepto-user-controls/src/lib/concepto-tree/core/models/tree.model.ts"],"names":[],"mappings":"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","sourcesContent":["// lib/core/models/tree.model.ts\r\nimport { signal, computed, effect } from '@angular/core';\r\nimport { Subject } from 'rxjs';\r\nimport { TreeNode } from './tree-node.model';\r\nimport { TreeOptions } from './tree-options.model';\r\nimport { TreeEvent } from './tree-events.model';\r\n\r\nexport class TreeModel {\r\n  // Reactive state with signals\r\n  readonly roots = signal<TreeNode[]>([]);\r\n  readonly focusedNodeId = signal<string | number | null>(null);\r\n  readonly expandedNodeIds = signal<Set<string | number>>(new Set());\r\n  readonly activeNodeIds = signal<Set<string | number>>(new Set());\r\n  readonly selectedNodeIds = signal<Set<string | number>>(new Set());\r\n  readonly hiddenNodeIds = signal<Set<string | number>>(new Set());\r\n  \r\n  // Computed signals\r\n  readonly focusedNode = computed(() => {\r\n    const id = this.focusedNodeId();\r\n    return id ? this.getNodeById(id) : null;\r\n  });\r\n  \r\n  readonly expandedNodes = computed(() => \r\n    this.getAllNodes().filter(node => \r\n      this.expandedNodeIds().has(node.id)\r\n    )\r\n  );\r\n  \r\n  readonly activeNodes = computed(() =>\r\n    this.getAllNodes().filter(node =>\r\n      this.activeNodeIds().has(node.id)\r\n    )\r\n  );\r\n  \r\n  readonly selectedNodes = computed(() =>\r\n    this.getAllNodes().filter(node =>\r\n      this.selectedNodeIds().has(node.id)\r\n    )\r\n  );\r\n  \r\n  readonly visibleNodes = computed(() =>\r\n    this.getAllNodes().filter(node => !node.isHidden())\r\n  );\r\n  \r\n  readonly flattenedNodes = computed(() => {\r\n    const flattened: TreeNode[] = [];\r\n    const traverse = (nodes: TreeNode[]) => {\r\n      nodes.forEach(node => {\r\n        if (!node.isHidden()) {\r\n          flattened.push(node);\r\n          if (node.isExpanded() && node.children.length > 0) {\r\n            traverse(node.children);\r\n          }\r\n        }\r\n      });\r\n    };\r\n    traverse(this.roots());\r\n    return flattened;\r\n  });\r\n  \r\n  // Event streams\r\n  readonly events$ = new Subject<TreeEvent>();\r\n  \r\n  // Virtual root for unified handling\r\n  virtualRoot: TreeNode | null = null;\r\n  \r\n  // Node registry for quick lookup\r\n  private nodeRegistry = new Map<string | number, TreeNode>();\r\n  \r\n  constructor(public options: TreeOptions) {\r\n    // Constructor sin effects - se sincronizan en las operaciones\r\n  }\r\n  \r\n  // Data management\r\n  setData(data: any[]): void {\r\n    this.nodeRegistry.clear();\r\n    const roots = this.buildNodes(data, null, 0);\r\n    this.roots.set(roots);\r\n    this.emitEvent({ type: 'initialized', treeModel: this });\r\n  }\r\n  \r\n  private buildNodes(\r\n    data: any[],\r\n    parent: TreeNode | null,\r\n    level: number\r\n  ): TreeNode[] {\r\n    return data.map((item, index) => {\r\n      const node = new TreeNode(item, parent, level, index, this.options);\r\n      this.nodeRegistry.set(node.id, node);\r\n      \r\n      // Recursively build children\r\n      const childrenData = item[this.options.childrenField || 'children'];\r\n      if (Array.isArray(childrenData) && childrenData.length > 0) {\r\n        node.children = this.buildNodes(childrenData, node, level + 1);\r\n      }\r\n      \r\n      return node;\r\n    });\r\n  }\r\n  \r\n  update(): void {\r\n    // Trigger change detection by creating new signal values\r\n    this.roots.set([...this.roots()]);\r\n    this.emitEvent({ type: 'update', treeModel: this });\r\n  }\r\n  \r\n  // Node lookup\r\n  getNodeById(id: string | number): TreeNode | null {\r\n    return this.nodeRegistry.get(id) || null;\r\n  }\r\n  \r\n  getNodeBy(predicate: (node: TreeNode) => boolean): TreeNode | null {\r\n    return this.getAllNodes().find(predicate) || null;\r\n  }\r\n  \r\n  getAllNodes(): TreeNode[] {\r\n    const nodes: TreeNode[] = [];\r\n    const traverse = (nodeList: TreeNode[]) => {\r\n      nodeList.forEach(node => {\r\n        nodes.push(node);\r\n        if (node.children.length > 0) {\r\n          traverse(node.children);\r\n        }\r\n      });\r\n    };\r\n    traverse(this.roots());\r\n    return nodes;\r\n  }\r\n  \r\n  // Navigation\r\n  focusNode(node: TreeNode | null): void {\r\n    if (this.focusedNode()) {\r\n      this.focusedNode()!.setFocus(false);\r\n    }\r\n    if (node) {\r\n      this.focusedNodeId.set(node.id);\r\n      node.setFocus(true);\r\n      this.emitEvent({ type: 'focus', node });\r\n    } else {\r\n      this.focusedNodeId.set(null);\r\n    }\r\n  }\r\n  \r\n  focusNextNode(): void {\r\n    const flattened = this.flattenedNodes();\r\n    const currentIndex = flattened.findIndex(\r\n      n => n.id === this.focusedNodeId()\r\n    );\r\n    if (currentIndex < flattened.length - 1) {\r\n      this.focusNode(flattened[currentIndex + 1]);\r\n    }\r\n  }\r\n  \r\n  focusPreviousNode(): void {\r\n    const flattened = this.flattenedNodes();\r\n    const currentIndex = flattened.findIndex(\r\n      n => n.id === this.focusedNodeId()\r\n    );\r\n    if (currentIndex > 0) {\r\n      this.focusNode(flattened[currentIndex - 1]);\r\n    }\r\n  }\r\n  \r\n  focusDrillDown(): void {\r\n    const focused = this.focusedNode();\r\n    if (focused) {\r\n      if (!focused.isExpanded() && focused.hasChildren) {\r\n        focused.expand();\r\n      } else if (focused.children.length > 0) {\r\n        this.focusNode(focused.children[0]);\r\n      }\r\n    }\r\n  }\r\n  \r\n  focusDrillUp(): void {\r\n    const focused = this.focusedNode();\r\n    if (focused) {\r\n      if (focused.isExpanded() && focused.hasChildren) {\r\n        focused.collapse();\r\n      } else if (focused.parent) {\r\n        this.focusNode(focused.parent);\r\n      }\r\n    }\r\n  }\r\n  \r\n  // Operations\r\n  expandAll(): void {\r\n    const ids = new Set(this.getAllNodes().map(n => n.id));\r\n    this.expandedNodeIds.set(ids);\r\n    this.emitEvent({ type: 'expandAll', treeModel: this });\r\n  }\r\n  \r\n  collapseAll(): void {\r\n    this.expandedNodeIds.set(new Set());\r\n    this.emitEvent({ type: 'collapseAll', treeModel: this });\r\n  }\r\n  \r\n  expandNode(node: TreeNode): void {\r\n    this.expandedNodeIds.update(ids => {\r\n      const newIds = new Set(ids);\r\n      newIds.add(node.id);\r\n      return newIds;\r\n    });\r\n    node.isExpanded.set(true);\r\n    this.emitEvent({ type: 'expand', node });\r\n  }\r\n\r\n  collapseNode(node: TreeNode): void {\r\n    this.expandedNodeIds.update(ids => {\r\n      const newIds = new Set(ids);\r\n      newIds.delete(node.id);\r\n      return newIds;\r\n    });\r\n    node.isExpanded.set(false);\r\n    this.emitEvent({ type: 'collapse', node });\r\n  }\r\n\r\n  activateNode(node: TreeNode, multi: boolean = false): void {\r\n    if (!multi) {\r\n      this.activeNodeIds.set(new Set([node.id]));\r\n      this.getAllNodes().forEach(n => n.isActive.set(n.id === node.id));\r\n    } else {\r\n      this.activeNodeIds.update(ids => {\r\n        const newIds = new Set(ids);\r\n        newIds.add(node.id);\r\n        return newIds;\r\n      });\r\n      node.isActive.set(true);\r\n    }\r\n    this.emitEvent({ type: 'activate', node });\r\n  }\r\n  \r\n  deactivateNode(node: TreeNode): void {\r\n    this.activeNodeIds.update(ids => {\r\n      const newIds = new Set(ids);\r\n      newIds.delete(node.id);\r\n      return newIds;\r\n    });\r\n    node.isActive.set(false);\r\n    this.emitEvent({ type: 'deactivate', node });\r\n  }\r\n  \r\n  selectNode(node: TreeNode, multi: boolean = false): void {\r\n    if (!multi) {\r\n      this.selectedNodeIds.set(new Set([node.id]));\r\n    } else {\r\n      this.selectedNodeIds.update(ids => {\r\n        const newIds = new Set(ids);\r\n        if (ids.has(node.id)) {\r\n          newIds.delete(node.id);\r\n        } else {\r\n          newIds.add(node.id);\r\n        }\r\n        return newIds;\r\n      });\r\n    }\r\n    this.emitEvent({ type: 'select', node });\r\n  }\r\n  \r\n  // Filtering\r\n  filterNodes(filterFn: (node: TreeNode) => boolean, autoShow = true): void {\r\n    const hiddenIds = new Set<string | number>();\r\n    \r\n    this.getAllNodes().forEach(node => {\r\n      const matches = filterFn(node);\r\n      if (!matches) {\r\n        hiddenIds.add(node.id);\r\n      } else if (autoShow) {\r\n        // Show ancestors of matching nodes\r\n        node.getAncestors().forEach(ancestor => {\r\n          hiddenIds.delete(ancestor.id);\r\n        });\r\n      }\r\n    });\r\n    \r\n    this.hiddenNodeIds.set(hiddenIds);\r\n    this.emitEvent({ type: 'filter', treeModel: this });\r\n  }\r\n  \r\n  clearFilter(): void {\r\n    this.hiddenNodeIds.set(new Set());\r\n    this.emitEvent({ type: 'clearFilter', treeModel: this });\r\n  }\r\n  \r\n  // Drag & Drop\r\n  canMoveNode(\r\n    node: TreeNode,\r\n    to: { parent: TreeNode; index: number }\r\n  ): boolean {\r\n    // Prevent moving to itself or descendants\r\n    if (node === to.parent) return false;\r\n    if (to.parent.getAncestors().includes(node)) return false;\r\n    \r\n    // Custom validation\r\n    if (this.options.allowDrop) {\r\n      if (typeof this.options.allowDrop === 'function') {\r\n        return this.options.allowDrop(node, to);\r\n      }\r\n      return this.options.allowDrop;\r\n    }\r\n    \r\n    return true;\r\n  }\r\n  \r\n  moveNode(node: TreeNode, to: { parent: TreeNode; index: number }): void {\r\n    if (!this.canMoveNode(node, to)) return;\r\n\r\n    // Remove from old parent\r\n    if (node.parent) {\r\n      const oldIndex = node.parent.children.indexOf(node);\r\n      if (oldIndex !== -1) {\r\n        // Create new array to trigger change detection\r\n        node.parent.children = [\r\n          ...node.parent.children.slice(0, oldIndex),\r\n          ...node.parent.children.slice(oldIndex + 1)\r\n        ];\r\n      }\r\n    } else {\r\n      // Handle root nodes\r\n      const rootIndex = this.roots().indexOf(node);\r\n      if (rootIndex !== -1) {\r\n        this.roots.set([\r\n          ...this.roots().slice(0, rootIndex),\r\n          ...this.roots().slice(rootIndex + 1)\r\n        ]);\r\n      }\r\n    }\r\n\r\n    // Add to new parent - create new array to trigger change detection\r\n    const newChildren = [...to.parent.children];\r\n    newChildren.splice(to.index, 0, node);\r\n    to.parent.children = newChildren;\r\n    node.parent = to.parent;\r\n\r\n    // Update levels\r\n    this.updateNodeLevels(node);\r\n\r\n    this.emitEvent({ type: 'moveNode', node, to });\r\n    this.update();\r\n  }\r\n  \r\n  private updateNodeLevels(node: TreeNode): void {\r\n    const newLevel = node.parent ? node.parent.level + 1 : 0;\r\n    node.level = newLevel;\r\n    \r\n    node.children.forEach(child => this.updateNodeLevels(child));\r\n  }\r\n  \r\n  // Async children loading\r\n  async loadChildren(node: TreeNode): Promise<void> {\r\n    if (!this.options.getChildren) return;\r\n    \r\n    node.setLoading(true);\r\n    \r\n    try {\r\n      const childrenData = await this.options.getChildren(node);\r\n      node.children = this.buildNodes(childrenData, node, node.level + 1);\r\n      node.hasChildren = node.children.length > 0;\r\n      \r\n      this.emitEvent({ type: 'loadChildren', node });\r\n      this.update();\r\n    } catch (error) {\r\n      this.emitEvent({ type: 'loadChildrenError', node, error });\r\n    } finally {\r\n      node.setLoading(false);\r\n    }\r\n  }\r\n  \r\n  // Events\r\n  private emitEvent(event: TreeEvent): void {\r\n    this.events$.next(event);\r\n  }\r\n}"]}

package/esm2022/lib/concepto-tree/core/services/tree-drag-drop.service.mjs

@@ -0,0 +1,27 @@
+// lib/core/services/tree-drag-drop.service.ts
+import { Injectable, signal } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TreeDragDropService {
+    draggedNode = signal(null);
+    setDraggedNode(node) {
+        this.draggedNode.set(node);
+    }
+    getDraggedNode() {
+        return this.draggedNode();
+    }
+    clearDraggedNode() {
+        this.draggedNode.set(null);
+    }
+    isDragging() {
+        return this.draggedNode() !== null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeDragDropService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeDragDropService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeDragDropService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZS1kcmFnLWRyb3Auc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvbmNlcHRvLXVzZXItY29udHJvbHMvc3JjL2xpYi9jb25jZXB0by10cmVlL2NvcmUvc2VydmljZXMvdHJlZS1kcmFnLWRyb3Auc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSw4Q0FBOEM7QUFDOUMsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBTW5ELE1BQU0sT0FBTyxtQkFBbUI7SUFDYixXQUFXLEdBQUcsTUFBTSxDQUFrQixJQUFJLENBQUMsQ0FBQztJQUU5RCxjQUFjLENBQUMsSUFBYztRQUMxQixJQUFJLENBQUMsV0FBVyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUM3QixDQUFDO0lBRUQsY0FBYztRQUNaLE9BQU8sSUFBSSxDQUFDLFdBQVcsRUFBRSxDQUFDO0lBQzVCLENBQUM7SUFFRCxnQkFBZ0I7UUFDZCxJQUFJLENBQUMsV0FBVyxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQztJQUM3QixDQUFDO0lBRUQsVUFBVTtRQUNSLE9BQU8sSUFBSSxDQUFDLFdBQVcsRUFBRSxLQUFLLElBQUksQ0FBQztJQUNyQyxDQUFDO3dHQWpCVSxtQkFBbUI7NEdBQW5CLG1CQUFtQixjQUZsQixNQUFNOzs0RkFFUCxtQkFBbUI7a0JBSC9CLFVBQVU7bUJBQUM7b0JBQ1YsVUFBVSxFQUFFLE1BQU07aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiLy8gbGliL2NvcmUvc2VydmljZXMvdHJlZS1kcmFnLWRyb3Auc2VydmljZS50c1xyXG5pbXBvcnQgeyBJbmplY3RhYmxlLCBzaWduYWwgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgVHJlZU5vZGUgfSBmcm9tICcuLi9tb2RlbHMvdHJlZS1ub2RlLm1vZGVsJztcclxuXHJcbkBJbmplY3RhYmxlKHtcclxuICBwcm92aWRlZEluOiAncm9vdCcsXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBUcmVlRHJhZ0Ryb3BTZXJ2aWNlIHtcclxuICBwcml2YXRlIHJlYWRvbmx5IGRyYWdnZWROb2RlID0gc2lnbmFsPFRyZWVOb2RlIHwgbnVsbD4obnVsbCk7XHJcbiAgXHJcbiBzZXREcmFnZ2VkTm9kZShub2RlOiBUcmVlTm9kZSk6IHZvaWQge1xyXG4gICAgdGhpcy5kcmFnZ2VkTm9kZS5zZXQobm9kZSk7XHJcbiAgfVxyXG4gIFxyXG4gIGdldERyYWdnZWROb2RlKCk6IFRyZWVOb2RlIHwgbnVsbCB7XHJcbiAgICByZXR1cm4gdGhpcy5kcmFnZ2VkTm9kZSgpO1xyXG4gIH1cclxuICBcclxuICBjbGVhckRyYWdnZWROb2RlKCk6IHZvaWQge1xyXG4gICAgdGhpcy5kcmFnZ2VkTm9kZS5zZXQobnVsbCk7XHJcbiAgfVxyXG4gIFxyXG4gIGlzRHJhZ2dpbmcoKTogYm9vbGVhbiB7XHJcbiAgICByZXR1cm4gdGhpcy5kcmFnZ2VkTm9kZSgpICE9PSBudWxsO1xyXG4gIH1cclxufSJdfQ==

package/esm2022/lib/concepto-tree/directives/tree-drag.directive.mjs

@@ -0,0 +1,69 @@
+// lib/directives/tree-drag.directive.ts
+import { Directive, Input, HostListener, HostBinding, ElementRef, inject, // Add inject
+ } from '@angular/core';
+import { TreeDragDropService } from '../core/services/tree-drag-drop.service';
+import * as i0 from "@angular/core";
+export class TreeDragDirective {
+    node;
+    treeModel;
+    options;
+    // Use inject() function instead of constructor injection
+    elementRef = inject(ElementRef);
+    dragDropService = inject(TreeDragDropService);
+    get draggable() {
+        if (typeof this.options.allowDrag === 'function') {
+            return this.options.allowDrag(this.node);
+        }
+        return this.options.allowDrag || false;
+    }
+    onDragStart(event) {
+        if (!this.draggable) {
+            event.preventDefault();
+            return;
+        }
+        this.dragDropService.setDraggedNode(this.node);
+        if (event.dataTransfer) {
+            event.dataTransfer.effectAllowed = 'move';
+            event.dataTransfer.setData('text/plain', this.node.id.toString());
+            // Create drag image
+            const dragImage = this.elementRef.nativeElement.cloneNode(true);
+            dragImage.style.opacity = '0.7';
+            document.body.appendChild(dragImage);
+            event.dataTransfer.setDragImage(dragImage, 0, 0);
+            setTimeout(() => document.body.removeChild(dragImage), 0);
+        }
+        this.elementRef.nativeElement.classList.add('tree-node-dragging');
+    }
+    onDragEnd(event) {
+        this.dragDropService.clearDraggedNode();
+        this.elementRef.nativeElement.classList.remove('tree-node-dragging');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeDragDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: TreeDragDirective, isStandalone: true, selector: "[treeDrag]", inputs: { node: ["treeDrag", "node"], treeModel: "treeModel", options: "options" }, host: { listeners: { "dragstart": "onDragStart($event)", "dragend": "onDragEnd($event)" }, properties: { "attr.draggable": "this.draggable" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeDragDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[treeDrag]',
+                    standalone: true,
+                }]
+        }], propDecorators: { node: [{
+                type: Input,
+                args: [{ required: true, alias: 'treeDrag' }]
+            }], treeModel: [{
+                type: Input,
+                args: [{ required: true }]
+            }], options: [{
+                type: Input,
+                args: [{ required: true }]
+            }], draggable: [{
+                type: HostBinding,
+                args: ['attr.draggable']
+            }], onDragStart: [{
+                type: HostListener,
+                args: ['dragstart', ['$event']]
+            }], onDragEnd: [{
+                type: HostListener,
+                args: ['dragend', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/concepto-tree/directives/tree-drop.directive.mjs

@@ -0,0 +1,124 @@
+// lib/directives/tree-drop.directive.ts
+import { Directive, Input, HostListener, HostBinding, ElementRef, signal, inject, // Add inject
+ } from '@angular/core';
+import { TreeDragDropService } from '../core/services/tree-drag-drop.service';
+import * as i0 from "@angular/core";
+export class TreeDropDirective {
+    node;
+    treeModel;
+    options;
+    dropPosition = 'inside';
+    // Use inject() function instead of constructor injection
+    elementRef = inject(ElementRef);
+    dragDropService = inject(TreeDragDropService);
+    isDraggingOver = signal(false);
+    canDrop = signal(false);
+    get isDropTarget() {
+        return this.isDraggingOver() && this.canDrop();
+    }
+    get isDropDisabled() {
+        return this.isDraggingOver() && !this.canDrop();
+    }
+    onDragEnter(event) {
+        event.preventDefault();
+        const draggedNode = this.dragDropService.getDraggedNode();
+        if (!draggedNode)
+            return;
+        this.isDraggingOver.set(true);
+        const dropTarget = this.getDropTarget();
+        const canDrop = this.treeModel.canMoveNode(draggedNode, dropTarget);
+        this.canDrop.set(canDrop);
+        if (canDrop && event.dataTransfer) {
+            event.dataTransfer.dropEffect = 'move';
+        }
+    }
+    onDragOver(event) {
+        if (this.canDrop()) {
+            event.preventDefault();
+            if (event.dataTransfer) {
+                event.dataTransfer.dropEffect = 'move';
+            }
+        }
+    }
+    onDragLeave(event) {
+        // Check if we're really leaving (not just entering a child element)
+        const rect = this.elementRef.nativeElement.getBoundingClientRect();
+        const x = event.clientX;
+        const y = event.clientY;
+        if (x < rect.left || x >= rect.right || y < rect.top || y >= rect.bottom) {
+            this.isDraggingOver.set(false);
+            this.canDrop.set(false);
+        }
+    }
+    onDrop(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        const draggedNode = this.dragDropService.getDraggedNode();
+        if (!draggedNode || !this.canDrop())
+            return;
+        const dropTarget = this.getDropTarget();
+        this.treeModel.moveNode(draggedNode, dropTarget);
+        this.isDraggingOver.set(false);
+        this.canDrop.set(false);
+        this.dragDropService.clearDraggedNode();
+    }
+    getDropTarget() {
+        switch (this.dropPosition) {
+            case 'before':
+                return {
+                    parent: this.node.parent,
+                    index: this.node.index,
+                };
+            case 'after':
+                return {
+                    parent: this.node.parent,
+                    index: this.node.index + 1,
+                };
+            case 'inside':
+            default:
+                return {
+                    parent: this.node,
+                    index: this.node.children.length,
+                };
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeDropDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: TreeDropDirective, isStandalone: true, selector: "[treeDrop]", inputs: { node: ["treeDrop", "node"], treeModel: "treeModel", options: "options", dropPosition: "dropPosition" }, host: { listeners: { "dragenter": "onDragEnter($event)", "dragover": "onDragOver($event)", "dragleave": "onDragLeave($event)", "drop": "onDrop($event)" }, properties: { "class.tree-drop-target": "this.isDropTarget", "class.tree-drop-disabled": "this.isDropDisabled" } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeDropDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[treeDrop]',
+                    standalone: true,
+                }]
+        }], propDecorators: { node: [{
+                type: Input,
+                args: [{ required: true, alias: 'treeDrop' }]
+            }], treeModel: [{
+                type: Input,
+                args: [{ required: true }]
+            }], options: [{
+                type: Input,
+                args: [{ required: true }]
+            }], dropPosition: [{
+                type: Input
+            }], isDropTarget: [{
+                type: HostBinding,
+                args: ['class.tree-drop-target']
+            }], isDropDisabled: [{
+                type: HostBinding,
+                args: ['class.tree-drop-disabled']
+            }], onDragEnter: [{
+                type: HostListener,
+                args: ['dragenter', ['$event']]
+            }], onDragOver: [{
+                type: HostListener,
+                args: ['dragover', ['$event']]
+            }], onDragLeave: [{
+                type: HostListener,
+                args: ['dragleave', ['$event']]
+            }], onDrop: [{
+                type: HostListener,
+                args: ['drop', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-drop.directive.js","sourceRoot":"","sources":["../../../../../../projects/concepto-user-controls/src/lib/concepto-tree/directives/tree-drop.directive.ts"],"names":[],"mappings":"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","sourcesContent":["// lib/directives/tree-drop.directive.ts\r\nimport {\r\n  Directive,\r\n  Input,\r\n  HostListener,\r\n  HostBinding,\r\n  ElementRef,\r\n  signal,\r\n  inject, // Add inject\r\n} from '@angular/core';\r\nimport { TreeNode } from '../core/models/tree-node.model';\r\nimport { TreeModel } from '../core/models/tree.model';\r\nimport { TreeOptions } from '../core/models/tree-options.model';\r\nimport { TreeDragDropService } from '../core/services/tree-drag-drop.service';\r\n\r\ntype DropPosition = 'before' | 'after' | 'inside';\r\n\r\n@Directive({\r\n  selector: '[treeDrop]',\r\n  standalone: true,\r\n})\r\nexport class TreeDropDirective {\r\n  @Input({ required: true, alias: 'treeDrop' }) node!: TreeNode;\r\n  @Input({ required: true }) treeModel!: TreeModel;\r\n  @Input({ required: true }) options!: TreeOptions;\r\n  @Input() dropPosition: DropPosition = 'inside';\r\n  \r\n  // Use inject() function instead of constructor injection\r\n  private readonly elementRef = inject(ElementRef);\r\n  private readonly dragDropService = inject(TreeDragDropService);\r\n  \r\n  readonly isDraggingOver = signal(false);\r\n  readonly canDrop = signal(false);\r\n  \r\n  @HostBinding('class.tree-drop-target')\r\n  get isDropTarget(): boolean {\r\n    return this.isDraggingOver() && this.canDrop();\r\n  }\r\n  \r\n  @HostBinding('class.tree-drop-disabled')\r\n  get isDropDisabled(): boolean {\r\n    return this.isDraggingOver() && !this.canDrop();\r\n  }\r\n  \r\n  @HostListener('dragenter', ['$event'])\r\n  onDragEnter(event: DragEvent): void {\r\n    event.preventDefault();\r\n    \r\n    const draggedNode = this.dragDropService.getDraggedNode();\r\n    if (!draggedNode) return;\r\n    \r\n    this.isDraggingOver.set(true);\r\n    \r\n    const dropTarget = this.getDropTarget();\r\n    const canDrop = this.treeModel.canMoveNode(draggedNode, dropTarget);\r\n    this.canDrop.set(canDrop);\r\n    \r\n    if (canDrop && event.dataTransfer) {\r\n      event.dataTransfer.dropEffect = 'move';\r\n    }\r\n  }\r\n  \r\n  @HostListener('dragover', ['$event'])\r\n  onDragOver(event: DragEvent): void {\r\n    if (this.canDrop()) {\r\n      event.preventDefault();\r\n      if (event.dataTransfer) {\r\n        event.dataTransfer.dropEffect = 'move';\r\n      }\r\n    }\r\n  }\r\n  \r\n  @HostListener('dragleave', ['$event'])\r\n  onDragLeave(event: DragEvent): void {\r\n    // Check if we're really leaving (not just entering a child element)\r\n    const rect = this.elementRef.nativeElement.getBoundingClientRect();\r\n    const x = event.clientX;\r\n    const y = event.clientY;\r\n    \r\n    if (x < rect.left || x >= rect.right || y < rect.top || y >= rect.bottom) {\r\n      this.isDraggingOver.set(false);\r\n      this.canDrop.set(false);\r\n    }\r\n  }\r\n  \r\n  @HostListener('drop', ['$event'])\r\n  onDrop(event: DragEvent): void {\r\n    event.preventDefault();\r\n    event.stopPropagation();\r\n    \r\n    const draggedNode = this.dragDropService.getDraggedNode();\r\n    if (!draggedNode || !this.canDrop()) return;\r\n    \r\n    const dropTarget = this.getDropTarget();\r\n    this.treeModel.moveNode(draggedNode, dropTarget);\r\n    \r\n    this.isDraggingOver.set(false);\r\n    this.canDrop.set(false);\r\n    this.dragDropService.clearDraggedNode();\r\n  }\r\n  \r\n  private getDropTarget(): { parent: TreeNode; index: number } {\r\n    switch (this.dropPosition) {\r\n      case 'before':\r\n        return {\r\n          parent: this.node.parent!,\r\n          index: this.node.index,\r\n        };\r\n      case 'after':\r\n        return {\r\n          parent: this.node.parent!,\r\n          index: this.node.index + 1,\r\n        };\r\n      case 'inside':\r\n      default:\r\n        return {\r\n          parent: this.node,\r\n          index: this.node.children.length,\r\n        };\r\n    }\r\n  }\r\n}"]}

package/esm2022/lib/concepto-tree/directives/tree-node-template.directive.mjs

@@ -0,0 +1,19 @@
+// lib/directives/tree-node-template.directive.ts
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class TreeNodeTemplateDirective {
+    template;
+    constructor(template) {
+        this.template = template;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeNodeTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: TreeNodeTemplateDirective, isStandalone: true, selector: "[treeNodeTemplate]", ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeNodeTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[treeNodeTemplate]',
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [{ type: i0.TemplateRef }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZS1ub2RlLXRlbXBsYXRlLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvbmNlcHRvLXVzZXItY29udHJvbHMvc3JjL2xpYi9jb25jZXB0by10cmVlL2RpcmVjdGl2ZXMvdHJlZS1ub2RlLXRlbXBsYXRlLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxpREFBaUQ7QUFDakQsT0FBTyxFQUFFLFNBQVMsRUFBZSxNQUFNLGVBQWUsQ0FBQzs7QUFNdkQsTUFBTSxPQUFPLHlCQUF5QjtJQUNqQjtJQUFuQixZQUFtQixRQUEwQjtRQUExQixhQUFRLEdBQVIsUUFBUSxDQUFrQjtJQUFHLENBQUM7d0dBRHRDLHlCQUF5Qjs0RkFBekIseUJBQXlCOzs0RkFBekIseUJBQXlCO2tCQUpyQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxvQkFBb0I7b0JBQzlCLFVBQVUsRUFBRSxJQUFJO2lCQUNqQiIsInNvdXJjZXNDb250ZW50IjpbIi8vIGxpYi9kaXJlY3RpdmVzL3RyZWUtbm9kZS10ZW1wbGF0ZS5kaXJlY3RpdmUudHNcclxuaW1wb3J0IHsgRGlyZWN0aXZlLCBUZW1wbGF0ZVJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5cclxuQERpcmVjdGl2ZSh7XHJcbiAgc2VsZWN0b3I6ICdbdHJlZU5vZGVUZW1wbGF0ZV0nLFxyXG4gIHN0YW5kYWxvbmU6IHRydWUsXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBUcmVlTm9kZVRlbXBsYXRlRGlyZWN0aXZlIHtcclxuICBjb25zdHJ1Y3RvcihwdWJsaWMgdGVtcGxhdGU6IFRlbXBsYXRlUmVmPGFueT4pIHt9XHJcbn0iXX0=