@atlaskit/pragmatic-drag-and-drop 0.17.0

package/dist/esm/make-adapter/make-monitor.js

@@ -0,0 +1,93 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+export function makeMonitor() {
+  var registry = new Set();
+  var dragging = null;
+  function tryAddToActive(monitor) {
+    if (!dragging) {
+      return;
+    }
+    // Monitor is allowed to monitor events if:
+    // 1. It has no `canMonitor` function (default is that a monitor can listen to everything)
+    // 2. `canMonitor` returns true
+    if (!monitor.canMonitor || monitor.canMonitor(dragging.canMonitorArgs)) {
+      dragging.active.add(monitor);
+    }
+  }
+  function monitorForConsumers(args) {
+    // We are giving each `args` a new reference so that you
+    // can create multiple monitors with the same `args`.
+    var entry = _objectSpread({}, args);
+    registry.add(entry);
+
+    // if there is an active drag we need to see if this new monitor is relevant
+    tryAddToActive(entry);
+    return function cleanup() {
+      registry.delete(entry);
+
+      // We need to stop publishing events during a drag to this monitor!
+      if (dragging) {
+        dragging.active.delete(entry);
+      }
+    };
+  }
+  function dispatchEvent(_ref) {
+    var eventName = _ref.eventName,
+      payload = _ref.payload;
+    if (eventName === 'onGenerateDragPreview') {
+      dragging = {
+        canMonitorArgs: {
+          initial: payload.location.initial,
+          source: payload.source
+        },
+        active: new Set()
+      };
+      var _iterator = _createForOfIteratorHelper(registry),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var monitor = _step.value;
+          tryAddToActive(monitor);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+
+    // This should never happen.
+    if (!dragging) {
+      return;
+    }
+
+    // Creating an array from the set _before_ iterating
+    // This is so that monitors added during the current event will not be called.
+    // This behaviour matches native EventTargets where an event listener
+    // cannot add another event listener during an active event to the same
+    // event target in the same event (for us we have a single global event target)
+    var active = Array.from(dragging.active);
+    for (var _i = 0, _active = active; _i < _active.length; _i++) {
+      var _monitor = _active[_i];
+      // A monitor can be removed by another monitor during an event.
+      // We need to check that the monitor is still registered before calling it
+      if (dragging.active.has(_monitor)) {
+        var _monitor$eventName;
+        // @ts-expect-error: I cannot get this type working!
+        (_monitor$eventName = _monitor[eventName]) === null || _monitor$eventName === void 0 ? void 0 : _monitor$eventName.call(_monitor, payload);
+      }
+    }
+    if (eventName === 'onDrop') {
+      dragging.active.clear();
+      dragging = null;
+    }
+  }
+  return {
+    dispatchEvent: dispatchEvent,
+    monitorForConsumers: monitorForConsumers
+  };
+}

package/dist/esm/util/add-attribute.js

@@ -0,0 +1,8 @@
+export function addAttribute(element, _ref) {
+  var attribute = _ref.attribute,
+    value = _ref.value;
+  element.setAttribute(attribute, value);
+  return function () {
+    return element.removeAttribute(attribute);
+  };
+}

package/dist/esm/util/combine.js

@@ -0,0 +1,11 @@
+/** Create a new combined function that will call all the provided functions */
+export function combine() {
+  for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
+    fns[_key] = arguments[_key];
+  }
+  return function cleanup() {
+    fns.forEach(function (fn) {
+      return fn();
+    });
+  };
+}

package/dist/esm/util/disable-native-drag-preview.js

@@ -0,0 +1,30 @@
+// In order to disable the native drag preview you can
+// use `event.dataTransfer.setDragImage()` to set a small
+// invisible image as the drag preview.
+// There are alternative techniques,
+// (eg setting opacity to in onGenerateDragPreview and then 1 in onDragStart)
+// but the technique in this file worked best across browsers and platforms
+
+// Here we are preloading the image so that it is ready for the first drag.
+// Even though the image is base64 encoded, the browser queues an async task
+// to decode the image. The image needs to be decoded before it can be used
+var tinyTransparentImage = function () {
+  // SSR safe
+  if (typeof window === 'undefined') {
+    return null;
+  }
+
+  // Image generated by: https://png-pixel.com/
+  // It is a 1x1 transparent gif
+  // It is the smallest possible transparent image we could find that works on all platforms
+  // Note: using an encoded SVG would be nicer code, but it doesn't work on iOS
+  var img = new Image();
+  img.src = 'data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACH5BAEAAAAALAAAAAABAAEAAAICRAEAOw==';
+  return img;
+}();
+export function disableNativeDragPreview(_ref) {
+  var nativeSetDragImage = _ref.nativeSetDragImage;
+  if (nativeSetDragImage && tinyTransparentImage) {
+    nativeSetDragImage(tinyTransparentImage, 0, 0);
+  }
+}

