edytor 3.0.0 → 5.0.0

package/dist/crdt/placement/display.d.ts

@@ -1,38 +1,13 @@
 /**
  * Where a block displays: its display slot (read-time promotion out of a
  * deleted, childless or passing parent, the line and layout rules), the
- * children index and document order built from it, the text order of a
- * text's pieces (`textRanker`), liveness, and the inverse of the claim
- * owners. Pure over replicated state and the ownership the caller passes.
+ * children index and document order built from it, liveness, and the
+ * inverse of the claim owners. Pure over replicated state and the
+ * ownership the caller passes. The order of a text's pieces is the slots'
+ * (`order.split.text`: a split-born slot's key, fork patch YP22).
  */
 import { type Owner } from '../text/model.js';
-import type { BlockId, BlockRec, ChildSlot, DisplayOwnership, DocOrder, ModelView, ResolvedPlacement } from './model.js';
-/**
- * Split pieces in text order (`order.split.text`): the blocks whose streams lie in one
- * backing text and that still stand where they were made (their winning
- * placement is their first candidate, `1.<client>`: no move, outdent or
- * lift since) under one parent show in their streams' order in that text —
- * the order of the boundaries that delimit them, the same on every
- * replica — at the ranks they hold between them: the i-th of them in the
- * text takes the i-th smallest of their ranks. Ranks written at a split
- * (`sourceRank`) are a guess made on one replica's text; the boundaries are
- * the replicated fact, so two peers splitting one block at once keep the
- * text's order whatever each saw (an unseen edit after one's own split
- * point included). A block moved since stands where it was moved.
- *
- * `inText(home)`: the blocks of `home`'s text, in text order (segment 0's
- * first). Memoized per (text, parent) until `forget(home)`.
- */
-export declare const textRanker: (blocks: ReadonlyMap<BlockId, BlockRec>, placements: ReadonlyMap<BlockId, ResolvedPlacement>, homeOf: (b: BlockId) => BlockId | undefined, inText: (home: BlockId) => readonly BlockId[]) => {
-    rank: (id: BlockId, parent: BlockId | null, rank: string) => string;
-    /**
-     * Decide `home`'s text again (its segments or a member's placement
-     * changed); the blocks whose text-order rank changed.
-     */
-    regroup: (home: BlockId) => Set<BlockId>;
-    /** Drop what was decided for `home`'s text (every one, without it). */
-    forget: (home?: BlockId) => void;
-};
+import type { BlockId, ChildSlot, DisplayOwnership, DocOrder, ModelView, ResolvedPlacement } from './model.js';
 /**
  * THE liveness answer: `id` carries no live delete mark, owns
  * itself (`own.hidden` covers both: a delete-marked or unknown block owns
@@ -93,7 +68,7 @@ export declare const displayParentOf: (own: DisplayOwnership, pl: ResolvedPlacem
  * promoted one ({@link displaySlotOf}).
  */
 export declare const childrenIndex: (placements: Map<BlockId, ResolvedPlacement>, own: DisplayOwnership) => Map<BlockId | null, ChildSlot[]>;
