edytor 5.0.0 → 7.0.0

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

@@ -1,13 +0,0 @@
-import type { BlockId } from '../../placement/model.js';
-import type { IndexClaims } from './claims.js';
-import type { IndexPlacement } from './placement.js';
-import type { IndexState } from './state.js';
-import type { IndexStreams } from './streams.js';
-/** The block records of one doc's index. */
-export declare const indexRecords: (ix: IndexState & IndexClaims & IndexStreams & IndexPlacement) => {
-    kept: (item: unknown) => boolean;
-    updateBlockRec: (id: BlockId) => void;
-    ensureRec: (id: BlockId) => void;
-    syncIncarnations: (id: BlockId) => string[];
-};
-export type IndexRecords = ReturnType<typeof indexRecords>;

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

@@ -1,139 +0,0 @@
-/**
- * Block records: each registry entry's record (and the losing
- * incarnations a key shows), rebuilt on a structural change, noting what
- * the maintained facts must re-decide.
- */
-import { readData } from '../../data.js';
-import { Y } from '../../engine.js';
-import { baseIdOf, incarnationNode, incarnationsOf, isIncarnationId } from '../../incarnations.js';
-import { engineOps } from '../../structs.js';
-import { CONTENT, NONCE, hasDeleteMark, hasWithdrawMark, isNodeLike } from '../../schema.js';
-import { sameShape, typeAttr } from './shared.js';
-/** The block records of one doc's index. */
-export const indexRecords = (ix) => {
-    const { registry, blocks, shells, reclaim, rawOrder, placementSeeds, stateSeeds, incarnations, noteClaims, claimsOf, noteKind, homeFor, reslot } = ix;
-    // ── records ──────────────────────────────────────────────────────
-    /** Fork patch YP14's predicate: the registry values the engine keeps. */
-    const kept = engineOps(Y).isKeptReplaced;
-    /** The node of `id`: its registry value, or the losing incarnation a derived id names. */
-    const nodeAt = (id) => {
-        const v = registry.getAttr(id);
-        if (isNodeLike(v) || !isIncarnationId(id))
-            return v;
-        return incarnationNode(registry, id, kept) ?? undefined;
-    };
-    const buildRec = (id, node) => {
-        const content = node.getAttr(CONTENT);
-        const derived = isIncarnationId(id);
-        // A losing incarnation lives and dies with its key's block: hidden by its
-        // own delete mark or while that block is deleted (a withdrawn one included).
-        const keyDeleted = derived ? (blocks.get(baseIdOf(id))?.deleted ?? true) : false;
-        // The implicit claims stamp below every written one: an explicit claim
-        // (a split moving them to its tail block) outranks them.
-        const implicit = derived
-            ? []
-            : incarnationsOf(registry, id, kept).map((x, i) => ({
-                m: x.id,
-                stamp: { c: -1, k: -1 - i }
-            }));
-        return {
-            id,
-            node,
-            type: typeAttr(node),
-            data: readData(node),
-            n: node.getAttr(NONCE),
-            deleted: hasDeleteMark(node) || keyDeleted,
-            content: isNodeLike(content) ? content : undefined,
-            implicit,
-            // Read from its stream once the record is in (`claimsOf`), again after the fold's texts.
-            claims: [],
-            home: homeFor(id)
-        };
-    };
-    /**
-     * Rebuild (or create, or drop) block `id`'s record, and note what the
-     * maintained facts must re-decide: its owner and the tops of the
-     * blocks it claims, its placement — and, when its entry came or
-     * went, the placements of the blocks whose display edge it holds.
-     */
-    const updateBlockRec = (id) => {
-        const old = blocks.get(id);
-        const node = nodeAt(id);
-        if (!isNodeLike(node))
-            blocks.delete(id);
-        else {
-            const rec = buildRec(id, node);
-            blocks.set(id, rec);
-            rec.claims = claimsOf(id);
-            reclaim.add(id);
-        }
-        const rec = blocks.get(id);
-        // Another node now stands for `id` (or none): its sequence's slots change owner.
-        if (old?.node !== rec?.node) {
-            if (old !== undefined)
-                reslot(old.node);
-            if (rec !== undefined)
-                reslot(rec.node);
-        }
-        noteShell(id);
-        noteClaims(id, old?.claims ?? [], rec?.claims ?? []);
-        placementSeeds.add(id);
-        if ((old === undefined) !== (rec === undefined)) {
-            stateSeeds.add(id);
-            for (const c of rawOrder.get(id) ?? [])
-                placementSeeds.add(c.id);
-        }
-        if (old?.type !== rec?.type) {
-            noteKind(id);
-            if (old === undefined ||
-                rec === undefined ||
-                ix.roles === null ||
-                !sameShape(ix.roles, old.type, rec.type))
-                stateSeeds.add(id);
-        }
-    };
-    /** A withdrawn block without a delete mark: its `deleted` is settled after each fold. */
-    const noteShell = (id) => {
-        const rec = blocks.get(id);
-        const was = shells.has(id);
-        // A losing incarnation is never withdrawn on its own: its key's block decides.
-        if (isIncarnationId(id))
-            shells.delete(id);
-        else if (rec !== undefined && !rec.deleted && hasWithdrawMark(rec.node))
-            shells.add(id);
-        else
-            shells.delete(id);
-        // A withdrawn cell shows in a column its table no longer lists (`table.cell`): re-place it.
-        if (was !== shells.has(id) && rec !== undefined && ix.cellKinds.has(rec.type))
-            stateSeeds.add(id);
-    };
-    const ensureRec = (id) => {
-        if (!blocks.has(id))
-            updateBlockRec(id);
-    };
-    /**
-     * Re-read the losing incarnations of key `id` after its record
-     * changed: each one shown now or before gets its record rebuilt (its
-     * liveness is the key's); returns them, for the fold to rescan.
-     */
-    const syncIncarnations = (id) => {
-        if (isIncarnationId(id))
-            return [];
-        const before = incarnations.get(id) ?? [];
-        const now = incarnationsOf(registry, id, kept).map((x) => x.id);
-        if (now.length === 0)
-            incarnations.delete(id);
-        else
-            incarnations.set(id, now);
-        const all = [...new Set([...before, ...now])];
-        for (const v of all)
-            updateBlockRec(v);
-        return all;
-    };
-    return {
-        kept,
-        updateBlockRec,
-        ensureRec,
-        syncIncarnations
-    };
-};

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

