@headless-tree/core 0.0.11 → 0.0.12

package/lib/cjs/features/tree/feature.js

@@ -20,7 +20,6 @@ exports.treeFeature = {
         focusedItem: "setFocusedItem",
     },
     treeInstance: {
-        isItemExpanded: ({ tree }, itemId) => tree.getState().expandedItems.includes(itemId),
         getItemsMeta: ({ tree }) => {
             const { rootItemId } = tree.getConfig();
             const { expandedItems } = tree.getState();
@@ -52,44 +51,22 @@ exports.treeFeature = {
             }
             return flatItems;
         },
-        expandItem: ({ tree }, itemId) => {
-            var _a;
-            if (!tree.getItemInstance(itemId).isFolder()) {
-                return;
-            }
-            if ((_a = tree.getState().loadingItems) === null || _a === void 0 ? void 0 : _a.includes(itemId)) {
-                return;
-            }
-            tree.applySubStateUpdate("expandedItems", (expandedItems) => [
-                ...expandedItems,
-                itemId,
-            ]);
-            tree.rebuildTree();
-        },
-        collapseItem: ({ tree }, itemId) => {
-            if (!tree.getItemInstance(itemId).isFolder()) {
-                return;
-            }
-            tree.applySubStateUpdate("expandedItems", (expandedItems) => expandedItems.filter((id) => id !== itemId));
-            tree.rebuildTree();
-        },
         // TODO memo
         getFocusedItem: ({ tree }) => {
             var _a, _b;
             return ((_b = tree.getItemInstance((_a = tree.getState().focusedItem) !== null && _a !== void 0 ? _a : "")) !== null && _b !== void 0 ? _b : tree.getItems()[0]);
         },
-        focusItem: ({ tree }, itemId) => {
-            tree.applySubStateUpdate("focusedItem", itemId);
-        },
         focusNextItem: ({ tree }) => {
+            var _a;
             const { index } = tree.getFocusedItem().getItemMeta();
             const nextIndex = Math.min(index + 1, tree.getItems().length - 1);
-            tree.focusItem(tree.getItems()[nextIndex].getId());
+            (_a = tree.getItems()[nextIndex]) === null || _a === void 0 ? void 0 : _a.setFocused();
         },
         focusPreviousItem: ({ tree }) => {
+            var _a;
             const { index } = tree.getFocusedItem().getItemMeta();
             const nextIndex = Math.max(index - 1, 0);
-            tree.focusItem(tree.getItems()[nextIndex].getId());
+            (_a = tree.getItems()[nextIndex]) === null || _a === void 0 ? void 0 : _a.setFocused();
         },
         updateDomFocus: ({ tree }) => {
             // Required because if the state is managed outside in react, the state only updated during next render
@@ -104,7 +81,8 @@ exports.treeFeature = {
                 focusedElement.focus();
             }));
         },
-        getContainerProps: ({ prev }) => (Object.assign(Object.assign({}, prev === null || prev === void 0 ? void 0 : prev()), { role: "tree", ariaLabel: "", ariaActivedescendant: "" })),
+        // TODO add label parameter
+        getContainerProps: ({ prev, tree }) => (Object.assign(Object.assign({}, prev === null || prev === void 0 ? void 0 : prev()), { role: "tree", "aria-label": "", ref: tree.registerElement })),
         // relevant for hotkeys of this feature
         isSearchOpen: () => false,
     },
@@ -115,10 +93,10 @@ exports.treeFeature = {
             yield (0, utils_1.poll)(() => item.getElement() !== null, 20);
             (_d = item.getElement()) === null || _d === void 0 ? void 0 : _d.scrollIntoView(scrollIntoViewArg);
         }),
