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

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # @headless-tree/core
 
-## 0.0.0-20250509212452
+## 0.0.0-20250511185653
 
 ### Minor Changes
 

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

@@ -29,17 +29,14 @@ const loadItemData = (tree, itemId) => __awaiter(void 0, void 0, void 0, functio
     tree.applySubStateUpdate("loadingItemData", (loadingItemData) => loadingItemData.filter((id) => id !== itemId));
     (_b = dataRef.current.awaitingItemDataLoading) === null || _b === void 0 ? void 0 : _b[itemId].forEach((cb) => cb());
     (_c = dataRef.current.awaitingItemDataLoading) === null || _c === void 0 ? true : delete _c[itemId];
-    return item;
 });
 const loadChildrenIds = (tree, itemId) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b, _c, _d, _e;
     const config = tree.getConfig();
     const dataRef = getDataRef(tree);
-    let childrenIds;
-    // TODO is folder check?
     if ("getChildrenWithData" in config.dataLoader) {
         const children = yield config.dataLoader.getChildrenWithData(itemId);
-        childrenIds = children.map((c) => c.id);
+        const childrenIds = children.map((c) => c.id);
         dataRef.current.childrenIds[itemId] = childrenIds;
         children.forEach(({ id, data }) => {
             var _a, _b, _c;
@@ -53,7 +50,7 @@ const loadChildrenIds = (tree, itemId) => __awaiter(void 0, void 0, void 0, func
         tree.applySubStateUpdate("loadingItemData", (loadingItemData) => loadingItemData.filter((id) => !childrenIds.includes(id)));
     }
     else {
-        childrenIds = yield config.dataLoader.getChildren(itemId);
+        const childrenIds = yield config.dataLoader.getChildren(itemId);
         dataRef.current.childrenIds[itemId] = childrenIds;
         (_b = config.onLoadedChildren) === null || _b === void 0 ? void 0 : _b.call(config, itemId, childrenIds);
         tree.rebuildTree();
@@ -61,7 +58,6 @@ const loadChildrenIds = (tree, itemId) => __awaiter(void 0, void 0, void 0, func
     tree.applySubStateUpdate("loadingItemChildrens", (loadingItemChildrens) => loadingItemChildrens.filter((id) => id !== itemId));
     (_d = (_c = dataRef.current.awaitingItemChildrensLoading) === null || _c === void 0 ? void 0 : _c[itemId]) === null || _d === void 0 ? void 0 : _d.forEach((cb) => cb());
     (_e = dataRef.current.awaitingItemChildrensLoading) === null || _e === void 0 ? true : delete _e[itemId];
-    return childrenIds;
 });
 exports.asyncDataLoaderFeature = {
     key: "async-data-loader",
@@ -87,7 +83,6 @@ exports.asyncDataLoaderFeature = {
             });
         }),
         waitForItemChildrenLoaded: (_a, itemId_1) => __awaiter(void 0, [_a, itemId_1], void 0, function* ({ tree }, itemId) {
-            // TODO replace inner implementation with load() fns
             tree.retrieveChildrenIds(itemId);
             if (!tree.getState().loadingItemChildrens.includes(itemId)) {
                 return;
@@ -101,14 +96,6 @@ exports.asyncDataLoaderFeature = {
                 dataRef.current.awaitingItemChildrensLoading[itemId].push(resolve);
             });
         }),
-        loadItemData: (_a, itemId_1) => __awaiter(void 0, [_a, itemId_1], void 0, function* ({ tree }, itemId) {
-            var _b;
-            return ((_b = getDataRef(tree).current.itemData[itemId]) !== null && _b !== void 0 ? _b : (yield loadItemData(tree, itemId)));
-        }),
-        loadChildrenIds: (_a, itemId_1) => __awaiter(void 0, [_a, itemId_1], void 0, function* ({ tree }, itemId) {
-            var _b;
-            return ((_b = getDataRef(tree).current.childrenIds[itemId]) !== null && _b !== void 0 ? _b : (yield loadChildrenIds(tree, itemId)));
-        }),
         retrieveItemData: ({ tree }, itemId, skipFetch = false) => {
             var _a, _b;
             const config = tree.getConfig();

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

@@ -27,12 +27,8 @@ 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/lib/cjs/features/checkboxes/feature.js

@@ -1,46 +1,30 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkboxesFeature = void 0;
 const utils_1 = require("../../utils");
 const types_1 = require("./types");
-/*
- * Cases for checking:
- * - Check an unchecked item in an unchecked or indeterminate folder
- * - Check an explicitly unchecked item in a checked folder
- * - Check an unchecked folder in an unchecked or indeterminate folder
- *
- * Cases for unchecking:
- * - Uncheck a checked item in an indeterminate folder
- * - Uncheck an explicitly unchecked item in an checked folder
- */
-const fetchAllDescendants = (tree, itemId) => __awaiter(void 0, void 0, void 0, function* () {
-    const children = yield tree.loadChildrenIds(itemId);
-    return [
-        itemId,
-        ...(yield Promise.all(children.map((child) => fetchAllDescendants(tree, child)))).flat(),
-    ];
-});
+const errors_1 = require("../../utilities/errors");
 const getAllLoadedDescendants = (tree, itemId) => {
-    const children = tree.retrieveChildrenIds(itemId, true);
-    return [
-        itemId,
-        ...children.map((child) => getAllLoadedDescendants(tree, child)).flat(),
-    ];
+    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) => (Object.assign({ setCheckedItems: (0, utils_1.makeStateUpdater)("checkedItems", tree) }, defaultConfig)),
+    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",
     },
@@ -50,37 +34,33 @@ exports.checkboxesFeature = {
         },
     },
     itemInstance: {
-        getCheckboxProps: ({ item, itemId }) => {
+        getCheckboxProps: ({ item }) => {
             const checkedState = item.getCheckedState();
-            // console.log("prop", itemId, checkedState);
             return {
                 onChange: item.toggleCheckedState,
                 checked: checkedState === types_1.CheckedState.Checked,
                 ref: (r) => {
                     if (r) {
-                        // console.log("ref", itemId, checkedState);
                         r.indeterminate = checkedState === types_1.CheckedState.Indeterminate;
                     }
                 },
             };
         },
-        toggleCheckedState: (_a) => __awaiter(void 0, [_a], void 0, function* ({ item }) {
+        toggleCheckedState: ({ item }) => {
             if (item.getCheckedState() === types_1.CheckedState.Checked) {
-                yield item.setUnchecked();
+                item.setUnchecked();
             }
             else {
-                yield item.setChecked();
+                item.setChecked();
             }
-        }),
+        },
         getCheckedState: ({ item, tree, itemId }) => {
-            // TODO checkedcache
             const { checkedItems } = tree.getState();
             if (checkedItems.includes(itemId)) {
                 return types_1.CheckedState.Checked;
             }
-            if (item.isFolder()) {
+            if (item.isFolder() && !tree.getConfig().canCheckFolders) {
                 const descendants = getAllLoadedDescendants(tree, itemId);
-                console.log("descendants of ", itemId, descendants);
                 if (descendants.every((d) => checkedItems.includes(d))) {
                     return types_1.CheckedState.Checked;
                 }
@@ -88,41 +68,27 @@ exports.checkboxesFeature = {
                     return types_1.CheckedState.Indeterminate;
                 }
             }
-            // if (
-            //   item.isFolder() &&
-            //   checkedItems.some((checkedItem) =>
-            //     tree.getItemInstance(checkedItem)?.isDescendentOf(itemId),
-            //   )
-            // ) {
-            //   // TODO for every descendent, not every checked item
-            //   return checkedItems.every((checkedItem) =>
-            //     tree.getItemInstance(checkedItem)?.isDescendentOf(itemId),
-            //   )
-            //     ? CheckedState.Checked
-            //     : CheckedState.Indeterminate;
-            // }
             return types_1.CheckedState.Unchecked;
         },
-        setChecked: (_a) => __awaiter(void 0, [_a], void 0, function* ({ item, tree, itemId }) {
+        setChecked: ({ item, tree, itemId }) => {
             if (!item.isFolder() || tree.getConfig().canCheckFolders) {
                 tree.applySubStateUpdate("checkedItems", (items) => [...items, itemId]);
             }
             else {
-                const descendants = yield fetchAllDescendants(tree, itemId);
                 tree.applySubStateUpdate("checkedItems", (items) => [
                     ...items,
-                    ...descendants,
+                    ...getAllLoadedDescendants(tree, itemId),
                 ]);
             }
-        }),
-        setUnchecked: (_a) => __awaiter(void 0, [_a], void 0, function* ({ item, tree, itemId }) {
+        },
+        setUnchecked: ({ item, tree, itemId }) => {
             if (!item.isFolder() || tree.getConfig().canCheckFolders) {
                 tree.applySubStateUpdate("checkedItems", (items) => items.filter((id) => id !== itemId));
             }
             else {
-                yield tree.loadChildrenIds(itemId);
-                item.getChildren().forEach((item) => item.setUnchecked());
+                const descendants = getAllLoadedDescendants(tree, itemId);
+                tree.applySubStateUpdate("checkedItems", (items) => items.filter((id) => !descendants.includes(id)));
             }
-        }),
+        },
     },
 };

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

@@ -16,9 +16,9 @@ export type CheckboxesFeatureDef<T> = {
         setCheckedItems: (checkedItems: string[]) => void;
     };
     itemInstance: {
-        setChecked: () => Promise<void>;
-        setUnchecked: () => Promise<void>;
-        toggleCheckedState: () => Promise<void>;
+        setChecked: () => void;
+        setUnchecked: () => void;
+        toggleCheckedState: () => void;
         getCheckedState: () => CheckedState;
         getCheckboxProps: () => Record<string, any>;
     };

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

@@ -40,8 +40,6 @@ exports.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/cjs/features/sync-data-loader/types.d.ts

@@ -18,8 +18,8 @@ export type SyncDataLoaderFeatureDef<T> = {
         dataLoader: TreeDataLoader<T>;
     };
     treeInstance: {
-        retrieveItemData: (itemId: string, skipFetch?: boolean) => T;
-        retrieveChildrenIds: (itemId: string, skipFetch?: boolean) => string[];
+        retrieveItemData: (itemId: string) => T;
+        retrieveChildrenIds: (itemId: string) => string[];
     };
     itemInstance: {
         isLoading: () => boolean;

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

@@ -26,17 +26,14 @@ const loadItemData = (tree, itemId) => __awaiter(void 0, void 0, void 0, functio
     tree.applySubStateUpdate("loadingItemData", (loadingItemData) => loadingItemData.filter((id) => id !== itemId));
     (_b = dataRef.current.awaitingItemDataLoading) === null || _b === void 0 ? void 0 : _b[itemId].forEach((cb) => cb());
     (_c = dataRef.current.awaitingItemDataLoading) === null || _c === void 0 ? true : delete _c[itemId];
-    return item;
 });
 const loadChildrenIds = (tree, itemId) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b, _c, _d, _e;
     const config = tree.getConfig();
     const dataRef = getDataRef(tree);
-    let childrenIds;
-    // TODO is folder check?
     if ("getChildrenWithData" in config.dataLoader) {
         const children = yield config.dataLoader.getChildrenWithData(itemId);
-        childrenIds = children.map((c) => c.id);
+        const childrenIds = children.map((c) => c.id);
         dataRef.current.childrenIds[itemId] = childrenIds;
         children.forEach(({ id, data }) => {
             var _a, _b, _c;
@@ -50,7 +47,7 @@ const loadChildrenIds = (tree, itemId) => __awaiter(void 0, void 0, void 0, func
         tree.applySubStateUpdate("loadingItemData", (loadingItemData) => loadingItemData.filter((id) => !childrenIds.includes(id)));
     }
     else {
-        childrenIds = yield config.dataLoader.getChildren(itemId);
+        const childrenIds = yield config.dataLoader.getChildren(itemId);
         dataRef.current.childrenIds[itemId] = childrenIds;
         (_b = config.onLoadedChildren) === null || _b === void 0 ? void 0 : _b.call(config, itemId, childrenIds);
         tree.rebuildTree();
@@ -58,7 +55,6 @@ const loadChildrenIds = (tree, itemId) => __awaiter(void 0, void 0, void 0, func
     tree.applySubStateUpdate("loadingItemChildrens", (loadingItemChildrens) => loadingItemChildrens.filter((id) => id !== itemId));
     (_d = (_c = dataRef.current.awaitingItemChildrensLoading) === null || _c === void 0 ? void 0 : _c[itemId]) === null || _d === void 0 ? void 0 : _d.forEach((cb) => cb());
     (_e = dataRef.current.awaitingItemChildrensLoading) === null || _e === void 0 ? true : delete _e[itemId];
-    return childrenIds;
 });
 export const asyncDataLoaderFeature = {
     key: "async-data-loader",
@@ -84,7 +80,6 @@ export const asyncDataLoaderFeature = {
             });
         }),
         waitForItemChildrenLoaded: (_a, itemId_1) => __awaiter(void 0, [_a, itemId_1], void 0, function* ({ tree }, itemId) {
-            // TODO replace inner implementation with load() fns
             tree.retrieveChildrenIds(itemId);
             if (!tree.getState().loadingItemChildrens.includes(itemId)) {
                 return;
@@ -98,14 +93,6 @@ export const asyncDataLoaderFeature = {
                 dataRef.current.awaitingItemChildrensLoading[itemId].push(resolve);
             });
         }),
-        loadItemData: (_a, itemId_1) => __awaiter(void 0, [_a, itemId_1], void 0, function* ({ tree }, itemId) {
-            var _b;
-            return ((_b = getDataRef(tree).current.itemData[itemId]) !== null && _b !== void 0 ? _b : (yield loadItemData(tree, itemId)));
-        }),
-        loadChildrenIds: (_a, itemId_1) => __awaiter(void 0, [_a, itemId_1], void 0, function* ({ tree }, itemId) {
-            var _b;
-            return ((_b = getDataRef(tree).current.childrenIds[itemId]) !== null && _b !== void 0 ? _b : (yield loadChildrenIds(tree, itemId)));
-        }),
         retrieveItemData: ({ tree }, itemId, skipFetch = false) => {
             var _a, _b;
             const config = tree.getConfig();

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

@@ -27,12 +27,8 @@ 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/lib/esm/features/checkboxes/feature.js

@@ -1,43 +1,27 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { makeStateUpdater } from "../../utils";
 import { CheckedState } from "./types";
-/*
- * Cases for checking:
- * - Check an unchecked item in an unchecked or indeterminate folder
- * - Check an explicitly unchecked item in a checked folder
- * - Check an unchecked folder in an unchecked or indeterminate folder
- *
- * Cases for unchecking:
- * - Uncheck a checked item in an indeterminate folder
- * - Uncheck an explicitly unchecked item in an checked folder
- */
-const fetchAllDescendants = (tree, itemId) => __awaiter(void 0, void 0, void 0, function* () {
-    const children = yield tree.loadChildrenIds(itemId);
-    return [
-        itemId,
-        ...(yield Promise.all(children.map((child) => fetchAllDescendants(tree, child)))).flat(),
-    ];
-});
+import { throwError } from "../../utilities/errors";
 const getAllLoadedDescendants = (tree, itemId) => {
-    const children = tree.retrieveChildrenIds(itemId, true);
-    return [
-        itemId,
-        ...children.map((child) => getAllLoadedDescendants(tree, child)).flat(),
-    ];
+    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) => (Object.assign({ setCheckedItems: makeStateUpdater("checkedItems", tree) }, defaultConfig)),
+    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",
     },
@@ -47,37 +31,33 @@ export const checkboxesFeature = {
         },
     },
     itemInstance: {
-        getCheckboxProps: ({ item, itemId }) => {
+        getCheckboxProps: ({ item }) => {
             const checkedState = item.getCheckedState();
-            // console.log("prop", itemId, checkedState);
             return {
                 onChange: item.toggleCheckedState,
                 checked: checkedState === CheckedState.Checked,
                 ref: (r) => {
                     if (r) {
-                        // console.log("ref", itemId, checkedState);
                         r.indeterminate = checkedState === CheckedState.Indeterminate;
                     }
                 },
             };
         },
-        toggleCheckedState: (_a) => __awaiter(void 0, [_a], void 0, function* ({ item }) {
+        toggleCheckedState: ({ item }) => {
             if (item.getCheckedState() === CheckedState.Checked) {
-                yield item.setUnchecked();
+                item.setUnchecked();
             }
             else {
-                yield item.setChecked();
+                item.setChecked();
             }
-        }),
+        },
         getCheckedState: ({ item, tree, itemId }) => {
-            // TODO checkedcache
             const { checkedItems } = tree.getState();
             if (checkedItems.includes(itemId)) {
                 return CheckedState.Checked;
             }
-            if (item.isFolder()) {
+            if (item.isFolder() && !tree.getConfig().canCheckFolders) {
                 const descendants = getAllLoadedDescendants(tree, itemId);
-                console.log("descendants of ", itemId, descendants);
                 if (descendants.every((d) => checkedItems.includes(d))) {
                     return CheckedState.Checked;
                 }
@@ -85,41 +65,27 @@ export const checkboxesFeature = {
                     return CheckedState.Indeterminate;
                 }
             }
-            // if (
-            //   item.isFolder() &&
-            //   checkedItems.some((checkedItem) =>
-            //     tree.getItemInstance(checkedItem)?.isDescendentOf(itemId),
-            //   )
-            // ) {
-            //   // TODO for every descendent, not every checked item
-            //   return checkedItems.every((checkedItem) =>
-            //     tree.getItemInstance(checkedItem)?.isDescendentOf(itemId),
-            //   )
-            //     ? CheckedState.Checked
-            //     : CheckedState.Indeterminate;
-            // }
             return CheckedState.Unchecked;
         },
-        setChecked: (_a) => __awaiter(void 0, [_a], void 0, function* ({ item, tree, itemId }) {
+        setChecked: ({ item, tree, itemId }) => {
             if (!item.isFolder() || tree.getConfig().canCheckFolders) {
                 tree.applySubStateUpdate("checkedItems", (items) => [...items, itemId]);
             }
             else {
-                const descendants = yield fetchAllDescendants(tree, itemId);
                 tree.applySubStateUpdate("checkedItems", (items) => [
                     ...items,
-                    ...descendants,
+                    ...getAllLoadedDescendants(tree, itemId),
                 ]);
             }
-        }),
-        setUnchecked: (_a) => __awaiter(void 0, [_a], void 0, function* ({ item, tree, itemId }) {
+        },
+        setUnchecked: ({ item, tree, itemId }) => {
             if (!item.isFolder() || tree.getConfig().canCheckFolders) {
                 tree.applySubStateUpdate("checkedItems", (items) => items.filter((id) => id !== itemId));
             }
             else {
-                yield tree.loadChildrenIds(itemId);
-                item.getChildren().forEach((item) => item.setUnchecked());
+                const descendants = getAllLoadedDescendants(tree, itemId);
+                tree.applySubStateUpdate("checkedItems", (items) => items.filter((id) => !descendants.includes(id)));
             }
-        }),
+        },
     },
 };

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

@@ -16,9 +16,9 @@ export type CheckboxesFeatureDef<T> = {
         setCheckedItems: (checkedItems: string[]) => void;
     };
     itemInstance: {
-        setChecked: () => Promise<void>;
-        setUnchecked: () => Promise<void>;
-        toggleCheckedState: () => Promise<void>;
+        setChecked: () => void;
+        setUnchecked: () => void;
+        toggleCheckedState: () => void;
         getCheckedState: () => CheckedState;
         getCheckboxProps: () => Record<string, any>;
     };

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

@@ -37,8 +37,6 @@ 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/features/sync-data-loader/types.d.ts

@@ -18,8 +18,8 @@ export type SyncDataLoaderFeatureDef<T> = {
         dataLoader: TreeDataLoader<T>;
     };
     treeInstance: {
-        retrieveItemData: (itemId: string, skipFetch?: boolean) => T;
-        retrieveChildrenIds: (itemId: string, skipFetch?: boolean) => string[];
+        retrieveItemData: (itemId: string) => T;
+        retrieveChildrenIds: (itemId: string) => string[];
     };
     itemInstance: {
         isLoading: () => boolean;

package/package.json

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

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

@@ -22,19 +22,15 @@ const loadItemData = async <T>(tree: TreeInstance<T>, itemId: string) => {
 
   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[];
-
-  // TODO is folder check?
 
   if ("getChildrenWithData" in config.dataLoader) {
     const children = await config.dataLoader.getChildrenWithData(itemId);
-    childrenIds = children.map((c) => c.id);
+    const childrenIds = children.map((c) => c.id);
     dataRef.current.childrenIds[itemId] = childrenIds;
     children.forEach(({ id, data }) => {
       dataRef.current.itemData[id] = data;
@@ -49,7 +45,7 @@ const loadChildrenIds = async <T>(tree: TreeInstance<T>, itemId: string) => {
       loadingItemData.filter((id) => !childrenIds.includes(id)),
     );
   } else {
-    childrenIds = await config.dataLoader.getChildren(itemId);
+    const childrenIds = await config.dataLoader.getChildren(itemId);
     dataRef.current.childrenIds[itemId] = childrenIds;
     config.onLoadedChildren?.(itemId, childrenIds);
     tree.rebuildTree();
@@ -61,7 +57,6 @@ const loadChildrenIds = async <T>(tree: TreeInstance<T>, itemId: string) => {
 
   dataRef.current.awaitingItemChildrensLoading?.[itemId]?.forEach((cb) => cb());
   delete dataRef.current.awaitingItemChildrensLoading?.[itemId];
-  return childrenIds;
 };
 
 export const asyncDataLoaderFeature: FeatureImplementation = {
@@ -99,7 +94,6 @@ export const asyncDataLoaderFeature: FeatureImplementation = {
     },
 
     waitForItemChildrenLoaded: async ({ tree }, itemId) => {
-      // TODO replace inner implementation with load() fns
       tree.retrieveChildrenIds(itemId);
       if (!tree.getState().loadingItemChildrens.includes(itemId)) {
         return;
@@ -112,19 +106,6 @@ export const asyncDataLoaderFeature: FeatureImplementation = {
       });
     },
 
-    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) => {
       const config = tree.getConfig();
       const dataRef = getDataRef(tree);

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

@@ -32,12 +32,8 @@ 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/checkboxes/checkboxes.spec.ts

@@ -0,0 +1,134 @@
+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,42 +1,19 @@
 import { FeatureImplementation, TreeInstance } from "../../types/core";
 import { makeStateUpdater } from "../../utils";
 import { CheckedState } from "./types";
-
-/*
- * Cases for checking:
- * - Check an unchecked item in an unchecked or indeterminate folder
- * - Check an explicitly unchecked item in a checked folder
- * - Check an unchecked folder in an unchecked or indeterminate folder
- *
- * Cases for unchecking:
- * - Uncheck a checked item in an indeterminate folder
- * - Uncheck an explicitly unchecked item in an checked folder
- */
-
-const fetchAllDescendants = async <T>(
-  tree: TreeInstance<T>,
-  itemId: string,
-): Promise<string[]> => {
-  const children = await tree.loadChildrenIds(itemId);
-  return [
-    itemId,
-    ...(
-      await Promise.all(
-        children.map((child) => fetchAllDescendants(tree, child)),
-      )
-    ).flat(),
-  ];
-};
+import { throwError } from "../../utilities/errors";
 
 const getAllLoadedDescendants = <T>(
   tree: TreeInstance<T>,
   itemId: string,
 ): string[] => {
-  const children = tree.retrieveChildrenIds(itemId, true);
-  return [
-    itemId,
-    ...children.map((child) => getAllLoadedDescendants(tree, child)).flat(),
-  ];
+  if (!tree.getConfig().isItemFolder(tree.buildItemInstance(itemId))) {
+    return [itemId];
+  }
+  return tree
+    .retrieveChildrenIds(itemId)
+    .map((child) => getAllLoadedDescendants(tree, child))
+    .flat();
 };
 
 export const checkboxesFeature: FeatureImplementation = {
@@ -49,10 +26,19 @@ export const checkboxesFeature: FeatureImplementation = {
     ...initialState,
   }),
 
-  getDefaultConfig: (defaultConfig, tree) => ({
-    setCheckedItems: makeStateUpdater("checkedItems", tree),
-    ...defaultConfig,
-  }),
+  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",
@@ -65,40 +51,36 @@ export const checkboxesFeature: FeatureImplementation = {
   },
 
   itemInstance: {
-    getCheckboxProps: ({ item, itemId }) => {
+    getCheckboxProps: ({ item }) => {
       const checkedState = item.getCheckedState();
-      // console.log("prop", itemId, checkedState);
       return {
         onChange: item.toggleCheckedState,
         checked: checkedState === CheckedState.Checked,
         ref: (r: any) => {
           if (r) {
-            // console.log("ref", itemId, checkedState);
             r.indeterminate = checkedState === CheckedState.Indeterminate;
           }
         },
       };
     },
 
-    toggleCheckedState: async ({ item }) => {
+    toggleCheckedState: ({ item }) => {
       if (item.getCheckedState() === CheckedState.Checked) {
-        await item.setUnchecked();
+        item.setUnchecked();
       } else {
-        await item.setChecked();
+        item.setChecked();
       }
     },
 
     getCheckedState: ({ item, tree, itemId }) => {
-      // TODO checkedcache
       const { checkedItems } = tree.getState();
 
       if (checkedItems.includes(itemId)) {
         return CheckedState.Checked;
       }
 
-      if (item.isFolder()) {
+      if (item.isFolder() && !tree.getConfig().canCheckFolders) {
         const descendants = getAllLoadedDescendants(tree, itemId);
-        console.log("descendants of ", itemId, descendants);
         if (descendants.every((d) => checkedItems.includes(d))) {
           return CheckedState.Checked;
         }
@@ -107,43 +89,30 @@ export const checkboxesFeature: FeatureImplementation = {
         }
       }
 
-      // if (
-      //   item.isFolder() &&
-      //   checkedItems.some((checkedItem) =>
-      //     tree.getItemInstance(checkedItem)?.isDescendentOf(itemId),
-      //   )
-      // ) {
-      //   // TODO for every descendent, not every checked item
-      //   return checkedItems.every((checkedItem) =>
-      //     tree.getItemInstance(checkedItem)?.isDescendentOf(itemId),
-      //   )
-      //     ? CheckedState.Checked
-      //     : CheckedState.Indeterminate;
-      // }
-
       return CheckedState.Unchecked;
     },
 
-    setChecked: async ({ item, tree, itemId }) => {
+    setChecked: ({ item, tree, itemId }) => {
       if (!item.isFolder() || tree.getConfig().canCheckFolders) {
         tree.applySubStateUpdate("checkedItems", (items) => [...items, itemId]);
       } else {
-        const descendants = await fetchAllDescendants(tree, itemId);
         tree.applySubStateUpdate("checkedItems", (items) => [
           ...items,
-          ...descendants,
+          ...getAllLoadedDescendants(tree, itemId),
         ]);
       }
     },
 
-    setUnchecked: async ({ item, tree, itemId }) => {
+    setUnchecked: ({ item, tree, itemId }) => {
       if (!item.isFolder() || tree.getConfig().canCheckFolders) {
         tree.applySubStateUpdate("checkedItems", (items) =>
           items.filter((id) => id !== itemId),
         );
       } else {
-        await tree.loadChildrenIds(itemId);
-        item.getChildren().forEach((item) => item.setUnchecked());
+        const descendants = getAllLoadedDescendants(tree, itemId);
+        tree.applySubStateUpdate("checkedItems", (items) =>
+          items.filter((id) => !descendants.includes(id)),
+        );
       }
     },
   },

package/src/features/checkboxes/types.ts

@@ -18,9 +18,9 @@ export type CheckboxesFeatureDef<T> = {
     setCheckedItems: (checkedItems: string[]) => void;
   };
   itemInstance: {
-    setChecked: () => Promise<void>;
-    setUnchecked: () => Promise<void>;
-    toggleCheckedState: () => Promise<void>;
+    setChecked: () => void;
+    setUnchecked: () => void;
+    toggleCheckedState: () => void;
     getCheckedState: () => CheckedState;
     getCheckboxProps: () => Record<string, any>;
   };

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

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

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

@@ -17,8 +17,8 @@ export type SyncDataLoaderFeatureDef<T> = {
     dataLoader: TreeDataLoader<T>;
   };
   treeInstance: {
-    retrieveItemData: (itemId: string, skipFetch?: boolean) => T;
-    retrieveChildrenIds: (itemId: string, skipFetch?: boolean) => string[];
+    retrieveItemData: (itemId: string) => T;
+    retrieveChildrenIds: (itemId: string) => string[];
   };
   itemInstance: {
     isLoading: () => boolean;

package/src/features/tree/types.ts

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