cursedbelt 0.0.0 → 2.3.0

package/dist/react/hooks/pointerDnd.js

@@ -0,0 +1,319 @@
+/**
+ * Touch bridge for the native-DnD engine.
+ *
+ * pragmatic-drag-and-drop rides the browser's native HTML Drag-and-Drop API, which
+ * fires NO events for touch input (see {@link ./pragmaticDnd}). This module supplies the
+ * missing half: a small pointer-events drag driver that reproduces pragmatic's drop
+ * target + monitor shapes, so a **touch** drag flows through the SAME registered drop
+ * targets, the SAME per-target `isOver` feedback, and the SAME monitor subscribers as a
+ * mouse drag. The seam's consumers (`usePaletteDrag`, and the reorder / free-move hooks
+ * as they migrate off `@dnd-kit`) therefore get touch for free — the engine underneath
+ * them just gained the input mode the native API can't reach.
+ *
+ * It is split into a **pure core** (`withinTolerance`, `collectDropTargets`,
+ * `createTouchDragSession`) that the specs drive directly with plain coordinates, and a
+ * thin DOM/timer wiring (`wireTouchDragSource`) on top. Activation matches the retired
+ * `@dnd-kit` `TouchSensor` exactly: a 250 ms long-press with a 5 px tolerance, so a
+ * quick tap stays a tap and a scroll stays a scroll — only a deliberate hold starts a
+ * drag.
+ */
+/** Long-press activation defaults — the WCAG-recommended values the retired `@dnd-kit`
+ *  `TouchSensor` used, kept identical so touch feel does not change across the swap. */
+export const TOUCH_ACTIVATION_DELAY_MS = 250;
+export const TOUCH_ACTIVATION_TOLERANCE_PX = 5;
+/**
+ * Did the pointer stay inside the `tolerance` box around `origin`? A finger that drifts
+ * past it before the long-press delay elapses is a scroll/pan, not a drag, so the
+ * pending activation is abandoned. Pure.
+ */
+export function withinTolerance(origin, point, tolerance) {
+    return Math.abs(point.x - origin.x) <= tolerance && Math.abs(point.y - origin.y) <= tolerance;
+}
+/**
+ * Pick the drop targets under a pointer. `stack` is the raw hit-test result
+ * (`document.elementsFromPoint`, topmost/innermost first); we keep every registered
+ * target in that stack whose `canDrop` passes, preserving the innermost→outermost
+ * "bubble" order pragmatic's `location.dropTargets` uses (so `dropTargets[0]` is the
+ * innermost, exactly as the native adapter reports it). Pure — the specs feed it a
+ * synthetic stack, no real layout engine required.
+ */
+export function collectDropTargets(stack, registry, feedback) {
+    const records = [];
+    for (const element of stack) {
+        const entry = registry.get(element);
+        if (!entry)
+            continue;
+        const args = { ...feedback, element };
+        if (!entry.canDrop(args))
+            continue;
+        records.push({
+            element,
+            data: entry.getData(args),
+            dropEffect: 'move',
+            isActiveDueToStickiness: false,
+        });
+    }
+    return records;
+}
+// --- Shared registry ---------------------------------------------------------------
+const dropTargetRegistry = new Map();
+/**
+ * Register a drop target for touch hit-testing. The seam's `useDropTargetElement` calls
+ * this alongside its pragmatic registration, passing the SAME `getData`/`canDrop`
+ * wrappers, so a touch drag and a mouse drag resolve targets identically.
+ */
+export function registerPointerDropTarget(entry) {
+    dropTargetRegistry.set(entry.element, entry);
+    return () => {
+        // Only delete if we're still the registered entry, guarding a re-register race.
+        if (dropTargetRegistry.get(entry.element) === entry)
+            dropTargetRegistry.delete(entry.element);
+    };
+}
+const monitorListeners = new Set();
+/** Subscribe to touch drags. `monitorForDrags` (in the seam) uses this to fold touch
+ *  events into the same stream mouse drags flow through. */
+export function subscribePointerDragMonitor(listener) {
+    monitorListeners.add(listener);
+    return () => {
+        monitorListeners.delete(listener);
+    };
+}
+function emitToMonitors(event) {
+    // Snapshot so a listener that unsubscribes mid-dispatch cannot skip a sibling.
+    for (const listener of [...monitorListeners])
+        listener(event);
+}
+function makeInput(x, y) {
+    return {
+        altKey: false,
+        button: 0,
+        buttons: 1,
+        ctrlKey: false,
+        metaKey: false,
+        shiftKey: false,
+        clientX: x,
+        clientY: y,
+        pageX: x,
+        pageY: y,
+    };
+}
+/**
+ * The pure long-press → drag → drop state machine, with no DOM or timer dependency of
+ * its own (both are injected). `pointerDown` starts a pending long-press; a move past
+ * the tolerance (or an early up) abandons it as a scroll/tap; once the scheduled delay
+ * fires the drag activates, subsequent moves re-run the hit-test and toggle each
+ * target's `isOver`, and `pointerUp`/`cancel` emit the terminal drop.
+ */
+export function createTouchDragSession(cfg) {
+    let phase = 'idle';
+    let origin = { x: 0, y: 0 };
+    let cancelActivation = null;
+    let source = null;
+    let initial = null;
+    const overElements = new Set();
+    const locationAt = (point) => {
+        const input = makeInput(point.x, point.y);
+        const feedback = {
+            input,
+            source: source,
+            element: cfg.element,
+        };
+        const dropTargets = collectDropTargets(cfg.hitTest(point.x, point.y), cfg.registry, feedback);
+        return { input, dropTargets };
+    };
+    const syncOver = (dropTargets) => {
+        const next = new Set(dropTargets.map((t) => t.element));
+        for (const element of overElements) {
+            if (!next.has(element)) {
+                cfg.registry.get(element)?.setOver(false);
+                overElements.delete(element);
+            }
+        }
+        for (const element of next) {
+            if (!overElements.has(element)) {
+                cfg.registry.get(element)?.setOver(true);
+                overElements.add(element);
+            }
+        }
+    };
+    const clearOver = () => {
+        for (const element of overElements)
+            cfg.registry.get(element)?.setOver(false);
+        overElements.clear();
+    };
+    const reset = () => {
+        cancelActivation?.();
+        cancelActivation = null;
+        phase = 'idle';
+        source = null;
+        initial = null;
+    };
+    const activate = () => {
+        cancelActivation = null;
+        phase = 'active';
+        source = { element: cfg.element, dragHandle: cfg.element, data: cfg.getInitialData() };
+        initial = locationAt(origin);
+        syncOver(initial.dropTargets);
+        cfg.onActivate();
+        cfg.emit({ phase: 'start', source, initial, current: initial });
+    };
+    const finish = (current) => {
+        cfg.emit({
+            phase: 'drop',
+            source: source,
+            initial: initial,
+            current,
+        });
+        clearOver();
+        reset();
+        cfg.onEnd();
+    };
+    return {
+        isActive: () => phase === 'active',
+        status: () => phase,
+        pointerDown(point) {
+            if (phase !== 'idle')
+                return;
+            origin = { x: point.x, y: point.y };
+            phase = 'pending';
+            cancelActivation = cfg.schedule(activate, cfg.delayMs);
+        },
+        pointerMove(point) {
+            if (phase === 'pending') {
+                // Drift past the tolerance before activation → the user is scrolling, not dragging.
+                if (!withinTolerance(origin, point, cfg.tolerancePx))
+                    reset();
+                return;
+            }
+            if (phase !== 'active' || !source || !initial)
+                return;
+            const current = locationAt(point);
+            syncOver(current.dropTargets);
+            cfg.emit({ phase: 'drag', source, initial, current });
+        },
+        pointerUp(point) {
+            if (phase === 'pending') {
+                reset(); // lifted before the long-press elapsed → a tap
+                return;
+            }
+            if (phase !== 'active')
+                return;
+            finish(locationAt(point));
+        },
+        cancel() {
+            if (phase === 'pending') {
+                reset();
+                return;
+            }
+            if (phase !== 'active')
+                return;
+            // A cancel (Escape / pointercancel) ends on no drop target, so consumers roll back.
+            finish({ input: makeInput(origin.x, origin.y), dropTargets: [] });
+        },
+    };
+}
+function elementsFromPointSafe(x, y) {
+    if (typeof document === 'undefined' || typeof document.elementsFromPoint !== 'function')
+        return [];
+    return document.elementsFromPoint(x, y);
+}
+/**
+ * Wire touch-drag onto one draggable element, using the shared registry + monitor bus.
+ * Only `touch` pointers are handled — mouse/pen still drive pragmatic's native adapter,
+ * so the two engines never fight over the same gesture. Sets `touch-action: none` on the
+ * element while wired (restored on cleanup) so a long-press isn't stolen by the browser's
+ * scroll/gesture handling — the same guard the `@dnd-kit` sensors relied on.
+ *
+ * The `pointerdown` listener lives on the element; the `pointermove`/`up`/`cancel`/
+ * `keydown` listeners are only attached on the `window` for the life of one interaction
+ * (from touch-down until the drag ends or the long-press is abandoned). So a board with
+ * hundreds of draggables adds hundreds of cheap per-element listeners but ZERO always-on
+ * global ones — the same "no idle global listeners" property `@dnd-kit`'s single sensor had.
+ *
+ * Returns a cleanup that cancels any in-flight drag and removes every listener.
+ */
+export function wireTouchDragSource(config) {
+    const { element } = config;
+    const session = createTouchDragSession({
+        element,
+        getInitialData: config.getInitialData,
+        hitTest: elementsFromPointSafe,
+        registry: dropTargetRegistry,
+        emit: emitToMonitors,
+        onActivate: () => config.onDragStateChange(true),
+        onEnd: () => config.onDragStateChange(false),
+        delayMs: config.delayMs ?? TOUCH_ACTIVATION_DELAY_MS,
+        tolerancePx: config.tolerancePx ?? TOUCH_ACTIVATION_TOLERANCE_PX,
+        schedule: (callback, ms) => {
+            const id = window.setTimeout(callback, ms);
+            return () => window.clearTimeout(id);
+        },
+    });
+    let activePointerId = null;
+    const onPointerMove = (event) => {
+        if (event.pointerId !== activePointerId)
+            return;
+        // Once dragging, suppress the browser's scroll so the finger drives the drag.
+        if (session.isActive() && event.cancelable)
+            event.preventDefault();
+        session.pointerMove({ x: event.clientX, y: event.clientY });
+        if (session.status() === 'idle')
+            detach(); // a pre-activation move was a scroll
+    };
+    const onPointerUp = (event) => {
+        if (event.pointerId !== activePointerId)
+            return;
+        session.pointerUp({ x: event.clientX, y: event.clientY });
+        detach();
+    };
+    const onPointerCancel = (event) => {
+        if (event.pointerId !== activePointerId)
+            return;
+        session.cancel();
+        detach();
+    };
+    const onKeyDown = (event) => {
+        if (event.key === 'Escape') {
+            session.cancel();
+            detach();
+        }
+    };
+    function detach() {
+        if (activePointerId === null)
+            return;
+        activePointerId = null;
+        window.removeEventListener('pointermove', onPointerMove);
+        window.removeEventListener('pointerup', onPointerUp);
+        window.removeEventListener('pointercancel', onPointerCancel);
+        window.removeEventListener('keydown', onKeyDown);
+    }
+    const onPointerDown = (event) => {
+        if (event.pointerType !== 'touch' || !event.isPrimary || activePointerId !== null)
+            return;
+        activePointerId = event.pointerId;
+        if (typeof element.setPointerCapture === 'function') {
+            try {
+                element.setPointerCapture(event.pointerId);
+            }
+            catch {
+                // capture unavailable (e.g. happy-dom) — window listeners still track the drag
+            }
+        }
+        window.addEventListener('pointermove', onPointerMove, { passive: false });
+        window.addEventListener('pointerup', onPointerUp);
+        window.addEventListener('pointercancel', onPointerCancel);
+        window.addEventListener('keydown', onKeyDown);
+        session.pointerDown({ x: event.clientX, y: event.clientY });
+    };
+    const prevTouchAction = element.style.touchAction;
+    element.style.touchAction = 'none';
+    element.addEventListener('pointerdown', onPointerDown);
+    return () => {
+        session.cancel();
+        detach();
+        element.style.touchAction = prevTouchAction;
+        element.removeEventListener('pointerdown', onPointerDown);
+    };
+}
+//# sourceMappingURL=pointerDnd.js.map

