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

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

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

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

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

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

@@ -0,0 +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>, props?: IDnDProviderProps): IDnDProviderInternal;

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

@@ -0,0 +1,33 @@
+import { Ref } from 'vue';
+/**
+ * Tracks element size via ResizeObserver, writes to returned ref
+ *
+ * @param elementRef - Ref to element to observe
+ * @returns { overlaySize, overlaySizeObserver } — ref with { width, height } and cleanup
+ */
+export declare const useSizeObserver: (elementRef: Ref<HTMLElement | null>) => {
+    overlaySize: Ref<{
+        height: number;
+        width: number;
+        x: number;
+        y: number;
+        readonly bottom: number;
+        readonly left: number;
+        readonly right: number;
+        readonly top: number;
+        toJSON: () => any;
+    } | null, DOMRect | {
+        height: number;
+        width: number;
+        x: number;
+        y: number;
+        readonly bottom: number;
+        readonly left: number;
+        readonly right: number;
+        readonly top: number;
+        toJSON: () => any;
+    } | null>;
+    overlaySizeObserver: {
+        disconnect: () => void;
+    };
+};

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

@@ -0,0 +1,7 @@
+import { IDnDProviderInternal } from '../types/provider';
+import { IHovered } from '../../external/types/provider';
+/** Applies collision result to hovered and triggers zone/draggable events */
+export declare const applyCollisionResultToHovered: (provider: IDnDProviderInternal, hovered: IHovered, result: {
+    elements: HTMLElement[];
+    zones: HTMLElement[];
+}) => void;

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

@@ -0,0 +1,6 @@
+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/payload.d.ts

@@ -0,0 +1,12 @@
+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;
+/**
+ * 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

@@ -0,0 +1,9 @@
+import { IDnDProviderInternal } from '../types/provider';
+export declare function handleDropAndFinish(provider: IDnDProviderInternal): Promise<boolean>;
+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

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

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

@@ -0,0 +1,7 @@
+/**
+ * Default collision: same logic as vue-dnd-box reference
+ * - Filter: AABB overlap with container (overlay)
+ * - Sort: pointer outside container → isPointerInElement + depth; else overlap % + centerDistance
+ * - Picks closest to pointer when both zone and element present
+ */
+export declare const defaultCollisionDetection: import('./sensor').CollisionDetectionFn;

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

@@ -0,0 +1,3 @@
+export * from './steps';
+export { defaultCollisionDetection } from './default-collision';
+export { createSensor, type CollisionDetectionFn, type TMergeStrategy, } from './sensor';

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

@@ -0,0 +1,68 @@
+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[];
+};
+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

@@ -0,0 +1,30 @@
+import { IDnDProviderInternal } from '../types/provider';
+import { TSortCompareFn, TFilterFn, TCollisionCheckFn, TContainerBoxFn } from './sensor';
+/** Container from overlay ref */
+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;
+/** 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) */
+export declare const filterNotDescendantOfDragged: TFilterFn;
+/** Exclude disabled draggables and zones (including those inside disabled parents) */
+export declare const filterNotDisabled: TFilterFn;
+/** Exclude: not dragging, not descendant of dragged, not disabled */
+export declare const filterValidCollisionTarget: 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 */
+export declare const sortByOverlapAndPointer: TSortCompareFn;

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/observer.d.ts

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

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

@@ -0,0 +1,40 @@
+import { IConstraintsAreaEntity, TPointerState } from '../../external/types';
+/**
+ * Finds constraint area for a draggable element
+ */
+export declare function findConstraintArea(draggable: HTMLElement, constraintsAreaMap: Map<HTMLElement, IConstraintsAreaEntity>): {
+    element: HTMLElement;
+    entity: IConstraintsAreaEntity;
+} | null;
+/**
+ * Applies axis constraint
+ */
+export declare function applyAxisConstraint(targetX: number, targetY: number, axis: 'x' | 'y' | 'both', draggableRect: DOMRect): {
+    x: number;
+    y: number;
+};
+/**
+ * Applies bounds constraint within container
+ */
+export declare function applyBoundsConstraint(targetX: number, targetY: number, axis: 'x' | 'y' | 'both', constraintRect: DOMRect, overlayRect: DOMRect): {
+    x: number;
+    y: number;
+};
+/**
+ * Calculates final overlay position with all constraints applied
+ */
+export declare function calculateConstrainedPosition(pointer: TPointerState, overlayElement: HTMLElement | null, firstDraggable: HTMLElement | null, constraintsAreaMap: Map<HTMLElement, IConstraintsAreaEntity>, overlaySizeFallback?: {
+    width: number;
+    height: number;
+} | null): {
+    x: number;
+    y: number;
+};
+/**
+ * Updates pointer.current with constraint-applied coordinates.
+ * When constraints exist, stores the "effective" position so pointer matches overlay.
+ */
+export declare function updatePointerWithConstraints(pointer: TPointerState, rawX: number, rawY: number, overlayElement: HTMLElement | null, firstDraggable: HTMLElement | null, constraintsAreaMap: Map<HTMLElement, IConstraintsAreaEntity>, overlaySizeFallback?: {
+    width: number;
+    height: number;
+} | null): void;

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

