@headless-tree/core 0.0.10 → 0.0.12

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

@@ -0,0 +1,136 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import { DragEvent } from "react";
+import { Mock, expect, vi } from "vitest";
+import { TestTree } from "./test-tree";
+import { HotkeyName } from "../types/core";
+import { HotkeyConfig } from "../features/hotkeys-core/types";
+
+export class TestTreeDo<T> {
+  protected itemInstance(itemId: string) {
+    return this.tree.instance.getItemInstance(itemId);
+  }
+
+  protected itemProps(itemId: string) {
+    return this.itemInstance(itemId).getProps();
+  }
+
+  constructor(protected tree: TestTree<T>) {}
+
+  selectItem(id: string) {
+    this.itemProps(id).onClick({});
+  }
+
+  shiftSelectItem(id: string) {
+    this.itemProps(id).onClick({ shiftKey: true });
+  }
+
+  ctrlSelectItem(id: string) {
+    this.itemProps(id).onClick({ ctrlKey: true });
+  }
+
+  ctrlShiftSelectItem(id: string) {
+    this.itemProps(id).onClick({ shiftKey: true, ctrlKey: true });
+  }
+
+  selectMultiple(...ids: string[]) {
+    ids.forEach((id) => this.ctrlSelectItem(id));
+  }
+
+  hotkey(hotkey: HotkeyName, e: Partial<KeyboardEvent> = {}) {
+    const hotkeyConfig: HotkeyConfig<any> = {
+      ...this.tree.instance.getHotkeyPresets()[hotkey],
+      ...this.tree.instance.getConfig().hotkeys?.[hotkey],
+    };
+    if (
+      hotkeyConfig.isEnabled &&
+      !hotkeyConfig.isEnabled?.(this.tree.instance)
+    ) {
+      throw new Error(`Hotkey "${hotkey}" is disabled`);
+    }
+    if (!hotkeyConfig.handler) {
+      throw new Error(`Hotkey "${hotkey}" has no handler`);
+    }
+    hotkeyConfig.handler(
+      {
+        ...e,
+        stopPropagation: () => {},
+        preventDefault: () => {},
+      } as any,
+      this.tree.instance,
+    );
+  }
+
+  startDrag(itemId: string, event?: DragEvent) {
+    if (!this.itemProps(itemId).draggable) {
+      throw new Error(
+        `Can't drag item ${itemId}, has attribute draggable=false`,
+      );
+    }
+
+    const e = event ?? TestTree.dragEvent();
+    this.itemProps(itemId).onDragStart(e);
+    return e;
+  }
+
+  dragOver(itemId: string, event?: DragEvent) {
+    const e = event ?? TestTree.dragEvent();
+    (e.preventDefault as Mock).mockClear();
+    this.itemProps(itemId).onDragOver(e);
+    this.itemProps(itemId).onDragOver(e);
+    this.itemProps(itemId).onDragOver(e);
+    expect(e.preventDefault).toBeCalledTimes(3);
+
+    this.consistentCalls(e.preventDefault);
+    this.consistentCalls(e.stopPropagation);
+    return e;
+  }
+
+  dragOverNotAllowed(itemId: string, event?: DragEvent) {
+    const e = event ?? TestTree.dragEvent();
+    (e.preventDefault as Mock).mockClear();
+    this.itemProps(itemId).onDragOver(e);
+    this.itemProps(itemId).onDragOver(e);
+    this.itemProps(itemId).onDragOver(e);
+    expect(e.preventDefault).toBeCalledTimes(0);
+
+    this.consistentCalls(e.preventDefault);
+    this.consistentCalls(e.stopPropagation);
+    return e;
+  }
+
+  dragLeave(itemId: string) {
+    this.itemProps(itemId).onDragLeave({});
+  }
+
+  dragEnd(itemId: string, event?: DragEvent) {
+    const e = event ?? TestTree.dragEvent();
+    this.itemProps(itemId).onDragEnd(e);
+    return e;
+  }
+
+  drop(itemId: string, event?: DragEvent) {
+    const e = event ?? TestTree.dragEvent();
+    this.itemProps(itemId).onDrop(e);
+    return e;
+  }
+
+  dragOverAndDrop(itemId: string, event?: DragEvent) {
+    const e = event ?? TestTree.dragEvent();
+    this.dragOver(itemId, e);
+    return this.drop(itemId, e);
+  }
+
+  private consistentCalls(fn: any) {
+    if (!vi.isMockFunction(fn)) {
+      throw new Error("fn is not a mock");
+    }
+    expect(
+      fn.mock.calls.length,
+      "function called inconsistent times",
+    ).toBeOneOf([0, 3]);
+    expect(
+      new Set(fn.mock.calls.map((call) => call.join("__"))).size,
+      "function called with inconsistent parameters",
+    ).toBeOneOf([0, 1]);
+  }
+}

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

