edytor 5.0.0 → 6.0.0

package/dist/crdt/doc/meta.js

@@ -1,198 +0,0 @@
-/**
- * A block's meta: its type (`setBlockType`, the steps a retype implies) and
- * its data, a block's, an atom's or the document's (`patchData`, the data
- * steps of a patch), and the baseline `setBlock`.
- */
-import { randOf } from '../rand.js';
-import { TYPE } from '../schema.js';
-import { asBlockSpec, asContentItem, sanitizeSpec, sanitizeWireJson } from '../../utils/json.js';
-import { patchWrites, leafKey, isObject } from '../data.js';
-import { collides } from '../placement/model.js';
-import { ref, refused, sanitizeItem } from './plan.js';
-/** The meta ops of one facade, prepared. */
-export const metaOps = (c) => {
-    const { doc, roles, roleOf, dataNode, view, blockTypeOf, blockDataOf, childrenIds, positionOf, isLines, isVoid, displayLength, live, contentTarget, REFUSED, plan, attr, leavingIsland, settle, remove, atomOf, writeContent } = c;
-    /**
-     * The data step of `patches` (sanitized) on a block, one of its atoms or
-     * the document (`crdt/data.ts`): none when it changes nothing, `null`
-     * when a patch is refused.
-     */
-    const dataSteps = (target, patches) => {
-        const [id, inlineId] = typeof target === 'object' && target ? [target.block, target.atom] : [target ?? undefined];
-        const node = dataNode(id, inlineId);
-        // A block kind's atomic paths are written as one leaf each (`data.atomic`).
-        const type = inlineId === undefined && id !== undefined ? blockTypeOf(id) : undefined;
-        const atomic = (type === undefined ? undefined : roleOf(type)?.atomic) ?? [];
-        const writes = node
-            ? patchWrites(node, patches, doc.clientID, randOf(doc), atomic.map((p) => leafKey(typeof p === 'string' ? [p] : p)))
-            : [];
-        if (writes === null)
-            return null; // a patch fits no value there
-        if (writes.length === 0)
-            return [];
-        const offset = inlineId === undefined ? undefined : atomOf(id, inlineId)?.at;
-        return [
-            {
-                op: 'patchData',
-                ...(id !== undefined && { id }),
-                ...(inlineId !== undefined && { inlineId, offset }),
-                ops: patches,
-                writes
-            }
-        ];
-    };
-    /** A whole-data replace: a patch of the root. */
-    const replaceData = (data) => [{ path: [], value: sanitizeWireJson(data) }];
-    /**
-     * `data`'s leaves as sets over `current` (`data.retype.keep`): a
-     * plain object's keys, recursively where `current` holds an object
-     * there too; anything else (an array, a primitive, an empty object, an
-     * object where `current` holds none) as one value at its path. Nothing
-     * else under the root is touched.
-     */
-    const leafSets = (data, current) => {
-        const out = [];
-        const walk = (v, at, path) => {
-            if (isObject(v) && Object.keys(v).length > 0 && (path.length === 0 || isObject(at)))
-                for (const [k, x] of Object.entries(v))
-                    walk(x, isObject(at) ? at[k] : undefined, [...path, k]);
-            else if (path.length > 0)
-                out.push({ path, value: v });
-        };
-        walk(sanitizeWireJson(data), current, []);
-        return out;
-    };
-    /**
-     * The target role decides: nothing renders a void's children,
-     * so a block retyped to a void kind hands them to the slot right after
-     * it, as the kind they show there (`settledKind`), in their order (where
-     * the read-time shedding shows a child a peer adds meanwhile). An island
-     * declared `lines` retyped to an ordinary kind keeps its lines, each
-     * retyped to the new kind's default child (the document's where that
-     * renders no content): no line kind outside its island. Any other
-     * island's children keep their kinds (a table's rows stay rows), as
-     * `typeOf` shows a child a peer adds meanwhile.
-     */
-    const retypeSteps = (id, type) => {
-        const { kids } = view();
-        const pos = positionOf(id);
-        const steps = attr(id, TYPE, type);
-        const moved = kids.get(id) ?? [];
-        // A code block retyped to an ordinary kind keeps its lines as that kind's children
-        // (`leavingIsland`: never a kind that hides their text).
-        const to = roles.of(type);
-        if (isLines(id) && !to.island && !to.childless) {
-            return [
-                ...steps,
-                ...moved.flatMap((k) => {
-                    const kind = leavingIsland(id, blockTypeOf(k.id), to.child);
-                    return kind === undefined ? [] : attr(k.id, TYPE, kind);
-                })
-            ];
-        }
-        if (!to.childless || moved.length === 0 || pos === null)
-            return steps;
-        // The children keep their home slots: the read shows them in the void's
-        // slot (`conc.void-children`), settled for its parent.
-        return [
-            ...steps,
-            ...settle(id, moved.map((k) => k.id), pos.parent)
-        ];
-    };
-    /** Set the block type (attr write — the block keeps its identity; see `retypeSteps`). */
-    const setBlockType = (id, type) => {
-        id = ref(id);
-        return live(id) ? plan([id], retypeSteps(id, ref(type))) : REFUSED;
-    };
-    /**
-     * Patch the data of a block, one of its inline atoms or the document
-     * (`null`), in order (`crdt/data.ts`): each patch replaces the value at
-     * its path (`value` absent deletes it), `splice` and `order` edit the
-     * array there; a path addresses array items by index, resolved here
-     * to the items' ids. Only the leaves it changes are written, so a
-     * peer's edit of another key or item is kept. Refused for an absent
-     * target, a path that is no array of strings, a root value that is no
-     * object, or an op that fits no value at its path.
-     */
-    const patchData = (target, patches) => {
-        const valid = (p) => Array.isArray(p?.path) &&
-            p.path.every((k) => typeof k === 'string') &&
-            (p.path.length > 0 || p.value === undefined || isObject(p.value));
-        if (!Array.isArray(patches) || !patches.every(valid))
-            return REFUSED;
-        // Only the fields a patch has: an absent one is no non-JSON value to report.
-        const clean = patches.map(({ path, value, splice, order }) => sanitizeWireJson({
-            path,
-            ...(value !== undefined && { value }),
-            ...(splice !== undefined && { splice }),
-            ...(order !== undefined && { order })
-        }));
-        const t = target === null
-            ? null
-            : typeof target === 'string'
-                ? ref(target)
-                : { block: ref(target.block), atom: ref(target.atom) };
-        if (typeof t === 'string' ? !live(t) : t !== null && atomOf(t.block, t.atom) === undefined)
-            return REFUSED;
-        const steps = dataSteps(t, clean);
-        return steps ? plan(t === null ? [] : [typeof t === 'string' ? t : t.block], steps) : REFUSED;
-    };
-    /**
-     * Baseline `setBlock`: `type` updates the block in place and `data`
-     * sets the leaves it names, removing none (`data.retype.keep`: a
-     * retype keeps the block's properties, as Notion's Turn into does;
-     * `setBlockData` replaces them); `content`/`children` REPLACE
-     * wholesale — explicit replacement is a
-     * new-identity operation; a retype to a void kind without `children`
-     * unnests the current ones (`retypeSteps`). All-or-nothing: children
-     * for a block that is `void` after the write, or a replacement id that
-     * is already taken (a live or deleted
-     * block, the replaced children included, or a duplicate inside the
-     * replacement), refuses before any write — `id-collision` for the
-     * latter. A caller wanting a child back re-creates it with a fresh id.
-     */
-    const setBlock = (id, value) => {
-        id = ref(id);
-        const content = value.content?.map((item) => sanitizeItem(asContentItem(item)));
-        const children = value.children?.map((child) => sanitizeSpec(asBlockSpec(child)));
-        if (!live(id) || (content !== undefined && !contentTarget(id)))
-            return REFUSED;
-        const type = value.type === undefined ? undefined : ref(value.type);
-        const toVoid = type === undefined ? isVoid(id) : roles.of(type).childless;
-        if (children?.length && toVoid)
-            return REFUSED;
-        if (children !== undefined && collides(doc, children))
-            return refused('id-collision');
-        const data = value.data === undefined ? [] : dataSteps(id, leafSets(value.data, blockDataOf(id)));
-        if (data === null)
-            return REFUSED;
-        const writes = [
-            ...(type === undefined
-                ? []
-                : children === undefined
-                    ? retypeSteps(id, type)
-                    : attr(id, TYPE, type)),
-            ...data
-        ];
-        if (content !== undefined) {
-            const length = displayLength(id);
-            if (length > 0)
-                writes.push({ op: 'deleteText', id, offset: 0, length });
-            writeContent(writes, id, 0, content);
-        }
-        if (children !== undefined) {
-            for (const kid of childrenIds(id))
-                writes.push(remove(kid));
-            if (children.length > 0)
-                writes.push({ op: 'insertBlocks', parent: id, index: 0, specs: children });
-        }
-        return plan([id], writes);
-    };
-    return {
-        dataSteps,
-        replaceData,
-        setBlockType,
-        patchData,
-        setBlock
-    };
-};

