edytor 5.0.0 → 7.0.0

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

@@ -1,258 +0,0 @@
-import { cellKey, LAST_CELL, unlistedCellKey } from '../../placement/keys.js';
-import { listedColumns, unlistedRank } from '../../tables.js';
-/** The layout rules of one doc's index, over its state. */
-export const indexLayout = (ix) => {
-    const { blocks, kindsOf } = ix;
-    /** The role of `b`'s stored kind; `undefined` without roles or a record. */
-    const kindOf = (b) => {
-        const type = blocks.get(b)?.type;
-        return ix.roles === null || type === undefined ? undefined : ix.roles.of(type);
-    };
-    /** The line kind of `b` when it is an island declared `lines`. */
-    const lineKind = (b) => kindOf(b)?.line;
-    /** The item kind of `b` when it is a layout. */
-    const itemKind = (b) => kindOf(b)?.layout;
-    /** The row kind of `b` when it is a table (`table.*`). */
-    const rowKind = (b) => kindOf(b)?.table;
-    /** `table`'s row kind and that row kind's cell kind, as `[row, cell]`. */
-    const rowOfTable = (table) => {
-        const row = ix.roles?.of(table).table;
-        return row === undefined ? undefined : [row, ix.roles.of(row).child];
-    };
-    /** The cell kind of `b` when it is a row of a table kind. */
-    const cellKind = (b) => ix.rowKinds.get(blocks.get(b)?.type ?? '');
-    /**
-     * The column ids of table `table` in their order, each with its
-     * position (`data.columns[i].id`), or `null` when it is no table or
-     * holds no `columns` array: its cells then show in their own order.
-     * Read from the record's data, memoized per data object.
-     */
-    const columnsMemo = new WeakMap();
-    const columnsOf = (table) => {
-        if (rowKind(table) === undefined)
-            return null;
-        const data = blocks.get(table)?.data;
-        if (data === null || typeof data !== 'object')
-            return null;
-        let index = columnsMemo.get(data);
-        if (index === undefined) {
-            const ids = listedColumns(data);
-            columnsMemo.set(data, (index = ids && new Map(ids.map((id, i) => [id, i]))));
-        }
-        return index;
-    };
-    /** The column a cell names (`data.column`), if any. */
-    const columnOf = (cell) => {
-        const c = blocks.get(cell)?.data?.column;
-        return typeof c === 'string' ? c : undefined;
-    };
-    /**
-     * What of `b`'s data the table rules read, as one key: a table's column
-     * ids, a cell's column (`''` for any other block). A change of it
-     * re-places the table's cells.
-     */
-    const tableFacts = (b, data) => {
-        const k = kindsOf.get(b);
-        if (data === null || typeof data !== 'object')
-            return '';
-        if (k?.table)
-            return JSON.stringify(listedColumns(data));
-        if (k?.cell) {
-            const c = data.column;
-            return typeof c === 'string' ? c : '';
-        }
-        return '';
-    };
-    /**
-     * The rank cell `id` displays at in row `row` (`table.columns`): its
-     * column's position in the table holding the row, so every row shows its
-     * cells in the table's column order whatever their placements (a key of
-     * the position, ties by block id); a withdrawn cell of a
-     * column the table no longer lists after them, its column's place among
-     * those fixed by its id (`unlistedRank`); any other cell of no listed
-     * column last (it does not display, `table.cell`).
-     * `undefined`: no table with columns holds the row — its placement rank.
-     */
-    const cellRank = (row, id) => {
-        const cell = cellKind(row);
-        if (cell === undefined || blocks.get(id)?.type !== cell)
-            return undefined;
-        const table = ix.placementsMap.get(row)?.parent;
-        const index = typeof table === 'string' ? columnsOf(table) : null;
-        if (index === null)
-            return undefined;
-        const column = columnOf(id);
-        const at = column === undefined ? undefined : index.get(column);
-        if (at === undefined && column !== undefined && ix.shells.has(id))
-            return unlistedCellKey(unlistedRank(column));
-        return at === undefined ? LAST_CELL : cellKey(at);
-    };
-    /**
-     * The table rules (`table.*`), in the same pass: a cell displays only in
-     * a row of a table, and, when the table lists its columns, only for a
-     * listed column — or, withdrawn by an undo while it holds another
-     * writer's text (`hist.undo.withdraw`), for the column the undo took out
-     * of the list — and as the first of the row's cells for it
-     * (`table.cell`); a row displays only in a table and while it shows a
-     * cell (`table.row`); a table displays while it shows a row
-     * (`table.empty`). What does not display hands up nothing a table rule
-     * shows: a cell's text goes with it.
-     */
-    const tableVisit = (kids, out, id, ctx, shown) => {
-        const k = kindsOf.get(id);
-        const childIds = (kids.get(id) ?? []).map((c) => c.id);
-        const pass = (sub) => {
-            out.add(id);
-            shown.push(...sub.filter((x) => !isTableish(x.id)));
-        };
-        if (k.table) {
-            const sub = dissolveVisit(kids, out, childIds, false, { table: id });
-            if (sub.some((x) => kindsOf.get(x.id)?.row))
-                shown.push({ id, kids: sub.map((x) => x.id) });
-            else
-                pass(sub);
-        }
-        else if (k.row) {
-            const table = ctx !== null && 'table' in ctx ? ctx.table : null;
-            const sub = dissolveVisit(kids, out, childIds, false, table === null ? null : { row: id, columns: columnsOf(table), seen: new Set() });
-            if (table !== null && sub.some((x) => kindsOf.get(x.id)?.cell))
-                shown.push({ id, kids: sub.map((x) => x.id) });
-            else
-                pass(sub);
-        }
-        else {
-            const sub = dissolveVisit(kids, out, childIds, false, null);
-            const row = ctx !== null && 'row' in ctx ? ctx : null;
-            let shows = row !== null;
-            if (row !== null && row.columns !== null) {
-                const column = columnOf(id);
-                shows =
-                    column !== undefined &&
-                        (row.columns.has(column) || ix.shells.has(id)) &&
-                        !row.seen.has(column);
-                if (shows)
-                    row.seen.add(column);
-            }
-            if (shows)
-                shown.push({ id, kids: sub.map((x) => x.id) });
-            else
-                pass(sub);
-        }
-    };
-    /** `b`'s kind is a table, a table's row or a row's cell. */
-    const isTableish = (b) => {
-        const k = kindsOf.get(b);
-        return k !== undefined && (k.table || k.row || k.cell);
-    };
-    const dissolveVisit = (kids, out, ids, layout, ctx = null) => {
-        const isItem = (b) => ix.itemKinds.has(blocks.get(b)?.type ?? '');
-        const shown = [];
-        for (const id of ids) {
-            if (isTableish(id)) {
-                tableVisit(kids, out, id, ctx, shown);
-                continue;
-            }
-            const own = itemKind(id) !== undefined;
-            const sub = dissolveVisit(kids, out, (kids.get(id) ?? []).map((k) => k.id), own);
-            if (own) {
-                if (sub.length > 1)
-                    shown.push({ id, kids: [] });
-                else {
-                    out.add(id);
-                    for (const k of sub) {
-                        out.add(k.id);
-                        shown.push(...k.kids.map((kid) => ({ id: kid, kids: [] })));
-                    }
-                }
-            }
-            else if (isItem(id) && (!layout || sub.length === 0)) {
-                out.add(id);
-                shown.push(...sub);
-            }
-            else
-                shown.push({ id, kids: sub.map((k) => k.id) });
-        }
-        return shown;
-    };
-    const dissolve = (kids) => {
-        const out = new Set();
-        dissolveVisit(kids, out, (kids.get(null) ?? []).map((k) => k.id), false);
-        return out;
-    };
-    /**
-     * Re-run the layout rules on the layouts `changed` (blocks whose slot
-     * in `kids0` changed, with their parents) and `kinds` reach: from each
-     * one up through layouts and items, the topmost such ancestor's
-     * subtree. Returns the blocks whose dissolved state flipped.
-     */
-    const redissolve = (changed, kinds) => {
-        const flips = new Set();
-        const isLayoutish = (b) => {
-            const k = kindsOf.get(b);
-            return k !== undefined && (k.layout || k.item || k.table || k.row || k.cell);
-        };
-        const roots = new Set();
-        const climb = (b) => {
-            let top;
-            for (let x = b; typeof x === 'string' && isLayoutish(x); x = ix.slots0.get(x)?.parent)
-                top = x;
-            if (top !== undefined)
-                roots.add(top);
-        };
-        for (const [id, [from, to]] of changed) {
-            climb(id);
-            climb(from);
-            climb(to);
-        }
-        for (const id of kinds) {
-            // Its kind decides its own rule, its parent's count and its children's (`layout`).
-            climb(id);
-            climb(ix.slots0.get(id)?.parent);
-            for (const k of ix.kids0.get(id) ?? [])
-                climb(k.id);
-            // Only a layout, an item or a table's block dissolves: one that left those kinds shows again.
-            if (!isLayoutish(id) && ix.dissolved.delete(id))
-                flips.add(id);
-        }
-        for (const root of roots) {
-            if (!ix.slots0.has(root))
-                continue;
-            const parent = ix.slots0.get(root).parent;
-            const nodes = [];
-            const stack = [root];
-            for (let x = stack.pop(); x !== undefined; x = stack.pop()) {
-                nodes.push(x);
-                for (const k of ix.kids0.get(x) ?? [])
-                    stack.push(k.id);
-            }
-            const out = new Set();
-            dissolveVisit(ix.kids0, out, [root], parent !== null && itemKind(parent) !== undefined);
-            for (const x of nodes) {
-                if (out.has(x) === ix.dissolved.has(x))
-                    continue;
-                if (out.has(x))
-                    ix.dissolved.add(x);
-                else
-                    ix.dissolved.delete(x);
-                flips.add(x);
-            }
-        }
-        // A block that left the index (hidden, removed) dissolves no more.
-        for (const id of changed.keys())
-            if (!ix.slots0.has(id) && ix.dissolved.delete(id))
-                flips.add(id);
-        return flips;
-    };
-    return {
-        kindOf,
-        lineKind,
-        itemKind,
-        rowKind,
-        rowOfTable,
-        cellKind,
-        cellRank,
-        tableFacts,
-        dissolve,
-        redissolve
-    };
-};

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

