dnd-block-tree 0.1.0 → 0.2.0

package/dist/index.js

@@ -15,11 +15,8 @@ function extractBlockId(zoneId) {
 }
 
 // src/core/collision.ts
-var weightedVerticalCollision = ({
-  droppableContainers,
-  collisionRect
-}) => {
-  if (!collisionRect) return [];
+function computeCollisionScores(droppableContainers, collisionRect) {
+  const pointerX = collisionRect.left + collisionRect.width / 2;
   const pointerY = collisionRect.top + collisionRect.height / 2;
   const candidates = droppableContainers.map((container) => {
     const rect = container.rect.current;
@@ -29,11 +26,19 @@ var weightedVerticalCollision = ({
     const edgeDistance = Math.min(distanceToTop, distanceToBottom);
     const isBelowCenter = pointerY > rect.top + rect.height / 2;
     const bias = isBelowCenter ? -5 : 0;
+    const isWithinX = pointerX >= rect.left && pointerX <= rect.right;
+    let horizontalScore = 0;
+    if (isWithinX) {
+      horizontalScore = -rect.left * 0.1;
+    } else {
+      const distanceToZone = pointerX < rect.left ? rect.left - pointerX : pointerX - rect.right;
+      horizontalScore = Math.min(distanceToZone, 50);
+    }
     return {
       id: container.id,
       data: {
         droppableContainer: container,
-        value: edgeDistance + bias
+        value: edgeDistance + bias + horizontalScore
       }
     };
   }).filter((c) => c !== null);
@@ -42,8 +47,44 @@ var weightedVerticalCollision = ({
     const bValue = b.data.value;
     return aValue - bValue;
   });
+  return candidates;
+}
+var weightedVerticalCollision = ({
+  droppableContainers,
+  collisionRect
+}) => {
+  if (!collisionRect) return [];
+  const candidates = computeCollisionScores(droppableContainers, collisionRect);
   return candidates.slice(0, 1);
 };
+function createStickyCollision(threshold = 15) {
+  let currentZoneId = null;
+  const detector = ({
+    droppableContainers,
+    collisionRect
+  }) => {
+    if (!collisionRect) return [];
+    const candidates = computeCollisionScores(droppableContainers, collisionRect);
+    if (candidates.length === 0) return [];
+    const bestCandidate = candidates[0];
+    const bestScore = bestCandidate.data.value;
+    if (currentZoneId !== null) {
+      const currentCandidate = candidates.find((c) => c.id === currentZoneId);
+      if (currentCandidate) {
+        const currentScore = currentCandidate.data.value;
+        if (currentScore - bestScore < threshold) {
+          return [currentCandidate];
+        }
+      }
+    }
+    currentZoneId = bestCandidate.id;
+    return [bestCandidate];
+  };
+  detector.reset = () => {
+    currentZoneId = null;
+  };
+  return detector;
+}
 var closestCenterCollision = ({
   droppableContainers,
   collisionRect
@@ -76,38 +117,57 @@ var closestCenterCollision = ({
 };
 var DEFAULT_ACTIVATION_DISTANCE = 8;
 function useConfiguredSensors(config = {}) {
-  const { activationDistance = DEFAULT_ACTIVATION_DISTANCE } = config;
+  const {
+    activationDistance = DEFAULT_ACTIVATION_DISTANCE,
+    activationDelay,
+    tolerance
+  } = config;
+  let activationConstraint;
+  if (activationDelay !== void 0) {
+    activationConstraint = {
+      delay: activationDelay,
+      tolerance: tolerance ?? 5
+    };
+  } else {
+    activationConstraint = {
+      distance: activationDistance
+    };
+  }
   return core.useSensors(
     core.useSensor(core.PointerSensor, {
-      activationConstraint: {
-        distance: activationDistance
-      }
+      activationConstraint
     }),
     core.useSensor(core.TouchSensor, {
-      activationConstraint: {
-        distance: activationDistance
-      }
+      activationConstraint
     }),
     core.useSensor(core.KeyboardSensor)
   );
 }
-function getSensorConfig(activationDistance = DEFAULT_ACTIVATION_DISTANCE) {
+function getSensorConfig(config = {}) {
+  const {
+    activationDistance = DEFAULT_ACTIVATION_DISTANCE,
+    activationDelay,
+    tolerance
+  } = config;
+  let activationConstraint;
+  if (activationDelay !== void 0) {
+    activationConstraint = {
+      delay: activationDelay,
+      tolerance: tolerance ?? 5
+    };
+  } else {
+    activationConstraint = {
+      distance: activationDistance
+    };
+  }
   return {
-    pointer: {
-      activationConstraint: {
-        distance: activationDistance
-      }
-    },
-    touch: {
-      activationConstraint: {
-        distance: activationDistance
-      }
-    }
+    pointer: { activationConstraint },
+    touch: { activationConstraint }
   };
 }
 
 // src/utils/helper.ts
-function extractUUID(id, pattern = "^(before|after|into)-") {
+function extractUUID(id, pattern = "^(before|after|into|end)-") {
   const regex = new RegExp(pattern);
   return id.replace(regex, "");
 }
@@ -147,8 +207,10 @@ function DropZoneComponent({
   react.useEffect(() => {
     if (isOver) handleInternalHover();
   }, [isOver, handleInternalHover]);
-  if (active?.id && extractUUID(id) === String(active.id)) return null;
-  if (activeId && extractUUID(id) === activeId) return null;
+  const zoneBlockId = extractUUID(id);
+  const isIntoZone = id.startsWith("into-");
+  if (isIntoZone && active?.id && zoneBlockId === String(active.id)) return null;
+  if (isIntoZone && activeId && zoneBlockId === activeId) return null;
   return /* @__PURE__ */ jsxRuntime.jsx(
     "div",
     {
@@ -163,10 +225,12 @@ function DropZoneComponent({
 var DropZone = react.memo(DropZoneComponent);
 function DraggableBlock({
   block,
-  children
+  children,
+  disabled
 }) {
   const { attributes, listeners, setNodeRef, isDragging } = core.useDraggable({
-    id: block.id
+    id: block.id,
+    disabled
   });
   return /* @__PURE__ */ jsxRuntime.jsx("div", { ref: setNodeRef, ...attributes, ...listeners, children: children({ isDragging }) });
 }
@@ -184,47 +248,49 @@ function TreeRenderer({
   dropZoneClassName,
   dropZoneActiveClassName,
   indentClassName = "ml-6 border-l border-gray-200 pl-4",
-  rootClassName = "flex flex-col gap-1"
+  rootClassName = "flex flex-col gap-1",
+  canDrag,
+  previewPosition,
+  draggedBlock
 }) {
   const items = blocksByParent.get(parentId) ?? [];
   const filteredBlocks = items.filter((block) => block.id !== activeId);
-  const firstVisibleBlockId = filteredBlocks[0]?.id;
+  const showGhostHere = previewPosition?.parentId === parentId && draggedBlock;
   const containerClass = depth === 0 ? rootClassName : indentClassName;
-  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: containerClass, children: filteredBlocks.map((block) => {
-    const isContainer = containerTypes.includes(block.type);
-    const isExpanded = expandedMap[block.id] !== false;
-    const Renderer = renderers[block.type];
-    if (!Renderer) {
-      console.warn(`No renderer found for block type: ${block.type}`);
-      return null;
-    }
-    return /* @__PURE__ */ jsxRuntime.jsxs(react.Fragment, { children: [
-      block.id === firstVisibleBlockId && /* @__PURE__ */ jsxRuntime.jsx(
-        DropZone,
-        {
-          id: `before-${block.id}`,
-          parentId: block.parentId,
-          onHover,
-          activeId,
-          className: dropZoneClassName,
-          activeClassName: dropZoneActiveClassName
-        }
-      ),
-      /* @__PURE__ */ jsxRuntime.jsx(DraggableBlock, { block, children: ({ isDragging }) => {
-        if (isContainer) {
-          const childContent = isExpanded ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
-            /* @__PURE__ */ jsxRuntime.jsx(
-              DropZone,
-              {
-                id: `into-${block.id}`,
-                parentId: block.id,
-                onHover,
-                activeId,
-                className: dropZoneClassName,
-                activeClassName: dropZoneActiveClassName
-              }
-            ),
-            /* @__PURE__ */ jsxRuntime.jsx(
+  return /* @__PURE__ */ jsxRuntime.jsxs("div", { className: containerClass, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      DropZone,
+      {
+        id: parentId ? `into-${parentId}` : "root-start",
+        parentId,
+        onHover,
+        activeId,
+        className: dropZoneClassName,
+        activeClassName: dropZoneActiveClassName
+      }
+    ),
+    filteredBlocks.map((block, index) => {
+      const isContainer = containerTypes.includes(block.type);
+      const isExpanded = expandedMap[block.id] !== false;
+      const Renderer = renderers[block.type];
+      const isDragDisabled = canDrag ? !canDrag(block) : false;
+      const ghostBeforeThis = showGhostHere && previewPosition.index === index;
+      const originalIndex = items.findIndex((b) => b.id === block.id);
+      const isLastInOriginal = originalIndex === items.length - 1;
+      if (!Renderer) {
+        console.warn(`No renderer found for block type: ${block.type}`);
+        return null;
+      }
+      const GhostRenderer = draggedBlock ? renderers[draggedBlock.type] : null;
+      return /* @__PURE__ */ jsxRuntime.jsxs(react.Fragment, { children: [
+        ghostBeforeThis && GhostRenderer && /* @__PURE__ */ jsxRuntime.jsx("div", { className: "opacity-50 pointer-events-none", children: GhostRenderer({
+          block: draggedBlock,
+          isDragging: true,
+          depth
+        }) }),
+        /* @__PURE__ */ jsxRuntime.jsx(DraggableBlock, { block, disabled: isDragDisabled, children: ({ isDragging }) => {
+          if (isContainer) {
+            const childContent = isExpanded ? /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: /* @__PURE__ */ jsxRuntime.jsx(
               TreeRenderer,
               {
                 blocks,
@@ -240,38 +306,60 @@ function TreeRenderer({
                 dropZoneClassName,
                 dropZoneActiveClassName,
                 indentClassName,
-                rootClassName
+                rootClassName,
+                canDrag,
+                previewPosition,
+                draggedBlock
               }
-            )
-          ] }) : null;
+            ) }) : null;
+            return Renderer({
+              block,
+              children: childContent,
+              isDragging,
+              depth,
+              isExpanded,
+              onToggleExpand: () => onToggleExpand(block.id)
+            });
+          }
           return Renderer({
             block,
-            children: childContent,
             isDragging,
-            depth,
-            isExpanded,
-            onToggleExpand: () => onToggleExpand(block.id)
+            depth
           });
-        }
-        return Renderer({
-          block,
-          isDragging,
-          depth
-        });
-      } }),
-      /* @__PURE__ */ jsxRuntime.jsx(
-        DropZone,
-        {
-          id: `after-${block.id}`,
-          parentId: block.parentId,
-          onHover,
-          activeId,
-          className: dropZoneClassName,
-          activeClassName: dropZoneActiveClassName
-        }
-      )
-    ] }, block.id);
-  }) });
+        } }),
+        !isLastInOriginal && /* @__PURE__ */ jsxRuntime.jsx(
+          DropZone,
+          {
+            id: `after-${block.id}`,
+            parentId: block.parentId,
+            onHover,
+            activeId,
+            className: dropZoneClassName,
+            activeClassName: dropZoneActiveClassName
+          }
+        )
+      ] }, block.id);
+    }),
+    showGhostHere && previewPosition.index >= filteredBlocks.length && draggedBlock && (() => {
+      const GhostRenderer = renderers[draggedBlock.type];
+      return GhostRenderer ? /* @__PURE__ */ jsxRuntime.jsx("div", { className: "opacity-50 pointer-events-none", children: GhostRenderer({
+        block: draggedBlock,
+        isDragging: true,
+        depth
+      }) }) : null;
+    })(),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      DropZone,
+      {
+        id: parentId ? `end-${parentId}` : "root-end",
+        parentId,
+        onHover,
+        activeId,
+        className: dropZoneClassName,
+        activeClassName: dropZoneActiveClassName
+      }
+    )
+  ] });
 }
 function DragOverlay({
   activeBlock,
@@ -331,12 +419,15 @@ function reparentBlockIndex(state, activeId, targetZone, containerTypes = []) {
   const byParent = cloneParentMap(state.byParent);
   const dragged = byId.get(String(activeId));
   if (!dragged) return state;
+  const isRootStart = targetZone === "root-start";
+  const isRootEnd = targetZone === "root-end";
+  const isEnd = targetZone.startsWith("end-") || isRootEnd;
   const zoneTargetId = extractUUID(targetZone);
   const isAfter = targetZone.startsWith("after-");
-  const isInto = targetZone.startsWith("into-");
+  const isInto = targetZone.startsWith("into-") || isRootStart;
   const target = byId.get(zoneTargetId);
   const oldParentId = dragged.parentId ?? null;
-  const newParentId = isInto ? zoneTargetId : target?.parentId ?? null;
+  const newParentId = isRootStart || isRootEnd ? null : isInto || isEnd ? zoneTargetId : target?.parentId ?? null;
   if (containerTypes.includes(dragged.type) && newParentId !== null) {
     const newParent = byId.get(newParentId);
     if (newParent && !containerTypes.includes(newParent.type)) {
@@ -348,8 +439,12 @@ function reparentBlockIndex(state, activeId, targetZone, containerTypes = []) {
   const filtered = oldList.filter((id) => id !== dragged.id);
   byParent.set(oldParentId, filtered);
   const newList = [...byParent.get(newParentId) ?? []];
-  let insertIndex = newList.length;
-  if (!isInto) {
+  let insertIndex;
+  if (isInto) {
+    insertIndex = 0;
+  } else if (isEnd) {
+    insertIndex = newList.length;
+  } else {
     const idx = newList.indexOf(zoneTargetId);
     insertIndex = idx === -1 ? newList.length : isAfter ? idx + 1 : idx;
   }
@@ -389,6 +484,30 @@ function deleteBlockAndDescendants(state, id) {
   }
   return { byId, byParent };
 }
+function getBlockPosition(blocks, blockId) {
+  const block = blocks.find((b) => b.id === blockId);
+  if (!block) return { parentId: null, index: 0 };
+  const siblings = blocks.filter((b) => b.parentId === block.parentId);
+  const index = siblings.findIndex((b) => b.id === blockId);
+  return { parentId: block.parentId, index };
+}
+function computeInitialExpanded(blocks, containerTypes, initialExpanded) {
+  if (initialExpanded === "none") {
+    return {};
+  }
+  const expandedMap = {};
+  const containers = blocks.filter((b) => containerTypes.includes(b.type));
+  if (initialExpanded === "all" || initialExpanded === void 0) {
+    for (const container of containers) {
+      expandedMap[container.id] = true;
+    }
+  } else if (Array.isArray(initialExpanded)) {
+    for (const id of initialExpanded) {
+      expandedMap[id] = true;
+    }
+  }
+  return expandedMap;
+}
 function BlockTree({
   blocks,
   renderers,
@@ -400,17 +519,45 @@ function BlockTree({
   className = "flex flex-col gap-1",
   dropZoneClassName,
   dropZoneActiveClassName,
-  indentClassName
+  indentClassName,
+  showDropPreview = true,
+  // Callbacks
+  onDragStart,
+  onDragMove,
+  onDragEnd,
+  onDragCancel,
+  onBlockMove,
+  onExpandChange,
+  onHoverChange,
+  // Customization
+  canDrag,
+  canDrop,
+  collisionDetection,
+  sensors: sensorConfig,
+  initialExpanded
 }) {
-  const sensors = useConfiguredSensors({ activationDistance });
+  const sensors = useConfiguredSensors({
+    activationDistance: sensorConfig?.activationDistance ?? activationDistance,
+    activationDelay: sensorConfig?.activationDelay,
+    tolerance: sensorConfig?.tolerance
+  });
+  const initialExpandedMap = react.useMemo(
+    () => computeInitialExpanded(blocks, containerTypes, initialExpanded),
+    // Only compute on mount
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  );
   const stateRef = react.useRef({
     activeId: null,
     hoverZone: null,
-    expandedMap: {},
-    virtualState: null
+    expandedMap: initialExpandedMap,
+    virtualState: null,
+    isDragging: false
   });
   const initialBlocksRef = react.useRef([]);
   const cachedReorderRef = react.useRef(null);
+  const fromPositionRef = react.useRef(null);
+  const stickyCollisionRef = react.useRef(createStickyCollision(20));
   const [, forceRender] = react.useReducer((x) => x + 1, 0);
   const debouncedSetVirtual = react.useRef(
     debounce((newBlocks) => {
@@ -422,72 +569,218 @@ function BlockTree({
       forceRender();
     }, previewDebounce)
   ).current;
-  const effectiveIndex = stateRef.current.virtualState ?? computeNormalizedIndex(blocks);
+  const debouncedDragMove = react.useRef(
+    debounce((event) => {
+      onDragMove?.(event);
+    }, 50)
+  ).current;
+  const originalIndex = computeNormalizedIndex(blocks);
   const blocksByParent = /* @__PURE__ */ new Map();
-  for (const [parentId, ids] of effectiveIndex.byParent.entries()) {
+  for (const [parentId, ids] of originalIndex.byParent.entries()) {
     blocksByParent.set(
       parentId,
-      ids.map((id) => effectiveIndex.byId.get(id)).filter(Boolean)
+      ids.map((id) => originalIndex.byId.get(id)).filter(Boolean)
     );
   }
-  const activeBlock = stateRef.current.activeId ? effectiveIndex.byId.get(stateRef.current.activeId) ?? null : null;
+  const previewPosition = react.useMemo(() => {
+    if (!showDropPreview || !stateRef.current.virtualState || !stateRef.current.activeId) {
+      return null;
+    }
+    const virtualIndex = stateRef.current.virtualState;
+    const activeId = stateRef.current.activeId;
+    const block = virtualIndex.byId.get(activeId);
+    if (!block) return null;
+    const parentId = block.parentId ?? null;
+    const siblings = virtualIndex.byParent.get(parentId) ?? [];
+    const index = siblings.indexOf(activeId);
+    return { parentId, index };
+  }, [showDropPreview, stateRef.current.virtualState, stateRef.current.activeId]);
+  const activeBlock = stateRef.current.activeId ? originalIndex.byId.get(stateRef.current.activeId) ?? null : null;
+  const draggedBlock = activeBlock;
   const handleDragStart = react.useCallback((event) => {
     const id = String(event.active.id);
+    const block = blocks.find((b) => b.id === id);
+    if (!block) return;
+    if (canDrag && !canDrag(block)) {
+      return;
+    }
+    const dragEvent = {
+      block,
+      blockId: id
+    };
+    const result = onDragStart?.(dragEvent);
+    if (result === false) {
+      return;
+    }
+    fromPositionRef.current = getBlockPosition(blocks, id);
+    stickyCollisionRef.current.reset();
     stateRef.current.activeId = id;
+    stateRef.current.isDragging = true;
     initialBlocksRef.current = [...blocks];
     cachedReorderRef.current = null;
     forceRender();
-  }, [blocks]);
+  }, [blocks, canDrag, onDragStart]);
+  const handleDragMove = react.useCallback((event) => {
+    if (!onDragMove) return;
+    const id = stateRef.current.activeId;
+    if (!id) return;
+    const block = blocks.find((b) => b.id === id);
+    if (!block) return;
+    const moveEvent = {
+      block,
+      blockId: id,
+      overZone: stateRef.current.hoverZone,
+      coordinates: {
+        x: event.delta.x,
+        y: event.delta.y
+      }
+    };
+    debouncedDragMove(moveEvent);
+  }, [blocks, onDragMove, debouncedDragMove]);
   const handleDragOver = react.useCallback((event) => {
     if (!event.over) return;
     const targetZone = String(event.over.id);
     const activeId = stateRef.current.activeId;
     if (!activeId) return;
+    const activeBlock2 = blocks.find((b) => b.id === activeId);
+    const targetBlockId = extractBlockId(targetZone);
+    const targetBlock = blocks.find((b) => b.id === targetBlockId) ?? null;
+    if (canDrop && activeBlock2 && !canDrop(activeBlock2, targetZone, targetBlock)) {
+      return;
+    }
+    if (stateRef.current.hoverZone !== targetZone) {
+      const zoneType = getDropZoneType(targetZone);
+      const hoverEvent = {
+        zoneId: targetZone,
+        zoneType,
+        targetBlock
+      };
+      onHoverChange?.(hoverEvent);
+    }
     stateRef.current.hoverZone = targetZone;
     const baseIndex = computeNormalizedIndex(initialBlocksRef.current);
     const updatedIndex = reparentBlockIndex(baseIndex, activeId, targetZone, containerTypes);
     const orderedBlocks = buildOrderedBlocks(updatedIndex, containerTypes);
     cachedReorderRef.current = { targetId: targetZone, reorderedBlocks: orderedBlocks };
-    debouncedSetVirtual(orderedBlocks);
-  }, [containerTypes, debouncedSetVirtual]);
+    if (showDropPreview) {
+      debouncedSetVirtual(orderedBlocks);
+    }
+  }, [blocks, containerTypes, debouncedSetVirtual, canDrop, onHoverChange, showDropPreview]);
   const handleDragEnd = react.useCallback((_event) => {
     debouncedSetVirtual.cancel();
+    debouncedDragMove.cancel();
     const cached = cachedReorderRef.current;
+    const activeId = stateRef.current.activeId;
+    const activeBlockData = activeId ? blocks.find((b) => b.id === activeId) : null;
+    if (activeBlockData) {
+      const endEvent = {
+        block: activeBlockData,
+        blockId: activeId,
+        targetZone: cached?.targetId ?? null,
+        cancelled: false
+      };
+      onDragEnd?.(endEvent);
+    }
+    if (cached && activeBlockData && fromPositionRef.current) {
+      const toPosition = getBlockPosition(cached.reorderedBlocks, activeBlockData.id);
+      const moveEvent = {
+        block: activeBlockData,
+        from: fromPositionRef.current,
+        to: toPosition,
+        blocks: cached.reorderedBlocks
+      };
+      onBlockMove?.(moveEvent);
+    }
     stateRef.current.activeId = null;
     stateRef.current.hoverZone = null;
     stateRef.current.virtualState = null;
+    stateRef.current.isDragging = false;
     cachedReorderRef.current = null;
     initialBlocksRef.current = [];
+    fromPositionRef.current = null;
     if (cached && onChange) {
       onChange(cached.reorderedBlocks);
     }
     forceRender();
-  }, [debouncedSetVirtual, onChange]);
+  }, [blocks, debouncedSetVirtual, debouncedDragMove, onChange, onDragEnd, onBlockMove]);
+  const handleDragCancel = react.useCallback((_event) => {
+    debouncedSetVirtual.cancel();
+    debouncedDragMove.cancel();
+    const activeId = stateRef.current.activeId;
+    const activeBlockData = activeId ? blocks.find((b) => b.id === activeId) : null;
+    if (activeBlockData) {
+      const cancelEvent = {
+        block: activeBlockData,
+        blockId: activeId,
+        targetZone: null,
+        cancelled: true
+      };
+      onDragCancel?.(cancelEvent);
+      onDragEnd?.(cancelEvent);
+    }
+    stateRef.current.activeId = null;
+    stateRef.current.hoverZone = null;
+    stateRef.current.virtualState = null;
+    stateRef.current.isDragging = false;
+    cachedReorderRef.current = null;
+    initialBlocksRef.current = [];
+    fromPositionRef.current = null;
+    forceRender();
+  }, [blocks, debouncedSetVirtual, debouncedDragMove, onDragCancel, onDragEnd]);
   const handleHover = react.useCallback((zoneId, _parentId) => {
     const activeId = stateRef.current.activeId;
     if (!activeId) return;
+    const activeBlockData = blocks.find((b) => b.id === activeId);
+    const targetBlockId = extractBlockId(zoneId);
+    const targetBlock = blocks.find((b) => b.id === targetBlockId) ?? null;
+    if (canDrop && activeBlockData && !canDrop(activeBlockData, zoneId, targetBlock)) {
+      return;
+    }
+    if (stateRef.current.hoverZone !== zoneId) {
+      const zoneType = getDropZoneType(zoneId);
+      const hoverEvent = {
+        zoneId,
+        zoneType,
+        targetBlock
+      };
+      onHoverChange?.(hoverEvent);
+    }
     stateRef.current.hoverZone = zoneId;
     const baseIndex = computeNormalizedIndex(initialBlocksRef.current);
     const updatedIndex = reparentBlockIndex(baseIndex, activeId, zoneId, containerTypes);
     const orderedBlocks = buildOrderedBlocks(updatedIndex, containerTypes);
     cachedReorderRef.current = { targetId: zoneId, reorderedBlocks: orderedBlocks };
-    debouncedSetVirtual(orderedBlocks);
-  }, [containerTypes, debouncedSetVirtual]);
+    if (showDropPreview) {
+      debouncedSetVirtual(orderedBlocks);
+    }
+  }, [blocks, containerTypes, debouncedSetVirtual, canDrop, onHoverChange, showDropPreview]);
   const handleToggleExpand = react.useCallback((id) => {
+    const newExpanded = stateRef.current.expandedMap[id] === false;
     stateRef.current.expandedMap = {
       ...stateRef.current.expandedMap,
-      [id]: stateRef.current.expandedMap[id] === false
+      [id]: newExpanded
     };
+    const block = blocks.find((b) => b.id === id);
+    if (block && onExpandChange) {
+      const expandEvent = {
+        block,
+        blockId: id,
+        expanded: newExpanded
+      };
+      onExpandChange(expandEvent);
+    }
     forceRender();
-  }, []);
+  }, [blocks, onExpandChange]);
   return /* @__PURE__ */ jsxRuntime.jsxs(
     core.DndContext,
     {
       sensors,
-      collisionDetection: weightedVerticalCollision,
+      collisionDetection: collisionDetection ?? stickyCollisionRef.current,
       onDragStart: handleDragStart,
+      onDragMove: handleDragMove,
       onDragOver: handleDragOver,
       onDragEnd: handleDragEnd,
+      onDragCancel: handleDragCancel,
       children: [
         /* @__PURE__ */ jsxRuntime.jsx("div", { className, children: /* @__PURE__ */ jsxRuntime.jsx(
           TreeRenderer,
@@ -504,7 +797,10 @@ function BlockTree({
             dropZoneClassName,
             dropZoneActiveClassName,
             indentClassName,
-            rootClassName: className
+            rootClassName: className,
+            canDrag,
+            previewPosition,
+            draggedBlock
           }
         ) }),
         /* @__PURE__ */ jsxRuntime.jsx(DragOverlay, { activeBlock, children: dragOverlay })
@@ -577,7 +873,6 @@ function createBlockState() {
       reducerWithContainerTypes,
       computeNormalizedIndex(initialBlocks)
     );
-    const [lastCreatedItem, setLastCreatedItem] = react.useState(null);
     const blocks = react.useMemo(() => {
       const result = [];
       const walk = (parentId) => {
@@ -626,7 +921,6 @@ function createBlockState() {
           order: 0
         };
         dispatch({ type: "ADD_ITEM", payload: newItem });
-        setLastCreatedItem(newItem);
         return newItem;
       },
       []
@@ -649,7 +943,6 @@ function createBlockState() {
           type: "INSERT_ITEM",
           payload: { item: newItem, parentId, index: insertIndex }
         });
-        setLastCreatedItem(newItem);
         return newItem;
       },
       [state]
@@ -855,6 +1148,7 @@ exports.cloneParentMap = cloneParentMap;
 exports.closestCenterCollision = closestCenterCollision;
 exports.computeNormalizedIndex = computeNormalizedIndex;
 exports.createBlockState = createBlockState;
+exports.createStickyCollision = createStickyCollision;
 exports.createTreeState = createTreeState;
 exports.debounce = debounce;
 exports.deleteBlockAndDescendants = deleteBlockAndDescendants;