pxd 0.0.64 → 0.1.2

package/dist/composables/_internal/use-overlay-dialog.d.ts

@@ -0,0 +1,25 @@
+import type { Ref } from 'vue';
+interface OverlayDialogProps {
+    autoFocusElement?: string | boolean;
+    closeOnPressEscape?: boolean;
+    closeOnClickOverlay?: boolean;
+    loading?: boolean;
+}
+interface OverlayDialogEmits {
+    (event: 'outside-click', ev: PointerEvent): void;
+}
+interface OverlayDialogOptions {
+    props: OverlayDialogProps;
+    emits: OverlayDialogEmits;
+    elementRef: Ref<HTMLElement | undefined>;
+    onClose: () => void;
+}
+/**
+ * Shared dialog (Modal/Drawer) behaviors: focus trap wiring and overlay
+ * click/escape close handlers.
+ */
+export declare function useOverlayDialog({ props, emits, elementRef, onClose }: OverlayDialogOptions): {
+    closeOverlayIfNeed: () => void;
+    onOverlayClick: (ev: PointerEvent) => void;
+};
+export {};

package/dist/composables/_internal/use-overlay-dialog.js

@@ -0,0 +1,25 @@
+import { computed } from "vue";
+import { isTruthyProp } from "../../utils/format.js";
+import { useFocusTrap } from "./use-focus-trap.js";
+export function useOverlayDialog({ props, emits, elementRef, onClose }) {
+  const focusTrapOptions = computed(() => ({
+    autoFocusElement: props.autoFocusElement,
+    escapeDeactivates: props.closeOnPressEscape,
+    clickOutsideDeactivates: props.closeOnClickOverlay
+  }));
+  useFocusTrap(elementRef, focusTrapOptions);
+  function closeOverlayIfNeed() {
+    if (isTruthyProp(props.loading)) {
+      return;
+    }
+    onClose();
+  }
+  function onOverlayClick(ev) {
+    emits("outside-click", ev);
+    if (!isTruthyProp(props.closeOnClickOverlay)) {
+      return;
+    }
+    closeOverlayIfNeed();
+  }
+  return { closeOverlayIfNeed, onOverlayClick };
+}

package/dist/composables/{use-overlay-manager.js → _internal/use-overlay-manager.js}

@@ -1,6 +1,6 @@
 import { onScopeDispose } from "vue";
