@vue-dnd-kit/core 2.4.7 → 3.0.0

package/dist/external/types/operations.d.ts

@@ -1,187 +0,0 @@
-import { IPlacement, TInsertSide, TPlacementOrientation } from './placement';
-
-
-// ── Result types ───────────────────────────────────────────────────────────────
-
-/**
- * Result of suggestSort.
- * Same-list: sourceItems === targetItems (one array, reordered).
- * Cross-list: two different arrays — apply both.
- */
-export interface ISuggestSortResult<T = unknown> {
-  /** Source list after removing dragged items. Same ref as targetItems when sameList. */
-  sourceItems: T[];
-  /** Target list after inserting dragged items at targetIndex. */
-  targetItems: T[];
-  /** The items that were moved (in original order). */
-  draggedItems: T[];
-  sourceIndexes: number[];
-  targetIndex: number;
-  mode: 'insert' | 'append' | 'prepend';
-  sameList: boolean;
-}
-
-/**
- * Result of suggestSwap.
- * Same-list: one array with positions swapped (sourceItems === targetItems).
- * Cross-list: two arrays with the items exchanged.
- * Multi-drag: dragged group exchanges with the single hovered item.
- */
-export interface ISuggestSwapResult<T = unknown> {
-  /** Source list after swap. */
-  sourceItems: T[];
-  /** Target list after swap. Same ref as sourceItems when sameList. */
-  targetItems: T[];
-  sourceIndexes: number[];
-  targetIndex: number;
-  sameList: boolean;
-}
-
-/**
- * Result of suggestCopy.
- * Source list is NEVER modified — only target receives new items.
- */
-export interface ISuggestCopyResult<T = unknown> {
-  /** Target list after inserting copies. */
-  targetItems: T[];
-  /** Shallow copies of the dragged items that were inserted. */
-  copiedItems: T[];
-  targetIndex: number;
-  mode: 'insert' | 'append' | 'prepend';
-}
-
-/**
- * Result of suggestRemove.
- */
-export interface ISuggestRemoveResult<T = unknown> {
-  /** Source list after removing dragged items. */
-  sourceItems: T[];
-  /** The items that were removed. */
-  removedItems: T[];
-  sourceIndexes: number[];
-}
-
-/** Draggable element currently under the cursor (inside the drop zone). */
-export interface IHoveredDraggableContext<T = unknown> {
-  element: HTMLElement;
-  /** Cursor position relative to this element. */
-  placement: IPlacement;
-  index: number;
-  /** The actual object: items[index]. */
-  item: T;
-  items: T[];
-  /** Custom data from the `data` option (reactive, always up-to-date) */
-  data?: unknown;
-}
-
-/** Placement helpers: interpret placement flags by list orientation. */
-export interface IPlacementHelpers {
-  /** 'before' = top (vertical) / left (horizontal). 'after' = bottom / right. */
-  getInsertSide(
-    placement: IPlacement | undefined,
-    orientation: TPlacementOrientation
-  ): TInsertSide | null;
-  isAtZoneStart(
-    placement: IPlacement | undefined,
-    orientation: TPlacementOrientation
-  ): boolean;
-  isAtZoneEnd(
-    placement: IPlacement | undefined,
-    orientation: TPlacementOrientation
-  ): boolean;
-}
-
-/**
- * Helpers object available on every drag event via `event.helpers`.
- *
- * ── Low-level (stateless, no event context) ─────────────────────────────────
- * Array primitives and placement interpreters. Use these to build custom logic.
- *
- * ── High-level (event-bound) ────────────────────────────────────────────────
- * Preset operations that read the current event context.
- * The user decides which one to call based on `event.hoveredDraggable`:
- *
- * ```ts
- * onDrop(event) {
- *   if (event.hoveredDraggable) {
- *     // hovering over an element → sort / swap / copy into position
- *     const r = event.helpers.suggestSort()
- *     if (r) list.value = r.targetItems
- *   } else {
- *     // hovering over zone only → append / prepend / copy to zone
- *     const r = event.helpers.suggestSort()
- *     if (r) list.value = r.targetItems
- *   }
- * }
- * ```
- */
-export interface IHelpers {
-  // ── Low-level: array ops ──────────────────────────────────────────────────
-  /** Insert toInsert items into items at index. Returns new array. */
-  insertAt<T>(items: T[], index: number, toInsert: T[]): T[];
-  /** Remove count items at index. Returns new array. */
-  removeAt<T>(items: T[], index: number, count?: number): T[];
-  /** Remove multiple indexes (high → low, safe). Returns new array. */
-  removeIndexes<T>(items: T[], indexes: number[]): T[];
-  /** Swap items at positions i and j. Returns new array. */
-  swapAt<T>(items: T[], i: number, j: number): T[];
-
-  // ── Low-level: placement ──────────────────────────────────────────────────
-  /** 'before' or 'after' relative to the orientation axis, or null if ambiguous. */
-  getInsertSide(
-    placement: IPlacement | undefined,
-    orientation: TPlacementOrientation
-  ): TInsertSide | null;
-  /** True when pointer is at the very start edge of the zone (no center). */
-  isAtZoneStart(
-    placement: IPlacement | undefined,
-    orientation: TPlacementOrientation
-  ): boolean;
-  /** True when pointer is at the very end edge of the zone (no center). */
-  isAtZoneEnd(
-    placement: IPlacement | undefined,
-    orientation: TPlacementOrientation
-  ): boolean;
-
-  // ── High-level: event-bound presets ───────────────────────────────────────
-
-  /**
-   * **Sort / Transfer** — universal insert.
-   *
-   * - With `hoveredDraggable`: inserts dragged items before or after the
-   *   hovered element (determined by cursor placement).
-   * - Without `hoveredDraggable`: appends to zone start/end based on zone placement.
-   * - Same-list: reorders in place. Cross-list: transfers (removes from source, inserts into target).
-   *
-   * Returns null when context is insufficient (no draggedItems or no dropZone).
-   * Cast result arrays to your item type: `r.targetItems as MyItem[]`.
-   */
-  suggestSort(orientation?: TPlacementOrientation): ISuggestSortResult | null;
-
-  /**
-   * **Swap** — exchange the single dragged item with the hovered element.
-   *
-   * - Same-list: swaps two positions in one array.
-   * - Cross-list: exchanges items between two arrays.
-   *
-   * Returns null when multi-drag or no `hoveredDraggable`.
-   */
-  suggestSwap(): ISuggestSwapResult | null;
-
-  /**
-   * **Copy** — insert copies of dragged items at target position WITHOUT removing from source.
-   *
-   * Position logic is identical to `suggestSort`.
-   * Useful for copy-on-drag (e.g. held Ctrl key).
-   *
-   * Returns null when context is insufficient.
-   */
-  suggestCopy(orientation?: TPlacementOrientation): ISuggestCopyResult | null;
-
-  /**
-   * **Remove** — remove dragged items from their source list.
-   *
-   * Returns null when there are no draggedItems.
-   */
-  suggestRemove(): ISuggestRemoveResult | null;
-}

