edytor 4.0.0 → 6.0.0

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

@@ -1,225 +0,0 @@
-import { DEAD, claimGraph, 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();
-    let ownersBuilt = false;
-    /** 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 (!ownersBuilt) {
-            ownersBuilt = true;
-            ownerSeeds.clear();
-            const graph = claimGraph(blocks);
-            owners.clear();
-            for (const [b, o] of graph.owners)
-                if (blocks.has(b))
-                    owners.set(b, o);
-            topOf.clear();
-            topInv.clear();
-            claimersOf.clear();
-            for (const [holder, rec] of blocks)
-                for (const c of rec.claims)
-                    addTo(claimersOf, c.m, holder);
-            for (const m of claimersOf.keys())
-                setTop(m, topClaim(m));
-            displaysMap.clear();
-            for (const b of blocks.keys())
-                setDisplay(b, undefined, owners.get(b));
-            return;
-        }
-        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>;