dnd-block-tree 0.5.0 → 1.1.0

package/README.md

@@ -1,20 +1,17 @@
 # dnd-block-tree
 
 [![npm version](https://img.shields.io/npm/v/dnd-block-tree.svg)](https://www.npmjs.com/package/dnd-block-tree)
-[![npm downloads](https://img.shields.io/npm/dm/dnd-block-tree.svg)](https://www.npmjs.com/package/dnd-block-tree)
-[![bundle size](https://img.shields.io/bundlephobia/minzip/dnd-block-tree)](https://bundlephobia.com/package/dnd-block-tree)
 [![CI](https://github.com/thesandybridge/dnd-block-tree/actions/workflows/ci.yml/badge.svg)](https://github.com/thesandybridge/dnd-block-tree/actions/workflows/ci.yml)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![TypeScript](https://img.shields.io/badge/TypeScript-5.0-blue.svg)](https://www.typescriptlang.org/)
-[![demo](https://img.shields.io/badge/demo-live-brightgreen.svg)](https://dnd-block-tree.vercel.app)
+[![demo](https://img.shields.io/badge/demo-live-brightgreen.svg)](https://blocktree.sandybridge.io)
 
 A headless React library for building hierarchical drag-and-drop interfaces. Bring your own components, we handle the complexity.
 
 ## Features
 
 - **Stable Drop Zones** - Zones render based on original block positions, not preview state, ensuring consistent drop targets during drag
-- **Ghost Preview** - Semi-transparent preview shows where blocks will land without affecting zone positions
-- **Depth-Aware Collision** - Smart algorithm prefers nested zones when cursor is at indented levels, with hysteresis to prevent flickering
+- **Ghost Preview** - In-flow semi-transparent preview shows where blocks will land with accurate layout
+- **Snapshotted Collision** - Zone rects are frozen on drag start and re-measured after each ghost commit, preventing layout-shift feedback loops
+- **Depth-Aware Collision** - Smart algorithm prefers nested zones when cursor is at indented levels, with cross-depth-aware hysteresis
 - **Mobile & Touch Support** - Separate touch/pointer activation constraints with configurable `longPressDelay` and optional `hapticFeedback`
 - **Snapshot-Based Computation** - State captured at drag start. All preview computations use snapshot, ensuring consistent behavior
 - **Debounced Preview** - 150ms debounced virtual state for smooth drag previews without jitter
@@ -516,7 +513,7 @@ Enable accessible tree navigation with the `keyboardNavigation` prop:
 | Home | Focus first block |
 | End | Focus last block |
 
-Blocks receive `data-block-id` and `tabIndex` attributes for focus management, and the tree root gets `role="tree"`.
+Blocks receive `data-block-id` and `tabIndex` attributes for focus management, and the tree root gets `role="tree"`. Each block element includes WAI-ARIA TreeView attributes: `aria-level`, `aria-posinset`, `aria-setsize`, `aria-expanded` (containers only), and `aria-selected`.
 
 ## Multi-Select Drag
 
@@ -627,6 +624,31 @@ const collision = createStickyCollision(20)
 
 You can also pass any `CollisionDetection` function from `@dnd-kit/core`.
 
+### Snapshotted Zone Rects
+
+`createStickyCollision` accepts an optional `SnapshotRectsRef` — a ref to a `Map<string, DOMRect>` of frozen zone positions. When provided, collision detection uses these snapshots instead of live DOM measurements, preventing feedback loops caused by the in-flow ghost preview shifting zone positions.
+
+```typescript
+import { createStickyCollision, type SnapshotRectsRef } from 'dnd-block-tree'
+
+const snapshotRef: SnapshotRectsRef = { current: null }
+const collision = createStickyCollision(20, snapshotRef)
+
+// Snapshot all zone rects after drag starts:
+snapshotRef.current = new Map(
+  [...document.querySelectorAll('[data-zone-id]')].map(el => [
+    el.getAttribute('data-zone-id')!,
+    el.getBoundingClientRect(),
+  ])
+)
+```
+
+`BlockTree` handles this lifecycle automatically — zones are snapshotted on drag start and re-measured via `requestAnimationFrame` after each ghost position commit.
+
+### Cross-Depth Hysteresis
+
+The sticky collision uses a reduced threshold (25% of normal) when switching between zones at different indentation levels. This makes it easy to drag blocks in and out of containers while still preventing flickering between same-depth adjacent zones.
+
 ## Type Safety
 
 The library provides automatic type inference for container vs non-container renderers:
@@ -663,6 +685,7 @@ import {
   deleteBlockAndDescendants,  // Remove a block and all its descendants from index
   getBlockDepth,              // Compute depth of a block (root = 1)
   getSubtreeDepth,            // Max depth of a subtree (leaf = 1)
+  validateBlockTree,          // Validate tree for cycles, orphans, stale refs
 
   // Serialization
   flatToNested,               // Convert flat block array to nested tree
@@ -687,12 +710,22 @@ import {
   // Collision detection
   weightedVerticalCollision,  // Edge-distance collision, depth-aware
   closestCenterCollision,     // Simple closest-center collision
-  createStickyCollision,      // Hysteresis wrapper to prevent flickering
+  createStickyCollision,      // Hysteresis wrapper with snapshot support
+  type SnapshotRectsRef,      // Ref type for frozen zone rects
+
+  // Internal helpers
+  cloneMap,                   // Clone a Map
+  cloneParentMap,             // Deep clone a parent->children Map
+  debounce,                   // Debounce with cancel()
 
   // Hooks
+  createBlockState,           // Factory for block state context + provider
+  createTreeState,            // Factory for tree UI state context + provider
   useBlockHistory,            // Undo/redo state management
   useLayoutAnimation,         // FLIP-based reorder animations
   useVirtualTree,             // Virtual scrolling primitives
+  useConfiguredSensors,       // Configure dnd-kit sensors
+  getSensorConfig,            // Get sensor config from SensorConfig
 
   // Components
   BlockTree,                  // Main drag-and-drop tree component
@@ -705,7 +738,7 @@ import {
 
 ## Demo
 
-Check out the [live demo](https://dnd-block-tree.vercel.app) to see the library in action with two example use cases:
+Check out the [live demo](https://blocktree.sandybridge.io) to see the library in action with two example use cases:
 
 - **Productivity** - Sections, tasks, and notes with undo/redo, max depth control, and keyboard navigation
 - **File System** - Folders and files

package/dist/index.d.mts

@@ -389,6 +389,81 @@ interface TreeStateProviderProps<T extends BaseBlock = BaseBlock> {
     blockMap: Map<string, T>;
 }
 
+/**
+ * Clone a Map
+ */
+declare function cloneMap<K, V>(map: Map<K, V>): Map<K, V>;
+/**
+ * Clone a parent map with arrays
+ */
+declare function cloneParentMap(map: Map<string | null, string[]>): Map<string | null, string[]>;
+/**
+ * Compute normalized index from flat block array.
+ *
+ * With `orderingStrategy: 'fractional'`, siblings are sorted by their `order`
+ * field (lexicographic). With `'integer'` (default), the input order is preserved.
+ */
+declare function computeNormalizedIndex<T extends BaseBlock>(blocks: T[], orderingStrategy?: OrderingStrategy): BlockIndex<T>;
+/**
+ * Build ordered flat array from BlockIndex.
+ *
+ * With `'integer'` ordering (default), assigns sequential `order: 0, 1, 2, …`.
+ * With `'fractional'` ordering, preserves existing `order` values — the moved
+ * block already has its new fractional key set by `reparentBlockIndex`.
+ */
+declare function buildOrderedBlocks<T extends BaseBlock>(index: BlockIndex<T>, containerTypes?: readonly string[], orderingStrategy?: OrderingStrategy): T[];
+/**
+ * Reparent a block based on drop zone ID.
+ *
+ * @param state - Current block index
+ * @param activeId - ID of the dragged block
+ * @param targetZone - Drop zone ID (e.g., "after-uuid", "before-uuid", "into-uuid")
+ * @param containerTypes - Block types that can have children
+ * @param orderingStrategy - Whether to assign a fractional key to the moved block
+ */
+declare function reparentBlockIndex<T extends BaseBlock>(state: BlockIndex<T>, activeId: UniqueIdentifier, targetZone: string, containerTypes?: readonly string[], orderingStrategy?: OrderingStrategy, maxDepth?: number): BlockIndex<T>;
+/**
+ * Compute the depth of a block by walking its parentId chain.
+ * Root-level blocks have depth 1.
+ */
+declare function getBlockDepth<T extends BaseBlock>(index: BlockIndex<T>, blockId: string): number;
+/**
+ * Compute the maximum depth of a subtree rooted at blockId (inclusive).
+ * A leaf block returns 1.
+ */
+declare function getSubtreeDepth<T extends BaseBlock>(index: BlockIndex<T>, blockId: string, visited?: Set<string>): number;
+/**
+ * Get all descendant IDs of a block
+ */
+declare function getDescendantIds<T extends BaseBlock>(state: BlockIndex<T>, parentId: string): Set<string>;
+/**
+ * Reparent multiple blocks to a target zone, preserving their relative order.
+ * The first block in `blockIds` is treated as the primary (anchor) block.
+ */
+declare function reparentMultipleBlocks<T extends BaseBlock>(state: BlockIndex<T>, blockIds: string[], targetZone: string, containerTypes?: readonly string[], orderingStrategy?: OrderingStrategy, maxDepth?: number): BlockIndex<T>;
+/**
+ * Result of validating a block tree
+ */
+interface TreeValidationResult {
+    valid: boolean;
+    issues: string[];
+}
+/**
+ * Validate a block tree index for structural integrity.
+ * Checks for cycles, orphans (parentId references non-existent block),
+ * and stale refs (byParent lists IDs not present in byId).
+ *
+ * Opt-in utility — not called automatically.
+ */
+declare function validateBlockTree<T extends BaseBlock>(index: BlockIndex<T>): TreeValidationResult;
+/**
+ * Delete a block and all its descendants
+ */
+declare function deleteBlockAndDescendants<T extends BaseBlock>(state: BlockIndex<T>, id: string): BlockIndex<T>;
+
+type SnapshotRectsRef = {
+    current: Map<UniqueIdentifier, DOMRect> | null;
+};
 /**
  * Custom collision detection that scores drop zones by distance to nearest edge.
  * Uses edge-distance scoring with a bottom bias for more natural drag behavior.
@@ -404,8 +479,11 @@ declare const weightedVerticalCollision: CollisionDetection;
  * between adjacent drop zones.
  *
  * @param threshold - Minimum score improvement required to switch zones (default: 15px)
+ * @param snapshotRef - Optional ref to snapshotted zone rects. When populated,
+ *   collision detection uses these frozen rects instead of live DOM measurements,
+ *   preventing layout-shift feedback loops from in-flow ghost previews.
  */
-declare function createStickyCollision(threshold?: number): CollisionDetection & {
+declare function createStickyCollision(threshold?: number, snapshotRef?: SnapshotRectsRef): CollisionDetection & {
     reset: () => void;
 };
 /**
@@ -521,7 +599,8 @@ interface TreeRendererProps<T extends BaseBlock> {
 /**
  * Recursive tree renderer with smart drop zones
  */
-declare function TreeRenderer<T extends BaseBlock>({ blocks, blocksByParent, parentId, activeId, expandedMap, renderers, containerTypes, onHover, onToggleExpand, depth, dropZoneClassName, dropZoneActiveClassName, indentClassName, rootClassName, canDrag, previewPosition, draggedBlock, focusedId, selectedIds, onBlockClick, animation, virtualVisibleIds, }: TreeRendererProps<T>): react_jsx_runtime.JSX.Element;
+declare function TreeRendererInner<T extends BaseBlock>({ blocks, blocksByParent, parentId, activeId, expandedMap, renderers, containerTypes, onHover, onToggleExpand, depth, dropZoneClassName, dropZoneActiveClassName, indentClassName, rootClassName, canDrag, previewPosition, draggedBlock, focusedId, selectedIds, onBlockClick, animation, virtualVisibleIds, }: TreeRendererProps<T>): react_jsx_runtime.JSX.Element;
+declare const TreeRenderer: typeof TreeRendererInner;
 
 interface DropZoneProps {
     id: string;
@@ -666,63 +745,6 @@ interface UseVirtualTreeResult {
  */
 declare function useVirtualTree({ containerRef, itemCount, itemHeight, overscan, }: UseVirtualTreeOptions): UseVirtualTreeResult;
 
-/**
- * Clone a Map
- */
-declare function cloneMap<K, V>(map: Map<K, V>): Map<K, V>;
-/**
- * Clone a parent map with arrays
- */
-declare function cloneParentMap(map: Map<string | null, string[]>): Map<string | null, string[]>;
-/**
- * Compute normalized index from flat block array.
- *
- * With `orderingStrategy: 'fractional'`, siblings are sorted by their `order`
- * field (lexicographic). With `'integer'` (default), the input order is preserved.
- */
-declare function computeNormalizedIndex<T extends BaseBlock>(blocks: T[], orderingStrategy?: OrderingStrategy): BlockIndex<T>;
-/**
- * Build ordered flat array from BlockIndex.
- *
- * With `'integer'` ordering (default), assigns sequential `order: 0, 1, 2, …`.
- * With `'fractional'` ordering, preserves existing `order` values — the moved
- * block already has its new fractional key set by `reparentBlockIndex`.
- */
-declare function buildOrderedBlocks<T extends BaseBlock>(index: BlockIndex<T>, containerTypes?: readonly string[], orderingStrategy?: OrderingStrategy): T[];
-/**
- * Reparent a block based on drop zone ID.
- *
- * @param state - Current block index
- * @param activeId - ID of the dragged block
- * @param targetZone - Drop zone ID (e.g., "after-uuid", "before-uuid", "into-uuid")
- * @param containerTypes - Block types that can have children
- * @param orderingStrategy - Whether to assign a fractional key to the moved block
- */
-declare function reparentBlockIndex<T extends BaseBlock>(state: BlockIndex<T>, activeId: UniqueIdentifier, targetZone: string, containerTypes?: readonly string[], orderingStrategy?: OrderingStrategy, maxDepth?: number): BlockIndex<T>;
-/**
- * Compute the depth of a block by walking its parentId chain.
- * Root-level blocks have depth 1.
- */
-declare function getBlockDepth<T extends BaseBlock>(index: BlockIndex<T>, blockId: string): number;
-/**
- * Compute the maximum depth of a subtree rooted at blockId (inclusive).
- * A leaf block returns 1.
- */
-declare function getSubtreeDepth<T extends BaseBlock>(index: BlockIndex<T>, blockId: string): number;
-/**
- * Get all descendant IDs of a block
- */
-declare function getDescendantIds<T extends BaseBlock>(state: BlockIndex<T>, parentId: string): Set<string>;
-/**
- * Reparent multiple blocks to a target zone, preserving their relative order.
- * The first block in `blockIds` is treated as the primary (anchor) block.
- */
-declare function reparentMultipleBlocks<T extends BaseBlock>(state: BlockIndex<T>, blockIds: string[], targetZone: string, containerTypes?: readonly string[], orderingStrategy?: OrderingStrategy, maxDepth?: number): BlockIndex<T>;
-/**
- * Delete a block and all its descendants
- */
-declare function deleteBlockAndDescendants<T extends BaseBlock>(state: BlockIndex<T>, id: string): BlockIndex<T>;
-
 /**
  * Extract UUID from a zone ID by removing the prefix (before-, after-, into-, end-)
  */
@@ -811,4 +833,4 @@ declare function initFractionalOrder<T extends {
     order: number | string;
 }>(blocks: T[]): T[];
 
-export { type AnimationConfig, type AutoExpandConfig, type BaseBlock, type BlockAction, type BlockAddEvent, type BlockDeleteEvent, type BlockIndex, type BlockMoveEvent, type BlockPosition, type BlockRendererProps, type BlockRenderers, type BlockStateContextValue, type BlockStateProviderProps, BlockTree, type BlockTreeCallbacks, type BlockTreeConfig, type BlockTreeCustomization, type BlockTreeProps, BlockTreeSSR, type BlockTreeSSRProps, type CanDragFn, type CanDropFn, type ContainerRendererProps, type DragEndEvent, type DragMoveEvent, DragOverlay, type DragOverlayProps$1 as DragOverlayProps, type DragStartEvent, DropZone, type DropZoneConfig, type DropZoneProps, type DropZoneType, type ExpandChangeEvent, type HoverChangeEvent, type IdGeneratorFn, type InternalRenderers, type MoveOperation, type NestedBlock, type OrderingStrategy, type RendererPropsFor, type SensorConfig, TreeRenderer, type TreeRendererProps, type TreeStateContextValue, type TreeStateProviderProps, type UseBlockHistoryOptions, type UseBlockHistoryResult, type UseLayoutAnimationOptions, type UseVirtualTreeOptions, type UseVirtualTreeResult, buildOrderedBlocks, cloneMap, cloneParentMap, closestCenterCollision, compareFractionalKeys, computeNormalizedIndex, createBlockState, createStickyCollision, createTreeState, debounce, deleteBlockAndDescendants, extractBlockId, extractUUID, flatToNested, generateId, generateInitialKeys, generateKeyBetween, generateNKeysBetween, getBlockDepth, getDescendantIds, getDropZoneType, getSensorConfig, getSubtreeDepth, initFractionalOrder, nestedToFlat, reparentBlockIndex, reparentMultipleBlocks, triggerHaptic, useBlockHistory, useConfiguredSensors, useLayoutAnimation, useVirtualTree, weightedVerticalCollision };
+export { type AnimationConfig, type AutoExpandConfig, type BaseBlock, type BlockAction, type BlockAddEvent, type BlockDeleteEvent, type BlockIndex, type BlockMoveEvent, type BlockPosition, type BlockRendererProps, type BlockRenderers, type BlockStateContextValue, type BlockStateProviderProps, BlockTree, type BlockTreeCallbacks, type BlockTreeConfig, type BlockTreeCustomization, type BlockTreeProps, BlockTreeSSR, type BlockTreeSSRProps, type CanDragFn, type CanDropFn, type ContainerRendererProps, type DragEndEvent, type DragMoveEvent, DragOverlay, type DragOverlayProps$1 as DragOverlayProps, type DragStartEvent, DropZone, type DropZoneConfig, type DropZoneProps, type DropZoneType, type ExpandChangeEvent, type HoverChangeEvent, type IdGeneratorFn, type InternalRenderers, type MoveOperation, type NestedBlock, type OrderingStrategy, type RendererPropsFor, type SensorConfig, type SnapshotRectsRef, TreeRenderer, type TreeRendererProps, type TreeStateContextValue, type TreeStateProviderProps, type TreeValidationResult, type UseBlockHistoryOptions, type UseBlockHistoryResult, type UseLayoutAnimationOptions, type UseVirtualTreeOptions, type UseVirtualTreeResult, buildOrderedBlocks, cloneMap, cloneParentMap, closestCenterCollision, compareFractionalKeys, computeNormalizedIndex, createBlockState, createStickyCollision, createTreeState, debounce, deleteBlockAndDescendants, extractBlockId, extractUUID, flatToNested, generateId, generateInitialKeys, generateKeyBetween, generateNKeysBetween, getBlockDepth, getDescendantIds, getDropZoneType, getSensorConfig, getSubtreeDepth, initFractionalOrder, nestedToFlat, reparentBlockIndex, reparentMultipleBlocks, triggerHaptic, useBlockHistory, useConfiguredSensors, useLayoutAnimation, useVirtualTree, validateBlockTree, weightedVerticalCollision };

package/dist/index.d.ts

@@ -389,6 +389,81 @@ interface TreeStateProviderProps<T extends BaseBlock = BaseBlock> {
     blockMap: Map<string, T>;
 }
 
+/**
+ * Clone a Map
+ */
+declare function cloneMap<K, V>(map: Map<K, V>): Map<K, V>;
+/**
+ * Clone a parent map with arrays
+ */
+declare function cloneParentMap(map: Map<string | null, string[]>): Map<string | null, string[]>;
+/**
+ * Compute normalized index from flat block array.
+ *
+ * With `orderingStrategy: 'fractional'`, siblings are sorted by their `order`
+ * field (lexicographic). With `'integer'` (default), the input order is preserved.
+ */
+declare function computeNormalizedIndex<T extends BaseBlock>(blocks: T[], orderingStrategy?: OrderingStrategy): BlockIndex<T>;
+/**
+ * Build ordered flat array from BlockIndex.
+ *
+ * With `'integer'` ordering (default), assigns sequential `order: 0, 1, 2, …`.
+ * With `'fractional'` ordering, preserves existing `order` values — the moved
+ * block already has its new fractional key set by `reparentBlockIndex`.
+ */
+declare function buildOrderedBlocks<T extends BaseBlock>(index: BlockIndex<T>, containerTypes?: readonly string[], orderingStrategy?: OrderingStrategy): T[];
+/**
+ * Reparent a block based on drop zone ID.
+ *
+ * @param state - Current block index
+ * @param activeId - ID of the dragged block
+ * @param targetZone - Drop zone ID (e.g., "after-uuid", "before-uuid", "into-uuid")
+ * @param containerTypes - Block types that can have children
+ * @param orderingStrategy - Whether to assign a fractional key to the moved block
+ */
+declare function reparentBlockIndex<T extends BaseBlock>(state: BlockIndex<T>, activeId: UniqueIdentifier, targetZone: string, containerTypes?: readonly string[], orderingStrategy?: OrderingStrategy, maxDepth?: number): BlockIndex<T>;
+/**
+ * Compute the depth of a block by walking its parentId chain.
+ * Root-level blocks have depth 1.
+ */
+declare function getBlockDepth<T extends BaseBlock>(index: BlockIndex<T>, blockId: string): number;
+/**
+ * Compute the maximum depth of a subtree rooted at blockId (inclusive).
+ * A leaf block returns 1.
+ */
+declare function getSubtreeDepth<T extends BaseBlock>(index: BlockIndex<T>, blockId: string, visited?: Set<string>): number;
+/**
+ * Get all descendant IDs of a block
+ */
+declare function getDescendantIds<T extends BaseBlock>(state: BlockIndex<T>, parentId: string): Set<string>;
+/**
+ * Reparent multiple blocks to a target zone, preserving their relative order.
+ * The first block in `blockIds` is treated as the primary (anchor) block.
+ */
+declare function reparentMultipleBlocks<T extends BaseBlock>(state: BlockIndex<T>, blockIds: string[], targetZone: string, containerTypes?: readonly string[], orderingStrategy?: OrderingStrategy, maxDepth?: number): BlockIndex<T>;
+/**
+ * Result of validating a block tree
+ */
+interface TreeValidationResult {
+    valid: boolean;
+    issues: string[];
+}
+/**
+ * Validate a block tree index for structural integrity.
+ * Checks for cycles, orphans (parentId references non-existent block),
+ * and stale refs (byParent lists IDs not present in byId).
+ *
+ * Opt-in utility — not called automatically.
+ */
+declare function validateBlockTree<T extends BaseBlock>(index: BlockIndex<T>): TreeValidationResult;
+/**
+ * Delete a block and all its descendants
+ */
+declare function deleteBlockAndDescendants<T extends BaseBlock>(state: BlockIndex<T>, id: string): BlockIndex<T>;
+
+type SnapshotRectsRef = {
+    current: Map<UniqueIdentifier, DOMRect> | null;
+};
 /**
  * Custom collision detection that scores drop zones by distance to nearest edge.
  * Uses edge-distance scoring with a bottom bias for more natural drag behavior.
@@ -404,8 +479,11 @@ declare const weightedVerticalCollision: CollisionDetection;
  * between adjacent drop zones.
  *
  * @param threshold - Minimum score improvement required to switch zones (default: 15px)
+ * @param snapshotRef - Optional ref to snapshotted zone rects. When populated,
+ *   collision detection uses these frozen rects instead of live DOM measurements,
+ *   preventing layout-shift feedback loops from in-flow ghost previews.
  */
-declare function createStickyCollision(threshold?: number): CollisionDetection & {
+declare function createStickyCollision(threshold?: number, snapshotRef?: SnapshotRectsRef): CollisionDetection & {
     reset: () => void;
 };
 /**
@@ -521,7 +599,8 @@ interface TreeRendererProps<T extends BaseBlock> {
 /**
  * Recursive tree renderer with smart drop zones
  */
-declare function TreeRenderer<T extends BaseBlock>({ blocks, blocksByParent, parentId, activeId, expandedMap, renderers, containerTypes, onHover, onToggleExpand, depth, dropZoneClassName, dropZoneActiveClassName, indentClassName, rootClassName, canDrag, previewPosition, draggedBlock, focusedId, selectedIds, onBlockClick, animation, virtualVisibleIds, }: TreeRendererProps<T>): react_jsx_runtime.JSX.Element;
+declare function TreeRendererInner<T extends BaseBlock>({ blocks, blocksByParent, parentId, activeId, expandedMap, renderers, containerTypes, onHover, onToggleExpand, depth, dropZoneClassName, dropZoneActiveClassName, indentClassName, rootClassName, canDrag, previewPosition, draggedBlock, focusedId, selectedIds, onBlockClick, animation, virtualVisibleIds, }: TreeRendererProps<T>): react_jsx_runtime.JSX.Element;
+declare const TreeRenderer: typeof TreeRendererInner;
 
 interface DropZoneProps {
     id: string;
@@ -666,63 +745,6 @@ interface UseVirtualTreeResult {
  */
 declare function useVirtualTree({ containerRef, itemCount, itemHeight, overscan, }: UseVirtualTreeOptions): UseVirtualTreeResult;
 
-/**
- * Clone a Map
- */
-declare function cloneMap<K, V>(map: Map<K, V>): Map<K, V>;
-/**
- * Clone a parent map with arrays
- */
-declare function cloneParentMap(map: Map<string | null, string[]>): Map<string | null, string[]>;
-/**
- * Compute normalized index from flat block array.
- *
- * With `orderingStrategy: 'fractional'`, siblings are sorted by their `order`
- * field (lexicographic). With `'integer'` (default), the input order is preserved.
- */
-declare function computeNormalizedIndex<T extends BaseBlock>(blocks: T[], orderingStrategy?: OrderingStrategy): BlockIndex<T>;
-/**
- * Build ordered flat array from BlockIndex.
- *
- * With `'integer'` ordering (default), assigns sequential `order: 0, 1, 2, …`.
- * With `'fractional'` ordering, preserves existing `order` values — the moved
- * block already has its new fractional key set by `reparentBlockIndex`.
- */
-declare function buildOrderedBlocks<T extends BaseBlock>(index: BlockIndex<T>, containerTypes?: readonly string[], orderingStrategy?: OrderingStrategy): T[];
-/**
- * Reparent a block based on drop zone ID.
- *
- * @param state - Current block index
- * @param activeId - ID of the dragged block
- * @param targetZone - Drop zone ID (e.g., "after-uuid", "before-uuid", "into-uuid")
- * @param containerTypes - Block types that can have children
- * @param orderingStrategy - Whether to assign a fractional key to the moved block
- */
-declare function reparentBlockIndex<T extends BaseBlock>(state: BlockIndex<T>, activeId: UniqueIdentifier, targetZone: string, containerTypes?: readonly string[], orderingStrategy?: OrderingStrategy, maxDepth?: number): BlockIndex<T>;
-/**
- * Compute the depth of a block by walking its parentId chain.
- * Root-level blocks have depth 1.
- */
-declare function getBlockDepth<T extends BaseBlock>(index: BlockIndex<T>, blockId: string): number;
-/**
- * Compute the maximum depth of a subtree rooted at blockId (inclusive).
- * A leaf block returns 1.
- */
-declare function getSubtreeDepth<T extends BaseBlock>(index: BlockIndex<T>, blockId: string): number;
-/**
- * Get all descendant IDs of a block
- */
-declare function getDescendantIds<T extends BaseBlock>(state: BlockIndex<T>, parentId: string): Set<string>;
-/**
- * Reparent multiple blocks to a target zone, preserving their relative order.
- * The first block in `blockIds` is treated as the primary (anchor) block.
- */
-declare function reparentMultipleBlocks<T extends BaseBlock>(state: BlockIndex<T>, blockIds: string[], targetZone: string, containerTypes?: readonly string[], orderingStrategy?: OrderingStrategy, maxDepth?: number): BlockIndex<T>;
-/**
- * Delete a block and all its descendants
- */
-declare function deleteBlockAndDescendants<T extends BaseBlock>(state: BlockIndex<T>, id: string): BlockIndex<T>;
-
 /**
  * Extract UUID from a zone ID by removing the prefix (before-, after-, into-, end-)
  */
@@ -811,4 +833,4 @@ declare function initFractionalOrder<T extends {
     order: number | string;
 }>(blocks: T[]): T[];
 
-export { type AnimationConfig, type AutoExpandConfig, type BaseBlock, type BlockAction, type BlockAddEvent, type BlockDeleteEvent, type BlockIndex, type BlockMoveEvent, type BlockPosition, type BlockRendererProps, type BlockRenderers, type BlockStateContextValue, type BlockStateProviderProps, BlockTree, type BlockTreeCallbacks, type BlockTreeConfig, type BlockTreeCustomization, type BlockTreeProps, BlockTreeSSR, type BlockTreeSSRProps, type CanDragFn, type CanDropFn, type ContainerRendererProps, type DragEndEvent, type DragMoveEvent, DragOverlay, type DragOverlayProps$1 as DragOverlayProps, type DragStartEvent, DropZone, type DropZoneConfig, type DropZoneProps, type DropZoneType, type ExpandChangeEvent, type HoverChangeEvent, type IdGeneratorFn, type InternalRenderers, type MoveOperation, type NestedBlock, type OrderingStrategy, type RendererPropsFor, type SensorConfig, TreeRenderer, type TreeRendererProps, type TreeStateContextValue, type TreeStateProviderProps, type UseBlockHistoryOptions, type UseBlockHistoryResult, type UseLayoutAnimationOptions, type UseVirtualTreeOptions, type UseVirtualTreeResult, buildOrderedBlocks, cloneMap, cloneParentMap, closestCenterCollision, compareFractionalKeys, computeNormalizedIndex, createBlockState, createStickyCollision, createTreeState, debounce, deleteBlockAndDescendants, extractBlockId, extractUUID, flatToNested, generateId, generateInitialKeys, generateKeyBetween, generateNKeysBetween, getBlockDepth, getDescendantIds, getDropZoneType, getSensorConfig, getSubtreeDepth, initFractionalOrder, nestedToFlat, reparentBlockIndex, reparentMultipleBlocks, triggerHaptic, useBlockHistory, useConfiguredSensors, useLayoutAnimation, useVirtualTree, weightedVerticalCollision };
+export { type AnimationConfig, type AutoExpandConfig, type BaseBlock, type BlockAction, type BlockAddEvent, type BlockDeleteEvent, type BlockIndex, type BlockMoveEvent, type BlockPosition, type BlockRendererProps, type BlockRenderers, type BlockStateContextValue, type BlockStateProviderProps, BlockTree, type BlockTreeCallbacks, type BlockTreeConfig, type BlockTreeCustomization, type BlockTreeProps, BlockTreeSSR, type BlockTreeSSRProps, type CanDragFn, type CanDropFn, type ContainerRendererProps, type DragEndEvent, type DragMoveEvent, DragOverlay, type DragOverlayProps$1 as DragOverlayProps, type DragStartEvent, DropZone, type DropZoneConfig, type DropZoneProps, type DropZoneType, type ExpandChangeEvent, type HoverChangeEvent, type IdGeneratorFn, type InternalRenderers, type MoveOperation, type NestedBlock, type OrderingStrategy, type RendererPropsFor, type SensorConfig, type SnapshotRectsRef, TreeRenderer, type TreeRendererProps, type TreeStateContextValue, type TreeStateProviderProps, type TreeValidationResult, type UseBlockHistoryOptions, type UseBlockHistoryResult, type UseLayoutAnimationOptions, type UseVirtualTreeOptions, type UseVirtualTreeResult, buildOrderedBlocks, cloneMap, cloneParentMap, closestCenterCollision, compareFractionalKeys, computeNormalizedIndex, createBlockState, createStickyCollision, createTreeState, debounce, deleteBlockAndDescendants, extractBlockId, extractUUID, flatToNested, generateId, generateInitialKeys, generateKeyBetween, generateNKeysBetween, getBlockDepth, getDescendantIds, getDropZoneType, getSensorConfig, getSubtreeDepth, initFractionalOrder, nestedToFlat, reparentBlockIndex, reparentMultipleBlocks, triggerHaptic, useBlockHistory, useConfiguredSensors, useLayoutAnimation, useVirtualTree, validateBlockTree, weightedVerticalCollision };