edytor 1.0.0-rc.3 → 2.0.0

package/dist/dnd/vendor/pragmatic/UPSTREAM.md

@@ -0,0 +1,103 @@
+# Vendored Pragmatic drag and drop — provenance & changes
+
+Atlassian's Pragmatic drag and drop, forked inside edytor: only the modules
+edytor reaches, as the packages publish them, so the block handles' and the
+table grips' drags run the library's own logic without depending on its
+packages. `src/lib/dnd/pragmatic.ts` is the one importer; nothing else in
+edytor imports from this directory. Do not edit these files by hand: re-sync
+(below) and record every change here.
+
+## Pinned source
+
+| Package                                         | Version | npm integrity (`pnpm-lock.yaml` before the fork)                                                          | License                           |
+| ----------------------------------------------- | ------- | --------------------------------------------------------------------------------------------------------- | --------------------------------- |
+| `@atlaskit/pragmatic-drag-and-drop`             | 4.0.0   | `sha512-pyDo2B5NiaExoKGmgeXKGNUL4aR4UzzSZm8QWWjYTEyBLVqSqKyKUwtVxMw2YEkakagOGFONUdHM32LAH2nPug==` | Apache-2.0, `…/LICENSE.md`        |
+| `@atlaskit/pragmatic-drag-and-drop-auto-scroll` | 3.2.1   | `sha512-2fhWAG48EjPoKhoHLG6RcT3/VaCzYEbRb6BtA/Vcfx4FrL0P1KrEgBJ6OAwB0X8MOV6UH22YgjFFHjv8fQD9rA==` | Apache-2.0, `…/LICENSE.md`        |
+| `bind-event-listener` (core's dependency)       | 3.0.0   | `sha512-PJvH288AWQhKs2v9zyfYdPzlPqf5bXbGMmhmUIY9x4dAUGIWgomO771oBQNwJnMQSnUIXhKu6sgzpBRXTlvb8Q==` | MIT © Alexander Reardon, `LICENSE` |
+| `raf-schd` (core's dependency)                  | 4.0.3   | `sha512-tQkJl2GRWh83ui2DiPTJz9wEiMN20syf+5oKfB03yYP7ioZcJwsIK8FjrtLwH1m7C7e+Tt2yYBlrOpdT+dyeIQ==` | MIT © Alex Reardon, `LICENSE`     |
+
+The core's third dependency, `@babel/runtime`, is not needed: the fork takes
+each package's `dist/es2019` build, which uses no Babel helper (object spread,
+destructuring and `for…of` are native there), not its `dist/esm` build.
+
+## Layout
+
+```text
+pragmatic-drag-and-drop/              dist/es2019/<path>.js and dist/types/<path>.d.ts of the core
+pragmatic-drag-and-drop-auto-scroll/  the same, of the auto-scroll package
+bind-event-listener/                  index.js, bind.js, bind-all.js: its src/*.ts with the types removed
+raf-schd/                             dist/raf-schd.esm.js, verbatim
+```
+
+Each package keeps its published directory structure, so a file here diffs
+against `dist/es2019/<same path>` (or `dist/types/<same path>` for a `.d.ts`).
+
+## What was kept
+
+The module closure of the three entry points `pragmatic.ts` imports, nothing
+else:
+
+- core `entry-point/element/adapter` (`draggable`, `dropTargetForElements`,
+  `monitorForElements`): the element adapter, the drag lifecycle, drop targets
+  and monitors, the honey pot fix, the window-leaving and broken-drag
+  detection;
+- core `entry-point/element/set-custom-native-drag-preview`;
+- auto-scroll `entry-point/element` (`autoScrollForElements`,
+  `autoScrollWindowForElements`, the over-element API and its scheduler).
+
+The `.d.ts` files are the declarations those entry points' types reach (9
+files); a `.js` without one is reached only from other vendored `.js`.
+Everything else the packages publish (the external and text-selection
+adapters, the other utilities, the hitbox package (the block handles split a
+row into its halves themselves), the unsafe-overflow auto-scroll, CommonJS and `dist/esm` builds) is left out.
+
+## Local changes (the only ones)
+
+1. **Import specifiers.** Every relative specifier gains its file extension
+   (`'./once'` → `'./once.js'`, a directory import its `/index.js`), so the
+   packaged `dist/` loads in Node as ES modules too. Every bare specifier
+   between the packages (`@atlaskit/pragmatic-drag-and-drop/adapter/element-adapter`,
+   `…/utils/combine`, `…/utils/once`, `…/get-element-from-point-without-honey-pot`,
+   `…/types` in the declarations) and to the two dependencies
+   (`bind-event-listener`, `raf-schd`) becomes the relative path of the
+   vendored file. This binds the auto-scroll package to the same core as the
+   element adapter: its monitor sees the drags the adapter starts (edytor
+   used to rebuild the auto-scroll API from its CommonJS `makeApi` for that,
+   since a browser bundle resolved the package's own bare import to a second
+   core). Specifiers quoted in comments (the `@deprecated` notes) stay as
+   written.
+2. **`bind-event-listener` in JavaScript.** The package publishes CommonJS
+   only; its three `src/*.ts` modules are vendored as ES modules with their
+   type annotations removed (the code, comments and names unchanged). Its
+   types are not needed: no vendored declaration names them.
+
+No statement of the libraries' own code is changed. A check that a re-sync
+reproduces this: strip every import specifier from each vendored file and from
+its upstream file, and compare: they are equal.
+
+## How edytor builds around it
+
+- `tsconfig*.json` exclude `src/lib/dnd/vendor/**`: TypeScript reads the
+  vendored `.d.ts` beside each entry `.js`, never checks the JavaScript.
+- ESLint, Prettier, `scripts/deps.mjs` (the context graph) and the line counts
+  (`scripts/xloc.mjs`, `scripts/bundle-size.mjs`) skip it as vendored code.
+- `package.json#sideEffects` lists the core's directory: upstream declares the
+  core with side effects (`count-events-for-safari.js` binds its WebKit
+  listeners at import), the auto-scroll without.
+- Nothing runs against the DOM at import (the core guards `typeof window`):
+  server rendering imports it as before.
+
+## Re-syncing with upstream
+
+1. Install the new versions of the two packages (and of `bind-event-listener`,
+   `raf-schd`) somewhere outside the package's dependencies.
+2. From each package's `module:es2019` entry (`element/adapter`,
+   `element/set-custom-native-drag-preview`, auto-scroll
+   `element`), follow every import; copy each reached `dist/es2019` file and,
+   from each entry's `types` field, each reached `dist/types` declaration to
+   the same path here, rewriting specifiers as in change 1.
+3. Redo change 2 from `bind-event-listener`'s `src/`; copy
+   `raf-schd/dist/raf-schd.esm.js`; copy the license files.
+4. Update the table above, run the drag lanes (the block handle, table, columns,
+   drop reach, auto-scroll, drag preview and press-after-drag specs in
+   Chromium, Firefox and WebKit, the jsdom drag rows) and the packed consumer.

