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

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/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/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;

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

@@ -1,91 +0,0 @@
-import { makeStateUpdater } from "../../utils";
-import { CheckedState } from "./types";
-import { throwError } from "../../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();
-};
-export const 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) {
-            throwError(`!canCheckFolders not supported with async trees`);
-        }
-        return Object.assign({ setCheckedItems: 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 === CheckedState.Checked,
-                ref: (r) => {
-                    if (r) {
-                        r.indeterminate = checkedState === CheckedState.Indeterminate;
-                    }
-                },
-            };
-        },
-        toggleCheckedState: ({ item }) => {
-            if (item.getCheckedState() === CheckedState.Checked) {
-                item.setUnchecked();
-            }
-            else {
-                item.setChecked();
-            }
-        },
-        getCheckedState: ({ item, tree, itemId }) => {
-            const { checkedItems } = tree.getState();
-            if (checkedItems.includes(itemId)) {
-                return CheckedState.Checked;
-            }
-            if (item.isFolder() && !tree.getConfig().canCheckFolders) {
-                const descendants = getAllLoadedDescendants(tree, itemId);
-                if (descendants.every((d) => checkedItems.includes(d))) {
-                    return CheckedState.Checked;
-                }
-                if (descendants.some((d) => checkedItems.includes(d))) {
-                    return CheckedState.Indeterminate;
-                }
-            }
-            return 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/esm/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/esm/features/checkboxes/types.js

@@ -1,6 +0,0 @@
-export var CheckedState;
-(function (CheckedState) {
-    CheckedState["Checked"] = "checked";
-    CheckedState["Unchecked"] = "unchecked";
-    CheckedState["Indeterminate"] = "indeterminate";
-})(CheckedState || (CheckedState = {}));

package/src/features/checkboxes/checkboxes.spec.ts

@@ -1,134 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { TestTree } from "../../test-utils/test-tree";
-import { checkboxesFeature } from "./feature";
-import { CheckedState } from "./types";
-
-const factory = TestTree.default({})
-  .withFeatures(checkboxesFeature)
-  .suits.sync().tree;
-
-describe("core-feature/checkboxes", () => {
-  it("should initialize with no checked items", async () => {
-    const tree = await factory.createTestCaseTree();
-    expect(tree.instance.getState().checkedItems).toEqual([]);
-  });
-
-  it("should check items", async () => {
-    const tree = await factory.createTestCaseTree();
-    tree.item("x111").setChecked();
-    tree.item("x112").setChecked();
-    expect(tree.instance.getState().checkedItems).toEqual(["x111", "x112"]);
-  });
-
-  it("should uncheck an item", async () => {
-    const tree = await factory
-      .with({ state: { checkedItems: ["x111"] } })
-      .createTestCaseTree();
-    tree.item("x111").setUnchecked();
-    expect(tree.instance.getState().checkedItems).not.toContain("x111");
-  });
-
-  it("should toggle checked state", async () => {
-    const tree = await factory.createTestCaseTree();
-    const item = tree.item("x111");
-
-    item.toggleCheckedState();
-    expect(tree.instance.getState().checkedItems).toContain("x111");
-
-    item.toggleCheckedState();
-    expect(tree.instance.getState().checkedItems).not.toContain("x111");
-  });
-
-  describe("props", () => {
-    it("should toggle checked state", async () => {
-      const tree = await factory.createTestCaseTree();
-      const item = tree.item("x111");
-
-      item.getCheckboxProps().onChange();
-      expect(tree.instance.getState().checkedItems).toContain("x111");
-
-      item.getCheckboxProps().onChange();
-      expect(tree.instance.getState().checkedItems).not.toContain("x111");
-    });
-
-    it("should return checked state in props", async () => {
-      const tree = await factory.createTestCaseTree();
-      tree.item("x111").setChecked();
-      expect(tree.item("x111").getCheckboxProps().checked).toBe(true);
-      expect(tree.item("x112").getCheckboxProps().checked).toBe(false);
-    });
-
-    it("should create indeterminate state", async () => {
-      const tree = await factory.createTestCaseTree();
-      tree.item("x111").setChecked();
-      const refObject = { indeterminate: undefined };
-      tree.item("x11").getCheckboxProps().ref(refObject);
-      expect(refObject.indeterminate).toBe(true);
-    });
-
-    it("should not create indeterminate state", async () => {
-      const tree = await factory.createTestCaseTree();
-      const refObject = { indeterminate: undefined };
-      tree.item("x11").getCheckboxProps().ref(refObject);
-      expect(refObject.indeterminate).toBe(false);
-    });
-  });
-
-  it("should handle folder checking when canCheckFolders is true", async () => {
-    const tree = await factory
-      .with({ canCheckFolders: true })
-      .createTestCaseTree();
-
-    tree.item("x11").setChecked();
-    expect(tree.instance.getState().checkedItems).toContain("x11");
-  });
-
-  it("should handle folder checking when canCheckFolders is false", async () => {
-    const tree = await factory.createTestCaseTree();
-
-    tree.item("x11").setChecked();
-    expect(tree.instance.getState().checkedItems).toEqual(
-      expect.arrayContaining(["x111", "x112", "x113", "x114"]),
-    );
-  });
-
-  it("should turn folder indeterminate", async () => {
-    const tree = await factory.createTestCaseTree();
-
-    tree.item("x111").setChecked();
-    expect(tree.item("x11").getCheckedState()).toBe(CheckedState.Indeterminate);
-  });
-
-  it("should turn folder checked if all children are checked", async () => {
-    const tree = await factory
-      .with({
-        isItemFolder: (item) => item.getItemData().length < 4,
-      })
-      .createTestCaseTree();
-
-    tree.item("x11").setChecked();
-    tree.item("x12").setChecked();
-    tree.item("x13").setChecked();
-    expect(tree.item("x1").getCheckedState()).toBe(CheckedState.Indeterminate);
-    tree.do.selectItem("x14");
-    tree.item("x141").setChecked();
-    tree.item("x142").setChecked();
-    tree.item("x143").setChecked();
-    expect(tree.item("x1").getCheckedState()).toBe(CheckedState.Indeterminate);
-    tree.item("x144").setChecked();
-    expect(tree.item("x1").getCheckedState()).toBe(CheckedState.Checked);
-  });
-
-  it("should return correct checked state for items", async () => {
-    const tree = await factory.createTestCaseTree();
-    const item = tree.instance.getItemInstance("x111");
-
-    expect(item.getCheckedState()).toBe(CheckedState.Unchecked);
-
-    item.setChecked();
-    expect(item.getCheckedState()).toBe(CheckedState.Checked);
-
-    item.setUnchecked();
-    expect(item.getCheckedState()).toBe(CheckedState.Unchecked);
-  });
-});

package/src/features/checkboxes/feature.ts

@@ -1,119 +0,0 @@
-import { FeatureImplementation, TreeInstance } from "../../types/core";
-import { makeStateUpdater } from "../../utils";
-import { CheckedState } from "./types";
-import { throwError } from "../../utilities/errors";
-
-const getAllLoadedDescendants = <T>(
-  tree: TreeInstance<T>,
-  itemId: string,
-): string[] => {
-  if (!tree.getConfig().isItemFolder(tree.buildItemInstance(itemId))) {
-    return [itemId];
-  }
-  return tree
-    .retrieveChildrenIds(itemId)
-    .map((child) => getAllLoadedDescendants(tree, child))
-    .flat();
-};
-
-export const checkboxesFeature: FeatureImplementation = {
-  key: "checkboxes",
-
-  overwrites: ["selection"],
-
-  getInitialState: (initialState) => ({
-    checkedItems: [],
-    ...initialState,
-  }),
-
-  getDefaultConfig: (defaultConfig, tree) => {
-    const hasAsyncLoader = defaultConfig.features?.some(
-      (f) => f.key === "async-data-loader",
-    );
-    if (hasAsyncLoader && !defaultConfig.canCheckFolders) {
-      throwError(`!canCheckFolders not supported with async trees`);
-    }
-    return {
-      setCheckedItems: makeStateUpdater("checkedItems", tree),
-      canCheckFolders: 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 === CheckedState.Checked,
-        ref: (r: any) => {
-          if (r) {
-            r.indeterminate = checkedState === CheckedState.Indeterminate;
-          }
-        },
-      };
-    },
-
-    toggleCheckedState: ({ item }) => {
-      if (item.getCheckedState() === CheckedState.Checked) {
-        item.setUnchecked();
-      } else {
-        item.setChecked();
-      }
-    },
-
-    getCheckedState: ({ item, tree, itemId }) => {
-      const { checkedItems } = tree.getState();
-
-      if (checkedItems.includes(itemId)) {
-        return CheckedState.Checked;
-      }
-
-      if (item.isFolder() && !tree.getConfig().canCheckFolders) {
-        const descendants = getAllLoadedDescendants(tree, itemId);
-        if (descendants.every((d) => checkedItems.includes(d))) {
-          return CheckedState.Checked;
-        }
-        if (descendants.some((d) => checkedItems.includes(d))) {
-          return CheckedState.Indeterminate;
-        }
-      }
-
-      return 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/src/features/checkboxes/types.ts

@@ -1,28 +0,0 @@
-import { SetStateFn } from "../../types/core";
-
-export 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;
-};