@headless-tree/core 0.0.0-20230802230636

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

@@ -0,0 +1,227 @@
+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, memo, poll } from "../../utils";
+export const treeFeature = {
+    key: "tree",
+    getInitialState: (initialState) => (Object.assign({ expandedItems: [], focusedItem: null }, initialState)),
+    getDefaultConfig: (defaultConfig, tree) => (Object.assign({ setExpandedItems: makeStateUpdater("expandedItems", tree), setFocusedItem: makeStateUpdater("focusedItem", tree) }, defaultConfig)),
+    stateHandlerNames: {
+        expandedItems: "setExpandedItems",
+        focusedItem: "setFocusedItem",
+    },
+    createTreeInstance: (prev, instance) => (Object.assign(Object.assign({}, prev), { retrieveItemData: () => {
+            throw new Error("No data-loader registered");
+        }, retrieveChildrenIds: () => {
+            throw new Error("No data-loader registered");
+        }, isItemExpanded: (itemId) => instance.getState().expandedItems.includes(itemId), getItemsMeta: () => {
+            const { rootItemId } = instance.getConfig();
+            const { expandedItems } = instance.getState();
+            const flatItems = [];
+            const recursiveAdd = (itemId, parentId, level, setSize, posInSet) => {
+                var _a;
+                flatItems.push({
+                    itemId,
+                    level,
+                    index: flatItems.length,
+                    parentId,
+                    setSize,
+                    posInSet,
+                });
+                if (expandedItems.includes(itemId)) {
+                    const children = (_a = instance.retrieveChildrenIds(itemId)) !== null && _a !== void 0 ? _a : [];
+                    let i = 0;
+                    for (const childId of children) {
+                        recursiveAdd(childId, itemId, level + 1, children.length, i++);
+                    }
+                }
+            };
+            const children = instance.retrieveChildrenIds(rootItemId);
+            let i = 0;
+            for (const itemId of children) {
+                recursiveAdd(itemId, rootItemId, 0, children.length, i++);
+            }
+            return flatItems;
+        }, expandItem: (itemId) => {
+            var _a;
+            if (!instance.getItemInstance(itemId).isFolder()) {
+                return;
+            }
+            if ((_a = instance.getState().loadingItems) === null || _a === void 0 ? void 0 : _a.includes(itemId)) {
+                return;
+            }
+            instance.applySubStateUpdate("expandedItems", (expandedItems) => [
+                ...expandedItems,
+                itemId,
+            ]);
+            instance.rebuildTree();
+        }, collapseItem: (itemId) => {
+            if (!instance.getItemInstance(itemId).isFolder()) {
+                return;
+            }
+            instance.applySubStateUpdate("expandedItems", (expandedItems) => expandedItems.filter((id) => id !== itemId));
+            instance.rebuildTree();
+        }, 
+        // TODO memo
+        getFocusedItem: () => {
+            var _a, _b;
+            return ((_b = instance.getItemInstance((_a = instance.getState().focusedItem) !== null && _a !== void 0 ? _a : "")) !== null && _b !== void 0 ? _b : instance.getItems()[0]);
+        }, focusItem: (itemId) => {
+            instance.applySubStateUpdate("focusedItem", itemId);
+        }, focusNextItem: () => {
+            const { index } = instance.getFocusedItem().getItemMeta();
+            const nextIndex = Math.min(index + 1, instance.getItems().length - 1);
+            instance.focusItem(instance.getItems()[nextIndex].getId());
+        }, focusPreviousItem: () => {
+            const { index } = instance.getFocusedItem().getItemMeta();
+            const nextIndex = Math.max(index - 1, 0);
+            instance.focusItem(instance.getItems()[nextIndex].getId());
+        }, updateDomFocus: () => {
+            // Required because if the state is managed outside in react, the state only updated during next render
+            setTimeout(() => __awaiter(void 0, void 0, void 0, function* () {
+                var _a, _b;
+                const focusedItem = instance.getFocusedItem();
+                (_b = (_a = instance.getConfig()).scrollToItem) === null || _b === void 0 ? void 0 : _b.call(_a, focusedItem);
+                yield poll(() => focusedItem.getElement() !== null, 20);
+                const focusedElement = focusedItem.getElement();
+                if (!focusedElement)
+                    return;
+                focusedElement.focus();
+            }));
+        }, getContainerProps: () => {
+            var _a;
+            return (Object.assign(Object.assign({}, (_a = prev.getContainerProps) === null || _a === void 0 ? void 0 : _a.call(prev)), { role: "tree", ariaLabel: "", ariaActivedescendant: "" }));
+        } })),
+    createItemInstance: (prev, item, tree) => (Object.assign(Object.assign({}, prev), { isLoading: () => {
+            throw new Error("No data-loader registered");
+        }, scrollTo: (scrollIntoViewArg) => __awaiter(void 0, void 0, void 0, function* () {
+            var _a, _b;
+            (_b = (_a = tree.getConfig()).scrollToItem) === null || _b === void 0 ? void 0 : _b.call(_a, item);
+            yield poll(() => item.getElement() !== null, 20);
+            item.getElement().scrollIntoView(scrollIntoViewArg);
+        }), getId: () => item.getItemMeta().itemId, getProps: () => {
+            var _a;
+            const itemMeta = item.getItemMeta();
+            return Object.assign(Object.assign({}, (_a = prev.getProps) === null || _a === void 0 ? void 0 : _a.call(prev)), { role: "treeitem", "aria-setsize": itemMeta.setSize, "aria-posinset": itemMeta.posInSet, "aria-selected": "false", "aria-label": item.getItemName(), "aria-level": itemMeta.level, tabIndex: item.isFocused() ? 0 : -1, onClick: item.getMemoizedProp("tree/onClick", () => (e) => {
+                    item.setFocused();
+                    item.primaryAction();
+                    if (e.ctrlKey || e.shiftKey || e.metaKey) {
+                        return;
+                    }
+                    if (!item.isFolder()) {
+                        return;
+                    }
+                    if (item.isExpanded()) {
+                        item.collapse();
+                    }
+                    else {
+                        item.expand();
+                    }
+                }) });
+        }, expand: () => tree.expandItem(item.getItemMeta().itemId), collapse: () => tree.collapseItem(item.getItemMeta().itemId), getItemData: () => tree.retrieveItemData(item.getItemMeta().itemId), isExpanded: () => tree.getState().expandedItems.includes(item.getItemMeta().itemId), isFocused: () => tree.getState().focusedItem === item.getItemMeta().itemId ||
+            (tree.getState().focusedItem === null && item.getItemMeta().index === 0), isFolder: () => item.getItemMeta().level === -1 ||
+            tree.getConfig().isItemFolder(item), getItemName: () => {
+            const config = tree.getConfig();
+            return config.getItemName(item);
+        }, setFocused: () => tree.focusItem(item.getItemMeta().itemId), primaryAction: () => { var _a, _b; return (_b = (_a = tree.getConfig()).onPrimaryAction) === null || _b === void 0 ? void 0 : _b.call(_a, item); }, getParent: memo((itemMeta) => {
+            for (let i = itemMeta.index - 1; i >= 0; i--) {
+                const potentialParent = tree.getItems()[i];
+                if (potentialParent.getItemMeta().level < itemMeta.level) {
+                    return potentialParent;
+                }
+            }
+            return tree.getItemInstance(tree.getConfig().rootItemId);
+        }, () => [item.getItemMeta()]), 
+        // TODO remove
+        getIndexInParent: () => item.getItemMeta().posInSet, getChildren: () => tree
+            .retrieveChildrenIds(item.getItemMeta().itemId)
+            .map((id) => tree.getItemInstance(id)), getTree: () => tree, getItemAbove: () => tree.getItems()[item.getItemMeta().index - 1], getItemBelow: () => tree.getItems()[item.getItemMeta().index + 1], getMemoizedProp: (name, create, deps) => {
+            var _a, _b, _c, _d, _e;
+            var _f, _g;
+            const data = item.getDataRef();
+            const memoizedValue = (_a = data.current.memoizedValues) === null || _a === void 0 ? void 0 : _a[name];
+            if (memoizedValue &&
+                (!deps ||
+                    ((_c = (_b = data.current.memoizedDeps) === null || _b === void 0 ? void 0 : _b[name]) === null || _c === void 0 ? void 0 : _c.every((d, i) => d === deps[i])))) {
+                return memoizedValue;
+            }
+            (_d = (_f = data.current).memoizedDeps) !== null && _d !== void 0 ? _d : (_f.memoizedDeps = {});
+            (_e = (_g = data.current).memoizedValues) !== null && _e !== void 0 ? _e : (_g.memoizedValues = {});
+            const value = create();
+            data.current.memoizedDeps[name] = deps;
+            data.current.memoizedValues[name] = value;
+            return value;
+        } })),
+    hotkeys: {
+        focusNextItem: {
+            hotkey: "ArrowDown",
+            canRepeat: true,
+            preventDefault: true,
+            isEnabled: (tree) => { var _a, _b; return !((_b = (_a = tree.isSearchOpen) === null || _a === void 0 ? void 0 : _a.call(tree)) !== null && _b !== void 0 ? _b : false) && !tree.getState().dnd; },
+            handler: (e, tree) => {
+                tree.focusNextItem();
+                tree.updateDomFocus();
+            },
+        },
+        focusPreviousItem: {
+            hotkey: "ArrowUp",
+            canRepeat: true,
+            preventDefault: true,
+            isEnabled: (tree) => { var _a, _b; return !((_b = (_a = tree.isSearchOpen) === null || _a === void 0 ? void 0 : _a.call(tree)) !== null && _b !== void 0 ? _b : false) && !tree.getState().dnd; },
+            handler: (e, tree) => {
+                tree.focusPreviousItem();
+                tree.updateDomFocus();
+            },
+        },
+        expandOrDown: {
+            hotkey: "ArrowRight",
+            canRepeat: true,
+            handler: (e, tree) => {
+                const item = tree.getFocusedItem();
+                if (item.isExpanded() || !item.isFolder()) {
+                    tree.focusNextItem();
+                    tree.updateDomFocus();
+                }
+                else {
+                    item.expand();
+                }
+            },
+        },
+        collapseOrUp: {
+            hotkey: "ArrowLeft",
+            canRepeat: true,
+            handler: (e, tree) => {
+                var _a;
+                const item = tree.getFocusedItem();
+                if ((!item.isExpanded() || !item.isFolder()) &&
+                    item.getItemMeta().level !== 0) {
+                    (_a = item.getParent()) === null || _a === void 0 ? void 0 : _a.setFocused();
+                    tree.updateDomFocus();
+                }
+                else {
+                    item.collapse();
+                }
+            },
+        },
+        focusFirstItem: {
+            hotkey: "Home",
+            handler: (e, tree) => {
+                tree.focusItem(tree.getItems()[0].getId());
+                tree.updateDomFocus();
+            },
+        },
+        focusLastItem: {
+            hotkey: "End",
+            handler: (e, tree) => {
+                tree.focusItem(tree.getItems()[tree.getItems().length - 1].getId());
+                tree.updateDomFocus();
+            },
+        },
+    },
+};

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

