edytor 1.0.0-rc.2 → 1.0.0

package/dist/{plugins/blockHandles → dnd}/autoScroll.d.ts

@@ -1,5 +1,6 @@
 /**
- * Auto-scroll for one block drag (Atlassian's auto-scroll package): the window
+ * 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

package/dist/{plugins/blockHandles → dnd}/autoScroll.js

@@ -1,6 +1,7 @@
-import { autoScrollApi } from '../../dnd/pragmatic.js';
+import { autoScroll, autoScrollWindow } from './pragmatic.js';
 /**
- * Auto-scroll for one block drag (Atlassian's auto-scroll package): the window
+ * 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
@@ -11,7 +12,6 @@ export const autoScrollFor = (root, ours) => {
     // so it is created only where that exists.
     if (typeof root.ownerDocument.elementsFromPoint !== 'function')
         return () => { };
-    const { autoScroll, autoScrollWindow } = autoScrollApi();
     const canScroll = ({ source }) => ours(source.data);
     const releases = [autoScrollWindow({ canScroll })];
     const { body, documentElement, defaultView } = root.ownerDocument;

package/dist/dnd/pragmatic.d.ts

@@ -1,22 +1,4 @@
-import type * as ElementAdapter from '@atlaskit/pragmatic-drag-and-drop/element/adapter';
-import type * as CustomPreview from '@atlaskit/pragmatic-drag-and-drop/element/set-custom-native-drag-preview';
-import type * as ListItem from '@atlaskit/pragmatic-drag-and-drop-hitbox/list-item';
-import type * as AutoScroll from '@atlaskit/pragmatic-drag-and-drop-auto-scroll/element';
-export declare const draggable: typeof ElementAdapter.draggable, dropTargetForElements: (args: import("@atlaskit/pragmatic-drag-and-drop/dist/types/internal-types").DropTargetArgs<import("@atlaskit/pragmatic-drag-and-drop/dist/types/internal-types").ElementDragType>) => import("@atlaskit/pragmatic-drag-and-drop/dist/types/internal-types").CleanupFn;
-export declare const setCustomNativeDragPreview: typeof CustomPreview.setCustomNativeDragPreview;
-/** The list-item hitbox (reorder-before / reorder-after / combine, each available, not-available or blocked). */
-export declare const attachInstruction: typeof ListItem.attachInstruction, extractInstruction: typeof ListItem.extractInstruction;
-export type { Availability, Instruction } from '@atlaskit/pragmatic-drag-and-drop-hitbox/list-item';
-type AutoScrollApi = {
-    autoScroll: typeof AutoScroll.autoScrollForElements;
-    autoScrollWindow: typeof AutoScroll.autoScrollWindowForElements;
-};
-/**
- * Atlassian's auto-scroll for element drags (registered scroll containers, and
- * the window), bound to this module's adapter. The package's own element entry
- * binds it to the core required by its bare path, which a browser bundle
- * resolves to the core's ES build: a second adapter whose monitor never sees
- * the drags this adapter starts, so nothing would scroll. Created on first use:
- * creating it registers a monitor whose frame loop runs on every element drag.
- */
-export declare const autoScrollApi: () => AutoScrollApi;
+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';

package/dist/dnd/pragmatic.js

@@ -1,26 +1,7 @@
-// Atlassian's typed directory entry points are not loadable by Node ESM after
-// SvelteKit externalizes them for SSR. Their published CommonJS files are
-// loadable there; reconnect that runtime to the public declarations here.
-// @ts-expect-error The published CommonJS entry has no adjacent declaration.
-import * as adapterRuntime from '@atlaskit/pragmatic-drag-and-drop/dist/cjs/entry-point/element/adapter.js';
-// @ts-expect-error The published CommonJS entry has no adjacent declaration.
-import * as previewRuntime from '@atlaskit/pragmatic-drag-and-drop/dist/cjs/entry-point/element/set-custom-native-drag-preview.js';
-// @ts-expect-error The published CommonJS entry has no adjacent declaration.
-import * as listItemRuntime from '@atlaskit/pragmatic-drag-and-drop-hitbox/dist/cjs/list-item.js';
-// @ts-expect-error The published CommonJS module has no adjacent declaration.
-import * as autoScrollRuntime from '@atlaskit/pragmatic-drag-and-drop-auto-scroll/dist/cjs/over-element/make-api.js';
-const adapter = adapterRuntime;
-export const { draggable, dropTargetForElements } = adapter;
-export const { setCustomNativeDragPreview } = previewRuntime;
-/** The list-item hitbox (reorder-before / reorder-after / combine, each available, not-available or blocked). */
-export const { attachInstruction, extractInstruction } = listItemRuntime;
-let autoScrollApiOf;
-/**
- * Atlassian's auto-scroll for element drags (registered scroll containers, and
- * the window), bound to this module's adapter. The package's own element entry
- * binds it to the core required by its bare path, which a browser bundle
- * resolves to the core's ES build: a second adapter whose monitor never sees
- * the drags this adapter starts, so nothing would scroll. Created on first use:
- * creating it registers a monitor whose frame loop runs on every element drag.
- */
-export const autoScrollApi = () => (autoScrollApiOf ??= autoScrollRuntime.makeApi({ monitor: adapter.monitorForElements }));
+// 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.
+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';