package/dist/dnd/vendor/pragmatic/bind-event-listener/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Alexander Reardon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/dnd/vendor/pragmatic/bind-event-listener/bind-all.js

@@ -0,0 +1,46 @@
+import { bind } from './bind.js';
+
+function toOptions(value) {
+  if (typeof value === 'undefined') {
+    return undefined;
+  }
+
+  // Convert capture boolean format to options to object
+  if (typeof value === 'boolean') {
+    return {
+      capture: value,
+    };
+  }
+
+  // Already an object, don't need to convert it
+  return value;
+}
+
+function getBinding(original, sharedOptions) {
+  // No shared options, just return original binding
+  if (sharedOptions == null) {
+    return original;
+  }
+
+  const binding = {
+    ...original,
+    // Converting both options to object format for merging
+    options: {
+      ...toOptions(sharedOptions),
+      // Giving individual binding option precedence
+      ...toOptions(original.options),
+    },
+  };
+  return binding;
+}
+
+export function bindAll(target, bindings, sharedOptions) {
+  const unbinds = bindings.map((original) => {
+    const binding = getBinding(original, sharedOptions);
+    return bind(target, binding);
+  });
+
+  return function unbindAll() {
+    unbinds.forEach((unbind) => unbind());
+  };
+}

package/dist/dnd/vendor/pragmatic/bind-event-listener/bind.js