@@ -0,0 +1,62 @@
+import { ItemInstance, SetStateFn, TreeInstance } from "../../types/core";
+export type ItemMeta = {
+    itemId: string;
+    parentId: string;
+    level: number;
+    index: number;
+    setSize: number;
+    posInSet: number;
+};
+export type TreeItemDataRef = {
+    memoizedValues: Record<string, any>;
+    memoizedDeps: Record<string, any[] | undefined>;
+};
+export type TreeFeatureDef<T> = {
+    state: {
+        expandedItems: string[];
+        focusedItem: string | null;
+    };
+    config: {
+        isItemFolder: (item: ItemInstance<T>) => boolean;
+        getItemName: (item: ItemInstance<T>) => string;
+        onPrimaryAction?: (item: ItemInstance<T>) => void;
+        scrollToItem?: (item: ItemInstance<T>) => void;
+        setExpandedItems?: SetStateFn<string[]>;
+        setFocusedItem?: SetStateFn<string | null>;
+    };
+    treeInstance: {
+        /** @internal */
+        getItemsMeta: () => ItemMeta[];
+        expandItem: (itemId: string) => void;
+        collapseItem: (itemId: string) => void;
+        isItemExpanded: (itemId: string) => boolean;
+        focusItem: (itemId: string) => void;
+        getFocusedItem: () => ItemInstance<any>;
+        focusNextItem: () => void;
+        focusPreviousItem: () => void;
+        updateDomFocus: () => void;
+        getContainerProps: () => Record<string, any>;
+    };
+    itemInstance: {
+        getId: () => string;
+        getProps: () => Record<string, any>;
+        getItemName: () => string;
+        getItemData: () => T;
+        expand: () => void;
+        collapse: () => void;
+        isExpanded: () => boolean;
+        isFocused: () => boolean;
+        isFolder: () => boolean;
+        setFocused: () => void;
+        getParent: () => ItemInstance<T>;
+        getChildren: () => ItemInstance<T>[];
+        getIndexInParent: () => number;
+        primaryAction: () => void;
+        getTree: () => TreeInstance<T>;
+        getItemAbove: () => ItemInstance<T> | null;
+        getItemBelow: () => ItemInstance<T> | null;
+        getMemoizedProp: <X>(name: string, create: () => X, deps?: any[]) => X;
+        scrollTo: (scrollIntoViewArg?: boolean | ScrollIntoViewOptions) => Promise<void>;
+    };
+    hotkeys: "focusNextItem" | "focusPreviousItem" | "expandOrDown" | "collapseOrUp" | "focusFirstItem" | "focusLastItem";
+};

