@headless-tree/core 0.0.8 → 0.0.10

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @headless-tree/core
 
+## 0.0.10
+
+### Patch Changes
+
+- 520ec27: test release
+
+## 0.0.9
+
+### Patch Changes
+
+- ab2a124: dev release
+
 ## 0.0.8
 
 ### Patch Changes

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

@@ -6,7 +6,10 @@ const buildItemInstance = (features, tree, itemId) => {
     var _a, _b;
     const itemInstance = {};
     for (const feature of features) {
-        Object.assign(itemInstance, (_b = (_a = feature.createItemInstance) === null || _a === void 0 ? void 0 : _a.call(feature, Object.assign({}, itemInstance), itemInstance, tree, itemId)) !== null && _b !== void 0 ? _b : {});
+        Object.assign(
+        // TODO dont run createItemInstance, but assign prototype objects instead?
+        // https://jsfiddle.net/bgenc58r/
+        itemInstance, (_b = (_a = feature.createItemInstance) === null || _a === void 0 ? void 0 : _a.call(feature, Object.assign({}, itemInstance), itemInstance, tree, itemId)) !== null && _b !== void 0 ? _b : {});
     }
     return itemInstance;
 };
@@ -72,7 +75,6 @@ const createTree = (initialConfig) => {
                 itemInstances.push(itemInstancesMap[item.itemId]);
             }
         }
-        console.log("REBUILT");
     };
     const eachFeature = (fn) => {
         for (const feature of additionalFeatures) {

package/lib/cjs/features/drag-and-drop/types.js

@@ -6,4 +6,4 @@ var DropTargetPosition;
     DropTargetPosition["Top"] = "top";
     DropTargetPosition["Bottom"] = "bottom";
     DropTargetPosition["Item"] = "item";
-})(DropTargetPosition = exports.DropTargetPosition || (exports.DropTargetPosition = {}));
+})(DropTargetPosition || (exports.DropTargetPosition = DropTargetPosition = {}));

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

