edytor 5.0.0 → 6.0.0

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

@@ -1,175 +0,0 @@
-/**
- * The run cache: each block's visible runs as a frozen snapshot, recomputed
- * when a fold invalidates it, sharing unchanged runs and interned payloads.
- */
-import { cloneJsonSafe } from '../../../utils/json.js';
-import { canonKey, deepFreeze, displayOf, readSegs } from '../model.js';
-import { runEquals } from './shared.js';
-/** The run cache of one doc's index. */
-export const indexCache = (ix) => {
-    const { blocks, textConsumers, listConsumers, cache, dirty, foldStats, frames, ownShim } = ix;
-    const rangeStats = { items: 0, markers: 0 };
-    // ── run cache ────────────────────────────────────────────────────
-    const internMap = new Map();
-    const debug = {
-        recomputes: 0,
-        recomputed: new Set(),
-        get itemsWalked() {
-            return rangeStats.items;
-        },
-        get markersWalked() {
-            return rangeStats.markers;
-        },
-        get frames() {
-            return frames.size;
-        },
-        get folds() {
-            return foldStats.folds;
-        },
-        get foldedPairs() {
-            return foldStats.pairs;
-        },
-        get foldedStructs() {
-            return foldStats.structs;
-        },
-        get placements() {
-            return foldStats.placed;
-        },
-        reset() {
-            debug.recomputes = 0;
-            debug.recomputed.clear();
-            foldStats.folds = 0;
-            foldStats.pairs = 0;
-            foldStats.structs = 0;
-            foldStats.placed = 0;
-            rangeStats.items = 0;
-            rangeStats.markers = 0;
-        }
-    };
-    // ── interning / freezing ─────────────────────────────────────────
-    // `cloneJsonSafe` is total even against hostile replicated payloads,
-    // and interning the normalized form keys it by its own canonical shape.
-    // The shared instance is built FROM that key (sorted keys): it must not
-    // remember the key order its first reader happened to fold, or
-    // `toJSON` would depend on when the view was read.
-    const intern = (v) => {
-        const key = canonKey(cloneJsonSafe(v));
-        let f = internMap.get(key);
-        if (f === undefined)
-            internMap.set(key, (f = deepFreeze(JSON.parse(key))));
-        return f;
-    };
-    // ── dep bookkeeping ──────────────────────────────────────────────
-    const drop = (index, keys, b) => {
-        for (const k of keys) {
-            const set = index.get(k);
-            set?.delete(b);
-            if (set?.size === 0)
-                index.delete(k);
-        }
-    };
-    const add = (index, keys, b) => {
-        for (const k of keys) {
-            let set = index.get(k);
-            if (set === undefined)
-                index.set(k, (set = new Set()));
-            set.add(b);
-        }
-    };
-    const applyDeps = (b, deps) => {
-        const old = cache.get(b)?.deps;
-        if (old) {
-            drop(textConsumers, old.texts, b);
-            drop(listConsumers, old.lists, b);
-        }
-        add(textConsumers, deps.texts, b);
-        add(listConsumers, deps.lists, b);
-    };
-    // ── snapshot construction ────────────────────────────────────────
-    const freezeFresh = (r) => Object.freeze(r);
-    /** The normalized fresh runs of `b` (interned payloads, equal marks merged) and their deps. */
-    const computeFresh = (b) => {
-        const deps = { texts: new Set(), lists: new Set([b]) };
-        const segs = displayOf(b, blocks, ownShim, (x, home) => {
-            deps.lists.add(x);
-            if (home !== undefined)
-                deps.texts.add(home);
-            // Every claim on a walked list is read, followed or not: a claim
-            // skipped for a dead target or a higher claimer becomes effective
-            // when that target revives or its winning claim goes away.
-            for (const c of blocks.get(x)?.claims ?? [])
-                deps.lists.add(c.m);
-        }) ?? [];
-        const fresh = [];
-        for (const item of readSegs(segs, rangeStats)) {
-            if (item.kind === 'text') {
-                const last = fresh[fresh.length - 1];
-                const marks = item.marks === undefined ? undefined : intern(item.marks);
-                if (last && last.kind === 'text' && last.marks === marks) {
-                    last.text += item.text;
-                }
-                else {
-                    fresh.push({
-                        kind: 'text',
-                        text: item.text,
-                        ...(marks === undefined ? {} : { marks })
-                    });
-                }
-            }
-            else {
-                fresh.push({
-                    kind: 'inline',
-                    id: item.id,
-                    type: item.type,
-                    ...(item.data === undefined ? {} : { data: intern(item.data) })
-                });
-            }
-        }
-        return { fresh, deps };
-    };
-    /**
-     * Structural sharing: reuse unchanged run objects from `old` — maximal
-     * equal prefix + equal suffix; `old` itself when every run is identical.
-     */
-    const reconcile = (old, fresh) => {
-        if (!old)
-            return Object.freeze(fresh.map(freezeFresh));
-        let s = 0;
-        const n = Math.min(old.length, fresh.length);
-        while (s < n && runEquals(old[s], fresh[s]))
-            s++;
-        if (s === old.length && s === fresh.length)
-            return old;
-        let eo = old.length - 1;
-        let ef = fresh.length - 1;
-        while (eo >= s && ef >= s && runEquals(old[eo], fresh[ef])) {
-            eo--;
-            ef--;
-        }
-        const out = new Array(fresh.length);
-        for (let i = 0; i < s; i++)
-            out[i] = old[i];
-        for (let i = s; i <= ef; i++)
-            out[i] = freezeFresh(fresh[i]);
-        for (let i = eo + 1; i < old.length; i++)
-            out[fresh.length - (old.length - i)] = old[i];
-        return Object.freeze(out);
-    };
-    // ── recompute ────────────────────────────────────────────────────
-    const computeRuns = (b) => {
-        const old = cache.get(b);
-        const { fresh, deps } = computeFresh(b);
-        const runs = reconcile(old?.runs, fresh);
-        applyDeps(b, deps);
-        cache.set(b, { runs, deps });
-        dirty.delete(b);
-        debug.recomputes++;
-        debug.recomputed.add(b);
-    };
-    return {
-        intern,
-        computeFresh,
-        computeRuns,
-        debug
-    };
-};

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