package/dist/external/types/placement.d.ts

@@ -1,34 +0,0 @@
-/**
- * Which side(s) of the element/zone the pointer is in.
- * Multiple flags can be true (e.g. top + right for corner). Do not normalize.
- * - vertical list: top = before, bottom = after
- * - horizontal list: left = before, right = after
- * - center: pointer in center zone (dual-role draggable+zone)
- */
-export interface IPlacement {
-  top: boolean;
-  right: boolean;
-  bottom: boolean;
-  left: boolean;
-  /** True when pointer is in center zone (inside placementMargins). Used for dual-role draggable+zone. */
-  center: boolean;
-}
-
-export type TPlacementOrientation = 'vertical' | 'horizontal';
-
-/** 'before' | 'after' for insert position along one axis */
-export type TInsertSide = 'before' | 'after';
-
-export interface IPlacementMargins {
-  top?: number;
-  right?: number;
-  bottom?: number;
-  left?: number;
-}
-
-/** Options for makeAutoScroll and DnDProvider autoScrollViewport prop */
-export interface IAutoScrollOptions {
-  threshold?: number | IPlacementMargins;
-  speed?: number;
-  disabled?: boolean;
-}

package/dist/external/types/pointer.d.ts

@@ -1,10 +0,0 @@
-export interface ICoordinates {
-  x: number;
-  y: number;
-}
-
-export type TPointerState = {
-  start: ICoordinates;
-  current: ICoordinates;
-  offset: ICoordinates;
-} | undefined | null

