@headless-tree/core 0.0.0-20250723222210 → 0.0.0-20250726130412

package/package.json

@@ -1,19 +1,26 @@
 {
   "name": "@headless-tree/core",
-  "version": "0.0.0-20250723222210",
-  "main": "lib/cjs/index.js",
-  "module": "lib/esm/index.js",
-  "types": "lib/esm/index.d.ts",
+  "version": "0.0.0-20250726130412",
+  "main": "dist/index.d.ts",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.mts",
   "exports": {
-    "types": "./lib/esm/index.d.ts",
-    "import": "./lib/esm/index.js",
-    "default": "./lib/cjs/index.js"
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.js",
+        "default": "./dist/index.d.ts"
+      }
+    },
+    "./package.json": "./package.json"
   },
   "sideEffects": false,
   "scripts": {
-    "build:cjs": "tsc -m commonjs --outDir lib/cjs",
-    "build:esm": "tsc",
-    "start": "tsc -w",
+    "build": "tsup ./src/index.ts --format esm,cjs --dts",
+    "start": "tsup ./src/index.ts --format esm,cjs --dts --watch",
     "test": "vitest run"
   },
   "repository": {
@@ -26,6 +33,7 @@
   "license": "MIT",
   "devDependencies": {
     "jsdom": "^26.0.0",
+    "tsup": "^8.5.0",
     "typescript": "^5.7.2",
     "vitest": "^3.0.3"
   }

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

@@ -74,17 +74,28 @@ describe("core-feature/checkboxes", () => {
     });
   });
 
