@vue-dnd-kit/core 2.0.0-alpha1 → 2.0.0-alpha10

package/README.md

@@ -1,5 +1,74 @@
-# Vue 3 + TypeScript + Vite
+# Vue DnD Kit - Core Package
 
-This template should help get you started developing with Vue 3 and TypeScript in Vite. The template uses Vue 3 `<script setup>` SFCs, check out the [script setup docs](https://v3.vuejs.org/api/sfc-script-setup.html#sfc-script-setup) to learn more.
+[![Release](https://img.shields.io/badge/status-release-green.svg)](https://github.com/zizigy/vue-dnd-kit)
+[![npm version](https://img.shields.io/npm/v/@vue-dnd-kit/core.svg)](https://www.npmjs.com/package/@vue-dnd-kit/core)
 
-Learn more about the recommended Project Setup and IDE Support in the [Vue Docs TypeScript Guide](https://vuejs.org/guide/typescript/overview.html#project-setup).
+<p align="center">
+  <a href="https://zizigy.github.io/vue-dnd-kit/">
+    <img src="https://raw.githubusercontent.com/ZiZiGY/vue-dnd-kit/v2/public/logo.svg" width="400" alt="Vue Drag & Drop Logo">
+  </a>
+</p>
+
+<p align="center">
+  Core package of the Vue Drag & Drop library with composables and provider-based API.
+</p>
+
+<p align="center">
+  <a href="https://zizigy.github.io/vue-dnd-kit/" target="_blank">
+    <img src="https://img.shields.io/badge/Documentation-Visit-blue?style=flat-square" alt="Documentation">
+  </a>
+</p>
+
+<p align="center">
+  Inspired by <a href="https://dndkit.com/" target="_blank">React DnD Kit</a>, adapted for Vue.js
+</p>
+
+---
+
+## About
+
+**Vue DnD Kit** — lightweight drag & drop library for Vue 3. Built around a provider (`DnDProvider`) and composables: `makeDraggable`, `makeDroppable`, `makeSelectionArea`, `makeConstraintArea`.
+
+- **Lightweight** — small bundle size, no extra dependencies (Vue as peer only)
+- **Flexible** — works with any layout and design system
+- **Accessible** — full keyboard support (start, move, cancel, drop)
+- **TypeScript** — fully typed
+
+---
+
+## Features
+
+- **Composables API** — `makeDraggable`, `makeDroppable`, `makeSelectionArea`, `makeConstraintArea`
+- **Provider-based** — `DnDProvider` + `useDnDProvider` for state access
+- **Keyboard support** — Enter/Space for start and drop, arrows for movement, Escape to cancel
+- **Modifier keys** — drag only when modifier held (e.g. Ctrl)
+- **Custom overlay** — custom drag preview via slot or `render` option
+
+---
+
+## Installation
+
+```bash
+npm install @vue-dnd-kit/core
+```
+
+```bash
+yarn add @vue-dnd-kit/core
+```
+
+```bash
+pnpm add @vue-dnd-kit/core
+```
+
+**Peer dependency:** Vue 3
+
+---
+
+## License
+
+[MIT](LICENSE) © [ZiZiGY](https://github.com/ZiZiGY)
+
+---
+
+<p align="center">🎉 Congratulations on the official release! 🎉</p>
+<p align="center">Made with ❤️ for the Vue.js community</p>

package/dist/external/components/DefaultOverlay.vue.d.ts

@@ -1,3 +1,2 @@
 declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export default _default;
-//# sourceMappingURL=DefaultOverlay.vue.d.ts.map

package/dist/external/components/DnDProvider.vue.d.ts

@@ -1,3 +1,4 @@
+import { IDnDProviderProps } from '../types/provider';
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: {
@@ -12,7 +13,7 @@ declare function __VLS_template(): {
     rootEl: any;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+declare const __VLS_component: import('vue').DefineComponent<IDnDProviderProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<IDnDProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     overlayRef: HTMLDivElement;
 }, any>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
@@ -22,4 +23,3 @@ type __VLS_WithTemplateSlots<T, S> = T & {
         $slots: S;
     };
 };
-//# sourceMappingURL=DnDProvider.vue.d.ts.map

package/dist/external/composables/makeAutoScroll.d.ts

@@ -0,0 +1,13 @@
+import { Ref } from 'vue';
+import { IAutoScrollOptions } from '../types';
+export type { IAutoScrollOptions };
+/**
+ * Auto-scroll when the drag overlay is near container edges. Element scroll only.
+ *
+ * @param container - Ref to the scrollable element
+ * @param options - threshold, speed, disabled
+ * @returns { isScrolling }
+ */
+export declare const makeAutoScroll: (container: Ref<HTMLElement | null>, options?: IAutoScrollOptions) => {
+    isScrolling: import('vue').ShallowRef<boolean, boolean>;
+};

package/dist/external/composables/makeConstraintArea.d.ts

@@ -0,0 +1,7 @@
+import { TDnDNodeRef, TDragAxis } from '../types';
+import { Ref } from 'vue';
+export interface IMakeConstraintAreaOptions {
+    axis?: TDragAxis | Ref<TDragAxis>;
+    restrictToArea?: boolean | Ref<boolean>;
+}
+export declare function makeConstraintArea(ref: TDnDNodeRef, options?: IMakeConstraintAreaOptions): {};

package/dist/external/composables/makeDraggable.d.ts

@@ -1,17 +1,19 @@
-import { IBaseOptions, IDragActivationOptions, IDraggableEvents, IModifierOptions, IPlacementMargins, TDnDNodeRef, TDraggablePayload } from '../types';
-import { Component, Ref } from 'vue';
+import { IBaseOptions, IDragActivationOptions, IDraggableEvents, IModifierOptions, IPlacement, IPlacementMargins, TDnDNodeRef, TDraggablePayload } from '../types';
+import { Component, ComputedRef, Ref, WritableComputedRef } from 'vue';
 interface IMakeDraggableOptions extends IBaseOptions {
     events?: IDraggableEvents;
     modifier?: IModifierOptions;
     render?: Component;
     dragHandle?: string | Ref<string>;
     activation?: IDragActivationOptions;
-    /** Margins for center zone. When pointer in center and element is also droppable, zone mode is used. */
     placementMargins?: IPlacementMargins;
 }
 interface IMakeDraggableReturnType {
+    selected: WritableComputedRef<boolean>;
+    isDragging: ComputedRef<boolean>;
+    isAllowed: ComputedRef<boolean>;
+    isDragOver: ComputedRef<IPlacement | undefined>;
 }
 export declare function makeDraggable(ref: TDnDNodeRef, payload?: TDraggablePayload): IMakeDraggableReturnType;
 export declare function makeDraggable(ref: TDnDNodeRef, options: IMakeDraggableOptions, payload?: TDraggablePayload): IMakeDraggableReturnType;
 export {};
-//# sourceMappingURL=makeDraggable.d.ts.map

package/dist/external/composables/makeDroppable.d.ts

@@ -1,7 +1,13 @@
-import { IBaseOptions, IDroppableEvents, TDnDNodeRef } from '../types';
+import { IBaseOptions, IDroppableEvents, IPlacement, TDnDNodeRef, TDroppablePayload } from '../types';
+import { ComputedRef } from 'vue';
 interface IMakeDroppableOptions extends IBaseOptions {
     events?: IDroppableEvents;
 }
-export declare function makeDroppable(ref: TDnDNodeRef, options?: IMakeDroppableOptions): void;
+interface IMakeDroppableReturnType {
+    isAllowed: ComputedRef<boolean>;
+    isDragOver: ComputedRef<IPlacement | undefined>;
+}
+export declare function makeDroppable(ref: TDnDNodeRef): IMakeDroppableReturnType;
+export declare function makeDroppable(ref: TDnDNodeRef, options: IMakeDroppableOptions, payload?: TDroppablePayload): IMakeDroppableReturnType;
+export declare function makeDroppable(ref: TDnDNodeRef, payload: TDroppablePayload): IMakeDroppableReturnType;
 export {};
-//# sourceMappingURL=makeDroppable.d.ts.map

package/dist/external/composables/{makeSelectableArea.d.ts → makeSelectionArea.d.ts}

@@ -1,15 +1,14 @@
 import { Ref } from 'vue';
 import { IBaseOptions, ISelectableAreaEvents, TDnDNodeRef, TModifierKeys, TModifierMethod } from '../types';
-interface ISelectableAreaOptions extends IBaseOptions {
+interface ISelectionAreaOptions extends IBaseOptions {
     modifier?: {
         keys: TModifierKeys | Ref<TModifierKeys>;
         method: TModifierMethod | Ref<TModifierMethod>;
     };
     events?: ISelectableAreaEvents;
 }
-export declare const makeSelectableArea: (nodeRef: TDnDNodeRef, options?: ISelectableAreaOptions) => {
+export declare const makeSelectionArea: (nodeRef: TDnDNodeRef, options?: ISelectionAreaOptions) => {
     isSelecting: import('vue').ComputedRef<boolean>;
     style: import('vue').ComputedRef<import('vue').CSSProperties>;
 };
 export {};
-//# sourceMappingURL=makeSelectableArea.d.ts.map

package/dist/external/composables/makeSnappedOverlayPosition.d.ts

@@ -0,0 +1,20 @@
+import { ComputedRef } from 'vue';
+import { ICoordinates } from '@vue-dnd-kit/core';
+/** Per-axis grid (no grid = step 1, no snap) */
+export type TSnapOverlayOptions = {
+    grid: number;
+    gridX?: never;
+    gridY?: never;
+} | {
+    grid?: never;
+    gridX: number;
+    gridY: number;
+};
+/**
+ * Returns a computed that maps overlay position (x, y) to grid‑snapped coordinates.
+ * Core keeps writing raw coordinates; use this for overlay display only.
+ *
+ * @param options - grid (or gridX / gridY)
+ * @returns ComputedRef<ICoordinates> — use for --position-x / --position-y in overlay
+ */
+export declare function makeSnappedOverlayPosition(position: ComputedRef<ICoordinates>, options?: TSnapOverlayOptions): ComputedRef<ICoordinates>;

package/dist/external/composables/useDnDProvider.d.ts

@@ -1,3 +1,2 @@
 import { IDnDProviderExternal } from '../types';
 export declare const useDnDProvider: () => IDnDProviderExternal;
-//# sourceMappingURL=useDnDProvider.d.ts.map

package/dist/external/env.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="vite/client" />
+
+declare module '*.vue' {
+  import type { DefineComponent } from 'vue';
+  const component: DefineComponent<object, object, unknown>;
+  export default component;
+}

package/dist/external/index.d.ts

@@ -1,12 +1,11 @@
-/**
- * Public API (external)
- * Re-exports from internal for future package consumers
- */
-export { default as DnDProvider } from './components/DnDProvider.vue';
+import { default as DnDProvider } from './components/DnDProvider.vue';
+export { DnDProvider };
 export { makeDraggable } from './composables/makeDraggable';
-export { makeSelectableArea } from './composables/makeSelectableArea';
-export { makeBoundingBox } from './composables/makeBoundingBox';
+export { makeSelectionArea } from './composables/makeSelectionArea';
+export { makeConstraintArea } from './composables/makeConstraintArea';
 export { makeDroppable } from './composables/makeDroppable';
 export { useDnDProvider } from './composables/useDnDProvider';
+export { makeAutoScroll, type IAutoScrollOptions, } from './composables/makeAutoScroll';
+export { makeSnappedOverlayPosition, type TSnapOverlayOptions, } from './composables/makeSnappedOverlayPosition';
+export { createSensor, defaultCollisionDetection, type CollisionDetectionFn, type TMergeStrategy, } from '../internal/sensors';
 export type * from './types';
-//# sourceMappingURL=index.d.ts.map

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

@@ -13,6 +13,14 @@ export interface IDragPayload<T = unknown, D = unknown> {
   dropData?: D;
 }
 
+export type TDroppablePayload<T = any, U = any> = () => [T[], U?];
+
+/** Resolved payload from TDroppablePayload (items + optional userData) */
+export interface IDropZonePayload<T = unknown, U = unknown> {
+  items: T[];
+  userData?: U;
+}
+
 export interface IBaseOptions {
   disabled?: boolean | Ref<boolean>;
   groups?: string[] | Ref<string[]>;
@@ -39,6 +47,9 @@ export interface IEntities {
   modifiersDraggableSet: ComputedRef<Set<HTMLElement>>;
   modifiersSelectableAreaSet: ComputedRef<Set<HTMLElement>>;
 
+  allowedDroppableSet: ComputedRef<Set<HTMLElement>>;
+  allowedDraggableSet: ComputedRef<Set<HTMLElement>>;
+
   visibleDraggableSet: Set<HTMLElement>;
   visibleDroppableSet: Set<HTMLElement>;
   visibleSelectableAreaSet: Set<HTMLElement>;
@@ -137,8 +148,10 @@ export interface IDraggableEntity extends IBaseEntity {
 export interface IDraggingEntity extends IDraggableEntity {
   initialHTML: string;
   initialRect: DOMRect;
+  initialOuterHTML: string;
 }
 
 export interface IDroppableEntity extends IBaseEntity {
   events?: IDroppableEvents;
+  payload?: TDroppablePayload;
 }

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

@@ -1,4 +1,4 @@
 export type * from './pointer';
 export type * from './provider';
 export type * from './placement';
-export type * from './entities'
+export type * from './entities';

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

@@ -4,7 +4,7 @@ export interface IPlacement {
   bottom: boolean;
   left: boolean;
   /** True when pointer is in center zone (inside placementMargins). Used for dual-role draggable+zone. */
-  center?: boolean;
+  center: boolean;
 }
 
 export interface IPlacementMargins {
@@ -13,3 +13,10 @@ export interface IPlacementMargins {
   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/provider.d.ts

@@ -1,10 +1,18 @@
-import { IConstraintsAreaEntity, IDragPayload, IDraggableEntity, IDroppableEntity, IEntities, ISelectableAreaEntity, TDnDNode } from './entities';
+import { IConstraintsAreaEntity, IDragPayload, IDropZonePayload, IDraggableEntity, IDroppableEntity, IEntities, ISelectableAreaEntity, TDnDNode } from './entities';
 import { ICoordinates, TPointerState } from './pointer';
-import { IPlacement } from './placement';
-import { Component, ComputedRef, CSSProperties, Reactive, Ref, ShallowRef } from 'vue';
+import { IAutoScrollOptions, IPlacement } from './placement';
+import { Component, ComputedRef, CSSProperties, Reactive, Ref, ShallowRef, WritableComputedRef } from 'vue';
 /** Event object passed to drag/drop handlers */
-export interface IDragEvent<T = unknown, D = unknown> {
+export interface IDragEvent<
+  T = unknown,
+  D = unknown,
+  U = unknown,
+  V = unknown,
+> {
+  /** Payload from the dragged item (draggable payload) */
   payload: IDragPayload<T, D> | undefined;
+  /** Payload from the drop zone (droppable payload), set for onEnter/onDrop/onLeave */
+  dropZonePayload?: IDropZonePayload<U, V>;
   provider: IDnDProviderExternal;
 }
 
@@ -37,9 +45,10 @@ export interface IDnDProviderExternal {
   distanceProgress: ComputedRef<number>;
   overlay: {
     ref: Ref<HTMLElement | null>;
-    style: ComputedRef<ICoordinates>;
+    position: ComputedRef<ICoordinates>;
     size: Ref<DOMRect | null>;
     render: Ref<Component | undefined>;
+    to: WritableComputedRef<string | false | null | undefined>;
   };
   hovered: IHovered;
   collision: {
@@ -49,6 +58,9 @@ export interface IDnDProviderExternal {
     };
     throttle: Ref<number>;
   };
+  autoScrollViewport: ComputedRef<
+    IAutoScrollOptions | true | false | null | undefined
+  >;
 }
 
 export interface IDelay {
@@ -62,3 +74,11 @@ export type TDnDState =
   | 'activating'
   | null
   | undefined;
+
+/** DnDProvider props */
+export interface IDnDProviderProps {
+  /** Enable viewport auto-scroll: true = defaults, object = options. false | null | undefined = disabled. */
+  autoScrollViewport?: IAutoScrollOptions | true | false | null;
+  /** Teleport overlay to element: 'body' = defaults, string = element id. false | null | undefined = disabled. */
+  overlayTo?: string | false | null;
+}

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

@@ -1,3 +1,2 @@
 import { IDnDProviderInternal } from '../types/provider';
 export declare const useDnDProviderEvents: (provider: IDnDProviderInternal) => void;
-//# sourceMappingURL=useDnDProviderEvents.d.ts.map

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

@@ -1,3 +1,2 @@
 import { IDnDProviderInternal } from '../types/provider';
 export declare const useDnDProviderInternal: () => IDnDProviderInternal;
-//# sourceMappingURL=useDnDProviderInternal.d.ts.map

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

@@ -1,4 +1,4 @@
 import { Ref } from 'vue';
+import { IDnDProviderProps } from '../../external/types/provider';
 import { IDnDProviderInternal } from '../types/provider';
-export declare function useDnDProviderState(overlayRef: Ref<HTMLElement | null>): IDnDProviderInternal;
-//# sourceMappingURL=useDnDProviderState.d.ts.map
+export declare function useDnDProviderState(overlayRef: Ref<HTMLElement | null>, props?: IDnDProviderProps): IDnDProviderInternal;

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

@@ -31,4 +31,3 @@ export declare const useSizeObserver: (elementRef: Ref<HTMLElement | null>) => {
         disconnect: () => void;
     };
 };
-//# sourceMappingURL=useSizeObserver.d.ts.map

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

@@ -0,0 +1,9 @@
+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

@@ -5,4 +5,3 @@ export declare const applyCollisionResultToHovered: (provider: IDnDProviderInter
     elements: HTMLElement[];
     zones: HTMLElement[];
 }) => void;
-//# sourceMappingURL=hover.d.ts.map

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

@@ -4,4 +4,3 @@ export declare const handleKeyboardEvents: {
     keyUp: (provider: IDnDProviderInternal) => (event: KeyboardEvent) => void;
     clear: (provider: IDnDProviderInternal) => () => void;
 };
-//# sourceMappingURL=keyboard.d.ts.map

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

@@ -1,8 +1,12 @@
-import { IDragPayload } from '../../external/types';
+import { IDragPayload, IDropZonePayload } from '../../external/types';
 import { IDnDProviderInternal } from '../types/provider';
 /**
  * Resolves payload from initiating draggable.
  * Calls entity.payload() and returns { index, items, dropData }.
  */
 export declare const createDragPayload: (provider: IDnDProviderInternal) => IDragPayload | undefined;
-//# sourceMappingURL=payload.d.ts.map
+/**
+ * Resolves payload from a droppable zone.
+ * Calls zone entity.payload() and returns { items, userData }.
+ */
+export declare const createDropZonePayload: (provider: IDnDProviderInternal, zone: HTMLElement) => IDropZonePayload | undefined;

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

@@ -7,4 +7,3 @@ export declare const createPointerHandlers: (provider: IDnDProviderInternal) =>
     pointerMove: (event: PointerEvent) => void;
     cleanup: () => void;
 };
-//# sourceMappingURL=pointer.d.ts.map

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

@@ -1,3 +1,2 @@
 import { IDnDProviderInternal } from '../types/provider';
 export declare const handleScrollEvent: (provider: IDnDProviderInternal) => () => void;
-//# sourceMappingURL=scroll.d.ts.map

package/dist/internal/sensors/{defaultCollision.d.ts → default-collision.d.ts}

@@ -2,7 +2,6 @@
  * Default collision: same logic as vue-dnd-box reference
  * - Filter: AABB overlap with container (overlay)
  * - Sort: pointer outside container → isPointerInElement + depth; else overlap % + centerDistance
- * - Returns full sorted list
+ * - Picks closest to pointer when both zone and element present
  */
 export declare const defaultCollisionDetection: import('./sensor').CollisionDetectionFn;
-//# sourceMappingURL=defaultCollision.d.ts.map

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

@@ -1,3 +1,3 @@
 export * from './steps';
-export { defaultCollisionDetection } from './defaultCollision';
-//# sourceMappingURL=index.d.ts.map
+export { defaultCollisionDetection } from './default-collision';
+export { createSensor, type CollisionDetectionFn, type TMergeStrategy, } from './sensor';

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

@@ -1,5 +1,14 @@
 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 draggables (visible + filtered by groups)
+ * OR use helper functions from `steps.ts`: `allowedVisibleZones()` and `visibleElements()`.
+ */
 export type CollisionDetectionFn = (provider: IDnDProviderInternal) => {
     elements: HTMLElement[];
     zones: HTMLElement[];
@@ -31,6 +40,8 @@ export type TSortCompareFn = (a: {
         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;
@@ -47,7 +58,11 @@ export interface 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;
-//# sourceMappingURL=sensor.d.ts.map

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

@@ -4,10 +4,10 @@ import { TSortCompareFn, TFilterFn, TCollisionCheckFn, TContainerBoxFn } from '.
 export declare const overlayContainer: (p: IDnDProviderInternal) => HTMLElement | null;
 /** Box from overlay style (x,y) + size — overlay uses fixed+transform, getBoundingClientRect is wrong */
 export declare const overlayBoxFromStyle: TContainerBoxFn;
-/** Visible draggables */
-export declare const visibleElements: (p: IDnDProviderInternal) => Set<HTMLElement> & Omit<Set<HTMLElement>, keyof Set<any>>;
-/** Visible droppables */
-export declare const visibleZones: (p: IDnDProviderInternal) => Set<HTMLElement> & Omit<Set<HTMLElement>, keyof Set<any>>;
+/** Allowed draggables (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) */
@@ -20,8 +20,11 @@ export declare const filterValidCollisionTarget: TFilterFn;
 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 */
 export declare const sortByOverlapAndPointer: TSortCompareFn;
-//# sourceMappingURL=steps.d.ts.map

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

@@ -0,0 +1,19 @@
+/** 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;
+  rect: DOMRect;
+}
+
+export interface IScrollAdapter {
+  getScrollState(el: HTMLElement): IScrollState;
+  setScroll(el: HTMLElement, scrollTop: number, scrollLeft: number): void;
+}
+
+export type TOverlayPoint = { x: number; y: number } | null;

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

@@ -1,5 +1,6 @@
 import { Ref } from 'vue';
 import { IDnDProviderExternal } from '../../external';
+import { IAutoScrollOptions } from '../../external/types/placement';
 import { IIntersectionObserverWrapper } from './observer';
 
 
@@ -26,4 +27,4 @@ export interface IDnDProviderInternal extends IDnDProviderExternal {
     selectableAreaObserver: IIntersectionObserverWrapper;
     overlaySizeObserver: { disconnect: () => void };
   };
-}
+}

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

@@ -0,0 +1,13 @@
+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;
+};

package/dist/internal/utils/constraints.d.ts

@@ -38,4 +38,3 @@ export declare function updatePointerWithConstraints(pointer: TPointerState, raw
     width: number;
     height: number;
 } | null): void;
-//# sourceMappingURL=constraints.d.ts.map

package/dist/internal/utils/disabled.d.ts

@@ -7,4 +7,3 @@ export type IEffectivelyDisabledContext = {
 export declare const isEffectivelyDisabledDraggable: (node: HTMLElement, ctx: IEffectivelyDisabledContext) => boolean;
 /** True if node is disabled as droppable (self or inside disabled droppable). O(droppableMap.size) */
 export declare const isEffectivelyDisabledDroppable: (node: HTMLElement, ctx: IEffectivelyDisabledContext) => boolean;
-//# sourceMappingURL=disabled.d.ts.map

package/dist/internal/utils/dom.d.ts

@@ -42,4 +42,3 @@ export declare const enableInteractions: () => void;
  * Prevents default browser behavior for the event
  */
 export declare const preventEvent: (event: Event) => void;
-//# sourceMappingURL=dom.d.ts.map

package/dist/internal/utils/drag-activation.d.ts

@@ -27,4 +27,3 @@ export declare function tryStartDragIfActivationComplete(provider: IDnDProviderI
 export declare function createActivationDelayTimer(provider: IDnDProviderInternal, onComplete: () => void): {
     cancel: () => void;
 };
-//# sourceMappingURL=drag-activation.d.ts.map

package/dist/internal/utils/events.d.ts

@@ -1,10 +1,11 @@
 import { IDnDProviderInternal } from '../types/provider';
-import { IHovered } from '../../external/types/provider';
+import { IDragEvent, IHovered } from '../../external/types/provider';
 export type TSelfDragEvent = 'onSelfDragStart' | 'onSelfDragMove' | 'onSelfDragEnd' | 'onSelfDragCancel';
 /** First key from Map or undefined */
 export declare const getFirstKey: <K>(map: Map<K, unknown>) => K | undefined;
 /** Closest draggable from event target */
 export declare const getClosestDraggableFromEvent: (event: PointerEvent) => HTMLElement | null;
+export declare const getDragEvent: (provider: IDnDProviderInternal, dropZone?: HTMLElement) => IDragEvent;
 /** Triggers onSelf* for element from event if it's in draggingMap */
 export declare const triggerSelfDragFromEvent: (provider: IDnDProviderInternal, event: PointerEvent, eventName: TSelfDragEvent) => void;
 /** Triggers onSelf* only for the initiating element (event.target.closest), skip if disabled */
@@ -19,4 +20,3 @@ export declare const triggerDraggableHoverChange: (provider: IDnDProviderInterna
 export declare const triggerZoneLeave: (provider: IDnDProviderInternal, hovered: IHovered) => void;
 /** Triggers zone onLeave on drop failure, skip disabled */
 export declare const triggerDropCancelEvents: (provider: IDnDProviderInternal, hovered: IHovered) => void;
-//# sourceMappingURL=events.d.ts.map

package/dist/internal/utils/geometry.d.ts

@@ -21,4 +21,3 @@ export declare const getCenter: (box: IBoundingBox) => IPoint;
 export declare const getDistance: (pointA: IPoint, pointB: IPoint) => number;
 export declare const getOverlapPercent: (boxA: IBoundingBox, boxB: IBoundingBox) => number;
 export declare const containsPoint: (box: IBoundingBox, x: number, y: number) => boolean;
-//# sourceMappingURL=geometry.d.ts.map