edytor 1.0.0-rc.3 → 2.0.0

package/dist/selection/replaceSelection.js

@@ -1,9 +1,15 @@
 import { Text } from '../text/text.svelte.js';
 import { id, vetoable } from '../utils.js';
+import { blockSelection, noSelection } from '../session/selection.js';
 import { hidden, selectedMembers, shown } from './visibility.js';
-export const getSelectionReplacementState = (edytor) => {
-    const { startText, endText, yStart, yEnd, isCollapsed } = edytor.selection.state;
-    return { startText, endText, yStart, yEnd, isCollapsed };
+/**
+ * The caret a write that decides one left (a range deletion, a placed flow:
+ * the view selects it), as a text and an offset; none when the write was
+ * refused.
+ */
+export const caretLeft = (edytor, result) => {
+    const { startText, yStart } = edytor.selection.textRange();
+    return result.status !== 'refused' && startText ? { text: startText, offset: yStart } : null;
 };
 /**
  * The selected blocks as clicked, in document order: a grip-selected list is
@@ -23,14 +29,18 @@ export const getSelectedBlocksInDocumentOrder = (edytor) => [...edytor.selection
  * the caret's block. Menus, the toolbar, kind commands and Tab read it.
  */
 export const getSelectionBlocks = (edytor) => {
-    const { selectedBlocks, state } = edytor.selection;
+    const { selectedBlocks, projection } = edytor.selection;
     if (selectedBlocks.size)
         return selectedMembers(edytor);
-    if (state.isCollapsed)
-        return state.startBlock ? [state.startBlock] : [];
-    const edges = [state.startBlock, state.endBlock];
-    const enters = (block) => block.isContainer && edges.some((edge) => edge && isInside(edge, block));
-    return state.blocks.filter((block) => !hidden(block) && !enters(block));
+    const { startText, endText } = edytor.selection.textRange(projection);
+    const [start, end] = [startText?.parent, endText?.parent];
+    if (projection.isCollapsed)
+        return start ? [start] : [];
+    const enters = (block) => block.isContainer && [start, end].some((edge) => edge?.isChildOf(block));
+    return projection.blocks.flatMap((id) => {
+        const block = edytor.idToBlock.get(id);
+        return block && !hidden(block) && !enters(block) ? [block] : [];
+    });
 };
 /**
  * The blocks <kbd>Mod</kbd>+<kbd>Enter</kbd> modifies (Notion): the
@@ -45,13 +55,6 @@ export const flipToggles = (blocks) => {
         if (node?.tagName === 'DETAILS')
             node.open = !node.open;
 };
-/** Whether `block` is a descendant of `ancestor`. */
-const isInside = (block, ancestor) => {
-    for (let parent = block.parent; parent; parent = parent.parent)
-        if (parent === ancestor)
-            return true;
-    return false;
-};
 /**
  * `blocks` with every layout they cover whole standing for it (as
  * Notion): a set holding every shown block of every column of a layout (each
@@ -170,28 +173,11 @@ export const movable = (blocks) => {
  */
 export const selectMoved = (edytor, moved, before) => {
     const held = [...before];
-    const kept = held.filter((block) => moved.some((root) => isInside(block, root)));
+    const kept = held.filter((block) => moved.some((root) => block.isChildOf(root)));
     // A layout moved for the blocks covering it whole stays selected as those blocks.
     const lifted = new Set(liftLayouts(kept));
     const roots = moved.filter((block) => !lifted.has(block) || held.includes(block));
-    edytor.selection.selectBlocks(...roots, ...kept);
-};
-/**
- * Run a block move that never hides a block the user saw (Notion): a closed
- * toggle a moved block lands in opens, and so does a closed toggle that
- * adopts blocks (Shift+Tab takes the blocks after it). `open` is view state.
- * Every relative move (`edytor.moveBlocks`) and every block move
- * command (`revealed`) share it. Answers the moved blocks.
- */
-export const revealing = (blocks, move) => {
-    const had = new Map(blocks.map((block) => [block, block.children.length]));
-    const moved = move();
-    for (const block of moved) {
-        reveal(block);
-        if (block.children.length > (had.get(block) ?? Infinity))
-            open(block);
-    }
-    return moved;
+    edytor.selection.select(blockSelection([...roots, ...kept].map((block) => block.id)));
 };
 /** Open `block` when it is a closed toggle (`open` is view state). */
 const open = (block) => {
@@ -199,33 +185,41 @@ const open = (block) => {
         block.node.open = true;
 };
 /**
- * Open every closed toggle `block` sits in, so it shows: a moved block
- * ({@link revealing}), find's current match (`plugins/find`).
+ * Open every closed toggle `block` sits in, so it shows (Notion: a move never
+ * hides a block the user saw): every block a view's operation moved (the
+ * dispatcher's write; a remote peer's move, an undo or a redo opens nothing:
+ * `open` is this view's state), find's current match (`plugins/find`).
  */
 export const reveal = (block) => {
     for (let parent = block.parent; parent; parent = parent.parent)
         open(parent);
 };
-/**
- * A block's move command (`nestBlock`, `unNestBlock`, `moveBlock`,
- * `moveBlocks`) that reveals what it moved (`revealing`), as the keys and
- * `edytor.moveBlocks` do. A remote peer's move, an undo or a redo
- * opens nothing: `open` is this view's state, and history restores it as
- * it was.
- */
-export const revealed = (command) => function (...args) {
-    let out;
-    const moving = args[0]?.blocks ?? [this];
-    revealing(moving, () => [(out = command.apply(this, args)) ?? []].flat());
-    return out;
-};
-export const replaceSelectionWithCollapsedTarget = (edytor, state = getSelectionReplacementState(edytor)) => {
-    const { startText, yStart } = state;
-    if (!startText || state.isCollapsed) {
+export const replaceSelectionWithCollapsedTarget = (edytor, range) => {
+    const { startText, yStart } = range ?? edytor.selection.textRange();
+    if (!startText || (range ?? edytor.selection.projection).isCollapsed) {
         return startText && { text: startText, offset: yStart };
     }
-    const [text, offset] = edytor.deleteContentWithinSelection({ replace: true, selection: state }) ?? [];
-    return text ? { text, offset: offset } : null;
+    return deleteRange(edytor, true, range);
+};
+/**
+ * The document's range deletion of the selected range (or `selection`,
+ * `del.range.*`; `replace`: the deletion half of a replacement, the head
+ * kept), which selects its caret. Answers that caret; refused by the
+ * document, the range's start; by the view or a hook, none.
+ */
+const deleteRange = (edytor, replace, selection) => {
+    const { startText, endText, yStart, yEnd } = selection ?? edytor.selection.textRange();
+    if (!startText || !endText)
+        return null;
+    const at = (text, offset) => ({
+        block: text.parent.id,
+        offset: text.segStart + offset
+    });
+    const [from, to] = [at(startText, yStart), at(endText, yEnd)];
+    const result = replace ? edytor.replaceRange(from, to) : edytor.deleteRange(from, to);
+    if (result.status === 'refused')
+        return result.reason === 'view' ? null : { text: startText, offset: yStart };
+    return caretLeft(edytor, result);
 };
 /**
  * The first or last text `block` shows: its own line's (a block selection is
@@ -235,7 +229,7 @@ export const replaceSelectionWithCollapsedTarget = (edytor, state = getSelection
  * document order); none for a void that shows nothing (a divider) or a
  * closed toggle's hidden body. A line created in the same change counts (it
  * is displayed once it mounts), as for `caretBeside`. Ranges over blocks
- * (`setAtBlockRange`, leaving a block selection), the block-selection keys
+ * (`selectLines`: Mod+A, a triple click), the block-selection keys
  * and Escape read it.
  */
 export const shownText = (block, edge, whole = false) => {
@@ -346,8 +340,8 @@ export const deleteSelectedBlocks = (edytor, blocks = selectedMembers(edytor)) =
             ...beside(blocks[0], 'blockBefore', blocks),
             ...beside(blocks.at(-1), 'blockAfter', blocks)
         ];
-    const deleted = edytor.dispatcher.caret(at?.text, at?.offset ?? 0, () => edytor.deleteBlocks({ blocks }));
-    if (!deleted)
+    const deleted = edytor.dispatcher.caret(at?.text, at?.offset ?? 0, () => edytor.deleteBlocks(blocks.map((block) => block.id)));
+    if (deleted?.status !== 'applied')
         return null;
     edytor.announcer.deleted(what);
     if (at)
@@ -362,7 +356,7 @@ export const deleteSelectedBlocks = (edytor, blocks = selectedMembers(edytor)) =
     if (text)
         edytor.dispatcher.caret(text, 0);
     else if (survivor)
-        edytor.selection.selectBlocks(survivor);
+        edytor.selection.select(blockSelection([survivor.id]));
     return text ?? null;
 };
 /**
@@ -383,9 +377,9 @@ const beside = (from, step, blocks) => {
 };
 /** Delete the selected range (or `selection`) as Backspace does (`del.range.*`), then its caret. */
 export const deleteSelectedRange = (edytor, payload = {}) => {
-    const [text, offset] = edytor.deleteContentWithinSelection(payload) ?? [];
-    if (text)
-        edytor.selection.setAtTextOffset(text, offset);
+    const at = deleteRange(edytor, false, payload.selection);
+    if (at)
+        edytor.selection.selectText(at.text, at.offset);
 };
 /**
  * Typing or a composition over a block selection (`flow.slot`),
@@ -398,14 +392,11 @@ const replaceSelectedBlocksWithEmptyBlock = (edytor) => {
     const parent = selected[0]?.parent;
     if (!parent || keepsSelectedBlocks(edytor, selected))
         return null;
-    const [text, offset] = edytor.insertFlow({
-        flow: { lines: [{ id: id('b'), type: edytor.defaultChild(parent) }] },
-        target: { replace: selected.map((block) => block.id) }
-    });
-    if (!text)
+    const at = caretLeft(edytor, edytor.insertFlow({ replace: selected.map((block) => block.id) }, { lines: [{ id: id('b'), type: edytor.defaultChild(parent) }] }));
+    if (!at)
         return null;
-    edytor.selection.selectBlocks();
-    return { text, offset };
+    edytor.selection.select(noSelection);
+    return at;
 };
 /** Where typed text lands: over selected blocks, one empty block in their place; else the range replaced. */
 export const replaceSelectionForInsertion = (edytor, state) => edytor.selection.selectedBlocks.size

package/dist/selection/selection.svelte.d.ts

@@ -1,9 +1,9 @@
 import type { Edytor } from '../edytor.svelte.js';
 import { Text } from '../text/text.svelte.js';
-import { Block } from '../block/block.svelte.js';
+import type { Block } from '../block/block.svelte.js';
 import { SvelteSet } from 'svelte/reactivity';
 import { InlineBlock } from '../block/inlineBlock.svelte.js';
-import type { EdgeSide, PendingMarks } from '../session/editing/text.js';
+import type { PendingMarks } from '../session/editing/text.js';
 import type { Anchor } from '../crdt/text/model.js';
 import { type AtomSide, type Marks, type SelectionProjection, type SelectionValue } from '../session/selection.js';
 /**
@@ -29,29 +29,6 @@ export type Caret = {
     block: Block;
     offset: number;
 };
-/**
- * The public read-only view: the projection's endpoints as wrappers
- * (`startText`/`yStart`… offsets inside text segments). Projection facts —
- * `content`, `marks`, the `isAt…`/`is…Spanning` flags, `islandRoot`,
- * `voidRoot` — are read from `selection.projection`.
- */
-export type SelectionState = {
-    yStart: number;
-    yEnd: number;
-    isCollapsed: boolean;
-    isReversed: boolean;
-    startText: Text | null;
-    endText: Text | null;
-    startBlock: Block | null;
-    endBlock: Block | null;
-    texts: Text[];
-    blocks: Block[];
-    isBlockSpanning: boolean;
-    /** Focus is in a void block's own `input`/`textarea`. */
-    isVoidEditableElement: boolean;
-    /** The mark-edge side of a DOM-derived caret (`marksForInsertion`). */
-    edge?: EdgeSide;
-};
 /**
  * Whether a DOM selection runs backward (focus before anchor in document
  * order), comparing boundary points — a focus on an ancestor element of the
@@ -81,9 +58,6 @@ export declare class EdytorSelection {
      */
     get selectedMembers(): Block[];
     selectedInlineBlock: SvelteSet<InlineBlock>;
-    private selectionDocument;
-    private shouldKeepModelSelectionForNextTextInsertion;
-    private modelSelectionPreservationBlock;
     /**
      * The selection: a value — none, a text range of two anchors,
      * one inline atom, or a set of block ids. Read-only: only `select()`
@@ -93,12 +67,6 @@ export declare class EdytorSelection {
     constructor(edytor: Edytor, edytorOnSelectionChange?: ((selection: EdytorSelection) => void) | undefined);
     /** The projection of the current value at the current document version. */
     get projection(): SelectionProjection;
-    /**
-     * The read-only wrapper view of the projection: every field is a
-     * projection of (value, document version); `edge` comes from the Surface
-     * for the value it was observed with.
-     */
-    get state(): SelectionState;
     /**
      * Replace the selection with `next` (none, a text range of two anchors,
      * one inline atom, or a set of block ids), keeping the selected and
@@ -134,19 +102,13 @@ export declare class EdytorSelection {
      * selection is computed against the host. Reactive.
      */
     get dragging(): boolean;
-    private getBlockByPath;
     /**
-     * `selectedInlineBlock` and `inlineBlockDeletionTarget` are one
-     * selection — every mutation must go through these two helpers so the
-     * armed Backspace/delete target can never outlive the cleared set
-     * (a stale target feeds `deleteSelectedInlineBlock` and makes
-     * `restoreSelectionAfterRepair` bail forever).
+     * Leave an atom selection: a caret at the atom's start (the end of the
+     * text before it), else none. `selectedInlineBlock` and
+     * `inlineBlockDeletionTarget` follow the value (`commit`).
      */
     clearInlineBlockSelection: () => void;
     selectInlineBlock: (inlineBlock: InlineBlock, from?: AtomSide) => void;
-    private isStateBlockContentRange;
-    private getNonNativeEditableIslandBlock;
-    private normalizeTextRangePoints;
     /**
      * Anchor a text position into the BACKING text that owns the atom at
      * that display position — the v14 replacement for
@@ -194,34 +156,4 @@ export declare class EdytorSelection {
     }) => Block | null;
     /** The text's computed direction (a Surface fact): arrow and word keys are visual. */
     rtl: (text: Text) => boolean;
-    private setStateFromBlockContentRange;
-    /**
-     * Select a set of whole blocks. With no block, leave block selection:
-     * the value becomes the text range the set showed, from its first shown
-     * line to its last (a list's items; a divider at an edge stays covered
-     * unless no line lies beyond it, `rangeEdge`), and stays as it is
-     * when no line is shown anywhere.
-     */
-    selectBlocks: (...blocks: Block[]) => void;
-    addBlockToSelection: (block: Block) => void;
-    removeBlockFromSelection: (block: Block) => void;
-    /**
-     * Select a caret at `offset` of `text`; the projector displays it after
-     * the flush. The value is minted now: a text that dies before the
-     * display is followed through its atoms, else the seam of its block.
-     */
-    setAtTextOffset: (text: Text | undefined | null, textOffset?: number | null | undefined) => void;
-    /** Select the whole content from `startText` to `endText` (the code block's select-all). */
-    setAtTextsRange: (startText: Text, endText: Text) => void;
-    /** Select a text range; the projector displays it after the flush. */
-    setAtRange: (startText: Text | undefined | null, startOffset: number | undefined | null, endText: Text | undefined | null, endOffset: number | undefined | null, options?: {
-        isReversed?: boolean;
-    }) => void;
-    /**
-     * Select `block`'s content (the whole of it by default): from its first
-     * shown line to its last (a list's items, a code block's lines), the
-     * offsets in those lines. A block that shows no line (a divider) keeps the
-     * current value. Displayed after the flush.
-     */
-    setAtBlockRange: (block?: Block | null, startOffset?: number, endOffset?: number) => void;
 }