edytor 2.0.0 → 4.0.0

package/dist/dnd/dropIndicator.js

@@ -1,4 +1,4 @@
-import { getOwnRowBottom, isBeside, nestIndent, ownRow, ownTextRow } from './geometry.js';
+import { cssVar, getOwnRowBottom, isBeside, nestIndent, ownRow, ownTextRow } from './geometry.js';
 /** Notion's drop bar: 4px (its height in `BlockHandles.svelte`, its look the app's). */
 const BAR = 4;
 /** Place `element` at `box`, relative to the layer (`origin`). */
@@ -14,10 +14,7 @@ const place = (element, box, origin) => Object.assign(element.style, {
  * unset there without one.
  */
 const themed = (from, name) => {
-    const value = from.ownerDocument.defaultView
-        ?.getComputedStyle(from)
-        .getPropertyValue(name)
-        .trim();
+    const value = cssVar(from, name);
     return (element) => value ? element.style.setProperty(name, value) : element.style.removeProperty(name);
 };
 /**

package/dist/dnd/external.d.ts

@@ -0,0 +1,6 @@
+import type { Scrollers } from './autoScroll.js';
+export { dropTargetForExternal } from './vendor/pragmatic/pragmatic-drag-and-drop/adapter/drop-target-for-external.js';
+export { containsFiles } from './vendor/pragmatic/pragmatic-drag-and-drop/public-utils/external/contains-files.js';
+export { getFiles } from './vendor/pragmatic/pragmatic-drag-and-drop/public-utils/external/get-files.js';
+/** The external adapter's auto-scroll, while `ours()` (the drag is over this editor). */
+export declare const externalScrollers: (ours: () => boolean) => Scrollers;

package/dist/dnd/external.js

@@ -0,0 +1,17 @@
+// Pragmatic drag and drop's external adapter (vendored with the element
+// adapter, on its core, `vendor/pragmatic/UPSTREAM.md`): drags that start
+// outside the window (files from the desktop). Only the media plugins that
+// take an upload import it (`plugins/fileDrop.ts`), so a view without them
+// ships none of it.
+import { autoScrollForExternal, autoScrollWindowForExternal } from './vendor/pragmatic/pragmatic-drag-and-drop-auto-scroll/entry-point/external.js';
+export { dropTargetForExternal } from './vendor/pragmatic/pragmatic-drag-and-drop/adapter/drop-target-for-external.js';
+export { containsFiles } from './vendor/pragmatic/pragmatic-drag-and-drop/public-utils/external/contains-files.js';
+export { getFiles } from './vendor/pragmatic/pragmatic-drag-and-drop/public-utils/external/get-files.js';
+/** The external adapter's auto-scroll, while `ours()` (the drag is over this editor). */
+export const externalScrollers = (ours) => {
+    const canScroll = () => ours();
+    return {
+        window: () => autoScrollWindowForExternal({ canScroll }),
+        element: (element) => autoScrollForExternal({ element, canScroll })
+    };
+};

package/dist/dnd/geometry.d.ts

@@ -27,6 +27,8 @@ export declare const ownTextRow: (node: HTMLElement) => DOMRect;
  */
 export declare const NEST_INDENT = 24;
 export declare const nestIndent: (node: HTMLElement) => number;
+/** The theme variable `name` as `node` inherits it, read now (none outside a window). */
+export declare const cssVar: (node: HTMLElement, name: string) => string | undefined;
 /**
  * Whether `y` is over the hint of `node`'s empty body (`body.hint`, a kind's
  * `data-edytor-empty-body` element: an open toggle's, a callout's): a drop

package/dist/dnd/geometry.js

@@ -31,12 +31,11 @@ export const ownTextRow = (node) => {
  */
 export const NEST_INDENT = 24;
 export const nestIndent = (node) => {
-    const value = node.ownerDocument.defaultView
-        ?.getComputedStyle(node)
-        .getPropertyValue('--edytor-nest-indent')
-        .trim();
+    const value = cssVar(node, '--edytor-nest-indent');
     return value?.endsWith('px') ? parseFloat(value) : NEST_INDENT;
 };
+/** The theme variable `name` as `node` inherits it, read now (none outside a window). */
+export const cssVar = (node, name) => node.ownerDocument.defaultView?.getComputedStyle(node).getPropertyValue(name).trim();
 /**
  * Whether `y` is over the hint of `node`'s empty body (`body.hint`, a kind's
  * `data-edytor-empty-body` element: an open toggle's, a callout's): a drop

package/dist/dnd/placement.d.ts

@@ -5,7 +5,7 @@
  * (`Drag`: the blocks it moves, none for files) and the placements the
  * document takes for it (`fits`); the rows are the view's drop targets
  * (`targetOf`). The block handles wire it to the drag library; a file drag
- * reads it from the host's own `dragover` (the media plugins' `plugins/fileDrop.ts`).
+ * reads it from Pragmatic's external adapter (the media plugins' `plugins/fileDrop.ts`).
  */
 import type { Block } from '../block/block.svelte.js';
 import type { Edytor } from '../edytor.svelte.js';

package/dist/dnd/pragmatic.d.ts

@@ -1,4 +1,6 @@
+import type { Scrollers } from './autoScroll.js';
 export { draggable, dropTargetForElements } from './vendor/pragmatic/pragmatic-drag-and-drop/entry-point/element/adapter.js';
 export type { ElementDropTargetEventPayloadMap } from './vendor/pragmatic/pragmatic-drag-and-drop/entry-point/element/adapter.js';
 export { setCustomNativeDragPreview } from './vendor/pragmatic/pragmatic-drag-and-drop/entry-point/element/set-custom-native-drag-preview.js';
-export { autoScrollForElements as autoScroll, autoScrollWindowForElements as autoScrollWindow } from './vendor/pragmatic/pragmatic-drag-and-drop-auto-scroll/entry-point/element.js';
+/** The element adapter's auto-scroll, for the drags whose data `ours` says are this editor's. */
+export declare const elementScrollers: (ours: (data: Record<string | symbol, unknown>) => boolean) => Scrollers;

package/dist/dnd/pragmatic.js

@@ -1,7 +1,17 @@
 // Atlassian's Pragmatic drag and drop, forked in `vendor/pragmatic` (its own
 // ES2019 build, `UPSTREAM.md`): the element adapter, the custom native drag
 // preview and the element auto-scroll, all on one core,
-// so the auto-scroll's monitor sees the drags this adapter starts.
+// so the auto-scroll's monitor sees the drags this adapter starts. The
+// external adapter (files dragged from outside) is `external.ts`'s, loaded
+// only by the media plugins that take an upload.
+import { autoScrollForElements, autoScrollWindowForElements } from './vendor/pragmatic/pragmatic-drag-and-drop-auto-scroll/entry-point/element.js';
 export { draggable, dropTargetForElements } from './vendor/pragmatic/pragmatic-drag-and-drop/entry-point/element/adapter.js';
 export { setCustomNativeDragPreview } from './vendor/pragmatic/pragmatic-drag-and-drop/entry-point/element/set-custom-native-drag-preview.js';
-export { autoScrollForElements as autoScroll, autoScrollWindowForElements as autoScrollWindow } from './vendor/pragmatic/pragmatic-drag-and-drop-auto-scroll/entry-point/element.js';
+/** The element adapter's auto-scroll, for the drags whose data `ours` says are this editor's. */
+export const elementScrollers = (ours) => {
+    const canScroll = ({ source }) => ours(source.data);
+    return {
+        window: () => autoScrollWindowForElements({ canScroll }),
+        element: (element) => autoScrollForElements({ element, canScroll })
+    };
+};

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

@@ -2,9 +2,10 @@
 
 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
+table grips' drags, and files dragged from outside, run the library's own logic without depending on its
+packages. `src/lib/dnd/pragmatic.ts` (the element adapter) and `src/lib/dnd/external.ts`
+(the external adapter, imported only by the media plugins that take an
+upload) are the importers; 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
@@ -34,8 +35,8 @@ 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:
+The module closure of the entry points `pragmatic.ts` and `external.ts`
+import, nothing else:
 
 - core `entry-point/element/adapter` (`draggable`, `dropTargetForElements`,
   `monitorForElements`): the element adapter, the drag lifecycle, drop targets
@@ -43,12 +44,20 @@ else:
   detection;
 - core `entry-point/element/set-custom-native-drag-preview`;
 - auto-scroll `entry-point/element` (`autoScrollForElements`,
-  `autoScrollWindowForElements`, the over-element API and its scheduler).
+  `autoScrollWindowForElements`, the over-element API and its scheduler);
+- core `adapter/drop-target-for-external` (`dropTargetForExternal`: the
+  external adapter, its drag of what enters the window, the window-entering
+  detection, the available types and items) and `adapter/monitor-for-external`
+  (the auto-scroll's monitor), `public-utils/external/contains-files` and
+  `get-files` (`containsFiles`, `getFiles`): files dragged from outside;
+- auto-scroll `entry-point/external` (`autoScrollForExternal`,
+  `autoScrollWindowForExternal`), on the same over-element API.
 
 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
+files for the element entries, 8 for the external ones); a `.js` without one is reached only from other vendored `.js`.
+Everything else the packages publish (the text-selection adapter, the
+external adapter's text, HTML and URL getters (edytor reads only files from
+an external drag; text and HTML drops stay the core's `events/onDrop.ts`), 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)
@@ -57,7 +66,7 @@ row into its halves themselves), the unsafe-overflow auto-scroll, CommonJS and `
    (`'./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`,
+   `…/adapter/monitor-for-external`, `…/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
@@ -71,9 +80,31 @@ row into its halves themselves), the unsafe-overflow auto-scroll, CommonJS and `
    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.
+3. **Options edytor never passes, removed** (each site marked `// edytor:`):
+   the auto-scroll's `getConfiguration` (its speed is the standard one, a
+   constant `internalConfig`) and `getAllowedAxis` (both axes always:
+   `shared/is-axis-allowed.js` is gone), and its distance dampening always on
+   (`get-scroll-by.js` reads its two axes through one `change`); a
+   `draggable`'s `dragHandle`, a drop target's `getDropEffect` and
+   `onDropTargetChange`, a monitor's `canMonitor`, and the native drag
+   preview's default `getOffset` (both callers give theirs). Their
+   declarations go too, so a caller passing one does not compile. And no
+   fallback for an engine without the Popover API (every supported engine
+   has it: `util/supports-popover.js` and `util/max-z-index.js` are gone);
+   the jsdom lanes stub `showPopover`.
+
+4. **An external drag's items show their `kind` and `type` while dragging**
+   (`adapter/external-adapter.js`, marked `// edytor:`): upstream locks
+   `items: []` until the drop; edytor snapshots each `DataTransferItem`'s
+   `kind` and `type` at the `dragenter` (what browsers expose then; the
+   live list empties after the event), with `getAsFile()` answering `null`.
+   The drop's payload is upstream's (the real items). The file drop reads it
+   to show the line only where the dragged files would land.
+
+No other 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 but for the sites of
+changes 3 and 4.
 
 ## How edytor builds around it
 
