edytor 4.0.0 → 6.0.0

package/dist/surface/projector.svelte.js

@@ -39,11 +39,12 @@
  * from the observer's records (`rendered`, `sel.drift.unreported`).
  */
 import { untrack } from 'svelte';
-import { clearDomSelection, createDomRange, getActiveElement, getDomSelection, getDomSelectionSnapshot, scrollCaretIntoView } from '../selection/domSelection.js';
+import { clearDomSelection, createDomRange, focusIn, getActiveElement, getDomSelection, getDomSelectionSnapshot, scrollCaretIntoView } from '../selection/domSelection.js';
 import { getMarkEdgeSide, getYIndex, isTextBoundSelectionPoint } from '../selection/selection.utils.js';
 import { project, sameEnds } from '../session/selection.js';
 import { isAndroidChromeBrowser } from '../events/events.utils.js';
 import { isKindControl, isOwnPoint } from '../events/nativeInteractiveControl.js';
+import { textLeaves } from '../events/domTextOffset.js';
 /**
  * Named rule: Android Chrome mutates the DOM after a
  * canceled `deleteContentBackward` and reports the caret one position right
@@ -54,9 +55,8 @@ const ANDROID_SNAP_BACK_MS = 250;
 const IME_POST_COMMIT_JUMP_MS = 100;
 /** The DOM point of a text-segment offset: its text leaf, else the element itself. */
 export const domPointOf = (element, offset) => {
-    const walker = element.ownerDocument.createTreeWalker(element, NodeFilter.SHOW_TEXT);
     let at = 0;
-    for (let leaf = walker.nextNode(); leaf; leaf = walker.nextNode()) {
+    for (const leaf of textLeaves(element)) {
         const end = at + leaf.length;
         if (offset <= end)
             return [leaf, offset - at];
@@ -116,9 +116,7 @@ export class Projector {
     pre = () => {
         void this.#deps();
         untrack(() => {
-            const node = this.edytor.node;
-            const active = node && getActiveElement(node);
-            this.#noted = active && node.contains(active) ? active : null;
+            this.#noted = focusIn(this.edytor.node);
         });
     };
     /** Root post-flush `$effect`: every DOM write of the flush has landed. */
@@ -430,8 +428,7 @@ export class Projector {
             // whose `selectionchange` can land after that key counted as a
             // gesture) leaves any caret the browser parks later its own
             // (`#parking`, `placed`), whatever key comes before it.
-            const active = getActiveElement(node);
-            if (requested && value.kind !== 'blocks' && active && node.contains(active))
+            if (requested && value.kind !== 'blocks' && focusIn(node))
                 this.#parking = true;
             const inside = !!dom?.anchorNode && node.contains(dom.anchorNode);
             const clears = value.kind === 'none' ? requested && inside : inside || dom?.rangeCount === 0;
@@ -459,15 +456,11 @@ export class Projector {
         if (!this.#shows(dom, range, isReversed)) {
             if (!this.#ours(requested))
                 return true;
-            const active = getActiveElement(node);
-            if (!(active && node.contains(active))) {
+            if (!focusIn(node)) {
                 // Focus first (focusing a host can move the selection): the editing
                 // host, never a focusable element inside the text such as a link.
-                edytor.expectInternalFocus();
                 const element = start[0] instanceof HTMLElement ? start[0] : start[0].parentElement;
-                (element?.closest('[contenteditable="true"]') ?? node).focus({
-                    preventScroll: true
-                });
+                edytor.expectInternalFocus(element?.closest('[contenteditable="true"]') ?? node);
             }
             this.#write(getDomSelection(node) ?? dom, points, isCollapsed);
             if (selection.scrollOnDisplay)
@@ -551,10 +544,11 @@ export class Projector {
     #ours = (requested) => {
         const node = this.edytor.node;
         const active = getActiveElement(node);
+        const inside = focusIn(node);
         // A form control or a foreign editable in a kind's chrome (a field bound to
         // `block.data`) owns its focus and its selection: never written over.
-        if (active && node.contains(active))
-            return !isKindControl(node, active);
+        if (inside)
+            return !isKindControl(node, inside);
         const document = node.ownerDocument;
         if (active && active !== document.body && active !== document.documentElement)
             return false;

package/dist/text/text.svelte.js

@@ -27,28 +27,26 @@ export class Text {
     get parent() {
         return this.edytor.idToBlock.block(this.blockId);
     }
-    /** This segment in its block's parts, and its position among them. */
-    get #at() {
+    /** This segment in its block's parts. */
+    get #parts() {
         if ($effect.tracking())
             this.edytor.cells?.get(this.blockId);
-        const parts = this.edytor.idToBlock.parts(this.blockId);
-        for (let index = 0, k = 0; index < parts.length; index++) {
-            const part = parts[index];
-            if (part.kind === 'text' && k++ === this.ordinal)
-                return { part, index };
-        }
-        return { index: -1 };
+        return this.edytor.idToBlock.parts(this.blockId);
+    }
+    get #part() {
+        return this.#parts.find((part) => part.kind === 'text' && part.segOrd === this.ordinal);
     }
     /** Position among the block's content parts. */
     get index() {
-        return this.#at.index;
+        const parts = this.#parts;
+        return parts.indexOf(this.#part);
     }
     get value() {
-        return segmentJSON(this.#at.part?.items ?? []);
+        return segmentJSON(this.#part?.runs ?? []);
     }
     /** The segment's text. */
     get stringContent() {
-        return this.#at.part?.items.map((item) => item.text).join('') ?? '';
+        return this.#part?.text ?? '';
     }
     get isEmpty() {
         return this.length === 0;
@@ -57,15 +55,15 @@ export class Text {
         return this.stringContent.endsWith('\n');
     }
     get length() {
-        return this.#at.part?.length ?? 0;
+        return this.stringContent.length;
     }
     /** Display offset of this segment inside its block's content (atoms count 1). */
     get segStart() {
-        return this.#at.part?.start ?? 0;
+        return this.#part?.start ?? 0;
     }
     /** The segment is shown by a live block. */
     get isInDocument() {
-        return this.parent.isInTree && this.#at.part !== undefined;
+        return this.parent.isInTree && this.#part !== undefined;
     }
     /**
      * Re-create this block's text elements from its cell — the repair of a
@@ -101,9 +99,8 @@ export class Text {
     /** @internal */
     attach = (node) => {
         this.node = node;
-        this.edytor.nodeToText.set(node, this);
         // Registered, it takes the attribute table's attributes (`surface/attributes.ts`).
-        const release = this.edytor.surface.register(node, 'text', this.parent.id);
+        const release = this.edytor.surface.register(node, 'text', this.parent.id, undefined, undefined, this);
         const pluginDestroy = cleanups(this.edytor.plugins, (plugin) => plugin.onTextAttached?.({ node, text: this }));
         // A display that waited for a mounted destination runs in the next pass.
         this.edytor.projector?.mounted(this);
@@ -111,8 +108,6 @@ export class Text {
             destroy: () => {
                 if (this.node === node)
                     this.node = undefined;
-                if (this.edytor.nodeToText.get(node) === this)
-                    this.edytor.nodeToText.delete(node);
                 release();
                 pluginDestroy.forEach((destroy) => destroy());
             }

package/dist/themes/notion.css

@@ -807,6 +807,35 @@
 	color: var(--notion-placeholder);
 }
 
+/*
+ * Shared suggestions: a block a suggestion made or proposes to delete
+ * (`data-edytor-suggested`), and its runs in the overlay, in its author's
+ * colour (`--edytor-range-color`).
+ */
+.edytor-notion [data-edytor-suggested='inserted'],
+.edytor-notion [data-edytor-suggested='split'] {
+	box-shadow: inset 2px 0 0 var(--edytor-suggestion-inserted, rgb(68 131 97));
+	background: var(--edytor-suggestion-inserted-background, rgba(68, 131, 97, 0.07));
+}
+.edytor-notion [data-edytor-suggested='removed'] {
+	background: var(--edytor-suggestion-removed);
+}
+.edytor-notion [data-edytor-suggested='removed'] [data-edytor-text] {
+	text-decoration: line-through;
+	text-decoration-color: var(--edytor-suggestion-removed-line, rgba(235, 87, 87, 0.6));
+}
+:is(.edytor-notion, .edytor-notion + [data-edytor-overlay]) [data-edytor-suggestion-inserted] {
+	border-bottom: 2px solid var(--edytor-range-color, rgb(68 131 97));
+	background: color-mix(in srgb, var(--edytor-range-color, rgb(68 131 97)) 10%, transparent);
+}
+:is(.edytor-notion, .edytor-notion + [data-edytor-overlay]) [data-edytor-suggestion-deleted] {
+	background: linear-gradient(
+		transparent calc(50% - 1px),
+		var(--edytor-range-color, rgb(235 87 87)) calc(50% - 1px) calc(50% + 1px),
+		transparent calc(50% + 1px)
+	);
+}
+
 /* ── Page (a subpage link) and table of contents ────────────────────── */
 .edytor-notion [data-edytor-type='page'] {
 	margin: 1px 0;

package/dist/utils.d.ts

@@ -1,4 +1,9 @@
 export declare const id: (prefix: "t" | "b" | "i" | "v" | "s" | "c") => string;
+/** `key`'s value in `map`, made (`make`) and stored when it holds none. */
+export declare const getOr: <K, V>(map: {
+    get(key: K): V | undefined;
+    set(key: K, value: V): unknown;
+}, key: K, make: () => V) => V;
 /**
  * A hook's veto as the dispatcher carries it: what `prevent(cb?)` recorded,
  * and the extension that recorded it. Hooks never see one thrown at them:

package/dist/utils.js

@@ -6,6 +6,13 @@ export const id = (prefix) => {
         t += alphabet[61 & r[n]];
     return `${prefix}_${t}`;
 };
+/** `key`'s value in `map`, made (`make`) and stored when it holds none. */
+export const getOr = (map, key, make) => {
+    let value = map.get(key);
+    if (value === undefined)
+        map.set(key, (value = make()));
+    return value;
+};
 /**
  * A hook's veto as the dispatcher carries it: what `prevent(cb?)` recorded,
  * and the extension that recorded it. Hooks never see one thrown at them:

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "edytor",
 	"license": "MIT",
-	"version": "4.0.0",
+	"version": "6.0.0",
 	"repository": {
 		"type": "git",
 		"url": "git+https://github.com/beynar/edytor.git"
@@ -23,6 +23,7 @@
 		"check:deps": "node scripts/deps.mjs",
 		"check:docs": "node scripts/check-docs.mjs",
 		"check:api": "node scripts/api-report.mjs --check",
+		"check:size": "node scripts/bundle-size.mjs --budget bundle-budget.json --top 0",
 		"api:report": "node scripts/api-report.mjs",
 		"check:watch": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json --watch",
 		"lint": "prettier --check . && eslint .",
@@ -50,6 +51,7 @@
 		"bench:browser": "node bench/browser.js",
 		"bench:runs": "BENCH_RUNS=1 vitest --config ./vitest.crdt.config.ts --run src/tests/crdt/runs/runs.bench.test.ts",
 		"size": "node scripts/bundle-size.mjs --by dir",
+		"bundle:attribution": "node scripts/bundle-attribution.mjs",
 		"registry:build": "shadcn-svelte registry build ./registry.json --output site/public/r",
 		"check:registry": "node scripts/check-registry.mjs",
 		"test:registry-install": "sh tests/registry-install/run.sh",

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

@@ -1,56 +0,0 @@
-/**
- * Structural capability: one answer in advance and at execution.
- *
- * ── Island/void enforcement (operation-layer, not stored) ──────────────
- *
- * Roles are resolved operation-time via `config.roleOf(type)`, through one
- * role table (`DisplayRoles`) that the index's display and every guard
- * below ask of a block's shown kind — the editor derives them from plugin
- * block definitions, exactly like the baseline's
- * `block.definition.island/void`. They are deliberately NOT replicated block
- * data: the schema stays policy-free, and a replica with different plugins
- * reads the same document. Enforced rules (baseline semantics, see
- * `plugins.ts` + `block.utils.ts`):
- *
- * - `void`: cannot accept children (insert/move/nest into void rejected),
- *   cannot merge either direction, cannot be split. Content edits ARE
- *   allowed — void rendered content (captions) stays editable per the
- *   baseline contract. Deletion is allowed (delete is not editing).
- * - `island`: editable content, but its subtree is structurally sealed —
- *   a block inside an island (`insideIsland`) cannot be moved, nested,
- *   unnested, or merged across the island boundary. Merges INSIDE one
- *   island are allowed; merging an island child into the island itself is
- *   allowed when the island renders its content. Moving or merging
- *   INTO an island subtree is rejected. An island declared `lines` (code)
- *   holds only lines of its `defaultChild` kind, and a line holds no
- *   children (the display enforces it against undo,
- *   `insertBlocks` refuses a line parent); any other island keeps its
- *   structure. `canPlace` and `canMerge` are the one answer, asked in
- *   advance or by the ops.
- * - Island merge: when an island block itself is merged (backward or
- *   forward), its children are unnested to the vacated sibling slot and
- *   reset to the default child of that slot's parent (`defaultChild`).
- * - Baseline merges NEVER adopt the merged block's children — they unnest
- *   to the vacated slot. The facade exposes both: `mergeBlocks` is the
- *   engine primitive (children adopt into the target
- *   by staying under the source, which the target's claim displays),
- *   `mergeBackward`/`mergeForward` reproduce the baseline command shape.
- *
- */
-import { type BlockId } from '../placement/model.js';
-import type { DocBase, DocReads } from './reads.js';
-/** The capability of the facade over its reads. */
-export declare const docCapability: (c: DocBase & DocReads) => {
-    canPlace: (ids: readonly BlockId[], parent?: BlockId | null, kindOf?: (id: BlockId) => string | undefined) => boolean;
-    isContainer: (id: BlockId) => boolean;
-    fits: (parent: BlockId | null, kind: string | undefined) => boolean;
-    fitsIn: (parentType: string, kind: string | undefined) => boolean;
-    fitted: (parent: BlockId | null, kind: string | undefined) => string | undefined;
-    emptiable: (id: BlockId) => boolean;
-    nestParent: (ids: readonly BlockId[], parent: BlockId) => BlockId;
-    canMerge: (fromId: BlockId, intoId: BlockId) => boolean;
-    rendersContent: (id: BlockId) => boolean;
-    defaultChild: (parent: BlockId | null) => string;
-    kindToCopy: (id: BlockId) => string;
-};
-export type DocCapability = ReturnType<typeof docCapability>;

package/dist/crdt/doc/capability.js

@@ -1,211 +0,0 @@
-/**
- * Structural capability: one answer in advance and at execution.
- *
- * ── Island/void enforcement (operation-layer, not stored) ──────────────
- *
- * Roles are resolved operation-time via `config.roleOf(type)`, through one
- * role table (`DisplayRoles`) that the index's display and every guard
- * below ask of a block's shown kind — the editor derives them from plugin
- * block definitions, exactly like the baseline's
- * `block.definition.island/void`. They are deliberately NOT replicated block
- * data: the schema stays policy-free, and a replica with different plugins
- * reads the same document. Enforced rules (baseline semantics, see
- * `plugins.ts` + `block.utils.ts`):
- *
- * - `void`: cannot accept children (insert/move/nest into void rejected),
- *   cannot merge either direction, cannot be split. Content edits ARE
- *   allowed — void rendered content (captions) stays editable per the
- *   baseline contract. Deletion is allowed (delete is not editing).
- * - `island`: editable content, but its subtree is structurally sealed —
- *   a block inside an island (`insideIsland`) cannot be moved, nested,
- *   unnested, or merged across the island boundary. Merges INSIDE one
- *   island are allowed; merging an island child into the island itself is
- *   allowed when the island renders its content. Moving or merging
- *   INTO an island subtree is rejected. An island declared `lines` (code)
- *   holds only lines of its `defaultChild` kind, and a line holds no
- *   children (the display enforces it against undo,
- *   `insertBlocks` refuses a line parent); any other island keeps its
- *   structure. `canPlace` and `canMerge` are the one answer, asked in
- *   advance or by the ops.
- * - Island merge: when an island block itself is merged (backward or
- *   forward), its children are unnested to the vacated sibling slot and
- *   reset to the default child of that slot's parent (`defaultChild`).
- * - Baseline merges NEVER adopt the merged block's children — they unnest
- *   to the vacated slot. The facade exposes both: `mergeBlocks` is the
- *   engine primitive (children adopt into the target
- *   by staying under the source, which the target's claim displays),
- *   `mergeBackward`/`mergeForward` reproduce the baseline command shape.
- *
- */
-import { isLiveIn } from '../placement/model.js';
-/** The capability of the facade over its reads. */
-export const docCapability = (c) => {
-    const { roles, rendersContentOf, view, blockTypeOf, childrenIds, positionOf, ancestorsOf, isVoid, isIsland, islandOf, insideIsland, holdsLayout, insideItem, isRowKind, isCellKind, displayLength } = c;
-    // ── structural capability: one answer in advance and at execution ──
-    /**
-     * May `ids` be placed under `parent` (`null` = the root)? Every id is
-     * live, distinct and outside any island interior (island subtrees are
-     * sealed); the destination is live, neither void nor an island nor
-     * inside one, and not inside any moved block's own subtree; and every
-     * block fits it as the kind `kindOf` gives (`fits`; a move keeps its
-     * kind) or already sits in it (a reorder changes nothing a list holds:
-     * an image shed into a list still moves among its items); and
-     * no layout, nor a block holding one, lands inside a layout item
-     * (`layout.nest`). A table's cell never moves, and its row only
-     * within its table (`table.fits`).
-     * Without a `parent`: may these blocks move at all (the drag
-     * affordance). The move ops refuse exactly when this answers `false`.
-     * (`insertBlock` is looser — island interiors are built by inserting
-     * into them.)
-     */
-    const canPlace = (ids, parent, kindOf = blockTypeOf) => {
-        const v = view();
-        if (ids.length === 0 || new Set(ids).size !== ids.length)
-            return false;
-        if (ids.some((id) => !isLiveIn(v, id) || insideIsland(id, v)))
-            return false;
-        // A cell moves only with its column, never as a block (`table.fits`).
-        if (ids.some((id) => isCellKind(blockTypeOf(id))))
-            return false;
-        // A row moves only within its table: a table's rows are reordered, never re-homed.
-        const rows = ids.filter((id) => isRowKind(blockTypeOf(id)));
-        if (rows.length > 0 && parent !== undefined)
-            if (parent === null || rows.some((id) => positionOf(id)?.parent !== parent))
-                return false;
-        if (parent === undefined || parent === null)
-            return true;
-        if (!isLiveIn(v, parent) || isVoid(parent))
-            return false;
-        const stays = (id) => positionOf(id)?.parent === parent;
-        if (!ids.every((id) => stays(id) || fits(parent, kindOf(id))))
-            return false;
-        if (insideItem(parent, v) && ids.some(holdsLayout))
-            return false;
-        return ![parent, ...ancestorsOf(parent, v)].some((a) => isIsland(a) || ids.includes(a));
-    };
-    /**
-     * A container: a block that shows only its children — no content of
-     * its own, neither void nor an island (a list, a table row, a column).
-     */
-    const isContainer = (id) => !rendersContent(id) && !isVoid(id) && !isIsland(id);
-    /**
-     * THE container rule: may a block of `kind` sit directly
-     * under `parent` (`null` = the root)? A container whose default child is
-     * a kind of its own — its item (a list's `list-item`, a columns
-     * layout's `column`) — holds only its items, and containers of them
-     * when the item renders content (a list directly in a list, from JSON
-     * or the API; a layout holds no layout, `layout.fits`); one whose
-     * default child is the document's (a column) holds any block. Every
-     * structural placement asks it: a move is refused where its blocks do
-     * not fit (`canPlace`), Tab nests under a container's last item
-     * (`nestParent`), an outdent or a lift is refused where the block would
-     * not fit, and a block a merge, delete or range sheds into a container
-     * takes its item kind when it is a plain block (`fitted`). Explicit kind
-     * writes (`insertBlocks`, a retype) place what they are told (the
-     * view's Turn into places the kind where it fits first, `liftOut`); a
-     * plain block stored directly in a list still shows as its item (the
-     * index's `typeOf`), whatever write or race put it there.
-     */
-    const fits = (parent, kind) => parent === null || fitsIn(blockTypeOf(parent) ?? '', kind);
-    /** `fits`, by the parent's kind (a block not written yet: `placeBeside`'s new item). */
-    const fitsIn = (parentType, kind) => {
-        if (!roles.container(parentType))
-            return true;
-        const item = roles.defaultChild(parentType);
-        if (item === defaultChild(null) || kind === item)
-            return true;
-        return (kind !== undefined &&
-            roles.container(kind) &&
-            roles.defaultChild(kind) === item &&
-            rendersContentOf(item));
-    };
-    /**
-     * `kind`, or — where a plain block (the document's default kind, or
-     * none: a pasted run) does not fit `parent` — `parent`'s item, when
-     * that renders content (a paragraph landing in a list is its item; one
-     * in a columns layout keeps its kind: its text never vanishes). Any
-     * other kind keeps its kind and data wherever a merge, a delete or a
-     * paste sheds it — an image under a bullet stays an image, a heading a
-     * heading, a to-do keeps its check — as a peer's
-     * concurrent promotion shows it (`typeOf` resets only the default
-     * kind); an outdent or a move that would place one directly in a list
-     * is refused (`fits`).
-     */
-    const fitted = (parent, kind) => {
-        if (fits(parent, kind) || (kind !== undefined && kind !== defaultChild(null)))
-            return kind;
-        const item = defaultChild(parent);
-        return rendersContentOf(item) ? item : kind;
-    };
-    /** A container that goes once it loses every child: it holds no text of its own (a peer's retype can leave some, hidden: it renders none). */
-    const emptiable = (id) => isContainer(id) && displayLength(id) === 0;
-    /**
-     * Where `ids` nest when nested into `parent` (Tab, a drop inside it):
-     * `parent`, or — a container they are no items of — its last child,
-     * and so on down. Tab after a list nests under its last item (Notion);
-     * a last child that holds no children (an image, a code block) is
-     * answered as it is, and `canPlace` refuses it, as Tab right under
-     * that block is refused.
-     */
-    const nestParent = (ids, parent) => {
-        let at = parent;
-        while (!ids.every((id) => fits(at, blockTypeOf(id)))) {
-            const last = childrenIds(at).at(-1);
-            if (last === undefined)
-                break;
-            at = last;
-        }
-        return at;
-    };
-    /**
-     * May `fromId`'s content merge into `intoId`? Both live and distinct,
-     * neither void, `intoId` renders its content (a list, a table row or a
-     * code block shows none, so a first item, cell or line never merges
-     * into it), `fromId` renders its own unless it is
-     * an island (a list or a row never merges as a whole: its items would
-     * leave it, `del.merge.container`), and the merge stays on one side of an island
-     * boundary (a block may merge into its own island root — that stays
-     * inside — but nothing from outside merges into an island).
-     */
-    const canMerge = (fromId, intoId) => {
-        const v = view();
-        if (fromId === intoId || !isLiveIn(v, fromId) || !isLiveIn(v, intoId))
-            return false;
-        if (isVoid(fromId) || isVoid(intoId))
-            return false;
-        // Nothing merges into or out of a table's cell (`table.merge`).
-        if (isCellKind(blockTypeOf(fromId)) || isCellKind(blockTypeOf(intoId)))
-            return false;
-        if (!rendersContent(intoId) || !(rendersContent(fromId) || isIsland(fromId)))
-            return false;
-        const islandFrom = islandOf(fromId, v);
-        if (intoId === islandFrom)
-            return true;
-        return islandFrom === islandOf(intoId, v) && !isIsland(intoId);
-    };
-    /** `id`'s shown kind renders its content. */
-    const rendersContent = (id) => rendersContentOf(blockTypeOf(id) ?? '');
-    /** The adopted default child type under `parent` (`null` = the root). */
-    const defaultChild = (parent) => roles.defaultChild(parent === null ? null : (blockTypeOf(parent) ?? null));
-    /**
-     * The kind a new block copies from `id` (a split tail, a flow's tail,
-     * a duplicate and each of its descendants). A type a peer's retype is
-     * replacing can be missing while its new value is pending: the copy
-     * then takes its parent's default child, never a missing type
-     * (it showed as `unknown` everywhere, for good).
-     */
-    const kindToCopy = (id) => blockTypeOf(id) ?? defaultChild(positionOf(id)?.parent ?? null);
-    return {
-        canPlace,
-        isContainer,
-        fits,
-        fitsIn,
-        fitted,
-        emptiable,
-        nestParent,
-        canMerge,
-        rendersContent,
-        defaultChild,
-        kindToCopy
-    };
-};

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

@@ -1,16 +0,0 @@
-import type { BlockId, InlineSpec } from '../placement/model.js';
-import type { Prepared } from './types.js';
-import type { OpsContext } from './steps.js';
-/** An inline atom to insert: its id is minted when it names none. */
-export type NewInline = Omit<InlineSpec, 'id'> & {
-    id?: string;
-};
-/** The content ops of one facade, prepared. */
-export declare const contentOps: (c: OpsContext) => {
-    insertText: (id: BlockId, offset: number, text: string, marks?: Record<string, unknown>) => Prepared;
-    deleteText: (id: BlockId, offset: number, length: number) => Prepared;
-    formatRange: (id: BlockId, offset: number, length: number, marks: Record<string, unknown>) => Prepared;
-    clearMarks: (id: BlockId, offset: number, length: number) => Prepared;
-    insertInline: (id: BlockId, offset: number, atom: NewInline) => Prepared;
-    removeInline: (id: BlockId, inlineId: string) => Prepared;
-};

package/dist/crdt/doc/content.js

@@ -1,77 +0,0 @@
-/**
- * Content ops: text and inline atoms in a block's display (allowed
- * inside voids — the caption contract), and marks over a range.
- */
-import { sanitizeWireJson, jsonEquals } from '../../utils/json.js';
-import { id as newId } from '../../utils.js';
-import { ref, sanitizeInline } from './plan.js';
-/** The content ops of one facade, prepared. */
-export const contentOps = (c) => {
-    const { contentTarget, REFUSED, plan, clamp, atomOf, textIn } = c;
-    // content ops (allowed inside voids — caption contract)
-    const insertText = (id, offset, text, marks) => {
-        id = ref(id);
-        const clean = ref(text);
-        if (!contentTarget(id))
-            return REFUSED;
-        const [at] = clamp(id, offset, 0);
-        const m = marks && sanitizeWireJson(marks);
-        return plan([id], clean === '' ? [] : [{ op: 'insertText', id, offset: at, text: clean, marks: m }]);
-    };
-    const deleteText = (id, offset, length) => {
-        id = ref(id);
-        if (!contentTarget(id))
-            return REFUSED;
-        const [at, end] = clamp(id, offset, length);
-        return plan([id], end > at ? [{ op: 'deleteText', id, offset: at, length: end - at }] : []);
-    };
-    /**
-     * Multi-mark format over a range (values may be null = unset); planned
-     * only when some text atom in the range carries a different value.
-     */
-    const formatRange = (id, offset, length, marks) => {
-        id = ref(id);
-        const clean = sanitizeWireJson(marks);
-        if (!contentTarget(id))
-            return REFUSED;
-        const [at, end] = clamp(id, offset, length);
-        // Planned only when some text atom carries another value (the same-value guard).
-        const differs = textIn(id, at, end).some((item) => Object.keys(clean).some((k) => !jsonEquals(item.marks?.[k] ?? null, clean[k] ?? null)));
-        return plan([id], differs ? [{ op: 'formatRange', id, offset: at, length: end - at, marks: clean }] : []);
-    };
-    /**
-     * Baseline `removeMarksFromText`: every mark present anywhere in the
-     * range is unset over the range. Names are discovered from the content.
-     */
-    const clearMarks = (id, offset, length) => {
-        const clears = {};
-        for (const item of textIn(ref(id), offset, offset + length)) {
-            for (const k of Object.keys(item.marks ?? {}))
-                clears[k] = null;
-        }
-        return formatRange(id, offset, length, clears);
-    };
-    /** An atom without an id gets a fresh one. */
-    const insertInline = (id, offset, atom) => {
-        id = ref(id);
-        const clean = sanitizeInline({ ...atom, id: atom.id ?? newId('i') });
-        if (!contentTarget(id))
-            return REFUSED;
-        return plan([id], [{ op: 'insertInline', id, offset: clamp(id, offset, 0)[0], atom: clean }]);
-    };
-    const removeInline = (id, inlineId) => {
-        id = ref(id);
-        const atom = atomOf(id, ref(inlineId));
-        if (atom === undefined)
-            return REFUSED;
-        return plan([id], [{ op: 'removeInline', id, offset: atom.at, inlineId: ref(inlineId) }]);
-    };
-    return {
-        insertText,
-        deleteText,
-        formatRange,
-        clearMarks,
-        insertInline,
-        removeInline
-    };
-};

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

@@ -1,15 +0,0 @@
-/**
- * Block deletion (`del.blocks.promote`): only the members leave, the
- * unselected children of a deleted block take its slot.
- */
-import type { BlockId } from '../placement/model.js';
-import type { Prepared } from './types.js';
-import type { OpsContext } from './steps.js';
-/** The delete ops of one facade, prepared. */
-export declare const deleteOps: (c: OpsContext) => {
-    deleteBlocks: (ids: readonly BlockId[], subtree?: boolean, filled?: BlockId | null) => Prepared;
-    deleteBlock: (id: BlockId, opts?: {
-        keepChildren?: boolean;
-    }) => Prepared;
-};
-export type DeleteOps = ReturnType<typeof deleteOps>;