package/dist/external/types/provider.d.ts

@@ -1,89 +0,0 @@
-import { IConstraintsAreaEntity, IDraggableEntity, IDroppableEntity, IEntities, ISelectableAreaEntity, TDnDNode, IDragItem, IDropZoneContext } from './entities';
-import { ICoordinates, TPointerState } from './pointer';
-import { IAutoScrollOptions } from './placement';
-import { IHelpers, IHoveredDraggableContext } from './operations';
-import { Component, ComputedRef, CSSProperties, Reactive, Ref, ShallowRef, VNode, VueElement, WritableComputedRef } from 'vue';
-
-
-/** Event object passed to all drag/drop handlers */
-export interface IDragEvent<DragT = unknown, ZoneT = unknown> {
-  /** All dragged items sorted by index. Length > 1 means multi-drag. */
-  draggedItems: IDragItem<DragT>[];
-  /** Drop zone context — present in onEnter / onDrop / onLeave. */
-  dropZone: IDropZoneContext<ZoneT> | undefined;
-  /** Draggable element under cursor inside the zone — use for insert-before/after. */
-  hoveredDraggable: IHoveredDraggableContext | undefined;
-  provider: IDnDProviderExternal;
-  /** Helpers bound to this event. Low-level array ops + high-level suggest* presets. */
-  helpers: IHelpers;
-}
-
-/** Map element → placement for elements under cursor during drag */
-export type THoveredMap = Map<HTMLElement, IPlacement>;
-
-export interface IHovered {
-  draggable: THoveredMap;
-  droppable: THoveredMap;
-}
-
-export interface ICollision {
-  throttle: Ref<number>;
-}
-
-export interface IDnDProviderExternal {
-  state: Ref<TDnDState | undefined>;
-  pointer: Ref<TPointerState | undefined>;
-  entities: Reactive<IEntities>;
-  keyboard: {
-    keys: {
-      pressedKeys: Ref<Set<string>>;
-      forDrag: string[];
-      forCancel: string[];
-      forDrop: string[];
-      forMove: string[];
-      forMoveFaster: string[];
-    };
-    step: number;
-    moveFaster: number;
-  };
-  scrollPosition: Reactive<ICoordinates>;
-  delay: Reactive<IDelay>;
-  distanceProgress: ComputedRef<number>;
-  preview: {
-    ref: Ref<HTMLElement | null>;
-    position: ComputedRef<ICoordinates>;
-    size: ShallowRef<DOMRect>;
-    render: Ref<Component | undefined>;
-    to: WritableComputedRef<string | false | null | undefined>;
-  };
-  hovered: IHovered;
-  collision: ICollision;
-  autoScrollViewport: ComputedRef<
-    IAutoScrollOptions | true | false | null | undefined
-  >;
-}
-
-export interface IDelay {
-  progress: number;
-  startTime: number;
-}
-
-export type TDnDState =
-  | 'dragging'
-  | 'selecting'
-  | 'activating'
-  | 'pending' /** awaiting async onDrop (e.g. confirm); drag still active */
-  | null
-  | undefined;
-
-export type TDropResult = 'accept' | 'cancel' | 'decline';
-
-/** DnDProvider props */
-export interface IDnDProviderProps {
-  /** Enable viewport auto-scroll: true = defaults, object = options. false | null | undefined = disabled. */
-  autoScrollViewport?: IAutoScrollOptions | true | false | null;
-  /** Teleport preview to element: 'body' = defaults, string = element id. false | null | undefined = disabled. */
-  previewTo?: string | false | null;
-  style?: any;
-  class?: any;
-}

package/dist/internal/composables/useDnDProviderEvents.d.ts

@@ -1,2 +0,0 @@
-import { IDnDProviderInternal } from '../types/provider';
-export declare const useDnDProviderEvents: (provider: IDnDProviderInternal) => void;