package/dist/esm/util/entering-and-leaving-the-window.js

@@ -0,0 +1,156 @@
+import { bindAll } from 'bind-event-listener';
+
+// *Usually* to detect if you are entering / leaving a window you can
+// use the `event.relatedTarget` property:
+
+// "dragenter":
+// - `event.relatedTarget` should point to the element that you are coming from
+//   - Scenario: A -> B
+//   - `event.target`: `B` (entering B)
+//   - `event.relatedTarget`: `A`: (leaving A - where you are coming from)
+// - if `event.relatedTarget` is `null` then you are entering the window (coming from `null`)
+//
+// "dragleave"
+// - `event.relatedTarget` should point to the element you are going to
+//   - Scenario: A -> B (entered B, leaving A)
+//   - `event.target`: `A` (leaving A)
+//   - `event.relatedTarget`: `B`: (entering into B - where you are going to)
+// - if `event.relatedTarget` is `null` then you are leaving the window (going to `null`)
+//
+// Unfortunately in Safari `event.relatedTarget` is *always* set to `null`
+// Safari bug: https://bugs.webkit.org/show_bug.cgi?id=242627
+// To work around this we count "dragenter" and "dragleave" events
+var safariFix = {
+  isSafari: false,
+  // Using symbols for event properties so we don't clash with
+  // anything on the `event` object
+  leavingWindow: Symbol('leaving'),
+  enteringWindow: Symbol('entering')
+};
+export function isEnteringWindow(_ref) {
+  var dragEnter = _ref.dragEnter;
+  if (dragEnter.type !== 'dragenter') {
+    return false;
+  }
+  if (safariFix.isSafari) {
+    return dragEnter.hasOwnProperty(safariFix.enteringWindow);
+  }
+  // This is the standard check.
+  // if `relatedTarget` is `null` during a "dragenter"
+  // then we are entering the`window`
+  return dragEnter.relatedTarget == null;
+}
+export function isLeavingWindow(_ref2) {
+  var dragLeave = _ref2.dragLeave;
+  if (dragLeave.type !== 'dragleave') {
+    return false;
+  }
+  if (safariFix.isSafari) {
+    return dragLeave.hasOwnProperty(safariFix.leavingWindow);
+  }
+  // This is the standard check.
+  // if `relatedTarget` is `null` during a "dragleave"
+  // then we are leave the `window`
+  return dragLeave.relatedTarget == null;
+}
+
+// NOTE: this fix currently has no test coverage
+// - our drag and drop browser tests currently only run in Chrome due to tooling limitations
+// - it didn't feel helpful to unit test as it is merely replicating a bug
+
+(function fixSafari() {
+  // Don't do anything when server side rendering
+  if (typeof window === 'undefined') {
+    return;
+  }
+
+  // rather than checking the userAgent for "jsdom" we can do this check
+  // so that the check will be removed completely in production code
+  if (process.env.NODE_ENV === 'test') {
+    return;
+  }
+  var _navigator = navigator,
+    userAgent = _navigator.userAgent;
+  var isSafari = userAgent.includes('AppleWebKit') && !userAgent.includes('Chrome');
+  if (!isSafari) {
+    return;
+  }
+  safariFix.isSafari = true;
+  function getInitialState() {
+    return {
+      enterCount: 0,
+      isOverWindow: false
+    };
+  }
+  var state = getInitialState();
+  function resetState() {
+    state = getInitialState();
+  }
+
+  // These event listeners are bound _forever_ and _never_ removed
+  // We don't bother cleaning up these event listeners (for now)
+  // as this workaround is only for Safari
+
+  // This is how the event count works:
+  //
+  // lift (+1 enterCount)
+  // - dragstart(draggable) [enterCount: 0]
+  // - dragenter(draggable) [enterCount: 1]
+  // leaving draggable (+0 enterCount)
+  // - dragenter(document.body) [enterCount: 2]
+  // - dragleave(draggable) [enterCount: 1]
+  // leaving window (-1 enterCount)
+  // - dragleave(document.body) [enterCount: 0] {leaving the window}
+
+  // Things to note:
+  // - dragenter and dragleave bubble
+  // - the first dragenter when entering a window might not be on `window`
+  //   - it could be on an element that is pressed up against the window
+  //   - (so we cannot rely on `event.target` values)
+
+  bindAll(window, [{
+    type: 'dragstart',
+    listener: function listener() {
+      state.enterCount = 0;
+      // drag start occurs in the source window
+      state.isOverWindow = true;
+
+      // When a drag first starts it will also trigger a "dragenter" on the draggable element
+    }
+  }, {
+    type: 'drop',
+    listener: resetState
+  }, {
+    type: 'dragend',
+    listener: resetState
+  }, {
+    type: 'dragenter',
+    listener: function listener(event) {
+      if (!state.isOverWindow && state.enterCount === 0) {
+        // Patching the `event` object
+        // The `event` object is shared with all event listeners for the event
+        // @ts-ignore
+        event[safariFix.enteringWindow] = true;
+      }
+      state.isOverWindow = true;
+      state.enterCount++;
+    }
+  }, {
+    type: 'dragleave',
+    listener: function listener(event) {
+      state.enterCount--;
+      if (state.isOverWindow && state.enterCount === 0) {
+        // Patching the `event` object as it is shared with all event listeners
+        // The `event` object is shared with all event listeners for the event
+        // @ts-ignore
+        event[safariFix.leavingWindow] = true;
+        state.isOverWindow = false;
+      }
+    }
+  }],
+  // using `capture: true` so that adding event listeners
+  // in bubble phase will have the correct symbols
+  {
+    capture: true
+  });
+})();