package/dist/dnd/track.d.ts

@@ -0,0 +1,14 @@
+import type { Edytor } from '../edytor.svelte.js';
+/**
+ * A resize drag from its press (the image's handles, a table column's and
+ * a layout gap's bands): the press's default and propagation stop; a
+ * `pointerdown` tracks its pointer (captured, on the document), a lone
+ * `mousedown` (`isLonePress`: WebKit's first press after a native drag)
+ * tracks the mouse on the window. `move` takes each move's client x, then
+ * the overlay measures again; `end` takes the release's x, or `null` when
+ * the drag ends without one (Escape, a cancel, the answered cancel, the view
+ * no longer permitting a write), and nothing is to be written. After a
+ * release the editor takes the keys (Notion: Mod+Z right after). Answers the
+ * cancel (for the view turning readonly mid-drag).
+ */
+export declare const trackDrag: (edytor: Edytor, press: PointerEvent | MouseEvent, move: (x: number) => void, end: (x: number | null) => void) => (() => void);

package/dist/dnd/track.js

@@ -0,0 +1,55 @@
+import { takeKeys } from '../events/onFocus.js';
+/**
+ * A resize drag from its press (the image's handles, a table column's and
+ * a layout gap's bands): the press's default and propagation stop; a
+ * `pointerdown` tracks its pointer (captured, on the document), a lone
+ * `mousedown` (`isLonePress`: WebKit's first press after a native drag)
+ * tracks the mouse on the window. `move` takes each move's client x, then
+ * the overlay measures again; `end` takes the release's x, or `null` when
+ * the drag ends without one (Escape, a cancel, the answered cancel, the view
+ * no longer permitting a write), and nothing is to be written. After a
+ * release the editor takes the keys (Notion: Mod+Z right after). Answers the
+ * cancel (for the view turning readonly mid-drag).
+ */
+export const trackDrag = (edytor, press, move, end) => {
+    press.preventDefault();
+    press.stopPropagation();
+    const target = press.currentTarget;
+    const pointer = press.type === 'pointerdown';
+    if (pointer)
+        target?.setPointerCapture?.(press.pointerId);
+    const document = target?.ownerDocument ?? edytor.node?.ownerDocument;
+    const tracked = pointer ? document : document?.defaultView;
+    const [moves, ups] = pointer ? ['pointermove', 'pointerup'] : ['mousemove', 'mouseup'];
+    const moved = (event) => {
+        if (!edytor.dispatcher.permits())
+            return finish(event);
+        move(event.clientX);
+        edytor.overlay.invalidate();
+    };
+    const finish = (event) => {
+        tracked?.removeEventListener(moves, moved);
+        tracked?.removeEventListener(ups, finish);
+        tracked?.removeEventListener('pointercancel', finish);
+        document?.removeEventListener('keydown', escape, true);
+        const released = event.type === ups;
+        end(released ? event.clientX : null);
+        edytor.overlay.invalidate();
+        if (released)
+            takeKeys(edytor);
+    };
+    const escape = (event) => {
+        if (event.key !== 'Escape')
+            return;
+        event.preventDefault();
+        event.stopPropagation();
+        finish(event);
+    };
+    tracked?.addEventListener(moves, moved);
+    tracked?.addEventListener(ups, finish);
+    if (pointer)
+        tracked?.addEventListener('pointercancel', finish);
+    document?.addEventListener('keydown', escape, true);
+    edytor.overlay.invalidate();
+    return () => finish(new Event('cancel'));
+};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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