edytor 1.0.0-rc.3 → 2.0.0

package/dist/session/navigation.js

@@ -1,9 +1,8 @@
-import { InlineBlock } from '../block/inlineBlock.svelte.js';
-import { Text } from '../text/text.svelte.js';
-import { getNextGraphemeEnd, getPreviousGraphemeStart } from '../text/text.utils.js';
-import { getNextWordEndOffset, getPreviousWordStartOffset } from '../text/wordBoundary.js';
+import { getNextGraphemeEnd, getNextWordEndOffset, getPreviousGraphemeStart, getPreviousWordStartOffset } from '../text/wordBoundary.js';
 import { getSelectedBlocksInDocumentOrder, shownText } from '../selection/replaceSelection.js';
+import { atomSelection, segmentsOf } from './selection.js';
 import { untargeted } from './attempt.js';
+import { siblingSlot } from './handles.js';
 /**
  * With no target (`untargeted`: the value is `none`, no gesture placed the
  * host's caret), a navigation key does nothing (Notion): it is claimed, so
@@ -14,65 +13,64 @@ export const stayWithoutTarget = (edytor, prevent) => {
     if (untargeted(edytor))
         prevent();
 };
+/** An inline atom in a block's string. */
+const ATOM = '';
+/** A block's content as one string, each inline atom one `ATOM`. */
+const stringOf = (edytor, block) => edytor.facade
+    .contentItems(block)
+    .map((item) => (item.kind === 'text' ? item.text : ATOM))
+    .join('');
 /** A block's stop at its edge in `dir` (its end going forward, its start going backward). */
-const edge = (block, dir) => {
-    const texts = block.content.filter((part) => part instanceof Text);
-    const text = dir > 0 ? texts.at(-1) : texts[0];
-    return text ? { text, offset: dir > 0 ? text.length : 0 } : null;
-};
+const edge = (edytor, block, dir) => ({
+    block,
+    offset: dir > 0 ? edytor.facade.displayLength(block) : 0
+});
 /** The first displayable block after `from` in document order (`from` null: the document's edge). */
 const displayable = (edytor, from, dir) => {
     const ids = edytor.facade.order();
-    const at = from ? ids.indexOf(from.id) : dir > 0 ? -1 : ids.length;
+    const at = from ? ids.indexOf(from) : dir > 0 ? -1 : ids.length;
     for (let i = at + dir; i >= 0 && i < ids.length; i += dir)
         if (edytor.selection.displayable(ids[i]))
-            return edytor.idToBlock.get(ids[i]) ?? null;
+            return ids[i];
     return null;
 };
 /**
- * The next stop from `at`: a grapheme or word boundary inside its text, else
- * the near side of the text beyond the atom next to it, else the near edge of
- * the next displayable block.
+ * The next stop from `at`: a grapheme or word boundary inside its text (the
+ * run between the atoms around it), else the near side of the atom next to
+ * it, else the near edge of the next displayable block.
  */