package/dist/internal/composables/useDnDProviderInternal.d.ts

@@ -1,2 +0,0 @@
-import { IDnDProviderInternal } from '../types/provider';
-export declare const useDnDProviderInternal: () => IDnDProviderInternal;

package/dist/internal/composables/useDnDProviderState.d.ts

@@ -1,4 +0,0 @@
-import { Ref } from 'vue';
-import { IDnDProviderProps } from '../../external/types/provider';
-import { IDnDProviderInternal } from '../types/provider';
-export declare function useDnDProviderState(previewRef: Ref<HTMLElement | null>, props?: IDnDProviderProps): IDnDProviderInternal;

package/dist/internal/composables/useViewportAutoScroll.d.ts

@@ -1,9 +0,0 @@
-import { IAutoScrollOptionsInternal } from '../types/auto-scroll';
-import { IDnDProviderInternal } from '../types/provider';
-/**
- * Internal composable: viewport (window) auto-scroll. Not exposed to user.
- */
-export declare function useViewportAutoScroll(provider: IDnDProviderInternal, options?: IAutoScrollOptionsInternal): {
-    isScrolling: import('vue').ShallowRef<boolean, boolean>;
-    stop: () => void;
-};

package/dist/internal/logic/hover.d.ts

@@ -1,6 +0,0 @@
-import { IDnDProviderInternal } from '../types/provider';
-import { IHovered } from '../../external/types/provider';
-export declare const applyCollisionResultToHovered: (provider: IDnDProviderInternal, hovered: IHovered, result: {
-    elements: HTMLElement[];
-    zones: HTMLElement[];
-}) => void;

package/dist/internal/logic/keyboard.d.ts

@@ -1,6 +0,0 @@
-import { IDnDProviderInternal } from '../types/provider';
-export declare const handleKeyboardEvents: {
-    keyDown: (provider: IDnDProviderInternal) => (event: KeyboardEvent) => void;
-    keyUp: (provider: IDnDProviderInternal) => (event: KeyboardEvent) => void;
-    clear: (provider: IDnDProviderInternal) => () => void;
-};

package/dist/internal/logic/operations.d.ts

@@ -1,35 +0,0 @@
-import { IHelpers, IPlacementHelpers, ISuggestCopyResult, ISuggestRemoveResult, ISuggestSortResult, ISuggestSwapResult } from '../../external/types/operations';
-import { TPlacementOrientation, IPlacement } from '../../external/types/placement';
-/** Minimal event shape used by internal suggest* (avoids circular import). */
-export interface IDropEventContext {
-    draggedItems: Array<{
-        index: number;
-        item: unknown;
-        items: unknown[];
-        data?: unknown;
-    }>;
-    dropZone?: {
-        items: unknown[];
-        placement: IPlacement | undefined;
-        data?: unknown;
-    };
-    hoveredDraggable?: {
-        element: HTMLElement;
-        placement: IPlacement;
-        index: number;
-        item: unknown;
-        items: unknown[];
-        data?: unknown;
-    };
-}
-export declare function insertAt<T>(items: T[], index: number, toInsert: T[]): T[];
-export declare function removeAt<T>(items: T[], index: number, count?: number): T[];
-/** Remove multiple indexes (order-safe: removes high → low). Returns new array. */
-export declare function removeIndexes<T>(items: T[], indexes: number[]): T[];
-export declare function swapAt<T>(items: T[], i: number, j: number): T[];
-export declare const placementHelpers: IPlacementHelpers;
-export declare function _suggestSort(event: IDropEventContext, orientation?: TPlacementOrientation): ISuggestSortResult | null;
-export declare function _suggestSwap(event: IDropEventContext): ISuggestSwapResult | null;
-export declare function _suggestCopy(event: IDropEventContext, orientation?: TPlacementOrientation): ISuggestCopyResult | null;
-export declare function _suggestRemove(event: IDropEventContext): ISuggestRemoveResult | null;
-export declare function createHelpers(ctx: IDropEventContext): IHelpers;

package/dist/internal/logic/payload.d.ts

