@voithos-labs/aragonite 0.10.1

package/dist/editor-actions/reorder-drag.js

@@ -0,0 +1,152 @@
+/**
+ * Pointer drag-to-reorder: one delegated capture-phase pointerdown on the editor
+ * root, a ghost + insertion line while dragging (no tree mutation, no reflow), and
+ * ONE move committed on drop. The drop index resolves against currently-mounted
+ * siblings only; autoscroll brings off-viewport ones into the window.
+ */
+import { createPointerDragSession } from '../selection/pointer-session';
+import { readBlockPath } from '../selection/path-lookup';
+export function installReorderDrag(ctx) {
+    const root = ctx.editorRoot;
+    function onPointerDown(e) {
+        if (e.button !== 0)
+            return;
+        const target = e.target;
+        if (!target?.closest('.block-drag-handle'))
+            return;
+        const dragHost = target.closest('.reorder-host');
+        if (!dragHost)
+            return;
+        const session = startSession(ctx, dragHost);
+        if (!session)
+            return;
+        // Capture-phase + stopPropagation so the block's own pointerdown never starts a
+        // cross-block text selection; preventDefault keeps the handle from taking focus.
+        e.preventDefault();
+        e.stopPropagation();
+        session.begin(e);
+    }
+    root.addEventListener('pointerdown', onPointerDown, true);
+    let disposed = false;
+    function dispose() {
+        if (disposed)
+            return;
+        disposed = true;
+        root.removeEventListener('pointerdown', onPointerDown, true);
+    }
+    if (ctx.lifetimeSignal) {
+        if (ctx.lifetimeSignal.aborted) {
+            dispose();
+            return { dispose };
+        }
+        ctx.lifetimeSignal.addEventListener('abort', dispose, { once: true });
+    }
+    return { dispose };
+}
+// ── Drag session ─────────────────────────────────────────────────────────────
+function startSession(ctx, dragHost) {
+    const fromPath = pathFor(dragHost);
+    const fromIndex = indexOf(dragHost);
+    const group = dragHost.parentElement;
+    if (!fromPath || fromIndex === null || !group)
+        return null;
+    const siblingSelector = dragHost.classList.contains('list-item-block')
+        ? '.list-item-block'
+        : '.block-host';
+    const label = ghostLabel(dragHost);
+    // The container this unit reorders within (null at top level). Marked for the
+    // drag's duration so the scope-locked reorder reads as intentional, not broken.
+    const scopeEl = dragHost.closest('.list-block, .blockquote-block');
+    let dropTo = null;
+    function siblings() {
+        const out = [];
+        for (const el of Array.from(group.children)) {
+            if (!(el instanceof HTMLElement))
+                continue;
+            if (!el.matches(siblingSelector) || !el.classList.contains('reorder-host'))
+                continue;
+            const index = indexOf(el);
+            if (index !== null)
+                out.push({ index, rect: el.getBoundingClientRect() });
+        }
+        out.sort((a, b) => a.index - b.index);
+        return out;
+    }
+    function process(clientX, clientY) {
+        const sibs = siblings();
+        // rawR = the original index to drop before. Removing the dragged item shifts
+        // later indices down by one, hence the adjustment so a downward drop lands
+        // where the line showed.
+        let rawR = sibs.length ? sibs[sibs.length - 1].index + 1 : fromIndex + 1;
+        let line = sibs.length
+            ? {
+                left: sibs[sibs.length - 1].rect.left,
+                top: sibs[sibs.length - 1].rect.bottom,
+                width: sibs[sibs.length - 1].rect.width
+            }
+            : null;
+        for (const s of sibs) {
+            if (clientY < s.rect.top + s.rect.height / 2) {
+                rawR = s.index;
+                line = { left: s.rect.left, top: s.rect.top, width: s.rect.width };
+                break;
+            }
+        }
+        dropTo = rawR <= fromIndex ? rawR : rawR - 1;
+        ctx.overlay.setGhost({ clientX, clientY, label });
+        if (line)
+            ctx.overlay.setLine(line);
+    }
+    return {
+        begin(down) {
+            scopeEl?.classList.add('reorder-scope');
+            createPointerDragSession(down, {
+                onMove: (p) => process(p.clientX, p.clientY),
+                // A drop commits only on release, never on cancel/Escape/unmount.
+                onEnd: (reason) => {
+                    if (reason === 'up' && dropTo !== null && dropTo !== fromIndex) {
+                        void ctx.moveReorderUnit(fromPath, dropTo);
+                    }
+                },
+                onTeardown: () => {
+                    scopeEl?.classList.remove('reorder-scope');
+                    ctx.overlay.setGhost(null);
+                    ctx.overlay.setLine(null);
+                },
+                autoScroll: {
+                    getTargets: () => {
+                        const host = ctx.getScrollHost();
+                        return host ? [host] : [];
+                    }
+                },
+                escape: true,
+                disableUserSelect: true,
+                lifetimeSignal: ctx.lifetimeSignal
+            });
+            // Paint from the press point before any move, so a no-move release still
+            // commits a drop.
+            process(down.clientX, down.clientY);
+        }
+    };
+}
+// ── Element → path / index ───────────────────────────────────────────────────
+// A `.list-item-block` carries no `data-block-path`, so borrow a descendant
+// block-host's — resolveReorderUnit climbs back to the list item either way.
+function pathFor(host) {
+    if (host.getAttribute('data-block-path'))
+        return readBlockPath(host);
+    return readBlockPath(host.querySelector('[data-block-path]'));
+}
+// A block-host's own path tail; for a list item, its inner content path's
+// second-to-last entry.
+function indexOf(host) {
+    if (host.getAttribute('data-block-path'))
+        return readBlockPath(host)?.at(-1) ?? null;
+    return readBlockPath(host.querySelector('[data-block-path]'))?.at(-2) ?? null;
+}
+function ghostLabel(host) {
+    const text = (host.textContent ?? '').trim().replace(/\s+/g, ' ');
+    if (!text)
+        return 'block';
+    return text.length > 40 ? text.slice(0, 40) + '…' : text;
+}