package/lib/esm/features/tree/types.js

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

package/lib/esm/index.d.ts

@@ -0,0 +1,23 @@
+export * from "./types/core";
+export * from "./core/create-tree";
+export * from "./features/tree/types";
+export * from "./features/main/types";
+export * from "./features/drag-and-drop/types";
+export * from "./features/selection/types";
+export * from "./features/async-data-loader/types";
+export * from "./features/sync-data-loader/types";
+export * from "./features/hotkeys-core/types";
+export * from "./features/search/types";
+export * from "./features/renaming/types";
+export * from "./features/expand-all/types";
+export * from "./features/selection/feature";
+export * from "./features/hotkeys-core/feature";
+export * from "./features/async-data-loader/feature";
+export * from "./features/sync-data-loader/feature";
+export * from "./features/drag-and-drop/feature";
+export * from "./features/search/feature";
+export * from "./features/renaming/feature";
+export * from "./features/expand-all/feature";
+export * from "./utilities/create-on-drop-handler";
+export * from "./utilities/insert-items-at-target";
+export * from "./utilities/remove-items-from-parents";

package/lib/esm/index.js

@@ -0,0 +1,23 @@
+export * from "./types/core";
+export * from "./core/create-tree";
+export * from "./features/tree/types";
+export * from "./features/main/types";
+export * from "./features/drag-and-drop/types";
+export * from "./features/selection/types";
+export * from "./features/async-data-loader/types";
+export * from "./features/sync-data-loader/types";
+export * from "./features/hotkeys-core/types";
+export * from "./features/search/types";
+export * from "./features/renaming/types";
+export * from "./features/expand-all/types";
+export * from "./features/selection/feature";
+export * from "./features/hotkeys-core/feature";
+export * from "./features/async-data-loader/feature";
+export * from "./features/sync-data-loader/feature";
+export * from "./features/drag-and-drop/feature";
+export * from "./features/search/feature";
+export * from "./features/renaming/feature";
+export * from "./features/expand-all/feature";
+export * from "./utilities/create-on-drop-handler";
+export * from "./utilities/insert-items-at-target";
+export * from "./utilities/remove-items-from-parents";

