@mk-drag-and-drop/dom 0.1.0

package/dist/modifiers/types.d.ts

@@ -0,0 +1,32 @@
+import type { DragPoint, DragRect } from "../geometry/rects.js";
+export type DragModifierSetupInput = {
+    draggableId: string;
+    group: string;
+    sourceRect: DragRect;
+    initialPointerPosition: DragPoint;
+};
+export type DragModifierTransformInput<State = unknown> = {
+    draggableId: string;
+    group: string;
+    sourceRect: DragRect;
+    initialPointerPosition: DragPoint;
+    rawPointerPosition: DragPoint;
+    pointerPosition: DragPoint;
+    overlayRect: DragRect;
+    state: State;
+};
+export type DragModifier<State = unknown> = {
+    setup?: (input: DragModifierSetupInput) => State;
+    transform: (input: DragModifierTransformInput<State>) => DragPoint;
+};
+type DragModifierInputTransform = {
+    bivarianceHack(input: DragModifierTransformInput<unknown>): DragPoint;
+}["bivarianceHack"];
+export type DragModifierInput = {
+    setup?: (input: DragModifierSetupInput) => unknown;
+    transform: DragModifierInputTransform;
+};
+export type ActiveDragModifier = {
+    transform: (input: Omit<DragModifierTransformInput<unknown>, "state">) => DragPoint;
+};
+export {};

package/dist/modifiers/types.js

@@ -0,0 +1 @@
+export {};

package/dist/runtime/drag-runtime-handle.d.ts

@@ -0,0 +1,22 @@
+import type { DragRect } from "../geometry/rects.js";
+import type { DomDraggableRuntime } from "../draggable/create-draggable.js";
+import type { DomDropContainerRuntime } from "../droppable/create-drop-container.js";
+import type { DomDroppableRuntime } from "../droppable/create-droppable.js";
+import type { DomSortableRuntime } from "../sortable/sortable-registry.js";
+import { type BindingCleanupRecord } from "./drag-runtime.js";
+import type { DragRuntimeConfigureInput, DragRuntimeOptions } from "./types.js";
+export type DragRuntimeHandleOptions = DragRuntimeOptions;
+export type DragRuntimeHandleConfigureInput = DragRuntimeConfigureInput;
+export type DragRuntimeHandle = DomDraggableRuntime & DomDroppableRuntime & DomDropContainerRuntime & DomSortableRuntime & {
+    configure: (input: DragRuntimeHandleConfigureInput) => void;
+    cleanup: () => void;
+    dispose: () => void;
+    onDispose: (callback: () => void) => () => void;
+    setOverlayRect: (overlayRect: DragRect | null) => void;
+};
+export type InternalBindingCleanupRuntime = {
+    registerBindingCleanup: (record: BindingCleanupRecord) => () => void;
+    pruneDisconnectedBindingCleanups: () => void;
+    getBindingCleanupRecordCount: () => number;
+};
+export declare function createDragRuntimeHandle(options?: DragRuntimeHandleOptions): DragRuntimeHandle;

package/dist/runtime/drag-runtime-handle.js

@@ -0,0 +1,33 @@
+import { DragRuntime } from "./drag-runtime.js";
+export function createDragRuntimeHandle(options) {
+    const runtime = new DragRuntime(options);
+    const handle = {
+        configure: (input) => runtime.configure(input),
+        cleanup: () => runtime.cleanup(),
+        dispose: () => runtime.dispose(),
+        setOverlayRect: (overlayRect) => runtime.setOverlayRect(overlayRect),
+        requestDragStart: (input) => runtime.requestDragStart(input),
+        isKeyboardDragEnabled: () => runtime.isKeyboardDragEnabled(),
+        handleSourceKeyboardKeyDown: (input) => runtime.handleSourceKeyboardKeyDown(input),
+        registerDropTarget: (dropTargetId, element, group, options) => {
+            runtime.registerDropTarget(dropTargetId, element, group, options);
+        },
+        unregisterDropTarget: (dropTargetId, element) => {
+            runtime.unregisterDropTarget(dropTargetId, element);
+        },
+        registerDropContainer: (containerId, element, group) => {
+            runtime.registerDropContainer(containerId, element, group);
+        },
+        unregisterDropContainer: (containerId, element) => {
+            runtime.unregisterDropContainer(containerId, element);
+        },
+        getDropTargetRegistration: (dropTargetId, group) => runtime.getDropTargetRegistration(dropTargetId, group),
+        subscribe: (subscription) => runtime.subscribe(subscription),
+        onDispose: (callback) => runtime.onDispose(callback),
+        remeasureDropTargets: (input) => runtime.remeasureDropTargets(input),
+        registerBindingCleanup: (record) => runtime.registerBindingCleanup(record),
+        pruneDisconnectedBindingCleanups: () => runtime.pruneDisconnectedBindingCleanups(),
+        getBindingCleanupRecordCount: () => runtime.getBindingCleanupRecordCount(),
+    };
+    return handle;
+}