package/dist/editor-actions/replacement-focus.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Shared helpers for `updateBlockContent`'s structural arm: the pre-commit reparse
+ * probe that picks structural-vs-typing, and the post-commit caret restore.
+ */
+import { updateNodeContent } from '../tree-operations';
+import { type SettledContent } from '../tree-operations/node-ops';
+import { type AnyBlockKind } from '../core/nodes';
+import type { NodeView } from '../core/node-views';
+import type { StructuralChange } from '../tree-operations/structural-change';
+import type { CommitScope } from './block-edit-scope';
+/**
+ * Preview the content update on a throwaway single-node probe to pick between the structural
+ * commit and the routine typing path; the live tree is untouched. `tailSuffix` is the document's
+ * folded trailing line when `node` is the tail block, else `''`: blanking the tail materializes
+ * it, which is structural and must route into the ceremony.
+ */
+export declare function previewContentReparse(node: NodeView, text: string, grammar: Parameters<typeof updateNodeContent>[3], ownerKind: AnyBlockKind | undefined, tailSuffix: string): StructuralChange;
+/**
+ * Restore the caret after a structural content commit. A no-op when focus already moved on.
+ */
+export declare function focusAfterContentReplace(scopePath: number[], at: number, settled: SettledContent, focusOffset: number, scope: CommitScope): void;
+/**
+ * A typing commit needs the caret restored; a BLUR commit (source folding as focus
+ * lands elsewhere) must not yank it back. The discriminator is where focus lives at
+ * afterTick time — a `data-block-path` outside the replaced window means it moved on.
+ */
+export declare function focusMovedOutsideReplacement(scopePath: number[], at: number, count: number): boolean;

package/dist/editor-actions/replacement-focus.js

