edytor 2.0.0 → 4.0.0

package/dist/crdt/text/delete-index.js

@@ -1,365 +0,0 @@
-/**
- * The index of text delete marks and restoration records (`text/deletes.ts`):
- * which root characters each live mark holds, every copy of a character and
- * what it copied, and the reads over them (members, leaves, holders, the
- * parts of one status), kept in each document's `State`.
- */
-import * as decoding from 'lib0-v14/decoding';
-import * as encoding from 'lib0-v14/encoding';
-import { asYDoc, clientsOf, collectable, collectNow, collects, engineOps, structAt, walkIdSet } from '../structs.js';
-export const overlaps = (a, b) => a.k < b.k + b.n && b.k < a.k + a.n;
-export const push = (map, key, v) => {
-    const list = map.get(key);
-    if (list === undefined)
-        map.set(key, [v]);
-    else
-        list.push(v);
-};
-export const keyOf = (r) => `${r.client}:${r.clock}`;
-/** The most spans a folded delete record holds (a backspace run merges into one). */
-export const FOLD_SPANS = 8;
-/** `spans` sorted, with touching and overlapping spans of one client merged. */
-export const mergeSpans = (spans) => {
-    const out = [];
-    for (const sp of [...spans].sort((a, b) => a.c - b.c || a.k - b.k)) {
-        const last = out[out.length - 1];
-        if (last !== undefined && last.c === sp.c && sp.k <= last.k + last.n)
-            last.n = Math.max(last.n, sp.k + sp.n - last.k);
-        else
-            out.push({ ...sp });
-    }
-    return out;
-};
-/** `m` narrowed to root characters `[lo, hi)`. */
-export const clip = (m, lo, hi) => ({
-    c: m.c,
-    k: m.k + lo - m.rk,
-    n: hi - lo,
-    rk: lo
-});
-export const encode = (rows) => {
-    const e = encoding.createEncoder();
-    encoding.writeVarUint(e, rows.length);
-    for (const row of rows)
-        for (const v of row)
-            encoding.writeVarUint(e, v);
-    return encoding.toUint8Array(e);
-};
-export const decode = (bytes, width) => {
-    const d = decoding.createDecoder(bytes);
-    const rows = [];
-    for (let i = decoding.readVarUint(d); i > 0; i--) {
-        const row = [];
-        for (let j = 0; j < width; j++)
-            row.push(decoding.readVarUint(d));
-        rows.push(row);
-    }
-    return rows;
-};
-/** The index's reads and writes over a document's `State`. */
-export const deleteIndex = (Y) => {
-    const ops = engineOps(Y);
-    const idSet = (spans) => {
-        const set = ops.idSet();
-        for (const sp of spans)
-            set.add(sp.c, sp.k, sp.n);
-        return set;
-    };
-    /** Each item of `spans`, split at their edges. */
-    const each = (tr, spans, fn) => ops.iterate(tr, idSet(spans), fn);
-    // ── the index ──────────────────────────────────────────────────────
-    /** `sp` as the root spans of its characters, in order (its own ids where it is no copy). */
-    const rootSpans = (s, sp) => {
-        const out = [];
-        let k = sp.k;
-        const end = sp.k + sp.n;
-        const copies = (s.copies.get(sp.c) ?? []).filter((e) => overlaps(e, sp));
-        for (const e of copies.sort((a, b) => a.k - b.k)) {
-            const lo = Math.max(k, e.k);
-            const hi = Math.min(end, e.k + e.n);
-            if (lo > k)
-                out.push({ c: sp.c, k, n: lo - k });
-            out.push({ c: e.rc, k: e.rk + lo - e.k, n: hi - lo });
-            k = hi;
-        }
-        if (end > k)
-            out.push({ c: sp.c, k, n: end - k });
-        return out;
-    };
-    /** Every member of root span `r`'s characters: the root itself and each copy. */
-    const members = (s, r) => [
-        { ...r, rk: r.k },
-        ...(s.byRoot.get(r.c) ?? [])
-            .filter((e) => overlaps({ k: e.rk, n: e.n }, r))
-            .map((e) => clip({ c: e.c, k: e.k, n: e.n, rk: e.rk }, Math.max(r.k, e.rk), Math.min(r.k + r.n, e.rk + e.n)))
-    ];
-    /** The live parts of member `m`, in root coordinates. */
-    const liveRoots = (s, m) => {
-        const out = [];
-        walkIdSet(Y, s.doc, idSet([m]), (st, lo, hi) => {
-            if (!st.deleted && hi > lo)
-                out.push({ c: m.c, k: m.rk + lo - m.k, n: hi - lo });
-        });
-        return out;
-    };
-    /** The live ids showing root spans `roots`. */
-    const shown = (s, roots) => roots.flatMap((r) => members(s, r).flatMap((m) => liveRoots(s, m).map((p) => clip(m, p.k, p.k + p.n))));
-    /** The live index of id `c:k` in its text (YATA order: the same on every replica). */
-    const indexOf = (s, c, k) => Y.indexOfId(asYDoc(s.doc), Y.createID(c, k))?.index ?? Infinity;
-    /**
-     * List order of ids `a` and `b` of one text (negative: `a` first): their
-     * live indices, and where no live unit separates them, the walk from one
-     * to the other through the dead run between them.
-     */
-    const order = (s, a, b) => {
-        const d = indexOf(s, a.c, a.k) - indexOf(s, b.c, b.k);
-        if (d !== 0 || (a.c === b.c && a.k === b.k))
-            return d;
-        const find = (x) => structAt(Y, clientsOf(s.doc).get(x.c) ?? [], x.k);
-        const [sa, sb] = [find(a), find(b)];
-        if (sa === sb)
-            return a.k - b.k;
-        for (let it = sa?.right ?? null; it !== null; it = it.right) {
-            if (it === sb)
-                return -1;
-            if (!it.deleted && it.countable !== false)
-                break;
-        }
-        return 1;
-    };
-    /**
-     * What restores root span `r`: per character, the leftmost leaf of its
-     * lineage (a member no copy was made of). A copy sits right before what it
-     * copied, so leaves are the newest incarnations, and the leftmost one is
-     * where the leftmost-wins deduplication keeps its neighbours.
-     */
-    const leaves = (s, r) => {
-        const ms = members(s, r);
-        if (ms.length === 1)
-            return ms;
-        const copied = (m, rk) => {
-            const id = m.k + rk - m.rk;
-            return (s.byOrigin.get(m.c) ?? []).some((e) => e.ok <= id && id < e.ok + e.n);
-        };
-        // A leaf beside a shown neighbour of the same copy puts the character back
-        // among the neighbours it was restored with.
-        const beside = (m, rk) => {
-            const id = m.k + rk - m.rk;
-            const e = (s.copies.get(m.c) ?? []).find((x) => x.k <= id && id < x.k + x.n);
-            const lo = e?.k ?? -Infinity;
-            const hi = e === undefined ? Infinity : e.k + e.n;
-            return [id - 1, id + 1].some((k) => k >= lo && k < hi && structAt(Y, clientsOf(s.doc).get(m.c) ?? [], k)?.deleted === false);
-        };
-        const out = [];
-        for (let rk = r.k; rk < r.k + r.n; rk++) {
-            let best = null;
-            let near = false;
-            for (const m of ms) {
-                if (rk < m.rk || rk >= m.rk + m.n || copied(m, rk))
-                    continue;
-                const id = { c: m.c, k: m.k + rk - m.rk };
-                const b = beside(m, rk);
-                if (best === null ||
-                    (b && !near) ||
-                    (b === near && order(s, id, { c: best.c, k: best.k + rk - best.rk }) < 0))
-                    [best, near] = [m, b];
-            }
-            if (best === null)
-                continue;
-            const last = out[out.length - 1];
-            if (last !== undefined &&
-                last.c === best.c &&
-                last.rk + last.n === rk &&
-                last.k + last.n === best.k + rk - best.rk)
-                last.n++;
-            else
-                out.push(clip(best, rk, rk + 1));
-        }
-        return out;
-    };
-    /** Whether the record `r` is live (the struct holding it is not deleted). */
-    const alive = (s, r) => structAt(Y, clientsOf(s.doc).get(r.client) ?? [], r.clock)?.deleted === false;
-    /** Every hold on root characters of client `c`. */
-    const heldOf = (s, c) => [...(s.held.get(c)?.values() ?? [])].flat();
-    /** Live marks holding any character of `r`, except those `skip` names. */
-    const holders = (s, r, skip) => heldOf(s, r.c)
-        .filter((h) => overlaps(h, r) && !skip?.(h.mark) && alive(s, h.mark))
-        .map((h) => h.mark);
-    /** `r` without the spans `done`. */
-    const minus = (r, done) => {
-        let out = [r];
-        for (const d of done)
-            if (d.c === r.c)
-                out = out.flatMap((x) => {
-                    if (!overlaps(x, d))
-                        return [x];
-                    const keep = [];
-                    if (d.k > x.k)
-                        keep.push({ c: x.c, k: x.k, n: d.k - x.k });
-                    if (d.k + d.n < x.k + x.n)
-                        keep.push({ c: x.c, k: d.k + d.n, n: x.k + x.n - d.k - d.n });
-                    return keep;
-                });
-        return out;
-    };
-    /** `r` cut where a live hold or a shown copy starts or ends: parts of one status each. */
-    const parts = (s, r) => {
-        const cuts = new Set([r.k, r.k + r.n]);
-        const edge = (k) => k > r.k && k < r.k + r.n && cuts.add(k);
-        for (const h of heldOf(s, r.c))
-            if (overlaps(h, r) && alive(s, h.mark))
-                [h.k, h.k + h.n].forEach(edge);
-        for (const m of members(s, r))
-            for (const p of liveRoots(s, m))
-                [p.k, p.k + p.n].forEach(edge);
-        const at = [...cuts].sort((a, b) => a - b);
-        return at.slice(1).map((hi, i) => ({ c: r.c, k: at[i], n: hi - at[i] }));
-    };
-    /** Index `copies`; the ones that were new. */
-    const addCopies = (s, copies) => copies.filter((e) => {
-        const key = `${e.c}:${e.k}`;
-        if (s.copyKeys.has(key))
-            return false;
-        s.copyKeys.add(key);
-        push(s.copies, e.c, e);
-        push(s.byRoot, e.rc, e);
-        push(s.byOrigin, e.oc, e);
-        return true;
-    });
-    const indexRecord = (s, rec, bytes) => addCopies(s, decode(bytes, 6).map(([k, n, rc, rk, oc, ok]) => ({ c: rec.client, k, n, rc, rk, oc, ok })));
-    const indexMark = (s, mark, bytes) => {
-        const key = keyOf(mark);
-        if (s.holds.has(key))
-            return false;
-        const roots = decode(bytes, 3).flatMap(([c, k, n]) => rootSpans(s, { c, k, n }));
-        s.holds.set(key, roots);
-        for (const r of roots) {
-            let byMark = s.held.get(r.c);
-            if (byMark === undefined)
-                s.held.set(r.c, (byMark = new Map()));
-            const list = byMark.get(key);
-            if (list === undefined)
-                byMark.set(key, [{ k: r.k, n: r.n, mark }]);
-            else
-                list.push({ k: r.k, n: r.n, mark });
-        }
-        return true;
-    };
-    /** Drop the marks `marks` from the index (by mark: folded delete records drop one per delete); whether any was indexed. */
-    const dropMarks = (s, marks) => {
-        let any = false;
-        for (const key of marks.map(keyOf)) {
-            const roots = s.holds.get(key);
-            if (roots === undefined)
-                continue;
-            any = true;
-            s.holds.delete(key);
-            for (const r of roots) {
-                const byMark = s.held.get(r.c);
-                byMark?.delete(key);
-                if (byMark?.size === 0)
-                    s.held.delete(r.c);
-            }
-        }
-        return any;
-    };
-    /** The records `st` (a struct of a records list) holds that `ids` names, with their bytes. */
-    const recordsIn = (st, ids) => {
-        const content = st.content?.getContent?.() ?? [];
-        const out = [];
-        for (let j = 0; j < st.length; j++) {
-            const r = { client: st.id.client, clock: st.id.clock + j };
-            // A collected record (its content gone) names nothing.
-            if (!(content[j] instanceof Uint8Array))
-                continue;
-            if (ids === null || ids.has(r.client, r.clock))
-                out.push([r, content[j]]);
-        }
-        return out;
-    };
-    /** Index the records `tr` wrote (restorations first: a mark's roots may need them). */
-    const sync = (s, tr) => {
-        const fresh = { copies: [], marks: [], released: false };
-        if (!tr.changed.has(s.marks) && !tr.changed.has(s.restored))
-            return fresh;
-        const inserted = [];
-        walkIdSet(Y, s.doc, tr.insertSet, (st) => {
-            if (st.parent === s.restored || st.parent === s.marks)
-                inserted.push(st);
-        });
-        for (const st of inserted)
-            if (st.parent === s.restored && !st.deleted)
-                for (const [r, bytes] of recordsIn(st, tr.insertSet))
-                    fresh.copies.push(...indexRecord(s, r, bytes));
-        for (const st of inserted)
-            if (st.parent === s.marks && !st.deleted)
-                for (const [r, bytes] of recordsIn(st, tr.insertSet))
-                    if (indexMark(s, r, bytes))
-                        fresh.marks.push(r);
-        const dropped = [];
-        walkIdSet(Y, s.doc, tr.deleteSet, (st) => {
-            if (st.parent === s.marks)
-                for (const [r] of recordsIn(st, tr.deleteSet))
-                    dropped.push(r);
-            // A restoration record only the purge deletes: its copies are
-            // forgotten and collected on every replica, as on the room.
-            if (st.parent === s.restored && !tr.insertSet.has(st.id.client, st.id.clock))
-                for (const [r, bytes] of recordsIn(st, null)) {
-                    const copies = copiesOf(r, bytes);
-                    forget(s, copies);
-                    collect(s, tr, copies);
-                }
-        });
-        fresh.released = dropMarks(s, dropped);
-        return fresh;
-    };
-    /** The copies record `r` names. */
-    const copiesOf = (r, bytes) => decode(bytes, 6).map(([k, n, rc, rk, oc, ok]) => ({ c: r.client, k, n, rc, rk, oc, ok }));
-    /** Drop `copies` from the index: the `gcFilter` no longer keeps them. */
-    const forget = (s, copies) => {
-        const gone = new Set(copies.map((e) => `${e.c}:${e.k}`));
-        const keep = (e) => !gone.has(`${e.c}:${e.k}`);
-        for (const map of [s.copies, s.byRoot, s.byOrigin])
-            for (const [c, list] of map)
-                map.set(c, list.filter(keep));
-        for (const key of gone)
-            s.copyKeys.delete(key);
-    };
-    /** Collect the deleted items wholly inside `copies` (none a history keeps). */
-    const collect = (s, tr, copies) => {
-        if (!collects(s.doc) || copies.length === 0)
-            return;
-        walkIdSet(Y, s.doc, idSet(copies), (st) => {
-            const it = st;
-            const inside = copies.some((e) => e.c === it.id.client && e.k <= it.id.clock && it.id.clock + it.length <= e.k + e.n);
-            if (inside &&
-                it.deleted &&
-                it.keep !== true &&
-                it.parent !== undefined &&
-                collectable(s.doc, it))
-                collectNow(it, tr);
-        });
-    };
-    return {
-        idSet,
-        each,
-        rootSpans,
-        members,
-        liveRoots,
-        shown,
-        indexOf,
-        leaves,
-        holders,
-        minus,
-        parts,
-        addCopies,
-        indexRecord,
-        indexMark,
-        dropMarks,
-        recordsIn,
-        sync,
-        copiesOf,
-        forget,
-        collect
-    };
-};