package/dist/runtime/drag-runtime.d.ts

@@ -0,0 +1,96 @@
+import type { DragRect } from "../geometry/rects.js";
+import { type KeyboardMoveDirection, type SourceKeyboardDragKeyDownInput as KeyboardSourceKeyDownInput } from "../input/keyboard-drag.js";
+import { type DragGroup, type RegisterDropTargetOptions, type RemeasureDropTargetsInput } from "./drop-target-registry.js";
+import type { DragRuntimeSubscription } from "./lifecycle.js";
+import type { DragRuntimeConfigureInput, DragRuntimeOptions, Point, RequestDragStartInput, RequestKeyboardDragStartInput } from "./types.js";
+export type BindingCleanupRecord = {
+    cleanup: () => void;
+    isConnected: () => boolean;
+};
+export declare class DragRuntime {
+    isDragging: boolean;
+    draggedId: string | null;
+    draggedGroup: DragGroup | null;
+    pointerPosition: Point | null;
+    activeDropTargetId: string | null;
+    private session;
+    private modifiers;
+    private activeDragModifiers;
+    private cleanupWindowListeners;
+    private cleanupTextSelectionSuppression;
+    private queuedPointerPosition;
+    private pointerFrameId;
+    private subscriptions;
+    private disposeCallbacks;
+    private bindingCleanupRecords;
+    private lifecycleCallbacks;
+    private lifecycleHelpers;
+    private lifecycleDropTargetRectSnapshot;
+    private dropTargetRegistry;
+    private pointerConfiguration;
+    private keyboardConfiguration;
+    private updateOverlayHost;
+    private targetingAlgorithm;
+    private hasDragOverlay;
+    private keepOverlayOnDrop;
+    private targetingConstraint;
+    private pointerActivation;
+    private keyboardDrag;
+    constructor(options?: DragRuntimeOptions);
+    configure(input: DragRuntimeConfigureInput): void;
+    requestDragStart(input: RequestDragStartInput): void;
+    isKeyboardDragEnabled(): boolean;
+    handleSourceKeyboardKeyDown(input: KeyboardSourceKeyDownInput): boolean;
+    requestKeyboardDragStart(input: RequestKeyboardDragStartInput): void;
+    moveKeyboardDrag(direction: KeyboardMoveDirection): void;
+    updatePointer(rawPointerPosition: Point): void;
+    private updatePointerNow;
+    endDrag(): void;
+    cancelDrag(): void;
+    registerDropTarget(dropTargetId: string, element: HTMLElement, group: DragGroup, options?: RegisterDropTargetOptions): void;
+    unregisterDropTarget(dropTargetId: string, element?: HTMLElement): void;
+    registerDropContainer(containerId: string, element: HTMLElement, group: DragGroup): void;
+    unregisterDropContainer(containerId: string, element?: HTMLElement): void;
+    cleanup(): void;
+    getDropTargetRect(dropTargetId: string): DragRect | null;
+    getDropTargetRegistration(dropTargetId: string, group?: DragGroup): import("./drop-target-registry.js").DropTargetRegistration | null;
+    getCurrentDragRect(): DragRect | null;
+    setOverlayRect(overlayRect: DragRect | null): void;
+    remeasureDropTargets(input?: RemeasureDropTargetsInput): void;
+    subscribe(subscription: DragRuntimeSubscription): () => void;
+    onDispose(callback: () => void): () => void;
+    registerBindingCleanup(record: BindingCleanupRecord): () => void;
+    pruneDisconnectedBindingCleanups(): void;
+    getBindingCleanupRecordCount(): number;
+    dispose(): void;
+    private startDragNow;
+    private finishDrag;
+    private bindPointerWindowListeners;
+    private bindKeyboardWindowListeners;
+    private suppressTextSelection;
+    private resetActiveDragState;
+    private cleanupActiveDragResources;
+    private flushQueuedPointerUpdate;
+    private cancelQueuedPointerUpdate;
+    private setSession;
+    private syncPublicDragFields;
+    private getActiveInput;
+    private getDraggingSession;
+    private getDropEventSortablePlacement;
+    private createDragState;
+    private getLifecycleDropTargetRect;
+    private createLifecycleDropTargetRectSnapshot;
+    private getActiveDropTargetId;
+    private getSortablePlacementPosition;
+    private getAvailableDropTargets;
+    private getCurrentDragRectAt;
+    private removeDisconnectedDropTargets;
+    private pruneDisconnectedBindingCleanupRecords;
+    private disposeBindingCleanupRecords;
+    private clearActiveDropTargetIdIfRemoved;
+    private notifyDragStart;
+    private notifyDragUpdate;
+    private notifyDragEnd;
+    private notifyDrop;
+}
+export declare function createDragRuntime(options?: DragRuntimeOptions): DragRuntime;