package/lib/esm/mddocs-entry.d.ts

@@ -0,0 +1,21 @@
+import { MainFeatureDef } from "./features/main/types";
+import { DragAndDropFeatureDef } from "./features/drag-and-drop/types";
+export * from ".";
+/** @interface */
+export type MainFeatureConfig = MainFeatureDef["config"];
+/** @interface */
+export type MainFeatureState = MainFeatureDef["state"];
+/** @interface */
+export type MainFeatureTreeInstance = MainFeatureDef["treeInstance"];
+/** @interface */
+export type MainFeatureItemInstance = MainFeatureDef["itemInstance"];
+export type MainFeatureHotkeys = MainFeatureDef["hotkeys"];
+/** @interface */
+export type DragAndDropFeatureConfig<T> = DragAndDropFeatureDef<T>["config"];
+/** @interface */
+export type DragAndDropFeatureState<T> = DragAndDropFeatureDef<T>["state"];
+/** @interface */
+export type DragAndDropFeatureTreeInstance<T> = DragAndDropFeatureDef<T>["treeInstance"];
+/** @interface */
+export type DragAndDropFeatureItemInstance<T> = DragAndDropFeatureDef<T>["itemInstance"];
+export type DragAndDropFeatureHotkeys<T> = DragAndDropFeatureDef<T>["hotkeys"];

package/lib/esm/mddocs-entry.js

@@ -0,0 +1 @@
+export * from ".";