package/dist/esm/util/fix-post-drag-pointer-bug.js

@@ -0,0 +1,108 @@
+import { bindAll } from 'bind-event-listener';
+/** Set a `style` property on a `HTMLElement`
+ *
+ * @returns a `cleanup` function to restore the `style` property to it's original state
+ */
+function setStyle(el, _ref) {
+  var property = _ref.property,
+    rule = _ref.rule,
+    _ref$priority = _ref.priority,
+    priority = _ref$priority === void 0 ? '' : _ref$priority;
+  var originalValue = el.style.getPropertyValue(property);
+  var originalPriority = el.style.getPropertyPriority(property);
+  el.style.setProperty(property, rule, priority);
+  return function cleanup() {
+    el.style.setProperty(property, originalValue, originalPriority);
+  };
+}
+
+/**
+ * Allow the user to continue to interact with the element their pointer is over at the end of the drag.
+ * This is important to allow the user to be able to click, drag (etc) after they have finished a drag
+ *
+ * @returns a `cleanup` function to restore all elements under the users pointer to their original state
+ */
+function allowPointerEventsOnElementUnderPointer(_ref2) {
+  var current = _ref2.current;
+  var underUsersPointer = document.elementFromPoint(current.input.clientX, current.input.clientY);
+  if (!(underUsersPointer instanceof HTMLElement)) {
+    return null;
+  }
+
+  // Debug note: change from 'pointer-events: none' to 'background: green'
+  // to get a better sense of what is being achieved
+  return setStyle(underUsersPointer, {
+    property: 'pointer-events',
+    rule: 'auto',
+    priority: 'important'
+  });
+}
+function blockPointerEventsOnEverything() {
+  var _element$sheet;
+  var element = document.createElement('style');
+  // Adding a data attribute so to make it super clear to consumers
+  // (and to our tests) what this temporary style tag is for
+  element.setAttribute('pdnd-post-drag-fix', 'true');
+  document.head.appendChild(element);
+
+  // Debug note: change from 'pointer-events: none' to 'background: red'
+  // to get a better sense of what is being achieved
+  (_element$sheet = element.sheet) === null || _element$sheet === void 0 ? void 0 : _element$sheet.insertRule('* { pointer-events: none !important; }');
+  return function cleanup() {
+    document.head.removeChild(element);
+  };
+}
+
+/** 🔥🤮 Fix (Chrome, Safari and Firefox) bug where the element under where the user started dragging
+ * (on the viewport) is entered into by the browser after a drag finishes ("drop" or "dragend")
+ *
+ * @description
+ *
+ * Block pointer events on all elements except for the specific element that pointer is currently over
+ *
+ * - [Visual explanation of bug](https://twitter.com/alexandereardon/status/1633614212873465856)
+ * - [Chrome bug](https://bugs.chromium.org/p/chromium/issues/detail?id=410328)
+ */
+export function fixPostDragPointerBug(_ref3) {
+  var current = _ref3.current;
+  // Queuing a microtask to give any opportunity for frameworks to update their UI in a microtask
+  // Note: react@18 does standard state updates in a microtask
+  // We do this so our `atDestination` gets the _actual_ element that is under the users pointer
+  // at the end of the drag.
+  queueMicrotask(function () {
+    var undoUnderPointer = allowPointerEventsOnElementUnderPointer({
+      current: current
+    });
+
+    // This will also block pointer-events on the children of the element under the users pointer.
+    // This is what we want. If the user drops on a container element we don't want the children
+    // of the container to be incorrectly entered into
+    var undoGlobalBlock = blockPointerEventsOnEverything();
+    function cleanup() {
+      unbindEvents();
+      undoUnderPointer === null || undoUnderPointer === void 0 ? void 0 : undoUnderPointer();
+      undoGlobalBlock();
+    }
+    var unbindEvents = bindAll(window, [{
+      type: 'pointerdown',
+      listener: cleanup
+    }, {
+      type: 'pointermove',
+      listener: cleanup
+    }, {
+      type: 'focusin',
+      listener: cleanup
+    }, {
+      type: 'focusout',
+      listener: cleanup
+    },
+    // a 'pointerdown' should happen before 'dragstart', but just being super safe
+    {
+      type: 'dragstart',
+      listener: cleanup
+    }], {
+      // Using `capture` is more likely to not be impacted by consumers stopping events
+      capture: true
+    });
+  });
+}