@@ -0,0 +1,60 @@
+/**
+ * Shared helpers for `updateBlockContent`'s structural arm: the pre-commit reparse
+ * probe that picks structural-vs-typing, and the post-commit caret restore.
+ */
+import { updateNodeContent } from '../tree-operations';
+import { settledCaretTarget } from '../tree-operations/node-ops';
+import { makeBlockNode } from '../core/nodes';
+import { readBlockPath } from '../selection/path-lookup';
+// ── Reparse probe ────────────────────────────────────────────────────────────
+/**
+ * Preview the content update on a throwaway single-node probe to pick between the structural
+ * commit and the routine typing path; the live tree is untouched. `tailSuffix` is the document's
+ * folded trailing line when `node` is the tail block, else `''`: blanking the tail materializes
+ * it, which is structural and must route into the ceremony.
+ */
+export function previewContentReparse(node, text, grammar, ownerKind, tailSuffix) {
+    const probe = makeBlockNode({
+        kind: node.kind,
+        leadingTrivia: node.leadingTrivia,
+        raw: node.raw
+    });
+    // The owner KIND rides along or the probe answers about different bytes than the commit
+    // writes; the owner node stays out — a probe must not write real wrap slots. The suffix
+    // rides by VALUE for the same reason: the probe's settle may only spend the copy.
+    return updateNodeContent({ children: [probe], ownerKind, owner: undefined, suffix: tailSuffix }, 0, text, grammar).change;
+}
+// ── Post-replacement focus ───────────────────────────────────────────────────
+/**
+ * Restore the caret after a structural content commit. A no-op when focus already moved on.
+ */
+export function focusAfterContentReplace(scopePath, at, settled, focusOffset, scope) {
+    const { change } = settled;
+    const count = change.op === 'replace' ? change.newCount : 1;
+    // The settled window, not the slot the gesture named: a fold above moved both.
+    const windowAt = change.op === 'replace' ? change.at : at;
+    if (focusMovedOutsideReplacement(scopePath, windowAt, count))
+        return;
+    const target = settledCaretTarget(settled, at, focusOffset, scope.children());
+    scope.refAt(target.index)?.focus(target.offset);
+}
+/**
+ * A typing commit needs the caret restored; a BLUR commit (source folding as focus
+ * lands elsewhere) must not yank it back. The discriminator is where focus lives at
+ * afterTick time — a `data-block-path` outside the replaced window means it moved on.
+ */
+export function focusMovedOutsideReplacement(scopePath, at, count) {
+    if (typeof document === 'undefined')
+        return false;
+    const host = document.activeElement?.closest?.('[data-block-path]') ?? null;
+    // No locatable path reads as "a remount ate the focused el", so run the restore.
+    const path = readBlockPath(host);
+    if (!path)
+        return false;
+    for (let depth = 0; depth < scopePath.length; depth++) {
+        if (path[depth] !== scopePath[depth])
+            return true;
+    }
+    const index = path[scopePath.length];
+    return index === undefined || index < at || index >= at + count;
+}

package/dist/editor-actions/search-replace.d.ts

@@ -0,0 +1,6 @@
+import type { Match } from '../search/document-scan';
+import type { EditorActionsDeps, UndoController } from './deps';
+export declare function createSearchReplace(deps: EditorActionsDeps, controller: UndoController): {
+    replaceOne: (match: Match, template: string) => Promise<number>;
+    replaceAll: (matches: Match[], template: string) => Promise<number>;
+};

package/dist/editor-actions/search-replace.js

