edytor 4.0.0 → 6.0.0

package/dist/crdt/doc/delete.js

@@ -1,84 +0,0 @@
-import { ref } from './plan.js';
-/** The delete ops of one facade, prepared. */
-export const deleteOps = (c) => {
-    const { view, blockTypeOf, childrenIds, positionOf, ancestorsOf, itemKindOf, isLayout, isLayoutItem, isTable, isTableRow, live, REFUSED, plan, settle, emptyingAll, emptied, deleting, remove } = c;
-    /**
-     * Delete a set of blocks (`del.blocks.promote`): this writer's mark on
-     * every member and on what it displays through merge claims (wins over
-     * concurrent moves). Only the members leave: the unselected children of a
-     * deleted block take its slot, in order, with their subtrees, as the
-     * kind they show there (`settledKind`: a deleted island's children take
-     * the slot parent's default child, a deleted list's items leave its
-     * kind, a block promoted into a list is its item). A container the delete leaves with no child goes too
-     * (`del.range.empty-container`). `subtree` is the explicit whole-subtree
-     * delete. `filled`: a parent the same plan fills again (a flow placed in
-     * the deleted blocks' slot, `flow.slot`), which is never emptied, so its
-     * layout never dissolves (`layout.flow-slot`).
-     */
-    const deleteBlocks = (ids, subtree = false, filled) => {
-        const set = new Set(ids.map(ref));
-        if ([...set].some((id) => !live(id)))
-            return REFUSED;
-        // A layout goes with its items: their blocks take its slot (`layout.dissolving`).
-        for (const id of [...set])
-            if (isLayout(id))
-                for (const kid of childrenIds(id))
-                    if (isLayoutItem(kid))
-                        set.add(kid);
-        // A table goes with its rows and cells, a row with its cells: none shows outside them (`table.delete-row`).
-        const whole = (id) => {
-            for (const kid of childrenIds(id)) {
-                set.add(kid);
-                whole(kid);
-            }
-        };
-        for (const id of [...set])
-            if (isTable(id) || isTableRow(id))
-                whole(id);
-        if (subtree) {
-            const roots = [...set].filter((id) => !ancestorsOf(id).some((a) => set.has(a)));
-            return plan(roots, emptied(roots, roots.map((id) => remove(id))));
-        }
-        const roots = [...set].filter((id) => !set.has(positionOf(id).parent));
-        const { kids } = view();
-        const promoting = new Set();
-        const members = [];
-        const writes = roots.flatMap((root) => {
-            const pos = positionOf(root);
-            const chunk = [];
-            const kept = [];
-            // The kept children keep their home slots: the read shows them in the
-            // root's slot, in its order (a block a peer puts under a member
-            // meanwhile takes the slot in that order too); only their kinds are
-            // written, as the slot's parent settles them.
-            const walk = (b) => {
-                chunk.push(b);
-                for (const kid of kids.get(b) ?? []) {
-                    if (set.has(kid.id))
-                        walk(kid.id);
-                    else
-                        kept.push({ id: kid.id, from: b });
-                }
-            };
-            walk(root);
-            members.push(...chunk);
-            if (kept.length > 0)
-                promoting.add(root);
-            // A layout shows only its items: a deleted item's blocks show right
-            // after the layout (`layout.only-items`), settled for its parent.
-            const item = pos.parent === null ? undefined : itemKindOf(pos.parent);
-            const out = (k) => item !== undefined && blockTypeOf(k.id) !== item;
-            return [
-                ...kept.flatMap((k) => settle(k.from, [k.id], out(k) ? positionOf(pos.parent).parent : pos.parent)),
-                deleting(root, chunk)
-            ];
-        });
-        return plan(roots, emptyingAll(roots.filter((r) => !promoting.has(r)).map((id) => positionOf(id).parent), roots.filter((r) => !promoting.has(r)), writes, filled === undefined ? undefined : new Set([filled]), members));
-    };
-    /** Delete `id` — its children take its slot (`keepChildren: false`: the whole subtree). */
-    const deleteBlock = (id, opts = {}) => deleteBlocks([id], opts.keepChildren === false);
-    return {
-        deleteBlocks,
-        deleteBlock
-    };
-};

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

@@ -1,9 +0,0 @@
-import type { BlockId } from '../placement/model.js';
-import type { Prepared } from './types.js';
-import type { OpsContext } from './steps.js';
-/** The layout ops of one facade, prepared. */
-export declare const layoutOps: (c: OpsContext) => {
-    besideAt: (target: BlockId, kind?: string) => BlockId;
-    placeBeside: (ids: readonly BlockId[], target: BlockId, side: "left" | "right", kind?: string) => Prepared;
-    wrapInLayout: (ids: readonly BlockId[], kind?: string, columns?: number) => Prepared;
-};

package/dist/crdt/doc/layout.js