@@ -0,0 +1,86 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import { Mock, expect } from "vitest";
+import { DragEvent } from "react";
+import { TestTree } from "./test-tree";
+import { DropTarget } from "../features/drag-and-drop/types";
+
+export class TestTreeExpect<T> {
+  protected itemInstance(itemId: string) {
+    return this.tree.instance.getItemInstance(itemId);
+  }
+
+  protected itemProps(itemId: string) {
+    return this.itemInstance(itemId).getProps();
+  }
+
+  constructor(private tree: TestTree<T>) {}
+
+  foldersExpanded(...itemIds: string[]) {
+    for (const itemId of itemIds) {
+      expect(
+        this.tree.instance.getItemInstance(itemId).isExpanded(),
+        `Expected ${itemId} to be expanded`,
+      ).toBe(true);
+    }
+  }
+
+  foldersCollapsed(...itemIds: string[]) {
+    for (const itemId of itemIds) {
+      expect(
+        this.tree.instance.getItemInstance(itemId).isExpanded(),
+        `Expected ${itemId} to be collapsed`,
+      ).toBe(false);
+    }
+  }
+
+  hasChildren(itemId: string, children: string[]) {
+    const item = this.tree.instance.getItemInstance(itemId);
+    const itemChildren = item.getChildren().map((child) => child.getId());
+    expect(itemChildren).toEqual(children);
+  }
+
+  dropped(draggedItems: string[], target: DropTarget<any>) {
+    expect(this.tree.instance.getConfig().onDrop).toBeCalledWith(
+      draggedItems.map((id) => this.tree.item(id)),
+      target,
+    );
+  }
+
+  dragOverNotAllowed(itemId: string, event?: DragEvent) {
+    const e = event ?? TestTree.dragEvent();
+    (e.preventDefault as Mock).mockClear();
+    this.itemProps(itemId).onDragOver(e);
+    this.itemProps(itemId).onDragOver(e);
+    this.itemProps(itemId).onDragOver(e);
+    expect(
+      e.preventDefault,
+      "onDragOver shouldn't call e.preventDefault if drag is not allowed",
+    ).not.toBeCalled();
+
+    this.itemProps(itemId).onDrop(e);
+    expect(
+      e.preventDefault,
+      "onDrop shouldn't call e.preventDefault if drag is not allowed",
+    ).not.toBeCalled();
+    expect(
+      this.tree.instance.getConfig().onDrop,
+      "onDrop handler shouldn't be called if drag is not allowed",
+    ).not.toBeCalled();
+    return e;
+  }
+
+  defaultDragLineProps(indent = 0) {
+    expect(this.tree.instance.getDragLineData()).toEqual({
+      indent,
+      left: indent * 20,
+      width: 100 - indent * 20,
+      top: 0,
+    });
+    expect(this.tree.instance.getDragLineStyle(0, 0)).toEqual({
+      left: `${indent * 20}px`,
+      pointerEvents: "none",
+      top: "0px",
+      width: `${100 - indent * 20}px`,
+    });
+  }
+}

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