package/dist/esm/util/get-input.js

@@ -0,0 +1,14 @@
+export function getInput(event) {
+  return {
+    altKey: event.altKey,
+    button: event.button,
+    buttons: event.buttons,
+    ctrlKey: event.ctrlKey,
+    metaKey: event.metaKey,
+    shiftKey: event.shiftKey,
+    clientX: event.clientX,
+    clientY: event.clientY,
+    pageX: event.pageX,
+    pageY: event.pageY
+  };
+}

package/dist/esm/util/once.js

@@ -0,0 +1,16 @@
+/** Provide a function that you only ever want to be called a single time */
+export function once(fn) {
+  var cache = null;
+  return function wrapped() {
+    if (!cache) {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      var result = fn.apply(this, args);
+      cache = {
+        result: result
+      };
+    }
+    return cache.result;
+  };
+}

package/dist/esm/util/reorder.js

@@ -0,0 +1,19 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+/**
+ * Reorder a provided `list`
+ * Returns a new array and does not modify the original array
+ */
+export function reorder(_ref) {
+  var list = _ref.list,
+    startIndex = _ref.startIndex,
+    finishIndex = _ref.finishIndex;
+  if (startIndex === -1 || finishIndex === -1) {
+    return list;
+  }
+  var result = Array.from(list);
+  var _result$splice = result.splice(startIndex, 1),
+    _result$splice2 = _slicedToArray(_result$splice, 1),
+    removed = _result$splice2[0];
+  result.splice(finishIndex, 0, removed);
+  return result;
+}

package/dist/esm/util/scroll-just-enough-into-view.js

@@ -0,0 +1,11 @@
+/**
+ * Scroll an `element` just enough into view so that the element becomes totally visible.
+ * If the element is already totally visible then no scrolling will occur.
+ */
+export function scrollJustEnoughIntoView(_ref) {
+  var element = _ref.element;
+  element.scrollIntoView({
+    block: 'nearest',
+    inline: 'nearest'
+  });
+}

package/dist/esm/util/set-custom-native-drag-preview.js