@@ -0,0 +1,7 @@
+export function bind(target, { type, listener, options }) {
+  target.addEventListener(type, listener, options);
+
+  return function unbind() {
+    target.removeEventListener(type, listener, options);
+  };
+}

package/dist/dnd/vendor/pragmatic/bind-event-listener/index.js

@@ -0,0 +1,2 @@
+export { bind } from './bind.js';
+export { bindAll } from './bind-all.js';

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/LICENSE.md

@@ -0,0 +1,11 @@
+Copyright 2022 Atlassian Pty Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
+compliance with the License. You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is
+distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied. See the License for the specific language governing permissions and limitations under the
+License.

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/adapter/element-adapter-native-data-key.js

@@ -0,0 +1,6 @@
+/**
+ * This key has been pulled into a separate module
+ * so that the external adapter does not need to import
+ * the element adapter
+ */
+export const elementAdapterNativeDataKey = 'application/vnd.pdnd';

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/adapter/element-adapter.d.ts

@@ -0,0 +1,57 @@
+import { type AllEvents, type BaseEventPayload, type CleanupFn, type DropTargetArgs, type DropTargetEventBasePayload, type DropTargetEventPayloadMap, type DropTargetGetFeedbackArgs, type ElementDragType, type EventPayloadMap, type Input, type MonitorArgs, type MonitorGetFeedbackArgs, type NativeMediaType } from '../internal-types.js';
+export type { ElementDragPayload } from '../internal-types.js';
+type DraggableGetFeedbackArgs = {
+    /**
+     * 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;
+};
+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: DraggableGetFeedbackArgs) => boolean;
+    /** Used to attach data to a drag operation. Called once just before the drag starts */
+    getInitialData?: (args: DraggableGetFeedbackArgs) => Record<string, unknown>;
+    /** Attach data to the native drag data store.
+     * This function is useful to attach native data that can be extracted by other web pages
+     * or web applications
+     * Attaching native data in this way will _not_ cause the native adapter on this page to start
+     * Although it can cause a native adapter in other applications to start
+     * @example getInitialDataForExternal(() => ({'text/plain': item.description}))
+     * */
+    getInitialDataForExternal?: (args: DraggableGetFeedbackArgs) => {
+        [Key in NativeMediaType]?: string;
+    };
+} & Partial<AllEvents<ElementDragType>>;
+export declare const dropTargetForElements: (args: DropTargetArgs<ElementDragType>) => CleanupFn;
+export declare const monitorForElements: (args: MonitorArgs<ElementDragType>) => CleanupFn;
+export declare function draggable(args: DraggableArgs): CleanupFn;
+/** Common event payload for all events */
+export type ElementEventBasePayload = BaseEventPayload<ElementDragType>;
+/** A map containing payloads for all events */
+export type ElementEventPayloadMap = EventPayloadMap<ElementDragType>;
+/** Common event payload for all drop target events */
+export type ElementDropTargetEventBasePayload = DropTargetEventBasePayload<ElementDragType>;
+/** A map containing payloads for all events on drop targets */
+export type ElementDropTargetEventPayloadMap = DropTargetEventPayloadMap<ElementDragType>;
+/** Arguments given to all feedback functions (eg `canDrag()`) on for a `draggable()` */
+export type ElementGetFeedbackArgs = DraggableGetFeedbackArgs;
+/** Arguments given to all feedback functions (eg `canDrop()`) on a `dropTargetForElements()` */
+export type ElementDropTargetGetFeedbackArgs = DropTargetGetFeedbackArgs<ElementDragType>;
+/** Arguments given to all monitor feedback functions (eg `canMonitor()`) for a `monitorForElements` */
+export type ElementMonitorGetFeedbackArgs = MonitorGetFeedbackArgs<ElementDragType>;

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/adapter/element-adapter.js

