@headless-tree/core 1.2.1 → 1.4.0

package/lib/cjs/utilities/remove-items-from-parents.js

@@ -1,32 +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.removeItemsFromParents = void 0;
-const removeItemsFromParents = (movedItems, onChangeChildren) => __awaiter(void 0, void 0, void 0, function* () {
-    const movedItemsIds = movedItems.map((item) => item.getId());
-    const uniqueParents = [
-        ...new Set(movedItems.map((item) => item.getParent())),
-    ];
-    for (const parent of uniqueParents) {
-        const siblings = parent === null || parent === void 0 ? void 0 : parent.getChildren();
-        if (siblings && parent) {
-            const newChildren = siblings
-                .filter((sibling) => !movedItemsIds.includes(sibling.getId()))
-                .map((i) => i.getId());
-            yield onChangeChildren(parent, newChildren);
-            if (parent && "updateCachedChildrenIds" in parent) {
-                parent === null || parent === void 0 ? void 0 : parent.updateCachedChildrenIds(newChildren);
-            }
-        }
-    }
-    movedItems[0].getTree().rebuildTree();
-});
-exports.removeItemsFromParents = removeItemsFromParents;

package/lib/cjs/utils.d.ts

@@ -1,6 +0,0 @@
-import { SetStateFn, TreeState, Updater } from "./types/core";
-export type NoInfer<T> = [T][T extends any ? 0 : never];
-export declare const memo: <D extends readonly any[], P extends readonly any[], R>(deps: (...args: [...P]) => [...D], fn: (...args: [...D]) => R) => (...a: P) => R;
-export declare function functionalUpdate<T>(updater: Updater<T>, input: T): T;
-export declare function makeStateUpdater<K extends keyof TreeState<any>>(key: K, instance: unknown): SetStateFn<TreeState<any>[K]>;
-export declare const poll: (fn: () => boolean, interval?: number, timeout?: number) => Promise<void>;

package/lib/cjs/utils.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.poll = exports.memo = void 0;
-exports.functionalUpdate = functionalUpdate;
-exports.makeStateUpdater = makeStateUpdater;
-const memo = (deps, fn) => {
-    let value;
-    let oldDeps = null;
-    return (...a) => {
-        const newDeps = deps(...a);
-        if (!value) {
-            value = fn(...newDeps);
-            oldDeps = newDeps;
-            return value;
-        }
-        const match = oldDeps &&
-            oldDeps.length === newDeps.length &&
-            !oldDeps.some((dep, i) => dep !== newDeps[i]);
-        if (match) {
-            return value;
-        }
-        value = fn(...newDeps);
-        oldDeps = newDeps;
-        return value;
-    };
-};
-exports.memo = memo;
-function functionalUpdate(updater, input) {
-    return typeof updater === "function"
-        ? updater(input)
-        : updater;
-}
-function makeStateUpdater(key, instance) {
-    return (updater) => {
-        instance.setState((old) => {
-            return Object.assign(Object.assign({}, old), { [key]: functionalUpdate(updater, old[key]) });
-        });
-    };
-}
-const poll = (fn, interval = 100, timeout = 1000) => new Promise((resolve) => {
-    let clear;
-    const i = setInterval(() => {
-        if (fn()) {
-            resolve();
-            clearInterval(i);
-            clearTimeout(clear);
-        }
-    }, interval);
-    clear = setTimeout(() => {
-        clearInterval(i);
-    }, timeout);
-});
-exports.poll = poll;

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

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

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

@@ -1,54 +0,0 @@
-import { throwError } from "../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);
-};
-export 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 throwError(`feature missing for method ${key}`);
-                }
-                return invokeInstanceMethod(features, instanceType, opts, key, featureIndex, args);
-            };
-        },
-    });
-    Object.assign(opts, buildOpts(item));
-    return [item, noop];
-};

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

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

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

@@ -1,22 +0,0 @@
-/* eslint-disable no-continue,no-labels,no-extra-label */
-export 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];
-};

package/lib/esm/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/esm/core/create-tree.js

@@ -1,187 +0,0 @@
-import { treeFeature } from "../features/tree/feature";
-import { buildStaticInstance } from "./build-static-instance";
-import { throwError } from "../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 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));
-export const createTree = (initialConfig) => {
-    var _a, _b, _c, _d;
-    const buildInstance = (_a = initialConfig.instanceBuilder) !== null && _a !== void 0 ? _a : buildStaticInstance;
-    const additionalFeatures = [
-        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;
-};

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

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

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

@@ -1,132 +0,0 @@
-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";
-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;
-});
-export const asyncDataLoaderFeature = {
-    key: "async-data-loader",
-    getInitialState: (initialState) => (Object.assign({ loadingItemData: [], loadingItemChildrens: [] }, initialState)),
-    getDefaultConfig: (defaultConfig, tree) => (Object.assign({ setLoadingItemData: makeStateUpdater("loadingItemData", tree), setLoadingItemChildrens: 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/esm/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/esm/features/async-data-loader/types.js

@@ -1 +0,0 @@
-export {};

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

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

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

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