edytor 2.0.0 → 3.0.0

package/dist/crdt/providers/websocket.js

@@ -142,16 +142,16 @@ export const bindWebsocketProvider = (Y) => {
             provider.synced = true;
         }
     });
-    // A room's comment threads (`watchComments`): the listeners of each room,
-    // by `<serverUrl>/<room>`, and the providers dialing it. A provider asks
-    // the room for them (a subscribe) at every open while a room has a
-    // listener, and hands each message the room sends to every listener.
-    const commentListeners = new Map();
-    const providersOf = new Map();
+    const watchers = new Set();
+    const providers = new Set();
     const subscribeFrame = (on) => frame(messageComments, (e) => writeCommentsSubscribe(e, on));
+    const hears = (watcher, provider) => watcher.room === provider.roomname &&
+        (watcher.channel === null || watcher.channel === provider.bcChannel);
+    const listenersOf = (provider) => [...watchers].filter((watcher) => hears(watcher, provider)).map((watcher) => watcher.listener);
+    const providersFor = (watcher) => [...providers].filter((p) => hears(watcher, p));
     room.messageHandlers[messageComments] = (_encoder, decoder, provider) => {
         const message = readCommentsMessage(decoder);
-        for (const listener of [...(commentListeners.get(provider.bcChannel) ?? [])]) {
+        for (const listener of listenersOf(provider)) {
             try {
                 listener(message);
             }
@@ -162,26 +162,28 @@ export const bindWebsocketProvider = (Y) => {
     };
     /**
      * Hear the comment threads of `room` on `server` (the URL a provider
-     * dials, `ws:`/`wss:`): every provider of that room subscribes now and
-     * at each (re)connect, which the room answers with every thread (a
-     * `snapshot`), then sends each `change`. Answers the unsubscribe; the
-     * last one leaving tells the room to stop.
+     * dials, `ws:`/`wss:`; `null`: every provider of that room on the page,
+     * whatever its server): every such provider subscribes now and at each
+     * (re)connect, which the room answers with every thread (a `snapshot`),
+     * then sends each `change`. Answers the unsubscribe; the last listener
+     * of a provider leaving tells its room to stop.
      */
     const watchComments = (server, roomName, listener) => {
-        const key = `${server.replace(/\/+$/, '')}/${roomName}`;
-        const listeners = commentListeners.get(key) ?? new Set();
-        commentListeners.set(key, listeners);
-        const first = listeners.size === 0;
-        listeners.add(listener);
-        if (first)
-            for (const provider of providersOf.get(key) ?? [])
-                send(provider, subscribeFrame(true));
+        const watcher = {
+            room: roomName,
+            channel: server === null ? null : `${server.replace(/\/+$/, '')}/${roomName}`,
+            listener
+        };
+        const fresh = providersFor(watcher).filter((p) => listenersOf(p).length === 0);
+        watchers.add(watcher);
+        for (const provider of fresh)
+            send(provider, subscribeFrame(true));
         return () => {
-            if (!listeners.delete(listener) || listeners.size > 0)
+            if (!watchers.delete(watcher))
                 return;
-            commentListeners.delete(key);
-            for (const provider of providersOf.get(key) ?? [])
-                send(provider, subscribeFrame(false));
+            for (const provider of providersFor(watcher))
+                if (listenersOf(provider).length === 0)
+                    send(provider, subscribeFrame(false));
         };
     };
     // The room's acknowledgement and its bounded catch-up (a frame too large
@@ -468,7 +470,7 @@ export const bindWebsocketProvider = (Y) => {
                 for (const buf of room.hello(provider))
                     sendOn(provider, websocket, buf);
                 // The room's comment threads, while someone listens (`watchComments`).
-                if (commentListeners.get(provider.bcChannel)?.size)
+                if (listenersOf(provider).length > 0)
                     sendOn(provider, websocket, subscribeFrame(true));
             };
             provider.emit('status', [{ status: 'connecting' }]);
@@ -540,8 +542,7 @@ export const bindWebsocketProvider = (Y) => {
                 this._resync = setInterval(() => send(this, room.step1(this)), resyncInterval);
             }
             this._bcSubscriber = room.bcSubscriber(this);
-            const peers = providersOf.get(this.bcChannel) ?? new Set();
-            providersOf.set(this.bcChannel, peers.add(this));
+            providers.add(this);
             // Local doc updates go to the room; another tab's go to the server
             // only (`broadcastUpdate` quarantines a read-only document). A
             // socket the room made read-only gets this document's own edits
@@ -641,9 +642,7 @@ export const bindWebsocketProvider = (Y) => {
                 return;
             clearInterval(this._resync);
             clearInterval(this._checkInterval);
-            const peers = providersOf.get(this.bcChannel);
-            if (peers?.delete(this) && peers.size === 0)
-                providersOf.delete(this.bcChannel);
+            providers.delete(this);
             this.disconnect();
             this.awareness.off('update', this._awarenessUpdateHandler);
             this.doc.off('update', this._updateHandler);

package/dist/crdt/semantics.js

@@ -40,6 +40,7 @@ export const normalizeRole = (role) => {
     };
 };
 /** Freeze `value` and everything in it: the tables are shared by every document. */
+/* @__NO_SIDE_EFFECTS__ */
 const frozen = (value) => {
     if (value && typeof value === 'object' && !Object.isFrozen(value)) {
         Object.freeze(value);
@@ -294,7 +295,8 @@ export const equationSemantics = /* @__PURE__ */ semanticsOf(equationKinds);
  * plugins are not default plugins of `<Edytor>`, but their roles are here so their
  * blocks read the same on every replica.
  */
-export const defaultSemantics = withMarks(semanticsOf(richTextKinds, codeKinds, imageKinds, mediaKinds, layoutKinds, pageKinds, tocKinds, tableKinds, equationKinds), { ...richTextMarks, ...commentMarks });
+export const defaultSemantics = /* @__PURE__ */ withMarks(semanticsOf(richTextKinds, codeKinds, imageKinds, mediaKinds, layoutKinds, pageKinds, tocKinds, tableKinds, equationKinds), 
+/* @__PURE__ */ Object.assign({}, richTextMarks, commentMarks));
 /**
  * The facade configuration (`EdytorDocConfig`) a document with no view
  * reads `semantics` with — the room's: roles, default children, content-less kinds

package/dist/dnd/autoScroll.d.ts

@@ -1,9 +1,17 @@
+/** One adapter's auto-scroll (Atlassian's auto-scroll package), its drags already chosen. */
+export type Scrollers = {
+    /** The window scrolls as the pointer nears its edges. */
+    window(): () => void;
+    /** `element` scrolls as the pointer nears its edges. */
+    element(element: Element): () => void;
+};
 /**
- * Auto-scroll for one drag (a block's, a table row's or column's; Atlassian's
- * auto-scroll package): the window
- * and every scrolling element from the editor up (the editor included) scroll
- * as the pointer nears their edges, faster the closer and the longer it stays,
- * innermost first. `ours` keeps it to this editor's drags. Registered at the
- * drag's start (the package allows it mid-drag); the answer releases it.
+ * Auto-scroll for one drag (a block's, a table row's or column's, files
+ * dragged from outside): the window and every scrolling element from the
+ * editor up (the editor included) scroll as the pointer nears their edges,
+ * faster the closer and the longer it stays, innermost first. `scrollers`
+ * is the drag's adapter's (`elementScrollers`, `externalScrollers`), kept to
+ * this editor's drags. Registered at the drag's start (the package allows it
+ * mid-drag); the answer releases it.
  */
-export declare const autoScrollFor: (root: HTMLElement, ours: (data: Record<string | symbol, unknown>) => boolean) => (() => void);
+export declare const autoScrollFor: (root: HTMLElement, scrollers: Scrollers) => (() => void);

package/dist/dnd/autoScroll.js

@@ -1,25 +1,20 @@
-import { autoScroll, autoScrollWindow } from './pragmatic.js';
 /**
- * Auto-scroll for one drag (a block's, a table row's or column's; Atlassian's
- * auto-scroll package): the window
- * and every scrolling element from the editor up (the editor included) scroll
- * as the pointer nears their edges, faster the closer and the longer it stays,
- * innermost first. `ours` keeps it to this editor's drags. Registered at the
- * drag's start (the package allows it mid-drag); the answer releases it.
+ * Auto-scroll for one drag (a block's, a table row's or column's, files
+ * dragged from outside): the window and every scrolling element from the
+ * editor up (the editor included) scroll as the pointer nears their edges,
+ * faster the closer and the longer it stays, innermost first. `scrollers`
+ * is the drag's adapter's (`elementScrollers`, `externalScrollers`), kept to
+ * this editor's drags. Registered at the drag's start (the package allows it
+ * mid-drag); the answer releases it.
  */
-export const autoScrollFor = (root, ours) => {
-    // The scroller hit-tests with `elementsFromPoint` every frame (jsdom has none),
-    // so it is created only where that exists.
-    if (typeof root.ownerDocument.elementsFromPoint !== 'function')
-        return () => { };
-    const canScroll = ({ source }) => ours(source.data);
-    const releases = [autoScrollWindow({ canScroll })];
+export const autoScrollFor = (root, scrollers) => {
+    const releases = [scrollers.window()];
     const { body, documentElement, defaultView } = root.ownerDocument;
     // The window is the document's scroller: stop below it.
     for (let element = root; element && element !== body && element !== documentElement; element = element.parentElement) {
         const { overflowX, overflowY } = defaultView.getComputedStyle(element);
         if (/auto|scroll|overlay/.test(`${overflowX} ${overflowY}`))
-            releases.push(autoScroll({ element, canScroll }));
+            releases.push(scrollers.element(element));
     }
     return () => releases.forEach((release) => release());
 };

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