@headless-tree/core 1.2.1 → 1.4.0

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

@@ -1,63 +0,0 @@
-import { ItemInstance, SetStateFn, TreeInstance } from "../../types/core";
-export interface ItemMeta {
-    itemId: string;
-    parentId: string;
-    level: number;
-    index: number;
-    setSize: number;
-    posInSet: number;
-}
-export interface 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[];
-        getFocusedItem: () => ItemInstance<T>;
-        getRootItem: () => ItemInstance<T>;
-        focusNextItem: () => void;
-        focusPreviousItem: () => void;
-        updateDomFocus: () => void;
-        /** Pass to the container rendering the tree children. The `treeLabel` parameter
-         * will be passed as `aria-label` parameter, and is recommended to be set. */
-        getContainerProps: (treeLabel?: string) => Record<string, any>;
-    };
-    itemInstance: {
-        getId: () => string;
-        getKey: () => string;
-        getProps: () => Record<string, any>;
-        getItemName: () => string;
-        getItemData: () => T;
-        equals: (other?: ItemInstance<any> | null) => boolean;
-        expand: () => void;
-        collapse: () => void;
-        isExpanded: () => boolean;
-        isDescendentOf: (parentId: string) => boolean;
-        isFocused: () => boolean;
-        isFolder: () => boolean;
-        setFocused: () => void;
-        getParent: () => ItemInstance<T> | undefined;
-        getChildren: () => ItemInstance<T>[];
-        getIndexInParent: () => number;
-        primaryAction: () => void;
-        getTree: () => TreeInstance<T>;
-        getItemAbove: () => ItemInstance<T> | undefined;
-        getItemBelow: () => ItemInstance<T> | undefined;
-        scrollTo: (scrollIntoViewArg?: boolean | ScrollIntoViewOptions) => Promise<void>;
-    };
-    hotkeys: "focusNextItem" | "focusPreviousItem" | "expandOrDown" | "collapseOrUp" | "focusFirstItem" | "focusLastItem";
-};

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

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

package/lib/esm/index.d.ts

@@ -1,33 +0,0 @@
-export * from "./types/core";
-export * from "./core/create-tree";
-export * from "./features/tree/types";
-export { MainFeatureDef, InstanceBuilder } from "./features/main/types";
-export * from "./features/drag-and-drop/types";
-export * from "./features/keyboard-drag-and-drop/types";
-export * from "./features/selection/types";
-export * from "./features/checkboxes/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/prop-memoization/types";
-export * from "./features/selection/feature";
-export * from "./features/checkboxes/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/keyboard-drag-and-drop/feature";
-export * from "./features/search/feature";
-export * from "./features/renaming/feature";
-export * from "./features/expand-all/feature";
-export * from "./features/prop-memoization/feature";
-export * from "./utilities/create-on-drop-handler";
-export * from "./utilities/insert-items-at-target";
-export * from "./utilities/remove-items-from-parents";
-export * from "./core/build-proxified-instance";
-export * from "./core/build-static-instance";
-export { makeStateUpdater } from "./utils";
-export { isOrderedDragTarget } from "./features/drag-and-drop/utils";

package/lib/esm/index.js

@@ -1,32 +0,0 @@
-export * from "./types/core";
-export * from "./core/create-tree";
-export * from "./features/tree/types";
-export * from "./features/drag-and-drop/types";
-export * from "./features/keyboard-drag-and-drop/types";
-export * from "./features/selection/types";
-export * from "./features/checkboxes/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/prop-memoization/types";
-export * from "./features/selection/feature";
-export * from "./features/checkboxes/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/keyboard-drag-and-drop/feature";
-export * from "./features/search/feature";
-export * from "./features/renaming/feature";
-export * from "./features/expand-all/feature";
-export * from "./features/prop-memoization/feature";
-export * from "./utilities/create-on-drop-handler";
-export * from "./utilities/insert-items-at-target";
-export * from "./utilities/remove-items-from-parents";
-export * from "./core/build-proxified-instance";
-export * from "./core/build-static-instance";
-export { makeStateUpdater } from "./utils";
-export { isOrderedDragTarget } from "./features/drag-and-drop/utils";

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