package/dist/crdt/doc/moves.d.ts

@@ -1,21 +0,0 @@
-import { type JSONBlock } from '../../utils/json.js';
-import { type BlockId, type BlockSpec, type Destination } from '../placement/model.js';
-import type { Prepared } from './types.js';
-import { type OpsContext } from './steps.js';
-/** The moves ops of one facade, prepared. */
-export declare const moveOps: (c: OpsContext) => {
-    insertBlocks: (dest: Destination, specs: readonly (BlockSpec | JSONBlock)[]) => Prepared;
-    moveBlocks: (ids: readonly BlockId[], dest: Destination) => Prepared;
-    unNestBlocks: (ids: readonly BlockId[]) => Prepared;
-    unNestBlock: (id: BlockId) => Prepared;
-    landingOf: (id: BlockId, kind: string, after?: boolean) => {
-        parent: string | null;
-        levels: string[];
-    };
-    liftOut: (id: BlockId, kind: string, { keep, after }?: {
-        keep?: boolean;
-        after?: readonly BlockSpec[];
-    }) => Prepared;
-    duplicateBlock: (id: BlockId, freshId?: (oldId: string, kind: "block" | "inline") => string) => Prepared;
-};
-export type MoveOps = ReturnType<typeof moveOps>;

package/dist/crdt/doc/moves.js