@@ -1,178 +0,0 @@
-/**
- * Layout ops (`layout.*`): the layout kind a new layout takes, where a
- * beside placement lands (`besideAt`), and the two layout-making ops,
- * `placeBeside` and `wrapInLayout`.
- */
-import { id as newId } from '../../utils.js';
-import { sanitizeSpec } from '../../utils/json.js';
-import { ref } from './plan.js';
-/** The layout ops of one facade, prepared. */
-export const layoutOps = (c) => {
-    const { roles, view, blockTypeOf, childrenIds, positionOf, ancestorsOf, isIsland, isLines, insideIsland, isLayout, isLayoutItem, holdsLayout, insideItem, live, canPlace, isContainer, fits, fitsIn, REFUSED, plan, moveTo, landing, emptied } = c;
-    /** The layout kind a new layout takes: `kind` when it is one, else the only one the roles declare. */
-    const layoutKind = (kind) => {
-        if (kind !== undefined)
-            return roles.layout(kind) === undefined ? undefined : kind;
-        const kinds = [...roles.layoutKinds()];
-        return kinds.length === 1 ? kinds[0] : undefined;
-    };
-    /** A fresh empty block of `type`. */
-    const spec = (type) => sanitizeSpec({ id: newId('b'), type, data: {} });
-    /**
-     * The block a beside placement at `target` stands beside
-     * (`layout.place-beside`): a layout or an item for itself; a block whose
-     * parent shows only its children (a list item → its list, at any depth)
-     * or is an island of lines (a code line → its code block) for that
-     * parent; then the block itself when it sits directly in an item or at
-     * the root, or where a new layout of `kind` (else the only layout kind)
-     * fits beside it (a toggle's, a callout's or a nested block's child,
-     * outside any item and island); else its outermost block below the
-     * root or an item.
-     */
-    const besideAt = (target, kind) => {
-        let at = ref(target);
-        if (isLayout(at) || isLayoutItem(at))
-            return at;
-        for (let parent = positionOf(at)?.parent ?? null; parent !== null && !isLayoutItem(parent) && (isContainer(parent) || isLines(parent)); parent = positionOf(parent)?.parent ?? null)
-            at = parent;
-        const parent = positionOf(at)?.parent ?? null;
-        if (parent === null || isLayoutItem(parent))
-            return at;
-        const wrap = layoutKind(kind);
-        if (wrap !== undefined &&
-            fits(parent, wrap) &&
-            !insideItem(parent) &&
-            !isIsland(parent) &&
-            !insideIsland(parent))
-            return at;
-        for (let up = parent; up !== null && !isLayoutItem(up); up = positionOf(up).parent)
-            at = up;
-        return at;
-    };
-    /**
-     * Place `ids` beside `target`, to its `side` (`layout.place-beside`: a
-     * block dragged to another block's left or right edge). The target
-     * resolves to its outermost block below the root or below a layout
-     * item (a list item → its list, a code line → its code block); an item
-     * stands for itself, a layout for its first or last slot. Beside a
-     * block in an item, a new item holding `ids` goes beside that item;
-     * otherwise the block and a new item holding `ids` are wrapped in a new
-     * layout of the layout `kind` (else the only one the roles declare) at
-     * its place. Refused when `ids` holds the target or an ancestor of it,
-     * an item, a layout or a block holding one, a block that does not
-     * fit an item, a block or a layout inside an island, and, wrapping,
-     * when there is no layout kind. The sources are cleaned in the same
-     * plan (`emptying`, `dissolving`); a plain move. `ids`: the moved
-     * blocks.
-     */
-    const placeBeside = (ids, target, side, kind) => {
-        const moved = ids.map(ref);
-        target = ref(target);
-        const v = view();
-        if ((side !== 'left' && side !== 'right') || !canPlace(moved) || !live(target))
-            return REFUSED;
-        if ([target, ...ancestorsOf(target, v)].some((a) => moved.includes(a)))
-            return REFUSED;
-        if (moved.some((id) => isLayoutItem(id) || holdsLayout(id)))
-            return REFUSED;
-        const right = side === 'right';
-        // Where the new item goes: beside an item of a layout, or a new layout wrapping `at`.
-        const at = besideAt(target, kind && ref(kind));
-        let layout = null;
-        let index = 0;
-        if (isLayout(at))
-            [layout, index] = [at, right ? childrenIds(at).length : 0];
-        else {
-            const item = isLayoutItem(at) ? at : positionOf(at).parent;
-            if (item !== null) {
-                const pos = positionOf(item);
-                [layout, index] = [pos.parent, pos.index + (right ? 1 : 0)];
-            }
-        }
-        const wrap = layout === null ? layoutKind(kind && ref(kind)) : blockTypeOf(layout);
-        const item = wrap === undefined ? undefined : roles.layout(wrap);
-        if (wrap === undefined || item === undefined)
-            return REFUSED;
-        if (moved.some((id) => !fitsIn(item, blockTypeOf(id))))
-            return REFUSED;
-        if (layout !== null && (isIsland(layout) || insideIsland(layout, v)))
-            return REFUSED;
-        const fresh = spec(item);
-        const into = (parent) => moveTo(moved, parent, 0);
-        let writes;
-        let kept;
-        if (layout !== null) {
-            writes = [{ op: 'insertBlocks', parent: layout, index, specs: [fresh] }, ...into(fresh.id)];
-            kept = new Set([fresh.id, ...landing(layout)]);
-        }
-        else {
-            const pos = positionOf(at);
-            const host = spec(item);
-            const wrapper = { ...spec(wrap), children: right ? [host, fresh] : [fresh, host] };
-            writes = [
-                { op: 'insertBlocks', parent: pos.parent, index: pos.index, specs: [wrapper] },
-                ...moveTo([at], host.id, 0),
-                ...into(fresh.id)
-            ];
-            kept = new Set([wrapper.id, host.id, fresh.id, ...landing(pos.parent)]);
-        }
-        return plan(moved, emptied(moved, writes, kept));
-    };
-    /**
-     * Wrap sibling blocks in a new layout of `columns` items (default: one
-     * per block), at the first one's place (`layout.wrap`: Turn into N
-     * columns, as Notion): the blocks fill the first items, one each, in
-     * document order; each item after them holds one empty block of the
-     * item's default child (one block turned into 3 columns: it, then two
-     * empty columns). The layout is of the layout `kind` (else the only one
-     * the roles declare). Refused for no block, fewer than two items or
-     * fewer items than blocks, blocks of different parents, an item, a
-     * layout or a block holding one, where the layout does not fit
-     * (`fits`: in a list, a code block) or lands inside an item or an
-     * island, and for a block that does not fit an item. A plain move.
-     * `ids`: the new layout.
-     */
-    const wrapInLayout = (ids, kind, columns = ids.length) => {
-        const blocks = ids.map(ref);
-        const v = view();
-        if (!Number.isInteger(columns) || columns < 2 || blocks.length < 1)
-            return REFUSED;
-        if (columns < blocks.length || !canPlace(blocks))
-            return REFUSED;
-        const parent = positionOf(blocks[0]).parent;
-        if (blocks.some((id) => positionOf(id).parent !== parent))
-            return REFUSED;
-        if (blocks.some((id) => isLayoutItem(id) || holdsLayout(id)))
-            return REFUSED;
-        const wrap = layoutKind(kind && ref(kind));
-        const item = wrap === undefined ? undefined : roles.layout(wrap);
-        if (wrap === undefined || item === undefined || !fits(parent, wrap))
-            return REFUSED;
-        if (parent !== null && (insideItem(parent, v) || isIsland(parent) || insideIsland(parent, v)))
-            return REFUSED;
-        if (blocks.some((id) => !fitsIn(item, blockTypeOf(id))))
-            return REFUSED;
-        const fill = roles.defaultChild(item);
-        if (columns > blocks.length && !fitsIn(item, fill))
-            return REFUSED;
-        const ordered = blocks.toSorted((a, b) => positionOf(a).index - positionOf(b).index);
-        const items = Array.from({ length: columns }, (_, i) => i < ordered.length ? spec(item) : { ...spec(item), children: [spec(fill)] });
-        const wrapper = { ...spec(wrap), children: items };
-        const at = positionOf(ordered[0]).index;
-        const writes = [
-            { op: 'insertBlocks', parent, index: at, specs: [wrapper] },
-            ...ordered.flatMap((id, i) => moveTo([id], items[i].id, 0))
-        ];
-        const kept = new Set([
-            wrapper.id,
-            ...items.map((it) => it.id),
-            ...landing(parent)
-        ]);
-        return plan([wrapper.id], emptied(ordered, writes, kept));
-    };
-    return {
-        besideAt,
-        placeBeside,
-        wrapInLayout
-    };
-};

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

