@headless-tree/core 0.0.0-20250511185653 → 0.0.0-20250511194715

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

@@ -119,7 +119,7 @@ export const selectionFeature = {
             },
         },
         selectAll: {
-            hotkey: "Control+a",
+            hotkey: "Control+KeyA",
             preventDefault: true,
             handler: (e, tree) => {
                 tree.setSelectedItems(tree.getItems().map((item) => item.getId()));

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

@@ -37,6 +37,8 @@ export const syncDataLoaderFeature = {
             }
             return unpromise(dataLoader.getChildrenWithData(itemId)).map((c) => c.data);
         },
+        loadItemData: ({ tree }, itemId) => tree.retrieveItemData(itemId),
+        loadChildrenIds: ({ tree }, itemId) => tree.retrieveChildrenIds(itemId),
     },
     itemInstance: {
         isLoading: () => false,

package/lib/esm/index.d.ts

@@ -5,7 +5,6 @@ export { MainFeatureDef, InstanceBuilder } from "./features/main/types";
 export * from "./features/drag-and-drop/types";
 export * from "./features/keyboard-drag-and-drop/types";
 export * from "./features/selection/types";
-export * from "./features/checkboxes/types";
 export * from "./features/async-data-loader/types";
 export * from "./features/sync-data-loader/types";
 export * from "./features/hotkeys-core/types";
@@ -14,7 +13,6 @@ 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/checkboxes/feature";
 export * from "./features/hotkeys-core/feature";
 export * from "./features/async-data-loader/feature";
 export * from "./features/sync-data-loader/feature";

package/lib/esm/index.js

@@ -4,7 +4,6 @@ export * from "./features/tree/types";
 export * from "./features/drag-and-drop/types";
 export * from "./features/keyboard-drag-and-drop/types";
 export * from "./features/selection/types";
-export * from "./features/checkboxes/types";
 export * from "./features/async-data-loader/types";
 export * from "./features/sync-data-loader/types";
 export * from "./features/hotkeys-core/types";
@@ -13,7 +12,6 @@ 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/checkboxes/feature";
 export * from "./features/hotkeys-core/feature";
 export * from "./features/async-data-loader/feature";
 export * from "./features/sync-data-loader/feature";

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

@@ -10,7 +10,6 @@ import { RenamingFeatureDef } from "../features/renaming/types";
 import { ExpandAllFeatureDef } from "../features/expand-all/types";
 import { PropMemoizationFeatureDef } from "../features/prop-memoization/types";
 import { KeyboardDragAndDropFeatureDef } from "../features/keyboard-drag-and-drop/types";
-import { CheckboxesFeatureDef } from "../features/checkboxes/types";
 export type Updater<T> = T | ((old: T) => T);
 export type SetStateFn<T> = (updaterOrValue: Updater<T>) => void;
 export type FeatureDef = {
@@ -35,7 +34,7 @@ type MergedFeatures<F extends FeatureDef> = {
     itemInstance: UnionToIntersection<F["itemInstance"]>;
     hotkeys: F["hotkeys"];
 };
-export type RegisteredFeatures<T> = MainFeatureDef<T> | TreeFeatureDef<T> | SelectionFeatureDef<T> | CheckboxesFeatureDef<T> | DragAndDropFeatureDef<T> | KeyboardDragAndDropFeatureDef<T> | HotkeysCoreFeatureDef<T> | SyncDataLoaderFeatureDef<T> | AsyncDataLoaderFeatureDef<T> | SearchFeatureDef<T> | RenamingFeatureDef<T> | ExpandAllFeatureDef | PropMemoizationFeatureDef;
+export type RegisteredFeatures<T> = MainFeatureDef<T> | TreeFeatureDef<T> | SelectionFeatureDef<T> | DragAndDropFeatureDef<T> | KeyboardDragAndDropFeatureDef<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> {
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@headless-tree/core",
-  "version": "0.0.0-20250511185653",
+  "version": "0.0.0-20250511194715",
   "type": "module",
   "main": "lib/cjs/index.js",
   "module": "lib/esm/index.js",

package/src/core/create-tree.ts

@@ -151,19 +151,6 @@ export const createTree = <T>(
         ] as Function;
         externalStateSetter?.(state[stateName]);
       },
-      buildItemInstance: ({}, itemId) => {
-        const [instance, finalizeInstance] = buildInstance(
-          features,
-          "itemInstance",
-          (instance) => ({
-            item: instance,
-            tree: treeInstance,
-            itemId,
-          }),
-        );
-        finalizeInstance();
-        return instance;
-      },
       // TODO rebuildSubTree: (itemId: string) => void;
       rebuildTree: () => {
         rebuildItemMeta();

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

@@ -20,23 +20,21 @@ const loadItemData = async <T>(tree: TreeInstance<T>, itemId: string) => {
     loadingItemData.filter((id) => id !== itemId),
   );
 
-  dataRef.current.awaitingItemDataLoading?.[itemId].forEach((cb) => cb());
-  delete dataRef.current.awaitingItemDataLoading?.[itemId];
+  return item;
 };
 
 const loadChildrenIds = async <T>(tree: TreeInstance<T>, itemId: string) => {
   const config = tree.getConfig();
   const dataRef = getDataRef(tree);
+  let childrenIds: string[];
 
   if ("getChildrenWithData" in config.dataLoader) {
     const children = await config.dataLoader.getChildrenWithData(itemId);
-    const childrenIds = children.map((c) => c.id);
+    childrenIds = children.map((c) => c.id);
     dataRef.current.childrenIds[itemId] = childrenIds;
     children.forEach(({ id, data }) => {
       dataRef.current.itemData[id] = data;
       config.onLoadedItem?.(id, data);
-      dataRef.current.awaitingItemDataLoading?.[id].forEach((cb) => cb());
-      delete dataRef.current.awaitingItemDataLoading?.[id];
     });
 
     config.onLoadedChildren?.(itemId, childrenIds);
@@ -45,7 +43,7 @@ const loadChildrenIds = async <T>(tree: TreeInstance<T>, itemId: string) => {
       loadingItemData.filter((id) => !childrenIds.includes(id)),
     );
   } else {
-    const childrenIds = await config.dataLoader.getChildren(itemId);
+    childrenIds = await config.dataLoader.getChildren(itemId);
     dataRef.current.childrenIds[itemId] = childrenIds;
     config.onLoadedChildren?.(itemId, childrenIds);
     tree.rebuildTree();
@@ -55,8 +53,7 @@ const loadChildrenIds = async <T>(tree: TreeInstance<T>, itemId: string) => {
     loadingItemChildrens.filter((id) => id !== itemId),
   );
 
-  dataRef.current.awaitingItemChildrensLoading?.[itemId]?.forEach((cb) => cb());
-  delete dataRef.current.awaitingItemChildrensLoading?.[itemId];
+  return childrenIds;
 };
 
 export const asyncDataLoaderFeature: FeatureImplementation = {
@@ -80,33 +77,25 @@ export const asyncDataLoaderFeature: FeatureImplementation = {
   },
 
   treeInstance: {
-    waitForItemDataLoaded: async ({ tree }, itemId) => {
-      tree.retrieveItemData(itemId);
-      if (!tree.getState().loadingItemData.includes(itemId)) {
-        return;
-      }
-      await new Promise<void>((resolve) => {
-        const dataRef = tree.getDataRef<AsyncDataLoaderDataRef>();
-        dataRef.current.awaitingItemDataLoading ??= {};
-        dataRef.current.awaitingItemDataLoading[itemId] ??= [];
-        dataRef.current.awaitingItemDataLoading[itemId].push(resolve);
-      });
-    },
+    waitForItemDataLoaded: ({ tree }, itemId) => tree.loadItemData(itemId),
 
-    waitForItemChildrenLoaded: async ({ tree }, itemId) => {
-      tree.retrieveChildrenIds(itemId);
-      if (!tree.getState().loadingItemChildrens.includes(itemId)) {
-        return;
-      }
-      await new Promise<void>((resolve) => {
-        const dataRef = tree.getDataRef<AsyncDataLoaderDataRef>();
-        dataRef.current.awaitingItemChildrensLoading ??= {};
-        dataRef.current.awaitingItemChildrensLoading[itemId] ??= [];
-        dataRef.current.awaitingItemChildrensLoading[itemId].push(resolve);
-      });
+    waitForItemChildrenLoaded: ({ tree }, itemId) =>
+      tree.loadChildrenIds(itemId),
+
+    loadItemData: async ({ tree }, itemId) => {
+      return (
+        getDataRef(tree).current.itemData[itemId] ??
+        (await loadItemData(tree, itemId))
+      );
+    },
+    loadChildrenIds: async ({ tree }, itemId) => {
+      return (
+        getDataRef(tree).current.childrenIds[itemId] ??
+        (await loadChildrenIds(tree, itemId))
+      );
     },
 
-    retrieveItemData: ({ tree }, itemId, skipFetch = false) => {
+    retrieveItemData: ({ tree }, itemId) => {
       const config = tree.getConfig();
       const dataRef = getDataRef(tree);
 
@@ -114,7 +103,7 @@ export const asyncDataLoaderFeature: FeatureImplementation = {
         return dataRef.current.itemData[itemId];
       }
 
-      if (!tree.getState().loadingItemData.includes(itemId) && !skipFetch) {
+      if (!tree.getState().loadingItemData.includes(itemId)) {
         tree.applySubStateUpdate("loadingItemData", (loadingItemData) => [
           ...loadingItemData,
           itemId,
@@ -126,13 +115,13 @@ export const asyncDataLoaderFeature: FeatureImplementation = {
       return config.createLoadingItemData?.() ?? null;
     },
 
-    retrieveChildrenIds: ({ tree }, itemId, skipFetch = false) => {
+    retrieveChildrenIds: ({ tree }, itemId) => {
       const dataRef = getDataRef(tree);
       if (dataRef.current.childrenIds[itemId]) {
         return dataRef.current.childrenIds[itemId];
       }
 
-      if (tree.getState().loadingItemChildrens.includes(itemId) || skipFetch) {
+      if (tree.getState().loadingItemChildrens.includes(itemId)) {
         return [];
       }
 

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

@@ -1,13 +1,9 @@
 import { SetStateFn } from "../../types/core";
 import { SyncDataLoaderFeatureDef } from "../sync-data-loader/types";
 
-type AwaitingLoaderCallbacks = Record<string, (() => void)[]>;
-
 export interface AsyncDataLoaderDataRef<T = any> {
   itemData: Record<string, T>;
   childrenIds: Record<string, string[]>;
-  awaitingItemDataLoading: AwaitingLoaderCallbacks;
-  awaitingItemChildrensLoading: AwaitingLoaderCallbacks;
 }
 
 /**
@@ -32,8 +28,12 @@ export type AsyncDataLoaderFeatureDef<T> = {
     onLoadedChildren?: (itemId: string, childrenIds: string[]) => void;
   };
   treeInstance: SyncDataLoaderFeatureDef<T>["treeInstance"] & {
+    /** @deprecated use loadItemData instead */
     waitForItemDataLoaded: (itemId: string) => Promise<void>;
+    /** @deprecated use loadChildrenIds instead */
     waitForItemChildrenLoaded: (itemId: string) => Promise<void>;
+    loadItemData: (itemId: string) => Promise<T>;
+    loadChildrenIds: (itemId: string) => Promise<string[]>;
   };
   itemInstance: SyncDataLoaderFeatureDef<T>["itemInstance"] & {
     /** Invalidate fetched data for item, and triggers a refetch and subsequent rerender if the item is visible

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

@@ -50,7 +50,7 @@ export const expandAllFeature: FeatureImplementation = {
       handler: async (_, tree) => {
         const cancelToken = { current: false };
         const cancelHandler = (e: KeyboardEvent) => {
-          if (e.key === "Escape") {
+          if (e.code === "Escape") {
             cancelToken.current = true;
           }
         };
@@ -63,7 +63,7 @@ export const expandAllFeature: FeatureImplementation = {
     },
 
     collapseSelected: {
-      hotkey: "Control+Shift+-",
+      hotkey: "Control+Shift+Minus",
       handler: (_, tree) => {
         tree.getSelectedItems().forEach((item) => item.collapseAll());
       },

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

@@ -6,10 +6,13 @@ import {
 import { HotkeyConfig, HotkeysCoreDataRef } from "./types";
 
 const specialKeys: Record<string, RegExp> = {
-  Letter: /^[a-z]$/,
-  LetterOrNumber: /^[a-z0-9]$/,
-  Plus: /^\+$/,
-  Space: /^ $/,
+  // TODO:breaking deprecate auto-lowercase
+  letter: /^Key[A-Z]$/,
+  letterornumber: /^(Key[A-Z]|Digit[0-9])$/,
+  plus: /^(NumpadAdd|Plus)$/,
+  minus: /^(NumpadSubtract|Minus)$/,
+  control: /^(ControlLeft|ControlRight)$/,
+  shift: /^(ShiftLeft|ShiftRight)$/,
 };
 
 const testHotkeyMatch = (
@@ -17,12 +20,28 @@ const testHotkeyMatch = (
   tree: TreeInstance<any>,
   hotkey: HotkeyConfig<any>,
 ) => {
-  const supposedKeys = hotkey.hotkey.toLowerCase().split("+");
-  const doKeysMatch = supposedKeys.every((key) =>
-    key in specialKeys
-      ? [...pressedKeys].some((pressedKey) => specialKeys[key].test(pressedKey))
-      : pressedKeys.has(key),
-  );
+  const supposedKeys = hotkey.hotkey.toLowerCase().split("+"); // TODO:breaking deprecate auto-lowercase
+  const doKeysMatch = supposedKeys.every((key) => {
+    if (key in specialKeys) {
+      return [...pressedKeys].some((pressedKey) =>
+        specialKeys[key].test(pressedKey),
+      );
+    }
+
+    const pressedKeysLowerCase = [...pressedKeys] // TODO:breaking deprecate auto-lowercase
+      .map((k) => k.toLowerCase());
+
+    if (pressedKeysLowerCase.includes(key.toLowerCase())) {
+      return true;
+    }
+
+    if (pressedKeysLowerCase.includes(`key${key.toLowerCase()}`)) {
+      // TODO:breaking deprecate e.key character matching
+      return true;
+    }
+
+    return false;
+  });
   const isEnabled = !hotkey.isEnabled || hotkey.isEnabled(tree);
   const equalCounts = pressedKeys.size === supposedKeys.length;
   return doKeysMatch && isEnabled && equalCounts;
@@ -50,10 +69,9 @@ export const hotkeysCoreFeature: FeatureImplementation = {
         return;
       }
 
-      const key = e.key.toLowerCase();
       data.current.pressedKeys ??= new Set();
-      const newMatch = !data.current.pressedKeys.has(key);
-      data.current.pressedKeys.add(key);
+      const newMatch = !data.current.pressedKeys.has(e.code);
+      data.current.pressedKeys.add(e.code);
 
       const hotkeyName = findHotkeyMatch(
         data.current.pressedKeys,
@@ -65,7 +83,7 @@ export const hotkeysCoreFeature: FeatureImplementation = {
       if (e.target instanceof HTMLInputElement) {
         // JS respects composite keydowns while input elements are focused, and
         // doesnt send the associated keyup events with the same key name
-        data.current.pressedKeys.delete(key);
+        data.current.pressedKeys.delete(e.code);
       }
 
       if (!hotkeyName) return;
@@ -90,7 +108,7 @@ export const hotkeysCoreFeature: FeatureImplementation = {
 
     const keyup = (e: KeyboardEvent) => {
       data.current.pressedKeys ??= new Set();
-      data.current.pressedKeys.delete(e.key.toLowerCase());
+      data.current.pressedKeys.delete(e.code);
     };
 
     const reset = () => {

package/src/features/keyboard-drag-and-drop/feature.ts

@@ -187,7 +187,7 @@ export const keyboardDragAndDropFeature: FeatureImplementation = {
 
   hotkeys: {
     startDrag: {
-      hotkey: "Control+Shift+D",
+      hotkey: "Control+Shift+KeyD",
       preventDefault: true,
       isEnabled: (tree) => !tree.getState().dnd,
       handler: (_, tree) => {

package/src/features/main/types.ts

@@ -36,8 +36,6 @@ export type MainFeatureDef<T = any> = {
       stateName: K,
       updater: Updater<TreeState<T>[K]>,
     ) => void;
-    /** @internal */
-    buildItemInstance: (itemId: string) => ItemInstance<T>;
     setState: SetStateFn<TreeState<T>>;
     getState: () => TreeState<T>;
     setConfig: SetStateFn<TreeConfig<T>>;

package/src/features/selection/feature.ts

@@ -144,7 +144,7 @@ export const selectionFeature: FeatureImplementation = {
       },
     },
     selectAll: {
-      hotkey: "Control+a",
+      hotkey: "Control+KeyA",
       preventDefault: true,
       handler: (e, tree) => {
         tree.setSelectedItems(tree.getItems().map((item) => item.getId()));

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

@@ -47,6 +47,9 @@ export const syncDataLoaderFeature: FeatureImplementation = {
         (c) => c.data,
       );
     },
+
+    loadItemData: ({ tree }, itemId) => tree.retrieveItemData(itemId),
+    loadChildrenIds: ({ tree }, itemId) => tree.retrieveChildrenIds(itemId),
   },
 
   itemInstance: {

package/src/features/tree/types.ts

@@ -20,7 +20,7 @@ export type TreeFeatureDef<T> = {
     focusedItem: string | null;
   };
   config: {
-    isItemFolder: (item: ItemInstance<T>) => boolean; // TODO:breaking use item data as payload
+    isItemFolder: (item: ItemInstance<T>) => boolean;
     getItemName: (item: ItemInstance<T>) => string;
 
     onPrimaryAction?: (item: ItemInstance<T>) => void;

package/src/index.ts

@@ -6,7 +6,6 @@ export { MainFeatureDef, InstanceBuilder } from "./features/main/types";
 export * from "./features/drag-and-drop/types";
 export * from "./features/keyboard-drag-and-drop/types";
 export * from "./features/selection/types";
-export * from "./features/checkboxes/types";
 export * from "./features/async-data-loader/types";
 export * from "./features/sync-data-loader/types";
 export * from "./features/hotkeys-core/types";
@@ -16,7 +15,6 @@ export * from "./features/expand-all/types";
 export * from "./features/prop-memoization/types";
 
 export * from "./features/selection/feature";
-export * from "./features/checkboxes/feature";
 export * from "./features/hotkeys-core/feature";
 export * from "./features/async-data-loader/feature";
 export * from "./features/sync-data-loader/feature";

package/src/types/core.ts

@@ -13,7 +13,6 @@ import { RenamingFeatureDef } from "../features/renaming/types";
 import { ExpandAllFeatureDef } from "../features/expand-all/types";
 import { PropMemoizationFeatureDef } from "../features/prop-memoization/types";
 import { KeyboardDragAndDropFeatureDef } from "../features/keyboard-drag-and-drop/types";
-import { CheckboxesFeatureDef } from "../features/checkboxes/types";
 
 export type Updater<T> = T | ((old: T) => T);
 export type SetStateFn<T> = (updaterOrValue: Updater<T>) => void;
@@ -54,7 +53,6 @@ export type RegisteredFeatures<T> =
   | MainFeatureDef<T>
   | TreeFeatureDef<T>
   | SelectionFeatureDef<T>
-  | CheckboxesFeatureDef<T>
   | DragAndDropFeatureDef<T>
   | KeyboardDragAndDropFeatureDef<T>
   | HotkeysCoreFeatureDef<T>

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

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

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

@@ -1,94 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkboxesFeature = void 0;
-const utils_1 = require("../../utils");
-const types_1 = require("./types");
-const errors_1 = require("../../utilities/errors");
-const getAllLoadedDescendants = (tree, itemId) => {
-    if (!tree.getConfig().isItemFolder(tree.buildItemInstance(itemId))) {
-        return [itemId];
-    }
-    return tree
-        .retrieveChildrenIds(itemId)
-        .map((child) => getAllLoadedDescendants(tree, child))
-        .flat();
-};
-exports.checkboxesFeature = {
-    key: "checkboxes",
-    overwrites: ["selection"],
-    getInitialState: (initialState) => (Object.assign({ checkedItems: [] }, initialState)),
-    getDefaultConfig: (defaultConfig, tree) => {
-        var _a;
-        const hasAsyncLoader = (_a = defaultConfig.features) === null || _a === void 0 ? void 0 : _a.some((f) => f.key === "async-data-loader");
-        if (hasAsyncLoader && !defaultConfig.canCheckFolders) {
-            (0, errors_1.throwError)(`!canCheckFolders not supported with async trees`);
-        }
-        return Object.assign({ setCheckedItems: (0, utils_1.makeStateUpdater)("checkedItems", tree), canCheckFolders: hasAsyncLoader !== null && hasAsyncLoader !== void 0 ? hasAsyncLoader : false }, defaultConfig);
-    },
-    stateHandlerNames: {
-        checkedItems: "setCheckedItems",
-    },
-    treeInstance: {
-        setCheckedItems: ({ tree }, checkedItems) => {
-            tree.applySubStateUpdate("checkedItems", checkedItems);
-        },
-    },
-    itemInstance: {
-        getCheckboxProps: ({ item }) => {
-            const checkedState = item.getCheckedState();
-            return {
-                onChange: item.toggleCheckedState,
-                checked: checkedState === types_1.CheckedState.Checked,
-                ref: (r) => {
-                    if (r) {
-                        r.indeterminate = checkedState === types_1.CheckedState.Indeterminate;
-                    }
-                },
-            };
-        },
-        toggleCheckedState: ({ item }) => {
-            if (item.getCheckedState() === types_1.CheckedState.Checked) {
-                item.setUnchecked();
-            }
-            else {
-                item.setChecked();
-            }
-        },
-        getCheckedState: ({ item, tree, itemId }) => {
-            const { checkedItems } = tree.getState();
-            if (checkedItems.includes(itemId)) {
-                return types_1.CheckedState.Checked;
-            }
-            if (item.isFolder() && !tree.getConfig().canCheckFolders) {
-                const descendants = getAllLoadedDescendants(tree, itemId);
-                if (descendants.every((d) => checkedItems.includes(d))) {
-                    return types_1.CheckedState.Checked;
-                }
-                if (descendants.some((d) => checkedItems.includes(d))) {
-                    return types_1.CheckedState.Indeterminate;
-                }
-            }
-            return types_1.CheckedState.Unchecked;
-        },
-        setChecked: ({ item, tree, itemId }) => {
-            if (!item.isFolder() || tree.getConfig().canCheckFolders) {
-                tree.applySubStateUpdate("checkedItems", (items) => [...items, itemId]);
-            }
-            else {
-                tree.applySubStateUpdate("checkedItems", (items) => [
-                    ...items,
-                    ...getAllLoadedDescendants(tree, itemId),
-                ]);
-            }
-        },
-        setUnchecked: ({ item, tree, itemId }) => {
-            if (!item.isFolder() || tree.getConfig().canCheckFolders) {
-                tree.applySubStateUpdate("checkedItems", (items) => items.filter((id) => id !== itemId));
-            }
-            else {
-                const descendants = getAllLoadedDescendants(tree, itemId);
-                tree.applySubStateUpdate("checkedItems", (items) => items.filter((id) => !descendants.includes(id)));
-            }
-        },
-    },
-};

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

@@ -1,26 +0,0 @@
-import { SetStateFn } from "../../types/core";
-export declare enum CheckedState {
-    Checked = "checked",
-    Unchecked = "unchecked",
-    Indeterminate = "indeterminate"
-}
-export type CheckboxesFeatureDef<T> = {
-    state: {
-        checkedItems: string[];
-    };
-    config: {
-        setCheckedItems?: SetStateFn<string[]>;
-        canCheckFolders?: boolean;
-    };
-    treeInstance: {
-        setCheckedItems: (checkedItems: string[]) => void;
-    };
-    itemInstance: {
-        setChecked: () => void;
-        setUnchecked: () => void;
-        toggleCheckedState: () => void;
-        getCheckedState: () => CheckedState;
-        getCheckboxProps: () => Record<string, any>;
-    };
-    hotkeys: never;
-};

package/lib/cjs/features/checkboxes/types.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CheckedState = void 0;
-var CheckedState;
-(function (CheckedState) {
-    CheckedState["Checked"] = "checked";
-    CheckedState["Unchecked"] = "unchecked";
-    CheckedState["Indeterminate"] = "indeterminate";
-})(CheckedState || (exports.CheckedState = CheckedState = {}));

package/lib/esm/features/checkboxes/feature.d.ts

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