@@ -1,47 +0,0 @@
-/**
- * Placements and the children index (maintained), the display
- * ownership the display reads (`ownShim`), and THE shown-kind rule
- * (`typeOf`).
- *
- * A structural change re-decides only what it can change: the display
- * edge of the blocks whose slot, record or mover changed (fork patch
- * YP22), and the display slot of every block whose slot walk
- * (`displaySlotOf`) reads one that changed — its stored subtree, through
- * the blocks it displays — patched into the parents' child lists. A
- * block's candidate edges are its live move records, strongest first, then
- * its home slot; it shows at the first that closes no cycle through the
- * accepted edges (`settle`): the later move wins, and the block whose edge
- * is the oldest of a cycle falls back to its next candidate, back where it
- * stood (its previous record, else home; the root's tail only when every
- * candidate closes a cycle), so a cycle resolves locally: no global pass.
- * The first build places every block the same way (their unique acyclic
- * acceptance, whatever the order; the tests' greedy rebuild,
- * `src/tests/oracles/placements.ts`, is what the self-checks compare). A
- * placed block's order key is found from its sequence neighbours
- * (`placement/keys.ts`), never by walking the parent's sequence; a rebuild
- * keys every list once, in its sequence's order. The layout rules re-run
- * only on the layouts a change reaches.
- */
-import { type BlockId, type DisplayOwnership, type DocOrder } from '../../placement/model.js';
-import { homeOf, type SlotRef } from '../../placement/resolve.js';
-import { type Unit } from '../../placement/slots.js';
-import type { EngineNode } from '../../engine-api.js';
-import type { IndexClaims } from './claims.js';
-import type { IndexLayout } from './layout.js';
-import type { IndexState } from './state.js';
-import type { IndexStreams } from './streams.js';
-/** Placement maintenance of one doc's index, over its state, claims, streams and layout rules. */
-export declare const indexPlacement: (ix: IndexState & IndexClaims & IndexStreams & IndexLayout) => {
-    ownShim: DisplayOwnership;
-    own0: DisplayOwnership;
-    noteKind: (id: BlockId) => void;
-    homeFor: (id: BlockId) => ReturnType<typeof homeOf>;
-    putSlot: (b: BlockId, u: Unit, ref: SlotRef | null) => void;
-    edgeParent: (id: BlockId) => BlockId | null | undefined;
-    noteFollowing: (id: BlockId) => void;
-    ensurePlacements: () => void;
-    reslot: (node: EngineNode) => void;
-    typeOf: (id: BlockId) => string;
-    order: () => DocOrder;
-};
-export type IndexPlacement = ReturnType<typeof indexPlacement>;