@@ -83,7 +114,8 @@ its upstream file, and compare: they are equal.
   (`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.
+  listeners at import, `adapter/external-adapter.js` its window `dragenter`
+  and `dragstart` listeners), the auto-scroll without.
 - Nothing runs against the DOM at import (the core guards `typeof window`):
   server rendering imports it as before.
 
@@ -92,12 +124,13 @@ its upstream file, and compare: they are equal.
 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,
+   `element/set-custom-native-drag-preview`, `adapter/drop-target-for-external`,
+   `adapter/monitor-for-external`, `utils/contains-files`, `utils/get-files`,
+   auto-scroll `element` and `external`), 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
+3. Redo change 2 from `bind-event-listener`'s `src/`, and changes 3 and 4; 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
+   drop reach, auto-scroll, drag preview, press-after-drag and file drop specs in
    Chromium, Firefox and WebKit, the jsdom drag rows) and the packed consumer.

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/adapter/drop-target-for-external.d.ts

@@ -0,0 +1,4 @@
+import { type CleanupFn } from '../internal-types.js';
+import { adapter } from './external-adapter.js';
+import type { StripEventsForDropTargets } from './external-adapter-types.js';
+export declare function dropTargetForExternal(args: StripEventsForDropTargets<Parameters<typeof adapter.dropTarget>[0]>): CleanupFn;

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/adapter/drop-target-for-external.js

@@ -0,0 +1,6 @@
+import { adapter } from './external-adapter.js';
+// eslint-disable-next-line @atlaskit/volt-strict-mode/no-multiple-exports
+export function dropTargetForExternal(args) {
+  // not removing unused events, just leaning on the type system
+  return adapter.dropTarget(args);
+}

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

@@ -21,8 +21,6 @@ type DraggableArgs = {
      * 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 */

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

@@ -1,5 +1,4 @@
 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';
@@ -34,7 +33,7 @@ const adapter = makeAdapter({
     return combine(honeyPotFix.bindEvents(), bind(document, {
       type: 'dragstart',
       listener(event) {
-        var _entry$dragHandle, _entry$getInitialData, _entry$getInitialData2, _entry$dragHandle2, _entry$getInitialData3, _entry$getInitialData4;
+        var _entry$getInitialData, _entry$getInitialData2, _entry$getInitialData3, _entry$getInitialData4;
         if (!api.canStart(event)) {
           return;
         }
@@ -123,7 +122,8 @@ const adapter = makeAdapter({
         const input = getInput(event);
         const feedback = {
           element: entry.element,
-          dragHandle: (_entry$dragHandle = entry.dragHandle) !== null && _entry$dragHandle !== void 0 ? _entry$dragHandle : null,
+          // edytor: no draggable sets `dragHandle`.
+          dragHandle: null,
           input
         };
 
@@ -134,24 +134,6 @@ const adapter = makeAdapter({
           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
@@ -215,7 +197,7 @@ const adapter = makeAdapter({
         event.dataTransfer.setData(elementAdapterNativeDataKey, '');
         const payload = {
           element: entry.element,
-          dragHandle: (_entry$dragHandle2 = entry.dragHandle) !== null && _entry$dragHandle2 !== void 0 ? _entry$dragHandle2 : null,
+          dragHandle: 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 = {

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

@@ -0,0 +1,26 @@
+import { type BaseEventPayload, type DropTargetEventBasePayload, type DropTargetEventPayloadMap, type DropTargetGetFeedbackArgs, type EventPayloadMap, type ExternalDragType, type MonitorGetFeedbackArgs } from '../internal-types.js';
+export type { NativeMediaType, ExternalDragPayload } from '../internal-types.js';
+export /**
+ * 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`
+ */ type StripEventsForDropTargets<T> = Omit<T, 'onGenerateDragPreview' | 'onDragStart'>;
+export type StripEventsForMonitors<T> = Omit<T, 'onGenerateDragPreview'>;
+/** Common event payload for all events */
+export type ExternalEventBasePayload = BaseEventPayload<ExternalDragType>;
+/** A map containing payloads for all events */
+export type ExternalEventPayloadMap = StripEventsForMonitors<EventPayloadMap<ExternalDragType>>;
+/** Common event payload for all drop target events */
+export type ExternalDropTargetEventBasePayload = DropTargetEventBasePayload<ExternalDragType>;
+/** A map containing payloads for all events on drop targets */
+export type ExternalDropTargetEventPayloadMap = StripEventsForDropTargets<DropTargetEventPayloadMap<ExternalDragType>>;
+/** Arguments given to all feedback functions (eg `canDrop()`) on a `dropTargetForExternal` */
+export type ExternalDropTargetGetFeedbackArgs = DropTargetGetFeedbackArgs<ExternalDragType>;
+/** Arguments given to all monitor feedback functions (eg `canMonitor()`) for a `monitorForExternal` */
+export type ExternalMonitorGetFeedbackArgs = MonitorGetFeedbackArgs<ExternalDragType>;

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

@@ -0,0 +1,30 @@
+import { type BaseEventPayload, type CleanupFn, type DropTargetArgs, type DropTargetEventBasePayload, type DropTargetEventPayloadMap, type DropTargetGetFeedbackArgs, type EventPayloadMap, type ExternalDragType, type MonitorArgs, type MonitorGetFeedbackArgs } from '../internal-types.js';
+export declare const adapter: {
+    registerUsage: () => CleanupFn;
+    dropTarget: (args: DropTargetArgs<ExternalDragType>) => CleanupFn;
+    monitor: (args: MonitorArgs<ExternalDragType>) => CleanupFn;
+};
+export /**
+ * 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`
+ */ type StripEventsForDropTargets<T> = Omit<T, 'onGenerateDragPreview' | 'onDragStart'>;
+export type StripEventsForMonitors<T> = Omit<T, 'onGenerateDragPreview'>;
+/** Common event payload for all events */
+export type ExternalEventBasePayload = BaseEventPayload<ExternalDragType>;
+/** A map containing payloads for all events */
+export type ExternalEventPayloadMap = StripEventsForMonitors<EventPayloadMap<ExternalDragType>>;
+/** Common event payload for all drop target events */
+export type ExternalDropTargetEventBasePayload = DropTargetEventBasePayload<ExternalDragType>;
+/** A map containing payloads for all events on drop targets */
+export type ExternalDropTargetEventPayloadMap = StripEventsForDropTargets<DropTargetEventPayloadMap<ExternalDragType>>;
+/** Arguments given to all feedback functions (eg `canDrop()`) on a `dropTargetForExternal` */
+export type ExternalDropTargetGetFeedbackArgs = DropTargetGetFeedbackArgs<ExternalDragType>;
+/** Arguments given to all monitor feedback functions (eg `canMonitor()`) for a `monitorForExternal` */
+export type ExternalMonitorGetFeedbackArgs = MonitorGetFeedbackArgs<ExternalDragType>;

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

@@ -0,0 +1,203 @@
+import { bind, bindAll } from '../../bind-event-listener/index.js';
+import { makeAdapter } from '../make-adapter/make-adapter.js';
+import { isEnteringWindow } from '../util/changing-window/is-entering-window.js';
+import { getBindingsForBrokenDrags } from '../util/detect-broken-drag.js';
+import { getAvailableItems } from './get-available-items.js';
+import { getAvailableTypes } from './get-available-types.js';
+import { isAnAvailableType } from './is-an-available-type.js';
+let didDragStartLocally = false;
+export const adapter = makeAdapter({
+  typeKey: 'external',
+  // for external drags, we are generally making a copy of something that is being dragged
+  defaultDropEffect: 'copy',
+  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 bind(window, {
+      type: 'dragenter',
+      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(`
+              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;
+        }
+        if (!api.canStart(event)) {
+          return;
+        }
+        if (!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
+        const types = getAvailableTypes(event.dataTransfer);
+        if (!types.length) {
+          return;
+        }
+        const locked = {
+          types,
+          // edytor: the items' `kind` and `type` as the browser shows them while
+          // dragging (no data: `getAsFile()` is `null` until the drop), snapshotted
+          // since the live list empties once the event is dispatched.
+          items: Array.from(event.dataTransfer.items ?? [], ({
+            kind,
+            type
+          }) => ({
+            kind,
+            type,
+            getAsFile: () => null,
+            getAsString: () => {}
+          })),
+          getStringData: () => null
+        };
+        api.start({
+          event,
+          dragType: {
+            type: 'external',
+            startedFrom: 'external',
+            payload: locked,
+            getDropPayload(event) {
+              // this would be a platform error
+              // trying to handle it gracefully rather than throwing (for now)
+              if (!event.dataTransfer) {
+                return locked;
+              }
+              const items = getAvailableItems(event.dataTransfer);
+              // need to use `.bind` as `getData` is required
+              // to be run with `event.dataTransfer` as the "this" context
+              const nativeGetData = event.dataTransfer.getData.bind(event.dataTransfer);
+              return {
+                types,
+                items,
+                // return `null` if there is no result, otherwise string
+                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.
+                  const value = nativeGetData(mediaType);
+
+                  // not exposing data for unavailable types
+                  if (!isAnAvailableType({
+                    type: mediaType,
+                    value
+                  })) {
+                    return null;
+                  }
+                  return value;
+                }
+              };
+            }
+          }
+        });
+      }
+    });
+  }
+});
+
+/** 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` */
+
+(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
+
+  const idle = {
+    type: 'idle'
+  };
+  let state = idle;
+  function clear() {
+    if (state.type !== 'dragging') {
+      return;
+    }
+    didDragStartLocally = false;
+    state.cleanup();
+    state = idle;
+  }
+  function bindEndEvents() {
+    return bindAll(window, [{
+      type: 'dragend',
+      listener: clear
+    }, ...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
+  bind(window, {
+    type: 'dragstart',
+    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
+    }
+  });
+})();

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/adapter/get-available-items.js

@@ -0,0 +1,13 @@
+import { isAnAvailableType } from './is-an-available-type.js';
+
+// eslint-disable-next-line @atlaskit/volt-strict-mode/no-multiple-exports
+export 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(item => item.kind === 'file' || isAnAvailableType({
+    type: item.type,
+    value: dataTransfer.getData(item.type)
+  }));
+}

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/adapter/get-available-types.js

@@ -0,0 +1,9 @@
+import { isAnAvailableType } from './is-an-available-type.js';
+
+// eslint-disable-next-line @atlaskit/volt-strict-mode/no-multiple-exports
+export function getAvailableTypes(transfer) {
+  return Array.from(transfer.types).filter(type => isAnAvailableType({
+    type,
+    value: transfer.getData(type)
+  }));
+}

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/adapter/is-an-available-type.js

@@ -0,0 +1,19 @@
+import { androidFallbackText } from '../util/android.js';
+import { textMediaType } from '../util/media-types/text-media-type.js';
+import { elementAdapterNativeDataKey } from './element-adapter-native-data-key.js';
+export function isAnAvailableType({
+  type,
+  value
+}) {
+  // We don't want to expose our private elementAdapter key / value
+  if (type === 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 && value === androidFallbackText) {
+    return false;
+  }
+  return true;
+}

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/adapter/monitor-for-external.d.ts

@@ -0,0 +1,4 @@
+import { type CleanupFn } from '../internal-types.js';
+import { adapter } from './external-adapter.js';
+import type { StripEventsForMonitors } from './external-adapter-types.js';
+export declare function monitorForExternal(args: StripEventsForMonitors<Parameters<typeof adapter.monitor>[0]>): CleanupFn;

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/adapter/monitor-for-external.js

@@ -0,0 +1,6 @@
+import { adapter } from './external-adapter.js';
+// eslint-disable-next-line @atlaskit/volt-strict-mode/no-multiple-exports
+export function monitorForExternal(args) {
+  // not removing unused events, just leaning on the type system
+  return adapter.monitor(args);
+}