@@ -1,18 +0,0 @@
-import type { EngineDoc } from '../../engine-api.js';
-import type { BlockId, ContentItem, ProjectedBlock } from '../../placement/model.js';
-import type { IndexReport } from '../runs.js';
-import type { IndexCache } from './cache.js';
-import type { IndexFold } from './fold.js';
-import type { IndexPlacement } from './placement.js';
-import type { IndexState, Published } from './state.js';
-/** The change report of one doc's index. */
-export declare const indexReporter: (ix: IndexState & IndexPlacement & IndexCache & IndexFold) => {
-    itemsOf: (id: BlockId) => ContentItem[];
-    projectBlock: (id: BlockId) => ProjectedBlock;
-    reachable: (prev?: Published["nodes"]) => Published;
-    publish: (origin: unknown, local: boolean) => void;
-    onUpdate: (_u: Uint8Array, origin: unknown, _d: EngineDoc, tr: unknown) => void;
-    onReport: (cb: (r: IndexReport, origin: unknown, local: boolean) => void) => (() => void);
-    hasSubscribers: () => boolean;
-};
-export type IndexReporter = ReturnType<typeof indexReporter>;

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

@@ -1,337 +0,0 @@
-/**
- * The change report: the fold against the last published index, one per
- * commit that changed the visible document, and the projection it carries.
- */
-import { cloneJsonSafe, sameIds } from '../../../utils/json.js';
-import { readData } from '../../data.js';
-import { callEach } from '../../protocols/observable.js';
-import { EMPTY_IDS, checksOf, dataOf, indexChecks, keyOf } from './shared.js';
-/** The change report of one doc's index. */
-export const indexReporter = (ix) => {
-    const { doc, dataRoot, blocks, following, dirtyLists, leftLists, candidates, ensurePlacements, typeOf, runs, syncAll } = ix;
-    const docData = () => cloneJsonSafe(readData(dataRoot) ?? {});
-    let dataChanged = false;
-    // ── projection ───────────────────────────────────────────────────
-    /** `id`'s visible content items: its runs, as fresh wrappers over their shared payloads. */
-    const itemsOf = (id) => runs(id).map((r) => ({ ...r }));
-    const projectBlock = (id) => {
-        const rec = blocks.get(id);
-        const projected = {
-            id,
-            type: typeOf(id),
-            data: dataOf(rec),
-            content: itemsOf(id),
-            children: []
-        };
-        for (const k of ix.kidsMap.get(id) ?? [])
-            projected.children.push(projectBlock(k.id));
-        return projected;
-    };
-    // ── the change report: the fold against the last published index ─
-    let published = null;
-    const reportSubs = new Set();
-    /** The reachable tree — nodes carry `prev`'s published payloads where they exist. */
-    const reachable = (prev) => {
-        ensurePlacements();
-        const nodes = new Map();
-        const order = new Map();
-        const stack = [null];
-        for (let parent = stack.pop(); parent !== undefined; parent = stack.pop()) {
-            const ks = ix.kidsMap.get(parent) ?? [];
-            if (ks.length === 0)
-                continue;
-            order.set(parent, Object.freeze(ks.map((k) => k.id)));
-            for (let index = ks.length - 1; index >= 0; index--)
-                stack.push(ks[index].id);
-            ks.forEach(({ id }, index) => {
-                const old = prev?.get(id);
-                const rec = blocks.get(id);
-                nodes.set(id, old === undefined
-                    ? { parent, index, type: typeOf(id), data: rec.data, runs: runs(id) }
-                    : { ...old, parent, index });
-            });
-        }
-        return { nodes, order, kids: ix.kidsVersion };
-    };
-    /**
-     * The report's structural part from the child lists patched since the
-     * last report, advancing the published tree in place — what
-     * `reachable` would give, without walking the lists nothing changed:
-     * a published block no longer shown leaves (a root when its parent
-     * stays), its still-shown descendants staying; each patched list's
-     * new order is news, a block in it at a new parent or index moved, one
-     * not published before is added with its subtree.
-     */
-    const advance = (pub, r, covered, reparented) => {
-        const { nodes, order } = pub;
-        const shown = (x) => {
-            for (let c = x; c !== null;) {
-                const slot = ix.slots.get(c);
-                if (slot === undefined)
-                    return false;
-                c = slot.parent;
-            }
-            return true;
-        };
-        const lists = [...dirtyLists];
-        // Leaving: a published block of a patched list that no longer shows.
-        const drop = (id) => {
-            const ks = order.get(id);
-            if (ks !== undefined) {
-                order.delete(id);
-                r.order.set(id, EMPTY_IDS);
-                for (const k of ks)
-                    if (!shown(k))
-                        drop(k);
-            }
-            nodes.delete(id);
-        };
-        for (const id of leftLists) {
-            const o = nodes.get(id);
-            if (o === undefined || shown(id))
-                continue;
-            if (o.parent === null || shown(o.parent))
-                r.removed.add(id);
-            drop(id);
-        }
-        // Each patched list that shows: its order, its moved and new blocks.
-        const fresh = new Map();
-        for (const p of lists) {
-            if (p !== null && !shown(p))
-                continue;
-            const ks = ix.kidsMap.get(p) ?? [];
-            const prev = order.get(p);
-            if (ks.length === 0) {
-                if (prev !== undefined) {
-                    order.delete(p);
-                    r.order.set(p, EMPTY_IDS);
-                }
-                continue;
-            }
-            const ids = ks.map((k) => k.id);
-            if (prev === undefined || !sameIds(prev, ids)) {
-                const frozen = Object.freeze(ids);
-                order.set(p, frozen);
-                r.order.set(p, frozen);
-            }
-            ks.forEach(({ id }, index) => {
-                const n = nodes.get(id);
-                if (n === undefined)
-                    fresh.set(id, { parent: p, index });
-                else if (n.parent !== p || n.index !== index) {
-                    r.moved.add(id);
-                    if (n.parent !== p)
-                        reparented.add(id);
-                    n.parent = p;
-                    n.index = index;
-                }
-            });
-        }
-        // New roots (no new ancestor) bring their subtree.
-        const add = (b, parent, index) => {
-            if (!nodes.has(b.id)) {
-                covered.add(b.id);
-                const rec = blocks.get(b.id);
-                nodes.set(b.id, { parent, index, type: typeOf(b.id), data: rec.data, runs: runs(b.id) });
-            }
-            if (b.children.length > 0 && !order.has(b.id)) {
-                const ids = Object.freeze(b.children.map((c) => c.id));
-                order.set(b.id, ids);
-                r.order.set(b.id, ids);
-            }
-            b.children.forEach((c, i) => add(c, b.id, i));
-        };
-        for (const [id, at] of fresh) {
-            let under = false;
-            for (let c = ix.slots.get(id)?.parent ?? null; c !== null && !under; c = ix.slots.get(c)?.parent ?? null)
-                under = fresh.has(c);
-            if (under || covered.has(id))
-                continue;
-            const b = projectBlock(id);
-            r.added.set(id, b);
-            add(b, at.parent, at.index);
-        }
-    };
-    /** The blocks whose shown kind followed their slot at the last report. */
-    let followingBefore = [];
-    /** The document data's key at the last report. */
-    let dataKey = '';
-    /** Build the commit's report and advance the published index to it. */
-    const report = () => {
-        const before = published;
-        // Fold every queued transaction first: a follow-up a cleanup
-        // started (a delete-mark repair) has already written, and the
-        // first content read below would fold it mid-report, after the
-        // child lists were read (found by the purge fuzz, rich lane, seeds 651 and 1271).
-        syncAll();
-        ensurePlacements();
-        const r = {
-            added: new Map(),
-            removed: new Set(),
-            moved: new Set(),
-            meta: new Map(),
-            content: new Map(),
-            order: new Map()
-        };
-        // The document's data is news when it differs from what was published.
-        if (dataChanged) {
-            dataChanged = false;
-            const data = docData();
-            const key = keyOf(data);
-            if (key !== dataKey)
-                [r.data, dataKey] = [data, key];
-        }
-        if (ix.kidsVersion === before.kids && candidates.size === 0)
-            return r.data ? r : null;
-        // Added subtrees carry their new descendants. A descendant that was
-        // visible before is reported like any visible block (moved, retyped,
-        // edited against its published baseline), so consumers keep it.
-        const covered = new Set();
-        /** Moved to another display parent: only those can show another kind (an index never does). */
-        const reparented = new Set();
-        const lists = ix.kidsVersion !== before.kids && !ix.allListsDirty;
-        const after = ix.kidsVersion === before.kids || lists ? before : reachable(before.nodes);
-        if (lists)
-            advance(before, r, covered, reparented);
-        else if (after !== before) {
-            for (const [parent, ids] of after.order) {
-                const prev = before.order.get(parent);
-                if (prev === undefined || !sameIds(prev, ids))
-                    r.order.set(parent, ids);
-            }
-            for (const parent of before.order.keys()) {
-                if (!after.order.has(parent))
-                    r.order.set(parent, EMPTY_IDS);
-            }
-            const register = (b) => {
-                if (!before.nodes.has(b.id))
-                    covered.add(b.id);
-                b.children.forEach(register);
-            };
-            for (const [id, n] of after.nodes) {
-                if (!before.nodes.has(id)) {
-                    if (covered.has(id))
-                        continue;
-                    const b = projectBlock(id);
-                    r.added.set(id, b);
-                    register(b);
-                }
-                else {
-                    const o = before.nodes.get(id);
-                    if (o.parent !== n.parent || o.index !== n.index)
-                        r.moved.add(id);
-                    if (o.parent !== n.parent)
-                        reparented.add(id);
-                }
-            }
-            // Removed subtree ROOTS: a removed id whose before-parent stays
-            // visible (or is the root). One under a removed parent leaves with
-            // it; one under a surviving child of a removed subtree does not.
-            for (const [id, o] of before.nodes) {
-                if (after.nodes.has(id))
-                    continue;
-                if (o.parent === null || after.nodes.has(o.parent))
-                    r.removed.add(id);
-            }
-        }
-        const meta = (id, n) => {
-            const rec = blocks.get(id);
-            const type = typeOf(id);
-            r.meta.set(id, { type, data: dataOf(rec) });
-            n.type = type;
-            n.data = rec.data;
-        };
-        for (const id of candidates) {
-            const n = after.nodes.get(id);
-            if (n === undefined || covered.has(id))
-                continue;
-            const rec = blocks.get(id);
-            if (typeOf(id) !== n.type || keyOf(rec.data) !== keyOf(n.data))
-                meta(id, n);
-            const next = runs(id);
-            if (next !== n.runs) {
-                const key = keyOf(next);
-                if ((n.key ??= keyOf(n.runs)) !== key)
-                    r.content.set(id, next);
-                n.runs = next;
-                n.key = key;
-            }
-        }
-        // A block that starts or stops displaying a kind other than its
-        // stored one moved, or its kind follows (or followed) its slot:
-        // its kind is news. Without a placement change, only a retype
-        // changes a shown kind — the retyped block's (a candidate) and the
-        // kinds derived from it: a promoted or stray line shows its display
-        // parent's default child.
-        if (after !== before || lists || ix.retyped) {
-            const now = [...following];
-            for (const id of [...reparented, ...now, ...followingBefore]) {
-                const n = after.nodes.get(id);
-                if (n !== undefined && !candidates.has(id) && !covered.has(id) && typeOf(id) !== n.type)
-                    meta(id, n);
-            }
-            followingBefore = now;
-        }
-        // A plain block directly in a list shows as its item (`itemOf`):
-        // a block whose shown kind changed re-reads its children's (a worklist:
-        // the map visits the entries added meanwhile).
-        for (const id of r.meta.keys())
-            for (const { id: kid } of ix.kidsMap.get(id) ?? []) {
-                const n = after.nodes.get(kid);
-                if (n !== undefined && !covered.has(kid) && !r.meta.has(kid) && typeOf(kid) !== n.type)
-                    meta(kid, n);
-            }
-        ix.retyped = false;
-        candidates.clear();
-        published = after;
-        after.kids = ix.kidsVersion;
-        dirtyLists.clear();
-        leftLists.clear();
-        ix.allListsDirty = false;
-        if (indexChecks.on)
-            checksOf(ix).checkPublished(published);
-        const empty = r.added.size + r.removed.size + r.moved.size + r.meta.size + r.content.size + r.order.size;
-        return empty === 0 && !r.data ? null : r;
-    };
-    /** Report the commit (or role change) to every subscriber, when it changed the visible document. */
-    const publish = (origin, local) => {
-        const r = report();
-        if (r !== null)
-            callEach('[edytor-doc] change', [...reportSubs], r, origin, local);
-    };
-    const onUpdate = (_u, origin, _d, tr) => {
-        if (tr.changed?.has(dataRoot))
-            dataChanged = true;
-        publish(origin, tr.local === true);
-    };
-    /** Subscribe to the change report; the first subscription takes the baseline. */
-    const onReport = (cb) => {
-        if (reportSubs.size === 0) {
-            syncAll();
-            published = reachable();
-            dataKey = keyOf(docData());
-            candidates.clear();
-            ix.reporting = true;
-            doc.on('update', onUpdate);
-        }
-        reportSubs.add(cb);
-        return () => {
-            if (!reportSubs.delete(cb) || reportSubs.size > 0)
-                return;
-            doc.off('update', onUpdate);
-            published = null;
-            ix.reporting = false;
-            candidates.clear();
-        };
-    };
-    const hasSubscribers = () => reportSubs.size > 0;
-    return {
-        itemsOf,
-        projectBlock,
-        reachable,
-        publish,
-        onUpdate,
-        onReport,
-        hasSubscribers
-    };
-};