@@ -1,5 +0,0 @@
-export {};
-/**
- * @internal — legacy helpers kept for compatibility with any code that might import them.
- * The main drag event is now built directly in events.ts via buildDraggedItems().
- */

package/dist/internal/logic/pointer.d.ts

@@ -1,11 +0,0 @@
-import { IDnDProviderInternal } from '../types/provider';
-import { TDropResult } from '../../external';
-export declare function runCollisionAndApply(provider: IDnDProviderInternal): void;
-export declare function handleDropAndFinish(provider: IDnDProviderInternal): Promise<TDropResult>;
-export declare function finishDragSession(provider: IDnDProviderInternal): void;
-export declare const createPointerHandlers: (provider: IDnDProviderInternal) => {
-    pointerDown: (event: PointerEvent) => void;
-    pointerUp: () => Promise<void>;
-    pointerMove: (event: PointerEvent) => void;
-    cleanup: () => void;
-};

package/dist/internal/logic/scroll.d.ts

@@ -1,2 +0,0 @@
-import { IDnDProviderInternal } from '../types/provider';
-export declare const handleScrollEvent: (provider: IDnDProviderInternal) => () => void;

package/dist/internal/sensors/default-collision.d.ts

@@ -1,18 +0,0 @@
-import { CollisionDetectionFn } from './sensor';
-import { IDnDProviderInternal } from '../types/provider';
-/**
- * Phase 1: ancestor-walk from the topmost element under the cursor.
- *
- * document.elementFromPoint (singular) returns the actual hit-tested element —
- * the same target as a real pointer event. Walking up from it collects only
- * registered elements that are ancestors (or the element itself), which means
- * elements behind a modal are never included even though they share the same
- * screen coordinates.
- *
- * Returns null when no registered element or zone is found in the ancestor chain.
- */
-export declare function runCursorPhase(provider: IDnDProviderInternal): {
-    elements: HTMLElement[];
-    zones: HTMLElement[];
-} | null;
-export declare const defaultCollisionDetection: CollisionDetectionFn;

package/dist/internal/sensors/index.d.ts

@@ -1,2 +0,0 @@
-export * from './steps';
-export { defaultCollisionDetection } from './default-collision';

package/dist/internal/sensors/sensor.d.ts

@@ -1,68 +0,0 @@
-import { IBoundingBox } from '../utils/geometry';
-import { IDnDProviderInternal } from '../types/provider';
-/**
- * Collision detection function signature.
- * Returns sorted lists of colliding elements and zones.
- *
- * IMPORTANT: When implementing custom sensors, use:
- * - `provider.entities.allowedDroppableSet` for zones (visible + filtered by groups)
- * - `provider.entities.allowedDraggableSet` for draggedItems (visible + filtered by groups)
- * OR use helper functions from `steps.ts`: `allowedVisibleZones()` and `visibleElements()`.
- */
-export type CollisionDetectionFn = (provider: IDnDProviderInternal) => {
-    elements: HTMLElement[];
-    zones: HTMLElement[];
-};
-export type TContainerFn = (provider: IDnDProviderInternal) => HTMLElement | null;
-export type TContainerBoxFn = (provider: IDnDProviderInternal) => IBoundingBox;
-export type TCandidatesFn = (provider: IDnDProviderInternal) => Iterable<HTMLElement>;
-export type TFilterFn = (node: HTMLElement, provider: IDnDProviderInternal) => boolean;
-export type TCollisionContext = {
-    containerBox: IBoundingBox;
-    pointer: {
-        x: number;
-        y: number;
-    };
-};
-export type TCollisionCheckFn = (nodeBox: IBoundingBox, ctx: TCollisionContext) => boolean;
-export type TSortCompareFn = (a: {
-    node: HTMLElement;
-    box: IBoundingBox;
-    meta: ICollisionMeta;
-}, b: {
-    node: HTMLElement;
-    box: IBoundingBox;
-    meta: ICollisionMeta;
-}, ctx: {
-    containerBox: IBoundingBox;
-    pointer: {
-        x: number;
-        y: number;
-    };
-}) => number;
-/** Merge strategy: how to combine elements and zones into final result */
-export type TMergeStrategy = 'separate' | 'unified-closest';
-export interface ICollisionMeta {
-    isPointerInElement: boolean;
-    overlapPercent: number;
-    depth: number;
-    centerDistance: number;
-}
-export interface ISensorBuilder {
-    container(fn: TContainerFn): ISensorBuilder;
-    containerBox(fn: TContainerBoxFn): ISensorBuilder;
-    elements(fn: TCandidatesFn): ISensorBuilder;
-    zones(fn: TCandidatesFn): ISensorBuilder;
-    filterElements(fn: TFilterFn): ISensorBuilder;
-    filterZones(fn: TFilterFn): ISensorBuilder;
-    collision(fn: TCollisionCheckFn): ISensorBuilder;
-    sortElements(fn: TSortCompareFn): ISensorBuilder;
-    sortZones(fn: TSortCompareFn): ISensorBuilder;
-    mergeStrategy(strategy: TMergeStrategy): ISensorBuilder;
-    /** Pick closest between first zone and first element by distance to pointer */
-    pickClosestBetweenFirst(enable: boolean): ISensorBuilder;
-    /** Filter by minimum overlap percent (0-100). Applied after collision check. */
-    minOverlapPercent(percent: number): ISensorBuilder;
-    build(): CollisionDetectionFn;
-}
-export declare const createSensor: () => ISensorBuilder;