@@ -0,0 +1,145 @@
+import { parse } from '../core/parser';
+import { cloneNode } from '../tree-operations/clone';
+import { spliceMany } from '../tree-operations/splice-many';
+import { getBlockKindDescriptor } from '../schema/block-kind-descriptor';
+import { normalizeBodyWrite, normalizeReplacementTrivia, writeOwnRaw } from '../tree-operations/node-ops';
+import { rebuildAncestryRaw } from '../schema/container-raw';
+import { replacePreservingFirst, stampStructuralChange } from '../tree-operations/structural-change';
+import { applyRangesToText } from '../search/replace';
+import { toEditEvent } from '../editor-events';
+import { docPathFrom } from '../cursor/coordinate-spaces';
+function descend(root, rel) {
+    let node = root;
+    for (const i of rel)
+        node = node?.children?.[i];
+    return node ?? null;
+}
+function groupBy(matches, key) {
+    const groups = new Map();
+    for (const m of matches) {
+        const k = key(m);
+        let g = groups.get(k);
+        if (!g) {
+            g = [];
+            groups.set(k, g);
+        }
+        g.push(m);
+    }
+    return groups;
+}
+export function createSearchReplace(deps, controller) {
+    // Reparse top-level child `topIndex` with its descendant matches substituted.
+    function buildSubtree(topIndex, matches, template) {
+        const child = cloneNode(deps.doc.children[topIndex]);
+        const byLeaf = groupBy(matches, (m) => m.path.slice(1).join(','));
+        for (const ranges of byLeaf.values()) {
+            const rel = ranges[0].path.slice(1);
+            const leaf = descend(child, rel);
+            if (!leaf)
+                continue;
+            // Reparsing a private clone bypasses `updateNodeContent`, so that sink's two byte
+            // rules — the kind's own raw rule and the owner's bodyWrite escape — apply here.
+            const owner = rel.length > 0 ? descend(child, rel.slice(0, -1)) : null;
+            const substituted = normalizeBodyWrite(owner?.kind, applyRangesToText(leaf.raw, ranges, template));
+            writeOwnRaw(leaf, substituted, deps.grammar);
+        }
+        // A nested leaf's edit must propagate up the clone's materialized container raw
+        // before the reparse from `child.raw`; a top-level leaf needs none.
+        for (const ranges of byLeaf.values()) {
+            const rel = ranges[0].path.slice(1);
+            if (rel.length > 0)
+                rebuildAncestryRaw(child, rel);
+        }
+        const newNodes = parse(child.raw, { grammar: deps.grammar, scope: 'fragment' }).children;
+        // leadingTrivia is positional and lives off `raw`, so parsing `child.raw` alone drops it.
+        return normalizeReplacementTrivia(child, newNodes);
+    }
+    /**
+     * A match can land on a container node itself. A CHILDLESS one scanned as a leaf, and this
+     * path reparses rather than writing in place — so the kind re-derives its own metadata from
+     * the substituted bytes and nothing goes stale. One with children is excluded: its raw is a
+     * rebuild of theirs, and substituting into it would drift (G1.12/G1.13).
+     */
+    function isReplaceable(match) {
+        const top = deps.doc.children[match.path[0]];
+        const node = top ? descend(top, match.path.slice(1)) : null;
+        if (!node)
+            return false;
+        return !getBlockKindDescriptor(node.kind).isContainer || (node.children?.length ?? 0) === 0;
+    }
+    /**
+     * The one hazard the reparse cannot absorb: a substitution that breaks a container's opener
+     * line comes back as a different kind entirely — a diagram silently becoming a plain code
+     * block. Accepted for leaves, declined here.
+     */
+    function keepsItsKind(before, after) {
+        // Only where the substitution wrote the container's OWN raw — a childless one, scanned as a
+        // leaf. One with children had a CHILD edited, and re-kinding there is the ordinary
+        // structural replace every leaf already gets.
+        const childless = (before.children?.length ?? 0) === 0;
+        if (!childless || !getBlockKindDescriptor(before.kind).isContainer)
+            return true;
+        return after.length === 1 && after[0].kind === before.kind;
+    }
+    async function replaceSubtrees(matches, template) {
+        const replaceable = matches.filter(isReplaceable);
+        const groups = groupBy(replaceable, (m) => m.path[0]);
+        const indices = [...groups.keys()].sort((a, b) => b - a); // last-first keeps lower indices valid
+        if (indices.length === 0)
+            return 0;
+        const seed = groups.get(indices[indices.length - 1])[0];
+        // One pushed snapshot + per-subtree skip-commits = one undo entry, so a throw
+        // mid-batch still recovers in one Ctrl+Z. Intentional.
+        // The push happens outside the commit ceremony, so its rollback register is ours too: a
+        // batch whose FIRST subtree throws applies nothing and must leave no entry behind, or the
+        // next Ctrl+Z spends itself restoring the document to where it already is.
+        const stacksBeforePush = deps.undoManager.getStacks();
+        controller.pushUndoSnapshotPath(seed.path, seed.start);
+        let newBlockCount = 0;
+        let applied = 0;
+        for (const topIndex of indices) {
+            const group = groups.get(topIndex);
+            let newNodes;
+            try {
+                newNodes = buildSubtree(topIndex, group, template);
+            }
+            catch (error) {
+                // buildSubtree dispatches into the kind's `rebuildRaw` — plugin code running
+                // outside every commit ceremony, so nothing else would attribute this.
+                deps.events.emit('error', {
+                    origin: 'commit',
+                    error,
+                    context: { op: 'replaceBlock', path: docPathFrom([topIndex]) }
+                });
+                break;
+            }
+            if (!keepsItsKind(deps.doc.children[topIndex], newNodes))
+                continue;
+            newBlockCount += newNodes.length;
+            applied += group.length;
+            await controller.commitStructural({
+                snapshot: 'skip', // batch shares the single snapshot pushed above
+                mutate: (children) => {
+                    spliceMany(children, topIndex, 1, newNodes);
+                    const change = replacePreservingFirst(topIndex, 1, newNodes.length);
+                    stampStructuralChange(children, change, deps.sharing);
+                    return change;
+                }
+                // op omitted → no per-commit edit event; one is emitted after the batch
+            });
+        }
+        if (applied === 0) {
+            deps.undoManager.restoreStacks(stacksBeforePush);
+            return 0;
+        }
+        // A single-subtree replace has one operated node, so the aggregate event carries
+        // its doc-absolute path (editor.md §12); a multi-subtree batch genuinely has none.
+        const eventPath = indices.length === 1 ? docPathFrom([indices[0]]) : [];
+        deps.events.emit('edit', toEditEvent({ kind: 'replaceBlock', detail: { count: newBlockCount } }, eventPath, Date.now()));
+        return applied;
+    }
+    return {
+        replaceOne: (match, template) => replaceSubtrees([match], template),
+        replaceAll: (matches, template) => replaceSubtrees(matches, template)
+    };
+}