-        getId: ({ item }) => item.getItemMeta().itemId,
+        getId: ({ itemId }) => itemId,
         getProps: ({ item, prev }) => {
             const itemMeta = item.getItemMeta();
-            return Object.assign(Object.assign({}, prev === null || prev === void 0 ? void 0 : prev()), { role: "treeitem", "aria-setsize": itemMeta.setSize, "aria-posinset": itemMeta.posInSet, "aria-selected": "false", "aria-label": item.getItemName(), "aria-level": itemMeta.level, tabIndex: item.isFocused() ? 0 : -1, onClick: item.getMemoizedProp("tree/onClick", () => (e) => {
+            return Object.assign(Object.assign({}, prev === null || prev === void 0 ? void 0 : prev()), { ref: item.registerElement, role: "treeitem", "aria-setsize": itemMeta.setSize, "aria-posinset": itemMeta.posInSet, "aria-selected": "false", "aria-label": item.getItemName(), "aria-level": itemMeta.level, tabIndex: item.isFocused() ? 0 : -1, onClick: (e) => {
                     item.setFocused();
                     item.primaryAction();
                     if (e.ctrlKey || e.shiftKey || e.metaKey) {
@@ -133,18 +111,37 @@ exports.treeFeature = {
                     else {
                         item.expand();
                     }
-                }) });
+                } });
+        },
+        expand: ({ tree, item, itemId }) => {
+            var _a;
+            if (!item.isFolder()) {
+                return;
+            }
+            if ((_a = tree.getState().loadingItems) === null || _a === void 0 ? void 0 : _a.includes(itemId)) {
+                return;
+            }
+            tree.applySubStateUpdate("expandedItems", (expandedItems) => [
+                ...expandedItems,
+                itemId,
+            ]);
+            tree.rebuildTree();
         },
-        expand: ({ tree, item }) => tree.expandItem(item.getItemMeta().itemId),
-        collapse: ({ tree, item }) => tree.collapseItem(item.getItemMeta().itemId),
-        getItemData: ({ tree, item }) => tree.retrieveItemData(item.getItemMeta().itemId),
+        collapse: ({ tree, item, itemId }) => {
+            if (!item.isFolder()) {
+                return;
+            }
+            tree.applySubStateUpdate("expandedItems", (expandedItems) => expandedItems.filter((id) => id !== itemId));
+            tree.rebuildTree();
+        },
+        getItemData: ({ tree, itemId }) => tree.retrieveItemData(itemId),
         equals: ({ item }, other) => item.getId() === (other === null || other === void 0 ? void 0 : other.getId()),
-        isExpanded: ({ tree, item }) => tree.getState().expandedItems.includes(item.getItemMeta().itemId),
+        isExpanded: ({ tree, itemId }) => tree.getState().expandedItems.includes(itemId),
         isDescendentOf: ({ item }, parentId) => {
             const parent = item.getParent();
             return Boolean((parent === null || parent === void 0 ? void 0 : parent.getId()) === parentId || (parent === null || parent === void 0 ? void 0 : parent.isDescendentOf(parentId)));
         },
-        isFocused: ({ tree, item }) => tree.getState().focusedItem === item.getItemMeta().itemId ||
+        isFocused: ({ tree, item, itemId }) => tree.getState().focusedItem === itemId ||
             (tree.getState().focusedItem === null && item.getItemMeta().index === 0),
         isFolder: ({ tree, item }) => item.getItemMeta().level === -1 ||
             tree.getConfig().isItemFolder(item),
@@ -152,12 +149,13 @@ exports.treeFeature = {
             const config = tree.getConfig();
             return config.getItemName(item);
         },
-        setFocused: ({ tree, item }) => tree.focusItem(item.getItemMeta().itemId),
+        setFocused: ({ tree, itemId }) => {
+            tree.applySubStateUpdate("focusedItem", itemId);
+        },
         primaryAction: ({ tree, item }) => { var _a, _b; return (_b = (_a = tree.getConfig()).onPrimaryAction) === null || _b === void 0 ? void 0 : _b.call(_a, item); },
         getParent: ({ tree, item }) => item.getItemMeta().parentId
             ? tree.getItemInstance(item.getItemMeta().parentId)
             : undefined,
-        // TODO remove
         getIndexInParent: ({ item }) => item.getItemMeta().posInSet,
         getChildren: ({ tree, item }) => tree
             .retrieveChildrenIds(item.getItemMeta().itemId)
@@ -165,23 +163,6 @@ exports.treeFeature = {
         getTree: ({ tree }) => tree,
         getItemAbove: ({ tree, item }) => tree.getItems()[item.getItemMeta().index - 1],
         getItemBelow: ({ tree, item }) => tree.getItems()[item.getItemMeta().index + 1],
-        getMemoizedProp: ({ item }, name, create, deps) => {
-            var _a, _b, _c, _d, _e;
-            var _f, _g;
-            const data = item.getDataRef();
-            const memoizedValue = (_a = data.current.memoizedValues) === null || _a === void 0 ? void 0 : _a[name];
-            if (memoizedValue &&
-                (!deps ||
-                    ((_c = (_b = data.current.memoizedDeps) === null || _b === void 0 ? void 0 : _b[name]) === null || _c === void 0 ? void 0 : _c.every((d, i) => d === deps[i])))) {
-                return memoizedValue;
-            }
-            (_d = (_f = data.current).memoizedDeps) !== null && _d !== void 0 ? _d : (_f.memoizedDeps = {});
-            (_e = (_g = data.current).memoizedValues) !== null && _e !== void 0 ? _e : (_g.memoizedValues = {});
-            const value = create();
-            data.current.memoizedDeps[name] = deps;
-            data.current.memoizedValues[name] = value;
-            return value;
-        },
     },
     hotkeys: {
         focusNextItem: {
@@ -237,14 +218,16 @@ exports.treeFeature = {
         focusFirstItem: {
             hotkey: "Home",
             handler: (e, tree) => {
-                tree.focusItem(tree.getItems()[0].getId());
+                var _a;
+                (_a = tree.getItems()[0]) === null || _a === void 0 ? void 0 : _a.setFocused();
                 tree.updateDomFocus();
             },
         },
         focusLastItem: {
             hotkey: "End",
             handler: (e, tree) => {
-                tree.focusItem(tree.getItems()[tree.getItems().length - 1].getId());
+                var _a;
+                (_a = tree.getItems()[tree.getItems().length - 1]) === null || _a === void 0 ? void 0 : _a.setFocused();
                 tree.updateDomFocus();
             },
         },

package/lib/cjs/features/tree/types.d.ts

@@ -27,10 +27,6 @@ export type TreeFeatureDef<T> = {
     treeInstance: {
         /** @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;
@@ -57,7 +53,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>;
     };
     hotkeys: "focusNextItem" | "focusPreviousItem" | "expandOrDown" | "collapseOrUp" | "focusFirstItem" | "focusLastItem";

package/lib/cjs/index.d.ts

@@ -10,6 +10,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";
 export * from "./features/async-data-loader/feature";
@@ -18,6 +19,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";
 export * from "./utilities/remove-items-from-parents";

package/lib/cjs/index.js

@@ -25,6 +25,7 @@ __exportStar(require("./features/hotkeys-core/types"), exports);
 __exportStar(require("./features/search/types"), exports);
 __exportStar(require("./features/renaming/types"), exports);
 __exportStar(require("./features/expand-all/types"), exports);
+__exportStar(require("./features/prop-memoization/types"), exports);
 __exportStar(require("./features/selection/feature"), exports);
 __exportStar(require("./features/hotkeys-core/feature"), exports);
 __exportStar(require("./features/async-data-loader/feature"), exports);
@@ -33,6 +34,7 @@ __exportStar(require("./features/drag-and-drop/feature"), exports);
 __exportStar(require("./features/search/feature"), exports);
 __exportStar(require("./features/renaming/feature"), exports);
 __exportStar(require("./features/expand-all/feature"), exports);
+__exportStar(require("./features/prop-memoization/feature"), exports);
 __exportStar(require("./utilities/create-on-drop-handler"), exports);
 __exportStar(require("./utilities/insert-items-at-target"), exports);
 __exportStar(require("./utilities/remove-items-from-parents"), exports);

package/lib/cjs/mddocs-entry.d.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 ".";
 /** @interface */
 export type AsyncDataLoaderFeatureConfig<T> = AsyncDataLoaderFeatureDef<T>["config"];
@@ -55,6 +56,15 @@ 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 */
 export type RenamingFeatureState<T> = RenamingFeatureDef<T>["state"];

package/lib/cjs/test-utils/test-tree-do.d.ts

@@ -3,7 +3,7 @@ import { TestTree } from "./test-tree";
 import { HotkeyName } from "../types/core";
 export declare class TestTreeDo<T> {
     protected tree: TestTree<T>;
-    protected itemInstance(itemId: string): import("../types/core").ItemInstance<any>;
+    protected itemInstance(itemId: string): import("../types/core").ItemInstance<T>;
     protected itemProps(itemId: string): Record<string, any>;
     constructor(tree: TestTree<T>);
     selectItem(id: string): void;

package/lib/cjs/test-utils/test-tree-expect.d.ts

@@ -3,7 +3,7 @@ import { TestTree } from "./test-tree";
 import { DropTarget } from "../features/drag-and-drop/types";
 export declare class TestTreeExpect<T> {
     private tree;
-    protected itemInstance(itemId: string): import("..").ItemInstance<any>;
+    protected itemInstance(itemId: string): import("..").ItemInstance<T>;
     protected itemProps(itemId: string): Record<string, any>;
     constructor(tree: TestTree<T>);
     foldersExpanded(...itemIds: string[]): void;

package/lib/cjs/test-utils/test-tree-expect.js

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

package/lib/cjs/test-utils/test-tree.d.ts

@@ -37,7 +37,7 @@ export declare class TestTree<T = string> {
     createTestCaseTree(): Promise<this>;
     withFeatures(...features: any): TestTree<T>;
     mockedHandler(handlerName: keyof TreeConfig<T>): import("vitest").Mock<(...args: any[]) => any>;
-    item(itemId: string): import("../types/core").ItemInstance<any>;
+    item(itemId: string): import("../types/core").ItemInstance<T>;
     reset(): void;
     debug(): void;
     setElementBoundingBox(itemId: string, bb?: Partial<DOMRect>): void;

package/lib/cjs/test-utils/test-tree.js

@@ -163,10 +163,18 @@ class TestTree {
     }
     setElementBoundingBox(itemId, bb = {
         left: 0,
-        right: 100,
+        width: 100,
         top: 0,
         height: 20,
     }) {
+        this.instance.registerElement({
+            getBoundingClientRect: () => ({
+                left: 0,
+                width: 100,
+                top: 0,
+                height: 10000,
+            }),
+        });
         this.instance.getItemInstance(itemId).registerElement({
             getBoundingClientRect: () => bb,
         });

package/lib/cjs/types/core.d.ts

@@ -8,14 +8,14 @@ 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;
 };
 export type EmptyFeatureDef = {
@@ -26,8 +26,6 @@ export type EmptyFeatureDef = {
     hotkeys: never;
 };
 type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? 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> = {
     state: UnionToIntersection<F["state"]>;
     config: UnionToIntersection<F["config"]>;
@@ -35,49 +33,50 @@ type MergedFeatures<F extends FeatureDef> = {
     itemInstance: UnionToIntersection<F["itemInstance"]>;
     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 HotkeysConfig<T, F extends FeatureDef = FeatureDefs<T>> = Record<HotkeyName<F>, HotkeyConfig<T>>;
-export type CustomHotkeysConfig<T, F extends FeatureDef = FeatureDefs<T>> = Partial<Record<HotkeyName<F> | `custom${string}`, Partial<HotkeyConfig<T>>>>;
+export type HotkeyName = MergedFeatures<RegisteredFeatures<any>>["hotkeys"];
+export type HotkeysConfig<T> = Record<HotkeyName, 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> = {
+export type FeatureImplementation<T = any> = {
     key?: string;
     deps?: string[];
     overwrites?: string[];
-    stateHandlerNames?: Partial<Record<keyof MergedFeatures<DepFeaturesDef>["state"], keyof MergedFeatures<DepFeaturesDef>["config"]>>;
-    getInitialState?: (initialState: Partial<MergedFeatures<DepFeaturesDef>["state"]>, tree: MergedFeatures<DepFeaturesDef>["treeInstance"]) => Partial<SelfFeatureDef["state"] & MergedFeatures<DepFeaturesDef>["state"]>;
-    getDefaultConfig?: (defaultConfig: Partial<MergedFeatures<DepFeaturesDef>["config"]>, tree: MergedFeatures<DepFeaturesDef>["treeInstance"]) => Partial<SelfFeatureDef["config"] & MergedFeatures<DepFeaturesDef>["config"]>;
+    stateHandlerNames?: Partial<Record<keyof TreeState<T>, keyof TreeConfig<T>>>;
+    getInitialState?: (initialState: Partial<TreeState<T>>, tree: TreeInstance<T>) => Partial<TreeState<T>>;
+    getDefaultConfig?: (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]>) => void;
+        [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]>) => void;
+        [key in keyof ItemInstance<T>]?: (opts: ItemInstanceOpts<key>, ...args: Parameters<ItemInstance<T>[key]>) => void;
     };
-    onTreeMount?: (instance: MergedFeatures<DepFeaturesDef>["treeInstance"], treeElement: HTMLElement) => void;
-    onTreeUnmount?: (instance: MergedFeatures<DepFeaturesDef>["treeInstance"], treeElement: HTMLElement) => void;
-    onItemMount?: (instance: MergedFeatures<DepFeaturesDef>["itemInstance"], itemElement: HTMLElement, tree: MergedFeatures<DepFeaturesDef>["treeInstance"]) => void;
-    onItemUnmount?: (instance: MergedFeatures<DepFeaturesDef>["itemInstance"], itemElement: HTMLElement, tree: MergedFeatures<DepFeaturesDef>["treeInstance"]) => void;
-    hotkeys?: HotkeysConfig<T, SelfFeatureDef>;
+    onTreeMount?: (instance: TreeInstance<T>, treeElement: HTMLElement) => void;
+    onTreeUnmount?: (instance: TreeInstance<T>, treeElement: HTMLElement) => void;
+    onItemMount?: (instance: ItemInstance<T>, itemElement: HTMLElement, tree: TreeInstance<T>) => void;
+    onItemUnmount?: (instance: ItemInstance<T>, itemElement: HTMLElement, tree: TreeInstance<T>) => void;
+    hotkeys?: Partial<HotkeysConfig<T>>;
 };
 export {};

package/lib/esm/core/build-static-instance.js

@@ -4,8 +4,7 @@ export const buildStaticInstance = (features, instanceType, buildOpts) => {
     const finalize = () => {
         const opts = buildOpts(instance);
         featureLoop: for (let i = 0; i < features.length; i++) {
-            // Loop goes in forward order, because later features overwrite previous ones
-            // TODO loop order correct? I think so...
+            // Loop goes in forward order, each features overwrite previous ones and wraps those in a prev() fn
             const definition = features[i][instanceType];
             if (!definition)
                 continue featureLoop;

package/lib/esm/core/create-tree.js

@@ -11,14 +11,17 @@ const verifyFeatures = (features) => {
         }
     }
 };
-const compareFeatures = (feature1, feature2) => {
-    var _a;
+const compareFeatures = (originalOrder) => (feature1, feature2) => {
+    var _a, _b;
     if (feature2.key && ((_a = feature1.overwrites) === null || _a === void 0 ? void 0 : _a.includes(feature2.key))) {
         return 1;
     }
-    return -1;
+    if (feature1.key && ((_b = feature2.overwrites) === null || _b === void 0 ? void 0 : _b.includes(feature1.key))) {
+        return -1;
+    }
+    return originalOrder.indexOf(feature1) - originalOrder.indexOf(feature2);
 };
-const sortFeatures = (features = []) => features.sort(compareFeatures);
+const sortFeatures = (features = []) => features.sort(compareFeatures(features));
 export const createTree = (initialConfig) => {
     var _a, _b, _c, _d;
     const buildInstance = (_a = initialConfig.instanceBuilder) !== null && _a !== void 0 ? _a : buildStaticInstance;

package/lib/esm/features/async-data-loader/feature.d.ts

@@ -1,5 +1,2 @@
 import { FeatureImplementation } from "../../types/core";
-import { AsyncDataLoaderFeatureDef } from "./types";
-import { MainFeatureDef } from "../main/types";
-import { TreeFeatureDef } from "../tree/types";
-export declare const asyncDataLoaderFeature: FeatureImplementation<any, AsyncDataLoaderFeatureDef<any>, MainFeatureDef | TreeFeatureDef<any> | AsyncDataLoaderFeatureDef<any>>;
+export declare const asyncDataLoaderFeature: FeatureImplementation;

package/lib/esm/features/async-data-loader/feature.js

@@ -73,23 +73,21 @@ export const asyncDataLoaderFeature = {
             }
             return [];
         },
-        invalidateItemData: ({ tree }, itemId) => {
+    },
+    itemInstance: {
+        isLoading: ({ tree, item }) => tree.getState().loadingItems.includes(item.getItemMeta().itemId),
+        invalidateItemData: ({ tree, itemId }) => {
             var _a;
             const dataRef = tree.getDataRef();
             (_a = dataRef.current.itemData) === null || _a === void 0 ? true : delete _a[itemId];
             tree.retrieveItemData(itemId);
         },
-        invalidateChildrenIds: ({ tree }, itemId) => {
+        invalidateChildrenIds: ({ tree, itemId }) => {
             var _a;
             const dataRef = tree.getDataRef();
             (_a = dataRef.current.childrenIds) === null || _a === void 0 ? true : delete _a[itemId];
             tree.retrieveChildrenIds(itemId);
         },
-    },
-    itemInstance: {
-        isLoading: ({ tree, item }) => tree.getState().loadingItems.includes(item.getItemMeta().itemId),
-        invalidateItemData: ({ tree, item }) => tree.invalidateItemData(item.getItemMeta().itemId),
-        invalidateChildrenIds: ({ tree, item }) => tree.invalidateChildrenIds(item.getItemMeta().itemId),
         updateCachedChildrenIds: ({ tree, itemId }, childrenIds) => {
             const dataRef = tree.getDataRef();
             dataRef.current.childrenIds[itemId] = childrenIds;

package/lib/esm/features/async-data-loader/types.d.ts

@@ -27,12 +27,9 @@ export type AsyncDataLoaderFeatureDef<T> = {
         onLoadedChildren?: (itemId: string, childrenIds: string[]) => void;
         asyncDataLoader?: AsyncTreeDataLoader<T>;
     };
-    treeInstance: SyncDataLoaderFeatureDef<T>["treeInstance"] & {
-        /** Invalidate fetched data for item, and triggers a refetch and subsequent rerender if the item is visible */
-        invalidateItemData: (itemId: string) => void;
-        invalidateChildrenIds: (itemId: string) => void;
-    };
+    treeInstance: SyncDataLoaderFeatureDef<T>["treeInstance"];
     itemInstance: SyncDataLoaderFeatureDef<T>["itemInstance"] & {
+        /** Invalidate fetched data for item, and triggers a refetch and subsequent rerender if the item is visible */
         invalidateItemData: () => void;
         invalidateChildrenIds: () => void;
         updateCachedChildrenIds: (childrenIds: string[]) => void;

package/lib/esm/features/drag-and-drop/feature.d.ts

@@ -1,3 +1,2 @@
-import { FeatureDefs, FeatureImplementation } from "../../types/core";
-import { DragAndDropFeatureDef } from "./types";
-export declare const dragAndDropFeature: FeatureImplementation<any, DragAndDropFeatureDef<any>, FeatureDefs<any>>;
+import { FeatureImplementation } from "../../types/core";
+export declare const dragAndDropFeature: FeatureImplementation;