@@ -1,121 +0,0 @@
-import { MainFeatureDef } from "./features/main/types";
-import { DragAndDropFeatureDef } from "./features/drag-and-drop/types";
-import { AsyncDataLoaderFeatureDef } from "./features/async-data-loader/types";
-import { ExpandAllFeatureDef } from "./features/expand-all/types";
-import { HotkeysCoreFeatureDef } from "./features/hotkeys-core/types";
-import { RenamingFeatureDef } from "./features/renaming/types";
-import { SearchFeatureDef } from "./features/search/types";
-import { SelectionFeatureDef } from "./features/selection/types";
-import { SyncDataLoaderFeatureDef } from "./features/sync-data-loader/types";
-import { TreeFeatureDef } from "./features/tree/types";
-import { PropMemoizationFeatureDef } from "./features/prop-memoization/types";
-import { KeyboardDragAndDropFeatureDef } from "./features/keyboard-drag-and-drop/types";
-export * from ".";
-/** @interface */
-export type AsyncDataLoaderFeatureConfig<T> = AsyncDataLoaderFeatureDef<T>["config"];
-/** @interface */
-export type AsyncDataLoaderFeatureState<T> = AsyncDataLoaderFeatureDef<T>["state"];
-/** @interface */
-export type AsyncDataLoaderFeatureTreeInstance<T> = AsyncDataLoaderFeatureDef<T>["treeInstance"];
-/** @interface */
-export type AsyncDataLoaderFeatureItemInstance<T> = AsyncDataLoaderFeatureDef<T>["itemInstance"];
-export type AsyncDataLoaderFeatureHotkeys<T> = AsyncDataLoaderFeatureDef<T>["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"];
-/** @interface */
-export type KeyboardDragAndDropFeatureConfig<T> = KeyboardDragAndDropFeatureDef<T>["config"];
-/** @interface */
-export type KeyboardDragAndDropFeatureState<T> = KeyboardDragAndDropFeatureDef<T>["state"];
-/** @interface */
-export type KeyboardDragAndDropFeatureTreeInstance<T> = KeyboardDragAndDropFeatureDef<T>["treeInstance"];
-/** @interface */
-export type KeyboardDragAndDropFeatureItemInstance<T> = KeyboardDragAndDropFeatureDef<T>["itemInstance"];
-export type KeyboardDragAndDropFeatureHotkeys<T> = KeyboardDragAndDropFeatureDef<T>["hotkeys"];
-/** @interface */
-export type ExpandAllFeatureConfig = ExpandAllFeatureDef["config"];
-/** @interface */
-export type ExpandAllFeatureState = ExpandAllFeatureDef["state"];
-/** @interface */
-export type ExpandAllFeatureTreeInstance = ExpandAllFeatureDef["treeInstance"];
-/** @interface */
-export type ExpandAllFeatureItemInstance = ExpandAllFeatureDef["itemInstance"];
-export type ExpandAllFeatureHotkeys = ExpandAllFeatureDef["hotkeys"];
-/** @interface */
-export type HotkeysCoreFeatureConfig<T> = HotkeysCoreFeatureDef<T>["config"];
-/** @interface */
-export type HotkeysCoreFeatureState<T> = HotkeysCoreFeatureDef<T>["state"];
-/** @interface */
-export type HotkeysCoreFeatureTreeInstance<T> = HotkeysCoreFeatureDef<T>["treeInstance"];
-/** @interface */
-export type HotkeysCoreFeatureItemInstance<T> = HotkeysCoreFeatureDef<T>["itemInstance"];
-export type HotkeysCoreFeatureHotkeys<T> = HotkeysCoreFeatureDef<T>["hotkeys"];
-/** @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 PropMemoizationConfig = PropMemoizationFeatureDef["config"];
-/** @interface */
-export type PropMemoizationState = PropMemoizationFeatureDef["state"];
-/** @interface */
-export type PropMemoizationTreeInstance = PropMemoizationFeatureDef["treeInstance"];
-/** @interface */
-export type PropMemoizationItemInstance = PropMemoizationFeatureDef["itemInstance"];
-export type PropMemoizationHotkeys = PropMemoizationFeatureDef["hotkeys"];
-/** @interface */
-export type RenamingFeatureConfig<T> = RenamingFeatureDef<T>["config"];
-/** @interface */
-export type RenamingFeatureState<T> = RenamingFeatureDef<T>["state"];
-/** @interface */
-export type RenamingFeatureTreeInstance<T> = RenamingFeatureDef<T>["treeInstance"];
-/** @interface */
-export type RenamingFeatureItemInstance<T> = RenamingFeatureDef<T>["itemInstance"];
-export type RenamingFeatureHotkeys<T> = RenamingFeatureDef<T>["hotkeys"];
-/** @interface */
-export type SearchFeatureConfig<T> = SearchFeatureDef<T>["config"];
-/** @interface */
-export type SearchFeatureState<T> = SearchFeatureDef<T>["state"];
-/** @interface */
-export type SearchFeatureTreeInstance<T> = SearchFeatureDef<T>["treeInstance"];
-/** @interface */
-export type SearchFeatureItemInstance<T> = SearchFeatureDef<T>["itemInstance"];
-export type SearchFeatureHotkeys<T> = SearchFeatureDef<T>["hotkeys"];
-/** @interface */
-export type SelectionFeatureConfig<T> = SelectionFeatureDef<T>["config"];
-/** @interface */
-export type SelectionFeatureState<T> = SelectionFeatureDef<T>["state"];
-/** @interface */
-export type SelectionFeatureTreeInstance<T> = SelectionFeatureDef<T>["treeInstance"];
-/** @interface */
-export type SelectionFeatureItemInstance<T> = SelectionFeatureDef<T>["itemInstance"];
-export type SelectionFeatureHotkeys<T> = SelectionFeatureDef<T>["hotkeys"];
-/** @interface */
-export type SyncDataLoaderFeatureConfig<T> = SyncDataLoaderFeatureDef<T>["config"];
-/** @interface */
-export type SyncDataLoaderFeatureState<T> = SyncDataLoaderFeatureDef<T>["state"];
-/** @interface */
-export type SyncDataLoaderFeatureTreeInstance<T> = SyncDataLoaderFeatureDef<T>["treeInstance"];
-/** @interface */
-export type SyncDataLoaderFeatureItemInstance<T> = SyncDataLoaderFeatureDef<T>["itemInstance"];
-export type SyncDataLoaderFeatureHotkeys<T> = SyncDataLoaderFeatureDef<T>["hotkeys"];
-/** @interface */
-export type TreeFeatureConfig<T> = TreeFeatureDef<T>["config"];
-/** @interface */
-export type TreeFeatureState<T> = TreeFeatureDef<T>["state"];
-/** @interface */
-export type TreeFeatureTreeInstance<T> = TreeFeatureDef<T>["treeInstance"];
-/** @interface */
-export type TreeFeatureItemInstance<T> = TreeFeatureDef<T>["itemInstance"];
-export type TreeFeatureHotkeys<T> = TreeFeatureDef<T>["hotkeys"];

