pxd 0.0.64 → 0.1.3

package/dist/composables/_internal/use-tree.d.ts

@@ -0,0 +1,103 @@
+import type { TreeDropPosition, TreeDropTarget, TreeFilterFn, TreeFlatNode, TreeMoveDetail, TreeModelValue, TreeOptions, TreeRemoteFilterFn, TreeSelectableFn } from '../../components/tree/types';
+import type { ComponentValue } from '../../types/shared/props';
+import type { MaybeElementRef } from '../../types/shared/utils';
+import type { ComputedRef, MaybeRefOrGetter, ShallowRef } from 'vue';
+export interface TreeNodeMeta {
+    node: TreeOptions[number];
+    children: TreeNodeMeta[];
+    parentValue?: ComponentValue;
+    depth: number;
+    /** Exclusive index in `list` right after this subtree. */
+    end: number;
+}
+export interface TreeIndex {
+    list: TreeNodeMeta[];
+    byValue: Map<ComponentValue, TreeNodeMeta>;
+}
+export declare function createTreeIndex(data: TreeOptions, childrenField: string): TreeIndex;
+export declare function useTreeIndex(data: MaybeRefOrGetter<TreeOptions>, childrenField: MaybeRefOrGetter<string>): ComputedRef<TreeIndex>;
+/** Children in `data` win over a cached request, and an untouched node keeps its identity. */
+export declare function graftLoadedChildren(data: TreeOptions, loaded: Map<ComponentValue, TreeOptions>, childrenField: string): TreeOptions;
+export interface TreeMatched {
+    /** Every hit plus its ancestors: ancestor-closed, so the row walk can prune whole subtrees. */
+    visible: ReadonlySet<ComponentValue>;
+    /** The hits alone. */
+    exact: ReadonlySet<ComponentValue>;
+}
+export declare function useTreeMatched(index: MaybeRefOrGetter<TreeIndex>, query: MaybeRefOrGetter<string>, filter: MaybeRefOrGetter<TreeFilterFn | undefined>): ComputedRef<TreeMatched>;
+export interface UseTreeSearchOptions {
+    query: MaybeRefOrGetter<string>;
+    remoteFilter?: MaybeRefOrGetter<TreeRemoteFilterFn | undefined>;
+}
+export interface UseTreeSearchReturn {
+    /** The forest the query last settled on, absent before the first answer. */
+    matches: ShallowRef<TreeOptions | undefined>;
+    remote: ComputedRef<boolean>;
+    /** Whether a request is in flight, the debounce window included. */
+    pending: ShallowRef<boolean>;
+    active: ComputedRef<boolean>;
+}
+export declare function useTreeSearch(options: UseTreeSearchOptions): UseTreeSearchReturn;
+export interface UseTreeRowsOptions {
+    query: MaybeRefOrGetter<string>;
+    expanded: MaybeRefOrGetter<ReadonlySet<ComponentValue>>;
+    matched: MaybeRefOrGetter<ReadonlySet<ComponentValue>>;
+    /** The hits without their ancestors; only read when `matchesOnly` is on. */
+    exactMatched?: MaybeRefOrGetter<ReadonlySet<ComponentValue> | undefined>;
+    matchesOnly?: MaybeRefOrGetter<boolean | undefined>;
+    canLoad?: MaybeRefOrGetter<((value: ComponentValue) => boolean) | undefined>;
+}
+/**
+ * Selection state is deliberately absent: it changes on every click, and putting it here would
+ * rebuild all N rows for a change that touches two of them. Read the sets at render time instead.
+ */
+export declare function useTreeRows(index: MaybeRefOrGetter<TreeIndex>, options: UseTreeRowsOptions): ComputedRef<TreeFlatNode[]>;
+export interface UseTreeSelectionOptions {
+    index: MaybeRefOrGetter<TreeIndex>;
+    modelValue: MaybeRefOrGetter<TreeModelValue | undefined>;
+    multiple: MaybeRefOrGetter<boolean>;
+    checkStrictly?: MaybeRefOrGetter<boolean | undefined>;
+    selectable?: MaybeRefOrGetter<TreeSelectableFn | undefined>;
+}
+export interface TreeToggleResult {
+    value: TreeModelValue;
+    halfCheckedValues: ComponentValue[];
+}
+export interface UseTreeSelectionReturn {
+    checked: ComputedRef<Set<ComponentValue>>;
+    indeterminate: ComputedRef<Set<ComponentValue>>;
+    toggle: (value: ComponentValue) => TreeToggleResult;
+    /** The span between the anchor and `value`, both ends included; toggles without an anchor. */
+    extend: (value: ComponentValue) => TreeToggleResult;
+    isSelectable: (value: ComponentValue) => boolean;
+}
+export declare function useTreeSelection(options: UseTreeSelectionOptions): UseTreeSelectionReturn;
+/** Walks up instead of scanning `index.list`: the hit test runs this on every pointer move. */
+export declare function isTreeDescendant(index: TreeIndex, ancestorValue: ComponentValue, value: ComponentValue): boolean;
+export interface TreeMoveResult {
+    data: TreeOptions;
+    detail: TreeMoveDetail;
+}
+/**
+ * The node is detached before the target is looked up, which rejects the whole family of invalid
+ * drops for free: it and its descendant are no longer in the tree to be found.
+ */
+export declare function moveTreeNode(data: TreeOptions, childrenField: string, value: ComponentValue, target: TreeDropTarget): TreeMoveResult | undefined;
+export interface UseTreeDragOptions {
+    container: MaybeElementRef<HTMLElement>;
+    rows: MaybeRefOrGetter<TreeFlatNode[]>;
+    enabled: MaybeRefOrGetter<boolean>;
+    dropInsideLeaf: MaybeRefOrGetter<boolean>;
+    /** Rejects a position the tree will refuse, so no indicator is ever painted for it. */
+    canDrop: (value: ComponentValue, targetValue: ComponentValue, position: TreeDropPosition) => boolean;
+    onExpand: (value: ComponentValue) => void;
+    onCommit: (value: ComponentValue, target: TreeDropTarget) => void;
+}
+export declare function useTreeDrag(options: UseTreeDragOptions): {
+    value: ShallowRef<ComponentValue | undefined, ComponentValue | undefined>;
+    target: ShallowRef<TreeDropTarget | undefined, TreeDropTarget | undefined>;
+    x: ShallowRef<number, number>;
+    y: ShallowRef<number, number>;
+    onPointerDown: (nodeValue: ComponentValue, event: PointerEvent) => void;
+    didDrag: () => boolean;
+};