edytor 1.0.0 → 3.0.0

package/dist/edytor.svelte.js

@@ -29,7 +29,7 @@ import Announcer from './components/Announcer.svelte';
 import RemoteSelections from './collaboration/RemoteSelections.svelte';
 import Ranges from './components/Ranges.svelte';
 import { Handles } from './session/handles.js';
-import { id } from './utils.js';
+import { cleanups, id } from './utils.js';
 import { Y } from './crdt/engine.js';
 import { markName } from './crdt/text/marks.js';
 import { callEach } from './crdt/protocols/observable.js';
@@ -43,6 +43,7 @@ import { Keymap } from './session/keymap.js';
 import { TRANSACTION } from './constants.js';
 import { Dispatcher } from './session/commands.js';
 import { History } from './session/history.js';
+import { DataWrites } from './session/props.js';
 import { kindCatalogue, kindCommand, UNKNOWN_KIND } from './kinds.js';
 import { clearDomSelection, getActiveElement, getDomSelection, getDomSelectionSnapshot } from './selection/domSelection.js';
 /** A consumer that is set (a prop or a plugin hook left out is `undefined`). */
@@ -131,13 +132,18 @@ export class Edytor {
         void this.#dataRevision;
         return this.facade.docData();
     };
+    /** @internal The view's property writes (`session/props`): the data proxies' one queue. */
+    dataWrites = new DataWrites(this);
+    #dataProxy;
     /**
-     * The document's properties, read-your-writes and reactive. Write them
-     * with `edytor.patchData(null, patches)`. Type them by augmenting
-     * {@link EdytorDocData}.
+     * The document's properties, as plain state: reactive at any depth, and
+     * writable (`edytor.data.title = 'Notes'`, `edytor.data.tags.push('x')`,
+     * `delete edytor.data.draft`). Each write is the `patchData` operation,
+     * dispatched; the writes of one task are one undo step. Type them by
+     * augmenting {@link EdytorDocData}.
      */
     get data() {
-        return this.docData();
+        return (this.#dataProxy ??= this.dataWrites.proxy(null, this.docData));
     }
     /** @internal The IME host pin (`surface/pin`): the composing cell's segment list and render, frozen. */
     pin = new Pin();
@@ -149,6 +155,8 @@ export class Edytor {
     announcer = new AnnouncerState(this);
     /** The words the view was given (`<Edytor labels>`); its plugins read their section through `labelsOf`. */
     labels = {};
+    /** Whether users may nest blocks (`allowNesting`, read once; the rule is `session/moves.ts` `nestsInto`). */
+    allowNesting = false;
     off = [];
     onChange;
     onDocChange;
@@ -185,11 +193,10 @@ export class Edytor {
     // CRDT (v14) — the document is the composition owner: it holds the ONE
     // engine doc, the shared facade (only structural read/write surface),
     // the default local history and the shared awareness. Injected
-    // documents are borrowed; a view with no `document` option internally
-    // owns one (built around `doc`/`awareness` when those are injected).
+    // documents are borrowed; a view with no `document` option owns a fresh one.
     document;
-    /** @internal `true` when this view created its document — `destroy()` then releases it. */
-    ownsDocument = false;
+    /** `true` when this view created its document — `destroy()` then releases it. */
+    #owned = false;
     get doc() {
         return this.document.doc;
     }
@@ -289,29 +296,23 @@ export class Edytor {
         this.dispatcher.record({ operation: command, status: this.history.replay(command) });
     };
     constructor(options) {
-        const { readonly, hotkeys, plugins, document, doc, awareness, actor, requireHydration, presence, sync, value, onSelectionChange, labels, onChange, onDocChange } = options;
+        const { readonly, hotkeys, plugins, document, actor, requireHydration, presence, sync, value, onSelectionChange, labels, onChange, onDocChange, allowNesting } = options;
         for (const name of DOCUMENT_WRITES)
             Object.defineProperty(this, name, {
                 value: (...args) => this.dispatcher.operate(name, args)
             });
         if (labels)
             this.labels = labels;
+        this.allowNesting = allowNesting === true;
         if (document !== undefined) {
-            if (DEV &&
-                (doc !== undefined ||
-                    awareness !== undefined ||
-                    actor !== undefined ||
-                    requireHydration !== undefined)) {
-                throw new Error('EdytorOptions: `document` cannot be combined with `doc`/`awareness`/`actor`/`requireHydration` — ' +
-                    'the document owns them (compose them via attachDocument first).');
+            if (DEV && (actor !== undefined || requireHydration !== undefined)) {
+                throw new Error('EdytorOptions: `document` cannot be combined with `actor`/`requireHydration`: set them on the document.');
             }
             this.document = document;
         }
         else {
-            // Legacy path — the view internally owns a document composed
-            // around the injected (or a fresh) doc/awareness.
-            this.document = attachDocument(doc ?? new Y.Doc(), { awareness, actor, requireHydration });
-            this.ownsDocument = true;
+            this.document = attachDocument(new Y.Doc(), { actor, requireHydration });
+            this.#owned = true;
         }
         this.readonly = readonly || false;
         this.onChange = onChange;
@@ -379,7 +380,7 @@ export class Edytor {
             // decision; every other view binds on the one readiness event
             // (`<Edytor>` decides an injected document at mount, once the
             // providers of its sibling views attached).
-            if (this.ownsDocument && !sync) {
+            if (this.#owned && !sync) {
                 this.sync(value || { children: [] });
             }
             else {
@@ -400,7 +401,7 @@ export class Edytor {
             // document-lifetime additive declarations, and an injected
             // document's are left for the views that legitimately share it.
             this.document.untrackOrigin(this.transaction);
-            if (this.ownsDocument) {
+            if (this.#owned) {
                 this.document.destroy();
             }
             throw error;
@@ -602,9 +603,7 @@ export class Edytor {
                     // A failed async handler (a command's hook or write) surfaces
                     // through the platform's error reporting; the DOM ignores
                     // the listener's promise.
-                    void Promise.resolve(result)
-                        .finally(clear)
-                        .catch((error) => typeof reportError === 'function' ? reportError(error) : console.error(error));
+                    void Promise.resolve(result).finally(clear).catch(reportError);
                 }
                 else {
                     clear();
@@ -821,11 +820,7 @@ export class Edytor {
             props: { announcer: this.announcer }
         });
         this.off.push(() => unmount(presence), () => unmount(ranges), () => unmount(live), detachOverlay);
-        this.plugins.forEach((plugin) => {
-            const action = plugin.onEdytorAttached?.({ node });
-            if (typeof action === 'function')
-                this.off.push(action);
-        });
+        this.off.push(...cleanups(this.plugins, (plugin) => plugin.onEdytorAttached?.({ node })));
         return {
             destroy: () => {
                 if (selectionIsInside(node))
@@ -855,7 +850,7 @@ export class Edytor {
      * discarded.
      *
      * Releases every listener the editor holds on potentially-SHARED objects
-     * — an injected doc/awareness outlives a single editor, so an
+     * — an injected document outlives a single editor, so an
      * undestroyed mount leaks a facade `update` listener and the undo
      * manager's doc observers forever.
      *
@@ -899,7 +894,7 @@ export class Edytor {
         // awareness, doc) belong to the document — released exactly once,
         // and only when THIS view created it. A borrowed document keeps
         // serving its sibling views and headless consumers.
-        if (this.ownsDocument) {
+        if (this.#owned) {
             this.document.destroy();
         }
     };

package/dist/events/beforeInputCommands.d.ts

@@ -9,6 +9,6 @@ import { type Attempt } from '../session/attempt.js';
  */
 export declare const insertLineBreak: (edytor: Edytor, snapshot: Attempt, caret?: "after" | "before") => void;
 /** The model command for a `beforeinput`, run as one user command (undo policy, prevention scope). */
-export declare const runBeforeInputCommand: (edytor: Edytor, snapshot: Attempt) => boolean | void | Promise<undefined> | Text | null | undefined;
+export declare const runBeforeInputCommand: (edytor: Edytor, snapshot: Attempt) => boolean | void | Text | Promise<undefined> | null | undefined;
 /** An editing intent at the current selection (a key binding's command): no event to fabricate. */
-export declare const runIntent: (edytor: Edytor, inputType: string) => boolean | void | Promise<undefined> | Text | null | undefined;
+export declare const runIntent: (edytor: Edytor, inputType: string) => boolean | void | Text | Promise<undefined> | null | undefined;

package/dist/events/beforeInputCommands.js

@@ -97,10 +97,10 @@ export const insertLineBreak = (edytor, snapshot, caret = 'after') => {
         : block.parent?.children[block.index + 1]?.firstText;
     caretAt(edytor, line, before ? (line?.length ?? 0) : 0);
 };
-const runPastePlugins = (edytor, dataTransfer) => {
+const runPastePlugins = (edytor, dataTransfer, at) => {
     const event = { clipboardData: dataTransfer };
     for (const plugin of edytor.plugins)
-        vetoable((prevent) => plugin.onPaste?.({ prevent, e: event }));
+        vetoable((prevent) => plugin.onPaste?.({ prevent, e: event, ...(at && { at }) }));
 };
 /** The drop point the browser reported: its text and offset (`null`: not in a text). */
 const dropPoint = (edytor, { declared: range }) => {
@@ -150,9 +150,13 @@ const insertPayload = async (edytor, snapshot) => {
     // A paste occurrence is the plain text its handler left to it (Shift-paste too).
     const fragment = !paste && readEdytorClipboardFragment(dataTransfer);
     if (!paste && !fragment && dataTransfer) {
-        // A plugin places the files at the selection: the drop point, never over selected blocks.
-        if (dataTransfer.files?.length)
+        // A plugin places the files at the drop indicator's placement, else at the
+        // selection: the drop point, never over selected blocks.
+        if (dataTransfer.files?.length) {
+            if (snapshot.placement)
+                return void runPastePlugins(edytor, dataTransfer, snapshot.placement);
             return void (land() !== null && runPastePlugins(edytor, dataTransfer));
+        }
         if (dataTransfer.getData('text/html'))
             runPastePlugins(edytor, dataTransfer);
     }

package/dist/events/onBeforeInput.js

@@ -7,7 +7,7 @@ import { isAndroidChromeBrowser } from './events.utils.js';
 import { isNativeInteractiveControl, isNativeInteractiveEvent, ownsEvent } from './nativeInteractiveControl.js';
 import { runBeforeInputCommand } from './beforeInputCommands.js';
 import { deleteInText } from './beforeInputDeleteCommands.js';
-import { readDomText } from './onInput.js';
+import { readDomText } from '../surface/observer.svelte.js';
 /** The Android no-op-Backspace and model-owned drift deadlines (named, counted browser rules). */
 const NATIVE_INPUT_REPAIR_WINDOW_MS = 150;
 const dirOf = (inputType) => INTENTS[inputType]?.dir;

package/dist/events/onDrop.js

@@ -3,15 +3,20 @@ import { runOccurrence } from './onBeforeInput.js';
 import { createEdytorClipboardFragment, writeEdytorClipboardData } from '../clipboard/clipboard.js';
 import { endTextDrag, startTextDrag, textDragOf } from '../clipboard/moveText.js';
 import { caretAtPoint, getDomSelection } from '../selection/domSelection.js';
+import { viewUploads } from '../session/uploads.js';
 /**
  * Payloads the editor can consume on drop. Preventing `dragover` is what
  * enables a drop, so it is prevented only for these types — internal and
  * unsupported drags keep the browser's not-allowed affordance and can never
  * produce a native DOM mutation.
  *
- * `Files` is intentionally accepted: file drops route through the plugin
- * `onPaste` hook (the Files → image seam: the image plugin with `upload`
- * claims image files; unclaimed files insert nothing).
+ * `Files` is intentionally accepted (so the browser never opens a dropped
+ * file in place of the page): with the view's uploads (a media plugin given
+ * an `upload`), file drops route through the plugin `onPaste` hook with the
+ * placement the uploads' drop target resolved (`ViewUploads.drop`, Pragmatic's
+ * external adapter: a block per file the kinds take there; unclaimed files
+ * insert nothing); without them a drop carrying
+ * files is ignored, its effect `none`.
  */
 const ACCEPTED_FOREIGN_DROP_TYPES = ['Files', 'text/html', 'text/plain', 'text/uri-list'];
 /**
@@ -121,8 +126,8 @@ const isAcceptedForeignDrop = (root, dataTransfer) => {
 // Preventing the drop suppresses the browser's own `insertFromDrop`
 // beforeinput, so the accepted payload is the occurrence itself — the same
 // routing as `insertFromPaste`, with the drop point as its declared target
-// range (`caretAtPoint`).
-const insertFromDrop = (edytor, root, event) => {
+// range (`caretAtPoint`); files carry the indicator's placement (`at`).
+const insertFromDrop = (edytor, root, event, placement = null) => {
     const at = caretAtPoint(root.ownerDocument, event.clientX, event.clientY);
     const point = at &&
         new StaticRange({
@@ -135,6 +140,7 @@ const insertFromDrop = (edytor, root, event) => {
         inputType: 'insertFromDrop',
         dataTransfer: event.dataTransfer,
         declared: point && root.contains(point.startContainer) ? point : null,
+        placement,
         cancelable: true
     });
 };
@@ -176,22 +182,31 @@ export const preventUnsupportedDrop = (event, edytor) => {
         drag.dropping = true;
         return insertFromDrop(edytor, root, event);
     }
+    const files = typesOf(event.dataTransfer).includes('Files');
+    // The view's uploads take dropped files (a media plugin given an `upload`); none: ignored.
+    const drop = files ? viewUploads(edytor)?.drop : undefined;
     if (event.type === 'dragover') {
         if (isAcceptedForeignDrop(root, event.dataTransfer)) {
             event.preventDefault();
             event.stopPropagation();
-            if (event.dataTransfer) {
-                event.dataTransfer.dropEffect = 'copy';
-            }
+            // Where files land shows from the uploads' drop target (Pragmatic's
+            // external adapter); a read-only view or one without uploads takes no
+            // file drop, and the browser must not open the file.
+            if (event.dataTransfer)
+                event.dataTransfer.dropEffect = files && (edytor.readonly || !drop) ? 'none' : 'copy';
         }
         return;
     }
     const accepted = isAcceptedForeignDrop(root, event.dataTransfer);
+    // Where the files land: the placement the uploads' drop target resolved at
+    // the drop point (its window listener captures, so it ran first).
+    const placed = drop?.take() ?? null;
+    const at = accepted && !ownsEvent(root, event) ? placed : null;
     if (accepted && isControlDrop(root, event))
         return;
     event.preventDefault();
     event.stopPropagation();
-    if (!accepted) {
+    if (!accepted || (files && (edytor.readonly || !drop))) {
         return;
     }
     if (ownsEvent(root, event) || isNativeInteractiveControl(event.target)) {
@@ -201,5 +216,5 @@ export const preventUnsupportedDrop = (event, edytor) => {
     }
     // Mid-composition drops are swallowed: the preview owns the write path.
     if (!edytor.isComposing)
-        return insertFromDrop(edytor, root, event);
+        return insertFromDrop(edytor, root, event, at);
 };

package/dist/events/onInput.d.ts

@@ -1,16 +1,4 @@
 import type { Edytor } from '../edytor.svelte.js';
-import type { Text } from '../text/text.svelte.js';
-/**
- * What the browser shows for `text`: its element's text nodes in order (WebKit's
- * converted-space wrappers read as plain spaces), the empty filler and the
- * trailing-newline marker stripped.
- */
-export declare const readDomText: (text: Text) => string;
-export declare const getCollapsedDomTextSelection: (edytor: Edytor) => {
-    text: Text;
-    offset: number;
-} | null;
-export declare const handleNativeLineBreakTextValue: (edytor: Edytor, text: Text, value: string) => Promise<boolean>;
 /**
  * An `input` event. Browser-made text is never adopted here: the mutation
  * queue is the only adopter (a native line break there runs as its

package/dist/events/onInput.js

@@ -1,76 +1,10 @@
-import { diffText } from '../utils/diffText.js';
-import { getDomSelectionSnapshot } from '../selection/domSelection.js';
-import { domOffsetIn } from '../selection/selection.utils.js';
 import { isControlEvent } from './nativeInteractiveControl.js';
-import { runOccurrence } from './onBeforeInput.js';
 import { attemptOf, kindOf } from '../session/attempt.js';
-const ZERO_WIDTH_SPACE = '\u200B';
-/**
- * What the browser shows for `text`: its element's text nodes in order (WebKit's
- * converted-space wrappers read as plain spaces), the empty filler and the
- * trailing-newline marker stripped.
- */
-export const readDomText = (text) => {
-    let value = '';
-    const node = text.node;
-    if (node) {
-        const walker = (node.ownerDocument ?? document).createTreeWalker(node, NodeFilter.SHOW_TEXT);
-        while (walker.nextNode()) {
-            const leaf = walker.currentNode;
-            value += leaf.parentElement?.closest('span.Apple-converted-space')
-                ? leaf.data.replaceAll('\u00A0', ' ')
-                : leaf.data;
-        }
-    }
-    // An empty text's filler shares its node with what the browser typed, on either side.
-    if (text.isEmpty)
-        return value.replaceAll(ZERO_WIDTH_SPACE, '');
-    if (text.endsWithNewline && value.endsWith(ZERO_WIDTH_SPACE)) {
-        value = value.slice(0, -ZERO_WIDTH_SPACE.length);
-    }
-    return value;
-};
-export const getCollapsedDomTextSelection = (edytor) => {
-    const selection = getDomSelectionSnapshot(edytor.node);
-    if (!selection?.anchorNode || !selection.isCollapsed) {
-        return null;
-    }
-    if (!edytor.node?.contains(selection.anchorNode)) {
-        return null;
-    }
-    const text = edytor.selection.getTextOfNode(selection.anchorNode);
-    if (!text?.node) {
-        return null;
-    }
-    // No model rule here: the DOM caret is read BEFORE the reconcile writes
-    // the model, so a native insertion legitimately sits past `text.length`
-    // (`selectText` clamps the final write).
-    return { text, offset: domOffsetIn(text, selection.anchorNode, selection.anchorOffset) };
-};
+import { getCollapsedDomTextSelection } from '../surface/observer.svelte.js';
 const getInputType = (event) => {
     const inputType = event.inputType;
     return typeof inputType === 'string' ? inputType : '';
 };
-const getNativeLineBreakInsertionIndexFromValue = (text, value) => {
-    const change = diffText(text.stringContent, value);
-    return change && !change.remove && /^[\r\n]+$/.test(change.insert) ? change.at : null;
-};
-export const handleNativeLineBreakTextValue = async (edytor, text, value) => {
-    if (!text.isInDocument)
-        return false;
-    const insertionIndex = getNativeLineBreakInsertionIndexFromValue(text, value);
-    if (insertionIndex === null) {
-        return false;
-    }
-    // The native line break is the key's occurrence: its intent, run by the model.
-    const inputType = edytor.attempts.confirm()?.inputType === 'insertLineBreak' || value.includes('\n')
-        ? 'insertLineBreak'
-        : 'insertParagraph';
-    text.refreshFromModel();
-    edytor.selection.selectText(text, insertionIndex);
-    await runOccurrence(edytor, { inputType, cancelable: false });
-    return true;
-};
 /**
  * An `input` no attempt expected (its engine sent no `beforeinput`): the
  * browser changed the text under its caret — a browser-owned attempt of its own.

package/dist/events/onPaste.d.ts

@@ -6,7 +6,8 @@ import type { Edytor } from '../edytor.svelte.js';
  * the document AND cancel its paste) or under a live composition (its
  * preview owns the write path: the browser pastes, the observer reconciles
  * it after the end, as PM input.ts:656-660). Else, unless Shift asks for
- * plain text: an Edytor fragment; what an extension's `onPaste` claims; a
+ * plain text: an Edytor fragment; what an extension's `onPaste` claims (the
+ * `pasteFirst` ones first, then list order); a
  * file nothing claimed inserts nothing (the Files → image seam), never its
  * name; external HTML (HTML that carries nothing falls through); markdown
  * text as its blocks (`paste.markdown`), except in a code block's lines.

package/dist/events/onPaste.js

@@ -54,7 +54,8 @@ const syncCollapsedDomCaretForPaste = (edytor) => {
  * the document AND cancel its paste) or under a live composition (its
  * preview owns the write path: the browser pastes, the observer reconciles
  * it after the end, as PM input.ts:656-660). Else, unless Shift asks for
- * plain text: an Edytor fragment; what an extension's `onPaste` claims; a
+ * plain text: an Edytor fragment; what an extension's `onPaste` claims (the
+ * `pasteFirst` ones first, then list order); a
  * file nothing claimed inserts nothing (the Files → image seam), never its
  * name; external HTML (HTML that carries nothing falls through); markdown
  * text as its blocks (`paste.markdown`), except in a code block's lines.
@@ -70,8 +71,12 @@ export async function onPaste(e) {
     if (!(shiftPasteModifierHeld && plain)) {
         const fragment = readEdytorClipboardFragment(data);
         if (!fragment) {
-            const claimed = (plugin) => vetoable((prevent) => plugin.onPaste?.({ prevent, e }));
-            if (this.dispatcher.intercept(claimed, () => e.preventDefault()))
+            // The `pasteFirst` hooks (a pasted reference: page link's `fromPaste`), then the
+            // others in list order; the first that prevents claims the paste.
+            const claimed = (first) => (plugin) => !!plugin.pasteFirst === first && vetoable((prevent) => plugin.onPaste?.({ prevent, e }));
+            const stop = () => e.preventDefault();
+            if (this.dispatcher.intercept(claimed(true), stop) ||
+                this.dispatcher.intercept(claimed(false), stop))
                 return;
             if (data?.files?.length)
                 return e.preventDefault();