@@ -1,274 +0,0 @@
-/**
- * Block placement ops: insert (`insertBlocks`, `duplicateBlock`), move
- * (`moveBlocks`), outdent (`unNestBlocks`) and the lift out of the
- * containers a kind does not fit (`landingOf`, `splitOut`, `liftOut`).
- */
-import { id as newId } from '../../utils.js';
-import { asBlockSpec, sanitizeSpec } from '../../utils/json.js';
-import { collides } from '../placement/model.js';
-import { ref } from './plan.js';
-import { PART } from './steps.js';
-/** The moves ops of one facade, prepared. */
-export const moveOps = (c) => {
-    const { doc, blockTypeOf, blockDataOf, childrenIds, positionOf, isVoid, isIsland, isLine, contentItems, live, canPlace, isContainer, fits, kindToCopy, REFUSED, plan, moveTo, move, leaving, settledKind, settle, landing, emptying, emptied } = c;
-    /**
-     * Insert blocks (specs may carry children/content/data; the batch is
-     * all-or-nothing). A spec is a `BlockSpec` or the `JSONBlock` that
-     * `toJSON` and the view's `value` speak (`{ type, content: [{ text }] }`):
-     * its ids are kept, minted where missing (`asBlockSpec`). Ids must be fresh.
-     * Refused when the parent is not live, is `void` or is an island's
-     * line (it holds no children), or any id collides.
-     * Inserting INSIDE an island is allowed — island interiors are built
-     * this way. `ids`: the inserted roots.
-     */
-    const insertBlocks = (dest, specs) => {
-        const parent = ref(dest.parent);
-        const clean = specs.map((spec) => sanitizeSpec(asBlockSpec(spec)));
-        if (parent !== null && (isVoid(parent) || isLine(parent)))
-            return REFUSED;
-        if (clean.length === 0)
-            return plan([], []);
-        if ((parent !== null && !live(parent)) || collides(doc, clean))
-            return REFUSED;
-        return plan(clean.map((s) => s.id), [{ op: 'insertBlocks', parent, index: dest.index, specs: clean }]);
-    };
-    /**
-     * Grouped move — one step, per-member conflict resolution; refused
-     * exactly when `canPlace` refuses the group. `ids`: the moved blocks,
-     * in request order.
-     */
-    const moveBlocks = (ids, dest) => {
-        const moved = ids.map(ref);
-        const parent = ref(dest.parent);
-        if (moved.length === 0)
-            return plan([], []);
-        if (!canPlace(moved, parent))
-            return REFUSED;
-        // A list the move leaves with no item goes (not one it moves or lands in).
-        const into = new Set([...moved, ...landing(parent)]);
-        return plan(moved, emptied(moved, move(moved, parent, dest.index), into));
-    };
-    /**
-     * Outdent: move sibling blocks `ids` (document order) right
-     * after their parent, and hand the siblings that followed the last of
-     * them to it as its last children — every outliner's Shift+Tab. A last
-     * block that cannot adopt them (void, island, a container they do not
-     * fit) leaves them with the parent. The blocks take the kind they show
-     * in their new slot (`settledKind`: a list's item becomes a paragraph,
-     * a paragraph outdented into a list its item); refused where one would
-     * not fit (a paragraph out of a column into its columns layout).
-     * Items leaving a container never take the items after them:
-     * the list splits around them, Notion's way — outdented first items go
-     * before it, last ones after it; from the middle, the list keeps the
-     * items after them and a new list of its kind takes the ones before
-     * them, so an item a peer appends meanwhile stays with the items it
-     * follows (`splitOut`, the split Turn into's `liftOut` makes). A
-     * container left with no child goes. One plan; refused as the
-     * move is. `ids`: the moved blocks.
-     */
-    const unNestBlocks = (ids) => {
-        const moved = ids.map(ref);
-        const last = moved.at(-1);
-        const pos = last === undefined ? null : positionOf(last);
-        const ppos = pos?.parent != null ? positionOf(pos.parent) : null;
-        if (!ppos || moved.some((id) => positionOf(id)?.parent !== pos.parent))
-            return REFUSED;
-        const from = pos.parent;
-        if (!canPlace(moved, ppos.parent, (id) => settledKind(from, id, ppos.parent)))
-            return REFUSED;
-        const after = childrenIds(from).slice(pos.index + 1);
-        const retype = settle(from, moved, ppos.parent);
-        if (isContainer(from))
-            return splitOut(moved, [from], [], false, retype);
-        const writes = [...moveTo(moved, ppos.parent, ppos.index + 1, leaving(true)), ...retype];
-        const adopts = after.length > 0 &&
-            !isVoid(last) &&
-            !isIsland(last) &&
-            after.every((id) => fits(last, blockTypeOf(id)));
-        if (adopts)
-            writes.push(...move(after, last, Infinity));
-        return plan(moved, writes);
-    };
-    /** Outdent one block (`unNestBlocks`). */
-    const unNestBlock = (id) => unNestBlocks([id]);
-    /**
-     * Where a block of `kind` at `id`'s place lands: `id`'s parent, or the
-     * first one up that `kind` fits (`fits`: a list holds only its items),
-     * and the containers it leaves on the way, innermost first (`levels`).
-     * Its own kind keeps a block where it is, as a reorder
-     * does (`canPlace`); a block inserted after it (`after`) has no place
-     * yet.
-     */
-    const landingOf = (id, kind, after = false) => {
-        const levels = [];
-        let parent = positionOf(id)?.parent ?? null;
-        const own = !after && blockTypeOf(id) === kind;
-        for (; !own && parent !== null && !fits(parent, kind); parent = positionOf(parent).parent)
-            levels.push(parent);
-        return { parent, levels };
-    };
-    /**
-     * Lift sibling blocks `ids` (document order) out of `levels`, the
-     * containers around them, innermost first: each level
-     * splits around them as an outdent splits one list — the blocks
-     * before them go to a new container of its kind, which the level above
-     * holds the same way, and the level keeps the ones after them, so an
-     * item a peer appends meanwhile stays with the items it follows; one
-     * left with no child goes. `specs` (new blocks) land right after them.
-     * With `keep`, `ids` stay before the split and only `specs` go out.
-     * `retype` (the caller's kind steps) joins the plan. The one split
-     * `unNestBlocks` and `liftOut` share. `ids`: the placed blocks.
-     */
-    const splitOut = (ids, levels, specs, keep, retype = []) => {
-        const moved = keep ? [] : [...ids];
-        const placed = [...moved, ...specs.map((s) => s.id)];
-        const insert = (at, index, s) => s.length ? [{ op: 'insertBlocks', parent: at, index, specs: s }] : [];
-        const last = ids.at(-1);
-        const { parent, index } = positionOf(levels.at(-1) ?? last);
-        if (levels.length === 0)
-            return plan(placed, [...insert(parent, index + 1, specs), ...retype]);
-        // Bottom up: what stays before the split at each level (the level
-        // itself, or a new head holding it), and whether anything follows it.
-        const heads = [];
-        let before = null;
-        let follows = false;
-        // The block right after `last` (what the split ends at when `keep`).
-        let next;
-        let child = last;
-        for (const level of levels) {
-            const kids = childrenIds(level);
-            const at = kids.indexOf(child);
-            const stays = (keep && child === last) || (before !== null && !before.head);
-            const lead = kids.slice(0, at + (stays ? 1 : 0)).filter((k) => !moved.includes(k));
-            if (!follows && at + 1 < kids.length)
-                [follows, next] = [true, kids[at + 1]];
-            if ((lead.length > 0 || before?.head) && follows) {
-                const spec = sanitizeSpec({
-                    id: newId('b'),
-                    type: kindToCopy(level),
-                    data: blockDataOf(level) ?? {}
-                });
-                heads.push({ spec, kids: lead, inner: before?.head });
-                before = { id: spec.id, head: spec };
-            }
-            else
-                before = lead.length > 0 ? { id: level } : null;
-            child = level;
-        }
-        // Written in one gap, each right after the block before it, as an
-        // after-record out of the level's slot or a before-record into the gap
-        // before it (`leaving`): the engine's sort decides their order against
-        // a peer's records there (fork patch YP22, `sourceOrder`: the block a
-        // record stands at, then its part), so a peer's heads, pieces, lifts
-        // and new blocks in the same gap keep the serial order whatever the
-        // client ids (`del.merge.container`). The head stands at the first block
-        // (with `keep`, at it: `with`), the blocks at themselves, the new
-        // blocks after the last (`after`) — or, kept before the block that
-        // follows, at that block (`kept`). The records are written last first,
-        // so each stands before the one written before it, in the order the
-        // sort gives them; the head and the new blocks are created in the
-        // innermost level right after the block they stand at (their home,
-        // hidden while their records show them) and moved out by them.
-        const outside = before !== null && !before.head;
-        const side = leaving(outside);
-        const gap = index + (outside ? 1 : 0);
-        const at = moved[0] ?? last;
-        const kids0 = childrenIds(levels[0]);
-        const home = kids0.indexOf(last) + 1;
-        const specIds = specs.map((sp) => sp.id);
-        const [stands, part] = keep && !outside ? [next, PART.kept] : [last, PART.after];
-        // One record per run of adjacent blocks, each standing at its first: a
-        // block a peer's move takes out of a run leaves the others at their own place.
-        const runs = [];
-        for (const id of moved) {
-            const run = runs.at(-1);
-            if (run !== undefined && kids0.indexOf(run.at(-1)) + 1 === kids0.indexOf(id))
-                run.push(id);
-            else
-                runs.push([id]);
-        }
-        const writes = [
-            ...insert(levels[0], home, specs),
-            ...(before?.head ? insert(levels[0], home, [before.head]) : []),
-            ...moveTo(specIds, parent, gap, side, stands, part),
-            ...runs.reverse().flatMap((run) => moveTo(run, parent, gap, side, run[0], PART.self)),
-            ...(before?.head
-                ? moveTo([before.head.id], parent, gap, side, at, keep ? PART.with : PART.head)
-                : [])
-        ];
-        for (const { spec, kids, inner } of heads.reverse()) {
-            writes.push(...moveTo(kids, spec.id, 0), ...(inner ? insert(spec.id, kids.length, [inner]) : []));
-        }
-        writes.push(...retype);
-        void next;
-        return plan(placed, emptying(levels[0], moved, writes, landing(parent)));
-    };
-    /**
-     * Place `id` where a block of `kind` fits, in one plan:
-     * out of every container around it that `kind` does not fit
-     * (`landingOf`: a list, and a list holding that list directly, for a
-     * heading or a divider), each split around it (`splitOut`). `after`
-     * (new blocks) lands right after it. With `keep`, `id` stays and only
-     * `after` goes out, the split right after `id` (a divider inserted
-     * after an item). Its own kind never moves it. The kinds are the
-     * caller's: it composes the retype (`setBlock`). Refused where `id`
-     * may not move there (`canPlace`). `ids`: the placed blocks.
-     */
-    const liftOut = (id, kind, { keep = false, after = [] } = {}) => {
-        id = ref(id);
-        kind = ref(kind);
-        const specs = after.map(sanitizeSpec);
-        const { parent, levels } = landingOf(id, kind, keep);
-        if (!positionOf(id) || collides(doc, specs) || !canPlace([id], parent, () => kind))
-            return REFUSED;
-        return splitOut([id], levels, specs, keep);
-    };
-    /**
-     * Explicit fresh-identity copy of a subtree (paste / drag-clone):
-     * serializes `id`, remaps every block and inline atom id through
-     * `freshId`, inserts the copy right after `id`. Text atoms get new
-     * identity too — duplication is a creation op, not a relocation. An
-     * inline id `freshId` does not answer (a block-only callback) is
-     * minted; a block id it does not answer refuses the copy. `ids`: the
-     * copy's root.
-     */
-    const duplicateBlock = (id, freshId = (_, kind) => newId(kind === 'block' ? 'b' : 'i')) => {
-        id = ref(id);
-        const pos = positionOf(id);
-        if (pos === null)
-            return REFUSED;
-        const spec = (b) => {
-            const fresh = freshId(b, 'block');
-            if (typeof fresh !== 'string')
-                return null;
-            const content = contentItems(b).map((item) => {
-                if (item.kind !== 'inline')
-                    return item;
-                const atom = freshId(item.id, 'inline');
-                return { ...item, id: typeof atom === 'string' ? atom : newId('i') };
-            });
-            const children = childrenIds(b).map(spec);
-            if (children.includes(null))
-                return null;
-            const data = blockDataOf(b);
-            return {
-                id: fresh,
-                type: kindToCopy(b),
-                ...(data !== undefined && { data }),
-                content,
-                children: children
-            };
-        };
-        const copy = spec(id);
-        return copy ? insertBlocks({ parent: pos.parent, index: pos.index + 1 }, [copy]) : REFUSED;
-    };
-    return {
-        insertBlocks,
-        moveBlocks,
-        unNestBlocks,
-        unNestBlock,
-        landingOf,
-        liftOut,
-        duplicateBlock
-    };
-};

package/dist/crdt/doc/split-merge.d.ts

@@ -1,10 +0,0 @@
-import { type BlockId, type SplitTail } from '../placement/model.js';
-import type { Prepared } from './types.js';
-import type { OpsContext } from './steps.js';
-/** The split-merge ops of one facade, prepared. */
-export declare const splitMergeOps: (c: OpsContext) => {
-    splitBlock: (id: BlockId, offset: number, newId: BlockId, tail?: SplitTail) => Prepared;
-    mergeBlocks: (fromId: BlockId, intoId: BlockId) => Prepared;
-    mergeBackward: (id: BlockId) => Prepared;
-    mergeForward: (id: BlockId) => Prepared;
-};