package/lib/esm/types/core.d.ts

@@ -0,0 +1,67 @@
+import { DragAndDropFeatureDef } from "../features/drag-and-drop/types";
+import { MainFeatureDef } from "../features/main/types";
+import { SelectionFeatureDef } from "../features/selection/types";
+import { TreeFeatureDef } from "../features/tree/types";
+import { HotkeyConfig, HotkeysCoreFeatureDef } from "../features/hotkeys-core/types";
+import { SyncDataLoaderFeatureDef } from "../features/sync-data-loader/types";
+import { AsyncDataLoaderFeatureDef } from "../features/async-data-loader/types";
+import { SearchFeatureDef } from "../features/search/types";
+import { RenamingFeatureDef } from "../features/renaming/types";
+import { ExpandAllFeatureDef } from "../features/expand-all/types";
+export type Updater<T> = T | ((old: T) => T);
+export type SetStateFn<T> = (updaterOrValue: Updater<T>) => void;
+export type FeatureDef = {
+    state: object;
+    config: object;
+    treeInstance: object;
+    itemInstance: object;
+    hotkeys: string;
+};
+export type EmptyFeatureDef = {
+    state: {};
+    config: {};
+    treeInstance: {};
+    itemInstance: {};
+    hotkeys: never;
+};
+type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;
+export type DefaultFeatures<T> = MainFeatureDef | TreeFeatureDef<T>;
+export type FeatureDefs<T> = MainFeatureDef | TreeFeatureDef<T> | SelectionFeatureDef<T> | DragAndDropFeatureDef<T> | HotkeysCoreFeatureDef<T> | SyncDataLoaderFeatureDef<T> | AsyncDataLoaderFeatureDef<T> | SearchFeatureDef<T> | RenamingFeatureDef<T> | ExpandAllFeatureDef;
+type MergedFeatures<F extends FeatureDef> = {
+    state: UnionToIntersection<F["state"]>;
+    config: UnionToIntersection<F["config"]>;
+    treeInstance: UnionToIntersection<F["treeInstance"]>;
+    itemInstance: UnionToIntersection<F["itemInstance"]>;
+    hotkeys: F["hotkeys"];
+};
+type TreeStateType<T> = MainFeatureDef["state"] & TreeFeatureDef<T>["state"] & SelectionFeatureDef<T>["state"] & DragAndDropFeatureDef<T>["state"] & HotkeysCoreFeatureDef<T>["state"] & SyncDataLoaderFeatureDef<T>["state"] & AsyncDataLoaderFeatureDef<T>["state"] & SearchFeatureDef<T>["state"] & RenamingFeatureDef<T>["state"] & ExpandAllFeatureDef["state"];
+export interface TreeState<T> extends TreeStateType<T> {
+}
+type TreeConfigType<T> = MainFeatureDef["config"] & TreeFeatureDef<T>["config"] & SelectionFeatureDef<T>["config"] & DragAndDropFeatureDef<T>["config"] & HotkeysCoreFeatureDef<T>["config"] & SyncDataLoaderFeatureDef<T>["config"] & AsyncDataLoaderFeatureDef<T>["config"] & SearchFeatureDef<T>["config"] & RenamingFeatureDef<T>["config"] & ExpandAllFeatureDef["config"];
+export interface TreeConfig<T> extends TreeConfigType<T> {
+}
+type TreeInstanceType<T> = MainFeatureDef["treeInstance"] & TreeFeatureDef<T>["treeInstance"] & SelectionFeatureDef<T>["treeInstance"] & DragAndDropFeatureDef<T>["treeInstance"] & HotkeysCoreFeatureDef<T>["treeInstance"] & SyncDataLoaderFeatureDef<T>["treeInstance"] & AsyncDataLoaderFeatureDef<T>["treeInstance"] & SearchFeatureDef<T>["treeInstance"] & RenamingFeatureDef<T>["treeInstance"] & ExpandAllFeatureDef["treeInstance"];
+export interface TreeInstance<T> extends TreeInstanceType<T> {
+}
+type ItemInstanceType<T> = MainFeatureDef["itemInstance"] & TreeFeatureDef<T>["itemInstance"] & SelectionFeatureDef<T>["itemInstance"] & DragAndDropFeatureDef<T>["itemInstance"] & HotkeysCoreFeatureDef<T>["itemInstance"] & SyncDataLoaderFeatureDef<T>["itemInstance"] & AsyncDataLoaderFeatureDef<T>["itemInstance"] & SearchFeatureDef<T>["itemInstance"] & RenamingFeatureDef<T>["itemInstance"] & ExpandAllFeatureDef["itemInstance"];
+export interface ItemInstance<T> extends ItemInstanceType<T> {
+}
+export type HotkeyName<F extends FeatureDef = FeatureDefs<any>> = MergedFeatures<F>["hotkeys"];
+export type HotkeysConfig<T, F extends FeatureDef = FeatureDefs<T>> = Record<HotkeyName<F>, HotkeyConfig<T>>;
+export type CustomHotkeysConfig<T, F extends FeatureDef = FeatureDefs<T>> = Partial<Record<HotkeyName<F> | `custom${string}`, Partial<HotkeyConfig<T>>>>;
+export type FeatureImplementation<T = any, D extends FeatureDef = any, F extends FeatureDef = EmptyFeatureDef> = {
+    key?: string;
+    deps?: string[];
+    overwrites?: string[];
+    stateHandlerNames?: Partial<Record<keyof MergedFeatures<F>["state"], keyof MergedFeatures<F>["config"]>>;
+    getInitialState?: (initialState: Partial<MergedFeatures<F>["state"]>, tree: MergedFeatures<F>["treeInstance"]) => Partial<D["state"] & MergedFeatures<F>["state"]>;
+    getDefaultConfig?: (defaultConfig: Partial<MergedFeatures<F>["config"]>, tree: MergedFeatures<F>["treeInstance"]) => Partial<D["config"] & MergedFeatures<F>["config"]>;
+    createTreeInstance?: (prev: MergedFeatures<F>["treeInstance"], instance: MergedFeatures<F>["treeInstance"]) => D["treeInstance"] & MergedFeatures<F>["treeInstance"];
+    createItemInstance?: (prev: MergedFeatures<F>["itemInstance"], item: MergedFeatures<F>["itemInstance"], tree: MergedFeatures<F>["treeInstance"], itemId: string) => D["itemInstance"] & MergedFeatures<F>["itemInstance"];
+    onTreeMount?: (instance: MergedFeatures<F>["treeInstance"], treeElement: HTMLElement) => void;
+    onTreeUnmount?: (instance: MergedFeatures<F>["treeInstance"], treeElement: HTMLElement) => void;
+    onItemMount?: (instance: MergedFeatures<F>["itemInstance"], itemElement: HTMLElement, tree: MergedFeatures<F>["treeInstance"]) => void;
+    onItemUnmount?: (instance: MergedFeatures<F>["itemInstance"], itemElement: HTMLElement, tree: MergedFeatures<F>["treeInstance"]) => void;
+    hotkeys?: HotkeysConfig<T, D>;
+};
+export {};