package/dist/react/hooks/pointerDnd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointerDnd.js","sourceRoot":"","sources":["../../../src/react/hooks/pointerDnd.ts"],"names":[],"mappings":"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"}

package/dist/react/hooks/pragmaticDnd.d.ts

@@ -0,0 +1,118 @@
+import { combine } from '@atlaskit/pragmatic-drag-and-drop/combine';
+import { draggable, dropTargetForElements, type ElementDropTargetGetFeedbackArgs, type ElementMonitorGetFeedbackArgs, monitorForElements } from '@atlaskit/pragmatic-drag-and-drop/element/adapter';
+import { disableNativeDragPreview } from '@atlaskit/pragmatic-drag-and-drop/element/disable-native-drag-preview';
+import type { CleanupFn } from '@atlaskit/pragmatic-drag-and-drop/types';
+import { attachClosestEdge, type Edge, extractClosestEdge } from '@atlaskit/pragmatic-drag-and-drop-hitbox/closest-edge';
+import { getReorderDestinationIndex } from '@atlaskit/pragmatic-drag-and-drop-hitbox/util/get-reorder-destination-index';
+/**
+ * The one place cursedbelt talks to the drag engine.
+ *
+ * The public drag hooks (`usePaletteItem`/`useDropSlot`, and — as they migrate —
+ * `useDragReorder`/`useCrossContainerDrag`/`useDragToMove`) are the *insulation
+ * layer*: an app calls those and never sees the engine. This module is the seam
+ * underneath them — it wraps `@atlaskit/pragmatic-drag-and-drop`'s imperative
+ * element adapter (register-on-a-DOM-node, cleanup-on-unmount) into the React
+ * ref+state ergonomics the hooks expect. Swapping engines again later means
+ * rewriting this file, not the hooks.
+ *
+ * Engine note: pragmatic-drag-and-drop is built on the **native HTML Drag and Drop
+ * API**. That gives us Apache-2.0 licensing and Atlassian's active stewardship, but
+ * the native API is pointer/mouse only — it fires no drag events from touch, and
+ * offers no keyboard drag. Two bridges in the seam close that gap so a swap to this
+ * engine is not a mobile-first / accessibility regression:
+ *
+ * - **Touch** ({@link ./pointerDnd}) — a long-press pointer driver that feeds the SAME
+ *   registered drop targets + monitor as a mouse drag; wired in here so every
+ *   `useDraggableElement` / `useDropTargetElement` gains touch automatically, and
+ *   surfaced to monitors through {@link monitorForDrags}.
+ * - **Keyboard** ({@link ./keyboardDnd}) — a WCAG 2.1.1 lift/move/drop affordance the
+ *   reorder + free-move hooks drive into the same reorder commit as a pointer drop.
+ */
+export type { CleanupFn, Edge, ElementDropTargetGetFeedbackArgs, ElementMonitorGetFeedbackArgs };
+export { attachClosestEdge, combine, disableNativeDragPreview, draggable, dropTargetForElements, extractClosestEdge, getReorderDestinationIndex, monitorForElements, };
+/**
+ * The reorder + kanban hooks use Atlassian's **hitbox** ({@link attachClosestEdge}/
+ * {@link extractClosestEdge}/{@link getReorderDestinationIndex}) for insertion instead
+ * of hand-rolled geometry: a drop target attaches the pointer's closest edge inside its
+ * `getData`, so the SAME edge flows through the native adapter (mouse/pen) AND the touch
+ * bridge's {@link ./pointerDnd} `collectDropTargets` (both call `getData` with `input` +
+ * `element`). A monitor reads it back with `extractClosestEdge` to drive a themed
+ * {@link ../components/DropIndicator} and compute the drop index — one edge model across
+ * every input engine. Kept in this seam so the hooks never import the engine directly.
+ */
+/**
+ * Walk up from `start` to the nearest scrollable ancestor (the element a drag near its
+ * edge should auto-scroll). Returns `null` when none is found (e.g. a page-scrolling
+ * list, SSR, or happy-dom where `overflow` is unset) so the caller can no-op rather than
+ * hijack window scroll. Layout-only + guarded, so it is inert under the render specs.
+ */
+export declare function findScrollContainer(start: Element | null): Element | null;
+/** Register `element` as an auto-scroll container for the drag engine (ref-counted). */
+export declare function registerAutoScroll(element: Element): CleanupFn;
+/**
+ * Register auto-scroll on the nearest scrollable ancestor of one draggable/droppable row,
+ * so dragging a list/board item toward the edge of its scroll container scrolls it into
+ * range. No-ops when there is no scrollable ancestor. Returns the cleanup to combine into
+ * the row's drag-registration effect.
+ */
+export declare function registerRowAutoScroll(rowEl: Element | null): CleanupFn;
+/** Data collected off the source being dragged (a pragmatic `getInitialData` result). */
+export type DragData = Record<string, unknown>;
+export interface DraggableElementOptions {
+    /** Turn dragging off without unmounting the element. */
+    disabled?: boolean;
+    /** Data attached to the drag, read back by drop targets + the monitor on drop. */
+    getInitialData?: () => DragData;
+    /** Suppress the browser's native drag image (when a custom overlay renders instead). */
+    disableNativePreview?: boolean;
+}
+export interface DraggableElementResult {
+    /** Ref callback for the element to make draggable. */
+    setRef: (el: HTMLElement | null) => void;
+    /** Optional ref callback for a drag-handle sub-element. When provided, the drag
+     *  can only be initiated from that element (the rest of the row stays clickable). */
+    setHandleRef: (el: HTMLElement | null) => void;
+    isDragging: boolean;
+}
+/**
+ * Make one element draggable. Handles the pragmatic register-in-an-effect /
+ * cleanup-on-unmount dance and surfaces `isDragging` as React state. Live options
+ * are read through a ref so changing a handler doesn't re-register mid-interaction.
+ *
+ * Mouse/pen go through pragmatic's native adapter; **touch** is added by the pointer
+ * bridge ({@link wireTouchDragSource}) so a long-press drag works on mobile too. The
+ * two never fight — the bridge only handles `touch` pointers, the native adapter only
+ * fires for mouse/pen — and both flip the same `isDragging` state.
+ */
+export declare function useDraggableElement(options: DraggableElementOptions): DraggableElementResult;
+export interface DropTargetElementOptions {
+    disabled?: boolean;
+    /** Data collected for this drop target (e.g. its slot id), read on drop. */
+    getData?: (args: ElementDropTargetGetFeedbackArgs) => DragData;
+    /** Reject incompatible drags. When it returns `false`, `isOver` never lights up
+     *  (pragmatic won't treat the element as an active target). */
+    canDrop?: (args: ElementDropTargetGetFeedbackArgs) => boolean;
+}
+export interface DropTargetElementResult {
+    setRef: (el: HTMLElement | null) => void;
+    /** `true` only while a *droppable* drag is directly over this element. */
+    isOver: boolean;
+}
+/**
+ * Make one element a drop target. `isOver` reflects a compatible hover only —
+ * `canDrop` gating happens inside the engine, so an incompatible drag never sets it.
+ *
+ * Registered with pragmatic (mouse/pen) AND the pointer bridge's registry (touch),
+ * using the SAME `getData`/`canDrop`, so both input modes resolve the target — and its
+ * `isOver` — identically.
+ */
+export declare function useDropTargetElement(options: DropTargetElementOptions): DropTargetElementResult;
+/**
+ * A drag monitor over BOTH input engines. Takes the same options as pragmatic's
+ * `monitorForElements` and additionally forwards **touch** drags (from the pointer
+ * bridge) through the same `canMonitor` gate and `onDragStart`/`onDrag`/`onDrop`
+ * callbacks — so a monitor written once reacts to mouse and touch alike. This is what
+ * the seam hooks (e.g. `usePaletteDrag`) use instead of `monitorForElements` directly.
+ */
+export declare function monitorForDrags(args: Parameters<typeof monitorForElements>[0]): CleanupFn;
+//# sourceMappingURL=pragmaticDnd.d.ts.map