@@ -0,0 +1,306 @@
+import { bind } from '../../bind-event-listener/index.js';
+import { getElementFromPointWithoutHoneypot } from '../honey-pot-fix/get-element-from-point-without-honey-pot.js';
+import { makeHoneyPotFix } from '../honey-pot-fix/make-honey-pot-fix.js';
+import { makeAdapter } from '../make-adapter/make-adapter.js';
+import { combine } from '../public-utils/combine.js';
+import { once } from '../public-utils/once.js';
+import { addAttribute } from '../util/add-attribute.js';
+import { androidFallbackText, isAndroid } from '../util/android.js';
+import { getInput } from '../util/get-input.js';
+import { textMediaType } from '../util/media-types/text-media-type.js';
+import { URLMediaType } from '../util/media-types/url-media-type.js';
+import { elementAdapterNativeDataKey } from './element-adapter-native-data-key.js';
+
+// Payload for the draggable being dragged
+// eslint-disable-next-line @atlaskit/volt-strict-mode/no-re-exports
+
+const draggableRegistry = new WeakMap();
+function addToRegistry(args) {
+  draggableRegistry.set(args.element, args);
+  return function cleanup() {
+    draggableRegistry.delete(args.element);
+  };
+}
+const honeyPotFix = makeHoneyPotFix();
+const adapter = makeAdapter({
+  typeKey: 'element',
+  defaultDropEffect: 'move',
+  mount(api) {
+    /**  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 combine(honeyPotFix.bindEvents(), bind(document, {
+      type: 'dragstart',
+      listener(event) {
+        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(`
+              It appears as though you have are not testing DragEvents correctly.
+
+              - If you are unit testing, ensure you have polyfilled DragEvent.
+              - If you are browser testing, ensure you are dispatching drag events correctly.
+
+              Please see our testing guides for more information:
+              https://atlassian.design/components/pragmatic-drag-and-drop/core-package/testing
+            `.replace(/ {2}/g, ''));
+          }
+          return;
+        }
+
+        // the closest parent that is a draggable element will be marked as
+        // the `event.target` for the event
+        const target = event.target;
+
+        // this source is only for elements
+        // Note: only HTMLElements can have the "draggable" attribute
+        if (!(target instanceof HTMLElement)) {
+          return;
+        }
+
+        // see if the thing being dragged is owned by us
+        const entry = draggableRegistry.get(target);
+
+        // no matching element found
+        // → dragging an element with `draggable="true"` that is not controlled by us
+        if (!entry) {
+          return;
+        }
+
+        /**
+         * A text selection drag _can_ have the `draggable` element be
+         * the `event.target` if the user is dragging the text selection
+         * from the `draggable`.
+         *
+         * To know if the `draggable` is being dragged, we look at whether any
+         * `"text/plain"` data is being dragged. If it is, then a text selection
+         * drag is occurring.
+         *
+         * This behaviour has been validated on:
+         *
+         * - Chrome@128 on Android@14
+         * - Chrome@128 on iOS@17.6.1
+         * - Chrome@128 on Windows@11
+         * - Chrome@128 on MacOS@14.6.1
+         * - Firefox@129 on Windows@11 (not possible for user to select text in a draggable)
+         * - Firefox@129 on MacOS@14.6.1 (not possible for user to select text in a draggable)
+         *
+         * Note: Could usually just use: `event.dataTransfer.types.includes(textMediaType)`
+         * but unfortunately ProseMirror is always setting `""` as the dragged text
+         *
+         * Note: Unfortunately editor is (heavily) leaning on the current functionality today
+         * and unwinding it will be a decent amount of effort. So for now, a text selection
+         * where the `event.target` is a `draggable` element will still trigger the
+         * element adapter.
+         *
+         * // Future state:
+         * if(event.dataTransfer.getData(textMediaType)) {
+         * 	return;
+         * }
+         *
+         */
+
+        const input = getInput(event);
+        const feedback = {
+          element: entry.element,
+          dragHandle: (_entry$dragHandle = entry.dragHandle) !== null && _entry$dragHandle !== void 0 ? _entry$dragHandle : null,
+          input
+        };
+
+        // Check: does the draggable want to allow dragging?
+        if (entry.canDrag && !entry.canDrag(feedback)) {
+          // cancel drag operation if we cannot drag
+          event.preventDefault();
+          return;
+        }
+
+        // Check: is there a drag handle and is the user using it?
+        if (entry.dragHandle) {
+          // technically don't need this util, but just being
+          // consistent with how we look up what is under the users
+          // cursor.
+          const over = getElementFromPointWithoutHoneypot({
+            x: input.clientX,
+            y: input.clientY
+          });
+
+          // if we are not dragging from the drag handle (or something inside the drag handle)
+          // then we will cancel the active drag
+          if (!entry.dragHandle.contains(over)) {
+            event.preventDefault();
+            return;
+          }
+        }
+
+        /**
+         *  **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
+         */
+        const 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 (const [key, data] of Object.entries(nativeData)) {
+            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
+         */
+        if (isAndroid() && !event.dataTransfer.types.includes(textMediaType) && !event.dataTransfer.types.includes(URLMediaType)) {
+          event.dataTransfer.setData(textMediaType, 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, '');
+        const payload = {
+          element: entry.element,
+          dragHandle: (_entry$dragHandle2 = entry.dragHandle) !== null && _entry$dragHandle2 !== void 0 ? _entry$dragHandle2 : null,
+          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 : {}
+        };
+        const dragType = {
+          type: 'element',
+          payload,
+          startedFrom: 'internal'
+        };
+        api.start({
+          event,
+          dragType
+        });
+      }
+    }));
+  },
+  dispatchEventToSource: ({
+    eventName,
+    payload
+  }) => {
+    var _draggableRegistry$ge, _draggableRegistry$ge2;
+    // During a drag operation, a draggable can be:
+    // - remounted with different functions
+    // - removed completely
+    // So we need to get the latest entry from the registry in order
+    // to call the latest event functions
+
+    (_draggableRegistry$ge = draggableRegistry.get(payload.source.element)) === null || _draggableRegistry$ge === void 0 ? void 0 : (_draggableRegistry$ge2 = _draggableRegistry$ge[eventName]) === null || _draggableRegistry$ge2 === void 0 ? void 0 : _draggableRegistry$ge2.call(_draggableRegistry$ge,
+    // I cannot seem to get the types right here.
+    // TS doesn't seem to like that one event can need `nativeSetDragImage`
+    // @ts-expect-error
+    payload);
+  },
+  onPostDispatch: honeyPotFix.getOnPostDispatch()
+});
+export const dropTargetForElements = adapter.dropTarget;
+// eslint-disable-next-line @atlaskit/volt-strict-mode/no-multiple-exports
+export const monitorForElements = adapter.monitor;
+
+// eslint-disable-next-line @atlaskit/volt-strict-mode/no-multiple-exports
+export function draggable(args) {
+  // Guardrail: warn if the drag handle is not contained in draggable element
+  if (process.env.NODE_ENV !== 'production') {
+    if (args.dragHandle && !args.element.contains(args.dragHandle)) {
+      // eslint-disable-next-line no-console
+      console.warn('Drag handle element must be contained in draggable element', {
+        element: args.element,
+        dragHandle: args.dragHandle
+      });
+    }
+  }
+  // Guardrail: warn if the draggable element is already registered
+  if (process.env.NODE_ENV !== 'production') {
+    const existing = draggableRegistry.get(args.element);
+    if (existing) {
+      // eslint-disable-next-line no-console
+      console.warn('You have already registered a `draggable` on the same element', {
+        existing,
+        proposed: args
+      });
+    }
+  }
+  const cleanup = combine(
+  // making the draggable register the adapter rather than drop targets
+  // this is because you *must* have a draggable element to start a drag
+  // but you _might_ not have any drop targets immediately
+  // (You might create drop targets async)
+  adapter.registerUsage(), addToRegistry(args), addAttribute(args.element, {
+    attribute: 'draggable',
+    value: 'true'
+  }));
+
+  // Wrapping in `once` to prevent unexpected side effects if consumers call
+  // the clean up function multiple times.
+  return once(cleanup);
+}
+
+/** 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/dnd/vendor/pragmatic/pragmatic-drag-and-drop/entry-point/element/adapter.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @deprecated Use `import { draggable, dropTargetForElements, monitorForElements } from '@atlaskit/pragmatic-drag-and-drop/adapter/element-adapter'` instead.
+ */
+export { draggable, dropTargetForElements, monitorForElements, type ElementEventBasePayload, type ElementEventPayloadMap, type ElementDropTargetEventBasePayload, type ElementDropTargetEventPayloadMap, type ElementGetFeedbackArgs, type ElementDropTargetGetFeedbackArgs, type ElementMonitorGetFeedbackArgs, } from '../../adapter/element-adapter.js';
+/**
+ * @deprecated Use `import { ElementEventBasePayload, ElementEventPayloadMap, ElementDropTargetEventBasePayload, ElementDropTargetEventPayloadMap, ElementGetFeedbackArgs, ElementDropTargetGetFeedbackArgs, ElementMonitorGetFeedbackArgs, ElementDragPayload } from '@atlaskit/pragmatic-drag-and-drop/adapter/element-adapter'` instead.
+ */
+export type { ElementDragPayload } from '../../internal-types.js';

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/entry-point/element/adapter.js