package/lib/esm/types/core.js

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

package/lib/esm/types/deep-merge.d.ts

@@ -0,0 +1,13 @@
+type TAllKeys<T> = T extends any ? keyof T : never;
+type TIndexValue<T, K extends PropertyKey, D = never> = T extends any ? K extends keyof T ? T[K] : D : never;
+type TPartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>> extends infer O ? {
+    [P in keyof O]: O[P];
+} : never;
+type TFunction = (...a: any[]) => any;
+type TPrimitives = string | number | boolean | bigint | symbol | Date | TFunction;
+export type TMerged<T> = [T] extends [Array<any>] ? {
+    [K in keyof T]: TMerged<T[K]>;
+} : [T] extends [TPrimitives] ? T : [T] extends [object] ? TPartialKeys<{
+    [K in TAllKeys<T>]: TMerged<TIndexValue<T, K>>;
+}, never> : T;
+export {};

package/lib/esm/types/deep-merge.js

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

package/lib/esm/utilities/create-on-drop-handler.d.ts

@@ -0,0 +1,3 @@
+import { ItemInstance } from "../types/core";
+import { DropTarget } from "../features/drag-and-drop/types";
+export declare const createOnDropHandler: <T>(onChangeChildren: (item: ItemInstance<T>, newChildren: string[]) => void) => (items: ItemInstance<T>[], target: DropTarget<T>) => void;

package/lib/esm/utilities/create-on-drop-handler.js