package/dist/internal/sensors/steps.d.ts

@@ -1,58 +0,0 @@
-import { IDnDProviderInternal } from '../types/provider';
-import { TSortCompareFn, TFilterFn, TCollisionCheckFn, TContainerBoxFn } from './sensor';
-/** Container from overlay ref */
-export declare const previewContainer: (p: IDnDProviderInternal) => HTMLElement | null;
-/**
- * Box from overlay style (x,y) + size.
- * The overlay is `position:fixed; top:0; left:0; transform:translate(x,y)`, so
- * getBoundingClientRect() is unreliable for the position (transform offsets it from 0,0).
- * However the SIZE from getBoundingClientRect IS correct and is used as a fallback
- * when the ResizeObserver hasn't fired yet (`overlay.size.value` is still null).
- *
- * Without the fallback: size=0 → containerBox is a zero-size point → pointer.x <= box.x+0
- * fails whenever offset.x>0 (grabbed away from left edge) → pointerInContainer=false always.
- */
-export declare const previewBoxFromStyle: TContainerBoxFn;
-/** Allowed draggedItems (visible + filtered by groups) */
-export declare const visibleElements: (p: IDnDProviderInternal) => Set<HTMLElement>;
-/** Allowed droppables (visible + filtered by groups) */
-export declare const allowedVisibleZones: (p: IDnDProviderInternal) => Set<HTMLElement>;
-/** Exclude nodes being dragged */
-export declare const filterNotDragging: TFilterFn;
-/** Exclude nodes that are descendants of any dragged element (nesting into self) */
-export declare const filterNotDescendantOfDragged: TFilterFn;
-/**
- * Exclude disabled draggedItems (including those inside disabled parents).
- * Role-specific: only looks at the node's draggable disabled state, so a node
- * that is also registered as droppable is unaffected by this check.
- */
-export declare const filterNotDisabledDraggable: TFilterFn;
-/**
- * Exclude disabled zones (including those inside disabled parents).
- * Role-specific: only looks at the node's droppable disabled state, so a node
- * that is also registered as draggable is unaffected by this check.
- */
-export declare const filterNotDisabledDroppable: TFilterFn;
-/** Exclude: not dragging, not descendant of dragged, not disabled — as a draggable */
-export declare const filterValidDraggableTarget: TFilterFn;
-/** Exclude: not dragging, not descendant of dragged, not disabled — as a zone */
-export declare const filterValidDroppableTarget: TFilterFn;
-/** AABB overlap check (element vs container) — legacy */
-export declare const aabbCollision: TCollisionCheckFn;
-/** Pointer-in-element: cursor must be inside element (AABB of element) */
-export declare const pointerInElementCollision: TCollisionCheckFn;
-/** Always true — no container check (for "closest on screen" regardless of overlay position) */
-export declare const noContainerCollision: TCollisionCheckFn;
-/** Sort: deepest first (topmost visible element under cursor) */
-export declare const sortByDepth: TSortCompareFn;
-/** Sort: by distance from pointer to element center (closest first) */
-export declare const sortByPointerDistance: TSortCompareFn;
-/**
- * Sort: pointer-in-element + depth when pointer inside container; overlap % + centerDistance when outside.
- *
- * The container box MUST be computed via previewBoxFromStyle (not getBoundingClientRect) so that
- * position is correct for a fixed+transform overlay. The size fallback in previewBoxFromStyle ensures
- * the box is never zero-sized on the first frame, making `pointerInContainer` reliably true whenever
- * the cursor is above the drag ghost.
- */
-export declare const sortByOverlapAndPointer: TSortCompareFn;

