@atlaskit/pragmatic-drag-and-drop 0.25.0 → 1.0.1

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @atlaskit/pragmatic-drag-and-drop
 
+## 1.0.1
+
+### Patch Changes
+
+- [#76476](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/pull-requests/76476) [`35148e092790`](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/commits/35148e092790) - Adding warning for test environments to let people know if DragEvents have not been setup correctly.
+
+## 1.0.0
+
+### Major Changes
+
+- [#70616](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/pull-requests/70616) [`42e57ea65fee`](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/commits/42e57ea65fee) - This is our first `major` release (`1.0`) for all Pragmatic drag and drop packages.
+
+  For a detailed explanation of these changes, and how to upgrade (automatically) to `1.0` please see our [1.0 upgrade guide](http://atlassian.design/components/pragmatic-drag-and-drop/core-package/upgrade-guides/upgrade-guide-for-1.0)
+
 ## 0.25.0
 
 ### Minor Changes

package/combine/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "@atlaskit/pragmatic-drag-and-drop/combine",
+  "main": "../dist/cjs/entry-point/combine.js",
+  "module": "../dist/esm/entry-point/combine.js",
+  "module:es2019": "../dist/es2019/entry-point/combine.js",
+  "sideEffects": false,
+  "types": "../dist/types/entry-point/combine.d.ts",
+  "typesVersions": {
+    ">=4.5 <4.9": {
+      "*": [
+        "../dist/types-ts4.5/entry-point/combine.d.ts"
+      ]
+    }
+  }
+}

package/constellation/index/props.mdx

@@ -1,3 +1,3 @@
 ---
-order: 3
+order: 1
 ---

package/dist/cjs/adapter/element-adapter-native-data-key.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.elementAdapterNativeDataKey = void 0;
+/**
+ * This key has been pulled into a separate module
+ * so that the external adapter does not need to import
+ * the element adapter
+ */
+var elementAdapterNativeDataKey = exports.elementAdapterNativeDataKey = 'application/vnd.pdnd';

package/dist/cjs/adapter/element-adapter.js

@@ -1,15 +1,21 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.draggable = draggable;
 exports.monitorForElements = exports.dropTargetForElements = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 var _bindEventListener = require("bind-event-listener");
 var _makeAdapter = require("../make-adapter/make-adapter");
+var _combine = require("../public-utils/combine");
 var _addAttribute = require("../util/add-attribute");
-var _combine = require("../util/combine");
+var _android = require("../util/android");
 var _getInput = require("../util/get-input");
+var _textMediaType = require("../util/media-types/text-media-type");
+var _urlMediaType = require("../util/media-types/url-media-type");
+var _elementAdapterNativeDataKey = require("./element-adapter-native-data-key");
 var draggableRegistry = new WeakMap();
 function addToRegistry(args) {
   draggableRegistry.set(args.element, args);
@@ -21,13 +27,40 @@ var adapter = (0, _makeAdapter.makeAdapter)({
   typeKey: 'element',
   defaultDropEffect: 'move',
   mount: function mount(api) {
-    return (0, _bindEventListener.bind)(window, {
+    /**  Binding event listeners the `document` rather than `window` so that
+     * this adapter always gets preference over the text adapter.
+     * `document` is the first `EventTarget` under `window`
+     * https://twitter.com/alexandereardon/status/1604658588311465985
+     */
+    return (0, _bindEventListener.bind)(document, {
       type: 'dragstart',
       listener: function listener(event) {
-        var _entry$dragHandle, _entry$dragHandle2, _entry$getInitialData, _entry$getInitialData2;
+        var _entry$dragHandle, _entry$getInitialData, _entry$getInitialData2, _entry$dragHandle2, _entry$getInitialData3, _entry$getInitialData4;
         if (!api.canStart(event)) {
           return;
         }
+
+        // If the "dragstart" event is cancelled, then a drag won't start
+        // There will be no further drag operation events (eg no "dragend" event)
+        if (event.defaultPrevented) {
+          return;
+        }
+
+        // Technically `dataTransfer` can be `null` according to the types
+        // But that behaviour does not seem to appear in the spec.
+        // If there is not `dataTransfer`, we can assume something is wrong and not
+        // start a drag
+        if (!event.dataTransfer) {
+          // Including this code on "test" and "development" environments:
+          // - Browser tests commonly run against "development" builds
+          // - Unit tests commonly run in "test"
+          if (process.env.NODE_ENV !== 'production') {
+            // eslint-disable-next-line no-console
+            console.warn("\n              It appears as though you have are not testing DragEvents correctly.\n\n              - If you are unit testing, ensure you have pollyfilled DragEvent.\n              - If you are browser testing, ensure you are dispatching drag events correctly.\n\n              Please see our testing guides for more information:\n              https://atlassian.design/components/pragmatic-drag-and-drop/core-package/testing\n            ".replace(/ {2}/g, ''));
+          }
+          return;
+        }
+
         // the closest parent that is a draggable element will be marked as
         // the `event.target` for the event
         var target = event.target;
@@ -72,26 +105,84 @@ var adapter = (0, _makeAdapter.makeAdapter)({
           }
         }
 
-        // Must set any media type for iOS15 to work
-        // Doing this will fail in firefox though, so we
-        // wrap the operation in a try/catch
-        try {
-          var _event$dataTransfer;
-          (_event$dataTransfer = event.dataTransfer) === null || _event$dataTransfer === void 0 || _event$dataTransfer.setData('application/vnd.pdnd', '');
-        } catch (e) {}
+        /**
+         *  **Goal**
+         *  Pass information to other applications
+         *
+         * **Approach**
+         *  Put data into the native data store
+         *
+         *  **What about the native adapter?**
+         *  When the element adapter puts native data into the native data store
+         *  the native adapter is not triggered in the current window,
+         *  but a native adapter in an external window _can_ be triggered
+         *
+         *  **Why bake this into core?**
+         *  This functionality could be pulled out and exposed inside of
+         *  `onGenerateDragPreview`. But decided to make it a part of the
+         *  base API as it felt like a common enough use case and ended
+         *  up being a similar amount of code to include this function as
+         *  it was to expose the hook for it
+         */
+        var nativeData = (_entry$getInitialData = (_entry$getInitialData2 = entry.getInitialDataForExternal) === null || _entry$getInitialData2 === void 0 ? void 0 : _entry$getInitialData2.call(entry, feedback)) !== null && _entry$getInitialData !== void 0 ? _entry$getInitialData : null;
+        if (nativeData) {
+          for (var _i = 0, _Object$entries = Object.entries(nativeData); _i < _Object$entries.length; _i++) {
+            var _Object$entries$_i = (0, _slicedToArray2.default)(_Object$entries[_i], 2),
+              key = _Object$entries$_i[0],
+              data = _Object$entries$_i[1];
+            event.dataTransfer.setData(key, data !== null && data !== void 0 ? data : '');
+          }
+        }
+
+        /**
+         *  📱 For Android devices, a drag operation will not start unless
+         * "text/plain" or "text/uri-list" data exists in the native data store
+         * https://twitter.com/alexandereardon/status/1732189803754713424
+         *
+         * Tested on:
+         * Device: Google Pixel 5
+         * Android version: 14 (November 5, 2023)
+         * Chrome version: 120.0
+         */
+        var types = event.dataTransfer.types;
+        if ((0, _android.isAndroid)() && !types.includes(_textMediaType.textMediaType) && !types.includes(_urlMediaType.urlMediaType)) {
+          event.dataTransfer.setData(_textMediaType.textMediaType, _android.androidFallbackText);
+        }
+
+        /**
+         * 1. Must set any media type for `iOS15` to work
+         * 2. We are also doing adding data so that the native adapter
+         * can know that the element adapter has handled this drag
+         *
+         * We used to wrap this `setData()` in a `try/catch` for Firefox,
+         * but it looks like that was not needed.
+         *
+         * Tested using: https://codesandbox.io/s/checking-firefox-throw-behaviour-on-dragstart-qt8h4f
+         *
+         * - ✅ Firefox@70.0 (Oct 2019) on macOS Sonoma
+         * - ✅ Firefox@70.0 (Oct 2019) on macOS Big Sur
+         * - ✅ Firefox@70.0 (Oct 2019) on Windows 10
+         *
+         * // just checking a few more combinations to be super safe
+         *
+         * - ✅ Chrome@78 (Oct 2019) on macOS Big Sur
+         * - ✅ Chrome@78 (Oct 2019) on Windows 10
+         * - ✅ Safari@14.1 on macOS Big Sur
+         */
+        event.dataTransfer.setData(_elementAdapterNativeDataKey.elementAdapterNativeDataKey, '');
         var payload = {
           element: entry.element,
           dragHandle: (_entry$dragHandle2 = entry.dragHandle) !== null && _entry$dragHandle2 !== void 0 ? _entry$dragHandle2 : null,
-          data: (_entry$getInitialData = (_entry$getInitialData2 = entry.getInitialData) === null || _entry$getInitialData2 === void 0 ? void 0 : _entry$getInitialData2.call(entry, feedback)) !== null && _entry$getInitialData !== void 0 ? _entry$getInitialData : {}
+          data: (_entry$getInitialData3 = (_entry$getInitialData4 = entry.getInitialData) === null || _entry$getInitialData4 === void 0 ? void 0 : _entry$getInitialData4.call(entry, feedback)) !== null && _entry$getInitialData3 !== void 0 ? _entry$getInitialData3 : {}
         };
-        var makeDragType = {
-          key: 'element',
-          startedFrom: 'internal',
-          payload: payload
+        var dragType = {
+          type: 'element',
+          payload: payload,
+          startedFrom: 'internal'
         };
         api.start({
           event: event,
-          dragInterface: makeDragType
+          dragType: dragType
         });
       }
     });
@@ -146,4 +237,18 @@ function draggable(args) {
     attribute: 'draggable',
     value: 'true'
   }));
-}
+}
+
+/** Common event payload for all events */
+
+/** A map containing payloads for all events */
+
+/** Common event payload for all drop target events */
+
+/** A map containing payloads for all events on drop targets */
+
+/** Arguments given to all feedback functions (eg `canDrag()`) on for a `draggable()` */
+
+/** Arguments given to all feedback functions (eg `canDrop()`) on a `dropTargetForElements()` */
+
+/** Arguments given to all monitor feedback functions (eg `canMonitor()`) for a `monitorForElements` */

package/dist/cjs/adapter/external-adapter.js

@@ -0,0 +1,252 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dropTargetForExternal = dropTargetForExternal;
+exports.getAvailableItems = getAvailableItems;
+exports.getAvailableTypes = getAvailableTypes;
+exports.isAnAvailableType = isAnAvailableType;
+exports.monitorForExternal = monitorForExternal;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _bindEventListener = require("bind-event-listener");
+var _makeAdapter = require("../make-adapter/make-adapter");
+var _android = require("../util/android");
+var _isEnteringWindow = require("../util/changing-window/is-entering-window");
+var _detectBrokenDrag = require("../util/detect-broken-drag");
+var _textMediaType = require("../util/media-types/text-media-type");
+var _elementAdapterNativeDataKey = require("./element-adapter-native-data-key");
+function isAnAvailableType(_ref) {
+  var type = _ref.type,
+    value = _ref.value;
+  // We don't want to expose our private elementAdapter key / value
+  if (type === _elementAdapterNativeDataKey.elementAdapterNativeDataKey) {
+    return false;
+  }
+  // Not exposing "text/plain" if it contains the android fallback text
+  // We _could_ add an `isAndroid()` check, but it's probably safest
+  // to trim this data out, regardless of what OS we see it on.
+  if (type === _textMediaType.textMediaType && value === _android.androidFallbackText) {
+    return false;
+  }
+  return true;
+}
+function getAvailableTypes(transfer) {
+  return Array.from(transfer.types).filter(function (type) {
+    return isAnAvailableType({
+      type: type,
+      value: transfer.getData(type)
+    });
+  });
+}
+function getAvailableItems(dataTransfer) {
+  // item.kind is 'string' | 'file'
+  // For 'string' item.type is the mimeType (eg 'text/plain')
+  // For 'file' item.type is the file type (eg 'image/jpg')
+
+  return Array.from(dataTransfer.items).filter(function (item) {
+    return item.kind === 'file' || isAnAvailableType({
+      type: item.type,
+      value: dataTransfer.getData(item.type)
+    });
+  });
+}
+var didDragStartLocally = false;
+var adapter = (0, _makeAdapter.makeAdapter)({
+  typeKey: 'external',
+  // for external drags, we are generally making a copy of something that is being dragged
+  defaultDropEffect: 'copy',
+  mount: function mount(api) {
+    // Binding to the `window` so that the element adapter
+    // has a chance to get in first on the`document`.
+    // We are giving preference to the element adapter.
+    return (0, _bindEventListener.bind)(window, {
+      type: 'dragenter',
+      listener: function listener(event) {
+        // drag operation was started within the document, it won't be an "external" drag
+        if (didDragStartLocally) {
+          return;
+        }
+
+        // Note: not checking if event was cancelled (`event.defaultPrevented`) as
+        // cancelling a "dragenter" accepts the drag operation (not prevent it)
+
+        // Something has gone wrong with our drag event
+        if (!event.dataTransfer) {
+          // Including this code on "test" and "development" environments:
+          // - Browser tests commonly run against "development" builds
+          // - Unit tests commonly run in "test"
+          if (process.env.NODE_ENV !== 'production') {
+            // eslint-disable-next-line no-console
+            console.warn("\n              It appears as though you have are not testing DragEvents correctly.\n\n              - If you are unit testing, ensure you have pollyfilled DragEvent.\n              - If you are browser testing, ensure you are dispatching drag events correctly.\n\n              Please see our testing guides for more information:\n              https://atlassian.design/components/pragmatic-drag-and-drop/core-package/testing\n            ".replace(/ {2}/g, ''));
+          }
+          return;
+        }
+        if (!api.canStart(event)) {
+          return;
+        }
+        if (!(0, _isEnteringWindow.isEnteringWindow)({
+          dragEnter: event
+        })) {
+          return;
+        }
+
+        // Note: not checking types for `elementAdapterNativeDataKey` as we expect to see that
+        // key when pdnd started the drag in another document
+        var types = getAvailableTypes(event.dataTransfer);
+        if (!types.length) {
+          return;
+        }
+        var locked = {
+          types: types,
+          items: [],
+          getStringData: function getStringData() {
+            return null;
+          }
+        };
+        api.start({
+          event: event,
+          dragType: {
+            type: 'external',
+            startedFrom: 'external',
+            payload: locked,
+            getDropPayload: function getDropPayload(event) {
+              // this would be a platform error
+              // trying to handle it gracefully rather than throwing (for now)
+              if (!event.dataTransfer) {
+                return locked;
+              }
+              var items = getAvailableItems(event.dataTransfer);
+              // need to use `.bind` as `getData` is required
+              // to be run with `event.dataTransfer` as the "this" context
+              var nativeGetData = event.dataTransfer.getData.bind(event.dataTransfer);
+              return {
+                types: types,
+                items: items,
+                // return `null` if there is no result, otherwise string
+                getStringData: function getStringData(mediaType) {
+                  // not dragging the requested type
+                  // return `null` (no result)
+                  if (!types.includes(mediaType)) {
+                    return null;
+                  }
+
+                  // nativeGetData will return `""` when there is no value,
+                  // but at this point we know we will only get explicitly set
+                  // values back as we have checked the `types`.
+                  // `""` can be an explicitly set value.
+                  var value = nativeGetData(mediaType);
+
+                  // not exposing data for unavailable types
+                  if (!isAnAvailableType({
+                    type: mediaType,
+                    value: value
+                  })) {
+                    return null;
+                  }
+                  return value;
+                }
+              };
+            }
+          }
+        });
+      }
+    });
+  }
+});
+
+/**
+ * Some events don't make sense for the external adapter
+ *
+ * `onGenerateDragPreview`
+ * The browser creates the drag preview for external drags, so we don't
+ * need an event to generate the preview for _monitors_ or the _dropTarget_
+ *
+ * `onDragStart`
+ * An external drag can never start from in the `window`, so _dropTarget_'s
+ * don't need `onDragStart`
+ */
+
+function dropTargetForExternal(args) {
+  // not removing unused events, just leaning on the type system
+  return adapter.dropTarget(args);
+}
+function monitorForExternal(args) {
+  // not removing unused events, just leaning on the type system
+  return adapter.monitor(args);
+}
+(function startup() {
+  // server side rendering check
+  if (typeof window === 'undefined') {
+    return;
+  }
+
+  // A shared single usage registration as we want to capture
+  // all external drag operations, even if there are no drop targets
+  // on the page yet
+  adapter.registerUsage();
+  // independent of pdnd, we need to keep track of
+  // all drag operations so that we can know if a drag operation
+  // has started locally
+  var idle = {
+    type: 'idle'
+  };
+  var state = idle;
+  function clear() {
+    if (state.type !== 'dragging') {
+      return;
+    }
+    didDragStartLocally = false;
+    state.cleanup();
+    state = idle;
+  }
+  function bindEndEvents() {
+    return (0, _bindEventListener.bindAll)(window, [{
+      type: 'dragend',
+      listener: clear
+    }].concat((0, _toConsumableArray2.default)((0, _detectBrokenDrag.getBindingsForBrokenDrags)({
+      onDragEnd: clear
+    }))),
+    // we want to make sure we get all the events,
+    // and this helps avoid not seeing events when folks stop
+    // them later on the event path
+    {
+      capture: true
+    });
+  }
+
+  // we always keep this event listener active
+  (0, _bindEventListener.bind)(window, {
+    type: 'dragstart',
+    listener: function listener() {
+      // something bad has happened if this is true!
+      if (state.type !== 'idle') {
+        return;
+      }
+      // set our global flag
+      didDragStartLocally = true;
+      state = {
+        type: 'dragging',
+        cleanup: bindEndEvents()
+      };
+    },
+    // binding in the capture phase so these listeners are called
+    // before our listeners in the adapters `mount` function
+    options: {
+      capture: true
+    }
+  });
+})();
+
+/** Common event payload for all events */
+
+/** A map containing payloads for all events */
+
+/** Common event payload for all drop target events */
+
+/** A map containing payloads for all events on drop targets */
+
+/** Arguments given to all feedback functions (eg `canDrop()`) on a `dropTargetForExternal` */
+
+/** Arguments given to all monitor feedback functions (eg `canMonitor()`) for a `monitorForExternal` */

package/dist/cjs/adapter/text-selection-adapter.js

@@ -0,0 +1,153 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dropTargetForTextSelection = dropTargetForTextSelection;
+exports.monitorForTextSelection = monitorForTextSelection;
+var _bindEventListener = require("bind-event-listener");
+var _makeAdapter = require("../make-adapter/make-adapter");
+var _isSafari = require("../util/is-safari");
+var _htmlMediaType = require("../util/media-types/html-media-type");
+var _textMediaType = require("../util/media-types/text-media-type");
+var _elementAdapterNativeDataKey = require("./element-adapter-native-data-key");
+function findTextNode(event) {
+  var _event$dataTransfer;
+  // Standard: the `event.target` should be the closest `Text` node.
+  if (event.target instanceof Text) {
+    return event.target;
+  }
+
+  // Structuring things this way so that if Safari fixes their bug
+  // then the standard check will start working
+  if (!(0, _isSafari.isSafari)()) {
+    return null;
+  }
+
+  /**
+   * According to the spec, `event.target` should be the `Text` node that
+   * the drag started from when dragging a text selection.
+   *
+   * → https://html.spec.whatwg.org/multipage/dnd.html#drag-and-drop-processing-model
+   *
+   * However, in Safari the closest `HTMLElement` is returned.
+   * So we need to figure out if text is dragging ourselves.
+   *
+   * → https://bugs.webkit.org/show_bug.cgi?id=268959
+   */
+  if (!(event.target instanceof HTMLElement)) {
+    return null;
+  }
+
+  // unlikely that this particular drag is a text selection drag
+  if (event.target.draggable) {
+    return null;
+  }
+
+  // if the drag contains no text data, then not dragging selected text
+  // return `null` if there is no dataTransfer, or if `getData()` returns ""
+  if (!((_event$dataTransfer = event.dataTransfer) !== null && _event$dataTransfer !== void 0 && _event$dataTransfer.getData(_textMediaType.textMediaType))) {
+    return null;
+  }
+
+  // Grab the first Text node and use that
+  var text = Array.from(event.target.childNodes).find(function (node) {
+    return node.nodeType === Node.TEXT_NODE;
+  });
+  return text !== null && text !== void 0 ? text : null;
+}
+var adapter = (0, _makeAdapter.makeAdapter)({
+  typeKey: 'text-selection',
+  // for text selection, we will usually be making a copy of the text
+  defaultDropEffect: 'copy',
+  mount: function mount(api) {
+    // Binding to the `window` so that the element adapter has a
+    // chance to get in first on the `document`.
+    // We are giving preference to the element adapter.
+    return (0, _bindEventListener.bindAll)(window, [{
+      type: 'dragstart',
+      listener: function listener(event) {
+        // If the "dragstart" event is cancelled, then a drag won't start
+        // There will be no further drag operation events (eg no "dragend" event)
+        if (event.defaultPrevented) {
+          return;
+        }
+
+        // Something has gone wrong with our drag event
+        if (!event.dataTransfer) {
+          // Including this code on "test" and "development" environments:
+          // - Browser tests commonly run against "development" builds
+          // - Unit tests commonly run in "test"
+          if (process.env.NODE_ENV !== 'production') {
+            // eslint-disable-next-line no-console
+            console.warn("\n                It appears as though you have are not testing DragEvents correctly.\n\n                - If you are unit testing, ensure you have pollyfilled DragEvent.\n                - If you are browser testing, ensure you are dispatching drag events correctly.\n\n                Please see our testing guides for more information:\n                https://atlassian.design/components/pragmatic-drag-and-drop/core-package/testing\n              ".replace(/ {2}/g, ''));
+          }
+          return;
+        }
+
+        // Drag is being handled by the element adapter
+        if (event.dataTransfer.types.includes(_elementAdapterNativeDataKey.elementAdapterNativeDataKey)) {
+          return;
+        }
+
+        // Something else is handling this drag
+        if (!api.canStart(event)) {
+          return;
+        }
+        var target = findTextNode(event);
+        if (!target) {
+          return;
+        }
+        var payload = {
+          // The `Text` node that is the `target` is the `Text` node
+          // that the user started the drag from.
+          // The full text being dragged can be looked up from the `dataTransfer`.
+          target: target,
+          // This is safe to do in "dragstart" as the `dataTransfer` is in read/write mode.
+          plain: event.dataTransfer.getData(_textMediaType.textMediaType),
+          HTML: event.dataTransfer.getData(_htmlMediaType.HTMLMediaType)
+        };
+        api.start({
+          event: event,
+          dragType: {
+            type: 'text-selection',
+            startedFrom: 'internal',
+            payload: payload
+          }
+        });
+      }
+    }]);
+  }
+});
+
+// The `onGenerateDragPreview` does not make sense to publish for text selection
+// as the browser is completely in control of the drag preview
+function dropTargetForTextSelection(args) {
+  // note: not removing `onGenerateDragPreview`; just leaning on the type system
+  return adapter.dropTarget(args);
+}
+
+// A shared single usage registration as any text can be dragged at any time
+(function register() {
+  // server side rendering check
+  if (typeof window === 'undefined') {
+    return;
+  }
+  adapter.registerUsage();
+})();
+function monitorForTextSelection(args) {
+  // note: not removing `onGenerateDragPreview`; just leaning on the type system
+  return adapter.monitor(args);
+}
+
+/** Common event payload for all events */
+
+/** A map containing payloads for all events */
+
+/** Common event payload for all drop target events */
+
+/** A map containing payloads for all events on drop targets */
+
+/** Argument given to all feedback functions (eg `canDrop()`) on a `dropTargetForExternal` */
+
+/** Argument given to all monitor feedback functions (eg `canMonitor()`) for a `monitorForExternal` */

package/dist/cjs/entry-point/cancel-unhandled.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "preventUnhandled", {
+  enumerable: true,
+  get: function get() {
+    return _preventUnhandled.preventUnhandled;
+  }
+});
+var _preventUnhandled = require("../public-utils/prevent-unhandled");

package/dist/cjs/entry-point/{util/combine.js → combine.js}

@@ -9,4 +9,4 @@ Object.defineProperty(exports, "combine", {
     return _combine.combine;
   }
 });
-var _combine = require("../../util/combine");
+var _combine = require("../public-utils/combine");

package/dist/cjs/entry-point/{util → element}/center-under-pointer.js

@@ -9,4 +9,4 @@ Object.defineProperty(exports, "centerUnderPointer", {
     return _centerUnderPointer.centerUnderPointer;
   }
 });
-var _centerUnderPointer = require("../../util/custom-native-drag-preview/center-under-pointer");
+var _centerUnderPointer = require("../../public-utils/element/custom-native-drag-preview/center-under-pointer");