edytor 2.0.0 → 3.0.0

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

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

@@ -9,9 +9,8 @@ export function makeMonitor() {
     // Monitor is allowed to monitor events if:
     // 1. It has no `canMonitor` function (default is that a monitor can listen to everything)
     // 2. `canMonitor` returns true
-    if (!monitor.canMonitor || monitor.canMonitor(dragging.canMonitorArgs)) {
-      dragging.active.add(monitor);
-    }
+    // edytor: no monitor sets `canMonitor`.
+    dragging.active.add(monitor);
   }
   function monitorForConsumers(args) {
     // We are giving each `args` a new reference so that you

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

@@ -29,7 +29,7 @@ type RenderFn = ({ container, }: {
  * });
  */
 export declare function setCustomNativeDragPreview({ render, nativeSetDragImage, getOffset, }: {
-    getOffset?: GetOffsetFn;
+    getOffset: GetOffsetFn;
     render: RenderFn;
     nativeSetDragImage: ElementEventPayloadMap['onGenerateDragPreview']['nativeSetDragImage'];
 }): void;

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

@@ -1,8 +1,6 @@
 import { monitorForElements } from '../../../adapter/element-adapter.js';
 import { isSafari } from '../../../util/is-safari.js';
-import { maxZIndex } from '../../../util/max-z-index.js';
 import { popoverResetUserAgentStyles } from '../../../util/popover-reset-styles.js';
-import { supportsPopover } from '../../../util/supports-popover.js';
 
 /** A function to remove the element that has been added to the `container`.
  * @example () => root.unmount()
@@ -10,13 +8,6 @@ import { supportsPopover } from '../../../util/supports-popover.js';
 
 /** A function that will render a preview element into a `container` `HTMLElement` */
 
-/** By default we use the build in values for the native drag preview: {x: 0, y: 0} */
-function defaultOffset() {
-  return {
-    x: 0,
-    y: 0
-  };
-}
 
 /** This function provides the ability to mount an element for it to be used as the native drag preview
  *
@@ -37,7 +28,8 @@ function defaultOffset() {
 export function setCustomNativeDragPreview({
   render,
   nativeSetDragImage,
-  getOffset = defaultOffset
+  // edytor: every caller gives its `getOffset`.
+  getOffset
 }) {
   const container = document.createElement('div');
 
@@ -50,23 +42,15 @@ export function setCustomNativeDragPreview({
   // Falls back to position:fixed + maxZIndex when the popover API is not available.
   // Note: the popover attribute must be set before the element is in the DOM.
   // `.showPopover()` is called further below after the element is appended to the body.
-  if (supportsPopover()) {
-    container.setAttribute('popover', 'manual');
-  }
+  // edytor: every supported engine has the Popover API (no fallback).
+  container.setAttribute('popover', 'manual');
   Object.assign(container.style, {
     // Ensuring we don't cause reflow when adding the element to the page
     // Using `position:fixed` rather than `position:absolute` so we are
     // positioned on the current viewport.
     // `position:fixed` also creates a new stacking context, so we don't need to do that here
     position: 'fixed',
-    ...(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,
     // According to `mdn`, the element can be offscreen:
     // https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer/setDragImage#imgelement
     //
@@ -82,9 +66,7 @@ export function setCustomNativeDragPreview({
   document.body.append(container);
 
   // `.showPopover()` must be called after the element is in the DOM.
-  if (supportsPopover()) {
-    container.showPopover();
-  }
+  container.showPopover();
   const unmount = render({
     container
   });

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/public-utils/external/contains-files.d.ts

@@ -0,0 +1,2 @@
+import { type ContainsSource } from './native-types.js';
+export declare function containsFiles({ source }: ContainsSource): boolean;

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/public-utils/external/contains-files.js

@@ -0,0 +1,5 @@
+export function containsFiles({
+  source
+}) {
+  return source.types.includes('Files');
+}

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/public-utils/external/get-files.d.ts

@@ -0,0 +1,3 @@
+import { type ContainsSource } from './native-types.js';
+/** Obtain an array of the dragged `File`s */
+export declare function getFiles({ source }: ContainsSource): File[];

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/public-utils/external/get-files.js

@@ -0,0 +1,12 @@
+/** Obtain an array of the dragged `File`s */
+// eslint-disable-next-line @atlaskit/volt-strict-mode/no-multiple-exports
+export function getFiles({
+  source
+}) {
+  return source.items
+  // unlike other media types, for files:
+  // item.kind is 'file'
+  // item.type is the type of file eg 'image/jpg'
+  // for other media types, item.type is the mime format
+  .filter(item => item.kind === 'file').map(item => item.getAsFile()).filter(file => file != null);
+}

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/public-utils/external/native-types.d.ts

@@ -0,0 +1,12 @@
+import type { ExternalDragPayload } from '../../internal-types.js';
+/** `ContainsSource` works for
+ * 1. `monitorForNative` > `canMonitor()`
+ * 2. `dropTargetForNative` > `canDrop()`
+ *
+ * We are also using `SourcePayload` as the parameter type for all native getters.
+ * For example, `getFiles({source}: SourcePayload)`
+ */
+export type ContainsSource = {
+    source: ExternalDragPayload;
+};
+export type PredicateFn = (args: ContainsSource) => boolean;

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/util/changing-window/is-entering-window-in-safari.js

@@ -0,0 +1,10 @@
+import { isSafari } from '../is-safari.js';
+import { symbols } from './count-events-for-safari.js';
+export function isEnteringWindowInSafari({
+  dragEnter
+}) {
+  if (!isSafari()) {
+    return false;
+  }
+  return dragEnter.hasOwnProperty(symbols.isEnteringWindow);
+}

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop/util/changing-window/is-entering-window.js

@@ -0,0 +1,55 @@
+import { isFirefox } from '../is-firefox.js';
+import { isSafari } from '../is-safari.js';
+import { isEnteringWindowInSafari } from './is-entering-window-in-safari.js';
+import { isFromAnotherWindow } from './is-from-another-window.js';
+export function isEnteringWindow({
+  dragEnter
+}) {
+  const {
+    type,
+    relatedTarget
+  } = dragEnter;
+  if (type !== 'dragenter') {
+    return false;
+  }
+  if (isSafari()) {
+    return isEnteringWindowInSafari({
+      dragEnter
+    });
+  }
+
+  // standard check
+  if (relatedTarget == null) {
+    return true;
+  }
+
+  /**
+   * 🦊 Exception: `iframe` in Firefox (`125.0`)
+   *
+   * Case 1: parent `window` → child `iframe`
+   * `relatedTarget` is the `iframe` element in the parent `window`
+   * (foreign element)
+   *
+   * Case 2: child `iframe` → parent `window`
+   * `relatedTarget` is an element inside the child `iframe`
+   * (foreign element)
+   */
+
+  if (isFirefox()) {
+    return isFromAnotherWindow(relatedTarget);
+  }
+
+  /**
+   * 🌏 Exception: `iframe` in Chrome (`124.0`)
+   *
+   * Case 1: parent `window` → child `iframe`
+   * `relatedTarget` is `null` *(standard check)*
+   *
+   * Case 2: child `iframe` → parent `window`
+   * `relatedTarget` is the `iframe` element in the parent `window`
+   */
+
+  // Case 2
+  // Using `instanceof` check as the element will be in the same `window`
+  return relatedTarget instanceof HTMLIFrameElement;
+}

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop-auto-scroll/entry-point/external.d.ts

@@ -0,0 +1,4 @@
+import type { ExternalDragType, CleanupFn } from '../../pragmatic-drag-and-drop/entry-point/types.js';
+import type { ElementAutoScrollArgs, WindowAutoScrollArgs } from '../internal-types.js';
+export declare const autoScrollForExternal: (args: ElementAutoScrollArgs<ExternalDragType>) => CleanupFn;
+export declare const autoScrollWindowForExternal: (args?: WindowAutoScrollArgs<ExternalDragType>) => CleanupFn;

package/dist/dnd/vendor/pragmatic/pragmatic-drag-and-drop-auto-scroll/entry-point/external.js

@@ -0,0 +1,8 @@
+import { monitorForExternal } from '../../pragmatic-drag-and-drop/adapter/monitor-for-external.js';
+import { makeApi } from '../over-element/make-api.js';
+const api = makeApi({
+  monitor: monitorForExternal
+});
+export const autoScrollForExternal = api.autoScroll;
+// eslint-disable-next-line @atlaskit/volt-strict-mode/no-multiple-exports
+export const autoScrollWindowForExternal = api.autoScrollWindow;

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

@@ -37,13 +37,9 @@ export type PublicConfig = Partial<{
 export type ElementAutoScrollArgs<DragType extends AllDragTypes> = {
     element: Element;
     canScroll?: (args: ElementGetFeedbackArgs<DragType>) => boolean;
-    getAllowedAxis?: (args: ElementGetFeedbackArgs<DragType>) => AllowedAxis;
-    getConfiguration?: (args: ElementGetFeedbackArgs<DragType>) => PublicConfig;
 };
 export type WindowAutoScrollArgs<DragType extends AllDragTypes> = {
     canScroll?: (args: WindowGetFeedbackArgs<DragType>) => boolean;
-    getAllowedAxis?: (args: WindowGetFeedbackArgs<DragType>) => AllowedAxis;
-    getConfiguration?: (args: WindowGetFeedbackArgs<DragType>) => PublicConfig;
 };
 export type Side = 'start' | 'end';
 export type Axis = 'vertical' | 'horizontal';