package/lib/esm/mddocs-entry.js

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

package/lib/esm/test-utils/test-tree-do.d.ts

@@ -1,23 +0,0 @@
-import { DragEvent } from "react";
-import { TestTree } from "./test-tree";
-import { HotkeyName } from "../types/core";
-export declare class TestTreeDo<T> {
-    protected tree: TestTree<T>;
-    protected itemInstance(itemId: string): import("../types/core").ItemInstance<T>;
-    protected itemProps(itemId: string): Record<string, any>;
-    constructor(tree: TestTree<T>);
-    selectItem(id: string): void;
-    shiftSelectItem(id: string): void;
-    ctrlSelectItem(id: string): void;
-    ctrlShiftSelectItem(id: string): void;
-    selectMultiple(...ids: string[]): void;
-    hotkey(hotkey: HotkeyName, e?: Partial<KeyboardEvent>): void;
-    startDrag(itemId: string, event?: DragEvent): DragEvent<Element>;
-    dragOver(itemId: string, event?: DragEvent): DragEvent<Element>;
-    dragOverNotAllowed(itemId: string, event?: DragEvent): DragEvent<Element>;
-    dragLeave(itemId: string): void;
-    dragEnd(itemId: string, event?: DragEvent): DragEvent<Element>;
-    drop(itemId: string, event?: DragEvent): Promise<DragEvent<Element>>;
-    dragOverAndDrop(itemId: string, event?: DragEvent): Promise<DragEvent<Element>>;
-    private consistentCalls;
-}