@@ -0,0 +1,227 @@
+/* eslint-disable import/no-extraneous-dependencies */
+import { beforeEach, describe, vi } from "vitest";
+import { DragEvent } from "react";
+import { TreeConfig, TreeInstance } from "../types/core";
+import { createTree } from "../core/create-tree";
+import { TestTreeDo } from "./test-tree-do";
+import { TestTreeExpect } from "./test-tree-expect";
+import { syncDataLoaderFeature } from "../features/sync-data-loader/feature";
+import { asyncDataLoaderFeature } from "../features/async-data-loader/feature";
+import { buildProxiedInstance } from "../core/build-proxified-instance";
+
+vi.useFakeTimers({ shouldAdvanceTime: true });
+
+export class TestTree<T = string> {
+  public readonly do = new TestTreeDo(this);
+
+  public readonly expect = new TestTreeExpect(this);
+
+  private treeInstance: TreeInstance<T> | null = null;
+
+  private static asyncLoaderResolvers: (() => void)[] = [];
+
+  suits = {
+    sync: () => ({
+      tree: this.withFeatures(syncDataLoaderFeature),
+      title: "Synchronous Data Loader",
+    }),
+    async: () => ({
+      tree: this.withFeatures(asyncDataLoaderFeature),
+      title: "Asynchronous Data Loader",
+    }),
+    proxifiedSync: () => ({
+      tree: this.withFeatures(syncDataLoaderFeature).with({
+        instanceBuilder: buildProxiedInstance,
+      }),
+      title: "Proxified Synchronous Data Loader",
+    }),
+    proxifiedAsync: () => ({
+      tree: this.withFeatures(asyncDataLoaderFeature).with({
+        instanceBuilder: buildProxiedInstance,
+      }),
+      title: "Proxified Asynchronous Data Loader",
+    }),
+  };
+
+  forSuits(runSuite: (tree: TestTree<T>) => void) {
+    describe.for([
+      this.suits.sync(),
+      this.suits.async(),
+      this.suits.proxifiedSync(),
+      this.suits.proxifiedAsync(),
+    ])("$title", ({ tree }) => {
+      tree.resetBeforeEach();
+      runSuite(tree);
+    });
+  }
+
+  get instance() {
+    if (!this.treeInstance) {
+      this.treeInstance = createTree(this.config);
+    }
+    return this.treeInstance;
+  }
+
+  private constructor(private config: TreeConfig<T>) {}
+
+  static async resolveAsyncLoaders() {
+    while (TestTree.asyncLoaderResolvers.length) {
+      TestTree.asyncLoaderResolvers.shift()?.();
+      await new Promise<void>((r) => {
+        setTimeout(r);
+      });
+    }
+  }
+
+  async resolveAsyncVisibleItems() {
+    this.instance.getItems();
+    await TestTree.resolveAsyncLoaders();
+    this.instance.getItems().forEach((i) => i.getItemName());
+    await TestTree.resolveAsyncLoaders();
+  }
+
+  static default(config: Partial<TreeConfig<string>>) {
+    return new TestTree({
+      rootItemId: "x",
+      createLoadingItemData: () => "loading",
+      dataLoader: {
+        getItem: (id) => id,
+        getChildren: (id) => [`${id}1`, `${id}2`, `${id}3`, `${id}4`],
+      },
+      asyncDataLoader: {
+        getItem: async (id) => {
+          await new Promise<void>((r) => {
+            (r as any).debugName = `Loading getItem ${id}`;
+            TestTree.asyncLoaderResolvers.push(r);
+          });
+          return id;
+        },
+        getChildren: async (id) => {
+          await new Promise<void>((r) => {
+            (r as any).debugName = `Loading getChildren ${id}`;
+            TestTree.asyncLoaderResolvers.push(r);
+          });
+          return [`${id}1`, `${id}2`, `${id}3`, `${id}4`];
+        },
+      },
+      getItemName: (item) => item.getItemData(),
+      indent: 20,
+      isItemFolder: (item) => item.getItemMeta().level < 2,
+      initialState: {
+        expandedItems: ["x1", "x11"],
+      },
+      features: [],
+      ...config,
+    });
+  }
+
+  with(config: Partial<TreeConfig<T>>) {
+    return new TestTree({ ...this.config, ...config });
+  }
+
+  resetBeforeEach() {
+    beforeEach(async () => {
+      await this.createTestCaseTree();
+    });
+  }
+
+  async createTestCaseTree() {
+    this.reset();
+    vi.clearAllMocks();
+    // trigger instance creation
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+    this.instance;
+    await this.resolveAsyncVisibleItems();
+    return this;
+  }
+
+  withFeatures(...features: any) {
+    return this.with({
+      features: [...(this.config.features ?? []), ...features],
+    });
+  }
+
+  mockedHandler(handlerName: keyof TreeConfig<T>) {
+    const mock = vi.fn();
+    if (this.treeInstance) {
+      this.treeInstance?.setConfig((prev) => ({
+        ...prev,
+        [handlerName as any]: mock,
+      }));
+    } else {
+      (this.config as any)[handlerName as any] = mock;
+    }
+    return mock;
+  }
+
+  item(itemId: string) {
+    return this.instance.getItemInstance(itemId);
+  }
+
+  reset() {
+    this.treeInstance = null;
+    TestTree.asyncLoaderResolvers = [];
+  }
+
+  debug() {
+    console.log(
+      this.instance
+        .getItems()
+        .map((item) =>
+          [
+            "  ".repeat(item.getItemMeta().level),
+            '"',
+            item.getItemName(),
+            '"',
+          ].join(""),
+        )
+        .join("\n"),
+    );
+  }
+
+  setElementBoundingBox(
+    itemId: string,
+    bb: Partial<DOMRect> = {
+      left: 0,
+      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);
+  }
+
+  static dragEvent(pageX = 1000, pageY = 0) {
+    return {
+      preventDefault: vi.fn(),
+      stopPropagation: vi.fn(),
+      dataTransfer: {
+        setData: vi.fn(),
+        getData: vi.fn(),
+        dropEffect: "unchaged-from-test",
+      },
+      pageX,
+      pageY,
+    } as unknown as DragEvent;
+  }
+
+  createTopDragEvent(indent = 0) {
+    return TestTree.dragEvent(indent * 20, 1);
+  }
+
+  createBottomDragEvent(indent = 0) {
+    return TestTree.dragEvent(indent * 20, 19);
+  }
+}