@@ -0,0 +1,10 @@
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
+/**
+ * @deprecated Use `import { draggable, dropTargetForElements, monitorForElements } from '@atlaskit/pragmatic-drag-and-drop/adapter/element-adapter'` instead.
+ */
+
+export { draggable, dropTargetForElements, monitorForElements } from '../../adapter/element-adapter.js';
+
+/**
+ * @deprecated Use `import { ElementEventBasePayload, ElementEventPayloadMap, ElementDropTargetEventBasePayload, ElementDropTargetEventPayloadMap, ElementGetFeedbackArgs, ElementDropTargetGetFeedbackArgs, ElementMonitorGetFeedbackArgs, ElementDragPayload } from '@atlaskit/pragmatic-drag-and-drop/adapter/element-adapter'` instead.
+ */

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/entry-point/element/set-custom-native-drag-preview.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @deprecated Use `import { setCustomNativeDragPreview } from '@atlaskit/pragmatic-drag-and-drop/utils/set-custom-native-drag-preview'` instead.
+ */
+export { setCustomNativeDragPreview } from '../../public-utils/element/custom-native-drag-preview/set-custom-native-drag-preview.js';

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/entry-point/element/set-custom-native-drag-preview.js

@@ -0,0 +1,6 @@
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
+/**
+ * @deprecated Use `import { setCustomNativeDragPreview } from '@atlaskit/pragmatic-drag-and-drop/utils/set-custom-native-drag-preview'` instead.
+ */
+
+export { setCustomNativeDragPreview } from '../../public-utils/element/custom-native-drag-preview/set-custom-native-drag-preview.js';

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/entry-point/types.d.ts