@@ -1,18 +0,0 @@
-/**
- * The claim graph (maintained): each block's owner along the max-stamp
- * claims (`top`), the blocks each owner displays, and what a structural
- * change of a block invalidates.
- */
-import type { BlockId } from '../../placement/model.js';
-import { type Claim, type Owner } from '../model.js';
-import type { FoldCtx, IndexState } from './state.js';
-/** The claim graph of one doc's index, over its state. */
-export declare const indexClaims: (ix: IndexState) => {
-    ensureOwners: () => void;
-    ownerOf: (b: BlockId) => Owner;
-    top: (m: BlockId) => BlockId | undefined;
-    displays: (owner: BlockId) => readonly BlockId[];
-    noteClaims: (id: BlockId, before: readonly Claim[], after: readonly Claim[]) => void;
-    invalidateBlock: (id: BlockId, ctx: FoldCtx, claimsBefore?: Claim[]) => void;
-};
-export type IndexClaims = ReturnType<typeof indexClaims>;

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

@@ -1,203 +0,0 @@
-import { DEAD, cmpStamp } from '../model.js';
-import { addTo, dropFrom } from './shared.js';
-/** The claim graph of one doc's index, over its state. */
-export const indexClaims = (ix) => {
-    const { blocks, listConsumers, displaysMap, ownerSeeds, ownerChanged } = ix;
-    // ── the claim graph (maintained) ─────────────────────────────
-    // `top(m)` is the max-stamp claim on `m` held by a live block; each
-    // block's owner follows `top` up (`claimGraph`). A structural change
-    // of a block (its claims, its delete mark, its record) re-decides the
-    // `top` of the blocks it claims (before and after) and the owners of
-    // those blocks and of every block whose `top` chain reaches them —
-    // never the whole graph.
-    const owners = new Map();
-    const topOf = new Map();
-    /** Claimer → the blocks it tops. */
-    const topInv = new Map();
-    /** Claimed block → the blocks whose claims list names it (live or not). */
-    const claimersOf = new Map();
-    /** The max-stamp claim on `m` held by a live block. */
-    const topClaim = (m) => {
-        let best;
-        for (const holder of claimersOf.get(m) ?? []) {
-            const rec = blocks.get(holder);
-            if (rec === undefined || rec.deleted)
-                continue;
-            for (const c of rec.claims)
-                if (c.m === m && (best === undefined || cmpStamp(c.stamp, best.stamp) > 0))
-                    best = { claimer: holder, stamp: c.stamp };
-        }
-        return best;
-    };
-    const setTop = (m, t) => {
-        const old = topOf.get(m);
-        if (old?.claimer === t?.claimer && (old === undefined || cmpStamp(old.stamp, t.stamp) === 0))
-            return false;
-        if (old !== undefined)
-            dropFrom(topInv, old.claimer, m);
-        if (t === undefined)
-            topOf.delete(m);
-        else {
-            topOf.set(m, t);
-            addTo(topInv, t.claimer, m);
-        }
-        return true;
-    };
-    /** `owner(b)` along `top` (`claimGraph`'s walk), memoized into `owners`. */
-    const walkOwner = (b) => {
-        const path = [];
-        let cur = b;
-        let result;
-        for (;;) {
-            const known = owners.get(cur);
-            if (known !== undefined) {
-                result = known;
-                break;
-            }
-            const rec = blocks.get(cur);
-            if (!rec || rec.deleted) {
-                result = DEAD;
-                break;
-            }
-            const at = path.indexOf(cur);
-            if (at >= 0) {
-                let best = topOf.get(path[at]);
-                for (const member of path.slice(at)) {
-                    const t = topOf.get(member);
-                    if (cmpStamp(t.stamp, best.stamp) > 0)
-                        best = t;
-                }
-                result = best.claimer;
-                break;
-            }
-            const t = topOf.get(cur);
-            if (t === undefined) {
-                result = cur;
-                break;
-            }
-            path.push(cur);
-            cur = t.claimer;
-        }
-        if (blocks.has(cur))
-            owners.set(cur, result);
-        for (const x of path)
-            owners.set(x, result);
-    };
-    const setDisplay = (b, from, to) => {
-        if (typeof from === 'string')
-            dropFrom(displaysMap, from, b);
-        if (typeof to === 'string')
-            addTo(displaysMap, to, b);
-    };
-    const ensureOwners = () => {
-        if (ownerSeeds.size === 0)
-            return;
-        // The tops a seed's claims (now, and those it dropped: noted in `claimersOf` changes) decide.
-        const affected = new Set();
-        const stack = [];
-        const seeds = [...ownerSeeds];
-        for (const x of ownerSeeds) {
-            stack.push(x);
-            for (const m of claimTargets.get(x) ?? [])
-                if (setTop(m, topClaim(m)))
-                    stack.push(m);
-            for (const c of blocks.get(x)?.claims ?? [])
-                if (setTop(c.m, topClaim(c.m)))
-                    stack.push(c.m);
-        }
-        ownerSeeds.clear();
-        claimTargets.clear();
-        for (let x = stack.pop(); x !== undefined; x = stack.pop()) {
-            if (affected.has(x))
-                continue;
-            affected.add(x);
-            for (const m of topInv.get(x) ?? [])
-                stack.push(m);
-        }
-        const before = new Map();
-        for (const x of affected) {
-            before.set(x, owners.get(x));
-            owners.delete(x);
-        }
-        for (const x of affected)
-            if (blocks.has(x))
-                walkOwner(x);
-        for (const [x, was] of before) {
-            const now = owners.get(x);
-            if (now === was)
-                continue;
-            setDisplay(x, was, now);
-            ownerChanged.add(x);
-        }
-        // A holder whose claims changed re-slots what shows through them: their
-        // order among its claims is the key of the blocks shown under it
-        // (`claimedRank`) — under its owner when it is itself merged away.
-        for (const x of seeds) {
-            if (!blocks.has(x))
-                continue;
-            ownerChanged.add(x);
-            const o = owners.get(x);
-            if (typeof o === 'string' && o !== x)
-                ownerChanged.add(o);
-        }
-    };
-    /** The claims each seed held before its record changed (their tops are re-decided too). */
-    const claimTargets = new Map();
-    const ownerOf = (b) => {
-        ensureOwners();
-        return owners.get(b) ?? DEAD;
-    };
-    /** The live claimer of the max-stamp claim on `m` (`DisplayOwnership.top`). */
-    const top = (m) => {
-        ensureOwners();
-        return topOf.get(m)?.claimer;
-    };
-    /** The blocks `owner` displays (the delete step's marks). */
-    const displays = (owner) => {
-        ensureOwners();
-        return [...(displaysMap.get(owner) ?? [])];
-    };
-    /** Union-ever claim targets per holder (never shrinks: a dropped claim still invalidates). */
-    const effects = new Map();
-    const noteEffects = (id, claims) => {
-        let fx = effects.get(id);
-        if (fx === undefined)
-            effects.set(id, (fx = new Set()));
-        for (const c of claims)
-            fx.add(c.m);
-    };
-    /** `id`'s claims went from `before` to `after`: its claim facts follow. */
-    const noteClaims = (id, before, after) => {
-        noteEffects(id, after);
-        const was = new Set(before.map((c) => c.m));
-        const now = new Set(after.map((c) => c.m));
-        for (const m of was)
-            if (!now.has(m)) {
-                dropFrom(claimersOf, m, id);
-                addTo(claimTargets, id, m);
-            }
-        for (const m of now)
-            if (!was.has(m))
-                addTo(claimersOf, m, id);
-        ownerSeeds.add(id);
-    };
-    /** A structural change of `id`: its readers, and the blocks it claims, re-read. */
-    const invalidateBlock = (id, ctx, claimsBefore = []) => {
-        ctx.invalidated.add(id);
-        for (const c of listConsumers.get(id) ?? [])
-            ctx.invalidated.add(c);
-        for (const m of new Set([...(effects.get(id) ?? []), ...claimsBefore.map((c) => c.m)])) {
-            ctx.invalidated.add(m);
-            for (const c of listConsumers.get(m) ?? [])
-                ctx.invalidated.add(c);
-        }
-    };
-    return {
-        ensureOwners,
-        ownerOf,
-        top,
-        displays,
-        noteClaims,
-        invalidateBlock
-    };
-};

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

@@ -1,21 +0,0 @@
-import type { BlockId } from '../../placement/model.js';
-import type { ContentRun } from '../runs.js';
-import type { IndexCache } from './cache.js';
-import type { IndexClaims } from './claims.js';
-import type { IndexPlacement } from './placement.js';
-import type { IndexRecords } from './records.js';
-import type { FoldCtx, IndexState, Tx } from './state.js';
-import type { IndexStreams } from './streams.js';
-import type { IndexLayout } from './layout.js';
-/** The fold of one doc's index, over every part it folds into. */
-export declare const indexFold: (ix: IndexState & IndexClaims & IndexStreams & IndexLayout & IndexPlacement & IndexRecords & IndexCache) => {
-    runs: (b: BlockId) => readonly ContentRun[];
-    settle: (affected: Iterable<BlockId>, ctx: FoldCtx | null) => void;
-    syncPending: (tr: Tx | null | undefined) => boolean;
-    openTx: () => Tx | null | undefined;
-    syncAll: () => void;
-    unfolded: () => boolean;
-    onCommit: (tr: Tx) => void;
-    committed: WeakSet<Tx>;
-};
-export type IndexFold = ReturnType<typeof indexFold>;