package/lib/esm/test-utils/test-tree-do.js

@@ -1,108 +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 { expect, vi } from "vitest";
-import { TestTree } from "./test-tree";
-export class TestTreeDo {
-    itemInstance(itemId) {
-        return this.tree.instance.getItemInstance(itemId);
-    }
-    itemProps(itemId) {
-        return this.itemInstance(itemId).getProps();
-    }
-    constructor(tree) {
-        this.tree = tree;
-    }
-    selectItem(id) {
-        this.itemProps(id).onClick({});
-    }
-    shiftSelectItem(id) {
-        this.itemProps(id).onClick({ shiftKey: true });
-    }
-    ctrlSelectItem(id) {
-        this.itemProps(id).onClick({ ctrlKey: true });
-    }
-    ctrlShiftSelectItem(id) {
-        this.itemProps(id).onClick({ shiftKey: true, ctrlKey: true });
-    }
-    selectMultiple(...ids) {
-        ids.forEach((id) => this.ctrlSelectItem(id));
-    }
-    hotkey(hotkey, e = {}) {
-        var _a, _b;
-        const hotkeyConfig = Object.assign(Object.assign({}, this.tree.instance.getHotkeyPresets()[hotkey]), (_a = this.tree.instance.getConfig().hotkeys) === null || _a === void 0 ? void 0 : _a[hotkey]);
-        if (hotkeyConfig.isEnabled &&
-            !((_b = hotkeyConfig.isEnabled) === null || _b === void 0 ? void 0 : _b.call(hotkeyConfig, this.tree.instance))) {
-            throw new Error(`Hotkey "${hotkey}" is disabled`);
-        }
-        if (!hotkeyConfig.handler) {
-            throw new Error(`Hotkey "${hotkey}" has no handler`);
-        }
-        hotkeyConfig.handler(Object.assign(Object.assign({}, e), { stopPropagation: () => { }, preventDefault: () => { } }), this.tree.instance);
-    }
-    startDrag(itemId, event) {
-        if (!this.itemProps(itemId).draggable) {
-            throw new Error(`Can't drag item ${itemId}, has attribute draggable=false`);
-        }
-        const e = event !== null && event !== void 0 ? event : TestTree.dragEvent();
-        this.itemProps(itemId).onDragStart(e);
-        return e;
-    }
-    dragOver(itemId, event) {
-        const e = event !== null && event !== void 0 ? event : TestTree.dragEvent();
-        e.preventDefault.mockClear();
-        this.itemProps(itemId).onDragOver(e);
-        this.itemProps(itemId).onDragOver(e);
-        this.itemProps(itemId).onDragOver(e);
-        expect(e.preventDefault).toBeCalledTimes(3);
-        this.consistentCalls(e.preventDefault);
-        this.consistentCalls(e.stopPropagation);
-        return e;
-    }
-    dragOverNotAllowed(itemId, event) {
-        const e = event !== null && event !== void 0 ? event : TestTree.dragEvent();
-        e.preventDefault.mockClear();
-        this.itemProps(itemId).onDragOver(e);
-        this.itemProps(itemId).onDragOver(e);
-        this.itemProps(itemId).onDragOver(e);
-        expect(e.preventDefault).toBeCalledTimes(0);
-        this.consistentCalls(e.preventDefault);
-        this.consistentCalls(e.stopPropagation);
-        return e;
-    }
-    dragLeave(itemId) {
-        this.itemProps(itemId).onDragLeave({});
-    }
-    dragEnd(itemId, event) {
-        const e = event !== null && event !== void 0 ? event : TestTree.dragEvent();
-        this.itemProps(itemId).onDragEnd(e);
-        return e;
-    }
-    drop(itemId, event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const e = event !== null && event !== void 0 ? event : TestTree.dragEvent();
-            yield this.itemProps(itemId).onDrop(e);
-            return e;
-        });
-    }
-    dragOverAndDrop(itemId, event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const e = event !== null && event !== void 0 ? event : TestTree.dragEvent();
-            this.dragOver(itemId, e);
-            return this.drop(itemId, e);
-        });
-    }
-    consistentCalls(fn) {
-        if (!vi.isMockFunction(fn)) {
-            throw new Error("fn is not a mock");
-        }
-        expect(fn.mock.calls.length, "function called inconsistent times").toBeOneOf([0, 3]);
-        expect(new Set(fn.mock.calls.map((call) => call.join("__"))).size, "function called with inconsistent parameters").toBeOneOf([0, 1]);
-    }
-}