@@ -0,0 +1 @@
+export type { DropTargetAllowedDropEffect, DropTargetRecord, Position, Input, DragLocation, DragLocationHistory, CleanupFn, AllDragTypes, MonitorArgs, BaseEventPayload, ElementDragType, TextSelectionDragType, ExternalDragType, } from '../internal-types.js';

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/honey-pot-fix/get-element-from-point-without-honey-pot.js

@@ -0,0 +1,12 @@
+import { isHoneyPotElement } from './is-honey-pot-element.js';
+export function getElementFromPointWithoutHoneypot(client) {
+  // eslint-disable-next-line no-restricted-syntax
+  const [top, second] = document.elementsFromPoint(client.x, client.y);
+  if (!top) {
+    return null;
+  }
+  if (isHoneyPotElement(top)) {
+    return second !== null && second !== void 0 ? second : null;
+  }
+  return top;
+}

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/honey-pot-fix/honey-pot-data-attribute.js

@@ -0,0 +1,3 @@
+// pulling this into a separate file so adapter(s) that don't
+// need the honey pot can pay as little as possible for it.
+export const honeyPotDataAttribute = 'data-pdnd-honey-pot';

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/honey-pot-fix/is-honey-pot-element.js

@@ -0,0 +1,4 @@
+import { honeyPotDataAttribute } from './honey-pot-data-attribute.js';
+export function isHoneyPotElement(target) {
+  return target instanceof Element && target.hasAttribute(honeyPotDataAttribute);
+}