package/src/types/core.ts

@@ -11,15 +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;
 
 export type FeatureDef = {
-  state: object;
-  config: object;
-  treeInstance: object;
-  itemInstance: object;
+  state: any;
+  config: any;
+  treeInstance: any;
+  itemInstance: any;
   hotkeys: string;
 };
 
@@ -37,10 +38,18 @@ type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (
   ? R
   : never;
 
-export type DefaultFeatures<T> = MainFeatureDef | TreeFeatureDef<T>;
+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
+  state: UnionToIntersection<F["state"]>;
+  config: UnionToIntersection<F["config"]>;
+  treeInstance: UnionToIntersection<F["treeInstance"]>;
+  itemInstance: UnionToIntersection<F["itemInstance"]>;
+  hotkeys: F["hotkeys"];
+};
 
-export type FeatureDefs<T> =
-  | MainFeatureDef
+export type RegisteredFeatures<T> =
+  | MainFeatureDef<T>
   | TreeFeatureDef<T>
   | SelectionFeatureDef<T>
   | DragAndDropFeatureDef<T>
@@ -49,136 +58,95 @@ export type FeatureDefs<T> =
   | AsyncDataLoaderFeatureDef<T>
   | SearchFeatureDef<T>
   | RenamingFeatureDef<T>
-  | ExpandAllFeatureDef;
-
-type MergedFeatures<F extends FeatureDef> = {
-  // TODO remove in favor of types below
-  state: UnionToIntersection<F["state"]>;
-  config: UnionToIntersection<F["config"]>;
-  treeInstance: UnionToIntersection<F["treeInstance"]>;
-  itemInstance: UnionToIntersection<F["itemInstance"]>;
-  hotkeys: F["hotkeys"];
-};
+  | ExpandAllFeatureDef
+  | PropMemoizationFeatureDef;
 
-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"];
+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>>>
 >;
 
