edytor 5.0.0 → 6.0.0

package/dist/crdt/providers/websocket.js

@@ -56,7 +56,7 @@ import { messagePermissionDenied, messageAccess, messageReadOnly, READ_ONLY_DENI
 import { bindSync } from '../protocols/sync.js';
 import { readCommentsMessage, writeCommentsSubscribe } from '../protocols/comments.js';
 import { frame } from '../protocols/envelope.js';
-import { assertRoomId, beginDestroy, bindRoomProtocol, tabs, chunkFrame, CLOSE, createChunkReader, emitFailed, initLifecycle, isRefusal, LOCAL_PRESENCE_LOSS, markSynced, messageAuth, messageChunk, messageComments, messageSaved, messageSync, MAX_FRAME_BYTES, SyncRefusedError } from './room.js';
+import { assertRoomId, beginDestroy, bindRoomProtocol, tabs, chunkFrame, CLOSE, createChunkReader, emitFailed, fault, initLifecycle, isRefusal, unknownType, LOCAL_PRESENCE_LOSS, markSynced, messageAuth, messageChunk, messageComments, messageSaved, messageSync, MAX_FRAME_BYTES, SyncRefusedError } from './room.js';
 import { asEngineDoc } from '../structs.js';
 import { ATTRIBUTION_ROOT } from '../schema.js';
 import { ATTRIBUTION_ORIGIN, writerOf } from '../attribution/attribution.js';
@@ -135,10 +135,7 @@ export const bindWebsocketProvider = (Y) => {
                     authType !== messageAccess) {
                     // An auth type we do not speak inside a valid v14 envelope is
                     // protocol skew — reported, never dropped silently.
-                    provider.emit('message-error', [
-                        new Error(`Unknown auth message type ${authType}`),
-                        provider
-                    ]);
+                    unknownType(provider, 'auth', authType);
                 }
             }
         },