@@ -0,0 +1,7 @@
+import { removeItemsFromParents } from "./remove-items-from-parents";
+import { insertItemsAtTarget } from "./insert-items-at-target";
+export const createOnDropHandler = (onChangeChildren) => (items, target) => {
+    const itemIds = items.map((item) => item.getId());
+    removeItemsFromParents(items, onChangeChildren);
+    insertItemsAtTarget(itemIds, target, onChangeChildren);
+};

package/lib/esm/utilities/insert-items-at-target.d.ts

@@ -0,0 +1,3 @@
+import { ItemInstance } from "../types/core";
+import { DropTarget } from "../features/drag-and-drop/types";
+export declare const insertItemsAtTarget: <T>(itemIds: string[], target: DropTarget<T>, onChangeChildren: (item: ItemInstance<T>, newChildrenIds: string[]) => void) => void;

package/lib/esm/utilities/insert-items-at-target.js

@@ -0,0 +1,20 @@
+export const insertItemsAtTarget = (itemIds, target, onChangeChildren) => {
+    // add moved items to new common parent, if dropped onto parent
+    if (target.childIndex === null) {
+        onChangeChildren(target.item, [
+            ...target.item.getChildren().map((item) => item.getId()),
+            ...itemIds,
+        ]);
+        // TODO items[0].getTree().rebuildTree();
+        return;
+    }
+    // add moved items to new common parent, if dropped between siblings
+    const oldChildren = target.item.getChildren();
+    const newChildren = [
+        ...oldChildren.slice(0, target.insertionIndex).map((item) => item.getId()),
+        ...itemIds,
+        ...oldChildren.slice(target.insertionIndex).map((item) => item.getId()),
+    ];
+    onChangeChildren(target.item, newChildren);
+    target.item.getTree().rebuildTree();
+};

package/lib/esm/utilities/remove-items-from-parents.d.ts

@@ -0,0 +1,2 @@
+import { ItemInstance } from "../types/core";
+export declare const removeItemsFromParents: <T>(movedItems: ItemInstance<T>[], onChangeChildren: (item: ItemInstance<T>, newChildrenIds: string[]) => void) => void;

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

@@ -0,0 +1,13 @@
+export const removeItemsFromParents = (movedItems, onChangeChildren) => {
+    var _a;
+    // TODO bulk sibling changes together
+    for (const item of movedItems) {
+        const siblings = (_a = item.getParent()) === null || _a === void 0 ? void 0 : _a.getChildren();
+        if (siblings) {
+            onChangeChildren(item.getParent(), siblings
+                .filter((sibling) => sibling.getId() !== item.getId())
+                .map((i) => i.getId()));
+        }
+    }
+    movedItems[0].getTree().rebuildTree();
+};

package/lib/esm/utils.d.ts

@@ -0,0 +1,6 @@
+import { TreeState, Updater } from "./types/core";
+export type NoInfer<T> = [T][T extends any ? 0 : never];
+export declare const memo: <D extends readonly any[], R>(fn: (...args_0: D) => R, deps: () => [...D]) => () => 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): (updater: Updater<TreeState<any>[K]>) => void;
+export declare const poll: (fn: () => boolean, interval?: number, timeout?: number) => Promise<void>;

package/lib/esm/utils.js

@@ -0,0 +1,46 @@
+export const memo = (fn, deps) => {
+    let value;
+    let oldDeps = null;
+    return () => {
+        const newDeps = deps();
+        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;
+    };
+};
+export function functionalUpdate(updater, input) {
+    return typeof updater === "function"
+        ? updater(input)
+        : updater;
+}
+export function makeStateUpdater(key, instance) {
+    return (updater) => {
+        instance.setState((old) => {
+            return Object.assign(Object.assign({}, old), { [key]: functionalUpdate(updater, old[key]) });
+        });
+    };
+}
+export 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);
+});

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@headless-tree/core",
+  "version": "0.0.0-20230802230636",
+  "main": "lib/cjs/index.js",
+  "module": "lib/esm/index.js",
+  "types": "lib/esm/index.d.ts",
+  "sideEffects": false,
+  "scripts": {
+    "build:cjs": "tsc -m commonjs --outDir lib/cjs",
+    "build:esm": "tsc",
+    "start": "tsc -w"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:lukasbach/headless-tree.git",
+    "directory": "packages/core"
+  },
+  "author": "Lukas Bach <npm@lukasbach.com>",
+  "license": "MIT",
+  "devDependencies": {
+    "typescript": "^5.0.4"
+  }
+}