package/dist/crdt/text/deletes.d.ts

@@ -1,76 +0,0 @@
-/**
- * Per-writer text delete marks — the block delete marks' rule applied to text.
- *
- * Deleting text tombstones its engine items, and an undo brings
- * text back as COPIES (new items). The engine records no writer for a
- * delete, so two writers who deleted the same character concurrently could
- * not tell each other's delete from their own: one undo brought it back
- * although the other writer's delete still held it, and the second undo
- * brought a second copy. A mark names the writer: every text delete writes
- * one record (its engine client is the writer) listing the characters it
- * deleted. Records sit in the history's scope — an undo deletes the undoer's
- * own record and a redo writes a copy of it — so a live record is exactly
- * "this writer's delete is in effect".
- *
- * The rule: a character is visible iff no writer's delete of it is in
- * effect, and at most one copy of it is visible. A character keeps one
- * identity across copies, its ROOT (the original item): every restoration
- * writes a record naming, for each copy, the member it copied and the root
- * (never removed). A character is restored by copying its newest member —
- * the leaf of that lineage, where its neighbours' copies are — so restored
- * text keeps its order whoever restores it. Every decision is made by the
- * replica whose fact it is, never on another replica's stale state:
- *
- * - restoring (the undoing history): the history hands every text unit of a
- *   replayed step to `restoreFilter`, which withholds it, and `onApply`
- *   restores each character of the step no other live mark holds and no
- *   copy shows, once. A character another mark holds stays PENDING on that
- *   history, which restores it once no mark holds it and no copy shows (two
- *   writers undid a double delete concurrently, each withheld by the other);
- * - holding (the mark's writer): a copy that appears while the writer's
- *   mark holds its character — a peer undid without having seen the delete
- *   — is deleted by that writer, as part of the marked step (so its undo
- *   brings the character back). A delete, and a redo that writes its mark
- *   again, hide the character's other visible copies in the same step;
- * - deduplicating (the copy's writer): a replica deletes its own copy when a
- *   copy with a smaller id shows the same character (concurrent
- *   restorations; the smaller one wins).
- *
- * Writes a local step needs join it (`onApply`, the facade's delete), so an
- * undo stays one update. Writes a REMOTE change calls for run in one
- * follow-up transaction under an origin no history tracks, like the
- * engine's formatting cleanup (fork patch YP10). Pending characters, holding and
- * deduplication are session facts: a writer whose history ended no longer
- * hides a concurrent restoration, though its live mark still withholds every
- * later undo.
- *
- * The index of marks and copies is `text/delete-index.ts`; this module
- * writes the marks, restores, holds and deduplicates.
- */
-import type { EngineApi, EngineDoc, EngineNode, YUndoManager } from '../engine-api.js';
-import { type State, type Step, type Tr } from './delete-index.js';
-/** Engine ids `c:k … c:k+n-1`. */
-export type Span = {
-    c: number;
-    k: number;
-    n: number;
-};
-export declare const bindDeletes: (Y: EngineApi) => {
-    /** The history's extra scope: the marks (an undo removes its own). */
-    scope: (doc: EngineDoc) => EngineNode;
-    /**
-     * Mark `spans` (the characters a text delete just deleted, inside its
-     * transaction) as this writer's, and hide their other visible copies.
-     */
-    markDeleted: (doc: EngineDoc, deleted: readonly Span[]) => void;
-    /** A doc's index of marks and copies, and the delete the purge writes (`purge.ts`). */
-    state: (doc: EngineDoc) => State;
-    remove: (tr: Tr, live: readonly Span[], into?: Step, keep?: boolean) => void;
-    /** The restore and apply rules of a history on `doc` (`doc/history.ts`). */
-    history: (doc: EngineDoc, um: () => YUndoManager) => {
-        /** Text units are restored by `onApply`, character by character. */
-        restoreFilter: (item: unknown) => boolean;
-        onApply: (transaction: unknown, stackItem: unknown) => void;
-    };
-};
-export type TextDeletes = ReturnType<typeof bindDeletes>;