edytor 1.0.0-rc.3 → 2.0.0

package/dist/session/bindings.js

@@ -1,18 +1,15 @@
-import { Text } from '../text/text.svelte.js';
+import { blockSelection } from './selection.js';
 import { extendVertically, navigationBindings, stayWithoutTarget, vertical } from './navigation.js';
-import { attemptOf, caretAt, intentSnapshot } from './attempt.js';
+import { caretAt, intentSnapshot } from './attempt.js';
 import { flipToggles, getSelectionBlocks, deleteSelectedBlocks, outermost, selectedBlocksExit, shownSelectionBlocks } from '../selection/replaceSelection.js';
 import { shown } from '../selection/visibility.js';
-const STRUCTURAL_HOTKEY_DOM_REPAIR_WINDOW_MS = 500;
-const HISTORY_HOTKEY_DOM_REPAIR_WINDOW_MS = 150;
 /**
  * Remove the selected inline atom as one command: the caret lands where
  * the atom was; a printable key types `value` there. Answers whether an atom
  * was selected.
  */
 export const replaceSelectedAtom = (edytor, value = '') => {
-    const selected = edytor.selection.selectedInlineBlock.values().next().value ??
-        edytor.selection.inlineBlockDeletionTarget;
+    const selected = edytor.selection.inlineBlockDeletionTarget;
     if (!selected)
         return false;
     edytor.selection.clearInlineBlockSelection();
@@ -20,40 +17,19 @@ export const replaceSelectedAtom = (edytor, value = '') => {
     const index = parent.content.indexOf(selected);
     if (index === -1)
         return true;
-    const [before, after] = [parent.content[index - 1], parent.content[index + 1]];
-    const caret = before instanceof Text ? before : after instanceof Text ? after : parent.firstText;
-    const offset = before instanceof Text ? before.length : 0;
-    parent.removeInlineBlock({ index });
+    // The text before the atom (a block's content starts with a text): the
+    // removal joins the text after the atom to it.
+    const text = parent.content[index - 1];
+    const offset = text.length;
+    edytor.removeInline(parent.id, selected.id);
     if (value)
-        caret?.insertText({ value, start: offset, end: offset });
-    edytor.dispatcher.caret(caret, offset + value.length);
+        edytor.insertText(parent.id, text.segStart + offset, value);
+    edytor.dispatcher.caret(text, offset + value.length);
     return true;
 };
-const selectNextVoidBlockFromCaret = (edytor) => {
-    const { startText, yStart, isCollapsed } = edytor.selection.state;
-    if (!startText || !isCollapsed || yStart !== startText.length) {
-        return false;
-    }
-    const nextBlock = shown(startText.parent, 'blockAfter');
-    if (!nextBlock?.definition.void) {
-        return false;
-    }
-    edytor.selection.selectBlocks(nextBlock);
-    return true;
-};
-/** The key's attempt: the model owns the DOM drift around its command for `window` ms. */
-const suppressHotkeyDomDrift = (edytor, window) => {
-    const attempt = attemptOf(edytor, { inputType: 'hotkey', cancelable: true });
-    edytor.attempts.drift(edytor.attempts.admit(attempt, 'model'), 'discard', window);
-};
-const ownsDeleteSelection = (edytor) => edytor.selection.selectedBlocks.size > 0 || edytor.selection.selectedInlineBlock.size > 0;
-const history = (direction) => ({ edytor, prevent }) => prevent(() => {
-    suppressHotkeyDomDrift(edytor, HISTORY_HOTKEY_DOM_REPAIR_WINDOW_MS);
-    if (direction === 'undo')
-        edytor.historyUndo();
-    else
-        edytor.historyRedo();
-});
+/** The selection is the editor's own: an inline atom or blocks (no DOM range shows it). */
+const owned = ({ selection }) => selection.selectedBlocks.size > 0 || selection.inlineBlockDeletionTarget !== null;
+const history = (direction) => ({ edytor, prevent }) => prevent(() => (direction === 'undo' ? edytor.historyUndo() : edytor.historyRedo()));
 /**
  * Block-selection keys walk the document order with the island seal,
  * past a collapsed toggle's hidden body.
@@ -65,54 +41,72 @@ const SEALED = { sealed: true };
  * no line and no highlight of their own (Notion): a selection holding every
  * block of a layout stands for it (`liftLayouts`).
  */
-const stepOnto = (block, step) => {
+const stepOnto = (block, dir) => {
     const { facade } = block.edytor;
+    const step = dir > 0 ? 'blockAfter' : 'blockBefore';
     let next = shown(block, step, SEALED);
     while (next && (facade.isLayout(next.id) || facade.isLayoutItem(next.id)))
         next = shown(next, step, SEALED);
     return next;
 };
 /** Move a single block selection to its sealed neighbour in document order. */
-const moveBlockSelection = (step) => ({ edytor, prevent }) => {
-    const selectedBlocks = edytor.selection.selectedBlocks;
-    if (selectedBlocks.size === 1) {
-        prevent(() => {
-            const target = stepOnto(selectedBlocks.values().next().value, step);
-            if (target) {
-                edytor.selection.selectBlocks(target);
-            }
-        });
-    }
+const moveBlockSelection = (dir) => ({ edytor, prevent }) => {
+    const [block, ...rest] = edytor.selection.selectedBlocks;
+    if (!block || rest.length)
+        return;
+    prevent(() => {
+        const target = stepOnto(block, dir);
+        if (target)
+            edytor.selection.select(blockSelection([target.id]));
+    });
 };
-const arrowUp = vertical(-1, moveBlockSelection('blockBefore'));
-const arrowDown = vertical(1, moveBlockSelection('blockAfter'));
+const arrowUp = vertical(-1, moveBlockSelection(-1));
+const arrowDown = vertical(1, moveBlockSelection(1));
 /**
  * Shift+ArrowUp/Down over a block selection. Its first member is the
  * anchor and its last the focus (insertion order): a key moving the focus
  * back toward the anchor shrinks the selection, otherwise it extends past
  * the selection's edge in document order, one block at a time — a
  * parent and its children are separate members (`sel.blocks.exact`).
+ * Without a block selection the editor owns vertical extension (Shift+ArrowDown
+ * at the end of a text right before a void selects the void).
  */
-const extendBlockSelection = (edytor, direction) => {
-    const members = Array.from(edytor.selection.selectedBlocks);
-    const focus = members.at(-1);
-    const sign = Math.sign(edytor.compareBlocks(focus, members[0]));
-    if (sign === (direction === 'up' ? 1 : -1)) {
-        edytor.selection.removeBlockFromSelection(focus);
+const extend = (dir) => ({ edytor, prevent }) => {
+    const { selection } = edytor;
+    const members = [...selection.selectedBlocks];
+    if (!members.length) {
+        stayWithoutTarget(edytor, prevent);
+        if ((dir > 0 && voidAfter(edytor)) || extendVertically(edytor, dir))
+            prevent();
         return;
     }
-    const sorted = members.toSorted(edytor.compareBlocks);
-    const next = direction === 'up'
-        ? stepOnto(sorted[0], 'blockBefore')
-        : stepOnto(sorted.at(-1), 'blockAfter');
-    if (next)
-        edytor.selection.addBlockToSelection(next);
+    prevent(() => {
+        const { value } = selection;
+        const ids = value.kind === 'blocks' ? value.ids : [];
+        const focus = members.at(-1);
+        if (Math.sign(edytor.compareBlocks(focus, members[0])) === -dir)
+            return selection.select(blockSelection(ids.filter((id) => id !== focus.id)));
+        const sorted = members.toSorted(edytor.compareBlocks);
+        const next = stepOnto((dir > 0 ? sorted.at(-1) : sorted[0]), dir);
+        if (next && !ids.includes(next.id))
+            selection.select(blockSelection([...ids, next.id]));
+    });
+};
+/** A caret at the end of a text whose block a void follows selects that void. */
+const voidAfter = (edytor) => {
+    const { start, isCollapsed, isAtEndOfText } = edytor.selection.projection;
+    const block = isCollapsed && isAtEndOfText && start && edytor.idToBlock.get(start.block);
+    const next = block ? shown(block, 'blockAfter') : null;
+    if (!next?.definition.void)
+        return false;
+    edytor.selection.select(blockSelection([next.id]));
+    return true;
 };
 /**
  * Move `blocks` one level, one group of siblings at a time (Notion: over
  * several nesting levels, each group that can move does, a vetoed one too:
  * `dispatcher.each`), as one undo step. A block inside another of them
- * moves with it; `edytor.moveBlocks` moves siblings with an unselected block
+ * moves with it; `edytor.move` moves siblings with an unselected block
  * between them apart, so no key reorders the text. Answers
  * the moved blocks.
  */
@@ -121,62 +115,66 @@ const moveRoots = (edytor, blocks, direction) => {
     for (const block of outermost(blocks).toSorted(edytor.compareBlocks))
         groups.set(block.parent, [...(groups.get(block.parent) ?? []), block]);
     return edytor.dispatcher
-        .each('moveBlocks', [...groups.values()], (group) => edytor.moveBlocks({ blocks: group, direction }))
+        .each('moveBlocks', [...groups.values()], (group) => edytor.move({ blocks: group, direction }))
         .flatMap((moved) => moved ?? []);
 };
 /**
- * Tab / Shift+Tab: nest or unnest the selected block, or the caret's block.
+ * Tab / Shift+Tab, with `allowNesting`: nest or unnest the selected block, or the caret's block.
  * Selected blocks, or the blocks a text range spans, move one level per
  * group of siblings, a selected block's selected descendants with it, as
- * one command; the selection stays.
+ * one command; the selection stays (its anchors moved with the blocks).
  */
-const nest = (operation) => ({ edytor, prevent }) => prevent(() => {
-    suppressHotkeyDomDrift(edytor, STRUCTURAL_HOTKEY_DOM_REPAIR_WINDOW_MS);
-    const selectedBlocks = edytor.selection.selectedBlocks;
-    const direction = operation === 'nestBlock' ? 'in' : 'out';
-    const blocks = getSelectionBlocks(edytor);
-    if (blocks.length > 1) {
-        const members = [...selectedBlocks];
-        const { startText, endText, yStart, yEnd, isReversed } = edytor.selection.state;
-        if (!moveRoots(edytor, blocks, direction).length)
+const nest = (operation) => ({ edytor, prevent }) => 
+// Nesting off (`allowNesting`, the default): the key is not the editor's, the browser moves the focus on.
+edytor.allowNesting &&
+    prevent(() => {
+        const { selection } = edytor;
+        const { value } = selection;
+        const direction = operation === 'nestBlock' ? 'in' : 'out';
+        const blocks = getSelectionBlocks(edytor);
+        if (blocks.length > 1) {
+            if (moveRoots(edytor, blocks, direction).length)
+                selection.select(value);
+            return;
+        }
+        const [selected] = selection.selectedBlocks;
+        const at = selection.textAt(selection.projection.start);
+        const block = selected ?? at?.text.parent;
+        if (!block)
+            return;
+        // Into the block before it; the view's move reveals a closed toggle it lands in or that adopts.
+        const into = block.previousBlock;
+        if (operation === 'nestBlock' && !into)
+            return edytor.dispatcher.record({ operation, status: 'refused' });
+        const result = operation === 'unNestBlock'
+            ? edytor.unNestBlock(block.id)
+            : edytor.nestBlock(block.id, into.id);
+        if (result.status !== 'applied')
             return;
-        if (members.length)
-            edytor.selection.selectBlocks(...members);
-        else if (startText && endText)
-            edytor.selection.setAtRange(startText, yStart, endText, yEnd, { isReversed });
-        return;
-    }
-    const selectedBlock = selectedBlocks.values().next().value;
-    const { yStart, startText, startBlock } = edytor.selection.state;
-    const index = startText?.index;
-    // The block's command reveals a closed toggle it lands in or that adopts.
-    const block = (selectedBlock || startBlock)?.[operation]();
-    if (block)
         edytor.announcer.moved({ blocks: [block], direction }, [block]);
-    if (block && selectedBlock)
-        edytor.selection.selectBlocks(block);
-    else if (block && index !== undefined)
-        caretAt(edytor, block.content[index], yStart);
-});
+        if (selected)
+            selection.select(blockSelection([block.id]));
+        else if (at)
+            caretAt(edytor, block.content[at.text.index], at.offset);
+    });
 /**
  * Backspace/Delete over an editor-owned selection: the selected atom, or
  * the selected blocks (the caret lands at the end of the block before them).
+ * The command runs the hooks and authors its caret; the projector displays it.
  */
 const deleteSelection = ({ edytor, prevent }) => {
-    if (edytor.selection.selectedInlineBlock.size || edytor.selection.inlineBlockDeletionTarget)
-        return prevent(() => replaceSelectedAtom(edytor));
-    if (!edytor.selection.selectedBlocks.size)
-        return;
-    // The command runs the hooks and authors its caret; the projector displays it.
-    prevent(() => deleteSelectedBlocks(edytor));
+    if (edytor.selection.inlineBlockDeletionTarget)
+        prevent(() => replaceSelectedAtom(edytor));
+    else if (edytor.selection.selectedBlocks.size)
+        prevent(() => deleteSelectedBlocks(edytor));
 };
 /** An Emacs kill (ctrl+h/d/k): a delete intent, or the owned selection's delete. */
 const kill = (inputType) => (payload) => {
     const { edytor, prevent } = payload;
-    if (ownsDeleteSelection(edytor))
+    if (owned(edytor))
         return deleteSelection(payload);
-    const { state, projection } = edytor.selection;
-    if (state.startText)
+    const { projection } = edytor.selection;
+    if (edytor.selection.textAt(projection.start))
         prevent(() => edytor.ports.input.runIntent(inputType(projection)));
 };
 /**
@@ -186,10 +184,7 @@ const kill = (inputType) => (payload) => {
  * without a DOM range, so the chord is claimed at its keydown. Shift+Delete
  * is not one (the Windows cut).
  */
-const wordAndLineDeletes = Object.fromEntries(['alt', 'mod', 'ctrl'].flatMap((modifier) => ['backspace', 'delete'].map((key) => [
-    `${modifier}+${key}`,
-    (payload) => (ownsDeleteSelection(payload.edytor) ? deleteSelection(payload) : undefined)
-])));
+const wordAndLineDeletes = Object.fromEntries(['alt', 'mod', 'ctrl'].flatMap((modifier) => ['backspace', 'delete'].map((key) => [`${modifier}+${key}`, deleteSelection])));
 /**
  * macOS Emacs/Cocoa text bindings. Bare `ctrl+` chords only resolve on
  * Apple platforms (the keymap folds Ctrl into `mod` elsewhere), so the table
@@ -204,9 +199,9 @@ const emacs = {
     'ctrl+k': kill((at) => at.isCollapsed && at.isAtEndOfBlock ? 'deleteContentForward' : 'deleteHardLineForward'),
     // Open-line: a soft break with the caret kept before it.
     'ctrl+o': ({ edytor, prevent }) => {
-        if (ownsDeleteSelection(edytor) || !edytor.selection.state.startText)
+        if (owned(edytor) || !edytor.selection.textAt(edytor.selection.projection.start))
             return;
-        prevent(() => edytor.dispatcher.run('insertBlock', () => edytor.ports.input.insertLineBreak(intentSnapshot(edytor, 'insertLineBreak'), 'before')));
+        prevent(() => edytor.dispatcher.run('insertBlocks', () => edytor.ports.input.insertLineBreak(intentSnapshot(edytor, 'insertLineBreak'), 'before')));
     },
     'ctrl+p': arrowUp,
     'ctrl+n': arrowDown
@@ -223,44 +218,21 @@ export const builtInBindings = {
     'mod+enter': ({ edytor, prevent }) => prevent(() => flipToggles(shownSelectionBlocks(edytor))),
     // The select-all ladder: the block's text, then the block, then every block
     // (at once with no selection at all, as Notion).
-    'mod+a': ({ edytor, prevent }) => {
-        prevent(() => {
-            const { startText, startBlock } = edytor.selection.state;
-            const { islandRoot, isAtStartOfBlock, isAtEndOfBlock } = edytor.selection.projection;
-            // Every block, nested ones included: a block selection is exactly its members.
-            const every = () => edytor.selection.selectBlocks(...edytor.facade.order().flatMap((id) => edytor.idToBlock.get(id) ?? []));
-            if (!startText) {
-                if (edytor.selection.value.kind === 'none')
-                    every();
-                return;
-            }
-            if (edytor.selection.selectedBlocks.size) {
-                every();
-            }
-            else if (isAtStartOfBlock && isAtEndOfBlock) {
-                edytor.selection.selectBlocks(edytor.idToBlock.get(islandRoot ?? '') ?? startText.parent);
-            }
-            else {
-                edytor.selection.setAtBlockRange(startBlock);
-            }
-        });
-    },
+    'mod+a': ({ edytor, prevent }) => prevent(() => {
+        const { selection, idToBlock } = edytor;
+        const { start, islandRoot, isAtStartOfBlock, isAtEndOfBlock } = selection.projection;
+        const block = selection.textAt(start)?.text.parent;
+        // Every block, nested ones included: a block selection is exactly its members.
+        if (block ? selection.selectedBlocks.size : selection.value.kind === 'none')
+            selection.select(blockSelection(edytor.facade.order().filter((id) => idToBlock.has(id))));
+        else if (block && isAtStartOfBlock && isAtEndOfBlock)
+            selection.select(blockSelection([(idToBlock.get(islandRoot ?? '') ?? block).id]));
+        else
+            selection.selectLines(block);
+    }),
     ...navigationBindings,
-    // Without a block selection the editor owns vertical extension.
-    'shift+arrowup': ({ edytor, prevent }) => {
-        if (edytor.selection.selectedBlocks.size)
-            return prevent(() => extendBlockSelection(edytor, 'up'));
-        stayWithoutTarget(edytor, prevent);
-        if (extendVertically(edytor, -1))
-            prevent();
-    },
-    'shift+arrowdown': ({ edytor, prevent }) => {
-        if (edytor.selection.selectedBlocks.size)
-            return prevent(() => extendBlockSelection(edytor, 'down'));
-        stayWithoutTarget(edytor, prevent);
-        if (selectNextVoidBlockFromCaret(edytor) || extendVertically(edytor, 1))
-            prevent();
-    },
+    'shift+arrowup': extend(-1),
+    'shift+arrowdown': extend(1),
     arrowup: arrowUp,
     arrowdown: arrowDown,
     tab: nest('nestBlock'),
@@ -273,7 +245,7 @@ export const builtInBindings = {
         prevent(() => {
             const at = selectedBlocksExit(edytor);
             if (at)
-                edytor.selection.setAtTextOffset(at.text, at.offset);
+                edytor.selection.selectText(at.text, at.offset);
         });
     },
     backspace: deleteSelection,

package/dist/session/commands.d.ts

@@ -1,22 +1,40 @@
-import type { Prepared } from '../crdt/edytor-doc.js';
+/**
+ * The command dispatcher: one per view.
+ *
+ * Every write a view makes is one of the document's operations
+ * (`DocumentWrites`, dispatched under its own name and arguments:
+ * `edytor.insertBlocks(…)`), or a named command that is one prepared plan of
+ * them (`plan`: a table row, a find-and-replace). It is admitted (readonly,
+ * `document.writable`), prepared, shown to every extension hook before any
+ * write — the command itself, then each planned step as the operation it
+ * performs — applied in one transaction, normalized once per touched block at
+ * the end of that transaction (normalizers read handles over the index), and
+ * reported (`refused | noop | applied | failed`). A user command (`run`)
+ * wraps the operations one gesture issues and closes the undo policy table.
+ * `prevent()` is caught here, once (`prevented`).
+ */
+import type { Block } from '../block/block.svelte.js';
+import type { DocumentWrites } from '../crdt/operations.js';
+import type { OpResult, Prepared } from '../crdt/edytor-doc.js';
+import type { DocPosition } from '../crdt/rangeDelete.js';
 import type { SelectionValue } from './selection.js';
 import type { Text } from '../text/text.svelte.js';
 import type { Caret } from '../selection/selection.svelte.js';
 /**
  * The result of the last command a view ran (`edytor.dispatcher.last`): its
- * operation, its status and, for a handle mutator (`block.insertBlockAfter`,
- * `text.insertText`, …), the `value` the mutator returned — `undefined`
- * when the command was refused or did not run.
+ * operation and its status.
  */
-export type CommandResult<T = unknown> = {
+export type CommandResult = {
     operation: string;
     status: 'refused' | 'noop' | 'applied' | 'failed';
-    /** What the command answered: a handle mutator's return value. */
-    value?: T;
     error?: unknown;
     /** The result selection the command authored, selected once. */
     selection?: SelectionValue;
 };
+/** A document write's name. */
+export type Write = keyof DocumentWrites;
+/** A kind's normalizer (`BlockDefinition.normalizeContent`/`normalizeChildren`). */
+export type Normalizer = 'normalizeContent' | 'normalizeChildren';
 export declare class Dispatcher {
     #private;
     private edytor;
@@ -37,9 +55,6 @@ export declare class Dispatcher {
     /** Requested normalization passes: (block id, normalizer). */
     private queue;
     private current;
-    /** The drain is entering `current`'s normalizer (its own request runs it). */
-    private entering;
-    private draining;
     /** A plan the next dispatched operation composes before its own (`lead`). */
     private leading;
     /** What the last `patchData` set to text: typing on the same paths continues its step (a bound field). */
@@ -55,9 +70,10 @@ export declare class Dispatcher {
      * placed. That step's undo withdraws the block, URL included
      * (`hist.undo.withdraw`), and its redo shows it again, so the paste stays
      * one step whatever the upload's delay, and the typing around it groups
-     * as if it never came. Throws, writing nothing, when a transaction is
-     * already open: its writes would take that transaction's origin and join
-     * its step (call it from a later task, as an upload's answer is).
+     * as if it never came. In development, throws, writing nothing, when a
+     * transaction is already open: its writes would take that transaction's
+     * origin and join its step (call it from a later task, as an upload's
+     * answer is).
      */
     outside: <T>(body: () => T) => T;
     /**
@@ -90,6 +106,17 @@ export declare class Dispatcher {
         block: unknown;
         text?: Text;
     }, body: (payload: P, plan?: Prepared) => R, prepare?: (payload: P) => Prepared) => R | undefined;
+    /**
+     * Dispatch `operation` as the plan `prepare` makes of `payload` (a hook's
+     * replacement payload is prepared again), about `block` (the root by
+     * default): hooks see it and each planned step before any write; one
+     * transaction; the blocks it touched normalized and the blocks it moved
+     * shown (closed toggles open); the caret it decides (`plan.at`: a range
+     * deletion, a placed flow) selected. Answers its result: `refused` when
+     * the document refused it, `refused` with the reason `'view'` when the
+     * view did (readonly, a read-only document) or a hook prevented it.
+     */
+    plan: <P>(operation: string, payload: P, prepare: (payload: P) => Prepared, block?: Block, text?: Text) => OpResult;
     /**
      * Run `body` with `lead` (a plan prepared now) composed into the first
      * operation it dispatches: one plan, so a veto of any step, or a refusal,
@@ -110,8 +137,8 @@ export declare class Dispatcher {
      * block offsets (an inline atom counting 1).
      */
     caret: {
-        <T>(text: Text | null | undefined, offset: number, ops?: () => T): T | undefined;
-        <T>(caret: Caret | null | undefined, ops?: () => T): T | undefined;
+        (text: Text | null | undefined, offset: number, ops?: () => OpResult): OpResult | undefined;
+        (caret: Caret | DocPosition | null | undefined, ops?: () => OpResult): OpResult | undefined;
     };
     /**
      * The cut an operation applies as it writes. Inside a user command none
@@ -122,7 +149,6 @@ export declare class Dispatcher {
     private policy;
     /** A continuation continues this view's last step, or cuts before it writes. */
     private decide;
-    private refuse;
     private settle;
     /**
      * Run a prevention's replacement: a command of its own, so a veto of one
@@ -132,12 +158,11 @@ export declare class Dispatcher {
      */
     private replace;
     /**
-     * The planned steps as hooks see them, under the documented
-     * operation names. A step that is the command itself (same name, same
-     * block) is not repeated; a write into a block the plan creates is part
-     * of that creation. (A `removeInline` step is only ever its own command,
-     * `removeInlineBlock`; `formatRange` steps belong to no dispatched plan
-     * yet: no mapping. A document data patch shows on the root.)
+     * The planned steps as hooks see them: each as the operation it performs,
+     * with that operation's arguments (`ARGS`), about the block it writes
+     * (the root for the document's data). A step that is the command itself
+     * (same name, same block) is not repeated; a write into a block the plan
+     * creates is part of that creation.
      */
     private steps;
 }