@headless-tree/core 1.6.1 → 1.6.3

package/dist/index.mjs

@@ -81,6 +81,7 @@ var poll = (fn, interval = 100, timeout = 1e3) => new Promise((resolve) => {
   }, interval);
   clear = setTimeout(() => {
     clearInterval(i);
+    resolve();
   }, timeout);
 });
 
@@ -170,12 +171,16 @@ var treeFeature = {
     },
     updateDomFocus: ({ tree }) => {
       setTimeout(() => __async(null, null, function* () {
-        var _a, _b;
+        var _a, _b, _c, _d, _e;
         const focusedItem = tree.getFocusedItem();
         (_b = (_a = tree.getConfig()).scrollToItem) == null ? void 0 : _b.call(_a, focusedItem);
-        yield poll(() => focusedItem.getElement() !== null, 20);
+        yield poll(() => focusedItem.getElement() !== null, 20, 500);
         const focusedElement = focusedItem.getElement();
-        if (!focusedElement) return;
+        if (!focusedElement) {
+          (_c = tree.getItems()[0]) == null ? void 0 : _c.setFocused();
+          (_e = (_d = tree.getItems()[0]) == null ? void 0 : _d.getElement()) == null ? void 0 : _e.focus();
+          return;
+        }
         focusedElement.focus();
       }));
     },
@@ -976,6 +981,7 @@ var checkboxesFeature = {
 };
 
 // src/features/hotkeys-core/feature.ts