@@ -0,0 +1,104 @@
+import { monitorForElements } from '../adapter/element-adapter';
+
+/** A function to remove the element that has been added to the `container`.
+ * @example () => ReactDOM.unmountComponentAtNode(container)
+ */
+
+/** A function that will render a preview element into a `container` `HTMLElement` */
+
+/** Any valid CSS string value
+ * @example `calc(var(--grid) * 2)
+ */
+
+/**
+ * Where to place the custom drag preview
+ *
+ * `type: 'center'`: Place the center of the drag preview user the users pointer
+ *
+ * `type: 'offset-from-pointer'`: Shift the drag preview away from the users pointer
+ */
+
+function setImage(_ref) {
+  var container = _ref.container,
+    placement = _ref.placement,
+    nativeSetDragImage = _ref.nativeSetDragImage;
+  if ((placement === null || placement === void 0 ? void 0 : placement.type) === 'center') {
+    var box = container.getBoundingClientRect();
+    nativeSetDragImage === null || nativeSetDragImage === void 0 ? void 0 : nativeSetDragImage(container, box.width / 2, box.height / 2);
+    return;
+  }
+  if ((placement === null || placement === void 0 ? void 0 : placement.type) === 'offset-from-pointer') {
+    // Using a transparent border to push the drag preview away
+    // from the user's pointer.
+    // In Chrome and Safari we could use `padding`:
+    // padding: 'var(--grid)',
+    // But it does not work in Firefox which trims the padding (or inner margin)
+    Object.assign(container.style, {
+      borderLeft: "".concat(placement.x, " solid transparent"),
+      borderTop: "".concat(placement.y, " solid transparent")
+    });
+  }
+  nativeSetDragImage === null || nativeSetDragImage === void 0 ? void 0 : nativeSetDragImage(container, 0, 0);
+}
+
+/** This function provides the ability to mount an element for it to be used as the native drag preview
+ *
+ * @example
+ * draggable({
+ *  onGenerateDragPreview: ({ nativeSetDragImage }) => {
+ *    setCustomNativeDragPreview({
+ *      render: ({ container }) => {
+ *        ReactDOM.render(<Preview item={item} />, container);
+ *        return () => ReactDOM.unmountComponentAtNode(container);
+ *      },
+ *      nativeSetDragImage,
+ *    });
+ *    },
+ * });
+ */
+export function setCustomNativeDragPreview(_ref2) {
+  var render = _ref2.render,
+    nativeSetDragImage = _ref2.nativeSetDragImage,
+    placement = _ref2.placement;
+  var container = document.createElement('div');
+  Object.assign(container.style, {
+    // Ensuring we don't cause reflow when adding the element to the page
+    // Using `position:fixed` rather than `position:absolute` so we are
+    // positioned on the current viewport.
+    // `position:fixed` also creates a new stacking context, so we don't need to do that here
+    position: 'fixed',
+    top: 0,
+    left: 0,
+    // Using maximum possible z-index so that this element will always be on top
+    // https://stackoverflow.com/questions/491052/minimum-and-maximum-value-of-z-index
+    // Did not use `layers` in `@atlaskit/theme` because:
+    // 1. This element is not a 'layer' in the conventional sense, as this element
+    //    is only created for a single frame for the browser to take a photo of it,
+    //    and then it is destroyed
+    // 2. Did not want to add a dependency onto `@atlaskit/theme`
+    // 3. Want to always be on top of product UI which might have higher z-index's
+    zIndex: 2147483647,
+    // Avoiding any additional events caused by the new element (being super safe)
+    pointerEvents: 'none'
+  });
+  document.body.append(container);
+  var unmount = render({
+    container: container
+  });
+  setImage({
+    container: container,
+    placement: placement,
+    nativeSetDragImage: nativeSetDragImage
+  });
+  function cleanup() {
+    unbindMonitor();
+    unmount === null || unmount === void 0 ? void 0 : unmount();
+    document.body.removeChild(container);
+  }
+  var unbindMonitor = monitorForElements({
+    // Remove portal in the dragstart event so that the user will never see it
+    onDragStart: cleanup,
+    // Backup: remove portal when the drop finishes (this would be an error case)
+    onDrop: cleanup
+  });
+}

package/dist/esm/version.json

@@ -0,0 +1,5 @@
+{
+	"name": "@atlaskit/pragmatic-drag-and-drop",
+	"version": "0.17.0",
+	"sideEffects": false
+}

package/dist/types/adapter/element-adapter.d.ts

