@ali-hm/angular-tree-component 20.3.3 → 20.3.4

package/index.d.ts

@@ -1,34 +1,26 @@
-import * as i0 from '@angular/core';
-import { OnInit, OnDestroy, TemplateRef, ViewContainerRef, EmbeddedViewRef, AfterViewInit, OnChanges, EventEmitter, DoCheck } from '@angular/core';
+import * as _angular_core from '@angular/core';
+import { Injector, OnDestroy, TemplateRef, AfterViewInit, OnInit, OnChanges, DoCheck } from '@angular/core';
 import * as i1 from '@angular/common';
 
-declare class TreeMobxAutorunDirective implements OnInit, OnDestroy {
-    protected templateRef: TemplateRef<any>;
-    protected viewContainer: ViewContainerRef;
-    protected templateBindings: {};
-    protected dispose: any;
-    protected view: EmbeddedViewRef<any>;
-    treeMobxAutorun: any;
-    ngOnInit(): void;
-    shouldDetach(): any;
-    autoDetect(view: EmbeddedViewRef<any>): void;
-    ngOnDestroy(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TreeMobxAutorunDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeMobxAutorunDirective, "[treeMobxAutorun]", never, { "treeMobxAutorun": { "alias": "treeMobxAutorun"; "required": false; }; }, {}, never, never, true, never>;
-}
-
 declare class TreeVirtualScroll {
     private treeModel;
     private _dispose;
-    yBlocks: number;
-    x: number;
-    viewportHeight: any;
+    private _yBlocks;
+    private _x;
+    private _viewportHeight;
     viewport: any;
+    get yBlocks(): number;
+    set yBlocks(value: number);
+    get x(): number;
+    set x(value: number);
+    get viewportHeight(): number | null;
+    set viewportHeight(value: number | null);
     get y(): number;
     get totalHeight(): number;
     constructor();
     fireEvent(event: any): void;
     init(): void;
+    setupWatchers(injector: Injector): void;
     isEnabled(): boolean;
     private _setYBlocks;
     recalcPositions(): void;
@@ -39,8 +31,8 @@ declare class TreeVirtualScroll {
     scrollIntoView(node: any, force: any, scrollToMiddle?: boolean): void;
     getViewportNodes(nodes: any): any;
     fixScroll(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TreeVirtualScroll, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<TreeVirtualScroll>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeVirtualScroll, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TreeVirtualScroll>;
 }
 
 /**
@@ -647,13 +639,21 @@ declare class TreeModel implements ITreeModel, OnDestroy {
     nodes: any[];
     eventNames: string[];
     virtualScroll: TreeVirtualScroll;
-    roots: TreeNode[];
-    expandedNodeIds: IDTypeDictionary;
-    selectedLeafNodeIds: IDTypeDictionary;
-    activeNodeIds: IDTypeDictionary;
-    hiddenNodeIds: IDTypeDictionary;
-    focusedNodeId: IDType;
-    virtualRoot: TreeNode;
+    private _roots;
+    private _expandedNodeIds;
+    private _selectedLeafNodeIds;
+    private _activeNodeIds;
+    private _hiddenNodeIds;
+    private _focusedNodeId;
+    private _virtualRoot;
+    get roots(): TreeNode[];
+    private set roots(value);
+    get virtualRoot(): TreeNode;
+    get focusedNode(): TreeNode;
+    get expandedNodes(): TreeNode[];
+    get activeNodes(): TreeNode[];
+    get hiddenNodes(): TreeNode[];
+    get selectedLeafNodes(): TreeNode[];
     private firstUpdate;
     private events;
     private subscriptions;
@@ -668,11 +668,6 @@ declare class TreeModel implements ITreeModel, OnDestroy {
     get isFocused(): boolean;
     isNodeFocused(node: any): boolean;
     isEmptyTree(): boolean;
-    get focusedNode(): any;
-    get expandedNodes(): any[];
-    get activeNodes(): any[];
-    get hiddenNodes(): any[];
-    get selectedLeafNodes(): any[];
     getNodeByPath(path: any[], startNode?: any): TreeNode;
     getNodeById(id: any): any;
     getNodeBy(predicate: any, startNode?: any): any;
@@ -723,15 +718,27 @@ declare class TreeModel implements ITreeModel, OnDestroy {
     private _calculateExpandedNodes;
     private _setActiveNodeSingle;
     private _setActiveNodeMulti;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TreeModel, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<TreeModel>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeModel, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TreeModel>;
 }
 
 declare class TreeNode implements ITreeNode {
     data: any;
     parent: TreeNode;
     treeModel: TreeModel;
-    private handler;
+    private _isLoadingChildren;
+    private _children;
+    private _index;
+    private _position;
+    private _height;
+    get children(): TreeNode[];
+    set children(value: TreeNode[]);
+    get index(): number;
+    set index(value: number);
+    get position(): number;
+    set position(value: number);
+    get height(): number;
+    set height(value: number);
     get isHidden(): boolean;
     get isExpanded(): boolean;
     get isActive(): boolean;
@@ -739,10 +746,6 @@ declare class TreeNode implements ITreeNode {
     get isSelected(): boolean;
     get isAllSelected(): boolean;
     get isPartiallySelected(): boolean;
-    children: TreeNode[];
-    index: number;
-    position: number;
-    height: number;
     get level(): number;
     get path(): string[];
     get elementRef(): any;
@@ -898,20 +901,21 @@ declare class TreeDraggedElement {
     set(draggedElement: any): void;
     get(): any;
     isDragging(): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TreeDraggedElement, never>;
-    static ɵprov: i0.ɵɵInjectableDeclaration<TreeDraggedElement>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeDraggedElement, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TreeDraggedElement>;
 }
 
 declare class LoadingComponent {
-    template: TemplateRef<any>;
-    node: TreeNode;
-    static ɵfac: i0.ɵɵFactoryDeclaration<LoadingComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<LoadingComponent, "tree-loading-component", never, { "template": { "alias": "template"; "required": false; }; "node": { "alias": "node"; "required": false; }; }, {}, never, never, true, never>;
+    readonly template: _angular_core.InputSignal<TemplateRef<any>>;
+    readonly node: _angular_core.InputSignal<TreeNode>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoadingComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LoadingComponent, "tree-loading-component", never, { "template": { "alias": "template"; "required": false; "isSignal": true; }; "node": { "alias": "node"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class TreeViewportComponent implements AfterViewInit, OnInit, OnDestroy {
     private elementRef;
     virtualScroll: TreeVirtualScroll;
+    private injector;
     setViewport: () => void;
     private readonly scrollEventHandler;
     constructor();
@@ -920,8 +924,8 @@ declare class TreeViewportComponent implements AfterViewInit, OnInit, OnDestroy
     ngOnDestroy(): void;
     getTotalHeight(): string;
     private throttle;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TreeViewportComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TreeViewportComponent, "tree-viewport", never, {}, {}, never, ["*"], true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeViewportComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TreeViewportComponent, "tree-viewport", never, {}, {}, never, ["*"], true, never>;
 }
 
 declare class TreeComponent implements OnChanges {
@@ -961,76 +965,78 @@ declare class TreeComponent implements OnChanges {
     ngOnChanges(changes: any): void;
     sizeChanged(): void;
     private pick;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TreeComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TreeComponent, "Tree, tree-root", never, { "nodes": { "alias": "nodes"; "required": false; }; "options": { "alias": "options"; "required": false; }; "focused": { "alias": "focused"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "toggleExpanded": "toggleExpanded"; "activate": "activate"; "deactivate": "deactivate"; "nodeActivate": "nodeActivate"; "nodeDeactivate": "nodeDeactivate"; "select": "select"; "deselect": "deselect"; "focus": "focus"; "blur": "blur"; "updateData": "updateData"; "initialized": "initialized"; "moveNode": "moveNode"; "copyNode": "copyNode"; "loadNodeChildren": "loadNodeChildren"; "changeFilter": "changeFilter"; "event": "event"; "stateChange": "stateChange"; }, ["loadingTemplate", "treeNodeTemplate", "treeNodeWrapperTemplate", "treeNodeFullTemplate"], never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TreeComponent, "Tree, tree-root", never, { "nodes": { "alias": "nodes"; "required": false; }; "options": { "alias": "options"; "required": false; }; "focused": { "alias": "focused"; "required": false; }; "state": { "alias": "state"; "required": false; }; }, { "toggleExpanded": "toggleExpanded"; "activate": "activate"; "deactivate": "deactivate"; "nodeActivate": "nodeActivate"; "nodeDeactivate": "nodeDeactivate"; "select": "select"; "deselect": "deselect"; "focus": "focus"; "blur": "blur"; "updateData": "updateData"; "initialized": "initialized"; "moveNode": "moveNode"; "copyNode": "copyNode"; "loadNodeChildren": "loadNodeChildren"; "changeFilter": "changeFilter"; "event": "event"; "stateChange": "stateChange"; }, ["loadingTemplate", "treeNodeTemplate", "treeNodeWrapperTemplate", "treeNodeFullTemplate"], never, true, never>;
 }
 
 declare class TreeNodeChildrenComponent {
-    node: TreeNode;
-    templates: any;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodeChildrenComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TreeNodeChildrenComponent, "tree-node-children", never, { "node": { "alias": "node"; "required": false; }; "templates": { "alias": "templates"; "required": false; }; }, {}, never, never, true, never>;
+    readonly node: _angular_core.InputSignal<TreeNode>;
+    readonly templates: _angular_core.InputSignal<any>;
+    children: _angular_core.Signal<TreeNode[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeNodeChildrenComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TreeNodeChildrenComponent, "tree-node-children", never, { "node": { "alias": "node"; "required": false; "isSignal": true; }; "templates": { "alias": "templates"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 declare class TreeNodeCollectionComponent implements OnInit, OnDestroy {
-    get nodes(): any;
-    set nodes(nodes: any);
-    treeModel: TreeModel;
-    _nodes: any;
+    readonly nodes: _angular_core.InputSignal<TreeNode[]>;
+    readonly treeModel: _angular_core.InputSignal<TreeModel>;
+    private injector;
     private virtualScroll;
-    templates: any;
-    viewportNodes: TreeNode[];
-    get marginTop(): string;
-    _dispose: any[];
-    setNodes(nodes: any): void;
+    readonly templates: _angular_core.InputSignal<any>;
+    viewportNodes: _angular_core.WritableSignal<TreeNode[]>;
+    marginTop: _angular_core.Signal<string>;
+    private _disposeEffects;
     ngOnInit(): void;
     ngOnDestroy(): void;
     trackNode(index: any, node: any): any;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodeCollectionComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TreeNodeCollectionComponent, "tree-node-collection", never, { "nodes": { "alias": "nodes"; "required": false; }; "treeModel": { "alias": "treeModel"; "required": false; }; "templates": { "alias": "templates"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeNodeCollectionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TreeNodeCollectionComponent, "tree-node-collection", never, { "nodes": { "alias": "nodes"; "required": false; "isSignal": true; }; "treeModel": { "alias": "treeModel"; "required": false; "isSignal": true; }; "templates": { "alias": "templates"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 declare class TreeNodeComponent {
-    node: TreeNode;
-    index: number;
-    templates: any;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodeComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TreeNodeComponent, "TreeNode, tree-node", never, { "node": { "alias": "node"; "required": false; }; "index": { "alias": "index"; "required": false; }; "templates": { "alias": "templates"; "required": false; }; }, {}, never, never, true, never>;
+    readonly node: _angular_core.InputSignal<TreeNode>;
+    readonly index: _angular_core.InputSignal<number>;
+    readonly templates: _angular_core.InputSignal<any>;
+    treeNodeFullTemplate: _angular_core.Signal<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeNodeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TreeNodeComponent, "TreeNode, tree-node", never, { "node": { "alias": "node"; "required": false; "isSignal": true; }; "index": { "alias": "index"; "required": false; "isSignal": true; }; "templates": { "alias": "templates"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class TreeNodeContent {
-    node: TreeNode;
-    index: number;
-    template: TemplateRef<any>;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodeContent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TreeNodeContent, "tree-node-content", never, { "node": { "alias": "node"; "required": false; }; "index": { "alias": "index"; "required": false; }; "template": { "alias": "template"; "required": false; }; }, {}, never, never, true, never>;
+    readonly node: _angular_core.InputSignal<TreeNode>;
+    readonly index: _angular_core.InputSignal<number>;
+    readonly template: _angular_core.InputSignal<TemplateRef<any>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeNodeContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TreeNodeContent, "tree-node-content", never, { "node": { "alias": "node"; "required": false; "isSignal": true; }; "index": { "alias": "index"; "required": false; "isSignal": true; }; "template": { "alias": "template"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class TreeNodeDropSlot {
-    node: TreeNode;
-    dropIndex: number;
+    readonly node: _angular_core.InputSignal<TreeNode>;
+    readonly dropIndex: _angular_core.InputSignal<number>;
     onDrop($event: any): void;
     allowDrop(element: any, $event: any): boolean;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodeDropSlot, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TreeNodeDropSlot, "TreeNodeDropSlot, tree-node-drop-slot", never, { "node": { "alias": "node"; "required": false; }; "dropIndex": { "alias": "dropIndex"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeNodeDropSlot, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TreeNodeDropSlot, "TreeNodeDropSlot, tree-node-drop-slot", never, { "node": { "alias": "node"; "required": false; "isSignal": true; }; "dropIndex": { "alias": "dropIndex"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class TreeNodeExpanderComponent {
-    node: TreeNode;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodeExpanderComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TreeNodeExpanderComponent, "tree-node-expander", never, { "node": { "alias": "node"; "required": false; }; }, {}, never, never, true, never>;
+    readonly node: _angular_core.InputSignal<TreeNode>;
+    readonly hasChildren: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeNodeExpanderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TreeNodeExpanderComponent, "tree-node-expander", never, { "node": { "alias": "node"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class TreeNodeWrapperComponent {
-    node: TreeNode;
-    index: number;
-    templates: any;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodeWrapperComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TreeNodeWrapperComponent, "tree-node-wrapper", never, { "node": { "alias": "node"; "required": false; }; "index": { "alias": "index"; "required": false; }; "templates": { "alias": "templates"; "required": false; }; }, {}, never, never, true, never>;
+    readonly node: _angular_core.InputSignal<TreeNode>;
+    readonly index: _angular_core.InputSignal<number>;
+    readonly templates: _angular_core.InputSignal<any>;
+    treeNodeWrapperTemplate: _angular_core.Signal<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeNodeWrapperComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TreeNodeWrapperComponent, "tree-node-wrapper", never, { "node": { "alias": "node"; "required": false; "isSignal": true; }; "index": { "alias": "index"; "required": false; "isSignal": true; }; "templates": { "alias": "templates"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class TreeNodeCheckboxComponent {
-    node: TreeNode;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TreeNodeCheckboxComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<TreeNodeCheckboxComponent, "tree-node-checkbox", never, { "node": { "alias": "node"; "required": false; }; }, {}, never, never, true, never>;
+    readonly node: _angular_core.InputSignal<TreeNode>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeNodeCheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TreeNodeCheckboxComponent, "tree-node-checkbox", never, { "node": { "alias": "node"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class TreeDropDirective implements AfterViewInit, OnDestroy {
@@ -1038,16 +1044,28 @@ declare class TreeDropDirective implements AfterViewInit, OnDestroy {
     private renderer;
     private treeDraggedElement;
     private ngZone;
-    allowDragoverStyling: boolean;
-    onDropCallback: EventEmitter<any>;
-    onDragOverCallback: EventEmitter<any>;
-    onDragLeaveCallback: EventEmitter<any>;
-    onDragEnterCallback: EventEmitter<any>;
+    readonly allowDragoverStyling: _angular_core.InputSignal<boolean>;
+    readonly treeAllowDrop: _angular_core.InputSignal<boolean | Function>;
+    readonly onDropCallback: _angular_core.OutputEmitterRef<{
+        event: DragEvent;
+        element: any;
+    }>;
+    readonly onDragOverCallback: _angular_core.OutputEmitterRef<{
+        event: DragEvent;
+        element: any;
+    }>;
+    readonly onDragLeaveCallback: _angular_core.OutputEmitterRef<{
+        event: DragEvent;
+        element: any;
+    }>;
+    readonly onDragEnterCallback: _angular_core.OutputEmitterRef<{
+        event: DragEvent;
+        element: any;
+    }>;
     private readonly dragOverEventHandler;
     private readonly dragEnterEventHandler;
     private readonly dragLeaveEventHandler;
     private _allowDrop;
-    set treeAllowDrop(allowDrop: any);
     allowDrop($event: any): boolean;
     constructor();
     ngAfterViewInit(): void;
@@ -1060,8 +1078,8 @@ declare class TreeDropDirective implements AfterViewInit, OnDestroy {
     private removeClass;
     private addDisabledClass;
     private removeDisabledClass;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TreeDropDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeDropDirective, "[treeDrop]", never, { "allowDragoverStyling": { "alias": "allowDragoverStyling"; "required": false; }; "treeAllowDrop": { "alias": "treeAllowDrop"; "required": false; }; }, { "onDropCallback": "treeDrop"; "onDragOverCallback": "treeDropDragOver"; "onDragLeaveCallback": "treeDropDragLeave"; "onDragEnterCallback": "treeDropDragEnter"; }, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeDropDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TreeDropDirective, "[treeDrop]", never, { "allowDragoverStyling": { "alias": "allowDragoverStyling"; "required": false; "isSignal": true; }; "treeAllowDrop": { "alias": "treeAllowDrop"; "required": false; "isSignal": true; }; }, { "onDropCallback": "treeDrop"; "onDragOverCallback": "treeDropDragOver"; "onDragLeaveCallback": "treeDropDragLeave"; "onDragEnterCallback": "treeDropDragEnter"; }, never, never, true, never>;
 }
 
 declare class TreeDragDirective implements AfterViewInit, DoCheck, OnDestroy {
@@ -1069,8 +1087,8 @@ declare class TreeDragDirective implements AfterViewInit, DoCheck, OnDestroy {
     private renderer;
     private treeDraggedElement;
     private ngZone;
-    draggedElement: any;
-    treeDragEnabled: any;
+    readonly draggedElement: _angular_core.InputSignal<any>;
+    readonly treeDragEnabled: _angular_core.InputSignal<any>;
     private readonly dragEventHandler;
     constructor();
     ngAfterViewInit(): void;
@@ -1079,33 +1097,34 @@ declare class TreeDragDirective implements AfterViewInit, DoCheck, OnDestroy {
     onDragStart(ev: any): void;
     onDrag(ev: any): void;
     onDragEnd(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TreeDragDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeDragDirective, "[treeDrag]", never, { "draggedElement": { "alias": "treeDrag"; "required": false; }; "treeDragEnabled": { "alias": "treeDragEnabled"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeDragDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TreeDragDirective, "[treeDrag]", never, { "draggedElement": { "alias": "treeDrag"; "required": false; "isSignal": true; }; "treeDragEnabled": { "alias": "treeDragEnabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class TreeAnimateOpenDirective {
     private renderer;
     private templateRef;
     private viewContainerRef;
-    private _isOpen;
-    animateSpeed: number;
-    animateAcceleration: number;
-    isEnabled: boolean;
-    set isOpen(value: boolean);
+    readonly isOpen: _angular_core.InputSignal<boolean>;
+    readonly animateSpeed: _angular_core.InputSignal<number>;
+    readonly animateAcceleration: _angular_core.InputSignal<number>;
+    readonly isEnabled: _angular_core.InputSignal<boolean>;
     private innerElement;
+    private previousIsOpen;
+    constructor();
     private _show;
     private _hide;
     private _animateOpen;
     private _animateClose;
-    static ɵfac: i0.ɵɵFactoryDeclaration<TreeAnimateOpenDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<TreeAnimateOpenDirective, "[treeAnimateOpen]", never, { "animateSpeed": { "alias": "treeAnimateOpenSpeed"; "required": false; }; "animateAcceleration": { "alias": "treeAnimateOpenAcceleration"; "required": false; }; "isEnabled": { "alias": "treeAnimateOpenEnabled"; "required": false; }; "isOpen": { "alias": "treeAnimateOpen"; "required": false; }; }, {}, never, never, true, never>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeAnimateOpenDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TreeAnimateOpenDirective, "[treeAnimateOpen]", never, { "isOpen": { "alias": "treeAnimateOpen"; "required": false; "isSignal": true; }; "animateSpeed": { "alias": "treeAnimateOpenSpeed"; "required": false; "isSignal": true; }; "animateAcceleration": { "alias": "treeAnimateOpenAcceleration"; "required": false; "isSignal": true; }; "isEnabled": { "alias": "treeAnimateOpenEnabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
 declare class TreeModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<TreeModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<TreeModule, never, [typeof i1.CommonModule, typeof TreeComponent, typeof TreeNodeComponent, typeof TreeNodeContent, typeof LoadingComponent, typeof TreeDropDirective, typeof TreeDragDirective, typeof TreeNodeExpanderComponent, typeof TreeNodeChildrenComponent, typeof TreeNodeDropSlot, typeof TreeNodeCollectionComponent, typeof TreeViewportComponent, typeof TreeNodeWrapperComponent, typeof TreeNodeCheckboxComponent, typeof TreeAnimateOpenDirective, typeof TreeMobxAutorunDirective], [typeof TreeComponent, typeof TreeNodeComponent, typeof TreeNodeContent, typeof LoadingComponent, typeof TreeDropDirective, typeof TreeDragDirective, typeof TreeNodeExpanderComponent, typeof TreeNodeChildrenComponent, typeof TreeNodeDropSlot, typeof TreeNodeCollectionComponent, typeof TreeViewportComponent, typeof TreeNodeWrapperComponent, typeof TreeNodeCheckboxComponent, typeof TreeAnimateOpenDirective, typeof TreeMobxAutorunDirective]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<TreeModule>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<TreeModule, never, [typeof i1.CommonModule, typeof TreeComponent, typeof TreeNodeComponent, typeof TreeNodeContent, typeof LoadingComponent, typeof TreeDropDirective, typeof TreeDragDirective, typeof TreeNodeExpanderComponent, typeof TreeNodeChildrenComponent, typeof TreeNodeDropSlot, typeof TreeNodeCollectionComponent, typeof TreeViewportComponent, typeof TreeNodeWrapperComponent, typeof TreeNodeCheckboxComponent, typeof TreeAnimateOpenDirective], [typeof TreeComponent, typeof TreeNodeComponent, typeof TreeNodeContent, typeof LoadingComponent, typeof TreeDropDirective, typeof TreeDragDirective, typeof TreeNodeExpanderComponent, typeof TreeNodeChildrenComponent, typeof TreeNodeDropSlot, typeof TreeNodeCollectionComponent, typeof TreeViewportComponent, typeof TreeNodeWrapperComponent, typeof TreeNodeCheckboxComponent, typeof TreeAnimateOpenDirective]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<TreeModule>;
 }
 
-export { KEYS, LoadingComponent, TREE_ACTIONS, TreeAnimateOpenDirective, TreeComponent, TreeDragDirective, TreeDraggedElement, TreeDropDirective, TreeMobxAutorunDirective, TreeModel, TreeModule, TreeNode, TreeNodeCheckboxComponent, TreeNodeChildrenComponent, TreeNodeCollectionComponent, TreeNodeComponent, TreeNodeContent, TreeNodeDropSlot, TreeNodeExpanderComponent, TreeNodeWrapperComponent, TreeViewportComponent, TreeVirtualScroll };
+export { KEYS, LoadingComponent, TREE_ACTIONS, TreeAnimateOpenDirective, TreeComponent, TreeDragDirective, TreeDraggedElement, TreeDropDirective, TreeModel, TreeModule, TreeNode, TreeNodeCheckboxComponent, TreeNodeChildrenComponent, TreeNodeCollectionComponent, TreeNodeComponent, TreeNodeContent, TreeNodeDropSlot, TreeNodeExpanderComponent, TreeNodeWrapperComponent, TreeViewportComponent, TreeVirtualScroll };
 export type { IActionHandler, IActionMapping, IAllowDragFn, IAllowDropFn, ITreeOptions, ITreeState };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ali-hm/angular-tree-component",
-  "version": "20.3.3",
-  "description": "A simple yet powerful tree component for Angular 19",
+  "version": "20.3.4",
+  "description": "A simple yet powerful tree component for Angular 12+",
   "author": "ali-hm",
   "homepage": "https://github.com/ali-hm/angular-tree-component",
   "license": "MIT",
@@ -26,11 +26,9 @@
   ],
   "peerDependencies": {
     "@angular/common": ">=20.0",
-    "@angular/core": ">=20.0",
-    "mobx": "~4.14.1"
+    "@angular/core": ">=20.0"
   },
   "dependencies": {
-    "mobx": "~4.14.1",
     "tslib": "^2.5.0"
   },
   "exports": {