@@ -0,0 +1,9 @@
+import { IEntities } from '../../external/types';
+/** Minimal context for draggable/droppable checks */
+export type IEffectivelyDisabledContext = {
+    entities: Pick<IEntities, 'draggableMap' | 'droppableMap'>;
+};
+/** True if node is disabled as draggable (self or inside disabled draggable). O(draggableMap.size) */
+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;

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

@@ -0,0 +1,44 @@
+import { ICoordinates, TDnDNodeRef } from '../../external/types';
+/**
+ * Resolves template ref to HTMLElement (handles both element and component refs)
+ */
+export declare const getNode: (node: TDnDNodeRef) => HTMLElement | null;
+/**
+ * Checks if point (x, y) is inside rect
+ */
+export declare const containsPoint: (rect: DOMRect, x: number, y: number) => boolean;
+/**
+ * True if child is a descendant of parent (parent.contains(child) and parent !== child)
+ */
+export declare const isDescendant: (parent: HTMLElement, child: HTMLElement) => boolean;
+/**
+ * Checks if two DOMRects intersect
+ */
+export declare const checkIntersection: (rect1: DOMRect, rect2: DOMRect) => boolean;
+/**
+ * Returns true if event target is outside the container
+ */
+export declare const isNotDirectClick: (event: Event, container: HTMLElement | null) => boolean;
+/**
+ * Returns scroll direction based on cursor proximity to container edges
+ */
+export declare const getAutoScrollDirection: (coords: ICoordinates, container: HTMLElement, threshold?: number) => {
+    x: number;
+    y: number;
+};
+/**
+ * Returns true if running in browser environment
+ */
+export declare const isClient: () => boolean;
+/**
+ * Disables user interactions during drag (user-select, context menu, etc.)
+ */
+export declare const disableInteractions: () => void;
+/**
+ * Restores user interactions after drag ends
+ */
+export declare const enableInteractions: () => void;
+/**
+ * Prevents default browser behavior for the event
+ */
+export declare const preventEvent: (event: Event) => void;

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

@@ -0,0 +1,29 @@
+import { IDragActivation, TPointerState } from '../../external/types';
+import { IDnDProviderInternal } from '../types/provider';
+/**
+ * Checks if the click target is within the drag handle (if specified)
+ * @param skipHandle - when true (e.g. keyboard drag), bypass handle check
+ */
+export declare function checkDragHandle(target: HTMLElement, draggable: HTMLElement, handleSelector?: string, skipHandle?: boolean): boolean;
+/**
+ * Calculates distance progress (0-1) for activation threshold
+ */
+export declare function calculateDistanceProgress(pointer: TPointerState, distanceThreshold: IDragActivation['distance']): number;
+/**
+ * Returns true if distance threshold is met
+ */
+export declare function isDistanceThresholdPassed(pointer: TPointerState, distanceThreshold: IDragActivation['distance']): boolean;
+/**
+ * Returns true if activation conditions are met (distance + delay, respecting condition)
+ */
+export declare function isActivationComplete(distanceProgress: number, delayProgress: number, activation?: IDragActivation): boolean;
+/**
+ * If activation is complete, starts dragging. Returns true if drag was started
+ */
+export declare function tryStartDragIfActivationComplete(provider: IDnDProviderInternal): boolean;
+/**
+ * Creates RAF-based delay timer that ticks until activation is complete, then calls onComplete
+ */
+export declare function createActivationDelayTimer(provider: IDnDProviderInternal, onComplete: () => void): {
+    cancel: () => void;
+};

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

@@ -0,0 +1,22 @@
+import { IDnDProviderInternal } from '../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 */
+export declare const triggerSelfDragForElement: (provider: IDnDProviderInternal, element: HTMLElement | undefined, eventName: TSelfDragEvent) => void;
+/** Triggers onDrag* for ALL non-disabled draggable elements */
+export declare const triggerDragForAll: (provider: IDnDProviderInternal, eventName: "onDragStart" | "onDragMove" | "onDragEnd" | "onDragCancel") => void;
+/** Triggers zone onEnter/onLeave when zone changes, skip disabled zones */
+export declare const triggerZoneEnterLeave: (provider: IDnDProviderInternal, prevZone: HTMLElement | undefined, newZone: HTMLElement | undefined) => void;
+/** Triggers onHover/onLeave when hovered draggable changes, skip disabled */
+export declare const triggerDraggableHoverChange: (provider: IDnDProviderInternal, prevEl: HTMLElement | undefined, newEl: HTMLElement | undefined) => void;
+/** Triggers zone onLeave on drag end, skip disabled */
+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;

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