package/lib/esm/test-utils/test-tree-expect.d.ts

@@ -1,17 +0,0 @@
-import { DragEvent } from "react";
-import { TestTree } from "./test-tree";
-import { DragTarget } from "../features/drag-and-drop/types";
-import { TreeState } from "../types/core";
-export declare class TestTreeExpect<T> {
-    private tree;
-    protected itemInstance(itemId: string): import("../types/core").ItemInstance<T>;
-    protected itemProps(itemId: string): Record<string, any>;
-    constructor(tree: TestTree<T>);
-    foldersExpanded(...itemIds: string[]): void;
-    foldersCollapsed(...itemIds: string[]): void;
-    hasChildren(itemId: string, children: string[]): void;
-    substate<K extends keyof TreeState<T>>(key: K, value: TreeState<T>[K]): void;
-    dropped(draggedItems: string[], target: DragTarget<any>): void;
-    dragOverNotAllowed(itemId: string, event?: DragEvent): DragEvent<Element>;
-    defaultDragLineProps(indent?: number): void;
-}

package/lib/esm/test-utils/test-tree-expect.js

@@ -1,62 +0,0 @@
-/* eslint-disable import/no-extraneous-dependencies */
-import { expect } from "vitest";
-import { TestTree } from "./test-tree";
-export class TestTreeExpect {
-    itemInstance(itemId) {
-        return this.tree.instance.getItemInstance(itemId);
-    }
-    itemProps(itemId) {
-        return this.itemInstance(itemId).getProps();
-    }
-    constructor(tree) {
-        this.tree = tree;
-    }
-    foldersExpanded(...itemIds) {
-        for (const itemId of itemIds) {
-            expect(this.tree.instance.getItemInstance(itemId).isExpanded(), `Expected ${itemId} to be expanded`).toBe(true);
-        }
-    }
-    foldersCollapsed(...itemIds) {
-        for (const itemId of itemIds) {
-            expect(this.tree.instance.getItemInstance(itemId).isExpanded(), `Expected ${itemId} to be collapsed`).toBe(false);
-        }
-    }
-    hasChildren(itemId, children) {
-        const item = this.tree.instance.getItemInstance(itemId);
-        const itemChildren = item.getChildren().map((child) => child.getId());
-        expect(itemChildren).toEqual(children);
-    }
-    substate(key, value) {
-        expect(this.tree.instance.getState()[key]).toEqual(value);
-    }
-    dropped(draggedItems, target) {
-        expect(this.tree.instance.getConfig().onDrop).toBeCalledWith(draggedItems.map((id) => this.tree.item(id)), target);
-    }
-    dragOverNotAllowed(itemId, event) {
-        const e = event !== null && event !== void 0 ? event : TestTree.dragEvent();
-        e.preventDefault.mockClear();
-        this.itemProps(itemId).onDragOver(e);
-        this.itemProps(itemId).onDragOver(e);
-        this.itemProps(itemId).onDragOver(e);
-        expect(e.preventDefault, "onDragOver shouldn't call e.preventDefault if drag is not allowed").not.toBeCalled();
-        this.itemProps(itemId).onDrop(e);
-        expect(e.preventDefault, "onDrop shouldn't call e.preventDefault if drag is not allowed").not.toBeCalled();
-        expect(this.tree.instance.getConfig().onDrop, "onDrop handler shouldn't be called if drag is not allowed").not.toBeCalled();
-        return e;
-    }
-    defaultDragLineProps(indent = 0) {
-        expect(this.tree.instance.getDragLineData()).toEqual({
-            indent,
-            left: indent * 20,
-            width: 100 - indent * 20,
-            top: 0,
-        });
-        expect(this.tree.instance.getDragLineStyle(0, 0)).toEqual({
-            position: "absolute",
-            left: `${indent * 20}px`,
-            pointerEvents: "none",
-            top: "0px",
-            width: `${100 - indent * 20}px`,
-        });
-    }
-}