-export type FeatureImplementation<
-  T = any,
-  D extends FeatureDef = any,
-  F extends FeatureDef = EmptyFeatureDef,
-> = {
+type MayReturnNull<T extends (...x: any[]) => any> = (
+  ...args: Parameters<T>
+) => ReturnType<T> | null;
+
+export type ItemInstanceOpts<Key extends keyof ItemInstance<any>> = {
+  item: ItemInstance<any>;
+  tree: TreeInstance<any>;
+  itemId: string;
+  prev?: MayReturnNull<ItemInstance<any>[Key]>;
+};
+
+export type TreeInstanceOpts<Key extends keyof TreeInstance<any>> = {
+  tree: TreeInstance<any>;
+  prev?: MayReturnNull<TreeInstance<any>[Key]>;
+};
+
+export type FeatureImplementation<T = any> = {
   key?: string;
   deps?: string[];
   overwrites?: string[];
 
-  stateHandlerNames?: Partial<
-    Record<keyof MergedFeatures<F>["state"], keyof MergedFeatures<F>["config"]>
-  >;
+  stateHandlerNames?: Partial<Record<keyof TreeState<T>, keyof TreeConfig<T>>>;
 
   getInitialState?: (
-    initialState: Partial<MergedFeatures<F>["state"]>,
-    tree: MergedFeatures<F>["treeInstance"],
-  ) => Partial<D["state"] & MergedFeatures<F>["state"]>;
+    initialState: Partial<TreeState<T>>,
+    tree: TreeInstance<T>,
+  ) => Partial<TreeState<T>>;
 
   getDefaultConfig?: (
-    defaultConfig: Partial<MergedFeatures<F>["config"]>,
-    tree: MergedFeatures<F>["treeInstance"],
-  ) => Partial<D["config"] & MergedFeatures<F>["config"]>;
-
-  createTreeInstance?: (
-    prev: MergedFeatures<F>["treeInstance"],
-    instance: MergedFeatures<F>["treeInstance"],
-  ) => D["treeInstance"] & MergedFeatures<F>["treeInstance"];
-
-  createItemInstance?: (
-    prev: MergedFeatures<F>["itemInstance"],
-    item: MergedFeatures<F>["itemInstance"],
-    tree: MergedFeatures<F>["treeInstance"],
-    itemId: string,
-  ) => D["itemInstance"] & MergedFeatures<F>["itemInstance"];
-
-  onTreeMount?: (
-    instance: MergedFeatures<F>["treeInstance"],
-    treeElement: HTMLElement,
-  ) => void;
+    defaultConfig: Partial<TreeConfig<T>>,
+    tree: TreeInstance<T>,
+  ) => Partial<TreeConfig<T>>;
 
-  onTreeUnmount?: (
-    instance: MergedFeatures<F>["treeInstance"],
-    treeElement: HTMLElement,
-  ) => void;
+  treeInstance?: {
+    [key in keyof TreeInstance<T>]?: (
+      opts: TreeInstanceOpts<key>,
+      ...args: Parameters<TreeInstance<T>[key]>
+    ) => void;
+  };
+
+  itemInstance?: {
+    [key in keyof ItemInstance<T>]?: (
+      opts: ItemInstanceOpts<key>,
+      ...args: Parameters<ItemInstance<T>[key]>
+    ) => void;
+  };
+
+  onTreeMount?: (instance: TreeInstance<T>, treeElement: HTMLElement) => void;
+
+  onTreeUnmount?: (instance: TreeInstance<T>, treeElement: HTMLElement) => void;
 
   onItemMount?: (
-    instance: MergedFeatures<F>["itemInstance"],
+    instance: ItemInstance<T>,
     itemElement: HTMLElement,
-    tree: MergedFeatures<F>["treeInstance"],
+    tree: TreeInstance<T>,
   ) => void;
 
   onItemUnmount?: (
-    instance: MergedFeatures<F>["itemInstance"],
+    instance: ItemInstance<T>,
     itemElement: HTMLElement,
-    tree: MergedFeatures<F>["treeInstance"],
+    tree: TreeInstance<T>,
   ) => void;
 
-  hotkeys?: HotkeysConfig<T, D>;
+  hotkeys?: Partial<HotkeysConfig<T>>;
 };

package/src/utilities/errors.ts

@@ -0,0 +1,2 @@
+export const throwError = (message: string) =>
+  Error(`Headless Tree: ${message}`);