@@ -0,0 +1,23 @@
+/**
+ * AABB geometry utilities for collision detection
+ */
+export interface IBoundingBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+    right: number;
+    bottom: number;
+}
+export interface IPoint {
+    x: number;
+    y: number;
+}
+export declare const checkCollision: (boxA: IBoundingBox, boxB: IBoundingBox) => boolean;
+export declare const getBoundingBox: (element: HTMLElement | null) => IBoundingBox;
+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;

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

@@ -0,0 +1,19 @@
+import { IDraggableEntity, IDraggingEntity, IDroppableEntity } from '../../external/types/entities';
+/**
+ * Checks compatibility between two group sets.
+ * Used for selection area, zones, droppable, etc.
+ *
+ * - Empty array = global (compatible with any)
+ * - Otherwise requires at least one shared group
+ */
+export declare const areGroupsCompatible: (groupsA: string[], groupsB: string[]) => boolean;
+/**
+ * Фильтрует видимые зоны по группам: оставляет только те, куда можно дропнуть
+ * текущий набор перетаскиваемых (draggingMap). Внутри сам берёт ключи из draggingMap.
+ */
+export declare function filterByGroupsDroppables(visibleDroppableSet: Set<HTMLElement>, draggingMap: Map<HTMLElement, IDraggingEntity>, draggableMap: Map<HTMLElement, IDraggableEntity>, droppableMap: Map<HTMLElement, IDroppableEntity>): Set<HTMLElement>;
+/**
+ * Фильтрует видимые драгаемые по группам: оставляет только те, что в одной «доступной» группе
+ * с текущим перетаскиваемым набором (draggingMap). Когда не тянем — все видимые доступны.
+ */
+export declare function filterByGroupsDraggables(visibleDraggableSet: Set<HTMLElement>, draggingMap: Map<HTMLElement, IDraggingEntity>, draggableMap: Map<HTMLElement, IDraggableEntity>): Set<HTMLElement>;

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

@@ -0,0 +1,29 @@
+/**
+ * Hover utilities: distance from pointer to element center
+ */
+/** Distance from pointer to element center */
+export declare const getDistanceFromPointerToElement: (pointer: {
+    x: number;
+    y: number;
+}, element: HTMLElement) => number;
+/**
+ * Get element center coordinates from DOMRect
+ * Utility for inline calculations without getBoundingClientRect call
+ */
+export declare const getCenterFromRect: (rect: DOMRect) => {
+    x: number;
+    y: number;
+};
+/** Calculate distance between pointer and rect center */
+export declare const getDistanceToRectCenter: (pointer: {
+    x: number;
+    y: number;
+}, rect: DOMRect) => number;
+/** Pick closest to pointer among zone and element (by distance to center). Returns { zone?, element? } */
+export declare const pickClosestToPointer: (pointer: {
+    x: number;
+    y: number;
+}, zone: HTMLElement | undefined, element: HTMLElement | undefined) => {
+    zone?: HTMLElement;
+    element?: HTMLElement;
+};

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

@@ -0,0 +1,5 @@
+export {};
+/**
+ * Keyboard utilities for DnD Kit
+ * Reserved for future modifier key handling, shortcuts, etc.
+ */

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

@@ -0,0 +1,18 @@
+/**
+ * DnD Kit data attributes and CSS selectors
+ */
+export declare const DnDAttributes: {
+    readonly SELECT_AREA: "data-dnd-kit-select-area";
+    readonly DRAGGABLE: "data-dnd-kit-draggable";
+    readonly DROPPABLE: "data-dnd-kit-droppable";
+    readonly CONSTRAINT_AREA: "data-dnd-kit-constraint-area";
+    readonly CONTAINER: "data-dnd-kit-container";
+};
+export declare const DnDSelectors: {
+    readonly SELECT_AREA: "[data-dnd-kit-select-area]";
+    readonly DRAGGABLE: "[data-dnd-kit-draggable]";
+    readonly DROPPABLE: "[data-dnd-kit-droppable]";
+    readonly CONSTRAINT_AREA: "[data-dnd-kit-constraint-area]";
+    readonly CONTAINER: "[data-dnd-kit-container]";
+};
+export declare const injectionKey: "VueDnDKitProvider";

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