package/dist/editor-actions/table-context.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The TableContext mutation bundle. The component keeps sticky-column state,
+ * focused-cell tracking, DOM helpers, and BlockComponent — only structural mutations
+ * live here.
+ */
+import type { CellPosition, ContainerEditActions, TableContext } from '../action-contracts';
+import type { NodeView } from '../core/node-views';
+import type { UndoController } from './deps';
+import type { BlockListState } from '../reactivity/block-list-state.svelte';
+/**
+ * The header (row 0) is positionally fixed. Null skips the commit, so a boundary
+ * press pushes no undo entry.
+ */
+export declare function tableRowReorderTarget(rowIdx: number, dir: -1 | 1, rowCount: number): number | null;
+/**
+ * Unlike rows, columns have no fixed header, so every index is a valid source and
+ * target and clamping spans the full range.
+ */
+export declare function tableColumnReorderTarget(colIdx: number, dir: -1 | 1, colCount: number): number | null;
+export interface TableMutationsContextDeps {
+    get node(): NodeView;
+    get myPath(): readonly number[];
+    get rowsState(): BlockListState;
+    get focusedCell(): {
+        rowIdx: number;
+        colIdx: number;
+    } | null;
+    parentContainerEdit: ContainerEditActions;
+    controller: UndoController;
+    focusCell: (rowIdx: number, colIdx: number, position: CellPosition) => void;
+    announceReorder: (message: string) => void;
+}
+export type TableMutationsContext = Pick<TableContext, 'insertRowAbove' | 'insertRowBelow' | 'insertColumnLeft' | 'insertColumnRight' | 'deleteRow' | 'deleteColumn' | 'reorderRowTo' | 'moveRowUp' | 'moveRowDown' | 'reorderColumnTo' | 'moveColumnLeft' | 'moveColumnRight' | 'cycleAlignment' | 'setColumnAlignment'>;
+export declare function createTableMutationsContext(deps: TableMutationsContextDeps): TableMutationsContext;