@headless-tree/core 0.0.11 → 0.0.12

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @headless-tree/core
 
+## 0.0.12
+
+### Patch Changes
+
+- 7236907: dev release
+
 ## 0.0.11
 
 ### Patch Changes

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

@@ -7,8 +7,7 @@ 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/cjs/core/create-tree.js

@@ -14,14 +14,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));
 const createTree = (initialConfig) => {
     var _a, _b, _c, _d;
     const buildInstance = (_a = initialConfig.instanceBuilder) !== null && _a !== void 0 ? _a : build_static_instance_1.buildStaticInstance;

package/lib/cjs/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/cjs/features/async-data-loader/feature.js

@@ -76,23 +76,21 @@ exports.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/cjs/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/cjs/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;

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

@@ -4,9 +4,9 @@ exports.dragAndDropFeature = void 0;
 const utils_1 = require("./utils");
 const utils_2 = require("../../utils");
 exports.dragAndDropFeature = {
-    key: "dragAndDrop",
+    key: "drag-and-drop",
     deps: ["selection"],
-    getDefaultConfig: (defaultConfig, tree) => (Object.assign({ canDrop: (_, target) => target.item.isFolder(), canDropForeignDragObject: () => false, setDndState: (0, utils_2.makeStateUpdater)("dnd", tree), canDropInbetween: true }, defaultConfig)),
+    getDefaultConfig: (defaultConfig, tree) => (Object.assign({ canDrop: (_, target) => target.item.isFolder(), canDropForeignDragObject: () => false, setDndState: (0, utils_2.makeStateUpdater)("dnd", tree), canReorder: true }, defaultConfig)),
     stateHandlerNames: {
         dnd: "setDndState",
     },
@@ -16,33 +16,33 @@ exports.dragAndDropFeature = {
             return (_b = (_a = tree.getState().dnd) === null || _a === void 0 ? void 0 : _a.dragTarget) !== null && _b !== void 0 ? _b : null;
         },
         getDragLineData: ({ tree }) => {
-            var _a, _b, _c, _d, _e;
-            // TODO doesnt work if scrolled down!
+            var _a, _b, _c, _d, _e, _f;
             const target = tree.getDropTarget();
-            const indent = ((_a = target === null || target === void 0 ? void 0 : target.item.getItemMeta().level) !== null && _a !== void 0 ? _a : 0) + 1; // TODO rename to indent
-            if (!target || target.childIndex === null)
+            const indent = ((_a = target === null || target === void 0 ? void 0 : target.item.getItemMeta().level) !== null && _a !== void 0 ? _a : 0) + 1;
+            const treeBb = (_b = tree.getElement()) === null || _b === void 0 ? void 0 : _b.getBoundingClientRect();
+            if (!target || !treeBb || target.childIndex === null)
                 return null;
-            const leftOffset = target.dragLineLevel * ((_b = tree.getConfig().indent) !== null && _b !== void 0 ? _b : 1);
+            const leftOffset = target.dragLineLevel * ((_c = tree.getConfig().indent) !== null && _c !== void 0 ? _c : 1);
             const targetItem = tree.getItems()[target.dragLineIndex];
             if (!targetItem) {
-                const bb = (_d = (_c = tree
-                    .getItems()[target.dragLineIndex - 1]) === null || _c === void 0 ? void 0 : _c.getElement()) === null || _d === void 0 ? void 0 : _d.getBoundingClientRect();
+                const bb = (_e = (_d = tree
+                    .getItems()[target.dragLineIndex - 1]) === null || _d === void 0 ? void 0 : _d.getElement()) === null || _e === void 0 ? void 0 : _e.getBoundingClientRect();
                 if (bb) {
                     return {
                         indent,
-                        top: bb.bottom,
-                        left: bb.left + leftOffset,
-                        right: bb.right,
+                        top: bb.bottom - treeBb.bottom,
+                        left: bb.left + leftOffset - treeBb.left,
+                        width: bb.width - leftOffset,
                     };
                 }
             }
-            const bb = (_e = targetItem.getElement()) === null || _e === void 0 ? void 0 : _e.getBoundingClientRect();
+            const bb = (_f = targetItem.getElement()) === null || _f === void 0 ? void 0 : _f.getBoundingClientRect();
             if (bb) {
                 return {
                     indent,
-                    top: bb.top,
-                    left: bb.left + leftOffset,
-                    right: bb.right,
+                    top: bb.top - treeBb.top,
+                    left: bb.left + leftOffset - treeBb.left,
+                    width: bb.width - leftOffset,
                 };
             }
             return null;
@@ -53,17 +53,20 @@ exports.dragAndDropFeature = {
                 ? {
                     top: `${dragLine.top + topOffset}px`,
                     left: `${dragLine.left + leftOffset}px`,
-                    width: `${dragLine.right - dragLine.left - leftOffset}px`,
+                    width: `${dragLine.width - leftOffset}px`,
                     pointerEvents: "none", // important to prevent capturing drag events
                 }
                 : { display: "none" };
         },
+        getContainerProps: ({ prev }) => {
+            const prevProps = prev === null || prev === void 0 ? void 0 : prev();
+            return Object.assign(Object.assign({}, prevProps), { style: Object.assign(Object.assign({}, prevProps === null || prevProps === void 0 ? void 0 : prevProps.style), { position: "relative" }) });
+        },
     },
     itemInstance: {
-        // TODO instead of individual getMemoizedProp calls, use a wrapped getMemoizedProps or something (getProps: () => getMemoized({...})
         getProps: ({ tree, item, prev }) => {
             var _a, _b, _c;
-            return (Object.assign(Object.assign({}, prev === null || prev === void 0 ? void 0 : prev()), { draggable: (_c = (_b = (_a = tree.getConfig()).isItemDraggable) === null || _b === void 0 ? void 0 : _b.call(_a, item)) !== null && _c !== void 0 ? _c : true, onDragStart: item.getMemoizedProp("dnd/onDragStart", () => (e) => {
+            return (Object.assign(Object.assign({}, prev === null || prev === void 0 ? void 0 : prev()), { draggable: (_c = (_b = (_a = tree.getConfig()).isItemDraggable) === null || _b === void 0 ? void 0 : _b.call(_a, item)) !== null && _c !== void 0 ? _c : true, onDragStart: (e) => {
                     var _a, _b, _c;
                     const selectedItems = tree.getSelectedItems();
                     const items = selectedItems.includes(item) ? selectedItems : [item];
@@ -83,7 +86,7 @@ exports.dragAndDropFeature = {
                         draggedItems: items,
                         draggingOverItem: tree.getFocusedItem(),
                     });
-                }), onDragOver: item.getMemoizedProp("dnd/onDragOver", () => (e) => {
+                }, onDragOver: (e) => {
                     var _a, _b, _c;
                     const dataRef = tree.getDataRef();
                     const nextDragCode = (0, utils_1.getDragCode)(e, item, tree);
@@ -109,11 +112,11 @@ exports.dragAndDropFeature = {
                     tree.applySubStateUpdate("dnd", (state) => (Object.assign(Object.assign({}, state), { dragTarget: target, draggingOverItem: item })));
                     dataRef.current.lastAllowDrop = true;
                     e.preventDefault();
-                }), onDragLeave: item.getMemoizedProp("dnd/onDragLeave", () => () => {
+                }, onDragLeave: () => {
                     const dataRef = tree.getDataRef();
                     dataRef.current.lastDragCode = "no-drag";
                     tree.applySubStateUpdate("dnd", (state) => (Object.assign(Object.assign({}, state), { draggingOverItem: undefined, dragTarget: undefined })));
-                }), onDragEnd: item.getMemoizedProp("dnd/onDragEnd", () => (e) => {
+                }, onDragEnd: (e) => {
                     var _a, _b, _c, _d;
                     const draggedItems = (_a = tree.getState().dnd) === null || _a === void 0 ? void 0 : _a.draggedItems;
                     tree.applySubStateUpdate("dnd", null);
@@ -121,7 +124,7 @@ exports.dragAndDropFeature = {
                         return;
                     }
                     (_d = (_c = tree.getConfig()).onCompleteForeignDrop) === null || _d === void 0 ? void 0 : _d.call(_c, draggedItems);
-                }), onDrop: item.getMemoizedProp("dnd/onDrop", () => (e) => {
+                }, onDrop: (e) => {
                     var _a, _b, _c;
                     const dataRef = tree.getDataRef();
                     const target = (0, utils_1.getDropTarget)(e, item, tree);
@@ -140,7 +143,7 @@ exports.dragAndDropFeature = {
                         (_c = config.onDropForeignDragObject) === null || _c === void 0 ? void 0 : _c.call(config, e.dataTransfer, target);
                     }
                     // TODO rebuild tree?
-                }) }));
+                } }));
         },
         isDropTarget: ({ tree, item }) => {
             const target = tree.getDropTarget();

package/lib/cjs/features/drag-and-drop/types.d.ts

@@ -12,7 +12,7 @@ export type DragLineData = {
     indent: number;
     top: number;
     left: number;
-    right: number;
+    width: number;
 };
 export type DropTarget<T> = {
     item: ItemInstance<T>;
@@ -40,9 +40,9 @@ export type DragAndDropFeatureDef<T> = {
         setDndState?: SetStateFn<DndState<T> | undefined | null>;
         /** Defines the size of the area at the top and bottom of an item where, when an item is dropped, the item willö
          * be placed above or below the item within the same parent, as opposed to being placed inside the item.
-         * If `canDropInbetween` is `false`, this is ignored. */
+         * If `canReorder` is `false`, this is ignored. */
         reorderAreaPercentage?: number;
-        canDropInbetween?: boolean;
+        canReorder?: boolean;
         isItemDraggable?: (item: ItemInstance<T>) => boolean;
         canDrag?: (items: ItemInstance<T>[]) => boolean;
         canDrop?: (items: ItemInstance<T>[], target: DropTarget<T>) => boolean;

package/lib/cjs/features/drag-and-drop/utils.d.ts

@@ -2,4 +2,4 @@ import { ItemInstance, TreeInstance } from "../../types/core";
 import { DropTarget } from "./types";
 export declare const canDrop: (dataTransfer: DataTransfer | null, target: DropTarget<any>, tree: TreeInstance<any>) => boolean;
 export declare const getDragCode: (e: any, item: ItemInstance<any>, tree: TreeInstance<any>) => string;
-export declare const getDropTarget: (e: any, item: ItemInstance<any>, tree: TreeInstance<any>, canDropInbetween?: boolean | undefined) => DropTarget<any>;
+export declare const getDropTarget: (e: any, item: ItemInstance<any>, tree: TreeInstance<any>, canReorder?: boolean | undefined) => DropTarget<any>;

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

@@ -47,7 +47,7 @@ const getItemDropCategory = (item) => {
 const getTargetPlacement = (e, item, tree, canMakeChild) => {
     var _a, _b, _c;
     const config = tree.getConfig();
-    if (!config.canDropInbetween) {
+    if (!config.canReorder) {
         return canMakeChild
             ? { type: PlacementType.MakeChild }
             : { type: PlacementType.ReorderBelow };
@@ -105,7 +105,7 @@ const getNthParent = (item, n) => {
     }
     return getNthParent(item.getParent(), n);
 };
-const getDropTarget = (e, item, tree, canDropInbetween = tree.getConfig().canDropInbetween) => {
+const getDropTarget = (e, item, tree, canReorder = tree.getConfig().canReorder) => {
     var _a, _b, _c;
     const draggedItems = (_b = (_a = tree.getState().dnd) === null || _a === void 0 ? void 0 : _a.draggedItems) !== null && _b !== void 0 ? _b : [];
     const itemMeta = item.getItemMeta();
@@ -129,13 +129,13 @@ const getDropTarget = (e, item, tree, canDropInbetween = tree.getConfig().canDro
     const canBecomeSibling = parentTarget && (0, exports.canDrop)(e.dataTransfer, parentTarget, tree);
     const canMakeChild = (0, exports.canDrop)(e.dataTransfer, itemTarget, tree);
     const placement = getTargetPlacement(e, item, tree, canMakeChild);
-    if (!canDropInbetween &&
+    if (!canReorder &&
         parent &&
         canBecomeSibling &&
         placement.type !== PlacementType.MakeChild) {
         return parentTarget;
     }
-    if (!canDropInbetween && parent && !canBecomeSibling) {
+    if (!canReorder && parent && !canBecomeSibling) {
         // TODO! this breaks in story DND/Can Drop. Maybe move this logic into a composable DropTargetStrategy[] ?
         return (0, exports.getDropTarget)(e, parent, tree, false);
     }

package/lib/cjs/features/expand-all/feature.d.ts

@@ -1,6 +1,2 @@
 import { FeatureImplementation } from "../../types/core";
-import { ExpandAllFeatureDef } from "./types";
-import { MainFeatureDef } from "../main/types";
-import { TreeFeatureDef } from "../tree/types";
-import { SyncDataLoaderFeatureDef } from "../sync-data-loader/types";
-export declare const expandAllFeature: FeatureImplementation<any, ExpandAllFeatureDef, MainFeatureDef | TreeFeatureDef<any> | SyncDataLoaderFeatureDef<any> | ExpandAllFeatureDef>;
+export declare const expandAllFeature: FeatureImplementation;

package/lib/cjs/features/hotkeys-core/feature.d.ts

@@ -1,4 +1,2 @@
 import { FeatureImplementation } from "../../types/core";
-import { HotkeysCoreFeatureDef } from "./types";
-import { MainFeatureDef } from "../main/types";
-export declare const hotkeysCoreFeature: FeatureImplementation<any, HotkeysCoreFeatureDef<any>, MainFeatureDef | HotkeysCoreFeatureDef<any>>;
+export declare const hotkeysCoreFeature: FeatureImplementation;

package/lib/cjs/features/prop-memoization/feature.d.ts

@@ -0,0 +1,2 @@
+import { FeatureImplementation } from "../../types/core";
+export declare const propMemoizationFeature: FeatureImplementation;

package/lib/cjs/features/prop-memoization/feature.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propMemoizationFeature = void 0;
+const memoize = (props, dataRef) => {
+    var _a;
+    (_a = dataRef.memoizedProps) !== null && _a !== void 0 ? _a : (dataRef.memoizedProps = {});
+    for (const key in props) {
+        if (typeof props[key] === "function") {
+            if (key in dataRef.memoizedProps) {
+                props[key] = dataRef.memoizedProps[key];
+            }
+            else {
+                dataRef.memoizedProps[key] = props[key];
+            }
+        }
+    }
+    return props;
+};
+exports.propMemoizationFeature = {
+    key: "prop-memoization",
+    overwrites: [
+        "main",
+        "async-data-loader",
+        "sync-data-loader",
+        "drag-and-drop",
+        "expand-all",
+        "hotkeys-core",
+        "renaming",
+        "search",
+        "selection",
+    ],
+    treeInstance: {
+        getContainerProps: ({ tree, prev }) => {
+            var _a;
+            const dataRef = tree.getDataRef();
+            const props = (_a = prev === null || prev === void 0 ? void 0 : prev()) !== null && _a !== void 0 ? _a : {};
+            return memoize(props, dataRef.current);
+        },
+    },
+    itemInstance: {
+        getProps: ({ item, prev }) => {
+            var _a;
+            const dataRef = item.getDataRef();
+            const props = (_a = prev === null || prev === void 0 ? void 0 : prev()) !== null && _a !== void 0 ? _a : {};
+            return memoize(props, dataRef.current);
+        },
+    },
+};

package/lib/cjs/features/prop-memoization/types.d.ts

@@ -0,0 +1,10 @@
+export type PropMemoizationDataRef = {
+    memoizedProps?: Record<string, any>;
+};
+export type PropMemoizationFeatureDef = {
+    state: {};
+    config: {};
+    treeInstance: {};
+    itemInstance: {};
+    hotkeys: never;
+};

package/lib/cjs/features/prop-memoization/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/features/renaming/feature.d.ts

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

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

@@ -10,14 +10,6 @@ exports.renamingFeature = {
         renamingValue: "setRenamingValue",
     },
     treeInstance: {
-        startRenamingItem: ({ tree }, itemId) => {
-            const item = tree.getItemInstance(itemId);
-            if (!item.canRename()) {
-                return;
-            }
-            tree.applySubStateUpdate("renamingItem", itemId);
-            tree.applySubStateUpdate("renamingValue", item.getItemName());
-        },
         getRenamingItem: ({ tree }) => {
             const itemId = tree.getState().renamingItem;
             return itemId ? tree.getItemInstance(itemId) : null;
@@ -40,6 +32,13 @@ exports.renamingFeature = {
         isRenamingItem: ({ tree }) => !!tree.getState().renamingItem,
     },
     itemInstance: {
+        startRenaming: ({ tree, item, itemId }) => {
+            if (!item.canRename()) {
+                return;
+            }
+            tree.applySubStateUpdate("renamingItem", itemId);
+            tree.applySubStateUpdate("renamingValue", item.getItemName());
+        },
         getRenameInputProps: ({ tree }) => ({
             onBlur: () => tree.abortRenaming(),
             value: tree.getRenamingValue(),
@@ -56,7 +55,7 @@ exports.renamingFeature = {
         renameItem: {
             hotkey: "F2",
             handler: (e, tree) => {
-                tree.startRenamingItem(tree.getFocusedItem().getId());
+                tree.getFocusedItem().startRenaming();
             },
         },
         abortRenaming: {

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

@@ -11,7 +11,6 @@ export type RenamingFeatureDef<T> = {
         onRename?: (item: ItemInstance<T>, value: string) => void;
     };
     treeInstance: {
-        startRenamingItem: (itemId: string) => void;
         getRenamingItem: () => ItemInstance<T> | null;
         getRenamingValue: () => string;
         abortRenaming: () => void;
@@ -22,6 +21,7 @@ export type RenamingFeatureDef<T> = {
         getRenameInputProps: () => any;
         canRename: () => boolean;
         isRenaming: () => boolean;
+        startRenaming: () => void;
     };
     hotkeys: "renameItem" | "abortRenaming" | "completeRenaming";
 };

package/lib/cjs/features/search/feature.d.ts

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

package/lib/cjs/features/selection/feature.d.ts

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

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

@@ -19,15 +19,15 @@ exports.selectionFeature = {
         },
     },
     itemInstance: {
-        select: ({ tree, item }) => {
+        select: ({ tree, itemId }) => {
             const { selectedItems } = tree.getState();
-            tree.setSelectedItems(selectedItems.includes(item.getItemMeta().itemId)
+            tree.setSelectedItems(selectedItems.includes(itemId)
                 ? selectedItems
-                : [...selectedItems, item.getItemMeta().itemId]);
+                : [...selectedItems, itemId]);
         },
-        deselect: ({ tree, item }) => {
+        deselect: ({ tree, itemId }) => {
             const { selectedItems } = tree.getState();
-            tree.setSelectedItems(selectedItems.filter((id) => id !== item.getItemMeta().itemId));
+            tree.setSelectedItems(selectedItems.filter((id) => id !== itemId));
         },
         isSelected: ({ tree, item }) => {
             const { selectedItems } = tree.getState();
@@ -60,7 +60,7 @@ exports.selectionFeature = {
                 item.select();
             }
         },
-        getProps: ({ tree, item, prev }) => (Object.assign(Object.assign({}, prev === null || prev === void 0 ? void 0 : prev()), { "aria-selected": item.isSelected() ? "true" : "false", onClick: item.getMemoizedProp("selection/onClick", () => (e) => {
+        getProps: ({ tree, item, prev }) => (Object.assign(Object.assign({}, prev === null || prev === void 0 ? void 0 : prev()), { "aria-selected": item.isSelected() ? "true" : "false", onClick: (e) => {
                 var _a, _b;
                 if (e.shiftKey) {
                     item.selectUpTo(e.ctrlKey || e.metaKey);
@@ -72,7 +72,7 @@ exports.selectionFeature = {
                     tree.setSelectedItems([item.getItemMeta().itemId]);
                 }
                 (_b = (_a = prev === null || prev === void 0 ? void 0 : prev()) === null || _a === void 0 ? void 0 : _a.onClick) === null || _b === void 0 ? void 0 : _b.call(_a, e);
-            }) })),
+            } })),
     },
     hotkeys: {
         // setSelectedItem: {
@@ -88,27 +88,37 @@ exports.selectionFeature = {
             },
         },
         selectUpwards: {
-            hotkey: "shift+ArrowUp",
-            handler: () => {
-                // TODO
+            hotkey: "Shift+ArrowUp",
+            handler: (e, tree) => {
+                const focused = tree.getFocusedItem();
+                const above = focused.getItemAbove();
+                if (!above)
+                    return;
+                if (focused.isSelected() && above.isSelected()) {
+                    focused.deselect();
+                }
+                else {
+                    above.select();
+                }
+                above.setFocused();
+                tree.updateDomFocus();
             },
         },
         selectDownwards: {
-            hotkey: "shift+ArrowDown",
-            handler: () => {
-                // TODO
-            },
-        },
-        selectUpwardsCtrl: {
-            hotkey: "shift+ctrl+ArrowUp",
-            handler: () => {
-                // TODO
-            },
-        },
-        selectDownwardsCtrl: {
-            hotkey: "shift+ctrl+ArrowUp",
-            handler: () => {
-                // TODO
+            hotkey: "Shift+ArrowDown",
+            handler: (e, tree) => {
+                const focused = tree.getFocusedItem();
+                const below = focused.getItemBelow();
+                if (!below)
+                    return;
+                if (focused.isSelected() && below.isSelected()) {
+                    focused.deselect();
+                }
+                else {
+                    below.select();
+                }
+                below.setFocused();
+                tree.updateDomFocus();
             },
         },
         selectAll: {

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

@@ -17,5 +17,5 @@ export type SelectionFeatureDef<T> = {
         isSelected: () => boolean;
         selectUpTo: (ctrl: boolean) => void;
     };
-    hotkeys: "toggleSelectItem" | "selectUpwards" | "selectDownwards" | "selectUpwardsCtrl" | "selectDownwardsCtrl" | "selectAll";
+    hotkeys: "toggleSelectItem" | "selectUpwards" | "selectDownwards" | "selectAll";
 };

package/lib/cjs/features/sync-data-loader/feature.d.ts

@@ -1,4 +1,2 @@
 import { FeatureImplementation } from "../../types/core";
-import { SyncDataLoaderFeatureDef } from "./types";
-import { MainFeatureDef } from "../main/types";
-export declare const syncDataLoaderFeature: FeatureImplementation<any, SyncDataLoaderFeatureDef<any>, MainFeatureDef | SyncDataLoaderFeatureDef<any>>;
+export declare const syncDataLoaderFeature: FeatureImplementation;

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

@@ -1,7 +1,2 @@
 import { FeatureImplementation } from "../../types/core";
-import { TreeFeatureDef } from "./types";
-import { MainFeatureDef } from "../main/types";
-import { HotkeysCoreFeatureDef } from "../hotkeys-core/types";
-import { SyncDataLoaderFeatureDef } from "../sync-data-loader/types";
-import { SearchFeatureDef } from "../search/types";
-export declare const treeFeature: FeatureImplementation<any, TreeFeatureDef<any>, MainFeatureDef | TreeFeatureDef<any> | HotkeysCoreFeatureDef<any> | SyncDataLoaderFeatureDef<any> | SearchFeatureDef<any>>;
+export declare const treeFeature: FeatureImplementation<any>;