@@ -459,7 +456,7 @@ export const bindWebsocketProvider = (Y) => {
                     room.readMessage(provider, new Uint8Array(event.data), true, (buf) => sendOn(provider, websocket, buf));
                 }
                 catch (error) {
-                    provider.emit('message-error', [error, provider]);
+                    fault(provider, error);
                 }
             };
             websocket.onerror = (event) => {
@@ -526,8 +523,8 @@ export const bindWebsocketProvider = (Y) => {
         /** Closes the current dial if it has not opened in time. */
         _connectTimer;
         _checkInterval;
-        _updateHandler;
-        _awarenessUpdateHandler;
+        /** @internal Removes the document and presence listeners (`room.listen`). */
+        _unlisten;
         constructor(serverUrl, roomname, doc, { connect = true, awareness = new Awareness(doc), params = {}, WebSocketPolyfill = WebSocket, resyncInterval = 0, maxBackoffTime = 2500, connectTimeout = defaultConnectTimeout, disableBc = false, maxFrameBytes = MAX_FRAME_BYTES } = {}) {
             assertRoomId(roomname);
             super();
@@ -548,14 +545,13 @@ export const bindWebsocketProvider = (Y) => {
             if (resyncInterval > 0) {
                 this._resync = setInterval(() => send(this, room.step1(this)), resyncInterval);
             }
-            this._bcSubscriber = room.bcSubscriber(this);
             providers.add(this);
             // Local doc updates go to the room; another tab's go to the server
             // only (`broadcastUpdate` quarantines a read-only document). A
             // socket the room made read-only gets this document's own edits
             // alone (each is denied): what a tab or a store delivered, and the
             // actor records, would draw denials nobody made.
-            this._updateHandler = (update, origin, _doc, transaction) => {
+            const onUpdate = (update, origin, _doc, transaction) => {
                 if (origin === this)
                     return;
                 const heard = origin === this._fromTab;
@@ -573,9 +569,7 @@ export const bindWebsocketProvider = (Y) => {
             };
             this._writes = new OwnWrites(doc, (unsaved) => this.emit('saved', [{ saved: unsaved === 0, unsaved }, this]));
             this._writes.trackDocument();
-            this.doc.on('update', this._updateHandler);
-            this._awarenessUpdateHandler = room.awarenessUpdateHandler(this);
-            awareness.on('update', this._awarenessUpdateHandler);
+            this._unlisten = room.listen(this, onUpdate);
             this._checkInterval = setInterval(() => {
                 if (!this.wsconnected)
                     return;
@@ -651,8 +645,7 @@ export const bindWebsocketProvider = (Y) => {
             clearInterval(this._checkInterval);
             providers.delete(this);
             this.disconnect();
-            this.awareness.off('update', this._awarenessUpdateHandler);
-            this.doc.off('update', this._updateHandler);
+            this._unlisten();
             super.destroy();
         }
         disconnect() {

package/dist/crdt/rangeDelete.d.ts

@@ -1,48 +1,8 @@
 /**
- * Range deletion between two positions — one prepared document operation
- * whose merge is the document's `canMerge`. The rules are the
- * `del.range.*` rows of `docs/editor-delete-contract.md`:
- *
- * - the head keeps `[0, start)`, the tail keeps `[end, len)`, and every
- *   block strictly between them in document order dies;
- * - the head dies iff its prefix is empty (never for a replacement,
- *   `del.range.replace`, nor when nothing else would be left to hold the
- *   caret, `del.range.whole-doc`: the head is kept, emptied, with its id,
- *   type and data, so peers deleting the same range keep the same block)
- *   and the tail then keeps its id; the tail dies iff
- *   its suffix is empty; otherwise the tail's suffix merges into the head
- *   when `canMerge(tail, head)` allows it (`del.range.island-seal`) — an end
- *   at the tail's start included: the seam between them is deleted;
- * - what follows the range end survives: the dying tail's children and the
- *   later siblings inside every container the range dies through take the
- *   topmost such container's slot, unless that would cross an island seal —
- *   then those containers stay (`del.range.outside-survives`);
- * - a container (a list: the document's `isContainer`) never dies because
- *   the range starts before it: it keeps what follows the range end, like
- *   the keys (`del.merge.container`); it dies only when it loses every
- *   child and holds no text of its own — the document's `emptiable`, the
- *   keys' rule (`del.range.empty-container`). An island that renders
- *   no content dies when it loses every child too, except a `lines` island
- *   (a code block) the range lies in: its head is then kept, emptied
- *   (`del.range.island-kept`);
- * - what a range rescues takes the kind it shows in its new slot (the
- *   document's `settle`: a paragraph rescued into a list is its item);
- * - blocks the view hides (a closed toggle's body) are not in the range:
- *   they go only with a block that goes, so a surviving head keeps its
- *   hidden children, unless it is kept only to hold the caret; a dying
- *   closed tail's body takes its place, shown (`del.range.hidden-body`);
- * - a layout the range leaves with one column dissolves, in the same plan
- *   (`layout.dissolving`);
- * - a range with an end in a table's cell keeps every cell and row: each
- *   cell it crosses loses the text it covers, nothing merges across a
- *   cell's edge, the blocks outside the table between the ends go, a
- *   table wholly between them goes whole, and the caret lands at the start
- *   (`table.range`);
- * - the plan's `at` is where the caret lands (`del.range.caret`).
+ * The types range deletion (`deleteRange`, `replaceRange`: the `del.range.*`
+ * rows, prepared in `doc/ops.ts`) reads.
  */
 import type { BlockId } from './placement/model.js';
-import type { Prepared } from './edytor-doc.js';
-import type { OpsContext } from './doc/steps.js';
 /** A position in one document version: a block and a display offset. */
 export type DocPosition = {
     block: BlockId;
@@ -56,8 +16,3 @@ export type DocPosition = {
 export type RangeView = {
     hidden?: (id: BlockId, removed?: ReadonlySet<BlockId>) => boolean;
 };
-/** `deleteRange` and `replaceRange` (the head kept), prepared. */
-export declare const rangeDeleteOps: (c: OpsContext) => {
-    deleteRange: (from: DocPosition, to: DocPosition, view?: RangeView) => Prepared;
-    replaceRange: (from: DocPosition, to: DocPosition, view?: RangeView) => Prepared;
-};

package/dist/crdt/rangeDelete.js

@@ -1,169 +1 @@
-import { ref } from './doc/plan.js';
-/** `deleteRange` and `replaceRange` (the head kept), prepared. */
-export const rangeDeleteOps = (c) => {
-    // `headSpent`: a whole-doc retry keeps the head, but what it hid goes as if it went.
-    const prepare = (keepHead, headSpent = false) => (from, to, view = {}) => {
-        // A position names shown text: a live block that renders its own content.
-        const holds = (id) => c.contentTarget(id) && c.rendersContent(id);
-        const pos = (p) => {
-            const block = ref(p.block);
-            const len = holds(block) ? c.displayLength(block) : -1;
-            return { block, offset: Math.max(0, Math.min(p.offset, len)) };
-        };
-        let [s, e] = [pos(from), pos(to)];
-        if (!holds(s.block) || !holds(e.block))
-            return c.REFUSED;
-        const { ids, at } = c.view().order;
-        if (at.get(s.block) > at.get(e.block) || (s.block === e.block && s.offset > e.offset))
-            [s, e] = [e, s];
-        const S = s.block;
-        const E = e.block;
-        if (S === E) {
-            const length = e.offset - s.offset;
-            const writes = length > 0 ? [{ op: 'deleteText', id: S, offset: s.offset, length }] : [];
-            return { ...c.plan([S], writes), at: s };
-        }
-        const parent = (id) => c.ancestorsOf(id)[0] ?? null;
-        const chain = c.ancestorsOf(E);
-        if (c.isTableCell(S) || c.isTableCell(E))
-            return inTables(s, e, view);
-        // What the view hides once `removed` go (nothing: as it is now).
-        const hiddenOnce = (removed) => {
-            const set = new Set(removed);
-            return (id) => !!view.hidden?.(id, set);
-        };
-        const headDies = !keepHead && s.offset === 0;
-        // What the view hides is not in the range: it goes only with a block that goes,
-        // a dying head's body included.
-        const hidden = hiddenOnce(headDies || headSpent ? [S] : []);
-        const between = ids.slice(at.get(S) + 1, at.get(E)).filter((id) => !hidden(id));
-        const lenE = c.displayLength(E);
-        const tailDies = e.offset === lenE;
-        const merges = !headDies && !tailDies && c.canMerge(E, S);
-        const tailGone = tailDies || merges;
-        // E's ancestors the range starts before die unless the rescue would cross an island.
-        // A container (a list) is not one: it dies only when the range empties it, and
-        // keeps its later items like the keys do (`del.merge.container`).
-        const partial = chain.filter((a) => (a === (headDies ? S : null) || between.includes(a)) && !c.isContainer(a));
-        const top = partial.at(-1);
-        const sealed = top !== undefined && chain.slice(0, chain.indexOf(top) + 1).some(c.isIsland);
-        const spared = new Set(sealed ? chain : []);
-        const doomed = new Set(between.filter((id) => !spared.has(id) && !chain.includes(id)));
-        if (!sealed)
-            partial.forEach((a) => doomed.add(a));
-        if (headDies && !spared.has(S))
-            doomed.add(S);
-        if (tailDies)
-            doomed.add(E);
-        // Rescue what follows the range end right after the topmost dying container's slot
-        // (after, not at it: a concurrent delete of S revives a merged E above them).
-        const home = sealed || top === undefined ? (tailGone ? E : undefined) : top;
-        const rescued = home === undefined ? [] : tailGone ? c.childrenIds(E) : [E];
-        for (let cur = E; home !== undefined && cur !== home; cur = parent(cur)) {
-            const sibs = c.childrenIds(parent(cur));
-            rescued.push(...sibs.slice(sibs.indexOf(cur) + 1));
-        }
-        const dest = home === undefined || rescued.length === 0 ? null : c.positionOf(home);
-        // A container (or an island that renders nothing) losing every child dies too.
-        const gone = (id) => doomed.has(id) || (merges && id === E);
-        const dies = (id) => c.emptiable(id) || (c.isIsland(id) && !c.rendersContent(id));
-        const emptied = (id) => {
-            if (id === null || gone(id) || !dies(id) || id === dest?.parent)
-                return;
-            if (!c.childrenIds(id).every(gone))
-                return;
-            doomed.add(id);
-            emptied(parent(id));
-        };
-        [...doomed, ...(merges ? [E] : [])].forEach((id) => emptied(parent(id)));
-        // A range inside one `lines` island never removes it: the head stays, emptied
-        // (a code block's Mod+A, `del.range.island-kept`).
-        const island = c.ancestorsOf(S).find(c.isIsland);
-        const linesIsland = island !== undefined && c.isLines(island);
-        if (!keepHead && linesIsland && doomed.has(island) && chain.includes(island))
-            return prepare(true, headDies)(from, to, view);
-        const lenS = c.displayLength(S);
-        const writes = [];
-        if (!doomed.has(S) && lenS > s.offset)
-            writes.push({ op: 'deleteText', id: S, offset: s.offset, length: lenS - s.offset });
-        if (!gone(E) && e.offset > 0)
-            writes.push({ op: 'deleteText', id: E, offset: 0, length: e.offset });
-        if (dest !== null) {
-            writes.push(...c.move(rescued, dest.parent, dest.index + 1));
-            // Each shows the kind of its new slot (an island's line, a list's item leave theirs).
-            for (const id of rescued)
-                writes.push(...c.settle(parent(id), [id], dest.parent));
-        }
-        if (merges) {
-            // The whole tail merges, then its cut prefix goes: E's own text is never written.
-            writes.push({ op: 'mergeBlocks', from: E, into: S, at: s.offset, length: lenE });
-            if (e.offset > 0)
-                writes.push({ op: 'deleteText', id: S, offset: s.offset, length: e.offset });
-        }
-        const kept = [...rescued, ...(merges ? [E] : [])];
-        for (const id of doomed)
-            if (!doomed.has(parent(id)))
-                writes.push(c.remove(id, kept));
-        // A layout the range leaves with one column dissolves (`layout.dissolving`).
-        writes.push(...c.dissolving(new Set([...doomed, ...(merges ? [E] : [])]), rescued, writes));
-        const caret = (() => {
-            if (!doomed.has(S))
-                return s;
-            if (!gone(E))
-                return { block: E, offset: 0 };
-            const survives = (id) => id === null || rescued.includes(id) || (!gone(id) && survives(parent(id)));
-            // Shown once the plan runs: a dying closed tail's rescued body is.
-            const hiddenAfter = hiddenOnce([...doomed, ...(merges ? [E] : [])]);
-            const shown = (id) => survives(id) && holds(id) && !hiddenAfter(id);
-            // Before the tail: blocks a sealed rescue spared between S and E count too.
-            const prev = ids.slice(0, at.get(E)).findLast(shown);
-            if (prev !== undefined)
-                return { block: prev, offset: c.displayLength(prev) };
-            const next = ids.slice(at.get(E) + 1).find(shown);
-            return next === undefined ? null : { block: next, offset: 0 };
-        })();
-        // Nothing else left to hold the caret: the head stays, emptied (whole-doc).
-        if (caret === null)
-            return prepare(true, headDies)(from, to, view);
-        return { ...c.plan([caret.block], writes), at: caret };
-    };
-    /**
-     * `table.range`: a range with an end in a cell. Every cell it crosses
-     * loses the text it covers and stays, with its row; the ends keep what
-     * lies outside the range, merging nothing; any other block between the
-     * ends goes (a table wholly between them whole), but the ancestors of
-     * the end, which stay and lose their text (the range covers it: they
-     * come after the start in reading order); the caret lands at the start.
-     */
-    const inTables = (s, e, view) => {
-        const { ids, at } = c.view().order;
-        const [S, E] = [s.block, e.block];
-        const kept = new Set(c.ancestorsOf(E));
-        const between = ids.slice(at.get(S) + 1, at.get(E)).filter((id) => !view.hidden?.(id));
-        const writes = [];
-        const lenS = c.displayLength(S);
-        if (lenS > s.offset)
-            writes.push({ op: 'deleteText', id: S, offset: s.offset, length: lenS - s.offset });
-        const [tableS, tableE] = [c.tableOf(S), c.tableOf(E)];
-        const doomed = new Set();
-        for (const id of between) {
-            const table = c.tableOf(id);
-            if (kept.has(id) || (table !== null && (table === tableS || table === tableE))) {
-                const len = c.isTableCell(id) || kept.has(id) ? c.displayLength(id) : 0;
-                if (len > 0)
-                    writes.push({ op: 'deleteText', id, offset: 0, length: len });
-            }
-            else
-                doomed.add(id);
-        }
-        if (e.offset > 0)
-            writes.push({ op: 'deleteText', id: E, offset: 0, length: e.offset });
-        const parentOf = (id) => c.ancestorsOf(id)[0] ?? null;
-        const roots = [...doomed].filter((id) => !doomed.has(parentOf(id)));
-        for (const id of roots)
-            writes.push(c.remove(id, []));
-        writes.push(...c.dissolving(new Set(roots), [], writes));
-        return { ...c.plan([S], writes), at: s };
-    };
-    return { deleteRange: prepare(false), replaceRange: prepare(true) };
-};
+export {};

package/dist/crdt/text/index/build.d.ts

@@ -0,0 +1,125 @@
+/**
+ * The per-document index (`indexOf`) as ONE closure: its state, then its
+ * parts — the claim graph, the stream table and each block's claims, the
+ * layout and table rules, placements and the children index (with THE
+ * shown-kind rule, `typeOf`), block records, the run cache, the fold and the
+ * change report — each reading the state and the parts before it as closure
+ * variables, then the view (`RunView`) over them. `../runs.ts` declares the
+ * index's types and contracts. The self-checks (`indexChecks`) read the
+ * maintained facts through {@link IndexFacts} and rebuild their own.
+ */
+import type { EngineDoc, EngineNode, EngineTransaction } from '../../engine-api.js';
+import { type BlockId, type BlockRec, type ChildSlot, type DisplayOwnership, type ResolvedPlacement } from '../../placement/model.js';
+import { type IdSetLike } from '../../structs.js';
+import { type LiveRow, type RowItem } from '../rows.js';
+import type { ContentRun, RunView } from '../runs.js';
+import { type Cached } from './shared.js';
+import { type Claim, type Owner, type Stream } from '../model.js';
+import { type Edge, type SlotRef } from '../../placement/resolve.js';
+export type TextEdit = {
+    item: RowItem;
+    len: number;
+    del: boolean;
+};
+export type TextEdits = {
+    edits: TextEdit[];
+    scan: boolean;
+    opaque: boolean;
+};
+/** One fold's effects: invalidated blocks, rescanned texts, rebuilt facets. */
+export type FoldCtx = {
+    invalidated: Set<BlockId>;
+    /** Per home block: its text's edits, whether it rescans, whether every reader re-reads. */
+    texts: Map<BlockId, {
+        edits: TextEdit[];
+        scan: boolean;
+        opaque: boolean;
+        seen: Set<TextEdits>;
+    }>;
+    /** The blocks whose entry or nonce changed: their delimiters are re-decided. */
+    named: Set<BlockId>;
+    table: boolean;
+    /** The winning parents, before and after, of the blocks the fold touched. */
+    parents: Set<BlockId>;
+};
+/** A slot in a children index: its display parent, rank and the island it displays out of. */
+export type Slot = {
+    parent: BlockId | null;
+    rank: string;
+    reset?: BlockId;
+};
+/** Each row's segments at its last placement: segment 0's block, then each cut's key and block. */
+export type Placed = {
+    head: BlockId | null;
+    keys: string[];
+    blocks: (BlockId | null)[];
+};
+/** The tree the change report last published. */
+export type Published = {
+    nodes: Map<BlockId, {
+        parent: BlockId | null;
+        index: number;
+        type: string;
+        data: unknown;
+        runs: readonly ContentRun[];
+        key?: string;
+    }>;
+    order: Map<BlockId | null, readonly BlockId[]>;
+    /** The children index version it was taken at. */
+    kids: number;
+};
+/** A transaction as the fold reads it. */
+export type Tx = {
+    insertSet?: IdSetLike;
+    deleteSet?: IdSetLike;
+    changed?: EngineTransaction['changed'];
+    /** The visibility changes hold records made, in order (fork patch YP20). */
+    holds?: number[];
+    /** The units whose mover changed, in order (fork patch YP22). */
+    moves?: number[];
+};
+/** The index's self-checks (`indexChecks`), run after each fold and each report. */
+export type SelfChecks = {
+    check: () => void;
+    checkPublished: (pub: Published) => void;
+};
+/**
+ * What the self-checks read of one index: the facts it maintains
+ * incrementally (compared with their rebuild from the replicated state) and
+ * the reads they compare through.
+ */
+export type IndexFacts = {
+    doc: EngineDoc;
+    registry: EngineNode;
+    blocks: ReadonlyMap<BlockId, BlockRec>;
+    displaysMap: ReadonlyMap<BlockId, ReadonlySet<BlockId>>;
+    rows: ReadonlyMap<BlockId, LiveRow>;
+    streamIx: ReadonlyMap<BlockId, unknown>;
+    delim: ReadonlyMap<BlockId, string>;
+    placementsMap: ReadonlyMap<BlockId, ResolvedPlacement>;
+    slotsByBlock: ReadonlyMap<BlockId, SlotRef[]>;
+    edges: ReadonlyMap<BlockId, Edge | null>;
+    rejected: ReadonlySet<BlockId>;
+    kids0: Map<BlockId | null, ChildSlot[]>;
+    kidsMap: Map<BlockId | null, ChildSlot[]>;
+    slots: ReadonlyMap<BlockId, Slot>;
+    dissolved: ReadonlySet<BlockId>;
+    following: ReadonlySet<BlockId>;
+    cache: ReadonlyMap<BlockId, Cached>;
+    dirty: ReadonlySet<BlockId>;
+    ownShim: DisplayOwnership;
+    own0: DisplayOwnership;
+    ownerOf: (b: BlockId) => Owner;
+    streamOf: (b: BlockId) => Stream | undefined;
+    sameClaims: (x: readonly Claim[], y: readonly Claim[]) => boolean;
+    dissolve: (kids: Map<BlockId | null, ChildSlot[]>) => Set<BlockId>;
+    noteFollowing: (id: BlockId) => void;
+    ensurePlacements: () => void;
+    computeFresh: (b: BlockId) => {
+        fresh: readonly ContentRun[];
+    };
+    unfolded: () => boolean;
+    reachable: (prev?: Published['nodes']) => Published;
+};
+/** The doc's index — built on first use, torn down when the doc is destroyed. */
+export declare const indexOf: (doc: EngineDoc) => RunView;