@@ -46,7 +46,7 @@ exports.searchFeature = {
     hotkeys: {
         openSearch: {
             hotkey: "LetterOrNumber",
-            preventDefault: true,
+            preventDefault: true, // TODO make true default
             isEnabled: (tree) => !tree.isSearchOpen(),
             handler: (e, tree) => {
                 e.stopPropagation();

package/lib/cjs/mddocs-entry.d.ts

@@ -1,15 +1,23 @@
 import { MainFeatureDef } from "./features/main/types";
 import { DragAndDropFeatureDef } from "./features/drag-and-drop/types";
+import { AsyncDataLoaderFeatureDef } from "./features/async-data-loader/types";
+import { ExpandAllFeatureDef } from "./features/expand-all/types";
+import { HotkeysCoreFeatureDef } from "./features/hotkeys-core/types";
+import { RenamingFeatureDef } from "./features/renaming/types";
+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";
 export * from ".";
 /** @interface */
-export type MainFeatureConfig = MainFeatureDef["config"];
+export type AsyncDataLoaderFeatureConfig<T> = AsyncDataLoaderFeatureDef<T>["config"];
 /** @interface */
-export type MainFeatureState = MainFeatureDef["state"];
+export type AsyncDataLoaderFeatureState<T> = AsyncDataLoaderFeatureDef<T>["state"];
 /** @interface */
-export type MainFeatureTreeInstance = MainFeatureDef["treeInstance"];
+export type AsyncDataLoaderFeatureTreeInstance<T> = AsyncDataLoaderFeatureDef<T>["treeInstance"];
 /** @interface */
-export type MainFeatureItemInstance = MainFeatureDef["itemInstance"];
-export type MainFeatureHotkeys = MainFeatureDef["hotkeys"];
+export type AsyncDataLoaderFeatureItemInstance<T> = AsyncDataLoaderFeatureDef<T>["itemInstance"];
+export type AsyncDataLoaderFeatureHotkeys<T> = AsyncDataLoaderFeatureDef<T>["hotkeys"];
 /** @interface */
 export type DragAndDropFeatureConfig<T> = DragAndDropFeatureDef<T>["config"];
 /** @interface */
@@ -19,3 +27,75 @@ export type DragAndDropFeatureTreeInstance<T> = DragAndDropFeatureDef<T>["treeIn
 /** @interface */
 export type DragAndDropFeatureItemInstance<T> = DragAndDropFeatureDef<T>["itemInstance"];
 export type DragAndDropFeatureHotkeys<T> = DragAndDropFeatureDef<T>["hotkeys"];
+/** @interface */
+export type ExpandAllFeatureConfig = ExpandAllFeatureDef["config"];
+/** @interface */
+export type ExpandAllFeatureState = ExpandAllFeatureDef["state"];
+/** @interface */
+export type ExpandAllFeatureTreeInstance = ExpandAllFeatureDef["treeInstance"];
+/** @interface */
+export type ExpandAllFeatureItemInstance = ExpandAllFeatureDef["itemInstance"];
+export type ExpandAllFeatureHotkeys = ExpandAllFeatureDef["hotkeys"];
+/** @interface */
+export type HotkeysCoreFeatureConfig<T> = HotkeysCoreFeatureDef<T>["config"];
+/** @interface */
+export type HotkeysCoreFeatureState<T> = HotkeysCoreFeatureDef<T>["state"];
+/** @interface */
+export type HotkeysCoreFeatureTreeInstance<T> = HotkeysCoreFeatureDef<T>["treeInstance"];
+/** @interface */
+export type HotkeysCoreFeatureItemInstance<T> = HotkeysCoreFeatureDef<T>["itemInstance"];
+export type HotkeysCoreFeatureHotkeys<T> = HotkeysCoreFeatureDef<T>["hotkeys"];
+/** @interface */
+export type MainFeatureConfig = MainFeatureDef["config"];
+/** @interface */
+export type MainFeatureState = MainFeatureDef["state"];
+/** @interface */
+export type MainFeatureTreeInstance = MainFeatureDef["treeInstance"];
+/** @interface */
+export type MainFeatureItemInstance = MainFeatureDef["itemInstance"];
+export type MainFeatureHotkeys = MainFeatureDef["hotkeys"];
+/** @interface */
+export type RenamingFeatureConfig<T> = RenamingFeatureDef<T>["config"];
+/** @interface */
+export type RenamingFeatureState<T> = RenamingFeatureDef<T>["state"];
+/** @interface */
+export type RenamingFeatureTreeInstance<T> = RenamingFeatureDef<T>["treeInstance"];
+/** @interface */
+export type RenamingFeatureItemInstance<T> = RenamingFeatureDef<T>["itemInstance"];
+export type RenamingFeatureHotkeys<T> = RenamingFeatureDef<T>["hotkeys"];
+/** @interface */
+export type SearchFeatureConfig<T> = SearchFeatureDef<T>["config"];
+/** @interface */
+export type SearchFeatureState<T> = SearchFeatureDef<T>["state"];
+/** @interface */
+export type SearchFeatureTreeInstance<T> = SearchFeatureDef<T>["treeInstance"];
+/** @interface */
+export type SearchFeatureItemInstance<T> = SearchFeatureDef<T>["itemInstance"];
+export type SearchFeatureHotkeys<T> = SearchFeatureDef<T>["hotkeys"];
+/** @interface */
+export type SelectionFeatureConfig<T> = SelectionFeatureDef<T>["config"];
+/** @interface */
+export type SelectionFeatureState<T> = SelectionFeatureDef<T>["state"];
+/** @interface */
+export type SelectionFeatureTreeInstance<T> = SelectionFeatureDef<T>["treeInstance"];
+/** @interface */
+export type SelectionFeatureItemInstance<T> = SelectionFeatureDef<T>["itemInstance"];
+export type SelectionFeatureHotkeys<T> = SelectionFeatureDef<T>["hotkeys"];
+/** @interface */
+export type SyncDataLoaderFeatureConfig<T> = SyncDataLoaderFeatureDef<T>["config"];
+/** @interface */
+export type SyncDataLoaderFeatureState<T> = SyncDataLoaderFeatureDef<T>["state"];
+/** @interface */
+export type SyncDataLoaderFeatureTreeInstance<T> = SyncDataLoaderFeatureDef<T>["treeInstance"];
+/** @interface */
+export type SyncDataLoaderFeatureItemInstance<T> = SyncDataLoaderFeatureDef<T>["itemInstance"];
+export type SyncDataLoaderFeatureHotkeys<T> = SyncDataLoaderFeatureDef<T>["hotkeys"];
+/** @interface */
+export type TreeFeatureConfig<T> = TreeFeatureDef<T>["config"];
+/** @interface */
+export type TreeFeatureState<T> = TreeFeatureDef<T>["state"];
+/** @interface */
+export type TreeFeatureTreeInstance<T> = TreeFeatureDef<T>["treeInstance"];
+/** @interface */
+export type TreeFeatureItemInstance<T> = TreeFeatureDef<T>["itemInstance"];
+export type TreeFeatureHotkeys<T> = TreeFeatureDef<T>["hotkeys"];

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

@@ -3,7 +3,10 @@ const buildItemInstance = (features, tree, itemId) => {
     var _a, _b;
     const itemInstance = {};
     for (const feature of features) {
-        Object.assign(itemInstance, (_b = (_a = feature.createItemInstance) === null || _a === void 0 ? void 0 : _a.call(feature, Object.assign({}, itemInstance), itemInstance, tree, itemId)) !== null && _b !== void 0 ? _b : {});
+        Object.assign(
+        // TODO dont run createItemInstance, but assign prototype objects instead?
+        // https://jsfiddle.net/bgenc58r/
+        itemInstance, (_b = (_a = feature.createItemInstance) === null || _a === void 0 ? void 0 : _a.call(feature, Object.assign({}, itemInstance), itemInstance, tree, itemId)) !== null && _b !== void 0 ? _b : {});
     }
     return itemInstance;
 };
@@ -69,7 +72,6 @@ export const createTree = (initialConfig) => {
                 itemInstances.push(itemInstancesMap[item.itemId]);
             }
         }
-        console.log("REBUILT");
     };
     const eachFeature = (fn) => {
         for (const feature of additionalFeatures) {

package/lib/esm/features/drag-and-drop/utils.js

@@ -1,4 +1,4 @@
-import { DropTargetPosition, } from "./types";
+import { DropTargetPosition } from "./types";
 export const getDragCode = ({ item, childIndex }) => `${item.getId()}__${childIndex !== null && childIndex !== void 0 ? childIndex : "none"}`;
 export const getDropOffset = (e, item) => {
     var _a;

package/lib/esm/features/search/feature.js

@@ -43,7 +43,7 @@ export const searchFeature = {
     hotkeys: {
         openSearch: {
             hotkey: "LetterOrNumber",
-            preventDefault: true,
+            preventDefault: true, // TODO make true default
             isEnabled: (tree) => !tree.isSearchOpen(),
             handler: (e, tree) => {
                 e.stopPropagation();

package/lib/esm/mddocs-entry.d.ts

@@ -1,15 +1,23 @@
 import { MainFeatureDef } from "./features/main/types";
 import { DragAndDropFeatureDef } from "./features/drag-and-drop/types";
+import { AsyncDataLoaderFeatureDef } from "./features/async-data-loader/types";
+import { ExpandAllFeatureDef } from "./features/expand-all/types";
+import { HotkeysCoreFeatureDef } from "./features/hotkeys-core/types";
+import { RenamingFeatureDef } from "./features/renaming/types";
+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";
 export * from ".";
 /** @interface */
-export type MainFeatureConfig = MainFeatureDef["config"];
+export type AsyncDataLoaderFeatureConfig<T> = AsyncDataLoaderFeatureDef<T>["config"];
 /** @interface */
-export type MainFeatureState = MainFeatureDef["state"];
+export type AsyncDataLoaderFeatureState<T> = AsyncDataLoaderFeatureDef<T>["state"];
 /** @interface */
-export type MainFeatureTreeInstance = MainFeatureDef["treeInstance"];
+export type AsyncDataLoaderFeatureTreeInstance<T> = AsyncDataLoaderFeatureDef<T>["treeInstance"];
 /** @interface */
-export type MainFeatureItemInstance = MainFeatureDef["itemInstance"];
-export type MainFeatureHotkeys = MainFeatureDef["hotkeys"];
+export type AsyncDataLoaderFeatureItemInstance<T> = AsyncDataLoaderFeatureDef<T>["itemInstance"];
+export type AsyncDataLoaderFeatureHotkeys<T> = AsyncDataLoaderFeatureDef<T>["hotkeys"];
 /** @interface */
 export type DragAndDropFeatureConfig<T> = DragAndDropFeatureDef<T>["config"];
 /** @interface */
@@ -19,3 +27,75 @@ export type DragAndDropFeatureTreeInstance<T> = DragAndDropFeatureDef<T>["treeIn
 /** @interface */
 export type DragAndDropFeatureItemInstance<T> = DragAndDropFeatureDef<T>["itemInstance"];
 export type DragAndDropFeatureHotkeys<T> = DragAndDropFeatureDef<T>["hotkeys"];
+/** @interface */
+export type ExpandAllFeatureConfig = ExpandAllFeatureDef["config"];
+/** @interface */
+export type ExpandAllFeatureState = ExpandAllFeatureDef["state"];
+/** @interface */
+export type ExpandAllFeatureTreeInstance = ExpandAllFeatureDef["treeInstance"];
+/** @interface */
+export type ExpandAllFeatureItemInstance = ExpandAllFeatureDef["itemInstance"];
+export type ExpandAllFeatureHotkeys = ExpandAllFeatureDef["hotkeys"];
+/** @interface */
+export type HotkeysCoreFeatureConfig<T> = HotkeysCoreFeatureDef<T>["config"];
+/** @interface */
+export type HotkeysCoreFeatureState<T> = HotkeysCoreFeatureDef<T>["state"];
+/** @interface */
+export type HotkeysCoreFeatureTreeInstance<T> = HotkeysCoreFeatureDef<T>["treeInstance"];
+/** @interface */
+export type HotkeysCoreFeatureItemInstance<T> = HotkeysCoreFeatureDef<T>["itemInstance"];
+export type HotkeysCoreFeatureHotkeys<T> = HotkeysCoreFeatureDef<T>["hotkeys"];
+/** @interface */
+export type MainFeatureConfig = MainFeatureDef["config"];
+/** @interface */
+export type MainFeatureState = MainFeatureDef["state"];
+/** @interface */
+export type MainFeatureTreeInstance = MainFeatureDef["treeInstance"];
+/** @interface */
+export type MainFeatureItemInstance = MainFeatureDef["itemInstance"];
+export type MainFeatureHotkeys = MainFeatureDef["hotkeys"];
+/** @interface */
+export type RenamingFeatureConfig<T> = RenamingFeatureDef<T>["config"];
+/** @interface */
+export type RenamingFeatureState<T> = RenamingFeatureDef<T>["state"];
+/** @interface */
+export type RenamingFeatureTreeInstance<T> = RenamingFeatureDef<T>["treeInstance"];
+/** @interface */
+export type RenamingFeatureItemInstance<T> = RenamingFeatureDef<T>["itemInstance"];
+export type RenamingFeatureHotkeys<T> = RenamingFeatureDef<T>["hotkeys"];
+/** @interface */
+export type SearchFeatureConfig<T> = SearchFeatureDef<T>["config"];
+/** @interface */
+export type SearchFeatureState<T> = SearchFeatureDef<T>["state"];
+/** @interface */
+export type SearchFeatureTreeInstance<T> = SearchFeatureDef<T>["treeInstance"];
+/** @interface */
+export type SearchFeatureItemInstance<T> = SearchFeatureDef<T>["itemInstance"];
+export type SearchFeatureHotkeys<T> = SearchFeatureDef<T>["hotkeys"];
+/** @interface */
+export type SelectionFeatureConfig<T> = SelectionFeatureDef<T>["config"];
+/** @interface */
+export type SelectionFeatureState<T> = SelectionFeatureDef<T>["state"];
+/** @interface */
+export type SelectionFeatureTreeInstance<T> = SelectionFeatureDef<T>["treeInstance"];
+/** @interface */
+export type SelectionFeatureItemInstance<T> = SelectionFeatureDef<T>["itemInstance"];
+export type SelectionFeatureHotkeys<T> = SelectionFeatureDef<T>["hotkeys"];
+/** @interface */
+export type SyncDataLoaderFeatureConfig<T> = SyncDataLoaderFeatureDef<T>["config"];
+/** @interface */
+export type SyncDataLoaderFeatureState<T> = SyncDataLoaderFeatureDef<T>["state"];
+/** @interface */
+export type SyncDataLoaderFeatureTreeInstance<T> = SyncDataLoaderFeatureDef<T>["treeInstance"];
+/** @interface */
+export type SyncDataLoaderFeatureItemInstance<T> = SyncDataLoaderFeatureDef<T>["itemInstance"];
+export type SyncDataLoaderFeatureHotkeys<T> = SyncDataLoaderFeatureDef<T>["hotkeys"];
+/** @interface */
+export type TreeFeatureConfig<T> = TreeFeatureDef<T>["config"];
+/** @interface */
+export type TreeFeatureState<T> = TreeFeatureDef<T>["state"];
+/** @interface */
+export type TreeFeatureTreeInstance<T> = TreeFeatureDef<T>["treeInstance"];
+/** @interface */
+export type TreeFeatureItemInstance<T> = TreeFeatureDef<T>["itemInstance"];
+export type TreeFeatureHotkeys<T> = TreeFeatureDef<T>["hotkeys"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@headless-tree/core",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "main": "lib/cjs/index.js",
   "module": "lib/esm/index.js",
   "types": "lib/esm/index.d.ts",
@@ -18,6 +18,6 @@
   "author": "Lukas Bach <npm@lukasbach.com>",
   "license": "MIT",
   "devDependencies": {
-    "typescript": "^5.0.4"
+    "typescript": "^5.4.2"
   }
 }

package/src/core/create-tree.ts

@@ -13,18 +13,20 @@ import { ItemMeta } from "../features/tree/types";
 const buildItemInstance = (
   features: FeatureImplementation[],
   tree: TreeInstance<any>,
-  itemId: string
+  itemId: string,
 ) => {
   const itemInstance = {} as ItemInstance<any>;
   for (const feature of features) {
     Object.assign(
+      // TODO dont run createItemInstance, but assign prototype objects instead?
+      // https://jsfiddle.net/bgenc58r/
       itemInstance,
       feature.createItemInstance?.(
         { ...itemInstance },
         itemInstance,
         tree,
-        itemId
-      ) ?? {}
+        itemId,
+      ) ?? {},
     );
   }
   return itemInstance;
@@ -34,7 +36,7 @@ const verifyFeatures = (features: FeatureImplementation[] | undefined) => {
   const loadedFeatures = features?.map((feature) => feature.key);
   for (const feature of features ?? []) {
     const missingDependency = feature.deps?.find(
-      (dep) => !loadedFeatures?.includes(dep)
+      (dep) => !loadedFeatures?.includes(dep),
     );
     if (missingDependency) {
       throw new Error(`${feature.key} needs ${missingDependency}`);
@@ -44,7 +46,7 @@ const verifyFeatures = (features: FeatureImplementation[] | undefined) => {
 
 const compareFeatures = (
   feature1: FeatureImplementation,
-  feature2: FeatureImplementation
+  feature2: FeatureImplementation,
 ) => {
   if (feature2.key && feature1.overwrites?.includes(feature2.key)) {
     return 1;
@@ -56,7 +58,7 @@ const sortFeatures = (features: FeatureImplementation[] = []) =>
   features.sort(compareFeatures);
 
 export const createTree = <T>(
-  initialConfig: TreeConfig<T>
+  initialConfig: TreeConfig<T>,
 ): TreeInstance<T> => {
   const treeInstance: TreeInstance<T> = {} as any;
 
@@ -68,15 +70,15 @@ export const createTree = <T>(
 
   let state = additionalFeatures.reduce(
     (acc, feature) => feature.getInitialState?.(acc, treeInstance) ?? acc,
-    initialConfig.initialState ?? initialConfig.state ?? {}
+    initialConfig.initialState ?? initialConfig.state ?? {},
   ) as TreeState<T>;
   let config = additionalFeatures.reduce(
     (acc, feature) => feature.getDefaultConfig?.(acc, treeInstance) ?? acc,
-    initialConfig
+    initialConfig,
   ) as TreeConfig<T>;
   const stateHandlerNames = additionalFeatures.reduce(
     (acc, feature) => ({ ...acc, ...feature.stateHandlerNames }),
-    {} as Record<string, string>
+    {} as Record<string, string>,
   );
 
   let treeElement: HTMLElement | undefined | null;
@@ -98,7 +100,7 @@ export const createTree = <T>(
     const rootInstance = buildItemInstance(
       [main, ...additionalFeatures],
       treeInstance,
-      config.rootItemId
+      config.rootItemId,
     );
     itemInstancesMap[config.rootItemId] = rootInstance;
     itemMetaMap[config.rootItemId] = {
@@ -116,7 +118,7 @@ export const createTree = <T>(
         const instance = buildItemInstance(
           [main, ...additionalFeatures],
           treeInstance,
-          item.itemId
+          item.itemId,
         );
         itemInstancesMap[item.itemId] = instance;
         itemInstances.push(instance);
@@ -124,7 +126,6 @@ export const createTree = <T>(
         itemInstances.push(itemInstancesMap[item.itemId]);
       }
     }
-    console.log("REBUILT");
   };
 
   const eachFeature = (fn: (feature: FeatureImplementation<any>) => void) => {
@@ -173,11 +174,11 @@ export const createTree = <T>(
 
         if (treeElement && !element) {
           eachFeature((feature) =>
-            feature.onTreeUnmount?.(treeInstance, treeElement!)
+            feature.onTreeUnmount?.(treeInstance, treeElement!),
           );
         } else if (!treeElement && element) {
           eachFeature((feature) =>
-            feature.onTreeMount?.(treeInstance, element)
+            feature.onTreeMount?.(treeInstance, element),
           );
         }
         treeElement = element;
@@ -196,11 +197,11 @@ export const createTree = <T>(
         const oldElement = itemElementsMap[itemId];
         if (oldElement && !element) {
           eachFeature((feature) =>
-            feature.onItemUnmount?.(instance, oldElement!, treeInstance)
+            feature.onItemUnmount?.(instance, oldElement!, treeInstance),
           );
         } else if (!oldElement && element) {
           eachFeature((feature) =>
-            feature.onItemMount?.(instance, element!, treeInstance)
+            feature.onItemMount?.(instance, element!, treeInstance),
           );
         }
         itemElementsMap[itemId] = element;
@@ -217,7 +218,7 @@ export const createTree = <T>(
   for (const feature of features) {
     Object.assign(
       treeInstance,
-      feature.createTreeInstance?.({ ...treeInstance }, treeInstance) ?? {}
+      feature.createTreeInstance?.({ ...treeInstance }, treeInstance) ?? {},
     );
     Object.assign(hotkeyPresets, feature.hotkeys ?? {});
   }

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

@@ -47,7 +47,7 @@ export const asyncDataLoaderFeature: FeatureImplementation<
           dataRef.current.itemData[itemId] = item;
           config.onLoadedItem?.(itemId, item);
           instance.applySubStateUpdate("loadingItems", (loadingItems) =>
-            loadingItems.filter((id) => id !== itemId)
+            loadingItems.filter((id) => id !== itemId),
           );
         });
       }
@@ -83,7 +83,7 @@ export const asyncDataLoaderFeature: FeatureImplementation<
           dataRef.current.childrenIds[itemId] = childrenIds;
           config.onLoadedChildren?.(itemId, childrenIds);
           instance.applySubStateUpdate("loadingItems", (loadingItems) =>
-            loadingItems.filter((id) => id !== itemId)
+            loadingItems.filter((id) => id !== itemId),
           );
           instance.rebuildTree();
         });
@@ -92,7 +92,7 @@ export const asyncDataLoaderFeature: FeatureImplementation<
           dataRef.current.childrenIds[itemId] = childrenIds;
           config.onLoadedChildren?.(itemId, childrenIds);
           instance.applySubStateUpdate("loadingItems", (loadingItems) =>
-            loadingItems.filter((id) => id !== itemId)
+            loadingItems.filter((id) => id !== itemId),
           );
           instance.rebuildTree();
         });

package/src/features/async-data-loader/types.ts

@@ -35,7 +35,7 @@ export type AsyncDataLoaderFeatureDef<T> = {
   itemInstance: SyncDataLoaderFeatureDef<T>["itemInstance"] & {
     invalidateItemData: () => void;
     invalidateChildrenIds: () => void;
-    isLoading: () => void;
+    isLoading: () => void; // TODO! boolean?
   };
   hotkeys: SyncDataLoaderFeatureDef<T>["hotkeys"];
 };

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

@@ -56,12 +56,12 @@ export type DragAndDropFeatureDef<T> = {
     };
     canDropForeignDragObject?: (
       dataTransfer: DataTransfer,
-      target: DropTarget<T>
+      target: DropTarget<T>,
     ) => boolean;
     onDrop?: (items: ItemInstance<T>[], target: DropTarget<T>) => void;
     onDropForeignDragObject?: (
       dataTransfer: DataTransfer,
-      target: DropTarget<T>
+      target: DropTarget<T>,
     ) => void;
 
     /** Runs in the onDragEnd event, if `ev.dataTransfer.dropEffect` is not `none`, i.e. the drop

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

@@ -1,10 +1,5 @@
 import { ItemInstance, TreeInstance } from "../../types/core";
-import {
-  DndState,
-  DragAndDropFeatureDef,
-  DropTarget,
-  DropTargetPosition,
-} from "./types";
+import { DropTarget, DropTargetPosition } from "./types";
 
 export const getDragCode = ({ item, childIndex }: DropTarget<any>) =>
   `${item.getId()}__${childIndex ?? "none"}`;
@@ -17,7 +12,7 @@ export const getDropOffset = (e: any, item: ItemInstance<any>): number => {
 export const canDrop = (
   dataTransfer: DataTransfer | null,
   target: DropTarget<any>,
-  tree: TreeInstance<any>
+  tree: TreeInstance<any>,
 ) => {
   const draggedItems = tree.getState().dnd?.draggedItems;
   const config = tree.getConfig();
@@ -40,7 +35,7 @@ export const canDrop = (
 const getDropTargetPosition = (
   offset: number,
   topLinePercentage: number,
-  bottomLinePercentage: number
+  bottomLinePercentage: number,
 ) => {
   if (offset < topLinePercentage) {
     return DropTargetPosition.Top;
@@ -55,7 +50,7 @@ export const getDropTarget = (
   e: any,
   item: ItemInstance<any>,
   tree: TreeInstance<any>,
-  canDropInbetween = tree.getConfig().canDropInbetween
+  canDropInbetween = tree.getConfig().canDropInbetween,
 ): DropTarget<any> => {
   const config = tree.getConfig();
   const draggedItems = tree.getState().dnd?.draggedItems ?? [];
@@ -81,7 +76,7 @@ export const getDropTarget = (
     ? getDropTargetPosition(
         offset,
         config.topLinePercentage ?? 0.3,
-        config.bottomLinePercentage ?? 0.7
+        config.bottomLinePercentage ?? 0.7,
       )
     : getDropTargetPosition(offset, 0.5, 0.5);
 
@@ -105,7 +100,7 @@ export const getDropTarget = (
         child && draggedItems?.some((i) => i.getId() === child.getId())
           ? ++counter
           : counter,
-      0
+      0,
     );
 
   return {

package/src/features/expand-all/feature.ts

@@ -20,7 +20,7 @@ export const expandAllFeature: FeatureImplementation<
 
     expandAll: async (cancelToken) => {
       await Promise.all(
-        tree.getItems().map((item) => item.expandAll(cancelToken))
+        tree.getItems().map((item) => item.expandAll(cancelToken)),
       );
     },
 
@@ -46,10 +46,10 @@ export const expandAllFeature: FeatureImplementation<
       await Promise.all(
         item.getChildren().map(async (child) => {
           await poll(
-            () => !tree.getState().loadingItems.includes(child.getId())
+            () => !tree.getState().loadingItems.includes(child.getId()),
           );
           await child?.expandAll(cancelToken);
-        })
+        }),
       );
     },
 

package/src/features/hotkeys-core/feature.ts

@@ -18,13 +18,13 @@ const specialKeys: Record<string, RegExp> = {
 const testHotkeyMatch = (
   pressedKeys: Set<string>,
   tree: TreeInstance<any>,
-  hotkey: HotkeyConfig<any>
+  hotkey: HotkeyConfig<any>,
 ) => {
   const supposedKeys = hotkey.hotkey.split("+");
   const doKeysMatch = supposedKeys.every((key) =>
     key in specialKeys
       ? [...pressedKeys].some((pressedKey) => specialKeys[key].test(pressedKey))
-      : pressedKeys.has(key)
+      : pressedKeys.has(key),
   );
   const isEnabled = !hotkey.isEnabled || hotkey.isEnabled(tree);
   const equalCounts = pressedKeys.size === supposedKeys.length;
@@ -35,10 +35,10 @@ const findHotkeyMatch = (
   pressedKeys: Set<string>,
   tree: TreeInstance<any>,
   config1: HotkeysConfig<any, any>,
-  config2: HotkeysConfig<any, any>
+  config2: HotkeysConfig<any, any>,
 ) => {
   return Object.entries({ ...config1, ...config2 }).find(([, hotkey]) =>
-    testHotkeyMatch(pressedKeys, tree, hotkey)
+    testHotkeyMatch(pressedKeys, tree, hotkey),
   )?.[0];
 };
 
@@ -60,7 +60,7 @@ export const hotkeysCoreFeature: FeatureImplementation<
         data.current.pressedKeys,
         tree as any,
         tree.getHotkeyPresets(),
-        tree.getConfig().hotkeys as HotkeysConfig<any>
+        tree.getConfig().hotkeys as HotkeysConfig<any>,
       );
 
       if (!hotkeyName) return;

package/src/features/hotkeys-core/types.ts

@@ -27,7 +27,7 @@ export type HotkeysCoreFeatureDef<T> = {
     onItemHotkey?: (
       name: string,
       item: ItemInstance<T>,
-      element: HTMLElement
+      element: HTMLElement,
     ) => void;
   };
   treeInstance: {};

package/src/features/main/types.ts

@@ -21,7 +21,7 @@ export type MainFeatureDef<T = any> = {
     /** @internal */
     applySubStateUpdate: <K extends keyof TreeState<any>>(
       stateName: K,
-      updater: Updater<TreeState<T>[K]>
+      updater: Updater<TreeState<T>[K]>,
     ) => void;
     setState: SetStateFn<TreeState<T>>;
     getState: () => TreeState<T>;

package/src/features/search/feature.ts

@@ -38,7 +38,7 @@ export const searchFeature: FeatureImplementation<
         .find((item) =>
           instance
             .getConfig()
-            .isSearchMatchingItem?.(instance.getSearchValue(), item)
+            .isSearchMatchingItem?.(instance.getSearchValue(), item),
         )
         ?.setFocused();
     },
@@ -76,9 +76,9 @@ export const searchFeature: FeatureImplementation<
       (search, items) =>
         items.filter(
           (item) =>
-            search && instance.getConfig().isSearchMatchingItem?.(search, item)
+            search && instance.getConfig().isSearchMatchingItem?.(search, item),
         ),
-      () => [instance.getSearchValue(), instance.getItems()]
+      () => [instance.getSearchValue(), instance.getItems()],
     ),
   }),
 
@@ -130,7 +130,7 @@ export const searchFeature: FeatureImplementation<
           .find(
             (item) =>
               item.getItemMeta().index >
-              tree.getFocusedItem().getItemMeta().index
+              tree.getFocusedItem().getItemMeta().index,
           );
         focusItem?.setFocused();
         focusItem?.scrollTo({ block: "nearest", inline: "nearest" });
@@ -148,7 +148,7 @@ export const searchFeature: FeatureImplementation<
           .find(
             (item) =>
               item.getItemMeta().index <
-              tree.getFocusedItem().getItemMeta().index
+              tree.getFocusedItem().getItemMeta().index,
           );
         focusItem?.setFocused();
         focusItem?.scrollTo({ block: "nearest", inline: "nearest" });

package/src/features/selection/feature.ts

@@ -46,14 +46,14 @@ export const selectionFeature: FeatureImplementation<
       tree.setSelectedItems(
         selectedItems.includes(item.getItemMeta().itemId)
           ? selectedItems
-          : [...selectedItems, item.getItemMeta().itemId]
+          : [...selectedItems, item.getItemMeta().itemId],
       );
     },
 
     deselect: () => {
       const { selectedItems } = tree.getState();
       tree.setSelectedItems(
-        selectedItems.filter((id) => id !== item.getItemMeta().itemId)
+        selectedItems.filter((id) => id !== item.getItemMeta().itemId),
       );
     },
 

package/src/features/tree/feature.ts

@@ -56,7 +56,7 @@ export const treeFeature: FeatureImplementation<
         parentId: string,
         level: number,
         setSize: number,
-        posInSet: number
+        posInSet: number,
       ) => {
         flatItems.push({
           itemId,
@@ -107,7 +107,7 @@ export const treeFeature: FeatureImplementation<
       }
 
       instance.applySubStateUpdate("expandedItems", (expandedItems) =>
-        expandedItems.filter((id) => id !== itemId)
+        expandedItems.filter((id) => id !== itemId),
       );
       instance.rebuildTree();
     },
@@ -226,7 +226,7 @@ export const treeFeature: FeatureImplementation<
         }
         return tree.getItemInstance(tree.getConfig().rootItemId);
       },
-      () => [item.getItemMeta()]
+      () => [item.getItemMeta()],
     ),
     // TODO remove
     getIndexInParent: () => item.getItemMeta().posInSet,

package/src/features/tree/types.ts

@@ -65,7 +65,7 @@ export type TreeFeatureDef<T> = {
     getItemBelow: () => ItemInstance<T> | null;
     getMemoizedProp: <X>(name: string, create: () => X, deps?: any[]) => X;
     scrollTo: (
-      scrollIntoViewArg?: boolean | ScrollIntoViewOptions
+      scrollIntoViewArg?: boolean | ScrollIntoViewOptions,
     ) => Promise<void>;
   };
   hotkeys:

package/src/mddocs-entry.ts

@@ -1,17 +1,40 @@
 import { MainFeatureDef } from "./features/main/types";
 import { DragAndDropFeatureDef } from "./features/drag-and-drop/types";
+import { AsyncDataLoaderFeatureDef } from "./features/async-data-loader/types";
+import { ExpandAllFeatureDef } from "./features/expand-all/types";
+import { HotkeysCoreFeatureDef } from "./features/hotkeys-core/types";
+import { RenamingFeatureDef } from "./features/renaming/types";
+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";
 
 export * from ".";
 
+//     /** @interface */
+//     export type XXXFeatureConfig<T> = XFeatureDef<T>["config"];
+//     /** @interface */
+//     export type XXXFeatureState<T> = XFeatureDef<T>["state"];
+//     /** @interface */
+//     export type XXXFeatureTreeInstance<T> = XFeatureDef<T>["treeInstance"];
+//     /** @interface */
+//     export type XXXFeatureItemInstance<T> = XFeatureDef<T>["itemInstance"];
+//     export type XXXFeatureHotkeys<T> = XFeatureDef<T>["hotkeys"];
+
 /** @interface */
-export type MainFeatureConfig = MainFeatureDef["config"];
+export type AsyncDataLoaderFeatureConfig<T> =
+  AsyncDataLoaderFeatureDef<T>["config"];
 /** @interface */
-export type MainFeatureState = MainFeatureDef["state"];
+export type AsyncDataLoaderFeatureState<T> =
+  AsyncDataLoaderFeatureDef<T>["state"];
 /** @interface */
-export type MainFeatureTreeInstance = MainFeatureDef["treeInstance"];
+export type AsyncDataLoaderFeatureTreeInstance<T> =
+  AsyncDataLoaderFeatureDef<T>["treeInstance"];
 /** @interface */
-export type MainFeatureItemInstance = MainFeatureDef["itemInstance"];
-export type MainFeatureHotkeys = MainFeatureDef["hotkeys"];
+export type AsyncDataLoaderFeatureItemInstance<T> =
+  AsyncDataLoaderFeatureDef<T>["itemInstance"];
+export type AsyncDataLoaderFeatureHotkeys<T> =
+  AsyncDataLoaderFeatureDef<T>["hotkeys"];
 
 /** @interface */
 export type DragAndDropFeatureConfig<T> = DragAndDropFeatureDef<T>["config"];
@@ -24,3 +47,94 @@ export type DragAndDropFeatureTreeInstance<T> =
 export type DragAndDropFeatureItemInstance<T> =
   DragAndDropFeatureDef<T>["itemInstance"];
 export type DragAndDropFeatureHotkeys<T> = DragAndDropFeatureDef<T>["hotkeys"];
+
+/** @interface */
+export type ExpandAllFeatureConfig = ExpandAllFeatureDef["config"];
+/** @interface */
+export type ExpandAllFeatureState = ExpandAllFeatureDef["state"];
+/** @interface */
+export type ExpandAllFeatureTreeInstance = ExpandAllFeatureDef["treeInstance"];
+/** @interface */
+export type ExpandAllFeatureItemInstance = ExpandAllFeatureDef["itemInstance"];
+export type ExpandAllFeatureHotkeys = ExpandAllFeatureDef["hotkeys"];
+
+/** @interface */
+export type HotkeysCoreFeatureConfig<T> = HotkeysCoreFeatureDef<T>["config"];
+/** @interface */
+export type HotkeysCoreFeatureState<T> = HotkeysCoreFeatureDef<T>["state"];
+/** @interface */
+export type HotkeysCoreFeatureTreeInstance<T> =
+  HotkeysCoreFeatureDef<T>["treeInstance"];
+/** @interface */
+export type HotkeysCoreFeatureItemInstance<T> =
+  HotkeysCoreFeatureDef<T>["itemInstance"];
+export type HotkeysCoreFeatureHotkeys<T> = HotkeysCoreFeatureDef<T>["hotkeys"];
+
+/** @interface */
+export type MainFeatureConfig = MainFeatureDef["config"];
+/** @interface */
+export type MainFeatureState = MainFeatureDef["state"];
+/** @interface */
+export type MainFeatureTreeInstance = MainFeatureDef["treeInstance"];
+/** @interface */
+export type MainFeatureItemInstance = MainFeatureDef["itemInstance"];
+export type MainFeatureHotkeys = MainFeatureDef["hotkeys"];
+
+/** @interface */
+export type RenamingFeatureConfig<T> = RenamingFeatureDef<T>["config"];
+/** @interface */
+export type RenamingFeatureState<T> = RenamingFeatureDef<T>["state"];
+/** @interface */
+export type RenamingFeatureTreeInstance<T> =
+  RenamingFeatureDef<T>["treeInstance"];
+/** @interface */
+export type RenamingFeatureItemInstance<T> =
+  RenamingFeatureDef<T>["itemInstance"];
+export type RenamingFeatureHotkeys<T> = RenamingFeatureDef<T>["hotkeys"];
+
+/** @interface */
+export type SearchFeatureConfig<T> = SearchFeatureDef<T>["config"];
+/** @interface */
+export type SearchFeatureState<T> = SearchFeatureDef<T>["state"];
+/** @interface */
+export type SearchFeatureTreeInstance<T> = SearchFeatureDef<T>["treeInstance"];
+/** @interface */
+export type SearchFeatureItemInstance<T> = SearchFeatureDef<T>["itemInstance"];
+export type SearchFeatureHotkeys<T> = SearchFeatureDef<T>["hotkeys"];
+
+/** @interface */
+export type SelectionFeatureConfig<T> = SelectionFeatureDef<T>["config"];
+/** @interface */
+export type SelectionFeatureState<T> = SelectionFeatureDef<T>["state"];
+/** @interface */
+export type SelectionFeatureTreeInstance<T> =
+  SelectionFeatureDef<T>["treeInstance"];
+/** @interface */
+export type SelectionFeatureItemInstance<T> =
+  SelectionFeatureDef<T>["itemInstance"];
+export type SelectionFeatureHotkeys<T> = SelectionFeatureDef<T>["hotkeys"];
+
+/** @interface */
+export type SyncDataLoaderFeatureConfig<T> =
+  SyncDataLoaderFeatureDef<T>["config"];
+/** @interface */
+export type SyncDataLoaderFeatureState<T> =
+  SyncDataLoaderFeatureDef<T>["state"];
+/** @interface */
+export type SyncDataLoaderFeatureTreeInstance<T> =
+  SyncDataLoaderFeatureDef<T>["treeInstance"];
+/** @interface */
+export type SyncDataLoaderFeatureItemInstance<T> =
+  SyncDataLoaderFeatureDef<T>["itemInstance"];
+export type SyncDataLoaderFeatureHotkeys<T> =
+  SyncDataLoaderFeatureDef<T>["hotkeys"];
+
+/** @interface */
+export type TreeFeatureConfig<T> = TreeFeatureDef<T>["config"];
+/** @interface */
+export type TreeFeatureState<T> = TreeFeatureDef<T>["state"];
+/** @interface */
+export type TreeFeatureTreeInstance<T> = TreeFeatureDef<T>["treeInstance"];
+/** @interface */
+export type TreeFeatureItemInstance<T> = TreeFeatureDef<T>["itemInstance"];
+export type TreeFeatureHotkeys<T> = TreeFeatureDef<T>["hotkeys"];

package/src/types/core.ts

@@ -32,7 +32,7 @@ export type EmptyFeatureDef = {
 };
 
 type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (
-  x: infer R
+  x: infer R,
 ) => any
   ? R
   : never;
@@ -52,6 +52,7 @@ export type FeatureDefs<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"]>;
@@ -117,7 +118,7 @@ export type HotkeysConfig<T, F extends FeatureDef = FeatureDefs<T>> = Record<
 
 export type CustomHotkeysConfig<
   T,
-  F extends FeatureDef = FeatureDefs<T>
+  F extends FeatureDef = FeatureDefs<T>,
 > = Partial<
   Record<HotkeyName<F> | `custom${string}`, Partial<HotkeyConfig<T>>>
 >;
@@ -125,7 +126,7 @@ export type CustomHotkeysConfig<
 export type FeatureImplementation<
   T = any,
   D extends FeatureDef = any,
-  F extends FeatureDef = EmptyFeatureDef
+  F extends FeatureDef = EmptyFeatureDef,
 > = {
   key?: string;
   deps?: string[];
@@ -137,46 +138,46 @@ export type FeatureImplementation<
 
   getInitialState?: (
     initialState: Partial<MergedFeatures<F>["state"]>,
-    tree: MergedFeatures<F>["treeInstance"]
+    tree: MergedFeatures<F>["treeInstance"],
   ) => Partial<D["state"] & MergedFeatures<F>["state"]>;
 
   getDefaultConfig?: (
     defaultConfig: Partial<MergedFeatures<F>["config"]>,
-    tree: MergedFeatures<F>["treeInstance"]
+    tree: MergedFeatures<F>["treeInstance"],
   ) => Partial<D["config"] & MergedFeatures<F>["config"]>;
 
   createTreeInstance?: (
     prev: MergedFeatures<F>["treeInstance"],
-    instance: 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
+    itemId: string,
   ) => D["itemInstance"] & MergedFeatures<F>["itemInstance"];
 
   onTreeMount?: (
     instance: MergedFeatures<F>["treeInstance"],
-    treeElement: HTMLElement
+    treeElement: HTMLElement,
   ) => void;
 
   onTreeUnmount?: (
     instance: MergedFeatures<F>["treeInstance"],
-    treeElement: HTMLElement
+    treeElement: HTMLElement,
   ) => void;
 
   onItemMount?: (
     instance: MergedFeatures<F>["itemInstance"],
     itemElement: HTMLElement,
-    tree: MergedFeatures<F>["treeInstance"]
+    tree: MergedFeatures<F>["treeInstance"],
   ) => void;
 
   onItemUnmount?: (
     instance: MergedFeatures<F>["itemInstance"],
     itemElement: HTMLElement,
-    tree: MergedFeatures<F>["treeInstance"]
+    tree: MergedFeatures<F>["treeInstance"],
   ) => void;
 
   hotkeys?: HotkeysConfig<T, D>;

package/src/types/deep-merge.ts

@@ -25,7 +25,7 @@ type TPrimitives =
 export type TMerged<T> = [T] extends [Array<any>]
   ? { [K in keyof T]: TMerged<T[K]> }
   : [T] extends [TPrimitives]
-  ? T
-  : [T] extends [object]
-  ? TPartialKeys<{ [K in TAllKeys<T>]: TMerged<TIndexValue<T, K>> }, never>
-  : T;
+    ? T
+    : [T] extends [object]
+      ? TPartialKeys<{ [K in TAllKeys<T>]: TMerged<TIndexValue<T, K>> }, never>
+      : T;

package/src/utilities/create-on-drop-handler.ts

@@ -5,7 +5,7 @@ import { insertItemsAtTarget } from "./insert-items-at-target";
 
 export const createOnDropHandler =
   <T>(
-    onChangeChildren: (item: ItemInstance<T>, newChildren: string[]) => void
+    onChangeChildren: (item: ItemInstance<T>, newChildren: string[]) => void,
   ) =>
   (items: ItemInstance<T>[], target: DropTarget<T>) => {
     const itemIds = items.map((item) => item.getId());

package/src/utilities/insert-items-at-target.ts

@@ -4,7 +4,7 @@ import { DropTarget } from "../features/drag-and-drop/types";
 export const insertItemsAtTarget = <T>(
   itemIds: string[],
   target: DropTarget<T>,
-  onChangeChildren: (item: ItemInstance<T>, newChildrenIds: string[]) => void
+  onChangeChildren: (item: ItemInstance<T>, newChildrenIds: string[]) => void,
 ) => {
   // add moved items to new common parent, if dropped onto parent
   if (target.childIndex === null) {

package/src/utilities/remove-items-from-parents.ts

@@ -2,7 +2,7 @@ import { ItemInstance } from "../types/core";
 
 export const removeItemsFromParents = <T>(
   movedItems: ItemInstance<T>[],
-  onChangeChildren: (item: ItemInstance<T>, newChildrenIds: string[]) => void
+  onChangeChildren: (item: ItemInstance<T>, newChildrenIds: string[]) => void,
 ) => {
   // TODO bulk sibling changes together
   for (const item of movedItems) {
@@ -12,7 +12,7 @@ export const removeItemsFromParents = <T>(
         item.getParent(),
         siblings
           .filter((sibling) => sibling.getId() !== item.getId())
-          .map((i) => i.getId())
+          .map((i) => i.getId()),
       );
     }
   }

package/src/utils.ts

@@ -4,7 +4,7 @@ export type NoInfer<T> = [T][T extends any ? 0 : never];
 
 export const memo = <D extends readonly any[], R>(
   fn: (...args: [...D]) => R,
-  deps: () => [...D]
+  deps: () => [...D],
 ) => {
   let value: R | undefined;
   let oldDeps: D | null = null;
@@ -40,7 +40,7 @@ export function functionalUpdate<T>(updater: Updater<T>, input: T): T {
 }
 export function makeStateUpdater<K extends keyof TreeState<any>>(
   key: K,
-  instance: unknown
+  instance: unknown,
 ) {
   return (updater: Updater<TreeState<any>[K]>) => {
     (instance as any).setState(<TTableState>(old: TTableState) => {

package/typedoc.json

@@ -1,4 +1,4 @@
 {
   "extends": ["../../typedoc.base.json"],
-  "entryPoints": ["src/index.ts"]
+  "entryPoints": ["src/mddocs-entry.ts"]
 }