-/** The order of a children list: by rank, ties by id. */
+/** The order of a children list: by rank, ties by id ({@link compareIds}). */
 export declare const bySlot: (a: {
     id: BlockId;
     rank: string;

package/dist/crdt/placement/display.js

@@ -1,144 +1,13 @@
 /**
  * Where a block displays: its display slot (read-time promotion out of a
  * deleted, childless or passing parent, the line and layout rules), the
- * children index and document order built from it, the text order of a
- * text's pieces (`textRanker`), liveness, and the inverse of the claim
- * owners. Pure over replicated state and the ownership the caller passes.
+ * children index and document order built from it, liveness, and the
+ * inverse of the claim owners. Pure over replicated state and the
+ * ownership the caller passes. The order of a text's pieces is the slots'
+ * (`order.split.text`: a split-born slot's key, fork patch YP22).
  */
 import { DEAD } from '../text/model.js';
-import { promotedRank } from './source.js';
-/**
- * Split pieces in text order (`order.split.text`): the blocks whose streams lie in one
- * backing text and that still stand where they were made (their winning
- * placement is their first candidate, `1.<client>`: no move, outdent or
- * lift since) under one parent show in their streams' order in that text —
- * the order of the boundaries that delimit them, the same on every
- * replica — at the ranks they hold between them: the i-th of them in the
- * text takes the i-th smallest of their ranks. Ranks written at a split
- * (`sourceRank`) are a guess made on one replica's text; the boundaries are
- * the replicated fact, so two peers splitting one block at once keep the
- * text's order whatever each saw (an unseen edit after one's own split
- * point included). A block moved since stands where it was moved.
- *
- * `inText(home)`: the blocks of `home`'s text, in text order (segment 0's
- * first). Memoized per (text, parent) until `forget(home)`.
- */
-export const textRanker = (blocks, placements, homeOf, inText) => {
-    const memo = new Map();
-    const keysOf = new Map();
-    /** `b` stands where it was made: its placement is its first candidate's. */
-    const unmoved = (b) => {
-        const c = blocks.get(b)?.cands[0];
-        const pl = placements.get(b);
-        if (c === undefined || pl === undefined || c.seq !== 1 || c.r !== pl.rank)
-            return false;
-        return pl.parent === (c.p !== null && !blocks.has(c.p) ? null : c.p);
-    };
-    const group = (home, parent) => {
-        const members = [];
-        for (const b of inText(home))
-            if (placements.get(b)?.parent === parent && unmoved(b))
-                members.push(b);
-        const out = new Map();
-        if (members.length < 2)
-            return out;
-        const rankOf = (b) => placements.get(b).rank;
-        // One client's blocks keep its own order (it ranked them knowing each
-        // other); the text decides between different clients' (concurrent
-        // splits). Each client's members, sorted by rank, fill that client's
-        // places in the text order.
-        const byClient = new Map();
-        for (const b of members) {
-            const c = blocks.get(b).cands[0].client;
-            const list = byClient.get(c);
-            if (list === undefined)
-                byClient.set(c, [b]);
-            else
-                list.push(b);
-        }
-        if (byClient.size < 2)
-            return out;
-        for (const list of byClient.values())
-            list.sort((x, y) => bySlot({ id: x, rank: rankOf(x) }, { id: y, rank: rankOf(y) }));
-        const next = new Map();
-        const order = members.map((b) => {
-            const c = blocks.get(b).cands[0].client;
-            const i = next.get(c) ?? 0;
-            next.set(c, i + 1);
-            return byClient.get(c)[i];
-        });
-        const ranks = members.map(rankOf).sort();
-        order.forEach((b, i) => out.set(b, ranks[i]));
-        return out;
-    };
-    return {
-        rank: (id, parent, rank) => {
-            const home = homeOf(id);
-            // A text no other block shares (most blocks' own): nothing to order.
-            if (home === undefined || inText(home).length < 2)
-                return rank;
-            const key = `${home}\u0000${parent}`;
-            let ranks = memo.get(key);
-            if (ranks === undefined) {
-                memo.set(key, (ranks = group(home, parent)));
-                let keys = keysOf.get(home);
-                if (keys === undefined)
-                    keysOf.set(home, (keys = new Set()));
-                keys.add(key);
-            }
-            return ranks.get(id) ?? rank;
-        },
-        /**
-         * Decide `home`'s text again (its segments or a member's placement
-         * changed); the blocks whose text-order rank changed.
-         */
-        regroup: (home) => {
-            const before = new Map();
-            for (const key of keysOf.get(home) ?? [])
-                for (const [b, r] of memo.get(key) ?? [])
-                    before.set(b, r);
-            for (const key of keysOf.get(home) ?? [])
-                memo.delete(key);
-            const keys = new Set();
-            keysOf.set(home, keys);
-            const changed = new Set();
-            const parents = new Set();
-            const row = inText(home);
-            if (row.length >= 2)
-                for (const b of row) {
-                    const pl = placements.get(b);
-                    if (pl !== undefined)
-                        parents.add(pl.parent);
-                }
-            for (const parent of parents) {
-                const key = `${home}\u0000${parent}`;
-                const ranks = group(home, parent);
-                memo.set(key, ranks);
-                keys.add(key);
-                for (const [b, r] of ranks)
-                    if (before.get(b) !== r)
-                        changed.add(b);
-            }
-            for (const [b, r] of before) {
-                const now = memo.get(`${home}\u0000${placements.get(b)?.parent}`)?.get(b);
-                if (now !== r)
-                    changed.add(b);
-            }
-            return changed;
-        },
-        /** Drop what was decided for `home`'s text (every one, without it). */
-        forget: (home) => {
-            if (home === undefined) {
-                memo.clear();
-                keysOf.clear();
-                return;
-            }
-            for (const key of keysOf.get(home) ?? [])
-                memo.delete(key);
-            keysOf.delete(home);
-        }
-    };
-};
+import { claimedRank, compareIds, promotedRank } from './keys.js';
 /**
  * THE liveness answer: `id` carries no live delete mark, owns
  * itself (`own.hidden` covers both: a delete-marked or unknown block owns
@@ -201,15 +70,13 @@ export const isLiveIn = (v, id) => {
  */
 export const displaySlotOf = (own, placements, pl, id) => {
     let { parent, rank } = pl;
-    // A piece of a text shown under its own placement's parent takes its text-order rank;
-    // a table's cell its column's (`table.columns`).
+    // A table's cell shown under its own placement's parent takes its column's rank
+    // (`table.columns`). Shown under its parent's claim owner (the parent merged away),
+    // it follows the owner's own children, by the claims down to its parent (`claimedRank`).
     const direct = (owner) => {
         if (owner !== pl.parent)
-            return rank;
-        const ruled = owner === null ? undefined : own.slotRank?.(owner, id, rank);
-        if (ruled !== undefined)
-            return ruled;
-        return own.textRank === undefined ? rank : own.textRank(id, owner, rank);
+            return claimedRank(claimPath(own, owner, pl.parent), rank);
+        return (owner === null ? undefined : own.slotRank?.(owner, id, rank)) ?? rank;
     };
     let reset = null;
     /** The first parent it is promoted out of (a deleted or childless one). */
@@ -240,8 +107,20 @@ export const displaySlotOf = (own, placements, pl, id) => {
         // Promoted into a container: it shows as one of its items.
         if (shows && reset === null && promoted !== null && own.container?.(owner) === true)
             reset = promoted;
+        // Under its parent's claim owner — promoted there or not — it is keyed in the
+        // owner's claimed space: the keys are local to one index, so a key of
+        // `parent`'s sequence compares with the owner's own children's on no replica
+        // but this one.
         if (shows)
-            return { parent: owner, rank: hops === 0 ? direct(owner) : rank, reset };
+            return {
+                parent: owner,
+                rank: owner !== parent
+                    ? claimedRank(claimPath(own, owner, parent), rank)
+                    : hops === 0
+                        ? direct(owner)
+                        : rank,
+                reset
+            };
         promoted ??= out;
         const up = placements.get(out);
         if (up === undefined || hops > placements.size)
@@ -253,6 +132,22 @@ export const displaySlotOf = (own, placements, pl, id) => {
     }
     return { parent: null, rank: pl.parent === null ? direct(null) : rank, reset };
 };
+/**
+ * The claims from `owner` down to `parent` (a block it displays through
+ * merge claims), as each holder's claim index: the order the merged blocks'
+ * children take after the owner's own children.
+ */
+const claimPath = (own, owner, parent) => {
+    const path = [];
+    for (let cur = parent, hops = 0; cur !== null && cur !== owner && hops < 256; hops++) {
+        const holder = own.top(cur);
+        if (holder === undefined)
+            break;
+        path.unshift(Math.max(0, own.claimIndex(holder, cur)));
+        cur = holder;
+    }
+    return path;
+};
 /**
  * The slot of `b` when it is a line — it displays (or, deleted, would
  * display) directly under a `lines` island ({@link DisplayOwnership.lined}) — else
@@ -315,8 +210,8 @@ export const childrenIndex = (placements, own) => {
         bucket.sort(bySlot);
     return index;
 };
-/** The order of a children list: by rank, ties by id. */
-export const bySlot = (a, b) => (a.rank === b.rank ? a.id.localeCompare(b.id) : a.rank < b.rank ? -1 : 1);
+/** The order of a children list: by rank, ties by id ({@link compareIds}). */
+export const bySlot = (a, b) => (a.rank === b.rank ? compareIds(a.id, b.id) : a.rank < b.rank ? -1 : 1);
 export const documentOrder = (kids) => {
     const ids = [];
     const at = new Map();

package/dist/crdt/placement/keys.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Order keys — the in-memory keys the index sorts a parent's children by.
+ *
+ * A block's place is its slot in its parent's sequence (fork patch YP22:
+ * the engine orders slots and move records); nothing about the order is
+ * stored. The index still needs a comparable key per child, so that
+ * `displaySlotOf`'s promotion, the layout rules, `positionInView`'s binary
+ * search and `anchors.seam` keep working over `(rank, id)`-sorted lists:
+ * each child gets a key between its sequence neighbours' when it is placed
+ * (`keyBetween`), or a dense one when a whole sequence is read
+ * (`denseKey`). Keys are plain strings compared with `<`; they are local to
+ * one index and never leave it (two replicas may hold different keys for
+ * one order).
+ *
+ * Three key spaces compose with them:
+ *
+ * - a promoted child's key is its slot's key, {@link PROMOTED} and its own
+ *   ({@link promotedRank}): `PROMOTED` sorts below every key character, so
+ *   the promoted children follow the slot and precede the next sibling;
+ * - a merged-away block's children show after the owner's own children,
+ *   by the owner's claim order ({@link claimedRank}): {@link CLAIMED} sorts
+ *   above every key character;
+ * - a table's cells show in column order ({@link cellKey}).
+ */
+/**
+ * The one order of two ids on a tie (a children list, the seam, the root's
+ * tail): their code units, the order every replica computes the same.
+ */
+export declare const compareIds: (a: string, b: string) => number;
+/** Sorts below every key character: the separator of a promoted child's key. */
+export declare const PROMOTED = "!";
+/**
+ * A key strictly between `a` and `b` (`undefined`: no bound). Both bounds
+ * are keys of this alphabet with `a < b`: place by place, a digit halfway
+ * between theirs when one fits, else `a`'s digit and one place deeper
+ * (classic fractional indexing). A key never ends in the lowest digit
+ * (`denseKey` writes none), so a key fits between any two.
+ */
+export declare const keyBetween: (a: string | undefined, b: string | undefined) => string;
+/** The `i`-th of a whole sequence's dense keys, in order (none ends in the lowest digit). */
+export declare const denseKey: (i: number) => string;
+/**
+ * The key of a block promoted into the slot keyed `slot` (read-time
+ * promotion, `del.blocks.promote`): after the slot, before every later key of
+ * the slot's list, in the promoted children's own order.
+ */
+export declare const promotedRank: (slot: string, rank: string) => string;
+/**
+ * The key of a child of a merged-away block shown under its owner: after the
+ * owner's own children, by the owner's claims (`path`: the claim index at
+ * each hop down to the child's parent), then the child's own key.
+ */
+export declare const claimedRank: (path: readonly number[], rank: string) => string;
+/**
+ * The key a table's cell displays at (`table.columns`): its column's
+ * position, before every unlisted column (`unlistedCellKey`) and the cells
+ * of no listed column (`LAST_CELL`).
+ */
+export declare const cellKey: (at: number) => string;
+/** A withdrawn cell's column the table no longer lists: after the listed ones, by `unlistedRank`. */
+export declare const unlistedCellKey: (hash: number) => string;
+/** A cell of no listed column: last (it does not display, `table.cell`). */
+export declare const LAST_CELL = "2";

package/dist/crdt/placement/keys.js

@@ -0,0 +1,95 @@
+/**
+ * Order keys — the in-memory keys the index sorts a parent's children by.
+ *
+ * A block's place is its slot in its parent's sequence (fork patch YP22:
+ * the engine orders slots and move records); nothing about the order is
+ * stored. The index still needs a comparable key per child, so that
+ * `displaySlotOf`'s promotion, the layout rules, `positionInView`'s binary
+ * search and `anchors.seam` keep working over `(rank, id)`-sorted lists:
+ * each child gets a key between its sequence neighbours' when it is placed
+ * (`keyBetween`), or a dense one when a whole sequence is read
+ * (`denseKey`). Keys are plain strings compared with `<`; they are local to
+ * one index and never leave it (two replicas may hold different keys for
+ * one order).
+ *
+ * Three key spaces compose with them:
+ *
+ * - a promoted child's key is its slot's key, {@link PROMOTED} and its own
+ *   ({@link promotedRank}): `PROMOTED` sorts below every key character, so
+ *   the promoted children follow the slot and precede the next sibling;
+ * - a merged-away block's children show after the owner's own children,
+ *   by the owner's claim order ({@link claimedRank}): {@link CLAIMED} sorts
+ *   above every key character;
+ * - a table's cells show in column order ({@link cellKey}).
+ */
+/**
+ * The one order of two ids on a tie (a children list, the seam, the root's
+ * tail): their code units, the order every replica computes the same.
+ */
+export const compareIds = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+/**
+ * Order-preserving alphabet: charCode order equals numeric order (64
+ * characters, all safe inside a JSON string).
+ */
+const ALPHABET = '-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz';
+const BASE = ALPHABET.length;
+/** Sorts below every key character: the separator of a promoted child's key. */
+export const PROMOTED = '!';
+/** Sorts above every key character: the prefix of a merged-away block's children. */
+const CLAIMED = '~';
+/** The index of a key character in the alphabet (`-1`: none). */
+const digit = (s, i) => (i < s.length ? ALPHABET.indexOf(s[i]) : -1);
+/**
+ * A key strictly between `a` and `b` (`undefined`: no bound). Both bounds
+ * are keys of this alphabet with `a < b`: place by place, a digit halfway
+ * between theirs when one fits, else `a`'s digit and one place deeper
+ * (classic fractional indexing). A key never ends in the lowest digit
+ * (`denseKey` writes none), so a key fits between any two.
+ */
+export const keyBetween = (a, b) => {
+    let out = '';
+    for (let i = 0;; i++) {
+        // Past a bound's end: below every digit (`a`), above every digit (`b`).
+        const da = a !== undefined && i < a.length ? digit(a, i) : 0;
+        const db = b === undefined ? BASE : i < b.length ? digit(b, i) : 0;
+        if (db - da > 1)
+            return out + ALPHABET[da + ((db - da) >> 1)];
+        out += ALPHABET[da];
+        // Below `b` already at this place: it bounds the deeper places no more.
+        if (db - da === 1)
+            b = undefined;
+    }
+};
+/** The `i`-th of a whole sequence's dense keys, in order (none ends in the lowest digit). */
+export const denseKey = (i) => {
+    // Four places of 63 digits (the lowest left out): 15M positions of one length.
+    let out = '';
+    let x = i;
+    for (let k = 0; k < 4; k++) {
+        out = ALPHABET[1 + (x % (BASE - 1))] + out;
+        x = Math.floor(x / (BASE - 1));
+    }
+    return out;
+};
+/**
+ * The key of a block promoted into the slot keyed `slot` (read-time
+ * promotion, `del.blocks.promote`): after the slot, before every later key of
+ * the slot's list, in the promoted children's own order.
+ */
+export const promotedRank = (slot, rank) => slot + PROMOTED + rank;
+/**
+ * The key of a child of a merged-away block shown under its owner: after the
+ * owner's own children, by the owner's claims (`path`: the claim index at
+ * each hop down to the child's parent), then the child's own key.
+ */
+export const claimedRank = (path, rank) => path.map((i) => CLAIMED + denseKey(i)).join('') + PROMOTED + rank;
+/**
+ * The key a table's cell displays at (`table.columns`): its column's
+ * position, before every unlisted column (`unlistedCellKey`) and the cells
+ * of no listed column (`LAST_CELL`).
+ */
+export const cellKey = (at) => '0' + denseKey(at);
+/** A withdrawn cell's column the table no longer lists: after the listed ones, by `unlistedRank`. */
+export const unlistedCellKey = (hash) => '1' + denseKey(hash % 2 ** 24);
+/** A cell of no listed column: last (it does not display, `table.cell`). */
+export const LAST_CELL = '2';