@headless-tree/core 1.2.1 → 1.3.0

package/src/features/tree/tree.spec.ts

@@ -235,8 +235,8 @@ describe("core-feature/selections", () => {
       it("generates item props for random item", () => {
         expect(tree.instance.getItemInstance("x2").getProps()).toEqual({
           "aria-label": "x2",
-          "aria-level": 0,
-          "aria-posinset": 1,
+          "aria-level": 1,
+          "aria-posinset": 2,
           "aria-selected": "false",
           "aria-setsize": 4,
           onClick: expect.any(Function),
@@ -249,8 +249,8 @@ describe("core-feature/selections", () => {
       it("generates item props for focused", () => {
         expect(tree.instance.getItemInstance("x1").getProps()).toEqual({
           "aria-label": "x1",
-          "aria-level": 0,
-          "aria-posinset": 0,
+          "aria-level": 1,
+          "aria-posinset": 1,
           "aria-selected": "false",
           "aria-setsize": 4,
           onClick: expect.any(Function),
@@ -472,4 +472,14 @@ describe("core-feature/selections", () => {
       });
     });
   });
+
+  describe("empty rootItemId", () => {
+    factory.with({ rootItemId: "" }).forSuits((tree) => {
+      describe("focused item", () => {
+        it("returns correct initial focused item", () => {
+          expect(tree.instance.getFocusedItem().getId()).toBe("1");
+        });
+      });
+    });
+  });
 });

package/src/test-utils/test-tree-do.ts

@@ -105,12 +105,14 @@ export class TestTreeDo<T> {
   dragEnd(itemId: string, event?: DragEvent) {
     const e = event ?? TestTree.dragEvent();
     this.itemProps(itemId).onDragEnd(e);
+    window.dispatchEvent(new CustomEvent("dragend"));
     return e;
   }
 
   async drop(itemId: string, event?: DragEvent) {
     const e = event ?? TestTree.dragEvent();
     await this.itemProps(itemId).onDrop(e);
+    window.dispatchEvent(new CustomEvent("dragend"));
     return e;
   }
 

package/src/test-utils/test-tree.ts

@@ -137,6 +137,7 @@ export class TestTree<T = string> {
     // eslint-disable-next-line @typescript-eslint/no-unused-expressions
     this.instance;
     await this.resolveAsyncVisibleItems();
+    this.instance.registerElement({ getBoundingClientRect: () => null } as any);
     return this;
   }
 

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/vitest.config.ts

@@ -2,5 +2,7 @@
 import { defineConfig } from "vitest/config";
 
 export default defineConfig({
-  test: {},
+  test: {
+    environment: "jsdom",
+  },
 });

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();
-        },
-    },
-};

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

@@ -1,47 +0,0 @@
-import { SetStateFn } from "../../types/core";
-import { SyncDataLoaderFeatureDef } from "../sync-data-loader/types";
-export interface AsyncDataLoaderDataRef<T = any> {
-    itemData: Record<string, T>;
-    childrenIds: Record<string, string[]>;
-}
-/**
- * @category Async Data Loader/General
- * */
-export type AsyncDataLoaderFeatureDef<T> = {
-    state: {
-        loadingItemData: string[];
-        loadingItemChildrens: string[];
-    };
-    config: {
-        rootItemId: string;
-        /** Will be called when HT retrieves item data for an item whose item data is asynchronously being loaded.
-         * Can be used to create placeholder data to use for rendering the tree item while it is loaded. If not defined,
-         * the tree item data will be null. */
-        createLoadingItemData?: () => T;
-        setLoadingItemData?: SetStateFn<string[]>;
-        setLoadingItemChildrens?: SetStateFn<string[]>;
-        onLoadedItem?: (itemId: string, item: T) => void;
-        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
-         * @param optimistic If true, the item will not trigger a state update on `loadingItemData`, and
-         * the tree will continue to display the old data until the new data has loaded. */
-        invalidateItemData: (optimistic?: boolean) => Promise<void>;
-        /** Invalidate fetched children ids for item, and triggers a refetch and subsequent rerender if the item is visible
-         * @param optimistic If true, the item will not trigger a state update on `loadingItemChildrens`, and
-         * the tree will continue to display the old data until the new data has loaded. */
-        invalidateChildrenIds: (optimistic?: boolean) => Promise<void>;
-        updateCachedChildrenIds: (childrenIds: string[]) => void;
-        isLoading: () => boolean;
-    };
-    hotkeys: SyncDataLoaderFeatureDef<T>["hotkeys"];
-};

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

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

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)));
-            }
-        },
-    },
-};