@@ -0,0 +1,27 @@
+/**
+ * Observers — IntersectionObserver (visibility) and ResizeObserver (size)
+ */
+export interface IObserverWrapper {
+    observe: (element: HTMLElement) => void;
+    unobserve: (element: HTMLElement) => void;
+    disconnect: () => void;
+}
+/**
+ * Creates an IntersectionObserver that manages a Set of visible elements
+ *
+ * @param targetSet - Set to add/remove elements
+ * @returns Object with observe/unobserve/disconnect methods
+ */
+export declare const createIntersectionObserver: (targetSet: Set<HTMLElement>) => IObserverWrapper;
+/**
+ * Creates a ResizeObserver that tracks element size and writes to target ref
+ *
+ * @param target - Ref to write { width, height } on resize
+ * @returns Object with observe/unobserve/disconnect methods
+ */
+export declare const createSizeObserver: (target: {
+    value: {
+        width: number;
+        height: number;
+    } | null;
+}) => IObserverWrapper;

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

@@ -0,0 +1,22 @@
+import { IDnDProviderExternal, IPlacement, IPlacementMargins } from '../../external';
+export interface IRect {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+}
+/**
+ * Creates pointer box from coordinates (e.g. cursor as 5×5)
+ */
+export declare const createPointerBox: (x: number, y: number, size?: number) => IRect;
+/**
+ * Creates pointer box from provider (cursor as 5×5)
+ */
+export declare const getPointerBoxFromProvider: (provider: IDnDProviderExternal) => IRect;
+/**
+ * Returns placement: which side(s) of the element the pointer is in.
+ * - If placementMargins set and pointer in center zone → center: true, top/right/bottom/left all false.
+ * - Else → center: false, and top/right/bottom/left by quadrants (e.g. top+right for top-right);
+ *   several can be true at once, only center is exclusive.
+ */
+export declare const getClosestPlacement: (pointerBox: IRect, elementRect: DOMRect, margins?: IPlacementMargins) => IPlacement;

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

@@ -0,0 +1,33 @@
+import { IDraggableEntity, IDraggingEntity, TPointerState } from '../../external/types';
+import { IDnDProviderInternal } from '../types/provider';
+/**
+ * Creates initial pointer state from event
+ */
+export declare function createPointerState(event: PointerEvent, offsetX?: number, offsetY?: number): TPointerState;
+/**
+ * Calculates cursor offset as ratio (0–1) relative to element size
+ */
+export declare function calculateCursorOffset(event: PointerEvent, element: HTMLElement): {
+    x: number;
+    y: number;
+};
+/**
+ * Creates dragging entity with initial data
+ */
+export declare function createDraggingEntity(element: HTMLElement, draggableEntity?: IDraggableEntity): IDraggingEntity;
+/**
+ * Инициализирует dragging для выбранных элементов
+ */
+export declare function initializeDraggingFromSelection(selectedSet: Set<HTMLElement>, draggableMap: Map<HTMLElement, IDraggableEntity>, draggingMap: Map<HTMLElement, IDraggingEntity>): void;
+/**
+ * Initializes dragging for single element
+ */
+export declare function initializeDraggingFromElement(element: HTMLElement, draggableMap: Map<HTMLElement, IDraggableEntity>, draggingMap: Map<HTMLElement, IDraggingEntity>): void;
+/**
+ * Starts dragging for the current provider state (initiatingDraggable + selectedSet)
+ */
+export declare function startDraggingForProvider(provider: IDnDProviderInternal): void;
+/**
+ * Initializes dragging (chooses between selection and single element)
+ */
+export declare function initializeDragging(initiatingElement: HTMLElement, selectedSet: Set<HTMLElement>, draggableMap: Map<HTMLElement, IDraggableEntity>, draggingMap: Map<HTMLElement, IDraggingEntity>): void;

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

@@ -0,0 +1,12 @@
+import { IDraggableEntity, ISelectableAreaEntity } from '../../external/types';
+import { Ref } from 'vue';
+/**
+ * Utility for filtering entities by modifier keys.
+ *
+ * @param entityMap - Map of entities (e.g. selectableAreaMap or draggableEntityMap)
+ * @param visibleSet - Set of visible nodes
+ * @param modifiers - Ref with pressed keys
+ * @param isDisabled - Optional: override disabled check (e.g. isEffectivelyDisabledDraggable for draggables)
+ * @returns Set of filtered nodes with matching modifiers
+ */
+export declare const filterByModifiers: (entityMap: Map<HTMLElement, IDraggableEntity | ISelectableAreaEntity>, visibleSet: Set<HTMLElement>, modifiers: Ref<Set<string>>, isDisabled?: (node: HTMLElement) => boolean) => Set<HTMLElement>;