package/dist/react/hooks/pragmaticDnd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pragmaticDnd.d.ts","sourceRoot":"","sources":["../../../src/react/hooks/pragmaticDnd.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,2CAA2C,CAAC;AACpE,OAAO,EACL,SAAS,EACT,qBAAqB,EACrB,KAAK,gCAAgC,EACrC,KAAK,6BAA6B,EAClC,kBAAkB,EACnB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAAE,wBAAwB,EAAE,MAAM,uEAAuE,CAAC;AACjH,OAAO,KAAK,EAEV,SAAS,EAGV,MAAM,yCAAyC,CAAC;AAEjD,OAAO,EACL,iBAAiB,EACjB,KAAK,IAAI,EACT,kBAAkB,EACnB,MAAM,uDAAuD,CAAC;AAC/D,OAAO,EAAE,0BAA0B,EAAE,MAAM,6EAA6E,CAAC;AAQzH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,YAAY,EAAE,SAAS,EAAE,IAAI,EAAE,gCAAgC,EAAE,6BAA6B,EAAE,CAAC;AACjG,OAAO,EACL,iBAAiB,EACjB,OAAO,EACP,wBAAwB,EACxB,SAAS,EACT,qBAAqB,EACrB,kBAAkB,EAClB,0BAA0B,EAC1B,kBAAkB,GACnB,CAAC;AAEF;;;;;;;;;GASG;AAIH;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,GAAG,OAAO,GAAG,IAAI,CAgBzE;AAMD,wFAAwF;AACxF,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,CAgB9D;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,GAAG,SAAS,CAItE;AAED,yFAAyF;AACzF,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE/C,MAAM,WAAW,uBAAuB;IACtC,wDAAwD;IACxD,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,kFAAkF;IAClF,cAAc,CAAC,EAAE,MAAM,QAAQ,CAAC;IAChC,wFAAwF;IACxF,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAED,MAAM,WAAW,sBAAsB;IACrC,sDAAsD;IACtD,MAAM,EAAE,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI,KAAK,IAAI,CAAC;IACzC;yFACqF;IACrF,YAAY,EAAE,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI,KAAK,IAAI,CAAC;IAC/C,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,uBAAuB,GAAG,sBAAsB,CAgC5F;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,4EAA4E;IAC5E,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,gCAAgC,KAAK,QAAQ,CAAC;IAC/D;mEAC+D;IAC/D,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,gCAAgC,KAAK,OAAO,CAAC;CAC/D;AAED,MAAM,WAAW,uBAAuB;IACtC,MAAM,EAAE,CAAC,EAAE,EAAE,WAAW,GAAG,IAAI,KAAK,IAAI,CAAC;IACzC,0EAA0E;IAC1E,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,wBAAwB,GAAG,uBAAuB,CAkC/F;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,CAwCzF"}

