edytor 1.0.0 → 3.0.0

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);
+}

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

@@ -1,7 +1,5 @@
 import { bind, bindAll } from '../../bind-event-listener/index.js';
-import { maxZIndex } from '../util/max-z-index.js';
 import { popoverResetUserAgentStyles } from '../util/popover-reset-styles.js';
-import { supportsPopover } from '../util/supports-popover.js';
 import { honeyPotDataAttribute } from './honey-pot-data-attribute.js';
 const honeyPotSize = 2;
 const halfHoneyPotSize = honeyPotSize / 2;
@@ -137,9 +135,8 @@ function mountHoneyPot({
   // including elements using z-index and other stacking contexts.
   // "manual" means no light dismiss — we manage the lifecycle ourselves.
   // Falls back to position:fixed + maxZIndex when the popover API is not available.
-  if (supportsPopover()) {
-    element.setAttribute('popover', 'manual');
-  }
+  // edytor: every supported engine has the Popover API (no fallback).
+  element.setAttribute('popover', 'manual');
 
   // can shift during the drag thanks to Firefox
   let clientRect = getHoneyPotRectFor({
@@ -147,14 +144,7 @@ function mountHoneyPot({
   });
   Object.assign(element.style, {
     position: 'fixed',
-    ...(supportsPopover() ?
-    // needs to come first as it has 'inset: unset' which
-    // needs to be overridden by our top / left values
-    popoverResetUserAgentStyles : {
-      // Fallback: using maximum possible z-index so that this element
-      // will always be on top of other positioned content.
-      zIndex: maxZIndex
-    }),
+    ...popoverResetUserAgentStyles,
     // Setting a background color explicitly to avoid any inherited styles.
     // Looks like this could be `opacity: 0`, but worried that _might_
     // cause the element to be ignored on some platforms.
@@ -172,9 +162,7 @@ function mountHoneyPot({
     })
   });
   document.body.appendChild(element);
-  if (supportsPopover()) {
-    element.showPopover();
-  }
+  element.showPopover();
 
   /**
    *  🦊 In firefox we can get `"pointermove"` events after the drag

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

@@ -243,9 +243,7 @@ export type MonitorGetFeedbackArgs<DragType extends AllDragTypes> = {
      */
     source: DragType['payload'];
 };
-export type MonitorArgs<DragType extends AllDragTypes> = Partial<AllEvents<DragType>> & {
-    canMonitor?: (args: MonitorGetFeedbackArgs<DragType>) => boolean;
-};
+export type MonitorArgs<DragType extends AllDragTypes> = Partial<AllEvents<DragType>>;
 export type DropTargetGetFeedbackArgs<DragType extends AllDragTypes> = {
     /**
      * The users _current_ input
@@ -318,11 +316,6 @@ export type DropTargetArgs<DragType extends AllDragTypes> = {
      * dropped on.
      */
     canDrop?: (args: DropTargetGetFeedbackArgs<DragType>) => boolean;
-    /**
-     * Optionally provide a _drop effect_ to be applied when
-     * this drop target is the innermost drop target being dragged over.
-     */
-    getDropEffect?: (args: DropTargetGetFeedbackArgs<DragType>) => DropTargetAllowedDropEffect;
     /**
      * Return `true` if you want your drop target to hold onto
      * selection after the user is no longer dragging over this drop target.

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

@@ -51,7 +51,7 @@ export function makeDropTarget({
     input,
     result = []
   }) {
-    var _args$getData, _args$getData2, _args$getDropEffect, _args$getDropEffect2;
+    var _args$getData, _args$getData2;
     if (target == null) {
       return result;
     }
@@ -104,7 +104,8 @@ export function makeDropTarget({
 
     // calculate our new record
     const data = (_args$getData = (_args$getData2 = args.getData) === null || _args$getData2 === void 0 ? void 0 : _args$getData2.call(args, feedback)) !== null && _args$getData !== void 0 ? _args$getData : {};
-    const dropEffect = (_args$getDropEffect = (_args$getDropEffect2 = args.getDropEffect) === null || _args$getDropEffect2 === void 0 ? void 0 : _args$getDropEffect2.call(args, feedback)) !== null && _args$getDropEffect !== void 0 ? _args$getDropEffect : defaultDropEffect;
+    // edytor: no drop target sets `getDropEffect`.
+    const dropEffect = defaultDropEffect;
     const record = {
       data,
       element: args.element,
@@ -150,7 +151,6 @@ export function makeDropTarget({
       const isCurrent = new Set(payload.location.current.dropTargets.map(record => record.element));
       const visited = new Set();
       for (const record of payload.location.previous.dropTargets) {
-        var _entry$onDropTargetCh;
         visited.add(record.element);
         const entry = registry.get(record.element);
         const isOver = isCurrent.has(record.element);
@@ -158,7 +158,7 @@ export function makeDropTarget({
           ...payload,
           self: record
         };
-        entry === null || entry === void 0 ? void 0 : (_entry$onDropTargetCh = entry.onDropTargetChange) === null || _entry$onDropTargetCh === void 0 ? void 0 : _entry$onDropTargetCh.call(entry, args);
+        // edytor: no drop target sets `onDropTargetChange`.
 
         // if we cannot find the drop target in the current array, then it has been left
         if (!isOver) {
@@ -167,7 +167,7 @@ export function makeDropTarget({
         }
       }
       for (const record of payload.location.current.dropTargets) {
-        var _entry$onDropTargetCh2, _entry$onDragEnter;
+        var _entry$onDragEnter;
         // already published an update to this drop target
         if (visited.has(record.element)) {
           continue;
@@ -178,7 +178,6 @@ export function makeDropTarget({
           self: record
         };
         const entry = registry.get(record.element);
-        entry === null || entry === void 0 ? void 0 : (_entry$onDropTargetCh2 = entry.onDropTargetChange) === null || _entry$onDropTargetCh2 === void 0 ? void 0 : _entry$onDropTargetCh2.call(entry, args);
         entry === null || entry === void 0 ? void 0 : (_entry$onDragEnter = entry.onDragEnter) === null || _entry$onDragEnter === void 0 ? void 0 : _entry$onDragEnter.call(entry, args);
       }
     }