@headless-tree/core 0.0.0-20250828231818 → 0.0.0-20250903185807

package/CHANGELOG.md

@@ -1,11 +1,12 @@
 # @headless-tree/core
 
-## 0.0.0-20250828231818
+## 0.0.0-20250903185807
 
 ### Patch Changes
 
 - 72e714b: all NPM deployments will now publish with provenance
 - 215ab4b: add a new symbol that can be used in hotkey configurations "metaorcontrol" that will trigger if either any windows control key or mac meta key is pressed (#141)
+- 51b0dea: Added `isUnorderedDragTarget` as alternative to `isDragTarget` for easier detection of drag type
 - cf845d7: Added new state variable `loadingCheckPropagationItems` to indicate if, in async trees with checkboxes and state propagation enabled, data loading operations are currently loading due to a checkbox propagation taking place
 - 597faad: Checkbox propagation is now supported for trees with async data loaders!
 - b0ee382: triggering a data refetch will now always set the loadingItemData/loadingItemChildrens state variable to the associated items if they where not apart of the cache before

package/dist/index.d.mts

@@ -75,7 +75,12 @@ type DragAndDropFeatureDef<T> = {
         getDragLineStyle: (topOffset?: number, leftOffset?: number) => Record<string, any>;
     };
     itemInstance: {
+        /** Checks if the user is dragging in a way which makes this the new parent of the dragged items, either by dragging on top of
+         * this item, or by dragging inbetween children of this item. See @{isUnorderedDragTarget} if the latter is undesirable. */
         isDragTarget: () => boolean;
+        /** As opposed to @{isDragTarget}, this will not be true if the target is inbetween children of this item. This returns only true
+         * if the user is dragging directly on top of this item. */
+        isUnorderedDragTarget: () => boolean;
         isDragTargetAbove: () => boolean;
         isDragTargetBelow: () => boolean;
         isDraggingOver: () => boolean;

package/dist/index.d.ts

@@ -75,7 +75,12 @@ type DragAndDropFeatureDef<T> = {
         getDragLineStyle: (topOffset?: number, leftOffset?: number) => Record<string, any>;
     };
     itemInstance: {
+        /** Checks if the user is dragging in a way which makes this the new parent of the dragged items, either by dragging on top of
+         * this item, or by dragging inbetween children of this item. See @{isUnorderedDragTarget} if the latter is undesirable. */
         isDragTarget: () => boolean;
+        /** As opposed to @{isDragTarget}, this will not be true if the target is inbetween children of this item. This returns only true
+         * if the user is dragging directly on top of this item. */
+        isUnorderedDragTarget: () => boolean;
         isDragTargetAbove: () => boolean;
         isDragTargetBelow: () => boolean;
         isDraggingOver: () => boolean;

package/dist/index.js

@@ -1641,6 +1641,10 @@ var dragAndDropFeature = {
       const target = tree.getDragTarget();
       return target ? target.item.getId() === item.getId() : false;
     },
+    isUnorderedDragTarget: ({ tree, item }) => {
+      const target = tree.getDragTarget();
+      return target ? !isOrderedDragTarget(target) && target.item.getId() === item.getId() : false;
+    },
     isDragTargetAbove: ({ tree, item }) => {
       const target = tree.getDragTarget();
       if (!target || !isOrderedDragTarget(target) || target.item !== item.getParent())

package/dist/index.mjs

@@ -1597,6 +1597,10 @@ var dragAndDropFeature = {
       const target = tree.getDragTarget();
       return target ? target.item.getId() === item.getId() : false;
     },
+    isUnorderedDragTarget: ({ tree, item }) => {
+      const target = tree.getDragTarget();
+      return target ? !isOrderedDragTarget(target) && target.item.getId() === item.getId() : false;
+    },
     isDragTargetAbove: ({ tree, item }) => {
       const target = tree.getDragTarget();
       if (!target || !isOrderedDragTarget(target) || target.item !== item.getParent())

package/package.json

@@ -1,6 +1,19 @@
 {
   "name": "@headless-tree/core",
-  "version": "0.0.0-20250828231818",
+  "description": "The definitive tree component for the Web",
+  "keywords": [
+    "tree",
+    "component",
+    "web",
+    "headless",
+    "ui",
+    "react",
+    "nested",
+    "async",
+    "checkbox",
+    "hook"
+  ],
+  "version": "0.0.0-20250903185807",
   "main": "dist/index.d.ts",
   "module": "dist/index.mjs",
   "types": "dist/index.d.mts",

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

@@ -332,6 +332,13 @@ export const dragAndDropFeature: FeatureImplementation = {
       return target ? target.item.getId() === item.getId() : false;
     },
 
+    isUnorderedDragTarget: ({ tree, item }) => {
+      const target = tree.getDragTarget();
+      return target
+        ? !isOrderedDragTarget(target) && target.item.getId() === item.getId()
+        : false;
+    },
+
     isDragTargetAbove: ({ tree, item }) => {
       const target = tree.getDragTarget();
 

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

@@ -108,7 +108,13 @@ export type DragAndDropFeatureDef<T> = {
     ) => Record<string, any>;
   };
   itemInstance: {
+    /** Checks if the user is dragging in a way which makes this the new parent of the dragged items, either by dragging on top of
+     * this item, or by dragging inbetween children of this item. See @{isUnorderedDragTarget} if the latter is undesirable. */
     isDragTarget: () => boolean;
+
+    /** As opposed to @{isDragTarget}, this will not be true if the target is inbetween children of this item. This returns only true
+     * if the user is dragging directly on top of this item. */
+    isUnorderedDragTarget: () => boolean;
     isDragTargetAbove: () => boolean;
     isDragTargetBelow: () => boolean;
     isDraggingOver: () => boolean;

package/src/mddocs-entry.ts

@@ -10,6 +10,7 @@ import { SyncDataLoaderFeatureDef } from "./features/sync-data-loader/types";
 import { TreeFeatureDef } from "./features/tree/types";
 import { PropMemoizationFeatureDef } from "./features/prop-memoization/types";
 import { KeyboardDragAndDropFeatureDef } from "./features/keyboard-drag-and-drop/types";
+import type { CheckboxesFeatureDef } from "./features/checkboxes/types";
 
 export * from ".";
 
@@ -167,3 +168,15 @@ export type TreeFeatureTreeInstance<T> = TreeFeatureDef<T>["treeInstance"];
 /** @interface */
 export type TreeFeatureItemInstance<T> = TreeFeatureDef<T>["itemInstance"];
 export type TreeFeatureHotkeys<T> = TreeFeatureDef<T>["hotkeys"];
+
+/** @interface */
+export type CheckboxesFeatureConfig<T> = CheckboxesFeatureDef<T>["config"];
+/** @interface */
+export type CheckboxesFeatureState<T> = CheckboxesFeatureDef<T>["state"];
+/** @interface */
+export type CheckboxesFeatureTreeInstance<T> =
+  CheckboxesFeatureDef<T>["treeInstance"];
+/** @interface */
+export type CheckboxesFeatureItemInstance<T> =
+  CheckboxesFeatureDef<T>["itemInstance"];
+export type CheckboxesFeatureHotkeys<T> = CheckboxesFeatureDef<T>["hotkeys"];