@@ -0,0 +1,42 @@
+import { AllEvents, BaseEventPayload, CleanupFn, DropTargetEventPayloadMap, EventPayloadMap, Input, InternalDragType, MonitorCanMonitorArgs } from '../internal-types';
+declare type ElementDragType = InternalDragType<'element', 'move', {
+    element: HTMLElement;
+    dragHandle: Element | null;
+    data: Record<string, unknown>;
+}>;
+declare type GetFeedbackArgs = {
+    /**
+     * The user input as a drag is trying to start (the `initial` input)
+     */
+    input: Input;
+    /**
+     * The `draggable` element
+     */
+    element: HTMLElement;
+    /**
+     * The `dragHandle` element for the `draggable`
+     */
+    dragHandle: Element | null;
+};
+declare type DraggableArgs = {
+    /** The `HTMLElement` that you want to attach draggable behaviour to.
+     * `element` is our unique _key_ for a draggable.
+     * `element` is a `HTMLElement` as only a `HTMLElement`
+     * can have a "draggable" attribute
+     */
+    element: HTMLElement;
+    /** The part of a draggable `element` that you want to use to control the dragging of the whole `element` */
+    dragHandle?: Element;
+    /** Conditionally allow a drag to occur */
+    canDrag?: (args: GetFeedbackArgs) => boolean;
+    /** Used to attach data to a drag operation. Called once just before the drag starts */
+    getInitialData?: (args: GetFeedbackArgs) => Record<string, unknown>;
+} & Partial<AllEvents<ElementDragType>>;
+export declare const dropTargetForElements: (args: import("../internal-types").DropTargetArgs<ElementDragType>) => CleanupFn;
+export declare const monitorForElements: (args: import("../internal-types").MonitorArgs<ElementDragType>) => CleanupFn;
+export declare function draggable(args: DraggableArgs): CleanupFn;
+export declare type ElementEventBasePayload = BaseEventPayload<ElementDragType>;
+export declare type ElementEventPayloadMap = EventPayloadMap<ElementDragType>;
+export declare type ElementDropTargetEventPayloadMap = DropTargetEventPayloadMap<ElementDragType>;
+export declare type ElementMonitorCanMonitorArgs = MonitorCanMonitorArgs<ElementDragType>;
+export {};

package/dist/types/adapter/file-adapter.d.ts

@@ -0,0 +1,18 @@
+import { BaseEventPayload, CleanupFn, DropTargetEventPayloadMap, EventPayloadMap, ExternalDragType, MonitorCanMonitorArgs } from '../internal-types';
+declare type FileDragType = ExternalDragType<'file', 'copy', {
+    items: DataTransfer['items'] | null;
+}>;
+declare const adapter: {
+    registerUsage: () => CleanupFn;
+    dropTarget: (args: import("../internal-types").DropTargetArgs<FileDragType>) => CleanupFn;
+    monitor: (args: import("../internal-types").MonitorArgs<FileDragType>) => CleanupFn;
+};
+declare type StripEventsForDropTargets<T> = Omit<T, 'onDragStart' | 'onGenerateDragPreview'>;
+declare type StripPreviewEvent<T> = Omit<T, 'onGenerateDragPreview'>;
+export declare const dropTargetForFiles: (args: StripEventsForDropTargets<Parameters<typeof adapter.dropTarget>[0]>) => CleanupFn;
+export declare const monitorForFiles: (args: StripPreviewEvent<Parameters<typeof adapter.monitor>[0]>) => CleanupFn;
+export declare type FileDropTargetEventPayloadMap = StripEventsForDropTargets<DropTargetEventPayloadMap<FileDragType>>;
+export declare type FileEventPayloadMap = StripPreviewEvent<EventPayloadMap<FileDragType>>;
+export declare type FileEventBasePayload = BaseEventPayload<FileDragType>;
+export declare type FileMonitorCanMonitorArgs = MonitorCanMonitorArgs<FileDragType>;
+export {};

package/dist/types/addon/cancel-unhandled.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Block drag operations outside of `@atlaskit/pragmatic-drag-and-drop`
+ */
+export declare const cancelUnhandled: {
+    start(): void;
+    stop(): void;
+};

package/dist/types/entry-point/adapter/element.d.ts

@@ -0,0 +1,2 @@
+export { draggable, dropTargetForElements, monitorForElements, } from '../../adapter/element-adapter';
+export type { ElementEventBasePayload, ElementEventPayloadMap, ElementDropTargetEventPayloadMap, ElementMonitorCanMonitorArgs, } from '../../adapter/element-adapter';

package/dist/types/entry-point/adapter/file.d.ts

@@ -0,0 +1,2 @@
+export { monitorForFiles, dropTargetForFiles, } from '../../adapter/file-adapter';
+export type { FileEventBasePayload, FileDropTargetEventPayloadMap, FileEventPayloadMap, FileMonitorCanMonitorArgs, } from '../../adapter/file-adapter';

package/dist/types/entry-point/addon/cancel-unhandled.d.ts

@@ -0,0 +1 @@
+export { cancelUnhandled } from '../../addon/cancel-unhandled';