-  it("should handle folder checking when canCheckFolders is true", async () => {
+  it("should handle folder checking", async () => {
     const tree = await factory
-      .with({ canCheckFolders: true })
+      .with({ canCheckFolders: true, propagateCheckedState: false })
       .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();
+  it("should not check folders if disabled", async () => {
+    const tree = await factory
+      .with({ canCheckFolders: false, propagateCheckedState: false })
+      .createTestCaseTree();
+
+    tree.item("x11").setChecked();
+    expect(tree.instance.getState().checkedItems.length).toBe(0);
+  });
+
+  it("should propagate checked state", async () => {
+    const tree = await factory
+      .with({ propagateCheckedState: true })
+      .createTestCaseTree();
 
     tree.item("x11").setChecked();
     expect(tree.instance.getState().checkedItems).toEqual(
@@ -93,7 +104,9 @@ describe("core-feature/checkboxes", () => {
   });
 
   it("should turn folder indeterminate", async () => {
-    const tree = await factory.createTestCaseTree();
+    const tree = await factory
+      .with({ propagateCheckedState: true })
+      .createTestCaseTree();
 
     tree.item("x111").setChecked();
     expect(tree.item("x11").getCheckedState()).toBe(CheckedState.Indeterminate);
@@ -103,6 +116,8 @@ describe("core-feature/checkboxes", () => {
     const tree = await factory
       .with({
         isItemFolder: (item) => item.getItemData().length < 4,
+        propagateCheckedState: true,
+        canCheckFolders: false,
       })
       .createTestCaseTree();
 

package/src/features/checkboxes/feature.ts

@@ -6,14 +6,16 @@ import { throwError } from "../../utilities/errors";
 const getAllLoadedDescendants = <T>(
   tree: TreeInstance<T>,
   itemId: string,
+  includeFolders = false,
 ): string[] => {
   if (!tree.getConfig().isItemFolder(tree.buildItemInstance(itemId))) {
     return [itemId];
   }
-  return tree
+  const descendants = tree
     .retrieveChildrenIds(itemId)
-    .map((child) => getAllLoadedDescendants(tree, child))
+    .map((child) => getAllLoadedDescendants(tree, child, includeFolders))
     .flat();
+  return includeFolders ? [itemId, ...descendants] : descendants;
 };
 
 export const checkboxesFeature: FeatureImplementation = {
@@ -30,12 +32,17 @@ export const checkboxesFeature: FeatureImplementation = {
     const hasAsyncLoader = defaultConfig.features?.some(
       (f) => f.key === "async-data-loader",
     );
-    if (hasAsyncLoader && !defaultConfig.canCheckFolders) {
-      throwError(`!canCheckFolders not supported with async trees`);
+    if (hasAsyncLoader && defaultConfig.propagateCheckedState) {
+      throwError(`propagateCheckedState not supported with async trees`);
     }
+    const propagateCheckedState =
+      defaultConfig.propagateCheckedState ?? !hasAsyncLoader;
+    const canCheckFolders =
+      defaultConfig.canCheckFolders ?? !propagateCheckedState;
     return {
       setCheckedItems: makeStateUpdater("checkedItems", tree),
-      canCheckFolders: hasAsyncLoader ?? false,
+      propagateCheckedState,
+      canCheckFolders,
       ...defaultConfig,
     };
   },
@@ -72,14 +79,16 @@ export const checkboxesFeature: FeatureImplementation = {
       }
     },
 
-    getCheckedState: ({ item, tree, itemId }) => {
+    getCheckedState: ({ item, tree }) => {
       const { checkedItems } = tree.getState();
+      const { propagateCheckedState } = tree.getConfig();
+      const itemId = item.getId();
 
       if (checkedItems.includes(itemId)) {
         return CheckedState.Checked;
       }
 
-      if (item.isFolder() && !tree.getConfig().canCheckFolders) {
+      if (item.isFolder() && propagateCheckedState) {
         const descendants = getAllLoadedDescendants(tree, itemId);
         if (descendants.every((d) => checkedItems.includes(d))) {
           return CheckedState.Checked;
@@ -93,25 +102,31 @@ export const checkboxesFeature: FeatureImplementation = {
     },
 
     setChecked: ({ item, tree, itemId }) => {
-      if (!item.isFolder() || tree.getConfig().canCheckFolders) {
-        tree.applySubStateUpdate("checkedItems", (items) => [...items, itemId]);
-      } else {
+      const { propagateCheckedState, canCheckFolders } = tree.getConfig();
+      if (item.isFolder() && propagateCheckedState) {
         tree.applySubStateUpdate("checkedItems", (items) => [
           ...items,
-          ...getAllLoadedDescendants(tree, itemId),
+          ...getAllLoadedDescendants(tree, itemId, canCheckFolders),
         ]);
+      } else if (!item.isFolder() || canCheckFolders) {
+        tree.applySubStateUpdate("checkedItems", (items) => [...items, itemId]);
       }
     },
 
     setUnchecked: ({ item, tree, itemId }) => {
-      if (!item.isFolder() || tree.getConfig().canCheckFolders) {
+      const { propagateCheckedState, canCheckFolders } = tree.getConfig();
+      if (item.isFolder() && propagateCheckedState) {
+        const descendants = getAllLoadedDescendants(
+          tree,
+          itemId,
+          canCheckFolders,
+        );
         tree.applySubStateUpdate("checkedItems", (items) =>
-          items.filter((id) => id !== itemId),
+          items.filter((id) => !descendants.includes(id) && id !== itemId),
         );
       } else {
-        const descendants = getAllLoadedDescendants(tree, itemId);
         tree.applySubStateUpdate("checkedItems", (items) =>
-          items.filter((id) => !descendants.includes(id)),
+          items.filter((id) => id !== itemId),
         );
       }
     },

package/src/features/checkboxes/types.ts

@@ -13,6 +13,7 @@ export type CheckboxesFeatureDef<T> = {
   config: {
     setCheckedItems?: SetStateFn<string[]>;
     canCheckFolders?: boolean;
+    propagateCheckedState?: boolean;
   };
   treeInstance: {
     setCheckedItems: (checkedItems: string[]) => void;

package/tsconfig.json

@@ -1,8 +1,5 @@
 {
   "extends": "../../tsconfig.json",
   "include": ["./src/**/*"],
-  "exclude": ["./src/**/*.spec.tsx", "./src/**/*.spec.ts", "./src/**/*.stories.tsx"],
-  "compilerOptions": {
-    "outDir": "lib/esm"
-  }
+  "exclude": ["./src/**/*.spec.tsx", "./src/**/*.spec.ts", "./src/**/*.stories.tsx"]
 }

package/lib/cjs/core/build-proxified-instance.d.ts

@@ -1,2 +0,0 @@
-import { InstanceBuilder } from "../features/main/types";
-export declare const buildProxiedInstance: InstanceBuilder;

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

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildProxiedInstance = void 0;
-const errors_1 = require("../utilities/errors");
-const noop = () => { };
-const findPrevInstanceMethod = (features, instanceType, methodKey, featureSearchIndex) => {
-    var _a;
-    for (let i = featureSearchIndex; i >= 0; i--) {
-        const feature = features[i];
-        const itemInstanceMethod = (_a = feature[instanceType]) === null || _a === void 0 ? void 0 : _a[methodKey];
-        if (itemInstanceMethod) {
-            return i;
-        }
-    }
-    return null;
-};
-const invokeInstanceMethod = (features, instanceType, opts, methodKey, featureIndex, args) => {
-    var _a;
-    const prevIndex = findPrevInstanceMethod(features, instanceType, methodKey, featureIndex - 1);
-    const itemInstanceMethod = (_a = features[featureIndex][instanceType]) === null || _a === void 0 ? void 0 : _a[methodKey];
-    return itemInstanceMethod(Object.assign(Object.assign({}, opts), { prev: prevIndex !== null
-            ? (...newArgs) => invokeInstanceMethod(features, instanceType, opts, methodKey, prevIndex, newArgs)
-            : null }), ...args);
-};
-const buildProxiedInstance = (features, instanceType, buildOpts) => {
-    // demo with prototypes: https://jsfiddle.net/bgenc58r/
-    const opts = {};
-    const item = new Proxy({}, {
-        has(target, key) {
-            if (typeof key === "symbol") {
-                return false;
-            }
-            if (key === "toJSON") {
-                return false;
-            }
-            const hasInstanceMethod = findPrevInstanceMethod(features, instanceType, key, features.length - 1);
-            return Boolean(hasInstanceMethod);
-        },
-        get(target, key) {
-            if (typeof key === "symbol") {
-                return undefined;
-            }
-            if (key === "toJSON") {
-                return {};
-            }
-            return (...args) => {
-                const featureIndex = findPrevInstanceMethod(features, instanceType, key, features.length - 1);
-                if (featureIndex === null) {
-                    throw (0, errors_1.throwError)(`feature missing for method ${key}`);
-                }
-                return invokeInstanceMethod(features, instanceType, opts, key, featureIndex, args);
-            };
-        },
-    });
-    Object.assign(opts, buildOpts(item));
-    return [item, noop];
-};
-exports.buildProxiedInstance = buildProxiedInstance;

package/lib/cjs/core/build-static-instance.d.ts

@@ -1,2 +0,0 @@
-import { InstanceBuilder } from "../features/main/types";
-export declare const buildStaticInstance: InstanceBuilder;

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

@@ -1,26 +0,0 @@
-"use strict";
-/* eslint-disable no-continue,no-labels,no-extra-label */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildStaticInstance = void 0;
-const buildStaticInstance = (features, instanceType, buildOpts) => {
-    const instance = {};
-    const finalize = () => {
-        const opts = buildOpts(instance);
-        featureLoop: for (let i = 0; i < features.length; i++) {
-            // 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;
-            methodLoop: for (const [key, method] of Object.entries(definition)) {
-                if (!method)
-                    continue methodLoop;
-                const prev = instance[key];
-                instance[key] = (...args) => {
-                    return method(Object.assign(Object.assign({}, opts), { prev }), ...args);
-                };
-            }
-        }
-    };
-    return [instance, finalize];
-};
-exports.buildStaticInstance = buildStaticInstance;

package/lib/cjs/core/create-tree.d.ts

@@ -1,2 +0,0 @@
-import { TreeConfig, TreeInstance } from "../types/core";
-export declare const createTree: <T>(initialConfig: TreeConfig<T>) => TreeInstance<T>;

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

@@ -1,191 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createTree = void 0;
-const feature_1 = require("../features/tree/feature");
-const build_static_instance_1 = require("./build-static-instance");
-const errors_1 = require("../utilities/errors");
-const verifyFeatures = (features) => {
-    var _a;
-    const loadedFeatures = features === null || features === void 0 ? void 0 : features.map((feature) => feature.key);
-    for (const feature of features !== null && features !== void 0 ? features : []) {
-        const missingDependency = (_a = feature.deps) === null || _a === void 0 ? void 0 : _a.find((dep) => !(loadedFeatures === null || loadedFeatures === void 0 ? void 0 : loadedFeatures.includes(dep)));
-        if (missingDependency) {
-            throw (0, errors_1.throwError)(`${feature.key} needs ${missingDependency}`);
-        }
-    }
-};
-// Check all possible pairs and sort the array
-const exhaustiveSort = (arr, compareFn) => {
-    const n = arr.length;
-    for (let i = 0; i < n; i++) {
-        for (let j = i + 1; j < n; j++) {
-            if (compareFn(arr[j], arr[i]) < 0) {
-                [arr[i], arr[j]] = [arr[j], arr[i]];
-            }
-        }
-    }
-    return arr;
-};
-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;
-    }
-    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 = []) => exhaustiveSort(features, 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;
-    const additionalFeatures = [
-        feature_1.treeFeature,
-        ...sortFeatures(initialConfig.features),
-    ];
-    verifyFeatures(additionalFeatures);
-    const features = [...additionalFeatures];
-    const [treeInstance, finalizeTree] = buildInstance(features, "treeInstance", (tree) => ({ tree }));
-    let state = additionalFeatures.reduce((acc, feature) => { var _a, _b; return (_b = (_a = feature.getInitialState) === null || _a === void 0 ? void 0 : _a.call(feature, acc, treeInstance)) !== null && _b !== void 0 ? _b : acc; }, (_c = (_b = initialConfig.initialState) !== null && _b !== void 0 ? _b : initialConfig.state) !== null && _c !== void 0 ? _c : {});
-    let config = additionalFeatures.reduce((acc, feature) => { var _a, _b; return (_b = (_a = feature.getDefaultConfig) === null || _a === void 0 ? void 0 : _a.call(feature, acc, treeInstance)) !== null && _b !== void 0 ? _b : acc; }, initialConfig);
-    const stateHandlerNames = additionalFeatures.reduce((acc, feature) => (Object.assign(Object.assign({}, acc), feature.stateHandlerNames)), {});
-    let treeElement;
-    const treeDataRef = { current: {} };
-    const itemInstancesMap = {};
-    let itemInstances = [];
-    const itemElementsMap = {};
-    const itemDataRefs = {};
-    let itemMetaMap = {};
-    const hotkeyPresets = {};
-    const rebuildItemMeta = () => {
-        // TODO can we find a way to only run this for the changed substructure?
-        itemInstances = [];
-        itemMetaMap = {};
-        const [rootInstance, finalizeRootInstance] = buildInstance(features, "itemInstance", (item) => ({ item, tree: treeInstance, itemId: config.rootItemId }));
-        finalizeRootInstance();
-        itemInstancesMap[config.rootItemId] = rootInstance;
-        itemMetaMap[config.rootItemId] = {
-            itemId: config.rootItemId,
-            index: -1,
-            parentId: null,
-            level: -1,
-            posInSet: 0,
-            setSize: 1,
-        };
-        for (const item of treeInstance.getItemsMeta()) {
-            itemMetaMap[item.itemId] = item;
-            if (!itemInstancesMap[item.itemId]) {
-                const [instance, finalizeInstance] = buildInstance(features, "itemInstance", (instance) => ({
-                    item: instance,
-                    tree: treeInstance,
-                    itemId: item.itemId,
-                }));
-                finalizeInstance();
-                itemInstancesMap[item.itemId] = instance;
-                itemInstances.push(instance);
-            }
-            else {
-                itemInstances.push(itemInstancesMap[item.itemId]);
-            }
-        }
-    };
-    const eachFeature = (fn) => {
-        for (const feature of additionalFeatures) {
-            fn(feature);
-        }
-    };
-    const mainFeature = {
-        key: "main",
-        treeInstance: {
-            getState: () => state,
-            setState: ({}, updater) => {
-                var _a;
-                // Not necessary, since I think the subupdate below keeps the state fresh anyways?
-                // state = typeof updater === "function" ? updater(state) : updater;
-                (_a = config.setState) === null || _a === void 0 ? void 0 : _a.call(config, state); // TODO this cant be right... This doesnt allow external state updates
-                // TODO this is never used, remove
-            },
-            applySubStateUpdate: ({}, stateName, updater) => {
-                state[stateName] =
-                    typeof updater === "function" ? updater(state[stateName]) : updater;
-                const externalStateSetter = config[stateHandlerNames[stateName]];
-                externalStateSetter === null || externalStateSetter === void 0 ? void 0 : 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: () => {
-                var _a;
-                rebuildItemMeta();
-                (_a = config.setState) === null || _a === void 0 ? void 0 : _a.call(config, state);
-            },
-            getConfig: () => config,
-            setConfig: (_, updater) => {
-                var _a, _b, _c;
-                const newConfig = typeof updater === "function" ? updater(config) : updater;
-                const hasChangedExpandedItems = ((_a = newConfig.state) === null || _a === void 0 ? void 0 : _a.expandedItems) &&
-                    ((_b = newConfig.state) === null || _b === void 0 ? void 0 : _b.expandedItems) !== state.expandedItems;
-                config = newConfig;
-                if (newConfig.state) {
-                    state = Object.assign(Object.assign({}, state), newConfig.state);
-                }
-                if (hasChangedExpandedItems) {
-                    // if expanded items where changed from the outside
-                    rebuildItemMeta();
-                    (_c = config.setState) === null || _c === void 0 ? void 0 : _c.call(config, state);
-                }
-            },
-            getItemInstance: ({}, itemId) => itemInstancesMap[itemId],
-            getItems: () => itemInstances,
-            registerElement: ({}, element) => {
-                if (treeElement === element) {
-                    return;
-                }
-                if (treeElement && !element) {
-                    eachFeature((feature) => { var _a; return (_a = feature.onTreeUnmount) === null || _a === void 0 ? void 0 : _a.call(feature, treeInstance, treeElement); });
-                }
-                else if (!treeElement && element) {
-                    eachFeature((feature) => { var _a; return (_a = feature.onTreeMount) === null || _a === void 0 ? void 0 : _a.call(feature, treeInstance, element); });
-                }
-                treeElement = element;
-            },
-            getElement: () => treeElement,
-            getDataRef: () => treeDataRef,
-            getHotkeyPresets: () => hotkeyPresets,
-        },
-        itemInstance: {
-            registerElement: ({ itemId, item }, element) => {
-                if (itemElementsMap[itemId] === element) {
-                    return;
-                }
-                const oldElement = itemElementsMap[itemId];
-                if (oldElement && !element) {
-                    eachFeature((feature) => { var _a; return (_a = feature.onItemUnmount) === null || _a === void 0 ? void 0 : _a.call(feature, item, oldElement, treeInstance); });
-                }
-                else if (!oldElement && element) {
-                    eachFeature((feature) => { var _a; return (_a = feature.onItemMount) === null || _a === void 0 ? void 0 : _a.call(feature, item, element, treeInstance); });
-                }
-                itemElementsMap[itemId] = element;
-            },
-            getElement: ({ itemId }) => itemElementsMap[itemId],
-            // eslint-disable-next-line no-return-assign
-            getDataRef: ({ itemId }) => { var _a; return ((_a = itemDataRefs[itemId]) !== null && _a !== void 0 ? _a : (itemDataRefs[itemId] = { current: {} })); },
-            getItemMeta: ({ itemId }) => itemMetaMap[itemId],
-        },
-    };
-    features.unshift(mainFeature);
-    for (const feature of features) {
-        Object.assign(hotkeyPresets, (_d = feature.hotkeys) !== null && _d !== void 0 ? _d : {});
-    }
-    finalizeTree();
-    return treeInstance;
-};
-exports.createTree = createTree;

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

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

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

@@ -1,135 +0,0 @@
-"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.asyncDataLoaderFeature = void 0;
-const utils_1 = require("../../utils");
-const getDataRef = (tree) => {
-    var _a, _b;
-    var _c, _d;
-    const dataRef = tree.getDataRef();
-    (_a = (_c = dataRef.current).itemData) !== null && _a !== void 0 ? _a : (_c.itemData = {});
-    (_b = (_d = dataRef.current).childrenIds) !== null && _b !== void 0 ? _b : (_d.childrenIds = {});
-    return dataRef;
-};
-const loadItemData = (tree, itemId) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    const config = tree.getConfig();
-    const dataRef = getDataRef(tree);
-    const item = yield config.dataLoader.getItem(itemId);
-    dataRef.current.itemData[itemId] = item;
-    (_a = config.onLoadedItem) === null || _a === void 0 ? void 0 : _a.call(config, itemId, item);
-    tree.applySubStateUpdate("loadingItemData", (loadingItemData) => loadingItemData.filter((id) => id !== itemId));
-    return item;
-});
-const loadChildrenIds = (tree, itemId) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
-    const config = tree.getConfig();
-    const dataRef = getDataRef(tree);
-    let childrenIds;
-    if ("getChildrenWithData" in config.dataLoader) {
-        const children = yield config.dataLoader.getChildrenWithData(itemId);
-        childrenIds = children.map((c) => c.id);
-        dataRef.current.childrenIds[itemId] = childrenIds;
-        children.forEach(({ id, data }) => {
-            var _a;
-            dataRef.current.itemData[id] = data;
-            (_a = config.onLoadedItem) === null || _a === void 0 ? void 0 : _a.call(config, id, data);
-        });
-        (_a = config.onLoadedChildren) === null || _a === void 0 ? void 0 : _a.call(config, itemId, childrenIds);
-        tree.rebuildTree();
-        tree.applySubStateUpdate("loadingItemData", (loadingItemData) => loadingItemData.filter((id) => !childrenIds.includes(id)));
-    }
-    else {
-        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();
-    }
-    tree.applySubStateUpdate("loadingItemChildrens", (loadingItemChildrens) => loadingItemChildrens.filter((id) => id !== itemId));
-    return childrenIds;
-});
-exports.asyncDataLoaderFeature = {
-    key: "async-data-loader",
-    getInitialState: (initialState) => (Object.assign({ loadingItemData: [], loadingItemChildrens: [] }, initialState)),
-    getDefaultConfig: (defaultConfig, tree) => (Object.assign({ setLoadingItemData: (0, utils_1.makeStateUpdater)("loadingItemData", tree), setLoadingItemChildrens: (0, utils_1.makeStateUpdater)("loadingItemChildrens", tree) }, defaultConfig)),
-    stateHandlerNames: {
-        loadingItemData: "setLoadingItemData",
-        loadingItemChildrens: "setLoadingItemChildrens",
-    },
-    treeInstance: {
-        waitForItemDataLoaded: ({ tree }, itemId) => tree.loadItemData(itemId),
-        waitForItemChildrenLoaded: ({ tree }, itemId) => tree.loadChildrenIds(itemId),
-        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();
-            const dataRef = getDataRef(tree);
-            if (dataRef.current.itemData[itemId]) {
-                return dataRef.current.itemData[itemId];
-            }
-            if (!tree.getState().loadingItemData.includes(itemId) && !skipFetch) {
-                tree.applySubStateUpdate("loadingItemData", (loadingItemData) => [
-                    ...loadingItemData,
-                    itemId,
-                ]);
-                loadItemData(tree, itemId);
-            }
-            return (_b = (_a = config.createLoadingItemData) === null || _a === void 0 ? void 0 : _a.call(config)) !== null && _b !== void 0 ? _b : null;
-        },
-        retrieveChildrenIds: ({ tree }, itemId, skipFetch = false) => {
-            const dataRef = getDataRef(tree);
-            if (dataRef.current.childrenIds[itemId]) {
-                return dataRef.current.childrenIds[itemId];
-            }
-            if (tree.getState().loadingItemChildrens.includes(itemId) || skipFetch) {
-                return [];
-            }
-            tree.applySubStateUpdate("loadingItemChildrens", (loadingItemChildrens) => [...loadingItemChildrens, itemId]);
-            loadChildrenIds(tree, itemId);
-            return [];
-        },
-    },
-    itemInstance: {
-        isLoading: ({ tree, item }) => tree.getState().loadingItemData.includes(item.getItemMeta().itemId) ||
-            tree.getState().loadingItemChildrens.includes(item.getItemMeta().itemId),
-        invalidateItemData: (_a, optimistic_1) => __awaiter(void 0, [_a, optimistic_1], void 0, function* ({ tree, itemId }, optimistic) {
-            var _b;
-            if (!optimistic) {
-                (_b = getDataRef(tree).current.itemData) === null || _b === void 0 ? true : delete _b[itemId];
-                tree.applySubStateUpdate("loadingItemData", (loadingItemData) => [
-                    ...loadingItemData,
-                    itemId,
-                ]);
-            }
-            yield loadItemData(tree, itemId);
-        }),
-        invalidateChildrenIds: (_a, optimistic_1) => __awaiter(void 0, [_a, optimistic_1], void 0, function* ({ tree, itemId }, optimistic) {
-            var _b;
-            if (!optimistic) {
-                (_b = getDataRef(tree).current.childrenIds) === null || _b === void 0 ? true : delete _b[itemId];
-                tree.applySubStateUpdate("loadingItemChildrens", (loadingItemChildrens) => [...loadingItemChildrens, itemId]);
-            }
-            yield loadChildrenIds(tree, itemId);
-        }),
-        updateCachedChildrenIds: ({ tree, itemId }, childrenIds) => {
-            const dataRef = tree.getDataRef();
-            dataRef.current.childrenIds[itemId] = childrenIds;
-            tree.rebuildTree();
-        },
-    },
-};