@headless-tree/core 0.0.9 → 0.0.11

package/src/features/selection/feature.ts

@@ -25,23 +25,19 @@ export const selectionFeature: FeatureImplementation<
     selectedItems: "setSelectedItems",
   },
 
-  createTreeInstance: (prev, instance) => ({
-    ...prev,
-
-    setSelectedItems: (selectedItems) => {
-      instance.applySubStateUpdate("selectedItems", selectedItems);
+  treeInstance: {
+    setSelectedItems: ({ tree }, selectedItems) => {
+      tree.applySubStateUpdate("selectedItems", selectedItems);
     },
 
     // TODO memo
-    getSelectedItems: () => {
-      return instance.getState().selectedItems.map(instance.getItemInstance);
+    getSelectedItems: ({ tree }) => {
+      return tree.getState().selectedItems.map(tree.getItemInstance);
     },
-  }),
-
-  createItemInstance: (prev, item, tree) => ({
-    ...prev,
+  },
 
-    select: () => {
+  itemInstance: {
+    select: ({ tree, item }) => {
       const { selectedItems } = tree.getState();
       tree.setSelectedItems(
         selectedItems.includes(item.getItemMeta().itemId)
@@ -50,19 +46,19 @@ export const selectionFeature: FeatureImplementation<
       );
     },
 
-    deselect: () => {
+    deselect: ({ tree, item }) => {
       const { selectedItems } = tree.getState();
       tree.setSelectedItems(
         selectedItems.filter((id) => id !== item.getItemMeta().itemId),
       );
     },
 
-    isSelected: () => {
+    isSelected: ({ tree, item }) => {
       const { selectedItems } = tree.getState();
       return selectedItems.includes(item.getItemMeta().itemId);
     },
 
-    selectUpTo: (ctrl: boolean) => {
+    selectUpTo: ({ tree, item }, ctrl: boolean) => {
       const indexA = item.getItemMeta().index;
       // TODO dont use focused item as anchor, but last primary-clicked item
       const indexB = tree.getFocusedItem().getItemMeta().index;
@@ -84,7 +80,7 @@ export const selectionFeature: FeatureImplementation<
       tree.setSelectedItems(uniqueSelectedItems);
     },
 
-    toggleSelect: () => {
+    toggleSelect: ({ item }) => {
       if (item.isSelected()) {
         item.deselect();
       } else {
@@ -92,22 +88,25 @@ export const selectionFeature: FeatureImplementation<
       }
     },
 
-    getProps: () => ({
-      ...prev.getProps(),
+    getProps: ({ tree, item, prev }) => ({
+      ...prev?.(),
       "aria-selected": item.isSelected() ? "true" : "false",
-      onClick: item.getMemoizedProp("selection/onClick", () => (e) => {
-        if (e.shiftKey) {
-          item.selectUpTo(e.ctrlKey || e.metaKey);
-        } else if (e.ctrlKey || e.metaKey) {
-          item.toggleSelect();
-        } else {
-          tree.setSelectedItems([item.getItemMeta().itemId]);
-        }
-
-        prev.getProps().onClick?.(e);
-      }),
+      onClick: item.getMemoizedProp(
+        "selection/onClick",
+        () => (e: MouseEvent) => {
+          if (e.shiftKey) {
+            item.selectUpTo(e.ctrlKey || e.metaKey);
+          } else if (e.ctrlKey || e.metaKey) {
+            item.toggleSelect();
+          } else {
+            tree.setSelectedItems([item.getItemMeta().itemId]);
+          }
+
+          prev?.()?.onClick?.(e);
+        },
+      ),
     }),
-  }),
+  },
 
   hotkeys: {
     // setSelectedItem: {

package/src/features/selection/selection.spec.ts

@@ -0,0 +1,220 @@
+import { describe, expect, it } from "vitest";
+import { TestTree } from "../../test-utils/test-tree";
+import { selectionFeature } from "./feature";
+
+const factory = TestTree.default({}).withFeatures(selectionFeature);
+
+// it("test", async () => {
+//   const tree = await factory.suits.async().tree.createDebugTree();
+//   const setSelectedItems = tree.mockedHandler("setSelectedItems");
+//   const setFocusedItem = tree.mockedHandler("setFocusedItem");
+//
+//   tree.do.selectItem("x111");
+//   tree.do.ctrlSelectItem("x112");
+//   tree.do.ctrlSelectItem("x113");
+//
+//   expect(setSelectedItems).toHaveBeenCalledWith(["x111", "x112", "x113"]);
+//   expect(setFocusedItem).toHaveBeenCalledWith("x113");
+// });
+
+describe("core-feature/selections", () => {
+  factory.forSuits((tree) => {
+    it("sets aria-selected to false", () => {
+      expect(
+        tree.instance.getItemInstance("x111").getProps()["aria-selected"],
+      ).toBe("false");
+    });
+
+    it("sets aria-selected to true", () => {
+      tree.do.selectItem("x111");
+      expect(
+        tree.instance.getItemInstance("x111").getProps()["aria-selected"],
+      ).toBe("true");
+    });
+
+    it("resets old selection after new select", () => {
+      tree.do.selectItem("x111");
+      tree.do.selectItem("x112");
+      expect(
+        tree.instance.getItemInstance("x111").getProps()["aria-selected"],
+      ).toBe("false");
+      expect(
+        tree.instance.getItemInstance("x112").getProps()["aria-selected"],
+      ).toBe("true");
+      expect(tree.instance.getItemInstance("x111").isSelected()).toBe(false);
+      expect(tree.instance.getItemInstance("x112").isSelected()).toBe(true);
+    });
+
+    describe("select and control select", () => {
+      it("should make isSelected 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);
+      });
+
+      it("should call individual state setters", () => {
+        const setSelectedItems = tree.mockedHandler("setSelectedItems");
+        const setFocusedItem = tree.mockedHandler("setFocusedItem");
+
+        tree.do.selectItem("x111");
+        tree.do.ctrlSelectItem("x112");
+        tree.do.ctrlSelectItem("x113");
+
+        expect(setSelectedItems).toHaveBeenCalledWith(["x111", "x112", "x113"]);
+        expect(setFocusedItem).toHaveBeenCalledWith("x113");
+      });
+
+      it("should call joint state setter", () => {
+        const setState = tree.mockedHandler("setState");
+
+        tree.do.selectItem("x111");
+        tree.do.ctrlSelectItem("x112");
+        tree.do.ctrlSelectItem("x113");
+
+        expect(setState).toHaveBeenCalledWith(
+          expect.objectContaining({
+            selectedItems: ["x111", "x112", "x113"],
+            focusedItem: "x113",
+          }),
+        );
+      });
+    });
+
+    describe("shift select", () => {
+      it("should make isSelected true", () => {
+        tree.do.selectItem("x111");
+        tree.do.shiftSelectItem("x113");
+        tree.do.ctrlSelectItem("x2");
+
+        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("x2").isSelected()).toBe(true);
+      });
+
+      it("should call individual state setters", () => {
+        const setSelectedItems = tree.mockedHandler("setSelectedItems");
+        const setFocusedItem = tree.mockedHandler("setFocusedItem");
+
+        tree.do.selectItem("x111");
+        tree.do.shiftSelectItem("x113");
+        expect(setFocusedItem).toHaveBeenCalledWith("x113");
+
+        tree.do.ctrlSelectItem("x2");
+
+        expect(setSelectedItems).toHaveBeenCalledWith([
+          "x111",
+          "x112",
+          "x113",
+          "x2",
+        ]);
+
+        expect(setFocusedItem).toHaveBeenCalledWith("x2");
+      });
+
+      it("should call joint state setter", () => {
+        const setState = tree.mockedHandler("setState");
+
+        tree.do.selectItem("x111");
+        tree.do.shiftSelectItem("x113");
+        expect(setState).toHaveBeenCalledWith(
+          expect.objectContaining({
+            selectedItems: ["x111", "x112", "x113"],
+            focusedItem: "x113",
+          }),
+        );
+
+        tree.do.ctrlSelectItem("x2");
+
+        expect(setState).toHaveBeenCalledWith(
+          expect.objectContaining({
+            selectedItems: ["x111", "x112", "x113", "x2"],
+            focusedItem: "x2",
+          }),
+        );
+      });
+    });
+
+    describe("programmatic select", () => {
+      describe("item instance actions", () => {
+        it("should handle select", () => {
+          const setSelectedItems = tree.mockedHandler("setSelectedItems");
+          tree.instance.getItemInstance("x111").select();
+          expect(setSelectedItems).toHaveBeenCalledWith(["x111"]);
+          expect(tree.instance.getItemInstance("x111").isSelected()).toBe(true);
+        });
+
+        it("should handle deselect", () => {
+          const setSelectedItems = tree.mockedHandler("setSelectedItems");
+          tree.instance.getItemInstance("x111").select();
+          tree.instance.getItemInstance("x111").deselect();
+          expect(setSelectedItems).toHaveBeenCalledWith([]);
+          expect(tree.instance.getItemInstance("x111").isSelected()).toBe(
+            false,
+          );
+        });
+
+        it("should handle toggle select on", () => {
+          const setSelectedItems = tree.mockedHandler("setSelectedItems");
+          tree.instance.getItemInstance("x111").toggleSelect();
+          expect(setSelectedItems).toHaveBeenCalledWith(["x111"]);
+          expect(tree.instance.getItemInstance("x111").isSelected()).toBe(true);
+        });
+
+        it("should handle toggle select off", () => {
+          const setSelectedItems = tree.mockedHandler("setSelectedItems");
+          tree.instance.getItemInstance("x111").select();
+          tree.instance.getItemInstance("x111").toggleSelect();
+          expect(setSelectedItems).toHaveBeenCalledWith([]);
+          expect(tree.instance.getItemInstance("x111").isSelected()).toBe(
+            false,
+          );
+        });
+
+        it("should handle selectUpTo without ctrl", () => {
+          const setSelectedItems = tree.mockedHandler("setSelectedItems");
+          tree.instance.getItemInstance("x111").toggleSelect();
+          tree.instance.getItemInstance("x112").toggleSelect();
+          tree.instance.getItemInstance("x112").setFocused();
+          tree.instance.getItemInstance("x114").selectUpTo(false);
+          expect(setSelectedItems).toHaveBeenCalledWith([
+            "x112",
+            "x113",
+            "x114",
+          ]);
+          expect(tree.instance.getItemInstance("x112").isSelected()).toBe(true);
+        });
+
+        it("should handle selectUpTo with ctrl", () => {
+          const setSelectedItems = tree.mockedHandler("setSelectedItems");
+          tree.instance.getItemInstance("x111").toggleSelect();
+          tree.instance.getItemInstance("x112").toggleSelect();
+          tree.instance.getItemInstance("x112").setFocused();
+          tree.instance.getItemInstance("x114").selectUpTo(true);
+          expect(setSelectedItems).toHaveBeenCalledWith([
+            "x111",
+            "x112",
+            "x113",
+            "x114",
+          ]);
+          expect(tree.instance.getItemInstance("x112").isSelected()).toBe(true);
+        });
+      });
+
+      it("should handle getters", () => {
+        const setSelectedItems = tree.mockedHandler("setSelectedItems");
+        tree.instance.setSelectedItems(["x111", "x112"]);
+        expect(setSelectedItems).toHaveBeenCalledWith(["x111", "x112"]);
+        expect(tree.instance.getItemInstance("x111").isSelected()).toBe(true);
+        expect(tree.instance.getItemInstance("x112").isSelected()).toBe(true);
+        expect(tree.instance.getSelectedItems()[0].getId()).toEqual("x111");
+        expect(tree.instance.getSelectedItems()[1].getId()).toEqual("x112");
+        expect(tree.instance.getSelectedItems().length).toBe(2);
+      });
+    });
+  });
+});

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

@@ -24,18 +24,15 @@ export const syncDataLoaderFeature: FeatureImplementation<
     loadingItems: "setLoadingItems",
   },
 
-  createTreeInstance: (prev, instance) => ({
-    ...prev,
+  treeInstance: {
+    retrieveItemData: ({ tree }, itemId) =>
+      tree.getConfig().dataLoader!.getItem(itemId),
 
-    retrieveItemData: (itemId) =>
-      instance.getConfig().dataLoader!.getItem(itemId),
-
-    retrieveChildrenIds: (itemId) =>
-      instance.getConfig().dataLoader!.getChildren(itemId),
-  }),
+    retrieveChildrenIds: ({ tree }, itemId) =>
+      tree.getConfig().dataLoader!.getChildren(itemId),
+  },
 
-  createItemInstance: (prev) => ({
-    ...prev,
+  itemInstance: {
     isLoading: () => false,
-  }),
+  },
 };

package/src/features/tree/feature.ts

@@ -1,9 +1,10 @@
 import { FeatureImplementation, ItemInstance } from "../../types/core";
 import { ItemMeta, TreeFeatureDef, TreeItemDataRef } from "./types";
-import { makeStateUpdater, memo, poll } from "../../utils";
+import { makeStateUpdater, poll } from "../../utils";
 import { MainFeatureDef } from "../main/types";
 import { HotkeysCoreFeatureDef } from "../hotkeys-core/types";
 import { SyncDataLoaderFeatureDef } from "../sync-data-loader/types";
+import { SearchFeatureDef } from "../search/types";
 
 export const treeFeature: FeatureImplementation<
   any,
@@ -12,6 +13,7 @@ export const treeFeature: FeatureImplementation<
   | TreeFeatureDef<any>
   | HotkeysCoreFeatureDef<any>
   | SyncDataLoaderFeatureDef<any>
+  | SearchFeatureDef<any>
 > = {
   key: "tree",
 
@@ -32,24 +34,15 @@ export const treeFeature: FeatureImplementation<
     focusedItem: "setFocusedItem",
   },
 
-  createTreeInstance: (prev, instance) => ({
-    ...prev,
+  treeInstance: {
+    isItemExpanded: ({ tree }, itemId) =>
+      tree.getState().expandedItems.includes(itemId),
 
-    retrieveItemData: () => {
-      throw new Error("No data-loader registered");
-    },
-
-    retrieveChildrenIds: () => {
-      throw new Error("No data-loader registered");
-    },
-
-    isItemExpanded: (itemId) =>
-      instance.getState().expandedItems.includes(itemId),
-
-    getItemsMeta: () => {
-      const { rootItemId } = instance.getConfig();
-      const { expandedItems } = instance.getState();
+    getItemsMeta: ({ tree }) => {
+      const { rootItemId } = tree.getConfig();
+      const { expandedItems } = tree.getState();
       const flatItems: ItemMeta[] = [];
+      const expandedItemsSet = new Set(expandedItems);
 
       const recursiveAdd = (
         itemId: string,
@@ -67,8 +60,9 @@ export const treeFeature: FeatureImplementation<
           posInSet,
         });
 
-        if (expandedItems.includes(itemId)) {
-          const children = instance.retrieveChildrenIds(itemId) ?? [];
+        if (expandedItemsSet.has(itemId)) {
+          // TODO THIS MADE A HUGE DIFFERENCE!
+          const children = tree.retrieveChildrenIds(itemId) ?? [];
           let i = 0;
           for (const childId of children) {
             recursiveAdd(childId, itemId, level + 1, children.length, i++);
@@ -76,7 +70,7 @@ export const treeFeature: FeatureImplementation<
         }
       };
 
-      const children = instance.retrieveChildrenIds(rootItemId);
+      const children = tree.retrieveChildrenIds(rootItemId);
       let i = 0;
       for (const itemId of children) {
         recursiveAdd(itemId, rootItemId, 0, children.length, i++);
@@ -85,62 +79,62 @@ export const treeFeature: FeatureImplementation<
       return flatItems;
     },
 
-    expandItem: (itemId) => {
-      if (!instance.getItemInstance(itemId).isFolder()) {
+    expandItem: ({ tree }, itemId) => {
+      if (!tree.getItemInstance(itemId).isFolder()) {
         return;
       }
 
-      if (instance.getState().loadingItems?.includes(itemId)) {
+      if (tree.getState().loadingItems?.includes(itemId)) {
         return;
       }
 
-      instance.applySubStateUpdate("expandedItems", (expandedItems) => [
+      tree.applySubStateUpdate("expandedItems", (expandedItems) => [
         ...expandedItems,
         itemId,
       ]);
-      instance.rebuildTree();
+      tree.rebuildTree();
     },
 
-    collapseItem: (itemId) => {
-      if (!instance.getItemInstance(itemId).isFolder()) {
+    collapseItem: ({ tree }, itemId) => {
+      if (!tree.getItemInstance(itemId).isFolder()) {
         return;
       }
 
-      instance.applySubStateUpdate("expandedItems", (expandedItems) =>
+      tree.applySubStateUpdate("expandedItems", (expandedItems) =>
         expandedItems.filter((id) => id !== itemId),
       );
-      instance.rebuildTree();
+      tree.rebuildTree();
     },
 
     // TODO memo
-    getFocusedItem: () => {
+    getFocusedItem: ({ tree }) => {
       return (
-        instance.getItemInstance(instance.getState().focusedItem ?? "") ??
-        instance.getItems()[0]
+        tree.getItemInstance(tree.getState().focusedItem ?? "") ??
+        tree.getItems()[0]
       );
     },
 
-    focusItem: (itemId) => {
-      instance.applySubStateUpdate("focusedItem", itemId);
+    focusItem: ({ tree }, itemId) => {
+      tree.applySubStateUpdate("focusedItem", itemId);
     },
 
-    focusNextItem: () => {
-      const { index } = instance.getFocusedItem().getItemMeta();
-      const nextIndex = Math.min(index + 1, instance.getItems().length - 1);
-      instance.focusItem(instance.getItems()[nextIndex].getId());
+    focusNextItem: ({ tree }) => {
+      const { index } = tree.getFocusedItem().getItemMeta();
+      const nextIndex = Math.min(index + 1, tree.getItems().length - 1);
+      tree.focusItem(tree.getItems()[nextIndex].getId());
     },
 
-    focusPreviousItem: () => {
-      const { index } = instance.getFocusedItem().getItemMeta();
+    focusPreviousItem: ({ tree }) => {
+      const { index } = tree.getFocusedItem().getItemMeta();
       const nextIndex = Math.max(index - 1, 0);
-      instance.focusItem(instance.getItems()[nextIndex].getId());
+      tree.focusItem(tree.getItems()[nextIndex].getId());
     },
 
-    updateDomFocus: () => {
+    updateDomFocus: ({ tree }) => {
       // Required because if the state is managed outside in react, the state only updated during next render
       setTimeout(async () => {
-        const focusedItem = instance.getFocusedItem();
-        instance.getConfig().scrollToItem?.(focusedItem);
+        const focusedItem = tree.getFocusedItem();
+        tree.getConfig().scrollToItem?.(focusedItem);
         await poll(() => focusedItem.getElement() !== null, 20);
         const focusedElement = focusedItem.getElement();
         if (!focusedElement) return;
@@ -148,29 +142,28 @@ export const treeFeature: FeatureImplementation<
       });
     },
 
-    getContainerProps: () => ({
-      ...prev.getContainerProps?.(),
+    getContainerProps: ({ prev }) => ({
+      ...prev?.(),
       role: "tree",
       ariaLabel: "",
       ariaActivedescendant: "",
     }),
-  }),
 
-  createItemInstance: (prev, item, tree) => ({
-    ...prev,
-    isLoading: () => {
-      throw new Error("No data-loader registered");
-    },
-    scrollTo: async (scrollIntoViewArg) => {
+    // relevant for hotkeys of this feature
+    isSearchOpen: () => false,
+  },
+
+  itemInstance: {
+    scrollTo: async ({ tree, item }, scrollIntoViewArg) => {
       tree.getConfig().scrollToItem?.(item as any);
       await poll(() => item.getElement() !== null, 20);
-      item.getElement()!.scrollIntoView(scrollIntoViewArg);
+      item.getElement()?.scrollIntoView(scrollIntoViewArg);
     },
-    getId: () => item.getItemMeta().itemId,
-    getProps: () => {
+    getId: ({ item }) => item.getItemMeta().itemId,
+    getProps: ({ item, prev }) => {
       const itemMeta = item.getItemMeta();
       return {
-        ...prev.getProps?.(),
+        ...prev?.(),
         role: "treeitem",
         "aria-setsize": itemMeta.setSize,
         "aria-posinset": itemMeta.posInSet,
@@ -178,7 +171,7 @@ export const treeFeature: FeatureImplementation<
         "aria-label": item.getItemName(),
         "aria-level": itemMeta.level,
         tabIndex: item.isFocused() ? 0 : -1,
-        onClick: item.getMemoizedProp("tree/onClick", () => (e) => {
+        onClick: item.getMemoizedProp("tree/onClick", () => (e: MouseEvent) => {
           item.setFocused();
           item.primaryAction();
 
@@ -198,46 +191,48 @@ export const treeFeature: FeatureImplementation<
         }),
       };
     },
-    expand: () => tree.expandItem(item.getItemMeta().itemId),
-    collapse: () => tree.collapseItem(item.getItemMeta().itemId),
-    getItemData: () => tree.retrieveItemData(item.getItemMeta().itemId),
-    isExpanded: () =>
+    expand: ({ tree, item }) => tree.expandItem(item.getItemMeta().itemId),
+    collapse: ({ tree, item }) => tree.collapseItem(item.getItemMeta().itemId),
+    getItemData: ({ tree, item }) =>
+      tree.retrieveItemData(item.getItemMeta().itemId),
+    equals: ({ item }, other) => item.getId() === other?.getId(),
+    isExpanded: ({ tree, item }) =>
       tree.getState().expandedItems.includes(item.getItemMeta().itemId),
-    isFocused: () =>
+    isDescendentOf: ({ item }, parentId) => {
+      const parent = item.getParent();
+      return Boolean(
+        parent?.getId() === parentId || parent?.isDescendentOf(parentId),
+      );
+    },
+    isFocused: ({ tree, item }) =>
       tree.getState().focusedItem === item.getItemMeta().itemId ||
       (tree.getState().focusedItem === null && item.getItemMeta().index === 0),
-    isFolder: () =>
+    isFolder: ({ tree, item }) =>
       item.getItemMeta().level === -1 ||
       tree.getConfig().isItemFolder(item as ItemInstance<any>),
-    getItemName: () => {
+    getItemName: ({ tree, item }) => {
       const config = tree.getConfig();
       return config.getItemName(item as ItemInstance<any>);
     },
-    setFocused: () => tree.focusItem(item.getItemMeta().itemId),
-    primaryAction: () =>
+    setFocused: ({ tree, item }) => tree.focusItem(item.getItemMeta().itemId),
+    primaryAction: ({ tree, item }) =>
       tree.getConfig().onPrimaryAction?.(item as ItemInstance<any>),
-    getParent: memo(
-      (itemMeta) => {
-        for (let i = itemMeta.index - 1; i >= 0; i--) {
-          const potentialParent = tree.getItems()[i];
-          if (potentialParent.getItemMeta().level < itemMeta.level) {
-            return potentialParent;
-          }
-        }
-        return tree.getItemInstance(tree.getConfig().rootItemId);
-      },
-      () => [item.getItemMeta()],
-    ),
+    getParent: ({ tree, item }) =>
+      item.getItemMeta().parentId
+        ? tree.getItemInstance(item.getItemMeta().parentId)
+        : undefined,
     // TODO remove
-    getIndexInParent: () => item.getItemMeta().posInSet,
-    getChildren: () =>
+    getIndexInParent: ({ item }) => item.getItemMeta().posInSet,
+    getChildren: ({ tree, item }) =>
       tree
         .retrieveChildrenIds(item.getItemMeta().itemId)
         .map((id) => tree.getItemInstance(id)),
-    getTree: () => tree as any,
-    getItemAbove: () => tree.getItems()[item.getItemMeta().index - 1],
-    getItemBelow: () => tree.getItems()[item.getItemMeta().index + 1],
-    getMemoizedProp: (name, create, deps) => {
+    getTree: ({ tree }) => tree as any,
+    getItemAbove: ({ tree, item }) =>
+      tree.getItems()[item.getItemMeta().index - 1],
+    getItemBelow: ({ tree, item }) =>
+      tree.getItems()[item.getItemMeta().index + 1],
+    getMemoizedProp: ({ item }, name, create, deps) => {
       const data = item.getDataRef<TreeItemDataRef>();
       const memoizedValue = data.current.memoizedValues?.[name];
       if (
@@ -254,7 +249,7 @@ export const treeFeature: FeatureImplementation<
       data.current.memoizedValues[name] = value;
       return value;
     },
-  }),
+  },
 
   hotkeys: {
     focusNextItem: {
@@ -262,7 +257,7 @@ export const treeFeature: FeatureImplementation<
       canRepeat: true,
       preventDefault: true,
       isEnabled: (tree) =>
-        !(tree.isSearchOpen?.() ?? false) && !tree.getState().dnd,
+        !(tree.isSearchOpen?.() ?? false) && !tree.getState().dnd, // TODO what happens when the feature doesnt exist? proxy method still claims to exist
       handler: (e, tree) => {
         tree.focusNextItem();
         tree.updateDomFocus();