package/lib/esm/test-utils/test-tree.d.ts

@@ -1,48 +0,0 @@
-import { DragEvent } from "react";
-import { TreeConfig, TreeInstance } from "../types/core";
-import { TestTreeDo } from "./test-tree-do";
-import { TestTreeExpect } from "./test-tree-expect";
-export declare class TestTree<T = string> {
-    private config;
-    readonly do: TestTreeDo<T>;
-    readonly expect: TestTreeExpect<T>;
-    private treeInstance;
-    private static asyncLoaderResolvers;
-    private asyncDataLoaderImp;
-    suits: {
-        sync: () => {
-            tree: TestTree<T>;
-            title: string;
-        };
-        async: () => {
-            tree: TestTree<T>;
-            title: string;
-        };
-        proxifiedSync: () => {
-            tree: TestTree<T>;
-            title: string;
-        };
-        proxifiedAsync: () => {
-            tree: TestTree<T>;
-            title: string;
-        };
-    };
-    forSuits(runSuite: (tree: TestTree<T>) => void): void;
-    get instance(): TreeInstance<T>;
-    private constructor();
-    static resolveAsyncLoaders(): Promise<void>;
-    resolveAsyncVisibleItems(): Promise<void>;
-    static default(config: Partial<TreeConfig<string>>): TestTree<string>;
-    with(config: Partial<TreeConfig<T>>): TestTree<T>;
-    resetBeforeEach(): void;
-    createTestCaseTree(): Promise<this>;
-    withFeatures(...features: any): TestTree<T>;
-    mockedHandler(handlerName: keyof TreeConfig<T>): import("vitest").Mock<(...args: any[]) => any>;
-    item(itemId: string): import("../types/core").ItemInstance<T>;
-    reset(): void;
-    debug(): void;
-    setElementBoundingBox(itemId: string, bb?: Partial<DOMRect>): void;
-    static dragEvent(clientX?: number, clientY?: number): DragEvent;
-    createTopDragEvent(indent?: number): DragEvent<Element>;
-    createBottomDragEvent(indent?: number): DragEvent<Element>;
-}