-const step = (edytor, { text, offset }, dir, unit) => {
-    const value = text.stringContent;
-    if (dir > 0 ? offset < value.length : offset > 0) {
+const step = (edytor, { block, offset }, dir, unit) => {
+    const value = stringOf(edytor, block);
+    const from = offset && value.lastIndexOf(ATOM, offset - 1) + 1;
+    const to = value.indexOf(ATOM, offset);
+    const text = value.slice(from, to < 0 ? undefined : to);
+    const at = offset - from;
+    if (dir > 0 ? at < text.length : at > 0) {
         const next = unit === 'word'
-            ? (dir > 0 ? getNextWordEndOffset : getPreviousWordStartOffset)(value, offset)
-            : (dir > 0 ? getNextGraphemeEnd : getPreviousGraphemeStart)(value, offset);
-        if (next !== offset)
-            return { text, offset: next };
+            ? (dir > 0 ? getNextWordEndOffset : getPreviousWordStartOffset)(text, at)
+            : (dir > 0 ? getNextGraphemeEnd : getPreviousGraphemeStart)(text, at);
+        if (next !== at)
+            return { block, offset: from + next };
     }
-    const { content } = text.parent;
-    const index = content.indexOf(text);
-    const beyond = content[index + 2 * dir];
-    if (content[index + dir] instanceof InlineBlock)
-        return beyond instanceof Text ? { text: beyond, offset: dir > 0 ? 0 : beyond.length } : null;
-    const block = displayable(edytor, text.parent, dir);
-    return block && edge(block, -dir);
+    if (value[dir > 0 ? offset : offset - 1] === ATOM)
+        return { block, offset: offset + dir };
+    const next = displayable(edytor, block, dir);
+    return next ? edge(edytor, next, -dir) : null;
 };
-const compare = (a, b, edytor) => a.text === b.text
-    ? a.offset - b.offset
-    : a.text.parent === b.text.parent
-        ? a.text.parent.content.indexOf(a.text) - b.text.parent.content.indexOf(b.text)
-        : edytor.compareBlocks(a.text.parent, b.text.parent);
+const compare = (edytor, a, b) => a.block === b.block ? a.offset - b.offset : edytor.facade.compare(a.block, b.block);
 /** Select `anchor` → `focus`: a caret, the one atom the range covers, or the range. */
 const select = (edytor, anchor, focus) => {
-    const order = compare(anchor, focus, edytor);
-    if (order === 0)
-        return edytor.selection.setAtTextOffset(focus.text, focus.offset);
-    const [start, end] = order < 0 ? [anchor, focus] : [focus, anchor];
-    const { content } = start.text.parent;
-    const index = content.indexOf(start.text);
-    const atom = content[index + 1];
-    if (atom instanceof InlineBlock &&
-        content[index + 2] === end.text &&
-        start.offset === start.text.length &&
-        end.offset === 0)
-        return edytor.selection.selectInlineBlock(atom, order > 0 ? 'after' : 'before');
-    edytor.selection.setAtRange(start.text, start.offset, end.text, end.offset, {
-        isReversed: order > 0
-    });
+    const { selection } = edytor;
+    const order = compare(edytor, anchor, focus);
+    const [start, end] = order > 0 ? [focus, anchor] : [anchor, focus];
+    const atom = start.block === end.block && end.offset - start.offset === 1
+        ? segmentsOf(edytor.facade, start.block).find((part) => part.kind === 'inline' && part.start === start.offset)
+        : null;
+    if (atom?.kind === 'inline')
+        return selection.select(atomSelection(start.block, atom.id, order > 0 ? 'after' : 'before'));
+    const [from, to] = [selection.textAt(start), selection.textAt(end)];
+    if (from && to)
+        selection.selectText(from.text, from.offset, to.text, to.offset, order > 0);
 };
 /**
  * One apply step for `unit` in `dir` (`left`/`right`: visual). Answers whether
@@ -82,8 +80,9 @@ const select = (edytor, anchor, focus) => {
  */
 export const move = (edytor, unit, key, extend) => {
     const { selection } = edytor;
-    const { value, state } = selection;
-    if (value.kind === 'none' || !state.startText || !state.endText)
+    const { value, projection } = selection;
+    let { start, end } = projection;
+    if (value.kind === 'none' || !selection.textAt(start) || !selection.textAt(end))
         return false;
     if (unit === 'char' && value.kind === 'blocks')
         return false;
@@ -91,50 +90,55 @@ export const move = (edytor, unit, key, extend) => {
     // end (a list's items, a code block's lines, never a divider; a
     // member's own line, never an unselected child's).
     const blocks = value.kind === 'blocks' && getSelectedBlocksInDocumentOrder(edytor);
-    let first = blocks
-        ? blocks.map((block) => shownText(block, 'first')).find(Boolean)
-        : state.startText;
-    let last = blocks
-        ? blocks.map((block) => shownText(block, 'last')).findLast(Boolean)
-        : state.endText;
-    if (!first || !last) {
+    if (blocks) {
+        const first = blocks.map((block) => shownText(block, 'first')).find(Boolean);
+        const last = blocks.map((block) => shownText(block, 'last')).findLast(Boolean);
+        if (first && last) {
+            start = { block: first.blockId, offset: first.segStart };
+            end = { block: last.blockId, offset: last.segStart + last.length };
+        }
         // Voids alone show no line: the blocks stay selected, except for the
         // document keys, whose target is the document's edge (`select` moves
         // an anchor left in a void beside it).
-        if (unit !== 'doc')
+        else if (unit !== 'doc')
             return true;
-        [first, last] = [state.startText, state.endText];
     }
-    const start = { text: first, offset: blocks ? 0 : state.yStart };
-    const end = { text: last, offset: blocks ? last.length : state.yEnd };
-    const rtl = selection.rtl(state.isReversed ? start.text : end.text);
+    if (!start || !end)
+        return false;
+    const rtl = selection.rtl(selection.textAt(projection.isReversed ? start : end).text);
     const dir = typeof key === 'number' ? key : (key === 'right') !== rtl ? 1 : -1;
     // The focus moves; an atom is the range anchored on the side it came from,
     // a block selection on the side away from the key.
-    const reversed = value.kind === 'atom' ? value.from === 'after' : blocks ? dir < 0 : state.isReversed;
+    const reversed = value.kind === 'atom' ? value.from === 'after' : blocks ? dir < 0 : projection.isReversed;
     const [anchor, focus] = reversed ? [end, start] : [start, end];
     const nodeBound = unit === 'char' && value.kind === 'text' && selection.hasNativeNodeSelection();
-    if (!extend && (blocks || !state.isCollapsed) && unit !== 'line' && unit !== 'doc') {
+    if (!extend && (blocks || !projection.isCollapsed) && unit !== 'line' && unit !== 'doc') {
         if (unit === 'char' && value.kind === 'text' && !nodeBound)
             return false;
         const to = dir > 0 ? end : start;
         select(edytor, to, to);
         return true;
     }
+    const first = unit === 'doc' ? displayable(edytor, null, -dir) : null;
     let to = unit === 'line'
-        ? edge(focus.text.parent, dir)
-        : unit === 'doc'
-            ? (() => {
-                const block = displayable(edytor, null, -dir);
-                return block && edge(block, dir);
-            })()
-            : step(edytor, focus, dir, unit);
-    // Past a soft break the caret has two DOM positions (the break's node end,
-    // the next line's start): Firefox's forward step only trades one for the
-    // other, so that step is the editor's (a logical step: bidi never reorders
-    // across a line break).
-    const native = unit === 'char' && !nodeBound && to?.text === focus.text && value.kind === 'text';
-    if (native && !(dir > 0 && focus.text.stringContent[focus.offset - 1] === '\n'))
+        ? edge(edytor, focus.block, dir)
+        : unit !== 'doc'
+            ? step(edytor, focus, dir, unit)
+            : first
+                ? edge(edytor, first, dir)
+                : null;
+    // A grapheme step inside the focus's text is the browser's, except past a
+    // soft break, where the caret has two DOM positions (the break's node
+    // end, the next line's start): Firefox's forward step only trades one for
+    // the other, so that step is the editor's (a logical step: bidi never
+    // reorders across a line break).
+    const text = stringOf(edytor, focus.block);
+    const native = unit === 'char' &&
+        !nodeBound &&
+        value.kind === 'text' &&
+        to?.block === focus.block &&
+        text[Math.min(to.offset, focus.offset)] !== ATOM;
+    if (native && !(dir > 0 && text[focus.offset - 1] === '\n'))
         return false;
     // A forward node-bound extension never rests on another block's first
     // stop (a derive maps that end back onto the previous block's end).
@@ -142,9 +146,8 @@ export const move = (edytor, unit, key, extend) => {
         extend &&
         to &&
         to.offset === 0 &&
-        to.text === to.text.parent.content[0] &&
-        to.text.parent !== anchor.text.parent &&
-        compare(anchor, to, edytor) < 0)
+        to.block !== anchor.block &&
+        compare(edytor, anchor, to) < 0)
         to = step(edytor, to, 1, 'char');
     if (!to) {
         if (!nodeBound)
@@ -156,80 +159,38 @@ export const move = (edytor, unit, key, extend) => {
     select(edytor, extend ? anchor : to, to);
     return true;
 };
-/** A block's lines: its texts split at `\n` soft breaks (logical lines, not layout). */
-const linesOf = (block) => {
-    const lines = [[]];
-    for (const part of block.content) {
-        if (!(part instanceof Text)) {
-            lines.at(-1).push(null);
-            continue;
-        }
-        let offset = 0;
-        part.stringContent.split('\n').forEach((line, index) => {
-            if (index)
-                lines.push([]);
-            lines.at(-1).push({ text: part, offset, length: line.length });
-            offset += line.length + 1;
-        });
-    }
-    return lines;
-};
-/** The stop at `column` of a line; past its end, the end of its last text. */
-const onLine = (line, column) => {
-    let rest = Math.max(column, 0);
-    let last = null;
-    for (const piece of line) {
-        if (!piece) {
-            rest = Math.max(0, rest - 1);
-            continue;
-        }
-        last = piece;
-        if (piece.length === 0 && rest > 0)
-            continue;
-        if (rest <= piece.length)
-            return { text: piece.text, offset: piece.offset + rest };
-        rest -= piece.length;
-    }
-    return last && { text: last.text, offset: last.offset + last.length };
-};
-const islandOf = (edytor, block) => [block.id, ...edytor.facade.ancestorsOf(block.id)].find((id) => edytor.facade.isIsland(id));
-/** The line holding `at` and its column there. */
-const locate = (lines, at) => {
-    for (const [index, line] of lines.entries()) {
-        let column = 0;
-        for (const piece of line) {
-            if (piece?.text === at.text &&
-                at.offset >= piece.offset &&
-                at.offset <= piece.offset + piece.length)
-                return { index, column: column + at.offset - piece.offset };
-            column += piece ? piece.length : 1;
-        }
-    }
-    return null;
+/** A block's lines (split at its `\n` soft breaks: logical lines, not layout), as start and end offsets. */
+const linesOf = (edytor, block) => {
+    let at = 0;
+    return stringOf(edytor, block)
+        .split('\n')
+        .map((line) => [at, (at += line.length + 1) - 1]);
 };
+const islandOf = (edytor, block) => [block, ...edytor.facade.ancestorsOf(block)].find((id) => edytor.facade.isIsland(id));
 /**
- * The stop one line from `from` in `dir` at `goal` (default: its own column):
- * the next line of its block, else the facing line of the next displayable
- * non-void block inside the same island, else its own block's edge. Every
- * line holds a text, so `onLine` always finds a stop.
+ * The stop one line from `from` in `dir` at `goal` (default: its own column;
+ * an atom is one column): the next line of its block, else the facing line
+ * of the next displayable non-void block inside the same island, else its
+ * own block's edge.
  */
 const lineStop = (edytor, from, dir, goal) => {
-    const block = from.text.parent;
-    const lines = linesOf(block);
-    const at = locate(lines, from);
-    if (!at)
+    const lines = linesOf(edytor, from.block);
+    const index = lines.findIndex(([start, end]) => from.offset >= start && from.offset <= end);
+    if (index < 0)
         return null;
-    const column = goal ?? at.column;
-    let line = lines[at.index + dir];
+    const column = goal ?? from.offset - lines[index][0];
+    let block = from.block;
+    let line = lines[index + dir];
     const island = islandOf(edytor, block);
     for (let next = line ? null : displayable(edytor, block, dir); next && !line; next = displayable(edytor, next, dir)) {
         if (islandOf(edytor, next) !== island)
             break;
-        if (!edytor.facade.isVoid(next.id))
-            line = linesOf(next).at(dir > 0 ? 0 : -1);
+        if (!edytor.facade.isVoid(next))
+            [block, line] = [next, linesOf(edytor, next).at(dir > 0 ? 0 : -1)];
     }
-    const to = line ? onLine(line, column) : onLine(lines.at(dir > 0 ? -1 : 0), dir * Infinity);
-    return to && { ...to, column };
+    const [start, end] = line ?? lines.at(dir > 0 ? -1 : 0);
+    const offset = start + (line ? column : dir * Infinity);
+    return { block, offset: Math.min(Math.max(offset, start), end), column };
 };
 const goals = new WeakMap();
 /**
@@ -240,12 +201,11 @@ const goals = new WeakMap();
  * moves keep the goal column. Answers whether a text selection moved.
  */
 export const extendVertically = (edytor, dir) => {
-    const { value, state } = edytor.selection;
-    if (value.kind !== 'text' || !state.startText || !state.endText)
+    const { value, projection } = edytor.selection;
+    const { start, end } = projection;
+    if (value.kind !== 'text' || !start || !end)
         return false;
-    const start = { text: state.startText, offset: state.yStart };
-    const end = { text: state.endText, offset: state.yEnd };
-    const [anchor, focus] = state.isReversed ? [end, start] : [start, end];
+    const [anchor, focus] = projection.isReversed ? [end, start] : [start, end];
     const kept = goals.get(edytor);
     const to = lineStop(edytor, focus, dir, kept?.value === value ? kept.column : undefined);
     if (!to)
@@ -270,9 +230,9 @@ const natives = new WeakMap();
  */
 const stopBelow = (edytor, block) => {
     const { facade } = edytor;
-    const items = [block.id, ...facade.ancestorsOf(block.id)].filter((id) => facade.isLayoutItem(id) || facade.isTableCell(id));
+    const items = [block, ...facade.ancestorsOf(block)].filter((id) => facade.isLayoutItem(id) || facade.isTableCell(id));
     const ids = facade.order();
-    const from = ids.indexOf(block.id);
+    const from = ids.indexOf(block);
     if (from < 0)
         return true;
     for (let i = from + 1; i < ids.length; i++) {
@@ -295,23 +255,30 @@ const stopBelow = (edytor, block) => {
  * cell, a code line, a heading). Never in a view that writes nothing.
  */
 const leavesLastStop = (edytor) => {
-    const { selection, root } = edytor;
-    const { value, state } = selection;
-    if (value.kind !== 'text' || !state.isCollapsed || !state.startText || !root)
-        return false;
-    if (!edytor.dispatcher.permits())
+    const block = onLastLine(edytor);
+    const { root } = edytor;
+    if (!block || !root || !edytor.dispatcher.permits())
         return false;
-    const at = { text: state.startText, offset: state.yStart };
-    const block = at.text.parent;
     if (block.parent?.isRoot && block.type === edytor.defaultChild(root))
         return false;
-    const lines = linesOf(block);
-    if (locate(lines, at)?.index !== lines.length - 1)
-        return false;
-    const end = edge(block, 1);
-    if (end && edytor.ports.surface.sameLine(at, end) === false)
-        return false;
-    return !stopBelow(edytor, block);
+    return !stopBelow(edytor, block.id);
+};
+/**
+ * The block a collapsed text caret sits on the last line of (a line box
+ * where the view lays one out, else a line break), if it does: where
+ * ArrowDown leaves the block (`nav.trailing.exit`, `body.down`).
+ */
+export const onLastLine = (edytor) => {
+    const { value, projection } = edytor.selection;
+    const at = projection.start;
+    const block = at && edytor.idToBlock.get(at.block);
+    if (value.kind !== 'text' || !projection.isCollapsed || !block)
+        return;
+    const text = stringOf(edytor, at.block);
+    if (text.includes('\n', at.offset))
+        return;
+    const last = edytor.ports.surface.sameLine(at, { block: at.block, offset: text.length });
+    return last === false ? undefined : block;
 };
 /**
  * The trailing paragraph (`nav.trailing`, Notion): the caret goes to an
@@ -329,13 +296,14 @@ export const toTrailingParagraph = (edytor) => {
         return false;
     const kind = edytor.defaultChild(root);
     if (last.type === kind && last.isEmpty && last.firstText) {
-        edytor.selection.setAtTextOffset(last.firstText, 0);
+        edytor.selection.selectText(last.firstText, 0);
         return true;
     }
-    const after = last.insertBlockAfter({ block: { type: kind } });
-    if (!after?.firstText)
+    const { ids } = edytor.insertBlocks(siblingSlot(last), [{ type: kind }]);
+    const text = edytor.idToBlock.get(ids[0] ?? '')?.firstText;
+    if (!text)
         return false;
-    edytor.dispatcher.caret(after.firstText, 0);
+    edytor.dispatcher.caret(text, 0);
     return true;
 };
 /**
@@ -363,10 +331,10 @@ export const landed = (edytor) => {
     if (!native || native.serial !== edytor.intentSerial || native.value !== selection.value)
         return false;
     natives.delete(edytor);
-    const { startText, endText, yStart, yEnd, isReversed } = selection.state;
-    if (!startText || !endText)
+    const { start, end, isReversed } = selection.projection;
+    const focus = isReversed ? start : end;
+    if (!focus)
         return false;
-    const focus = isReversed ? { text: startText, offset: yStart } : { text: endText, offset: yEnd };
     const to = lineStop(edytor, focus, native.dir) ?? focus;
     select(edytor, to, to);
     return true;

package/dist/session/ports.d.ts

@@ -9,6 +9,7 @@
  */
 import type { Text } from '../text/text.svelte.js';
 import type { Attempt } from './attempt.js';
+import type { SelectionPoint } from './selection.js';
 /** The surface as the session sees it: the projector, the observer, the DOM selection. */
 export interface SurfacePort {
     /**
@@ -35,13 +36,7 @@ export interface SurfacePort {
      * ends where a line wraps), or `null` where nothing is laid out
      * (`surface/lines.ts`).
      */
-    sameLine(a: {
-        text: Text;
-        offset: number;
-    }, b: {
-        text: Text;
-        offset: number;
-    }): boolean | null;
+    sameLine(a: SelectionPoint, b: SelectionPoint): boolean | null;
 }
 /** The input commands a key binding runs (`events/beforeInputCommands.ts`). */
 export interface InputPort {

package/dist/session/props.d.ts

@@ -1,28 +1,28 @@
 /**
- * Properties: the deep proxy behind `block.data`, `atom.data` and
- * `edytor.data` (syncrostate's feel, one small module).
+ * A view's property writes (`block.data`, `atom.data`, `edytor.data`): the
+ * data proxy (`crdt/props.ts`) over the view's one write path.
  *
- * A read goes to `read()` every time (the view's live, reactive source), so
- * a template that reads `block.data.title` re-renders when anyone changes
- * it. Plain objects read as nested proxies, arrays as array proxies,
- * everything else as the raw value; a proxy is cached per path, so its
- * identity is stable. An object or array held in an array item is that
- * item's (its path names the item by id, from `ids`): it stays on its item
- * wherever peers move it, so `{#each list as item (item)}` keeps a row, and
- * the focused field in it, on its item; once the item is removed, or its
- * array is, its writes are refused. A key is a path segment as
- * `keySegment` writes it (`~abc` as `~0abc`: never an item's id). A write
- * is one data patch through `write` (a
- * command): `obj.key = v`, `arr[i] = v` (by index) and `delete obj.key`
- * patch that path (a write inside an item, that item);
- * `push`, `pop`, `shift`, `unshift`, `splice` and `length` are one
- * `splice`, `sort` and `reverse` one `order` (the items move), `fill` and
- * `copyWithin` writes of the items they change.
- * `JSON.stringify` and `$state.snapshot` read plain JSON through it.
+ * The writes of one synchronous task are one dispatch: they queue per
+ * target and leave on the next microtask, or before any other operation
+ * this view dispatches, as the `patchData` operation of each target (more
+ * than one target: one user command, so one undo step, in one
+ * transaction). Hooks see that operation; a veto drops the burst. Until
+ * then the proxy reads its target's data with the queued patches applied
+ * (`dataPreview`), so a write reads back at once. A view that refuses
+ * writes (readonly, a read-only document) refuses an assignment at once:
+ * nothing is queued, the dispatcher records `refused`, nothing throws.
  */
-import { type DataPatch } from '../crdt/data.js';
-type Json = Record<string, unknown>;
-export declare const propsProxy: <T extends object = Json>(read: () => Json, write: (ops: DataPatch[]) => void, 
-/** The ids of the items of the array at a path (`facade.dataItemIds`). */
-ids?: (path: readonly string[]) => string[]) => T;
-export {};
+import type { DataPatch } from '../crdt/data.js';
+import type { DataTarget } from '../crdt/doc/types.js';
+import type { Edytor } from '../edytor.svelte.js';
+export declare class DataWrites {
+    #private;
+    private readonly edytor;
+    constructor(edytor: Edytor);
+    /** The live proxy over `target`'s data; `read` is its reactive, committed source. */
+    proxy<T extends object>(target: DataTarget, read: () => Record<string, unknown>): T;
+    /** Queue `patches` on `target` for this task's dispatch (refused at once when the view refuses writes). */
+    write(target: DataTarget, patches: DataPatch[]): undefined;
+    /** Dispatch the queued writes now: before any other operation of this view, and at the end of the task. */
+    flush(): undefined;
+}