package/dist/internal/types/auto-scroll.d.ts

@@ -1,20 +0,0 @@
-/** Internal: options for auto-scroll controller (same shape as IAutoScrollOptions for compatibility) */
-export interface IAutoScrollOptionsInternal {
-  threshold?: number | { top?: number; right?: number; bottom?: number; left?: number };
-  speed?: number;
-  disabled?: boolean;
-}
-
-export interface IScrollState {
-  scrollTop: number;
-  scrollLeft: number;
-}
-
-export interface IScrollAdapter {
-  getScrollState(el: HTMLElement): IScrollState;
-  setScroll(el: HTMLElement, scrollTop: number, scrollLeft: number): void;
-  /** Override rect calculation. Defaults to el.getBoundingClientRect(). */
-  getRect?(el: HTMLElement): DOMRect;
-}
-
-export type TOverlayPoint = { x: number; y: number } | null;

package/dist/internal/types/observer.d.ts

@@ -1,11 +0,0 @@
-export interface ISizeObserverWrapper {
-  observe: (element: HTMLElement) => void;
-  unobserve: (element: HTMLElement) => void;
-  disconnect: () => void;
-}
-
-export interface IIntersectionObserverWrapper {
-  observe: (element: HTMLElement) => void;
-  unobserve: (element: HTMLElement) => void;
-  disconnect: () => void;
-}

package/dist/internal/types/provider.d.ts

@@ -1,31 +0,0 @@
-import { Ref } from 'vue';
-import { IDnDProviderExternal } from '../../external';
-import { IAutoScrollOptions } from '../../external/types/placement';
-import { IIntersectionObserverWrapper } from './observer';
-
-
-export interface IKeyboardKeys {
-  pressedKeys: Ref<Set<string>>;
-  forDrag: string[];
-  forCancel: string[];
-  forDrop: string[];
-  forMove: string[];
-  forMoveFaster: string[];
-}
-
-export interface IKeyboardState {
-  keys: IKeyboardKeys;
-  step: number;
-  moveFaster: number;
-}
-
-export interface IDnDProviderInternal extends IDnDProviderExternal {
-  keyboard: IKeyboardState;
-  lib: {
-    draggableObserver: IIntersectionObserverWrapper;
-    droppableObserver: IIntersectionObserverWrapper;
-    selectableAreaObserver: IIntersectionObserverWrapper;
-    /** BoundingClientRect cache — invalidated on scroll and session reset */
-    rectCache: Map<HTMLElement, DOMRect>;
-  };
-}

package/dist/internal/utils/auto-scroll.d.ts

@@ -1,13 +0,0 @@
-import { IAutoScrollOptionsInternal, IScrollAdapter, TOverlayPoint } from '../types/auto-scroll';
-export declare const defaultScrollAdapter: IScrollAdapter;
-/**
- * Creates run/stop controller for auto-scroll loop. Element scroll only (no viewport).
- */
-export declare function createAutoScrollController(containerRef: {
-    value: HTMLElement | null;
-}, options: IAutoScrollOptionsInternal, getOverlayPoint: () => TOverlayPoint, scrollAdapter?: IScrollAdapter, isScrollingRef?: {
-    value: boolean;
-}): {
-    run: () => void;
-    stop: () => void;
-};