@@ -1,19 +0,0 @@
-import { type JSONBlock, type JSONInlineBlock, type JSONText } from '../../utils/json.js';
-import { type DataPatch } from '../data.js';
-import { type BlockId, type BlockSpec, type ContentItem } from '../placement/model.js';
-import type { Prepared, PlanStep, DataTarget } from './types.js';
-import type { OpsContext } from './steps.js';
-/** The meta ops of one facade, prepared. */
-export declare const metaOps: (c: OpsContext) => {
-    dataSteps: (target: DataTarget, patches: DataPatch[]) => PlanStep[] | null;
-    replaceData: (data: unknown) => DataPatch[];
-    setBlockType: (id: BlockId, type: string) => Prepared;
-    patchData: (target: DataTarget, patches: readonly DataPatch[]) => Prepared;
-    setBlock: (id: BlockId, value: {
-        type?: string;
-        data?: Record<string, unknown>;
-        content?: (ContentItem | JSONText | JSONInlineBlock)[];
-        children?: (BlockSpec | JSONBlock)[];
-    }) => Prepared;
-};
-export type MetaOps = ReturnType<typeof metaOps>;

package/dist/crdt/doc/meta.js

@@ -1,199 +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, is, 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 lined = is(id, (t) => roles.line(t) !== undefined);
-        if (lined && !roles.island(type) && !roles.childless(type)) {
-            const to = roles.defaultChild(type);
-            return [
-                ...steps,
-                ...moved.flatMap((k) => {
-                    const kind = leavingIsland(id, blockTypeOf(k.id), to);
-                    return kind === undefined ? [] : attr(k.id, TYPE, kind);
-                })
-            ];
-        }
-        if (!roles.childless(type) || 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.childless(type);
-        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>;