edytor 3.0.0 → 4.0.0

package/dist/crdt/text/deletes.js

@@ -1,362 +0,0 @@
-import { CONTENT_NODE, HORIZON_ROOT, INLINE_NODE, RESTORED_ROOT, TEXT_DELETES_ROOT } from '../schema.js';
-import { attrItems, clientsOf, dropSearchMarkers, engineOps, firstItem, keepFromCollection, nextClock, onTransaction, stepsOf, structAt, walkIdSet } from '../structs.js';
-import { clip, decode, deleteIndex, encode, FOLD_SPANS, keyOf, mergeSpans, overlaps } from './delete-index.js';
-const REACT = Symbol('edytor.text-deletes');
-const states = new WeakMap();
-export const bindDeletes = (Y) => {
-    const { idSet, each, rootSpans, members, liveRoots, shown, indexOf, leaves, holders, minus, parts, addCopies, indexRecord, indexMark, recordsIn, sync } = deleteIndex(Y);
-    const ops = engineOps(Y);
-    const attach = (doc) => {
-        let s = states.get(doc);
-        if (s !== undefined)
-            return s;
-        s = {
-            doc: doc,
-            marks: doc.get(TEXT_DELETES_ROOT),
-            restored: doc.get(RESTORED_ROOT),
-            horizon: doc.get(HORIZON_ROOT),
-            held: new Map(),
-            holds: new Map(),
-            copies: new Map(),
-            byRoot: new Map(),
-            byOrigin: new Map(),
-            copyKeys: new Set(),
-            policies: new Set(),
-            lastMark: null
-        };
-        states.set(doc, s);
-        const st = s;
-        const records = (node, fn) => {
-            for (let it = firstItem(node); it; it = it.right)
-                if (!it.deleted)
-                    for (const [r, bytes] of recordsIn(it, null))
-                        fn(r, bytes);
-        };
-        attrItems(st.restored).forEach((it) => {
-            // A record the purge deleted names nothing any more.
-            if (!it.deleted)
-                for (const [r, bytes] of recordsIn(it, null))
-                    indexRecord(st, r, bytes);
-        });
-        records(st.marks, (r, bytes) => indexMark(st, r, bytes));
-        // A deleted copy may have to be copied again by any replica (holds,
-        // duplicates, pending characters): garbage collection keeps its content.
-        const copy = (it) => it != null &&
-            (st.copies.get(it.id.client) ?? []).some((e) => overlaps(e, { k: it.id.clock, n: it.length }));
-        // (an inline atom copy keeps its attributes too)
-        keepFromCollection(doc, (it) => !copy(it) && !copy(it.parent?._item));
-        onTransaction(doc, 'afterTransaction', (tr) => react(st, tr));
-        return st;
-    };
-    // ── the writes ─────────────────────────────────────────────────────
-    /** Delete the live ids `live` (split at their edges); `into` a step, kept for its undo. */
-    const remove = (tr, live, into, keep = into !== undefined) => {
-        if (live.length === 0)
-            return;
-        each(tr, live, (it) => {
-            if (it.deleted)
-                return;
-            it.delete(tr);
-            dropSearchMarkers(it.parent);
-            if (keep)
-                it.keep = true;
-        });
-        if (into !== undefined)
-            ops.insertInto(into.deletes, idSet(live));
-    };
-    /** Restore root span `r` by copying its leaves; writes the restoration record. */
-    const restore = (s, p, tr, r) => {
-        const rows = [];
-        const copies = [];
-        for (const leaf of leaves(s, r)) {
-            const items = [];
-            each(tr, [leaf], (it) => void (it.deleted && items.push(it)));
-            for (const it of items) {
-                // A leaf has no copy: a local `redone` link left by an earlier
-                // restoration points at a copy this lineage no longer shows.
-                it.redone = null;
-                const copy = ops.redo(tr, it, new Set([it]));
-                if (copy === null)
-                    continue;
-                dropSearchMarkers(copy.parent);
-                // An inline atom comes back with its attributes: they were deleted with
-                // it and are re-created into the copy (their parent's `redone`).
-                const attrs = it.content.type?._map;
-                if (attrs !== undefined) {
-                    const kids = [...attrs.values()].filter((c) => c.deleted);
-                    for (const kid of kids)
-                        ops.redo(tr, kid, new Set(kids));
-                }
-                const e = {
-                    c: copy.id.client,
-                    k: copy.id.clock,
-                    n: it.length,
-                    rc: r.c,
-                    rk: leaf.rk + it.id.clock - leaf.k,
-                    oc: it.id.client,
-                    ok: it.id.clock
-                };
-                rows.push([e.k, e.n, e.rc, e.rk, e.oc, e.ok]);
-                copies.push(e);
-            }
-        }
-        if (rows.length === 0)
-            return;
-        // One key per record (its own id): a map entry depends on nothing, so
-        // the record integrates with the copies it names, before collection.
-        const next = nextClock(s.doc, s.doc.clientID);
-        s.restored.setAttr(`${s.doc.clientID.toString(36)}.${next.toString(36)}`, encode(rows));
-        addCopies(s, copies);
-    };
-    /**
-     * Keep root spans `roots` visible for `p`: restore what nothing shows and
-     * no mark (but those `skip` names) holds; return the rest, which `p`
-     * watches — unless this replica's own copy shows it. `done` collects what
-     * this pass restored (once per character).
-     */
-    const settle = (s, p, tr, roots, skip, done = []) => {
-        const watch = [];
-        for (const r of roots)
-            for (const part of minus(r, done).flatMap((x) => parts(s, x))) {
-                const live = shown(s, [part]);
-                if (live.length > 0) {
-                    if (live.some((l) => l.c !== s.doc.clientID))
-                        watch.push(part);
-                }
-                else if (holders(s, part, skip).length > 0)
-                    watch.push(part);
-                else {
-                    restore(s, p, tr, part);
-                    done.push(part);
-                }
-            }
-        return watch;
-    };
-    /** The undo step of this replica that wrote `mark`. */
-    const stepOf = (s, mark) => {
-        for (const p of s.policies)
-            for (const step of stepsOf(p.um().undoStack))
-                if (step.inserts.has(mark.client, mark.clock))
-                    return step;
-        return undefined;
-    };
-    /** This replica's live marks hide what the copies `copies` show, in their steps. */
-    const hold = (s, tr, copies) => {
-        for (const e of copies) {
-            const r = { c: e.rc, k: e.rk, n: e.n };
-            for (const mark of holders(s, r, (m) => m.client !== s.doc.clientID)) {
-                const roots = (s.holds.get(keyOf(mark)) ?? []).flatMap((h) => {
-                    const lo = Math.max(h.k, r.k);
-                    const hi = Math.min(h.k + h.n, r.k + r.n);
-                    return h.c === r.c && hi > lo ? [{ c: r.c, k: lo, n: hi - lo }] : [];
-                });
-                remove(tr, shown(s, roots), stepOf(s, mark));
-            }
-        }
-    };
-    /**
-     * Delete this replica's copies of characters another copy shows further
-     * left (and watch them). The leftmost copy wins: a copy sits right before
-     * the member it restored, so keeping the leftmost keeps restored text in
-     * order whichever restorations overlapped.
-     */
-    const dedupe = (s, tr, copies) => {
-        const doomed = [];
-        for (const e of copies) {
-            const ms = members(s, { c: e.rc, k: e.rk, n: e.n });
-            const live = ms.flatMap((m) => liveRoots(s, m).map((p) => clip(m, p.k, p.k + p.n)));
-            for (const o of live) {
-                if (o.c !== s.doc.clientID)
-                    continue;
-                for (let rk = o.rk; rk < o.rk + o.n; rk++) {
-                    const k = o.k + rk - o.rk;
-                    const at = indexOf(s, o.c, k);
-                    const left = live.some((m) => m !== o && m.rk <= rk && rk < m.rk + m.n && indexOf(s, m.c, m.k + rk - m.rk) < at);
-                    if (left)
-                        doomed.push({ c: o.c, k, n: 1 });
-                }
-            }
-        }
-        remove(tr, doomed, undefined, true);
-        const [p] = s.policies;
-        for (const d of doomed)
-            p.watch.push(...rootSpans(s, d));
-    };
-    /** Whether `tr` deleted a member of a character some history watches. */
-    const watchedDied = (s, tr) => [...s.policies].some((p) => p.watch.some((w) => members(s, w).some((m) => tr.deleteSet.intersects(m.c, m.k, m.n))));
-    /** After every commit: index its records; after a remote one, keep this replica's facts. */
-    const react = (s, tr) => {
-        const fresh = sync(s, tr);
-        // A purge deletes marks past the horizon: nothing comes back for
-        // it, and a pending character only they held stays deleted.
-        if (tr.changed.has(s.horizon)) {
-            for (const p of s.policies)
-                p.watch = p.watch.filter((w) => holders(s, w).length > 0 || shown(s, [w]).length > 0);
-            return;
-        }
-        if (tr.local || s.policies.size === 0)
-            return;
-        if (fresh.copies.length === 0 && !fresh.released && !watchedDied(s, tr))
-            return;
-        s.doc.transact((t) => {
-            hold(s, t, fresh.copies);
-            dedupe(s, t, fresh.copies);
-            for (const p of s.policies)
-                p.watch = settle(s, p, t, p.watch);
-        }, REACT);
-    };
-    /**
-     * The spans of this writer's last record merged with `spans`, when a
-     * delete may fold into it — it is the records list's last element, live,
-     * this replica's, written in this transaction or in the step still
-     * capturing (`open`: the history steps whose capture group is open), or
-     * anywhere when no history records steps here; and the merged record
-     * stays small ({@link FOLD_SPANS}). `null`: write a record of its own.
-     */
-    const foldInto = (s, tr, open, spans) => {
-        const at = s.lastMark;
-        if (at === null || at.c !== s.doc.clientID)
-            return null;
-        const last = structAt(Y, clientsOf(s.doc).get(at.c) ?? [], at.k);
-        if (last === null ||
-            last.deleted ||
-            last.parent !== s.marks ||
-            last.right !== null ||
-            last.id.clock + last.length - 1 !== at.k)
-            return null;
-        const same = tr?.insertSet.has(at.c, at.k) === true ||
-            open.some((ids) => ids.has(at.c, at.k)) ||
-            s.policies.size === 0;
-        if (!same)
-            return null;
-        const [, bytes] = recordsIn(last, null).at(-1) ?? [];
-        if (bytes === undefined)
-            return null;
-        const merged = mergeSpans([...decode(bytes, 3).map(([c, k, n]) => ({ c, k, n })), ...spans]);
-        return merged.length <= FOLD_SPANS ? merged : null;
-    };
-    /**
-     * Delete this replica's last record (the list's tail, {@link foldInto})
-     * and append `bytes` right after it, by item: no index walk over the
-     * list's tombstones. The list's search markers are dropped (their
-     * positions no longer hold).
-     */
-    const replaceLast = (s, tr, bytes) => {
-        const at = s.lastMark;
-        const tail = ops.cleanStart(tr, at.c, at.k);
-        tail.delete(tr);
-        dropSearchMarkers(s.marks);
-        const client = s.doc.clientID;
-        ops.appendAfter(tr, tail, s.marks, client, nextClock(s.doc, client), [bytes]);
-    };
-    /** The text units `ids` names, as spans. */
-    const unitsIn = (s, ids) => {
-        const out = [];
-        walkIdSet(Y, s.doc, ids, (st, lo, hi) => {
-            if (hi > lo && isUnit(st))
-                out.push({ c: st.id.client, k: lo, n: hi - lo });
-        });
-        return out;
-    };
-    /** A text unit a mark can hold: a character or inline atom of a backing text. */
-    const isUnit = (it) => it.parentSub === null &&
-        it.parent?.name === CONTENT_NODE &&
-        (typeof it.content?.str === 'string' || it.content?.type?.name === INLINE_NODE);
-    return {
-        /** The history's extra scope: the marks (an undo removes its own). */
-        scope: (doc) => attach(doc).marks,
-        /**
-         * Mark `spans` (the characters a text delete just deleted, inside its
-         * transaction) as this writer's, and hide their other visible copies.
-         */
-        markDeleted: (doc, deleted) => {
-            const s = attach(doc);
-            // Text inserted and deleted within one open capture group never comes
-            // back by that step's undo (the engine skips such a step): no mark.
-            const fresh = [...s.policies].flatMap((p) => {
-                const um = p.um();
-                const top = stepsOf(um.undoStack).at(-1);
-                const open = top !== undefined &&
-                    !um.undoing &&
-                    !um.redoing &&
-                    um.lastChange > 0 &&
-                    Date.now() - um.lastChange < um.captureTimeout;
-                return open ? [top.inserts] : [];
-            });
-            const tr = s.doc._transaction;
-            const spans = deleted.flatMap((sp) => {
-                const out = [];
-                for (let k = sp.k; k < sp.k + sp.n; k++) {
-                    if (fresh.some((ids) => ids.has(sp.c, k)))
-                        continue;
-                    const last = out[out.length - 1];
-                    if (last !== undefined && last.k + last.n === k)
-                        last.n++;
-                    else
-                        out.push({ c: sp.c, k, n: 1 });
-                }
-                return out;
-            });
-            if (spans.length === 0)
-                return;
-            // A delete in the step that wrote this writer's last record
-            // (a backspace run) folds into it, its spans merged — one record per
-            // step, not per keystroke. The record is replaced (deleted and
-            // written again), never edited, so an undo of the step still takes
-            // back exactly what the step deleted.
-            const folded = tr === null ? null : foldInto(s, tr, fresh, spans);
-            const k = nextClock(s.doc, s.doc.clientID);
-            const bytes = encode((folded ?? spans).map((sp) => [sp.c, sp.k, sp.n]));
-            if (folded === null)
-                s.marks.insert(s.marks.length, [bytes]);
-            else
-                replaceLast(s, tr, bytes);
-            s.lastMark = { c: s.doc.clientID, k };
-            if (tr !== null)
-                remove(tr, shown(s, spans.flatMap((sp) => rootSpans(s, sp))));
-        },
-        /** A doc's index of marks and copies, and the delete the purge writes (`purge.ts`). */
-        state: attach,
-        remove,
-        /** The restore and apply rules of a history on `doc` (`doc/history.ts`). */
-        history: (doc, um) => {
-            const s = attach(doc);
-            const p = { um, watch: [], tr: null, units: [] };
-            s.policies.add(p);
-            const current = () => {
-                const tr = s.doc._transaction;
-                if (p.tr !== tr)
-                    Object.assign(p, { tr, units: [] });
-                return p;
-            };
-            return {
-                /** Text units are restored by `onApply`, character by character. */
-                restoreFilter: (item) => {
-                    const it = item;
-                    if (!isUnit(it))
-                        return true;
-                    current().units.push({ c: it.id.client, k: it.id.clock, n: it.length });
-                    return false;
-                },
-                onApply: (transaction, stackItem) => {
-                    const tr = transaction;
-                    const q = current();
-                    const step = stackItem;
-                    const fresh = sync(s, tr);
-                    const roots = q.units.flatMap((u) => rootSpans(s, u));
-                    const ours = (m) => step.inserts.has(m.client, m.clock);
-                    q.watch.push(...settle(s, q, tr, roots, ours));
-                    // A redo writes its marks again: they hide what shows their characters.
-                    const held = fresh.marks.flatMap((m) => s.holds.get(keyOf(m)) ?? []);
-                    remove(tr, shown(s, held));
-                    // Text the step deleted that no mark of it holds (an undo of typing) is
-                    // this writer's delete too.
-                    const bare = unitsIn(s, tr.deleteSet).filter((u) => rootSpans(s, u).some((r) => !held.some((h) => h.c === r.c && h.k <= r.k && r.k + r.n <= h.k + h.n)));
-                    if (bare.length > 0)
-                        s.marks.insert(s.marks.length, [encode(bare.map((u) => [u.c, u.k, u.n]))]);
-                    q.units = [];
-                }
-            };
-        }
-    };
-};

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