package/dist/react/hooks/pragmaticDnd.js

@@ -0,0 +1,213 @@
+import { combine } from '@atlaskit/pragmatic-drag-and-drop/combine';
+import { draggable, dropTargetForElements, monitorForElements, } from '@atlaskit/pragmatic-drag-and-drop/element/adapter';
+import { disableNativeDragPreview } from '@atlaskit/pragmatic-drag-and-drop/element/disable-native-drag-preview';
+import { autoScrollForElements } from '@atlaskit/pragmatic-drag-and-drop-auto-scroll/element';
+import { attachClosestEdge, extractClosestEdge, } from '@atlaskit/pragmatic-drag-and-drop-hitbox/closest-edge';
+import { getReorderDestinationIndex } from '@atlaskit/pragmatic-drag-and-drop-hitbox/util/get-reorder-destination-index';
+import { useEffect, useRef, useState } from 'react';
+import { registerPointerDropTarget, subscribePointerDragMonitor, wireTouchDragSource, } from './pointerDnd';
+export { attachClosestEdge, combine, disableNativeDragPreview, draggable, dropTargetForElements, extractClosestEdge, getReorderDestinationIndex, monitorForElements, };
+/**
+ * The reorder + kanban hooks use Atlassian's **hitbox** ({@link attachClosestEdge}/
+ * {@link extractClosestEdge}/{@link getReorderDestinationIndex}) for insertion instead
+ * of hand-rolled geometry: a drop target attaches the pointer's closest edge inside its
+ * `getData`, so the SAME edge flows through the native adapter (mouse/pen) AND the touch
+ * bridge's {@link ./pointerDnd} `collectDropTargets` (both call `getData` with `input` +
+ * `element`). A monitor reads it back with `extractClosestEdge` to drive a themed
+ * {@link ../components/DropIndicator} and compute the drop index — one edge model across
+ * every input engine. Kept in this seam so the hooks never import the engine directly.
+ */
+// --- Auto-scroll -----------------------------------------------------------------
+/**
+ * Walk up from `start` to the nearest scrollable ancestor (the element a drag near its
+ * edge should auto-scroll). Returns `null` when none is found (e.g. a page-scrolling
+ * list, SSR, or happy-dom where `overflow` is unset) so the caller can no-op rather than
+ * hijack window scroll. Layout-only + guarded, so it is inert under the render specs.
+ */
+export function findScrollContainer(start) {
+    if (typeof window === 'undefined' || typeof window.getComputedStyle !== 'function')
+        return null;
+    let el = start?.parentElement ?? null;
+    const { body, documentElement } = document;
+    while (el && el !== body && el !== documentElement) {
+        let overflow = '';
+        try {
+            const s = window.getComputedStyle(el);
+            overflow = `${s.overflow}${s.overflowY}${s.overflowX}`;
+        }
+        catch {
+            overflow = '';
+        }
+        if (/(auto|scroll|overlay)/.test(overflow))
+            return el;
+        el = el.parentElement;
+    }
+    return null;
+}
+// Ref-count registrations so N rows sharing one scroll container register the engine's
+// auto-scroll exactly ONCE (double-registering would compound the scroll velocity).
+const autoScrollRegistry = new Map();
+/** Register `element` as an auto-scroll container for the drag engine (ref-counted). */
+export function registerAutoScroll(element) {
+    const existing = autoScrollRegistry.get(element);
+    if (existing)
+        existing.count += 1;
+    else
+        autoScrollRegistry.set(element, { count: 1, cleanup: autoScrollForElements({ element }) });
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        const entry = autoScrollRegistry.get(element);
+        if (!entry)
+            return;
+        entry.count -= 1;
+        if (entry.count <= 0) {
+            entry.cleanup();
+            autoScrollRegistry.delete(element);
+        }
+    };
+}
+/**
+ * Register auto-scroll on the nearest scrollable ancestor of one draggable/droppable row,
+ * so dragging a list/board item toward the edge of its scroll container scrolls it into
+ * range. No-ops when there is no scrollable ancestor. Returns the cleanup to combine into
+ * the row's drag-registration effect.
+ */
+export function registerRowAutoScroll(rowEl) {
+    const container = findScrollContainer(rowEl);
+    if (!container)
+        return () => { };
+    return registerAutoScroll(container);
+}
+/**
+ * Make one element draggable. Handles the pragmatic register-in-an-effect /
+ * cleanup-on-unmount dance and surfaces `isDragging` as React state. Live options
+ * are read through a ref so changing a handler doesn't re-register mid-interaction.
+ *
+ * Mouse/pen go through pragmatic's native adapter; **touch** is added by the pointer
+ * bridge ({@link wireTouchDragSource}) so a long-press drag works on mobile too. The
+ * two never fight — the bridge only handles `touch` pointers, the native adapter only
+ * fires for mouse/pen — and both flip the same `isDragging` state.
+ */
+export function useDraggableElement(options) {
+    const { disabled } = options;
+    const [element, setElement] = useState(null);
+    const [handleElement, setHandleElement] = useState(null);
+    const [isDragging, setIsDragging] = useState(false);
+    const optsRef = useRef(options);
+    optsRef.current = options;
+    useEffect(() => {
+        if (!element || disabled)
+            return;
+        const cleanupNative = draggable({
+            element,
+            dragHandle: handleElement ?? undefined,
+            getInitialData: () => optsRef.current.getInitialData?.() ?? {},
+            onGenerateDragPreview: ({ nativeSetDragImage }) => {
+                if (optsRef.current.disableNativePreview)
+                    disableNativeDragPreview({ nativeSetDragImage });
+            },
+            onDragStart: () => setIsDragging(true),
+            onDrop: () => setIsDragging(false),
+        });
+        const cleanupTouch = wireTouchDragSource({
+            element: handleElement ?? element,
+            getInitialData: () => optsRef.current.getInitialData?.() ?? {},
+            onDragStateChange: setIsDragging,
+        });
+        return () => {
+            cleanupNative();
+            cleanupTouch();
+        };
+    }, [element, handleElement, disabled]);
+    return { setRef: setElement, setHandleRef: setHandleElement, isDragging };
+}
+/**
+ * Make one element a drop target. `isOver` reflects a compatible hover only —
+ * `canDrop` gating happens inside the engine, so an incompatible drag never sets it.
+ *
+ * Registered with pragmatic (mouse/pen) AND the pointer bridge's registry (touch),
+ * using the SAME `getData`/`canDrop`, so both input modes resolve the target — and its
+ * `isOver` — identically.
+ */
+export function useDropTargetElement(options) {
+    const { disabled } = options;
+    const [element, setElement] = useState(null);
+    const [isOver, setIsOver] = useState(false);
+    const optsRef = useRef(options);
+    optsRef.current = options;
+    useEffect(() => {
+        if (!element || disabled)
+            return;
+        const getData = (args) => optsRef.current.getData?.(args) ?? {};
+        const canDrop = (args) => optsRef.current.canDrop?.(args) ?? true;
+        const cleanupNative = dropTargetForElements({
+            element,
+            getData,
+            canDrop,
+            onDragEnter: () => setIsOver(true),
+            onDragLeave: () => setIsOver(false),
+            onDrop: () => setIsOver(false),
+        });
+        const cleanupPointer = registerPointerDropTarget({
+            element,
+            getData,
+            canDrop,
+            setOver: setIsOver,
+        });
+        return () => {
+            cleanupNative();
+            cleanupPointer();
+        };
+    }, [element, disabled]);
+    return { setRef: setElement, isOver };
+}
+/**
+ * A drag monitor over BOTH input engines. Takes the same options as pragmatic's
+ * `monitorForElements` and additionally forwards **touch** drags (from the pointer
+ * bridge) through the same `canMonitor` gate and `onDragStart`/`onDrag`/`onDrop`
+ * callbacks — so a monitor written once reacts to mouse and touch alike. This is what
+ * the seam hooks (e.g. `usePaletteDrag`) use instead of `monitorForElements` directly.
+ */
+export function monitorForDrags(args) {
+    const cleanupNative = monitorForElements(args);
+    // The touch stream is separate, so mirror pragmatic's per-drag `canMonitor` decision:
+    // decide once at `start`, then honor it for that drag's `drag`/`drop` events.
+    let monitoring = false;
+    let previousDropTargets = [];
+    const cleanupTouch = subscribePointerDragMonitor((event) => {
+        if (event.phase === 'start') {
+            monitoring = args.canMonitor
+                ? args.canMonitor({ initial: event.initial, source: event.source })
+                : true;
+            previousDropTargets = [];
+        }
+        if (!monitoring)
+            return;
+        const payload = {
+            source: event.source,
+            location: {
+                initial: event.initial,
+                current: event.current,
+                previous: { dropTargets: previousDropTargets },
+            },
+        };
+        previousDropTargets = event.current.dropTargets;
+        if (event.phase === 'start')
+            args.onDragStart?.(payload);
+        else if (event.phase === 'drag')
+            args.onDrag?.(payload);
+        else {
+            args.onDrop?.(payload);
+            monitoring = false;
+            previousDropTargets = [];
+        }
+    });
+    return () => {
+        cleanupNative();
+        cleanupTouch();
+    };
+}
+//# sourceMappingURL=pragmaticDnd.js.map