+var resolveKeyCode = (e) => e.code !== "" && e.code !== "Unidentified" ? e.code : e.key;
 var specialKeys = {
   // TODO:breaking deprecate auto-lowercase
   letter: /^Key[A-Z]$/,
@@ -1024,9 +1030,10 @@ var hotkeysCoreFeature = {
       if (e.target instanceof HTMLInputElement && ignoreHotkeysOnInputs) {
         return;
       }
+      const resolvedCode = resolveKeyCode(e);
       (_b = (_a = data.current).pressedKeys) != null ? _b : _a.pressedKeys = /* @__PURE__ */ new Set();
-      const newMatch = !data.current.pressedKeys.has(e.code);
-      data.current.pressedKeys.add(e.code);
+      const newMatch = !data.current.pressedKeys.has(resolvedCode);
+      data.current.pressedKeys.add(resolvedCode);
       const hotkeyName = findHotkeyMatch(
         data.current.pressedKeys,
         tree,
@@ -1034,7 +1041,7 @@ var hotkeysCoreFeature = {
         hotkeys
       );
       if (e.target instanceof HTMLInputElement) {
-        data.current.pressedKeys.delete(e.code);
+        data.current.pressedKeys.delete(resolvedCode);
       }
       if (!hotkeyName) return;
       const hotkeyConfig = __spreadValues(__spreadValues({}, tree.getHotkeyPresets()[hotkeyName]), hotkeys == null ? void 0 : hotkeys[hotkeyName]);
@@ -1049,7 +1056,7 @@ var hotkeysCoreFeature = {
     const keyup = (e) => {
       var _a, _b;
       (_b = (_a = data.current).pressedKeys) != null ? _b : _a.pressedKeys = /* @__PURE__ */ new Set();
-      data.current.pressedKeys.delete(e.code);
+      data.current.pressedKeys.delete(resolveKeyCode(e));
     };
     const reset = () => {
       data.current.pressedKeys = /* @__PURE__ */ new Set();
@@ -1230,15 +1237,17 @@ var asyncDataLoaderFeature = {
       }
       yield loadChildrenIds(tree, itemId);
     }),
-    updateCachedChildrenIds: ({ tree, itemId }, childrenIds) => {
-      const dataRef = tree.getDataRef();
-      dataRef.current.childrenIds[itemId] = childrenIds;
-      tree.rebuildTree();
+    updateCachedChildrenIds: ({ tree, itemId }, childrenIds, skipUpdateTree) => {
+      getDataRef(tree).current.childrenIds[itemId] = childrenIds;
+      if (!skipUpdateTree) {
+        tree.rebuildTree();
+      }
     },
-    updateCachedData: ({ tree, itemId }, data) => {
-      const dataRef = tree.getDataRef();
-      dataRef.current.itemData[itemId] = data;
-      tree.rebuildTree();
+    updateCachedData: ({ tree, itemId }, data, skipUpdateTree) => {
+      getDataRef(tree).current.itemData[itemId] = data;
+      if (!skipUpdateTree) {
+        tree.rebuildTree();
+      }
     },
     hasLoadedData: ({ tree, itemId }) => {
       const dataRef = tree.getDataRef();
@@ -1405,15 +1414,16 @@ var getReparentTarget = (item, reparentLevel, draggedItems) => {
     dragLineLevel: reparentLevel
   };
 };
-var getDragTarget = (e, item, tree, canReorder = tree.getConfig().canReorder) => {
+var getDragTarget = (e, item, tree, hasDataTransferPayload, canReorder = tree.getConfig().canReorder) => {
   var _a;
+  const dataTransfer = hasDataTransferPayload ? e.dataTransfer : null;
   const draggedItems = (_a = tree.getState().dnd) == null ? void 0 : _a.draggedItems;
   const itemMeta = item.getItemMeta();
   const parent = item.getParent();
   const itemTarget = { item };
   const parentTarget = parent ? { item: parent } : null;
-  const canBecomeSibling = parentTarget && canDrop(e.dataTransfer, parentTarget, tree);
-  const canMakeChild = canDrop(e.dataTransfer, itemTarget, tree);
+  const canBecomeSibling = parentTarget && canDrop(dataTransfer, parentTarget, tree);
+  const canMakeChild = canDrop(dataTransfer, itemTarget, tree);
   const placement = getTargetPlacement(e, item, tree, canMakeChild);
   if (!canReorder && parent && canBecomeSibling && placement.type !== 2 /* MakeChild */) {
     if (draggedItems == null ? void 0 : draggedItems.some((item2) => item2.isDescendentOf(parent.getId()))) {
@@ -1422,7 +1432,7 @@ var getDragTarget = (e, item, tree, canReorder = tree.getConfig().canReorder) =>
     return parentTarget;
   }
   if (!canReorder && parent && !canBecomeSibling) {
-    return getDragTarget(e, parent, tree, false);
+    return getDragTarget(e, parent, tree, hasDataTransferPayload, false);
   }
   if (!parent) {
     return itemTarget;
@@ -1431,7 +1441,7 @@ var getDragTarget = (e, item, tree, canReorder = tree.getConfig().canReorder) =>
     return itemTarget;
   }
   if (!canBecomeSibling) {
-    return getDragTarget(e, parent, tree, false);
+    return getDragTarget(e, parent, tree, hasDataTransferPayload, false);
   }
   if (placement.type === 3 /* Reparent */) {
     return getReparentTarget(item, placement.reparentLevel, draggedItems);
@@ -1475,7 +1485,8 @@ var dragAndDropFeature = {
     canDragForeignDragObjectOver: defaultConfig.canDropForeignDragObject !== defaultCanDropForeignDragObject ? (dataTransfer) => dataTransfer.effectAllowed !== "none" : () => false,
     setDndState: makeStateUpdater("dnd", tree),
     canReorder: true,
-    openOnDropDelay: 800
+    openOnDropDelay: 800,
+    draggedItemOverwritesSelection: true
   }, defaultConfig),
   stateHandlerNames: {
     dnd: "setDndState"
@@ -1568,36 +1579,8 @@ var dragAndDropFeature = {
     }
   },
   itemInstance: {
-    getProps: ({ tree, item, prev }) => __spreadProps(__spreadValues({}, prev == null ? void 0 : prev()), {
-      draggable: true,
+    getProps: ({ tree, item, prev }) => __spreadProps(__spreadValues(__spreadValues({}, prev == null ? void 0 : prev()), tree.getConfig().seperateDragHandle ? {} : item.getDragHandleProps()), {
       onDragEnter: (e) => e.preventDefault(),
-      onDragStart: (e) => {
-        var _a, _b, _c, _d;
-        const selectedItems = tree.getSelectedItems ? tree.getSelectedItems() : [tree.getFocusedItem()];
-        const items = selectedItems.includes(item) ? selectedItems : [item];
-        const config = tree.getConfig();
-        if (!selectedItems.includes(item)) {
-          (_a = tree.setSelectedItems) == null ? void 0 : _a.call(tree, [item.getItemMeta().itemId]);
-        }
-        if (!((_c = (_b = config.canDrag) == null ? void 0 : _b.call(config, items)) != null ? _c : true)) {
-          e.preventDefault();
-          return;
-        }
-        if (config.setDragImage) {
-          const { imgElement, xOffset, yOffset } = config.setDragImage(items);
-          (_d = e.dataTransfer) == null ? void 0 : _d.setDragImage(imgElement, xOffset != null ? xOffset : 0, yOffset != null ? yOffset : 0);
-        }
-        if (config.createForeignDragObject && e.dataTransfer) {
-          const { format, data, dropEffect, effectAllowed } = config.createForeignDragObject(items);
-          e.dataTransfer.setData(format, data);
-          if (dropEffect) e.dataTransfer.dropEffect = dropEffect;
-          if (effectAllowed) e.dataTransfer.effectAllowed = effectAllowed;
-        }
-        tree.applySubStateUpdate("dnd", {
-          draggedItems: items,
-          draggingOverItem: tree.getFocusedItem()
-        });
-      },
       onDragOver: (e) => {
         var _a, _b, _c;
         e.stopPropagation();
@@ -1613,12 +1596,12 @@ var dragAndDropFeature = {
         dataRef.current.lastDragCode = nextDragCode;
         dataRef.current.lastDragEnter = Date.now();
         handleAutoOpenFolder(dataRef, tree, item, placement);
-        const target = getDragTarget(e, item, tree);
+        const target = getDragTarget(e, item, tree, false);
         if (!((_a = tree.getState().dnd) == null ? void 0 : _a.draggedItems) && (!e.dataTransfer || !((_c = (_b = tree.getConfig()).canDragForeignDragObjectOver) == null ? void 0 : _c.call(_b, e.dataTransfer, target)))) {
           dataRef.current.lastAllowDrop = false;
           return;
         }
-        if (!canDrop(e.dataTransfer, target, tree)) {
+        if (!canDrop(null, target, tree)) {
           dataRef.current.lastAllowDrop = false;
           return;
         }
@@ -1641,24 +1624,11 @@ var dragAndDropFeature = {
           }));
         }, 100);
       },
-      onDragEnd: (e) => {
-        var _a, _b;
-        const { onCompleteForeignDrop, canDragForeignDragObjectOver } = tree.getConfig();
-        const draggedItems = (_a = tree.getState().dnd) == null ? void 0 : _a.draggedItems;
-        if (((_b = e.dataTransfer) == null ? void 0 : _b.dropEffect) === "none" || !draggedItems) {
-          return;
-        }
-        const target = getDragTarget(e, item, tree);
-        if (canDragForeignDragObjectOver && e.dataTransfer && !canDragForeignDragObjectOver(e.dataTransfer, target)) {
-          return;
-        }
-        onCompleteForeignDrop == null ? void 0 : onCompleteForeignDrop(draggedItems);
-      },
       onDrop: (e) => __async(null, null, function* () {
         var _a, _b, _c;
         e.stopPropagation();
         const dataRef = tree.getDataRef();
-        const target = getDragTarget(e, item, tree);
+        const target = getDragTarget(e, item, tree, true);
         const draggedItems = (_a = tree.getState().dnd) == null ? void 0 : _a.draggedItems;
         const isValidDrop = canDrop(e.dataTransfer, target, tree);
         tree.applySubStateUpdate("dnd", {
@@ -1674,11 +1644,59 @@ var dragAndDropFeature = {
         dataRef.current.lastDragCode = void 0;
         if (draggedItems) {
           yield (_b = config.onDrop) == null ? void 0 : _b.call(config, draggedItems, target);
+          draggedItems[0].setFocused();
         } else if (e.dataTransfer) {
           yield (_c = config.onDropForeignDragObject) == null ? void 0 : _c.call(config, e.dataTransfer, target);
         }
+        tree.applySubStateUpdate("dnd", null);
+        tree.updateDomFocus();
       })
     }),
+    getDragHandleProps: ({ tree, item, prev }) => __spreadProps(__spreadValues({}, prev == null ? void 0 : prev()), {
+      draggable: true,
+      onDragStart: (e) => {
+        var _a, _b, _c, _d;
+        const { draggedItemOverwritesSelection } = tree.getConfig();
+        const selectedItems = tree.getSelectedItems ? tree.getSelectedItems() : [tree.getFocusedItem()];
+        const overwriteSelection = !selectedItems.includes(item) && draggedItemOverwritesSelection;
+        const items = overwriteSelection ? [item] : selectedItems;
+        const config = tree.getConfig();
+        if (overwriteSelection) {
+          (_a = tree.setSelectedItems) == null ? void 0 : _a.call(tree, [item.getItemMeta().itemId]);
+        }
+        if (!((_c = (_b = config.canDrag) == null ? void 0 : _b.call(config, items)) != null ? _c : true)) {
+          e.preventDefault();
+          return;
+        }
+        if (config.setDragImage) {
+          const { imgElement, xOffset, yOffset } = config.setDragImage(items);
+          (_d = e.dataTransfer) == null ? void 0 : _d.setDragImage(imgElement, xOffset != null ? xOffset : 0, yOffset != null ? yOffset : 0);
+        }
+        if (config.createForeignDragObject && e.dataTransfer) {
+          const { format, data, dropEffect, effectAllowed } = config.createForeignDragObject(items);
+          e.dataTransfer.setData(format, data);
+          if (dropEffect) e.dataTransfer.dropEffect = dropEffect;
+          if (effectAllowed) e.dataTransfer.effectAllowed = effectAllowed;
+        }
+        tree.applySubStateUpdate("dnd", {
+          draggedItems: items,
+          draggingOverItem: tree.getFocusedItem()
+        });
+      },
+      onDragEnd: (e) => {
+        var _a, _b;
+        const { onCompleteForeignDrop, canDragForeignDragObjectOver } = tree.getConfig();
+        const draggedItems = (_a = tree.getState().dnd) == null ? void 0 : _a.draggedItems;
+        if (((_b = e.dataTransfer) == null ? void 0 : _b.dropEffect) === "none" || !draggedItems) {
+          return;
+        }
+        const target = getDragTarget(e, item, tree, false);
+        if (canDragForeignDragObjectOver && e.dataTransfer && !canDragForeignDragObjectOver(e.dataTransfer, target)) {
+          return;
+        }
+        onCompleteForeignDrop == null ? void 0 : onCompleteForeignDrop(draggedItems);
+      }
+    }),
     isDragTarget: ({ tree, item }) => {
       const target = tree.getDragTarget();
       return target ? target.item.getId() === item.getId() : false;
@@ -1902,6 +1920,7 @@ var keyboardDragAndDropFeature = {
         } else if (dataTransfer) {
           yield (_d = config.onDropForeignDragObject) == null ? void 0 : _d.call(config, dataTransfer, target);
         }
+        tree.updateDomFocus();
         tree.applySubStateUpdate(
           "assistiveDndState",
           3 /* Completed */
@@ -2252,6 +2271,14 @@ var propMemoizationFeature = {
       (_e = (_d = dataRef.current.memo).item) != null ? _e : _d.item = {};
       return memoize(props, dataRef.current.memo.item);
     },
+    getDragHandleProps: ({ item, prev }) => {
+      var _a, _b, _c, _d, _e;
+      const dataRef = item.getDataRef();
+      const props = (_a = prev == null ? void 0 : prev()) != null ? _a : {};
+      (_c = (_b = dataRef.current).memo) != null ? _c : _b.memo = {};
+      (_e = (_d = dataRef.current.memo).drag) != null ? _e : _d.drag = {};
+      return memoize(props, dataRef.current.memo.drag);
+    },
     getRenameInputProps: ({ item, prev }) => {
       var _a, _b, _c, _d, _e;
       const dataRef = item.getDataRef();

package/package.json

@@ -13,7 +13,7 @@
     "checkbox",
     "hook"
   ],
-  "version": "1.6.1",
+  "version": "1.6.3",
   "main": "dist/index.d.ts",
   "module": "dist/index.mjs",
   "types": "dist/index.d.mts",

package/src/features/async-data-loader/feature.ts

@@ -180,15 +180,21 @@ export const asyncDataLoaderFeature: FeatureImplementation = {
       }
       await loadChildrenIds(tree, itemId);
     },
-    updateCachedChildrenIds: ({ tree, itemId }, childrenIds) => {
-      const dataRef = tree.getDataRef<AsyncDataLoaderDataRef>();
-      dataRef.current.childrenIds[itemId] = childrenIds;
-      tree.rebuildTree();
+    updateCachedChildrenIds: (
+      { tree, itemId },
+      childrenIds,
+      skipUpdateTree,
+    ) => {
+      getDataRef(tree).current.childrenIds[itemId] = childrenIds;
+      if (!skipUpdateTree) {
+        tree.rebuildTree();
+      }
     },
-    updateCachedData: ({ tree, itemId }, data) => {
-      const dataRef = tree.getDataRef<AsyncDataLoaderDataRef>();
-      dataRef.current.itemData[itemId] = data;
-      tree.rebuildTree();
+    updateCachedData: ({ tree, itemId }, data, skipUpdateTree) => {
+      getDataRef(tree).current.itemData[itemId] = data;
+      if (!skipUpdateTree) {
+        tree.rebuildTree();
+      }
     },
     hasLoadedData: ({ tree, itemId }) => {
       const dataRef = tree.getDataRef<AsyncDataLoaderDataRef>();

package/src/features/async-data-loader/types.ts

@@ -39,6 +39,7 @@ export type AsyncDataLoaderFeatureDef<T> = {
     waitForItemChildrenLoaded: (itemId: string) => Promise<void>;
     loadItemData: (itemId: string) => Promise<T>;
     loadChildrenIds: (itemId: string) => Promise<string[]>;
+
     /* idea: recursiveLoadItems: (itemId: string, cancelToken?: { current: boolean }, onLoad: (itemIds: string[]) => void) => Promise<T[]> */
   };
   itemInstance: SyncDataLoaderFeatureDef<T>["itemInstance"] & {
@@ -52,9 +53,16 @@ export type AsyncDataLoaderFeatureDef<T> = {
      * the tree will continue to display the old data until the new data has loaded. */
     invalidateChildrenIds: (optimistic?: boolean) => Promise<void>;
 
-    /** Set to undefined to clear cache without triggering automatic refetch. Use @invalidateItemData to clear and triggering refetch. */
-    updateCachedData: (data: T | undefined) => void;
-    updateCachedChildrenIds: (childrenIds: string[]) => void;
+    /** Set to undefined to clear cache without triggering automatic refetch. Use @invalidateItemData to clear and triggering refetch.
+     * @param skipUpdateTree If true, the tree will not rebuild the tree structure cache afterwards by calling `tree.rebuildTree()`. */
+    updateCachedData: (data: T | undefined, skipUpdateTree?: boolean) => void;
+
+    /** @param skipUpdateTree If true, the tree will not rebuild the tree structure cache afterwards by calling `tree.rebuildTree()`. */
+    updateCachedChildrenIds: (
+      childrenIds: string[],
+      skipUpdateTree?: boolean,
+    ) => void;
+
     hasLoadedData: () => boolean;
     isLoading: () => boolean;
   };

package/src/features/drag-and-drop/drag-and-drop.spec.ts

@@ -328,8 +328,7 @@ describe("core-feature/drag-and-drop", () => {
           "onDropForeignDragObject",
         );
         const event = tree.createBottomDragEvent(2);
-        tree.setElementBoundingBox("x212");
-        tree.setElementBoundingBox("x213");
+        tree.setElementBoundingBox("x112");
         tree.do.dragOver("x112", event);
         tree.do.drop("x112", event);
         expect(onDropForeignDragObject).toHaveBeenCalledWith(
@@ -357,6 +356,38 @@ describe("core-feature/drag-and-drop", () => {
         tree.do.drop("x11", event);
         expect(onDropForeignDragObject).not.toHaveBeenCalled();
       });
+
+      it("calls canDragForeignDragObjectOver in drag over events, not canDropForeignDragObject", () => {
+        const canDropForeignDragObject = tree
+          .mockedHandler("canDropForeignDragObject")
+          .mockReturnValue(true);
+        const canDragForeignDragObjectOver = tree
+          .mockedHandler("canDragForeignDragObjectOver")
+          .mockReturnValue(true);
+        const event = TestTree.dragEvent();
+        tree.do.dragOver("x11", event);
+        expect(canDragForeignDragObjectOver).toHaveBeenCalledWith(
+          event.dataTransfer,
+          { item: tree.item("x11") },
+        );
+        expect(canDropForeignDragObject).not.toHaveBeenCalled();
+      });
+
+      it("calls canDropForeignDragObject in drop events, not canDragForeignDragObjectOver", () => {
+        const canDropForeignDragObject = tree
+          .mockedHandler("canDropForeignDragObject")
+          .mockReturnValue(true);
+        const canDragForeignDragObjectOver = tree
+          .mockedHandler("canDragForeignDragObjectOver")
+          .mockReturnValue(true);
+        const event = TestTree.dragEvent();
+        tree.do.drop("x11", event);
+        expect(canDropForeignDragObject).toHaveBeenCalledWith(
+          event.dataTransfer,
+          { item: tree.item("x11") },
+        );
+        expect(canDragForeignDragObjectOver).not.toHaveBeenCalled();
+      });
     });
 
     describe("with insertion handlers", () => {
@@ -698,6 +729,54 @@ describe("core-feature/drag-and-drop", () => {
       });
     });
 
+    describe("seperateDragHandle", () => {
+      it("includes all drag handlers in getProps() when seperateDragHandle is false", () => {
+        const props = tree.instance.getItemInstance("x111").getProps();
+        expect(props.draggable).toBe(true);
+        expect(props.onDragStart).toBeDefined();
+        expect(props.onDragEnd).toBeDefined();
+        expect(props.onDragEnter).toBeDefined();
+        expect(props.onDragOver).toBeDefined();
+        expect(props.onDragLeave).toBeDefined();
+        expect(props.onDrop).toBeDefined();
+      });
+
+      it("includes drag handle handlers in getDragHandleProps() when seperateDragHandle is false", () => {
+        const props = tree.instance
+          .getItemInstance("x111")
+          .getDragHandleProps();
+        expect(props.draggable).toBe(true);
+        expect(props.onDragStart).toBeDefined();
+        expect(props.onDragEnd).toBeDefined();
+      });
+
+      it("excludes drag handle handlers from getProps() but includes drop handlers when seperateDragHandle is true", async () => {
+        const testTree = await tree
+          .with({ seperateDragHandle: true })
+          .createTestCaseTree();
+        const props = testTree.instance.getItemInstance("x111").getProps();
+        expect(props.draggable).toBeUndefined();
+        expect(props.onDragStart).toBeUndefined();
+        expect(props.onDragEnd).toBeUndefined();
+        expect(props.onDragEnter).toBeDefined();
+        expect(props.onDragOver).toBeDefined();
+        expect(props.onDragLeave).toBeDefined();
+        expect(props.onDrop).toBeDefined();
+      });
+
+      it("includes drag handle handlers in getDragHandleProps() when seperateDragHandle is true", async () => {
+        const testTree = await tree
+          .with({ seperateDragHandle: true })
+          .createTestCaseTree();
+        const props = testTree.instance
+          .getItemInstance("x111")
+          .getDragHandleProps();
+        expect(props.draggable).toBe(true);
+        expect(props.onDragStart).toBeDefined();
+        expect(props.onDragEnd).toBeDefined();
+      });
+    });
+
     describe("retains last drag state with dragcode", () => {
       it("uses constant number of calls to canDrop", () => {
         const canDrop = tree.mockedHandler("canDrop").mockReturnValue(true);
@@ -708,5 +787,99 @@ describe("core-feature/drag-and-drop", () => {
         expect(canDrop).toBeCalledTimes(3);
       });
     });
+
+    describe("draggedItemOverwritesSelection", () => {
+      it("overwrites selection when dragging unselected item with draggedItemOverwritesSelection=true", () => {
+        tree.do.selectItem("x111");
+        tree.do.ctrlSelectItem("x112");
+        tree.do.ctrlSelectItem("x113");
+
+        expect(tree.instance.getItemInstance("x111").isSelected()).toBe(true);
+        expect(tree.instance.getItemInstance("x112").isSelected()).toBe(true);
+        expect(tree.instance.getItemInstance("x113").isSelected()).toBe(true);
+        expect(tree.instance.getItemInstance("x114").isSelected()).toBe(false);
+
+        tree.do.startDrag("x114");
+
+        expect(tree.instance.getItemInstance("x111").isSelected()).toBe(false);
+        expect(tree.instance.getItemInstance("x112").isSelected()).toBe(false);
+        expect(tree.instance.getItemInstance("x113").isSelected()).toBe(false);
+        expect(tree.instance.getItemInstance("x114").isSelected()).toBe(true);
+      });
+
+      it("preserves selection when dragging unselected item with draggedItemOverwritesSelection=false", async () => {
+        const testTree = await tree
+          .with({ draggedItemOverwritesSelection: false })
+          .createTestCaseTree();
+
+        testTree.do.selectItem("x111");
+        testTree.do.ctrlSelectItem("x112");
+        testTree.do.ctrlSelectItem("x113");
+
+        expect(testTree.item("x111").isSelected()).toBe(true);
+        expect(testTree.item("x112").isSelected()).toBe(true);
+        expect(testTree.item("x113").isSelected()).toBe(true);
+        expect(testTree.item("x114").isSelected()).toBe(false);
+        testTree.do.startDrag("x114");
+
+        expect(testTree.item("x111").isSelected()).toBe(true);
+        expect(testTree.item("x112").isSelected()).toBe(true);
+        expect(testTree.item("x113").isSelected()).toBe(true);
+        expect(testTree.item("x114").isSelected()).toBe(false);
+      });
+
+      it("does not overwrite selection when dragging selected item with draggedItemOverwritesSelection=true", () => {
+        tree.do.selectItem("x111");
+        tree.do.ctrlSelectItem("x112");
+        tree.do.ctrlSelectItem("x113");
+
+        expect(tree.item("x111").isSelected()).toBe(true);
+        expect(tree.item("x112").isSelected()).toBe(true);
+        expect(tree.item("x113").isSelected()).toBe(true);
+
+        tree.do.startDrag("x111");
+
+        expect(tree.item("x111").isSelected()).toBe(true);
+        expect(tree.item("x112").isSelected()).toBe(true);
+        expect(tree.item("x113").isSelected()).toBe(true);
+      });
+
+      it("does not overwrite selection when dragging selected item with draggedItemOverwritesSelection=false", async () => {
+        const testTree = await tree
+          .with({ draggedItemOverwritesSelection: false })
+          .createTestCaseTree();
+
+        testTree.do.selectItem("x111");
+        testTree.do.ctrlSelectItem("x112");
+        testTree.do.ctrlSelectItem("x113");
+
+        expect(testTree.item("x111").isSelected()).toBe(true);
+        expect(testTree.item("x112").isSelected()).toBe(true);
+        expect(testTree.item("x113").isSelected()).toBe(true);
+
+        testTree.do.startDrag("x111");
+
+        expect(testTree.item("x111").isSelected()).toBe(true);
+        expect(testTree.item("x112").isSelected()).toBe(true);
+        expect(testTree.item("x113").isSelected()).toBe(true);
+      });
+
+      it("drags all selected items when draggedItemOverwritesSelection=false", async () => {
+        const testTree = await tree
+          .with({ draggedItemOverwritesSelection: false })
+          .createTestCaseTree();
+
+        testTree.do.selectItem("x111");
+        testTree.do.ctrlSelectItem("x112");
+        testTree.do.ctrlSelectItem("x113");
+
+        testTree.do.startDrag("x111");
+        testTree.do.dragOverAndDrop("x21");
+
+        testTree.expect.dropped(["x111", "x112", "x113"], {
+          item: testTree.item("x21"),
+        });
+      });
+    });
   });
 });