@@ -1,17 +0,0 @@
-/**
- * Anchored merge claims (`merge.claim.anchor`): the effective claimer of
- * each claim a split its writer did not see moves to the piece that ends
- * its region, re-decided after each fold's texts.
- */
-import type { BlockId } from '../../placement/model.js';
-import { type Claim } from '../model.js';
-import type { IndexClaims } from './claims.js';
-import type { FoldCtx, IndexState } from './state.js';
-/** The anchored merge claims of one doc's index, over its state and claim graph. */
-export declare const indexAnchored: (ix: IndexState & IndexClaims) => {
-    sameClaims: (x: readonly Claim[], y: readonly Claim[]) => boolean;
-    effectiveClaims: (b: BlockId, list: readonly Claim[]) => Claim[];
-    targetOf: (holder: BlockId, c: Claim) => [BlockId];
-    applyRetargets: (ctx: FoldCtx | null) => void;
-};
-export type IndexAnchored = ReturnType<typeof indexAnchored>;

package/dist/crdt/text/index/anchored.js

@@ -1,197 +0,0 @@
-import { storeOf } from '../../structs.js';
-import { cmpStamp, isBoundary } from '../model.js';
-import { gapOfItem, headOf, segmentOfCut, segmentOfGap } from '../rows.js';
-import { addTo, dropFrom } from './shared.js';
-/** The anchored merge claims of one doc's index, over its state and claim graph. */
-export const indexAnchored = (ix) => {
-    const { doc, blocks, rows, streamIx, homeOfText, attachOf, foreignOf, anchoredIn, retargets, unresolved, reclaim, noteClaims, invalidateBlock } = ix;
-    // ── anchored merge claims (`merge.claim.anchor`) ──
-    // A claim written since 0.1.0-next.26 carries the end of its holder's
-    // stream as its writer saw it (`a`: the last unit, `r`: the item after
-    // it). A split the writer did not see moves it to the piece that ends
-    // that region: its EFFECTIVE claimer is the block of the segment just
-    // before `r` (the text's last segment when `r` is null), if that is
-    // the holder's segment or one after it in the holder's row. Records
-    // carry their list (`listClaims`) and their effective claims
-    // (`claims`: their own that stay, then those other holders' anchors
-    // move to them, by stamp); every reader of claims reads the effective
-    // ones. Targets change only with a row's cuts: re-decided after each
-    // fold's texts for the holders whose record changed and those anchored
-    // in a re-placed row.
-    const anchorHomes = new Map();
-    const sameClaims = (x, y) => x.length === y.length &&
-        x.every((c, i) => c.m === y[i].m &&
-            c.holder === y[i].holder &&
-            c.seqIndex === y[i].seqIndex &&
-            cmpStamp(c.stamp, y[i].stamp) === 0);
-    /** `b`'s effective claims: its own that stay with it, then the others' moved to it, by stamp. */
-    function effectiveClaims(b, list) {
-        const targets = attachOf.get(b);
-        const own = targets === undefined ? list : list.filter((_, i) => (targets[i] ?? b) === b);
-        const holders = foreignOf.get(b);
-        if (holders === undefined)
-            return own;
-        const moved = [];
-        for (const h of holders) {
-            const hr = blocks.get(h);
-            const ts = attachOf.get(h);
-            if (hr === undefined || ts === undefined)
-                continue;
-            (hr.listClaims ?? hr.claims).forEach((c, i) => {
-                if (ts[i] === b)
-                    moved.push({ ...c, holder: h });
-            });
-        }
-        moved.sort((x, y) => cmpStamp(x.stamp, y.stamp));
-        return [...own, ...moved];
-    }
-    const store = storeOf(doc);
-    /** The struct holding unit `ref`, and the unit's offset in it (`null`: none held). */
-    const unitAt = (ref) => {
-        if (store.getClock(ref.c) <= ref.k)
-            return null;
-        const s = store.getItem({ client: ref.c, clock: ref.k });
-        if (s?.parent === undefined || s.parent === null)
-            return null;
-        return [s, ref.k - s.id.clock];
-    };
-    /** The gap of row `row` unit `off` of `it` lies in (`-1`: stale, the walk met an unknown boundary). */
-    const gapOfUnit = (row, it, off) => {
-        const arr = it.content?.arr;
-        if (!it.deleted && it.countable !== false && arr !== undefined) {
-            const key = (k) => row.keyIndex.get(`${it.id.client}:${it.id.clock + k}`);
-            for (let k = off; k >= 0; k--)
-                if (isBoundary(arr[k])) {
-                    const j = key(k);
-                    if (j === undefined)
-                        return -1;
-                    // The unit itself, a boundary: the units before it.
-                    return k === off ? j : j + 1;
-                }
-            for (let k = off + 1; k < it.length; k++)
-                if (isBoundary(arr[k])) {
-                    const j = key(k);
-                    return j === undefined ? -1 : j;
-                }
-        }
-        return gapOfItem(row, it);
-    };
-    /** The effective claimer of `holder`'s claim `c`. */
-    const targetOf = (holder, c) => {
-        if (c.a === undefined)
-            return [holder];
-        const at = streamIx.get(holder);
-        const row = at && rows.get(at.home);
-        if (row === undefined)
-            return [holder];
-        const a = unitAt(c.a);
-        if (a === null || a[0].parent !== row.text)
-            return [holder];
-        const k0 = segmentOfCut(row, at.cut);
-        let gap = row.bounds.length;
-        if (c.r != null) {
-            const r = unitAt(c.r);
-            if (r === null || r[0].parent !== row.text)
-                return [holder];
-            gap = gapOfUnit(row, r[0], r[1]);
-        }
-        if (k0 < 0 || gap < 0)
-            return [holder];
-        const k = segmentOfGap(row, gap);
-        const target = k < k0 ? null : headOf(row, k);
-        return [target ?? holder];
-    };
-    /**
-     * The rows whose placement may move `holder`'s anchored claim `c`: its
-     * stream's and its anchor's text's. `null` while it is unresolved — the
-     * holder has no stream, or an anchor names a unit not integrated yet
-     * (a payload is no dependency: the claim can arrive first) — and
-     * re-decided at every fold.
-     */
-    const watchOf = (holder, c) => {
-        if (c.a !== undefined && unitAt(c.a) === null)
-            return null;
-        if (c.r != null && unitAt(c.r) === null)
-            return null;
-        const homes = [];
-        const own = streamIx.get(holder)?.home;
-        if (own !== undefined)
-            homes.push(own);
-        const a = c.a === undefined ? null : unitAt(c.a);
-        const text = a === null ? undefined : homeOfText.get(a[0].parent);
-        if (text !== undefined && text !== own)
-            homes.push(text);
-        return homes.length === 0 ? null : homes;
-    };
-    /**
-     * The retarget pass: re-decide the targets of the holders queued, move
-     * their claims between effective claimers, and re-read the claims of
-     * every block that gained or lost one (its claim facts and readers).
-     */
-    const applyRetargets = (ctx) => {
-        for (const h of retargets) {
-            const rec = blocks.get(h);
-            const before = attachOf.get(h);
-            for (const home of anchorHomes.get(h) ?? [])
-                dropFrom(anchoredIn, home, h);
-            anchorHomes.delete(h);
-            let after;
-            unresolved.delete(h);
-            for (const [i, c] of (rec?.listClaims ?? []).entries()) {
-                if (c.a === undefined)
-                    continue;
-                const [t] = targetOf(h, c);
-                const watch = watchOf(h, c);
-                if (watch === null)
-                    unresolved.add(h);
-                else
-                    for (const home of watch) {
-                        addTo(anchoredIn, home, h);
-                        addTo(anchorHomes, h, home);
-                    }
-                if (t !== h)
-                    (after ??= new Array((rec.listClaims ?? []).length).fill(h))[i] = t;
-            }
-            const was = new Set(before ?? []);
-            const now = new Set(after ?? []);
-            for (const t of was)
-                if (t !== h && !now.has(t))
-                    dropFrom(foreignOf, t, h);
-            for (const t of now)
-                if (t !== h)
-                    addTo(foreignOf, t, h);
-            if (after === undefined)
-                attachOf.delete(h);
-            else
-                attachOf.set(h, after);
-            if (before !== undefined || after !== undefined) {
-                reclaim.add(h);
-                for (const t of was)
-                    reclaim.add(t);
-                for (const t of now)
-                    reclaim.add(t);
-            }
-        }
-        retargets.clear();
-        for (const b of reclaim) {
-            const rec = blocks.get(b);
-            if (rec === undefined)
-                continue;
-            const before = rec.claims;
-            const after = effectiveClaims(b, rec.listClaims ?? before);
-            if (sameClaims(before, after))
-                continue;
-            rec.claims = after;
-            noteClaims(b, before, after);
-            if (ctx !== null)
-                invalidateBlock(b, ctx, before);
-        }
-        reclaim.clear();
-    };
-    return {
-        sameClaims,
-        effectiveClaims,
-        targetOf,
-        applyRetargets
-    };
-};