edytor 1.0.0-rc.3 → 2.0.0

package/dist/text/text.svelte.js

@@ -1,16 +1,13 @@
 import {} from '../utils/json.js';
-import { Block } from '../block/block.svelte.js';
-import { batch, deleteText, removeMarksFromText, getMarksAtRange, insertText, markText, setText, splitText } from './text.utils.js';
-import { deltaToJson, runsToDeltas } from './deltas.js';
-/** A write through the block's model that the document did not refuse. */
-const accepted = (r) => r !== undefined && r.status !== 'refused';
+import { segmentJSON } from '../session/handles.js';
 /**
- * An id-only text handle: the `ordinal`-th text segment
- * of block `blockId` — no identity across commits beyond that position.
- * Getters read the document index; mutators write through the block's model.
- * `node` is the element that renders the segment (a Surface fact). A
- * reactive reader of a getter depends on the block's cell, so it re-runs
- * when a commit changes the block's content.
+ * An id-only, read-only text handle: the `ordinal`-th text segment of block
+ * `blockId` — no identity across commits beyond that position. Getters read
+ * the document index; writes are the view's operations in block offsets
+ * (`edytor.insertText(text.parent.id, text.segStart + offset, …)`). `node`
+ * is the element that renders the segment (a Surface fact). A reactive
+ * reader of a getter depends on the block's cell, so it re-runs when a
+ * commit changes the block's content.
  */
 export class Text {
     readonly = false;
@@ -46,7 +43,7 @@ export class Text {
         return this.#at.index;
     }
     get value() {
-        return deltaToJson(runsToDeltas(this.#at.part?.items ?? [])[0]);
+        return segmentJSON(this.#at.part?.items ?? []);
     }
     /** The segment's text. */
     get stringContent() {
@@ -80,33 +77,26 @@ export class Text {
             return;
         this.edytor.cells?.remount(this.parent.id);
     };
-    // ── segment writes ───────────────────────────────────────────────────
-    //
-    // `insertAt`/`deleteAt`/`formatAt` are the offset-based primitives the
-    // operation layer (`text.utils`), event handlers and plugins call. Offsets
-    // are SEGMENT-LOCAL display atoms (UTF-16 units); `segStart` maps them into
-    // the block's display space (read from the index, so a write after another
-    // in the same transaction lands right).
-    // They write raw (no hooks, no undo policy of their own): the commands
-    // that call them passed the dispatcher's admission, and a call a readonly
-    // view or a read-only document would refuse writes nothing.
-    /** Insert `text` (optionally marked) at segment-local `offset`. @internal */
-    insertAt = (offset, text, marks) => this.edytor.dispatcher.permits() &&
-        accepted(this.parent.model?.insertText(this.segStart + offset, text, marks ?? undefined));
-    /** Delete `length` atoms at segment-local `offset`. @internal */
-    deleteAt = (offset, length) => this.edytor.dispatcher.permits() &&
-        accepted(this.parent.model?.deleteText(this.segStart + offset, length));
-    /** Multi-mark format over `[offset, offset+length)` — `null` values remove the mark. @internal */
-    formatAt = (offset, length, attributes) => this.edytor.dispatcher.permits() &&
-        accepted(this.parent.model?.format(this.segStart + offset, length, attributes));
-    batch = batch.bind(this);
-    getMarksAtRange = getMarksAtRange.bind(this);
-    insertText = this.batch('insertText', insertText.bind(this));
-    deleteText = this.batch('deleteText', deleteText.bind(this));
-    splitText = this.batch('splitText', splitText.bind(this));
-    setText = this.batch('setText', setText.bind(this));
-    markText = this.batch('markText', markText.bind(this));
-    removeMarksFromText = this.batch('removeMarksFromText', removeMarksFromText.bind(this));
+    /**
+     * The runs of `[start, end)` (segment offsets), each with a copy of its
+     * marks: the MODEL runs (`value`), never the rendered ones — a kind's
+     * `transformText` decorations (code tokens) are no marks of the text.
+     */
+    getMarksAtRange = (start, end) => {
+        const result = [];
+        let offset = 0;
+        for (const { text, marks } of this.value) {
+            const until = offset + text.length;
+            // From the run holding `start`, every run starting before `end`.
+            if (result.length ? offset < end : start >= offset && start < until)
+                result.push({
+                    text: text.slice(Math.max(0, start - offset), end - offset),
+                    marks: { ...marks }
+                });
+            offset = until;
+        }
+        return result;
+    };
     /** @internal */
     attach = (node) => {
         this.node = node;
@@ -114,19 +104,13 @@ export class Text {
         const release = this.edytor.surface.register(node, 'text', this.parent.id);
         node.setAttribute('data-edytor-id', `${this.id}`);
         node.setAttribute('data-edytor-text', `true`);
-        let pluginDestroy = this.edytor.plugins.reduce((acc, plugin) => {
+        const pluginDestroy = this.edytor.plugins.flatMap((plugin) => {
             const action = plugin.onTextAttached?.({ node, text: this });
-            if (typeof action === 'function')
-                acc.push(action);
-            return acc;
-        }, []);
-        let insideVoid = this.parent.definition.void;
-        for (let block = this.parent; block instanceof Block; block = block.parent) {
-            if (block.definition.void) {
-                insideVoid = true;
-                break;
-            }
-        }
+            return typeof action === 'function' ? [action] : [];
+        });
+        let insideVoid = false;
+        for (let block = this.parent; block && !insideVoid; block = block.parent)
+            insideVoid = !!block.definition.void;
         if (insideVoid) {
             node.setAttribute('contenteditable', 'true');
             node.style.outline = 'none';

package/dist/text/wordBoundary.d.ts

@@ -1,2 +1,21 @@
+/**
+ * One semantic rule for grapheme and word boundaries, shared by caret jumps
+ * (session/navigation.ts) and deletion (beforeInputDeleteCommands.ts): a
+ * character at a caret is one grapheme (`Intl.Segmenter`);
+ * a word is a run of Unicode letters, numbers, or `_`; whitespace and
+ * punctuation are boundaries. When no word run remains in the direction,
+ * the boundary is the boundary run's far edge — a trailing `· ` is still
+ * consumed to the text end, matching platform word-delete. Offsets are
+ * UTF-16; the patterns read code points, so a surrogate pair counts as one
+ * character but keeps its two-unit width.
+ *
+ * The rule is deliberately text-local: callers decide the scope
+ * (navigation traverses across texts/blocks, word deletion clamps to the
+ * current Text).
+ */
 export declare const getPreviousWordStartOffset: (value: string, offset: number) => number;
 export declare const getNextWordEndOffset: (value: string, offset: number) => number;
+/** The start of the grapheme before `offset` (0 at the start). */
+export declare const getPreviousGraphemeStart: (value: string, offset: number) => number;
+/** The end of the grapheme after `offset` (`offset`, clamped, at the end). */
+export declare const getNextGraphemeEnd: (value: string, offset: number) => number;

package/dist/text/wordBoundary.js

@@ -1,58 +1,43 @@
 /**
- * One semantic rule for word boundaries, shared by caret word jumps
- * (session/navigation.ts) and word deletion (beforeInputDeleteCommands.ts):
+ * One semantic rule for grapheme and word boundaries, shared by caret jumps
+ * (session/navigation.ts) and deletion (beforeInputDeleteCommands.ts): a
+ * character at a caret is one grapheme (`Intl.Segmenter`);
  * a word is a run of Unicode letters, numbers, or `_`; whitespace and
  * punctuation are boundaries. When no word run remains in the direction,
  * the boundary is the boundary run's far edge — a trailing `· ` is still
  * consumed to the text end, matching platform word-delete. Offsets are
- * UTF-16 — `getCharacters` iterates code points so a surrogate pair counts
- * as one character but keeps its two-unit width.
+ * UTF-16; the patterns read code points, so a surrogate pair counts as one
+ * character but keeps its two-unit width.
  *
  * The rule is deliberately text-local: callers decide the scope
  * (navigation traverses across texts/blocks, word deletion clamps to the
  * current Text).
  */
-const getCharacters = (value) => {
-    let index = 0;
-    return Array.from(value).map((character) => {
-        const start = index;
-        index += character.length;
-        return {
-            character,
-            start,
-            end: index
-        };
-    });
-};
-const isWordCharacter = (character) => /[\p{L}\p{N}_]/u.test(character);
+/** The last word before the end, and the boundary run after it. */
+const BEFORE = /[\p{L}\p{N}_]+[^\p{L}\p{N}_]*$/u;
+/** The boundary run from the start, and the first word after it. */
+const AFTER = /^[^\p{L}\p{N}_]*[\p{L}\p{N}_]+/u;
 export const getPreviousWordStartOffset = (value, offset) => {
-    const characters = getCharacters(value).filter((character) => character.end <= offset);
-    let index = characters.length - 1;
-    while (index >= 0 && !isWordCharacter(characters[index].character)) {
-        index--;
-    }
-    if (index < 0) {
-        // Only a boundary run precedes the caret — its far edge is still
-        // a boundary (a leading punctuation/space run is consumable, not
-        // a stand-still).
-        return characters[0]?.start ?? offset;
-    }
-    while (index > 0 && isWordCharacter(characters[index - 1].character)) {
-        index--;
-    }
-    return characters[index].start;
+    const head = value.slice(0, Math.max(0, offset));
+    // Only a boundary run precedes the caret: its far edge is still a boundary.
+    return BEFORE.exec(head)?.index ?? (head ? 0 : offset);
 };
 export const getNextWordEndOffset = (value, offset) => {
-    const characters = getCharacters(value).filter((character) => character.start >= offset);
-    let index = 0;
-    while (index < characters.length && !isWordCharacter(characters[index].character)) {
-        index++;
-    }
-    if (index >= characters.length) {
-        return characters.at(-1)?.end ?? offset;
-    }
-    while (index + 1 < characters.length && isWordCharacter(characters[index + 1].character)) {
-        index++;
-    }
-    return characters[index].end;
+    const tail = value.slice(Math.max(0, offset));
+    const word = AFTER.exec(tail);
+    return word ? value.length - tail.length + word[0].length : tail ? value.length : offset;
+};
+const graphemes = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+/** The offsets where `value`'s graphemes start, then its length. */
+const graphemeEdges = (value) => [
+    ...Array.from(graphemes.segment(value), (s) => s.index),
+    value.length
+];
+const clamp = (value, offset) => Math.min(Math.max(offset, 0), value.length);
+/** The start of the grapheme before `offset` (0 at the start). */
+export const getPreviousGraphemeStart = (value, offset) => graphemeEdges(value).findLast((edge) => edge < clamp(value, offset)) ?? 0;
+/** The end of the grapheme after `offset` (`offset`, clamped, at the end). */
+export const getNextGraphemeEnd = (value, offset) => {
+    const at = clamp(value, offset);
+    return graphemeEdges(value).find((edge) => edge > at) ?? at;
 };