-import { cachedOff, cachedOn } from "../utils/event.js";
-import { toValue } from "../utils/ref.js";
+import { cachedOff, cachedOn } from "../../utils/event.js";
+import { toValue } from "../../utils/helper.js";
 let isKeydownListening = false;
 const overlayStack = [];
 function getTopOverlay() {

package/dist/composables/{use-popover-responsive.js → _internal/use-popover-responsive.js}

@@ -1,5 +1,5 @@
 import { computed } from "vue";
-import { PRESET_MEDIA_QUERIES, useMediaQuery } from "./use-media-query.js";
+import { PRESET_MEDIA_QUERIES, useMediaQuery } from "../use-media-query.js";
 export function usePopoverResponsive() {
   const isAdaptive = useMediaQuery(PRESET_MEDIA_QUERIES.IS_XS);
   const responsiveClasses = computed(() => {

package/dist/composables/_internal/use-selected-list-item.d.ts

@@ -0,0 +1,6 @@
+import type { ListOption, ListOptionEntry, ListOptionGroup, ListOptions, ListOptionSelected } from '../../components/list/types';
+import type { MaybeRefOrGetter } from 'vue';
+export declare function isListOptionGroup(option: ListOptionEntry): option is ListOptionGroup;
+export declare function resolveOptionByValue(options: ListOptionEntry[], value: ListOptionSelected['value']): ListOption | null;
+export declare function useSelectedListItems(options: MaybeRefOrGetter<ListOptions>, modelValue: MaybeRefOrGetter<unknown>): import("vue").ComputedRef<ListOption[]>;
+export declare function useSelectedListItem(options: MaybeRefOrGetter<ListOptions>, modelValue: MaybeRefOrGetter<unknown>): import("vue").ComputedRef<ListOption>;

package/dist/composables/_internal/use-selected-list-item.js

@@ -0,0 +1,36 @@
+import { computed } from "vue";
+import { toArray } from "../../utils/format.js";
+import { toValue } from "../../utils/helper.js";
+export function isListOptionGroup(option) {
+  return option.type === "group";
+}
+export function resolveOptionByValue(options, value) {
+  for (const entry of options) {
+    if (isListOptionGroup(entry)) {
+      const matchedOption = resolveOptionByValue(entry.options, value);
+      if (matchedOption) {
+        return matchedOption;
+      }
+    } else if (entry.value === value) {
+      return entry;
+    }
+  }
+  return null;
+}
+function resolveSelectedListItems(options, modelValue) {
+  const selectedOptions = [];
+  for (const value of toArray(modelValue)) {
+    const matchedOption = resolveOptionByValue(options, value);
+    if (matchedOption) {
+      selectedOptions.push(matchedOption);
+    }
+  }
+  return selectedOptions;
+}
+export function useSelectedListItems(options, modelValue) {
+  return computed(() => resolveSelectedListItems(toValue(options) ?? [], toValue(modelValue)));
+}
+export function useSelectedListItem(options, modelValue) {
+  const selectedItems = useSelectedListItems(options, modelValue);
+  return computed(() => selectedItems.value[0] ?? null);
+}

package/dist/composables/_internal/use-swipe-gesture.d.ts

@@ -0,0 +1,88 @@
+import type { MaybeElementRef } from '../../types/shared';
+import type { MaybeRefOrGetter } from 'vue';
+export type SwipeDirection = 'left' | 'right' | 'top' | 'bottom';
+export interface SwipePressState {
+    size: number;
+    /** The pointerdown event that opened the gesture. */
+    event: PointerEvent;
+}
+export interface SwipeFollowState {
+    /** Movement since the previous event along the active axis (px). */
+    delta: number;
+    /** Signed velocity (px / ms) since the previous event along the active axis. */
+    velocity: number;
+    /** `displacement / containerSize` signed ratio, typically in the range of -1 to 1. */
+    offset: number;
+    /** Signed displacement from the start point along the active axis (px). */
+    displacement: number;
+    /** The pointermove event that produced this sample. */
+    event: PointerEvent;
+}
+export interface SwipeReleaseState {
+    /** Whether the gesture qualified as a successful swipe (by velocity or distance). */
+    swiped: boolean;
+    /** Physical swipe direction. `undefined` when `swiped` is `false`. */
+    direction?: SwipeDirection;
+    /** Signed displacement at release along the active axis (px). */
+    displacement: number;
+    /** Signed velocity at release (px / ms). */
+    velocity: number;
+    /** Whether the gesture stayed on the target axis from the moment it was locked. */
+    axisLocked: boolean;
+    /** The pointerup or pointercancel event that ended the gesture. */
+    event: PointerEvent;
+}
+export interface SwipeTapState {
+    /** The pointerup event that ended the interaction. */
+    event: PointerEvent;
+    /**
+     * The pointerdown event that started it. A release that never became a pan can
+     * land on a different element, so hit-testing should use what the user pressed.
+     */
+    startEvent: PointerEvent | null;
+    /**
+     * `true` when `beforeStart` discarded the gesture, `false` when the pointer
+     * simply never travelled far enough to be recognized.
+     */
+    vetoed: boolean;
+}
+export interface SwipeGestureOptions {
+    disabled?: MaybeRefOrGetter<boolean>;
+    /** CSS selector for the drag handle element within the container. */
+    handleSelector?: string;
+    /** Swipe axis. Reactive; accepts a ref or getter. */
+    axis?: MaybeRefOrGetter<'horizontal' | 'vertical'>;
+    /** Minimum movement (px) before locking the gesture axis. */
+    axisLockThreshold?: number;
+    /** Main-axis movement must be at least this multiple of cross-axis movement. */
+    axisLockRatio?: number;
+    /** Minimum swipe distance (px) before movement events start. */
+    swipeThreshold?: number;
+    /** Fraction of the container size the finger must travel for a slow-drag swipe. */
+    distanceThreshold?: number;
+    /** Minimum absolute velocity (px / ms) for a quick-flick swipe. */
+    velocityThreshold?: number;
+    /**
+     * Gate evaluated once the gesture is recognized. Resolving `false` discards the
+     * gesture: `onFollow` never fires and the release is reported through `onTap`
+     * with `vetoed: true`. Movement arriving while a promise is pending is dropped,
+     * and a release inside that window waits for the verdict.
+     */
+    beforeStart?: (state: SwipePressState) => boolean | Promise<boolean>;
+    onPress?: (state: SwipePressState) => void;
+    onFollow?: (state: SwipeFollowState) => void;
+    /**
+     * Receives the raw release metrics. `swiped` and `direction` follow
+     * `distanceThreshold` / `velocityThreshold` against the container size; consumers
+     * that measure against something else decide from `displacement` themselves.
+     */
+    onRelease?: (state: SwipeReleaseState) => void;
+    /**
+     * Called on release when no swipe was ever recognized: the pointer travelled less
+     * than `swipeThreshold`, or `beforeStart` discarded it.
+     */
+    onTap?: (state: SwipeTapState) => void;
+}
+export declare function useSwipeGesture(containerRef: MaybeElementRef<HTMLElement>, options?: SwipeGestureOptions): {
+    stop: () => void;
+};

package/dist/composables/_internal/use-swipe-gesture.js

@@ -0,0 +1,345 @@
+import { nextTick, onScopeDispose, watch } from "vue";
+import { getElement } from "../../utils/dom.js";
+import { toValue } from "../../utils/helper.js";
+function isThenable(value) {
+  return typeof value === "object" && value !== null && typeof value.then === "function";
+}
+export function useSwipeGesture(containerRef, options = {}) {
+  const {
+    handleSelector,
+    axisLockThreshold = 0,
+    axisLockRatio = 1,
+    distanceThreshold = 0.35,
+    velocityThreshold = 0.3,
+    swipeThreshold = 10,
+    beforeStart,
+    onPress,
+    onFollow,
+    onRelease,
+    onTap
+  } = options;
+  let recognizer = null;
+  let stopped = false;
+  function isHorizontal() {
+    return (toValue(options.axis) ?? "horizontal") === "horizontal";
+  }
+  function getAxisValue(event, horizontal) {
+    return horizontal ? {
+      displacement: event.displacementX,
+      crossDisplacement: event.displacementY,
+      delta: event.deltaX,
+      velocity: event.velocityX
+    } : {
+      displacement: event.displacementY,
+      crossDisplacement: event.displacementX,
+      delta: event.deltaY,
+      velocity: event.velocityY
+    };
+  }
+  function resolveDirection(displacement, horizontal) {
+    return horizontal ? displacement > 0 ? "right" : "left" : displacement > 0 ? "bottom" : "top";
+  }
+  function resolveAxisLock(event, horizontal) {
+    const { displacement, crossDisplacement } = getAxisValue(event, horizontal);
+    const mainDistance = Math.abs(displacement);
+    const crossDistance = Math.abs(crossDisplacement);
+    if (Math.hypot(mainDistance, crossDistance) < axisLockThreshold) {
+      return "pending";
+    }
+    return mainDistance >= crossDistance * axisLockRatio ? "accepted" : "rejected";
+  }
+  function getTouchAction() {
+    return isHorizontal() ? "pan-y" : "pan-x";
+  }
+  function bind() {
+    const container = getElement(containerRef);
+    if (!container) {
+      return;
+    }
+    unbind();
+    const handle = handleSelector ? container.querySelector(handleSelector) : container;
+    if (!handle) {
+      return;
+    }
+    let containerSize = 0;
+    let axisLockState = "pending";
+    let startVerdict = "pending";
+    let startGate = null;
+    let released = false;
+    function resetGesture() {
+      axisLockState = "pending";
+      startVerdict = "pending";
+      startGate = null;
+    }
+    function emitTap(event, startEvent) {
+      const verdict = startVerdict;
+      const gate = startGate;
+      if (!onTap) {
+        return;
+      }
+      if (verdict === "pending" && gate) {
+        void gate.then((allowed) => onTap?.({ event, startEvent, vetoed: !allowed }));
+        return;
+      }
+      onTap({ event, startEvent, vetoed: verdict === "vetoed" });
+    }
+    function resolveStart(event) {
+      const state = { size: containerSize, event };
+      if (!beforeStart) {
+        startVerdict = "allowed";
+        onPress?.(state);
+        return;
+      }
+      const verdict = beforeStart(state);
+      if (isThenable(verdict)) {
+        startGate = verdict;
+        void verdict.then((allowed) => {
+          if (released) {
+            return;
+          }
+          startVerdict = allowed ? "allowed" : "vetoed";
+          if (startVerdict === "allowed") {
+            onPress?.(state);
+          }
+        });
+        return;
+      }
+      startVerdict = verdict ? "allowed" : "vetoed";
+      if (startVerdict === "allowed") {
+        onPress?.(state);
+      }
+    }
+    recognizer = new PointerSwipeRecognizer(handle, {
+      threshold: swipeThreshold,
+      touchAction: getTouchAction(),
+      onStart: (event) => {
+        axisLockState = "pending";
+        released = false;
+        containerSize = isHorizontal() ? container.offsetWidth : container.offsetHeight;
+        resolveStart(event.event);
+      },
+      onMove: (event) => {
+        if (startVerdict !== "allowed") {
+          return;
+        }
+        const h = isHorizontal();
+        if (axisLockState === "pending") {
+          axisLockState = resolveAxisLock(event, h);
+        }
+        if (axisLockState !== "accepted") {
+          return;
+        }
+        const { displacement, delta, velocity } = getAxisValue(event, h);
+        onFollow?.({
+          delta,
+          velocity,
+          displacement,
+          offset: containerSize > 0 ? displacement / containerSize : 0,
+          event: event.event
+        });
+      },
+      onEnd: (event) => {
+        released = true;
+        if (startVerdict !== "allowed") {
+          emitTap(event.event, event.startEvent);
+          resetGesture();
+          return;
+        }
+        const h = isHorizontal();
+        if (axisLockState === "pending") {
+          axisLockState = resolveAxisLock(event, h);
+        }
+        const { displacement, velocity } = getAxisValue(event, h);
+        const axisLocked = axisLockState === "accepted";
+        const swiped = axisLocked && containerSize > 0 && displacement !== 0 && (Math.abs(velocity) >= velocityThreshold || Math.abs(displacement) / containerSize >= distanceThreshold);
+        onRelease?.({
+          swiped,
+          direction: swiped ? resolveDirection(displacement, h) : void 0,
+          displacement,
+          velocity,
+          axisLocked,
+          event: event.event
+        });
+        resetGesture();
+      },
+      onIdle: (event, startEvent) => {
+        released = true;
+        emitTap(event, startEvent);
+        resetGesture();
+      },
+      onCancel: (event) => {
+        released = true;
+        onRelease?.({
+          swiped: false,
+          displacement: 0,
+          velocity: 0,
+          axisLocked: false,
+          event
+        });
+        resetGesture();
+      }
+    });
+  }
+  function unbind() {
+    recognizer?.destroy();
+    recognizer = null;
+  }
+  function stop() {
+    stopped = true;
+    unwatch();
+    unbind();
+  }
+  const unwatch = watch(
+    () => [getElement(containerRef), toValue(options.disabled), toValue(options.axis)],
+    async ([el, disabled]) => {
+      if (!el || disabled) {
+        unbind();
+        return;
+      }
+      await nextTick();
+      if (stopped || getElement(containerRef) !== el || toValue(options.disabled)) {
+        return;
+      }
+      bind();
+    },
+    { immediate: true, flush: "post" }
+  );
+  onScopeDispose(() => {
+    stop();
+  });
+  return {
+    stop
+  };
+}
+function getPointerPoint(event) {
+  return { x: event.clientX, y: event.clientY };
+}
+class PointerSwipeRecognizer {
+  constructor(el, options = {}) {
+    this.el = el;
+    this.options = options;
+    ;
+    el.style.webkitTapHighlightColor = "rgba(0,0,0,0)";
+    this.originalTouchAction = el.style.touchAction;
+    el.style.touchAction = options.touchAction ?? "none";
+    this.cleanup = this.bindEvents(el);
+  }
+  cleanup = null;
+  startPoint = null;
+  previousPoint = null;
+  previousTime = 0;
+  lastVelocity = { x: 0, y: 0 };
+  activePointerId = null;
+  hasRecognizedPan = false;
+  startEvent = null;
+  originalTouchAction = "";
+  destroy() {
+    this.cleanup?.();
+    this.cleanup = null;
+    this.el.style.touchAction = this.originalTouchAction;
+  }
+  bindEvents(el) {
+    const onPointerDown = (event) => {
+      if (!event.isPrimary || event.button !== 0) {
+        return;
+      }
+      this.activePointerId = event.pointerId;
+      this.startEvent = event;
+      this.startPoint = getPointerPoint(event);
+      this.previousPoint = this.startPoint;
+      this.previousTime = Date.now();
+      this.lastVelocity = { x: 0, y: 0 };
+      this.hasRecognizedPan = (this.options.threshold ?? 10) <= 0;
+      el.setPointerCapture?.(event.pointerId);
+      if (this.hasRecognizedPan) {
+        this.emitPan(this.options.onStart, event, this.startPoint, 0, 0);
+      }
+    };
+    const onPointerMove = (event) => {
+      if (event.pointerId !== this.activePointerId || !this.startPoint || !this.previousPoint) {
+        return;
+      }
+      const point = getPointerPoint(event);
+      const displacementX = point.x - this.startPoint.x;
+      const displacementY = point.y - this.startPoint.y;
+      const distance = Math.hypot(displacementX, displacementY);
+      if (!this.hasRecognizedPan) {
+        if (distance < (this.options.threshold ?? 10)) {
+          return;
+        }
+        this.hasRecognizedPan = true;
+        this.emitPan(this.options.onStart, event, point, displacementX, displacementY);
+      }
+      this.emitPan(this.options.onMove, event, point, displacementX, displacementY);
+    };
+    const onPointerUp = (event) => {
+      if (event.pointerId !== this.activePointerId || !this.startPoint) {
+        return;
+      }
+      const point = getPointerPoint(event);
+      if (this.hasRecognizedPan) {
+        this.emitPan(
+          this.options.onEnd,
+          event,
+          point,
+          point.x - this.startPoint.x,
+          point.y - this.startPoint.y
+        );
+      } else {
+        this.options.onIdle?.(event, this.startEvent);
+      }
+      el.releasePointerCapture?.(event.pointerId);
+      this.reset();
+    };
+    const onPointerCancel = (event) => {
+      if (event.pointerId !== this.activePointerId) {
+        return;
+      }
+      this.options.onCancel?.(event);
+      el.releasePointerCapture?.(event.pointerId);
+      this.reset();
+    };
+    el.addEventListener("pointerdown", onPointerDown);
+    window.addEventListener("pointermove", onPointerMove);
+    window.addEventListener("pointerup", onPointerUp);
+    window.addEventListener("pointercancel", onPointerCancel);
+    return () => {
+      el.removeEventListener("pointerdown", onPointerDown);
+      window.removeEventListener("pointermove", onPointerMove);
+      window.removeEventListener("pointerup", onPointerUp);
+      window.removeEventListener("pointercancel", onPointerCancel);
+    };
+  }
+  emitPan(callback, source, point, displacementX, displacementY) {
+    const now = Date.now();
+    const elapsed = Math.max(1, now - this.previousTime);
+    const deltaX = point.x - (this.previousPoint?.x ?? point.x);
+    const deltaY = point.y - (this.previousPoint?.y ?? point.y);
+    const velocityX = deltaX === 0 ? this.lastVelocity.x : deltaX / elapsed;
+    const velocityY = deltaY === 0 ? this.lastVelocity.y : deltaY / elapsed;
+    if (deltaX !== 0 || deltaY !== 0) {
+      this.lastVelocity = { x: velocityX, y: velocityY };
+    }
+    this.previousPoint = point;
+    this.previousTime = now;
+    callback?.({
+      displacementX,
+      displacementY,
+      deltaX,
+      deltaY,
+      velocityX,
+      velocityY,
+      event: source,
+      startEvent: this.startEvent
+    });
+  }
+  reset() {
+    this.startPoint = null;
+    this.previousPoint = null;
+    this.previousTime = 0;
+    this.lastVelocity = { x: 0, y: 0 };
+    this.activePointerId = null;
+    this.hasRecognizedPan = false;
+    this.startEvent = null;
+  }
+}

package/dist/composables/_internal/use-tailwind-variant.d.ts

@@ -0,0 +1,31 @@
+import type { ClassValue } from 'cn';
+type TailwindVariantSchema = Record<string, Record<string, ClassValue>>;
+type TailwindVariantFallback = string | number | boolean;
+type TailwindVariantPrimitive<T> = T extends 'true' ? true : T extends 'false' ? false : T extends `${infer Value extends number}` ? Value : T;
+type TailwindVariantValue<T extends Record<string, ClassValue>> = ([keyof T] extends [never] ? TailwindVariantFallback : Extract<keyof T, 'true' | 'false'> extends never ? TailwindVariantPrimitive<keyof T> | keyof T : boolean | keyof T) | null | undefined;
+type TailwindCompoundVariant<T extends TailwindVariantSchema> = Partial<{
+    [K in keyof T]: TailwindVariantValue<T[K]> | ReadonlyArray<TailwindVariantValue<T[K]>>;
+}> & {
+    class: ClassValue;
+};
+export type TailwindVariantSelection<T extends TailwindVariantSchema> = Partial<{
+    [K in keyof T]: TailwindVariantValue<T[K]>;
+}>;
+export interface TailwindVariantConfig<T extends TailwindVariantSchema> {
+    base?: ClassValue;
+    variants?: T;
+    compoundVariants?: ReadonlyArray<TailwindCompoundVariant<T>>;
+}
+export interface UseTailwindVariantOptions<T extends TailwindVariantSchema> {
+    selection?: () => TailwindVariantSelection<T>;
+    mergeAttrsClass?: boolean;
+}
+export declare function createTailwindVariant<T extends TailwindVariantSchema>(config: TailwindVariantConfig<T>): (selection?: TailwindVariantSelection<T>) => string;
+export declare function useTailwindVariant<T extends TailwindVariantSchema>(config: TailwindVariantConfig<T>, options?: UseTailwindVariantOptions<T>): {
+    attrs: import("vue").ComputedRef<{
+        [x: string]: unknown;
+        style?: import("vue").StyleValue;
+    }>;
+    classes: import("vue").ComputedRef<string>;
+};
+export {};

package/dist/composables/_internal/use-tailwind-variant.js

@@ -0,0 +1,62 @@
+import { cn } from "cn";
+import { computed, useAttrs } from "vue";
+function createTailwindVariantResolver(config) {
+  const compoundVariants = config.compoundVariants?.map(({ class: classes, ...conditions }) => ({
+    classes,
+    conditions: Object.entries(conditions).map(([key, expected]) => [
+      key,
+      (Array.isArray(expected) ? expected : [expected]).map(String)
+    ])
+  }));
+  return (selection = {}, additionalClasses) => {
+    const classes = [config.base];
+    for (const key in selection) {
+      if (!Object.hasOwn(selection, key)) {
+        continue;
+      }
+      const value = selection[key];
+      if (value == null) {
+        continue;
+      }
+      const valueClasses = config.variants?.[key]?.[String(value)];
+      if (valueClasses != null) {
+        classes.push(valueClasses);
+      }
+    }
+    if (compoundVariants) {
+      compoundVariantLoop: for (const compoundVariant of compoundVariants) {
+        for (const [key, expected] of compoundVariant.conditions) {
+          if (!expected.includes(String(selection[key]))) {
+            continue compoundVariantLoop;
+          }
+        }
+        classes.push(compoundVariant.classes);
+      }
+    }
+    classes.push(additionalClasses);
+    return cn(classes);
+  };
+}
+export function createTailwindVariant(config) {
+  const resolveClasses = createTailwindVariantResolver(config);
+  return (selection = {}) => resolveClasses(selection);
+}
+export function useTailwindVariant(config, options = {}) {
+  const rawAttrs = useAttrs();
+  const shouldMergeAttrsClass = options.mergeAttrsClass !== false;
+  const resolveClasses = createTailwindVariantResolver(config);
+  const attrs = computed(() => {
+    if (!shouldMergeAttrsClass) {
+      return rawAttrs;
+    }
+    const { class: _class, ...restAttrs } = rawAttrs;
+    return restAttrs;
+  });
+  const classes = computed(
+    () => resolveClasses(options.selection?.(), shouldMergeAttrsClass ? rawAttrs.class : void 0)
+  );
+  return {
+    attrs,
+    classes
+  };
+}

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

@@ -0,0 +1,23 @@
+import type { TreeDropPosition, TreeDropTarget, TreeFlatNode } from '../../components/tree/types';
+import type { MaybeElementRef } from '../../types/shared';
+import type { ComponentValue } from '../../types/shared';
+import type { MaybeRefOrGetter } from 'vue';
+export interface UseTreeDragOptions {
+    container: MaybeElementRef<HTMLElement>;
+    /** Rendered rows, the only ones the pointer can be measured against. */
+    rows: MaybeRefOrGetter<TreeFlatNode[]>;
+    /** Whole-session gate: off while searching, while disabled, or without the prop. */
+    enabled: 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: import("vue").ShallowRef<ComponentValue | undefined, ComponentValue | undefined>;
+    target: import("vue").ShallowRef<TreeDropTarget | undefined, TreeDropTarget | undefined>;
+    x: import("vue").ShallowRef<number, number>;
+    y: import("vue").ShallowRef<number, number>;
+    onPointerDown: (nodeValue: ComponentValue, event: PointerEvent) => void;
+    cancel: () => void;
+};