@headless-tree/core 0.0.11 → 0.0.12

package/src/features/tree/tree.spec.ts

@@ -1,14 +1,15 @@
 import { describe, expect, it, vi } from "vitest";
 import { TestTree } from "../../test-utils/test-tree";
+import { propMemoizationFeature } from "../prop-memoization/feature";
 
-const factory = TestTree.default({});
+const factory = TestTree.default({}).withFeatures(propMemoizationFeature);
 
 describe("core-feature/selections", () => {
   factory.forSuits((tree) => {
     describe("expanded items", () => {
       it("can expand via tree instance", () => {
         const setExpandedItems = tree.mockedHandler("setExpandedItems");
-        tree.instance.expandItem("x2");
+        tree.item("x2").expand();
         expect(setExpandedItems).toHaveBeenCalledWith(["x1", "x11", "x2"]);
       });
 
@@ -19,14 +20,14 @@ describe("core-feature/selections", () => {
       });
 
       it("returns correct isItemExpanded value", () => {
-        expect(tree.instance.isItemExpanded("x2")).toBe(false);
-        tree.instance.expandItem("x2");
-        expect(tree.instance.isItemExpanded("x2")).toBe(true);
+        expect(tree.item("x2").isExpanded()).toBe(false);
+        tree.item("x2").expand();
+        expect(tree.item("x2").isExpanded()).toBe(true);
       });
 
       it("calls setState", () => {
         const setState = tree.mockedHandler("setState");
-        tree.instance.expandItem("x2");
+        tree.item("x2").expand();
         expect(setState).toBeCalledWith(
           expect.objectContaining({ expandedItems: ["x1", "x11", "x2"] }),
         );
@@ -42,7 +43,7 @@ describe("core-feature/selections", () => {
     describe("collapsed items", () => {
       it("can collapse via tree instance", () => {
         const setExpandedItems = tree.mockedHandler("setExpandedItems");
-        tree.instance.collapseItem("x1");
+        tree.item("x1").collapse();
         expect(setExpandedItems).toHaveBeenCalledWith(["x11"]);
       });
 
@@ -53,14 +54,14 @@ describe("core-feature/selections", () => {
       });
 
       it("returns correct isItemExpanded value", () => {
-        expect(tree.instance.isItemExpanded("x1")).toBe(true);
-        tree.instance.collapseItem("x1");
-        expect(tree.instance.isItemExpanded("x1")).toBe(false);
+        expect(tree.item("x1").isExpanded()).toBe(true);
+        tree.item("x1").collapse();
+        expect(tree.item("x1").isExpanded()).toBe(false);
       });
 
       it("calls setState", () => {
         const setState = tree.mockedHandler("setState");
-        tree.instance.collapseItem("x1");
+        tree.item("x1").collapse();
         expect(setState).toBeCalledWith(
           expect.objectContaining({ expandedItems: ["x11"] }),
         );
@@ -74,15 +75,9 @@ describe("core-feature/selections", () => {
     });
 
     describe("focused item", () => {
-      it("focuses item on tree instance", () => {
+      it("focuses item", () => {
         const setFocusedItem = tree.mockedHandler("setFocusedItem");
-        tree.instance.focusItem("x11");
-        expect(setFocusedItem).toHaveBeenCalledWith("x11");
-      });
-
-      it("focuses item on item instance", () => {
-        const setFocusedItem = tree.mockedHandler("setFocusedItem");
-        tree.instance.getItemInstance("x11").setFocused();
+        tree.item("x11").setFocused();
         expect(setFocusedItem).toHaveBeenCalledWith("x11");
       });
 
@@ -91,13 +86,13 @@ describe("core-feature/selections", () => {
       });
 
       it("returns correct focused item", () => {
-        tree.instance.focusItem("x11");
+        tree.item("x11").setFocused();
         expect(tree.instance.getFocusedItem().getId()).toBe("x11");
       });
 
       it("calls setState", () => {
         const setState = tree.mockedHandler("setState");
-        tree.instance.focusItem("x1");
+        tree.item("x1").setFocused();
         expect(setState).toBeCalledWith(
           expect.objectContaining({ focusedItem: "x1" }),
         );
@@ -107,7 +102,7 @@ describe("core-feature/selections", () => {
         const scrollToItem = tree.mockedHandler("scrollToItem");
         const element = { focus: vi.fn() };
         tree.instance.getItemInstance("x2").registerElement(element as any);
-        tree.instance.focusItem("x2");
+        tree.item("x2").setFocused();
         tree.instance.updateDomFocus();
         vi.runAllTimers();
         await vi.waitFor(() =>
@@ -118,21 +113,21 @@ describe("core-feature/selections", () => {
 
       describe("move focus", () => {
         it("focuses next item", () => {
-          tree.instance.focusItem("x2");
+          tree.item("x2").setFocused();
           const setFocusedItem = tree.mockedHandler("setFocusedItem");
           tree.instance.focusNextItem();
           expect(setFocusedItem).toHaveBeenCalledWith("x3");
         });
 
         it("focuses previous item", () => {
-          tree.instance.focusItem("x2");
+          tree.item("x2").setFocused();
           const setFocusedItem = tree.mockedHandler("setFocusedItem");
           tree.instance.focusPreviousItem();
           expect(setFocusedItem).toHaveBeenCalledWith("x14");
         });
 
         it("remains at last item when focus is at bottom", () => {
-          tree.instance.focusItem("x4");
+          tree.item("x4").setFocused();
           const setFocusedItem = tree.mockedHandler("setFocusedItem");
           tree.instance.focusNextItem();
           expect(setFocusedItem).toHaveBeenCalledWith("x4");
@@ -140,7 +135,7 @@ describe("core-feature/selections", () => {
         });
 
         it("remains at first item when focus is at top", () => {
-          tree.instance.focusItem("x1");
+          tree.item("x1").setFocused();
           const setFocusedItem = tree.mockedHandler("setFocusedItem");
           tree.instance.focusPreviousItem();
           expect(setFocusedItem).toHaveBeenCalledWith("x1");
@@ -245,6 +240,7 @@ describe("core-feature/selections", () => {
           "aria-selected": "false",
           "aria-setsize": 4,
           onClick: expect.any(Function),
+          ref: expect.any(Function),
           role: "treeitem",
           tabIndex: -1,
         });
@@ -258,6 +254,7 @@ describe("core-feature/selections", () => {
           "aria-selected": "false",
           "aria-setsize": 4,
           onClick: expect.any(Function),
+          ref: expect.any(Function),
           role: "treeitem",
           tabIndex: 0,
         });
@@ -320,7 +317,7 @@ describe("core-feature/selections", () => {
       });
 
       it("returns correctly for getParent()", () => {
-        expect(tree.instance.getItemInstance("x111").getParent().getId()).toBe(
+        expect(tree.instance.getItemInstance("x111").getParent()?.getId()).toBe(
           "x11",
         );
       });
@@ -383,43 +380,6 @@ describe("core-feature/selections", () => {
       });
     });
 
-    describe("memoized props", () => {
-      it("runs memoized props correctly", () => {
-        const fn = vi.fn().mockReturnValue("result");
-        const memoizedProp = tree.instance
-          .getItemInstance("x1")
-          .getMemoizedProp("fn", () => fn);
-        expect(memoizedProp(1, 2, 3)).toBe("result");
-        expect(fn).toBeCalledWith(1, 2, 3);
-      });
-
-      it("runs just once", () => {
-        const fn = vi.fn().mockImplementation(() => () => "result");
-        tree.instance.getItemInstance("x1").getMemoizedProp("fn", fn)(1);
-        tree.instance.getItemInstance("x1").getMemoizedProp("fn", fn)(1);
-        tree.instance.getItemInstance("x1").getMemoizedProp("fn", fn)(1);
-        expect(fn).toBeCalledTimes(1);
-      });
-
-      it("reruns if dependencies changed", () => {
-        const fn = vi.fn().mockImplementation(() => () => "result");
-        tree.instance.getItemInstance("x1").getMemoizedProp("fn", fn, [1])(1);
-        tree.instance.getItemInstance("x1").getMemoizedProp("fn", fn, [1])(1);
-        tree.instance.getItemInstance("x1").getMemoizedProp("fn", fn, [2])(1);
-        expect(fn).toBeCalledTimes(2);
-      });
-
-      it("seperates functions by name", () => {
-        const fn1 = vi.fn().mockImplementation(() => () => "result");
-        const fn2 = vi.fn().mockImplementation(() => () => "result");
-        tree.instance.getItemInstance("x1").getMemoizedProp("fn", fn1, [1])(1);
-        tree.instance.getItemInstance("x1").getMemoizedProp("fn", fn1, [1])(1);
-        tree.instance.getItemInstance("x1").getMemoizedProp("fn2", fn2, [1])(1);
-        expect(fn1).toBeCalledTimes(1);
-        expect(fn2).toBeCalledTimes(1);
-      });
-    });
-
     describe("hotkeys", () => {
       it("focuses next item", () => {
         const setFocusedItem = tree.mockedHandler("setFocusedItem");

package/src/features/tree/types.ts

@@ -33,11 +33,6 @@ export type TreeFeatureDef<T> = {
     /** @internal */
     getItemsMeta: () => ItemMeta[];
 
-    expandItem: (itemId: string) => void;
-    collapseItem: (itemId: string) => void;
-    isItemExpanded: (itemId: string) => boolean;
-
-    focusItem: (itemId: string) => void;
     getFocusedItem: () => ItemInstance<any>;
     focusNextItem: () => void;
     focusPreviousItem: () => void;
@@ -65,7 +60,6 @@ export type TreeFeatureDef<T> = {
     getTree: () => TreeInstance<T>;
     getItemAbove: () => ItemInstance<T> | undefined;
     getItemBelow: () => ItemInstance<T> | undefined;
-    getMemoizedProp: <X>(name: string, create: () => X, deps?: any[]) => X;
     scrollTo: (
       scrollIntoViewArg?: boolean | ScrollIntoViewOptions,
     ) => Promise<void>;

package/src/index.ts

@@ -11,6 +11,7 @@ export * from "./features/hotkeys-core/types";
 export * from "./features/search/types";
 export * from "./features/renaming/types";
 export * from "./features/expand-all/types";
+export * from "./features/prop-memoization/types";
 
 export * from "./features/selection/feature";
 export * from "./features/hotkeys-core/feature";
@@ -20,6 +21,7 @@ export * from "./features/drag-and-drop/feature";
 export * from "./features/search/feature";
 export * from "./features/renaming/feature";
 export * from "./features/expand-all/feature";
+export * from "./features/prop-memoization/feature";
 
 export * from "./utilities/create-on-drop-handler";
 export * from "./utilities/insert-items-at-target";

package/src/mddocs-entry.ts

@@ -8,6 +8,7 @@ import { SearchFeatureDef } from "./features/search/types";
 import { SelectionFeatureDef } from "./features/selection/types";
 import { SyncDataLoaderFeatureDef } from "./features/sync-data-loader/types";
 import { TreeFeatureDef } from "./features/tree/types";
+import { PropMemoizationFeatureDef } from "./features/prop-memoization/types";
 
 export * from ".";
 
@@ -80,6 +81,18 @@ export type MainFeatureTreeInstance = MainFeatureDef["treeInstance"];
 export type MainFeatureItemInstance = MainFeatureDef["itemInstance"];
 export type MainFeatureHotkeys = MainFeatureDef["hotkeys"];
 
+/** @interface */
+export type PropMemoizationConfig = PropMemoizationFeatureDef["config"];
+/** @interface */
+export type PropMemoizationState = PropMemoizationFeatureDef["state"];
+/** @interface */
+export type PropMemoizationTreeInstance =
+  PropMemoizationFeatureDef["treeInstance"];
+/** @interface */
+export type PropMemoizationItemInstance =
+  PropMemoizationFeatureDef["itemInstance"];
+export type PropMemoizationHotkeys = PropMemoizationFeatureDef["hotkeys"];
+
 /** @interface */
 export type RenamingFeatureConfig<T> = RenamingFeatureDef<T>["config"];
 /** @interface */

package/src/test-utils/test-tree-expect.ts

@@ -73,7 +73,7 @@ export class TestTreeExpect<T> {
     expect(this.tree.instance.getDragLineData()).toEqual({
       indent,
       left: indent * 20,
-      right: 100,
+      width: 100 - indent * 20,
       top: 0,
     });
     expect(this.tree.instance.getDragLineStyle(0, 0)).toEqual({

package/src/test-utils/test-tree.ts

@@ -183,11 +183,21 @@ export class TestTree<T = string> {
     itemId: string,
     bb: Partial<DOMRect> = {
       left: 0,
-      right: 100,
+      width: 100,
       top: 0,
       height: 20,
     },
   ) {
+    this.instance.registerElement({
+      getBoundingClientRect: () =>
+        ({
+          left: 0,
+          width: 100,
+          top: 0,
+          height: 10000,
+        }) as DOMRect,
+    } as HTMLElement);
+
     this.instance.getItemInstance(itemId).registerElement({
       getBoundingClientRect: () => bb as DOMRect,
     } as HTMLElement);

package/src/types/core.ts

@@ -11,17 +11,16 @@ import { AsyncDataLoaderFeatureDef } from "../features/async-data-loader/types";
 import { SearchFeatureDef } from "../features/search/types";
 import { RenamingFeatureDef } from "../features/renaming/types";
 import { ExpandAllFeatureDef } from "../features/expand-all/types";
+import { PropMemoizationFeatureDef } from "../features/prop-memoization/types";
 
 export type Updater<T> = T | ((old: T) => T);
 export type SetStateFn<T> = (updaterOrValue: Updater<T>) => void;
 
-type FunctionMap = Record<string, (...args: any[]) => any>;
-
 export type FeatureDef = {
   state: any;
   config: any;
-  treeInstance: FunctionMap;
-  itemInstance: FunctionMap;
+  treeInstance: any;
+  itemInstance: any;
   hotkeys: string;
 };
 
@@ -39,20 +38,6 @@ type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (
   ? R
   : never;
 
-export type DefaultFeatures<T> = MainFeatureDef | TreeFeatureDef<T>;
-
-export type FeatureDefs<T> =
-  | MainFeatureDef
-  | TreeFeatureDef<T>
-  | SelectionFeatureDef<T>
-  | DragAndDropFeatureDef<T>
-  | HotkeysCoreFeatureDef<T>
-  | SyncDataLoaderFeatureDef<T>
-  | AsyncDataLoaderFeatureDef<T>
-  | SearchFeatureDef<T>
-  | RenamingFeatureDef<T>
-  | ExpandAllFeatureDef;
-
 type MergedFeatures<F extends FeatureDef> = {
   // type can't be removed because it's used for individual feature sets as feature deps in feature implementations
   // to my future self, yes I'm already aware this sounds dumb when I first write this
@@ -63,181 +48,105 @@ type MergedFeatures<F extends FeatureDef> = {
   hotkeys: F["hotkeys"];
 };
 
-type TreeStateType<T> = MainFeatureDef["state"] &
-  TreeFeatureDef<T>["state"] &
-  SelectionFeatureDef<T>["state"] &
-  DragAndDropFeatureDef<T>["state"] &
-  HotkeysCoreFeatureDef<T>["state"] &
-  SyncDataLoaderFeatureDef<T>["state"] &
-  AsyncDataLoaderFeatureDef<T>["state"] &
-  SearchFeatureDef<T>["state"] &
-  RenamingFeatureDef<T>["state"] &
-  ExpandAllFeatureDef["state"];
+export type RegisteredFeatures<T> =
+  | MainFeatureDef<T>
+  | TreeFeatureDef<T>
+  | SelectionFeatureDef<T>
+  | DragAndDropFeatureDef<T>
+  | HotkeysCoreFeatureDef<T>
+  | SyncDataLoaderFeatureDef<T>
+  | AsyncDataLoaderFeatureDef<T>
+  | SearchFeatureDef<T>
+  | RenamingFeatureDef<T>
+  | ExpandAllFeatureDef
+  | PropMemoizationFeatureDef;
+
+type TreeStateType<T> = MergedFeatures<RegisteredFeatures<T>>["state"];
 export interface TreeState<T> extends TreeStateType<T> {}
 
-type TreeConfigType<T> = MainFeatureDef["config"] &
-  TreeFeatureDef<T>["config"] &
-  SelectionFeatureDef<T>["config"] &
-  DragAndDropFeatureDef<T>["config"] &
-  HotkeysCoreFeatureDef<T>["config"] &
-  SyncDataLoaderFeatureDef<T>["config"] &
-  AsyncDataLoaderFeatureDef<T>["config"] &
-  SearchFeatureDef<T>["config"] &
-  RenamingFeatureDef<T>["config"] &
-  ExpandAllFeatureDef["config"];
+type TreeConfigType<T> = MergedFeatures<RegisteredFeatures<T>>["config"];
 export interface TreeConfig<T> extends TreeConfigType<T> {}
 
-type TreeInstanceType<T> = MainFeatureDef["treeInstance"] &
-  TreeFeatureDef<T>["treeInstance"] &
-  SelectionFeatureDef<T>["treeInstance"] &
-  DragAndDropFeatureDef<T>["treeInstance"] &
-  HotkeysCoreFeatureDef<T>["treeInstance"] &
-  SyncDataLoaderFeatureDef<T>["treeInstance"] &
-  AsyncDataLoaderFeatureDef<T>["treeInstance"] &
-  SearchFeatureDef<T>["treeInstance"] &
-  RenamingFeatureDef<T>["treeInstance"] &
-  ExpandAllFeatureDef["treeInstance"];
+type TreeInstanceType<T> = MergedFeatures<
+  RegisteredFeatures<T>
+>["treeInstance"];
 export interface TreeInstance<T> extends TreeInstanceType<T> {}
 
-type ItemInstanceType<T> = MainFeatureDef["itemInstance"] &
-  TreeFeatureDef<T>["itemInstance"] &
-  SelectionFeatureDef<T>["itemInstance"] &
-  DragAndDropFeatureDef<T>["itemInstance"] &
-  HotkeysCoreFeatureDef<T>["itemInstance"] &
-  SyncDataLoaderFeatureDef<T>["itemInstance"] &
-  AsyncDataLoaderFeatureDef<T>["itemInstance"] &
-  SearchFeatureDef<T>["itemInstance"] &
-  RenamingFeatureDef<T>["itemInstance"] &
-  ExpandAllFeatureDef["itemInstance"];
+type ItemInstanceType<T> = MergedFeatures<
+  RegisteredFeatures<T>
+>["itemInstance"];
 export interface ItemInstance<T> extends ItemInstanceType<T> {}
 
-export type HotkeyName<F extends FeatureDef = FeatureDefs<any>> =
-  MergedFeatures<F>["hotkeys"];
+export type HotkeyName = MergedFeatures<RegisteredFeatures<any>>["hotkeys"];
 
-export type HotkeysConfig<T, F extends FeatureDef = FeatureDefs<T>> = Record<
-  HotkeyName<F>,
-  HotkeyConfig<T>
->;
+export type HotkeysConfig<T> = Record<HotkeyName, HotkeyConfig<T>>;
 
-export type CustomHotkeysConfig<
-  T,
-  F extends FeatureDef = FeatureDefs<T>,
-> = Partial<
-  Record<HotkeyName<F> | `custom${string}`, Partial<HotkeyConfig<T>>>
+export type CustomHotkeysConfig<T> = Partial<
+  Record<HotkeyName | `custom${string}`, Partial<HotkeyConfig<T>>>
 >;
 
 type MayReturnNull<T extends (...x: any[]) => any> = (
   ...args: Parameters<T>
 ) => ReturnType<T> | null;
 
-export type ItemInstanceOpts<
-  ItemInstance extends FunctionMap = FunctionMap,
-  TreeInstance extends FunctionMap = FunctionMap,
-  Key extends keyof ItemInstance = any,
-> = {
-  item: ItemInstance;
-  tree: TreeInstance;
+export type ItemInstanceOpts<Key extends keyof ItemInstance<any>> = {
+  item: ItemInstance<any>;
+  tree: TreeInstance<any>;
   itemId: string;
-  prev?: MayReturnNull<ItemInstance[Key]>;
+  prev?: MayReturnNull<ItemInstance<any>[Key]>;
 };
 
-export type TreeInstanceOpts<
-  TreeInstance extends FunctionMap = FunctionMap,
-  Key extends keyof TreeInstance = any,
-> = {
-  tree: TreeInstance;
-  prev?: MayReturnNull<TreeInstance[Key]>;
+export type TreeInstanceOpts<Key extends keyof TreeInstance<any>> = {
+  tree: TreeInstance<any>;
+  prev?: MayReturnNull<TreeInstance<any>[Key]>;
 };
 
-export type FeatureImplementation<
-  T = any,
-  SelfFeatureDef extends FeatureDef = any,
-  DepFeaturesDef extends FeatureDef = any,
-  // /** @internal */
-  // AllFeatures extends FeatureDef = MergedFeatures<
-  //   DepFeaturesDef | SelfFeatureDef
-  // >,
-  // /** @internal */
-  // DepFeatures extends FeatureDef = MergedFeatures<DepFeaturesDef>,
-> = {
+export type FeatureImplementation<T = any> = {
   key?: string;
   deps?: string[];
   overwrites?: string[];
 
-  stateHandlerNames?: Partial<
-    Record<
-      keyof MergedFeatures<DepFeaturesDef>["state"],
-      keyof MergedFeatures<DepFeaturesDef>["config"]
-    >
-  >;
+  stateHandlerNames?: Partial<Record<keyof TreeState<T>, keyof TreeConfig<T>>>;
 
   getInitialState?: (
-    initialState: Partial<MergedFeatures<DepFeaturesDef>["state"]>,
-    tree: MergedFeatures<DepFeaturesDef>["treeInstance"],
-  ) => Partial<
-    SelfFeatureDef["state"] & MergedFeatures<DepFeaturesDef>["state"]
-  >;
+    initialState: Partial<TreeState<T>>,
+    tree: TreeInstance<T>,
+  ) => Partial<TreeState<T>>;
 
   getDefaultConfig?: (
-    defaultConfig: Partial<MergedFeatures<DepFeaturesDef>["config"]>,
-    tree: MergedFeatures<DepFeaturesDef>["treeInstance"],
-  ) => Partial<
-    SelfFeatureDef["config"] & MergedFeatures<DepFeaturesDef>["config"]
-  >;
+    defaultConfig: Partial<TreeConfig<T>>,
+    tree: TreeInstance<T>,
+  ) => Partial<TreeConfig<T>>;
 
   treeInstance?: {
-    [key in keyof (SelfFeatureDef["treeInstance"] &
-      MergedFeatures<DepFeaturesDef>["treeInstance"])]?: (
-      opts: TreeInstanceOpts<
-        SelfFeatureDef["treeInstance"] &
-          MergedFeatures<DepFeaturesDef>["treeInstance"],
-        key
-      >,
-      ...args: Parameters<
-        (SelfFeatureDef["treeInstance"] &
-          MergedFeatures<DepFeaturesDef>["treeInstance"])[key]
-      >
+    [key in keyof TreeInstance<T>]?: (
+      opts: TreeInstanceOpts<key>,
+      ...args: Parameters<TreeInstance<T>[key]>
     ) => void;
   };
 
   itemInstance?: {
-    [key in keyof (SelfFeatureDef["itemInstance"] &
-      MergedFeatures<DepFeaturesDef>["itemInstance"])]?: (
-      opts: ItemInstanceOpts<
-        SelfFeatureDef["itemInstance"] &
-          MergedFeatures<DepFeaturesDef>["itemInstance"],
-        SelfFeatureDef["treeInstance"] &
-          MergedFeatures<DepFeaturesDef>["treeInstance"],
-        key
-      >,
-      ...args: Parameters<
-        (SelfFeatureDef["itemInstance"] &
-          MergedFeatures<DepFeaturesDef>["itemInstance"])[key]
-      >
+    [key in keyof ItemInstance<T>]?: (
+      opts: ItemInstanceOpts<key>,
+      ...args: Parameters<ItemInstance<T>[key]>
     ) => void;
   };
 
-  onTreeMount?: (
-    instance: MergedFeatures<DepFeaturesDef>["treeInstance"],
-    treeElement: HTMLElement,
-  ) => void;
+  onTreeMount?: (instance: TreeInstance<T>, treeElement: HTMLElement) => void;
 
-  onTreeUnmount?: (
-    instance: MergedFeatures<DepFeaturesDef>["treeInstance"],
-    treeElement: HTMLElement,
-  ) => void;
+  onTreeUnmount?: (instance: TreeInstance<T>, treeElement: HTMLElement) => void;
 
   onItemMount?: (
-    instance: MergedFeatures<DepFeaturesDef>["itemInstance"],
+    instance: ItemInstance<T>,
     itemElement: HTMLElement,
-    tree: MergedFeatures<DepFeaturesDef>["treeInstance"],
+    tree: TreeInstance<T>,
   ) => void;
 
   onItemUnmount?: (
-    instance: MergedFeatures<DepFeaturesDef>["itemInstance"],
+    instance: ItemInstance<T>,
     itemElement: HTMLElement,
-    tree: MergedFeatures<DepFeaturesDef>["treeInstance"],
+    tree: TreeInstance<T>,
   ) => void;
 
-  hotkeys?: HotkeysConfig<T, SelfFeatureDef>;
+  hotkeys?: Partial<HotkeysConfig<T>>;
 };