@keenmate/svelte-treeview 4.8.0 → 5.0.0-rc02

package/dist/components/Tree.svelte.d.ts

@@ -1,8 +1,7 @@
 import type { Index, SearchOptions } from 'flexsearch';
 import { type LTreeNode } from '../ltree/ltree-node.svelte.js';
-import { type InsertArrayResult, type ContextMenuItem, type DropPosition, type DragDropMode, type DropOperation } from '../ltree/types.js';
-import { type RenderStats } from './RenderCoordinator.svelte.js';
-import '../global-api.js';
+import { type InsertArrayResult, type ContextMenuItem, type DropPosition, type DragDropMode, type DropOperation, type TreeChange, type ApplyChangesResult } from '../ltree/types.js';
+import type { RenderStats } from './RenderCoordinator.svelte.js';
 declare function $$render<T>(): {
     props: {
         idMember: string;
@@ -12,9 +11,12 @@ declare function $$render<T>(): {
         isExpandedMember?: string | null | undefined;
         isSelectedMember?: string | null | undefined;
         isDraggableMember?: string | null | undefined;
+        getIsDraggableCallback?: (node: LTreeNode<T>) => boolean;
         isDropAllowedMember?: string | null | undefined;
         allowedDropPositionsMember?: string | null | undefined;
         getAllowedDropPositionsCallback?: (node: LTreeNode<T>) => DropPosition[] | null | undefined;
+        isCollapsibleMember?: string | null | undefined;
+        getIsCollapsibleCallback?: (node: LTreeNode<T>) => boolean;
         hasChildrenMember?: string | null | undefined;
         isSorted?: boolean | null | undefined;
         displayValueMember?: string | null | undefined;
@@ -56,9 +58,9 @@ declare function $$render<T>(): {
         /**
          * Use flat/centralized rendering instead of recursive node rendering.
          * This significantly improves performance for large trees by:
+         * - Removing the {#key changeTracker} block that destroys all nodes on any change
          * - Using a single flat loop instead of recursive component instantiation
          * - Allowing Svelte's keyed {#each} to efficiently diff only changed nodes
-         * - Per-node reactive signals for O(1) data-only updates (updateNode, selection)
          */
         useFlatRendering?: boolean;
         /** Enable virtual scrolling in flat mode. Only visible nodes + overscan are rendered. */
@@ -110,14 +112,14 @@ declare function $$render<T>(): {
         collapseNodes: (nodePath: string) => Promise<void>;
         expandAll: (nodePath?: string | null | undefined) => void;
         collapseAll: (nodePath?: string | null | undefined) => void;
-        filterNodes: (searchText: string, searchOptions?: SearchOptions) => void;
-        searchNodes: (searchText: string | null | undefined, searchOptions?: SearchOptions) => LTreeNode<T>[];
+        filterNodes: (searchTextVal: string, searchOptions?: SearchOptions) => void;
+        searchNodes: (searchTextVal: string | null | undefined, searchOptions?: SearchOptions) => LTreeNode<T>[];
         getChildren: (parentPath: string) => LTreeNode<T>[];
         getSiblings: (path: string) => LTreeNode<T>[];
         refreshSiblings: (parentPath: string) => void;
         refreshNode: (path: string) => void;
         getNodeByPath: (path: string) => LTreeNode<T> | null;
-        moveNode: (sourcePath: string, targetPath: string, position: "above" | "below" | "child") => {
+        moveNode: (sourcePath: string, targetPath: string, position: "before" | "after" | "child") => {
             success: boolean;
             error?: string;
         };
@@ -126,7 +128,7 @@ declare function $$render<T>(): {
             node?: LTreeNode<T>;
             error?: string;
         };
-        addNode: (parentPath: string, data: T, pathSegment?: string) => {
+        addNode: (parentPath: string, nodeData: T, pathSegment?: string) => {
             success: boolean;
             node?: LTreeNode<T>;
             error?: string;
@@ -136,8 +138,8 @@ declare function $$render<T>(): {
             node?: LTreeNode<T>;
             error?: string;
         };
-        applyChanges: (changes: import("../ltree/types").TreeChange<T>[]) => import("../ltree/types").ApplyChangesResult;
-        copyNodeWithDescendants: (sourceNode: LTreeNode<T>, targetParentPath: string, transformData: (data: T) => T, siblingPath?: string, position?: "above" | "below") => {
+        applyChanges: (changes: TreeChange<T>[]) => ApplyChangesResult;
+        copyNodeWithDescendants: (sourceNode: LTreeNode<T>, targetParentPath: string, transformData: (data: T) => T, siblingPath?: string, position?: "before" | "after") => {
             success: boolean;
             rootNode?: LTreeNode<T>;
             count: number;
@@ -148,13 +150,10 @@ declare function $$render<T>(): {
         getAllData: () => T[];
         closeContextMenu: () => void;
         scrollToPath: (path: string, options?: {
-            /** Expand ancestors to make the node visible (default: true) */
             expand?: boolean;
-            /** Also expand the target node itself to show its children (default: false for performance) */
             expandTarget?: boolean;
             highlight?: boolean;
             scrollOptions?: ScrollIntoViewOptions;
-            /** Scroll only within the nearest scrollable container (prevents page scroll) */
             containerScroll?: boolean;
         }) => Promise<boolean>;
         update: (updates: Partial<Pick<{
@@ -165,9 +164,12 @@ declare function $$render<T>(): {
             isExpandedMember?: string | null | undefined;
             isSelectedMember?: string | null | undefined;
             isDraggableMember?: string | null | undefined;
+            getIsDraggableCallback?: (node: LTreeNode<T>) => boolean;
             isDropAllowedMember?: string | null | undefined;
             allowedDropPositionsMember?: string | null | undefined;
             getAllowedDropPositionsCallback?: (node: LTreeNode<T>) => DropPosition[] | null | undefined;
+            isCollapsibleMember?: string | null | undefined;
+            getIsCollapsibleCallback?: (node: LTreeNode<T>) => boolean;
             hasChildrenMember?: string | null | undefined;
             isSorted?: boolean | null | undefined;
             displayValueMember?: string | null | undefined;
@@ -209,9 +211,9 @@ declare function $$render<T>(): {
             /**
              * Use flat/centralized rendering instead of recursive node rendering.
              * This significantly improves performance for large trees by:
+             * - Removing the {#key changeTracker} block that destroys all nodes on any change
              * - Using a single flat loop instead of recursive component instantiation
              * - Allowing Svelte's keyed {#each} to efficiently diff only changed nodes
-             * - Per-node reactive signals for O(1) data-only updates (updateNode, selection)
              */
             useFlatRendering?: boolean;
             /** Enable virtual scrolling in flat mode. Only visible nodes + overscan are rendered. */
@@ -257,9 +259,9 @@ declare function $$render<T>(): {
             scrollHighlightClass?: string | null | undefined;
             contextMenuXOffset?: number | null | undefined;
             contextMenuYOffset?: number | null | undefined;
-        }, "treeId" | "treePathSeparator" | "idMember" | "pathMember" | "parentPathMember" | "levelMember" | "hasChildrenMember" | "isExpandedMember" | "isSelectedMember" | "isDraggableMember" | "isDropAllowedMember" | "displayValueMember" | "getDisplayValueCallback" | "searchValueMember" | "getSearchValueCallback" | "orderMember" | "isSorted" | "sortCallback" | "data" | "selectedNode" | "expandLevel" | "shouldToggleOnNodeClick" | "shouldUseInternalSearchIndex" | "initializeIndexCallback" | "searchText" | "indexerBatchSize" | "indexerTimeout" | "shouldDisplayDebugInformation" | "shouldDisplayContextMenuInDebugMode" | "onNodeClicked" | "onNodeDragStart" | "onNodeDragOver" | "beforeDropCallback" | "onNodeDrop" | "contextMenuCallback" | "dragDropMode" | "dropZoneMode" | "bodyClass" | "expandIconClass" | "collapseIconClass" | "leafIconClass" | "selectedNodeClass" | "dragOverNodeClass" | "scrollHighlightTimeout" | "scrollHighlightClass" | "contextMenuXOffset" | "contextMenuYOffset" | "virtualScroll" | "virtualRowHeight" | "virtualOverscan" | "virtualContainerHeight">>) => void;
+        }, "treeId" | "treePathSeparator" | "idMember" | "pathMember" | "parentPathMember" | "levelMember" | "hasChildrenMember" | "isExpandedMember" | "isSelectedMember" | "isDraggableMember" | "getIsDraggableCallback" | "isDropAllowedMember" | "displayValueMember" | "getDisplayValueCallback" | "searchValueMember" | "getSearchValueCallback" | "isCollapsibleMember" | "getIsCollapsibleCallback" | "orderMember" | "isSorted" | "sortCallback" | "data" | "selectedNode" | "expandLevel" | "shouldToggleOnNodeClick" | "shouldUseInternalSearchIndex" | "initializeIndexCallback" | "searchText" | "indexerBatchSize" | "indexerTimeout" | "shouldDisplayDebugInformation" | "shouldDisplayContextMenuInDebugMode" | "onNodeClicked" | "onNodeDragStart" | "onNodeDragOver" | "beforeDropCallback" | "onNodeDrop" | "contextMenuCallback" | "virtualScroll" | "virtualRowHeight" | "virtualOverscan" | "virtualContainerHeight" | "dragDropMode" | "dropZoneMode" | "bodyClass" | "expandIconClass" | "collapseIconClass" | "leafIconClass" | "selectedNodeClass" | "dragOverNodeClass" | "scrollHighlightTimeout" | "scrollHighlightClass" | "contextMenuXOffset" | "contextMenuYOffset">>) => void;
     };
-    bindings: "data" | "selectedNode" | "insertResult" | "searchText" | "isRendering";
+    bindings: "data" | "selectedNode" | "searchText" | "insertResult" | "isRendering";
     slots: {};
     events: {};
 };
@@ -267,20 +269,20 @@ declare class __sveltets_Render<T> {
     props(): ReturnType<typeof $$render<T>>['props'];
     events(): ReturnType<typeof $$render<T>>['events'];
     slots(): ReturnType<typeof $$render<T>>['slots'];
-    bindings(): "data" | "selectedNode" | "insertResult" | "searchText" | "isRendering";
+    bindings(): "data" | "selectedNode" | "searchText" | "insertResult" | "isRendering";
     exports(): {
         expandNodes: (nodePath: string) => Promise<void>;
         collapseNodes: (nodePath: string) => Promise<void>;
         expandAll: (nodePath?: string | null | undefined) => void;
         collapseAll: (nodePath?: string | null | undefined) => void;
-        filterNodes: (searchText: string, searchOptions?: SearchOptions) => void;
-        searchNodes: (searchText: string | null | undefined, searchOptions?: SearchOptions) => LTreeNode<T>[];
+        filterNodes: (searchTextVal: string, searchOptions?: SearchOptions) => void;
+        searchNodes: (searchTextVal: string | null | undefined, searchOptions?: SearchOptions) => LTreeNode<T>[];
         getChildren: (parentPath: string) => LTreeNode<T>[];
         getSiblings: (path: string) => LTreeNode<T>[];
         refreshSiblings: (parentPath: string) => void;
         refreshNode: (path: string) => void;
         getNodeByPath: (path: string) => LTreeNode<T> | null;
-        moveNode: (sourcePath: string, targetPath: string, position: "above" | "below" | "child") => {
+        moveNode: (sourcePath: string, targetPath: string, position: "before" | "after" | "child") => {
             success: boolean;
             error?: string;
         };
@@ -289,7 +291,7 @@ declare class __sveltets_Render<T> {
             node?: LTreeNode<T> | undefined;
             error?: string;
         };
-        addNode: (parentPath: string, data: T, pathSegment?: string) => {
+        addNode: (parentPath: string, nodeData: T, pathSegment?: string) => {
             success: boolean;
             node?: LTreeNode<T> | undefined;
             error?: string;
@@ -299,8 +301,8 @@ declare class __sveltets_Render<T> {
             node?: LTreeNode<T> | undefined;
             error?: string;
         };
-        applyChanges: (changes: import("../ltree/types.js").TreeChange<T>[]) => import("../ltree/types").ApplyChangesResult;
-        copyNodeWithDescendants: (sourceNode: LTreeNode<T>, targetParentPath: string, transformData: (data: T) => T, siblingPath?: string, position?: "above" | "below") => {
+        applyChanges: (changes: TreeChange<T>[]) => ApplyChangesResult;
+        copyNodeWithDescendants: (sourceNode: LTreeNode<T>, targetParentPath: string, transformData: (data: T) => T, siblingPath?: string, position?: "before" | "after") => {
             success: boolean;
             rootNode?: LTreeNode<T> | undefined;
             count: number;
@@ -311,13 +313,10 @@ declare class __sveltets_Render<T> {
         getAllData: () => T[];
         closeContextMenu: () => void;
         scrollToPath: (path: string, options?: {
-            /** Expand ancestors to make the node visible (default: true) */
             expand?: boolean;
-            /** Also expand the target node itself to show its children (default: false for performance) */
             expandTarget?: boolean;
             highlight?: boolean;
             scrollOptions?: ScrollIntoViewOptions;
-            /** Scroll only within the nearest scrollable container (prevents page scroll) */
             containerScroll?: boolean;
         } | undefined) => Promise<boolean>;
         update: (updates: Partial<Pick<{
@@ -328,9 +327,12 @@ declare class __sveltets_Render<T> {
             isExpandedMember?: string | null | undefined;
             isSelectedMember?: string | null | undefined;
             isDraggableMember?: string | null | undefined;
+            getIsDraggableCallback?: ((node: LTreeNode<T>) => boolean) | undefined;
             isDropAllowedMember?: string | null | undefined;
             allowedDropPositionsMember?: string | null | undefined;
             getAllowedDropPositionsCallback?: ((node: LTreeNode<T>) => DropPosition[] | null | undefined) | undefined;
+            isCollapsibleMember?: string | null | undefined;
+            getIsCollapsibleCallback?: ((node: LTreeNode<T>) => boolean) | undefined;
             hasChildrenMember?: string | null | undefined;
             isSorted?: boolean | null | undefined;
             displayValueMember?: string | null | undefined;
@@ -372,9 +374,9 @@ declare class __sveltets_Render<T> {
             /**
              * Use flat/centralized rendering instead of recursive node rendering.
              * This significantly improves performance for large trees by:
+             * - Removing the {#key changeTracker} block that destroys all nodes on any change
              * - Using a single flat loop instead of recursive component instantiation
              * - Allowing Svelte's keyed {#each} to efficiently diff only changed nodes
-             * - Per-node reactive signals for O(1) data-only updates (updateNode, selection)
              */
             useFlatRendering?: boolean;
             /** Enable virtual scrolling in flat mode. Only visible nodes + overscan are rendered. */
@@ -420,7 +422,7 @@ declare class __sveltets_Render<T> {
             scrollHighlightClass?: string | null | undefined;
             contextMenuXOffset?: number | null | undefined;
             contextMenuYOffset?: number | null | undefined;
-        }, "treeId" | "data" | "treePathSeparator" | "idMember" | "pathMember" | "parentPathMember" | "levelMember" | "hasChildrenMember" | "isExpandedMember" | "displayValueMember" | "getDisplayValueCallback" | "searchValueMember" | "getSearchValueCallback" | "orderMember" | "isSorted" | "sortCallback" | "isDraggableMember" | "isDropAllowedMember" | "shouldDisplayDebugInformation" | "isSelectedMember" | "selectedNode" | "expandLevel" | "shouldToggleOnNodeClick" | "shouldUseInternalSearchIndex" | "initializeIndexCallback" | "searchText" | "indexerBatchSize" | "indexerTimeout" | "shouldDisplayContextMenuInDebugMode" | "virtualScroll" | "virtualRowHeight" | "virtualOverscan" | "virtualContainerHeight" | "dragDropMode" | "dropZoneMode" | "onNodeClicked" | "onNodeDragStart" | "onNodeDragOver" | "beforeDropCallback" | "onNodeDrop" | "contextMenuCallback" | "bodyClass" | "expandIconClass" | "collapseIconClass" | "leafIconClass" | "selectedNodeClass" | "dragOverNodeClass" | "scrollHighlightTimeout" | "scrollHighlightClass" | "contextMenuXOffset" | "contextMenuYOffset">>) => void;
+        }, "treeId" | "data" | "treePathSeparator" | "idMember" | "pathMember" | "parentPathMember" | "levelMember" | "hasChildrenMember" | "isExpandedMember" | "displayValueMember" | "getDisplayValueCallback" | "searchValueMember" | "getSearchValueCallback" | "orderMember" | "isSorted" | "sortCallback" | "isDraggableMember" | "getIsDraggableCallback" | "isDropAllowedMember" | "isCollapsibleMember" | "getIsCollapsibleCallback" | "shouldDisplayDebugInformation" | "beforeDropCallback" | "onNodeDrop" | "contextMenuCallback" | "isSelectedMember" | "selectedNode" | "expandLevel" | "shouldToggleOnNodeClick" | "initializeIndexCallback" | "searchText" | "shouldUseInternalSearchIndex" | "indexerBatchSize" | "indexerTimeout" | "shouldDisplayContextMenuInDebugMode" | "virtualScroll" | "virtualRowHeight" | "virtualOverscan" | "virtualContainerHeight" | "dragDropMode" | "dropZoneMode" | "onNodeClicked" | "onNodeDragStart" | "onNodeDragOver" | "bodyClass" | "selectedNodeClass" | "dragOverNodeClass" | "expandIconClass" | "collapseIconClass" | "leafIconClass" | "scrollHighlightTimeout" | "scrollHighlightClass" | "contextMenuXOffset" | "contextMenuYOffset">>) => void;
     };
 }
 interface $$IsomorphicComponent {

package/dist/components/TreeProvider.svelte

@@ -0,0 +1,28 @@
+<script lang="ts" generics="T">
+	import { setContext, onDestroy, type Snippet } from 'svelte';
+	import { createTreeController } from '../core/createTreeController.js';
+	import { TreeController, type TreeControllerProps } from '../core/TreeController.svelte.js';
+
+	interface Props extends TreeControllerProps<T> {
+		children?: Snippet<[TreeController<T>]>;
+	}
+
+	let {
+		children,
+		...controllerProps
+	}: Props = $props();
+
+	const controller = createTreeController<T>(controllerProps as TreeControllerProps<T>);
+
+	// Set contexts that Node.svelte expects
+	setContext('Ltree', controller.tree);
+	setContext('NodeCallbacks', controller.nodeCallbacks);
+	setContext('NodeConfig', controller.nodeConfig);
+	if (controller.renderCoordinator) {
+		setContext('RenderCoordinator', controller.renderCoordinator);
+	}
+
+	onDestroy(() => controller.destroy());
+</script>
+
+{@render children?.(controller)}

package/dist/components/TreeProvider.svelte.d.ts

@@ -0,0 +1,28 @@
+import { type Snippet } from 'svelte';
+import { TreeController, type TreeControllerProps } from '../core/TreeController.svelte.js';
+declare function $$render<T>(): {
+    props: TreeControllerProps<T> & {
+        children?: Snippet<[TreeController<T>]>;
+    };
+    exports: {};
+    bindings: "";
+    slots: {};
+    events: {};
+};
+declare class __sveltets_Render<T> {
+    props(): ReturnType<typeof $$render<T>>['props'];
+    events(): ReturnType<typeof $$render<T>>['events'];
+    slots(): ReturnType<typeof $$render<T>>['slots'];
+    bindings(): "";
+    exports(): {};
+}
+interface $$IsomorphicComponent {
+    new <T>(options: import('svelte').ComponentConstructorOptions<ReturnType<__sveltets_Render<T>['props']>>): import('svelte').SvelteComponent<ReturnType<__sveltets_Render<T>['props']>, ReturnType<__sveltets_Render<T>['events']>, ReturnType<__sveltets_Render<T>['slots']>> & {
+        $$bindings?: ReturnType<__sveltets_Render<T>['bindings']>;
+    } & ReturnType<__sveltets_Render<T>['exports']>;
+    <T>(internal: unknown, props: ReturnType<__sveltets_Render<T>['props']> & {}): ReturnType<__sveltets_Render<T>['exports']>;
+    z_$$bindings?: ReturnType<__sveltets_Render<any>['bindings']>;
+}
+declare const TreeProvider: $$IsomorphicComponent;
+type TreeProvider<T> = InstanceType<typeof TreeProvider<T>>;
+export default TreeProvider;

package/dist/constants.generated.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "4.8.0";
+export declare const VERSION = "5.0.0-rc02";
 export declare const PACKAGE_NAME = "@keenmate/svelte-treeview";
 export declare const AUTHOR = "KeenMate";
 export declare const LICENSE = "MIT";

package/dist/constants.generated.js

@@ -1,6 +1,6 @@
 // Auto-generated file - do not edit manually
 // Generated by scripts/generate-constants.js
-export const VERSION = "4.8.0";
+export const VERSION = "5.0.0-rc02";
 export const PACKAGE_NAME = "@keenmate/svelte-treeview";
 export const AUTHOR = "KeenMate";
 export const LICENSE = "MIT";

package/dist/core/TreeController.svelte.d.ts

@@ -0,0 +1,353 @@
+import type { Index, SearchOptions } from 'flexsearch';
+import { type LTreeNode } from '../ltree/ltree-node.svelte.js';
+import { type Ltree, type InsertArrayResult, type ContextMenuItem, type DropPosition, type DragDropMode, type DropOperation, type TreeChange, type ApplyChangesResult } from '../ltree/types.js';
+import { type RenderCoordinator, type RenderStats } from '../components/RenderCoordinator.svelte.js';
+import '../global-api.js';
+export interface NodeCallbacks<T> {
+    onNodeClicked: (node: LTreeNode<T>) => void;
+    onNodeRightClicked: (node: LTreeNode<T>, event: MouseEvent) => void;
+    onNodeDragStart: (node: LTreeNode<T>, event: DragEvent) => void;
+    onNodeDragOver: (node: LTreeNode<T>, event: DragEvent) => void;
+    onNodeDragLeave: (node: LTreeNode<T>, event: DragEvent) => void;
+    onNodeDrop: (node: LTreeNode<T>, event: DragEvent) => void;
+    onZoneDrop: (node: LTreeNode<T>, position: DropPosition, event: DragEvent) => void;
+    onTouchDragStart: (node: LTreeNode<T>, event: TouchEvent) => void;
+    onTouchDragMove: (node: LTreeNode<T>, event: TouchEvent) => void;
+    onTouchDragEnd: (node: LTreeNode<T>, event: TouchEvent) => void;
+}
+export interface NodeConfig {
+    shouldToggleOnNodeClick: boolean;
+    expandIconClass: string;
+    collapseIconClass: string;
+    leafIconClass: string;
+    selectedNodeClass: string | null | undefined;
+    dragOverNodeClass: string | null | undefined;
+    dropZoneMode: 'floating' | 'glow';
+    dropZoneLayout: 'around' | 'above' | 'below' | 'wave' | 'wave2';
+    dropZoneStart: number | string;
+    dropZoneMaxWidth: number;
+    allowCopy: boolean;
+}
+export interface TreeControllerProps<T> {
+    idMember: string;
+    pathMember: string;
+    parentPathMember?: string | null | undefined;
+    levelMember?: string | null | undefined;
+    isExpandedMember?: string | null | undefined;
+    isSelectedMember?: string | null | undefined;
+    isDraggableMember?: string | null | undefined;
+    getIsDraggableCallback?: (node: LTreeNode<T>) => boolean;
+    isDropAllowedMember?: string | null | undefined;
+    allowedDropPositionsMember?: string | null | undefined;
+    getAllowedDropPositionsCallback?: (node: LTreeNode<T>) => DropPosition[] | null | undefined;
+    isCollapsibleMember?: string | null | undefined;
+    getIsCollapsibleCallback?: (node: LTreeNode<T>) => boolean;
+    hasChildrenMember?: string | null | undefined;
+    isSorted?: boolean | null | undefined;
+    displayValueMember?: string | null | undefined;
+    getDisplayValueCallback?: (node: LTreeNode<T>) => string;
+    searchValueMember?: string | null | undefined;
+    getSearchValueCallback?: (node: LTreeNode<T>) => string;
+    orderMember?: string | null | undefined;
+    treeId?: string | null | undefined;
+    treePathSeparator?: string | null | undefined;
+    sortCallback?: (items: LTreeNode<T>[]) => LTreeNode<T>[];
+    data: T[];
+    selectedNode?: LTreeNode<T> | null | undefined;
+    expandLevel?: number | null | undefined;
+    shouldToggleOnNodeClick?: boolean | null | undefined;
+    initializeIndexCallback?: () => Index;
+    searchText?: string | null | undefined;
+    shouldUseInternalSearchIndex?: boolean | null | undefined;
+    indexerBatchSize?: number | null | undefined;
+    indexerTimeout?: number | null | undefined;
+    shouldDisplayDebugInformation?: boolean;
+    shouldDisplayContextMenuInDebugMode?: boolean;
+    isLoading?: boolean;
+    progressiveRender?: boolean;
+    initialBatchSize?: number;
+    maxBatchSize?: number;
+    onRenderStart?: () => void;
+    onRenderProgress?: (stats: RenderStats) => void;
+    onRenderComplete?: (stats: RenderStats) => void;
+    useFlatRendering?: boolean;
+    /** Enable virtual scrolling in flat mode. Only visible nodes + overscan are rendered. */
+    virtualScroll?: boolean;
+    /** Explicit row height in px. Auto-measured from first row if not set. */
+    virtualRowHeight?: number;
+    /** Extra rows above/below viewport (default: 5) */
+    virtualOverscan?: number;
+    /** CSS height for scroll container. Auto-detected from parent if not set, fallback 400px. */
+    virtualContainerHeight?: string;
+    dragDropMode?: DragDropMode;
+    dropZoneMode?: 'floating' | 'glow';
+    dropZoneLayout?: 'around' | 'above' | 'below' | 'wave' | 'wave2';
+    dropZoneStart?: number | string;
+    dropZoneMaxWidth?: number;
+    allowCopy?: boolean;
+    autoHandleCopy?: boolean;
+    onNodeClicked?: (node: LTreeNode<T>) => void;
+    onNodeDragStart?: (node: LTreeNode<T>, event: DragEvent) => void;
+    onNodeDragOver?: (node: LTreeNode<T>, event: DragEvent) => void;
+    beforeDropCallback?: (dropNode: LTreeNode<T> | null, draggedNode: LTreeNode<T>, position: DropPosition, event: DragEvent | TouchEvent, operation: DropOperation) => boolean | {
+        position?: DropPosition;
+        operation?: DropOperation;
+    } | void | Promise<boolean | {
+        position?: DropPosition;
+        operation?: DropOperation;
+    } | void>;
+    onNodeDrop?: (dropNode: LTreeNode<T> | null, draggedNode: LTreeNode<T>, position: DropPosition, event: DragEvent | TouchEvent, operation: DropOperation) => void;
+    contextMenuCallback?: (node: LTreeNode<T>, closeMenuCallback: () => void) => ContextMenuItem[];
+    hasContextMenuSnippet?: boolean;
+    bodyClass?: string | null | undefined;
+    selectedNodeClass?: string | null | undefined;
+    dragOverNodeClass?: string | null | undefined;
+    expandIconClass?: string | null | undefined;
+    collapseIconClass?: string | null | undefined;
+    leafIconClass?: string | null | undefined;
+    scrollHighlightTimeout?: number | null | undefined;
+    scrollHighlightClass?: string | null | undefined;
+    contextMenuXOffset?: number | null | undefined;
+    contextMenuYOffset?: number | null | undefined;
+}
+export declare class TreeController<T> {
+    tree: Ltree<T>;
+    renderCoordinator: RenderCoordinator | null;
+    nodeCallbacks: NodeCallbacks<T>;
+    nodeConfig: NodeConfig;
+    treeId: string;
+    treePathSeparator: string;
+    data: T[];
+    selectedNode: LTreeNode<T> | null | undefined;
+    insertResult: InsertArrayResult<T> | null | undefined;
+    searchText: string | null | undefined;
+    isRendering: boolean;
+    shouldDisplayDebugInformation: boolean;
+    shouldDisplayContextMenuInDebugMode: boolean;
+    isLoading: boolean;
+    useFlatRendering: boolean;
+    progressiveRender: boolean;
+    initialBatchSize: number;
+    maxBatchSize: number;
+    bodyClass: string | null | undefined;
+    dragDropMode: DragDropMode;
+    allowCopy: boolean;
+    autoHandleCopy: boolean;
+    onNodeClickedCb: ((node: LTreeNode<T>) => void) | undefined;
+    onNodeDragStartCb: ((node: LTreeNode<T>, event: DragEvent) => void) | undefined;
+    onNodeDragOverCb: ((node: LTreeNode<T>, event: DragEvent) => void) | undefined;
+    beforeDropCallbackCb: TreeControllerProps<T>['beforeDropCallback'];
+    onNodeDropCb: TreeControllerProps<T>['onNodeDrop'];
+    contextMenuCallbackCb: TreeControllerProps<T>['contextMenuCallback'];
+    onRenderStartCb: (() => void) | undefined;
+    onRenderProgressCb: ((stats: RenderStats) => void) | undefined;
+    onRenderCompleteCb: ((stats: RenderStats) => void) | undefined;
+    shouldToggleOnNodeClick: boolean;
+    expandIconClass: string;
+    collapseIconClass: string;
+    leafIconClass: string;
+    selectedNodeClass: string | null | undefined;
+    dragOverNodeClass: string | null | undefined;
+    dropZoneMode: "floating" | "glow";
+    dropZoneLayout: "around" | "above" | "below" | "wave" | "wave2";
+    dropZoneStart: string | number;
+    dropZoneMaxWidth: number;
+    scrollHighlightTimeout: number;
+    scrollHighlightClass: string | null | undefined;
+    contextMenuXOffset: number;
+    contextMenuYOffset: number;
+    hasContextMenuSnippet: boolean;
+    virtualScroll: boolean;
+    virtualRowHeight: number | undefined;
+    virtualOverscan: number;
+    virtualContainerHeight: string | undefined;
+    contextMenuVisible: boolean;
+    contextMenuX: number;
+    contextMenuY: number;
+    contextMenuNode: LTreeNode<T> | null;
+    isDebugMenuActive: boolean;
+    currentHighlight: {
+        element: HTMLElement;
+        timeoutId: ReturnType<typeof setTimeout>;
+    } | null;
+    draggedNode: LTreeNode<any> | null;
+    isDragInProgress: boolean;
+    hoveredNodeForDrop: LTreeNode<any> | null;
+    activeDropPosition: DropPosition | null;
+    currentDropOperation: DropOperation;
+    floatingZoneRect: {
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    } | null;
+    floatingHoveredZone: "before" | "after" | "child" | null;
+    touchDragState: {
+        node: LTreeNode<any> | null;
+        startX: number;
+        startY: number;
+        isDragging: boolean;
+        ghostElement: HTMLElement | null;
+        currentDropTarget: LTreeNode<any> | null;
+    };
+    touchTimer: ReturnType<typeof setTimeout> | null;
+    flatRenderedIds: Set<string>;
+    flatRenderQueue: string[];
+    flatRenderAnimationFrame: number | null;
+    currentBatchSize: number;
+    vsScrollTop: number;
+    vsMeasuredRowHeight: number | null;
+    vsContainerRef: HTMLDivElement | undefined;
+    vsDetectedHeight: string | null;
+    private vsRafPending;
+    isDropPlaceholderActive: boolean;
+    _skipInsertArray: boolean;
+    private lastFlatNodesTracker;
+    containerElement: HTMLElement | null;
+    vsRowHeight: number;
+    vsActive: boolean;
+    vsContainerStyle: string;
+    allFlatNodes: LTreeNode<T>[];
+    vsTotalCount: number;
+    vsTotalHeight: number;
+    vsStartIndex: number;
+    vsEndIndex: number;
+    vsOffsetY: number;
+    flatNodesToRender: LTreeNode<T>[];
+    get statistics(): {
+        nodeCount: number;
+        maxLevel: number;
+        filteredNodeCount: number;
+        isIndexing: boolean;
+        pendingIndexCount: number;
+    };
+    constructor(props: TreeControllerProps<T>);
+    handleVirtualScroll: (event: Event) => void;
+    expandNodes(nodePath: string): Promise<void>;
+    collapseNodes(nodePath: string): Promise<void>;
+    expandAll(nodePath?: string | null | undefined): void;
+    collapseAll(nodePath?: string | null | undefined): void;
+    filterNodes(searchTextVal: string, searchOptions?: SearchOptions): void;
+    searchNodes(searchTextVal: string | null | undefined, searchOptions?: SearchOptions): LTreeNode<T>[];
+    getChildren(parentPath: string): LTreeNode<T>[];
+    getSiblings(path: string): LTreeNode<T>[];
+    refreshSiblings(parentPath: string): void;
+    refreshNode(path: string): void;
+    getNodeByPath(path: string): LTreeNode<T> | null;
+    moveNode(sourcePath: string, targetPath: string, position: 'before' | 'after' | 'child'): {
+        success: boolean;
+        error?: string;
+    };
+    removeNode(path: string, includeDescendants?: boolean): {
+        success: boolean;
+        node?: LTreeNode<T>;
+        error?: string;
+    };
+    addNode(parentPath: string, nodeData: T, pathSegment?: string): {
+        success: boolean;
+        node?: LTreeNode<T>;
+        error?: string;
+    };
+    updateNode(path: string, dataUpdates: Partial<T>): {
+        success: boolean;
+        node?: LTreeNode<T>;
+        error?: string;
+    };
+    applyChanges(changes: TreeChange<T>[]): ApplyChangesResult;
+    copyNodeWithDescendants(sourceNode: LTreeNode<T>, targetParentPath: string, transformData: (data: T) => T, siblingPath?: string, position?: 'before' | 'after'): {
+        success: boolean;
+        rootNode?: LTreeNode<T>;
+        count: number;
+        error?: string;
+    };
+    getExpandedPaths(): string[];
+    setExpandedPaths(paths: string[]): void;
+    getAllData(): T[];
+    /** Open the context menu at the given screen coordinates (offsets are applied automatically). */
+    openContextMenu(node: LTreeNode<T>, screenX: number, screenY: number): void;
+    closeContextMenu(): void;
+    /** Call from ondragstart. Sets up dataTransfer, stores drag state, fires callback. */
+    startDrag(node: LTreeNode<T>, event: DragEvent): void;
+    /** Call from ondragover. preventDefault, calculates drop position, updates hover state.
+     *  Pass `element` for position calculation (before/after/child based on cursor). */
+    dragOver(node: LTreeNode<T>, event: DragEvent, element?: HTMLElement): void;
+    /** Call from ondragleave. Clears hover state when cursor leaves element bounds. */
+    dragLeave(_node: LTreeNode<T>, event: DragEvent): void;
+    /** Call from ondrop. Uses calculated position or defaults to 'child'. */
+    drop(node: LTreeNode<T>, event: DragEvent): void;
+    /** Drop with explicit position (for custom drop zones or floating-style UI). */
+    dropAt(node: LTreeNode<T>, position: DropPosition, event: DragEvent | TouchEvent): void;
+    /** Cancel current drag and reset all state. */
+    cancelDrag(): void;
+    /** Touch drag start — proxy to internal touch handler. */
+    touchStart(node: LTreeNode<T>, event: TouchEvent): void;
+    /** Touch drag move — proxy to internal touch handler. */
+    touchMove(node: LTreeNode<T>, event: TouchEvent): void;
+    /** Touch drag end — proxy to internal touch handler. */
+    touchEnd(node: LTreeNode<T>, event: TouchEvent): void;
+    /** Get allowed drop positions for a node (proxies LTree method). */
+    getNodeAllowedDropPositions(node: LTreeNode<T>): DropPosition[] | null;
+    /** Get whether a node is draggable (proxies LTree resolution: callback > member > node property). */
+    getNodeIsDraggable(node: LTreeNode<T>): boolean;
+    /** Get whether a node is collapsible (proxies LTree resolution: callback > member > node property). */
+    getNodeIsCollapsible(node: LTreeNode<T>): boolean;
+    /** Calculate drop position from cursor location within an element (before/after/child).
+     *  Same logic as Node.svelte's calculateGlowPosition, respecting allowed positions. */
+    calculateDropPositionFromEvent(event: DragEvent | MouseEvent, element: HTMLElement, allowedPositions?: DropPosition[] | null): DropPosition;
+    scrollToPath(path: string, options?: {
+        expand?: boolean;
+        expandTarget?: boolean;
+        highlight?: boolean;
+        scrollOptions?: ScrollIntoViewOptions;
+        containerScroll?: boolean;
+        containerElement?: HTMLElement;
+    }): Promise<boolean>;
+    /**
+     * Apply scroll highlight to a node element by ID.
+     * Returns true if the element was found and highlighted, false otherwise.
+     */
+    private applyHighlight;
+    updateProps(updates: Partial<TreeControllerProps<T>>): void;
+    private _onNodeClicked;
+    private _onNodeRightClicked;
+    private isDropAllowedByMode;
+    private calculateDropPosition;
+    private _onNodeDragStart;
+    _onNodeDragEnd: (event: DragEvent) => void;
+    private _resetDragState;
+    private _handleDrop;
+    private _onNodeDragOver;
+    private _onNodeDragLeave;
+    private _onNodeDrop;
+    private _onZoneDrop;
+    isFloatingPositionAllowed(position: DropPosition): boolean;
+    handleFloatingZoneDragOver(position: 'before' | 'after' | 'child', event: DragEvent): void;
+    handleFloatingZoneDragLeave(): void;
+    handleFloatingZoneDrop(position: DropPosition, event: DragEvent): void;
+    private _onTouchStart;
+    private _onTouchMove;
+    private _onTouchEnd;
+    private _boundDocTouchMove;
+    private _boundDocTouchEnd;
+    private _addDocumentTouchListeners;
+    private _removeDocumentTouchListeners;
+    private _docTouchMove;
+    private _docTouchEnd;
+    private _resetTouchState;
+    private createGhostElement;
+    private removeGhostElement;
+    /** Clean up document-level listeners and ghost elements. Called on component destroy. */
+    destroy(): void;
+    private findNodeFromElement;
+    private updateDropTarget;
+    private clearDropTargetHighlight;
+    handleEmptyTreeDragOver: (event: DragEvent) => void;
+    handleEmptyTreeDragLeave: (event: DragEvent) => void;
+    handleEmptyTreeDrop: (event: DragEvent) => void;
+    handleEmptyTreeTouchEnd: (event: TouchEvent) => void;
+    handleTreeDragEnter: (event: DragEvent) => void;
+    handleTreeDragLeave: (event: DragEvent) => void;
+    scheduleFlatRenderBatch(): void;
+    private generateTreeId;
+    findScrollableAncestor(element: HTMLElement): HTMLElement | null;
+}