phormat 0.0.5

package/dist/editor/model/blockTree.d.ts

@@ -0,0 +1,39 @@
+import type { EditorBlock, EditorBlockType, EditorDocument } from './types';
+/** Indices into nested {@link EditorBlock.children} from document root downward. */
+export type TreePath = readonly number[];
+export type BlockLocation = {
+    block: EditorBlock;
+    parent: EditorBlock | null;
+    siblings: EditorBlock[];
+    index: number;
+    /** Index in {@link EditorDocument.blocks} for the root ancestor of this node. */
+    topLevelIndex: number;
+    path: TreePath;
+};
+export declare function nestingAllowlistFor(parent: EditorBlock | null): ReadonlySet<EditorBlockType> | null;
+export declare function canNestUnder(parent: EditorBlock | null, childType: EditorBlockType): boolean;
+export declare function blockCanMoveSibling(blocks: EditorBlock[], blockId: string, direction: 'up' | 'down'): boolean;
+export declare function blockTreeDepth(blocks: EditorBlock[], blockId: string): number;
+export declare function deepCloneBlock(block: EditorBlock): EditorBlock;
+export declare function deepCloneBlocks(blocks: EditorBlock[]): EditorBlock[];
+export declare function findBlockLocation(blocks: EditorBlock[], blockId: string, parent?: EditorBlock | null, siblings?: EditorBlock[], pathPrefix?: TreePath): BlockLocation | null;
+export declare function findBlockInDocument(doc: EditorDocument, blockId: string): BlockLocation | null;
+/** Relative index from `anchorId` to `focusId` among the same parent's children. */
+export declare function siblingIndexOffset(blocks: EditorBlock[], anchorId: string, focusId: string): number | null;
+export declare function blockAtSiblingOffset(blocks: EditorBlock[], anchorId: string, offset: number): EditorBlock | null;
+/** Contiguous top-level {@link EditorBlock.type} `listItem` run containing `startIndex`. */
+export declare function listRegionBounds(blocks: EditorBlock[], startIndex: number): {
+    start: number;
+    end: number;
+};
+export declare function listRegionBoundsForBlockId(blocks: EditorBlock[], blockId: string): {
+    start: number;
+    end: number;
+} | null;
+export declare function sourceRangeForBlockSpan(blocks: EditorBlock[], start: number, end: number, source: string): {
+    start: number;
+    end: number;
+} | null;
+export declare function normalizeListOrdinalsInItems(items: EditorBlock[]): void;
+export declare function normalizeListOrdinalsForest(blocks: EditorBlock[]): void;
+export declare function blockAtPath(blocks: EditorBlock[], path: TreePath): EditorBlock | null;

package/dist/editor/model/blockTree.js

@@ -0,0 +1,185 @@
+const LIST_ITEM_CHILD_TYPES = new Set([
+    'listItem',
+    'paragraph',
+    'blockquote',
+    'codeFence',
+    'callout',
+    'toggle'
+]);
+const PARAGRAPH_CHILD_TYPES = LIST_ITEM_CHILD_TYPES;
+const BLOCKQUOTE_CHILD_TYPES = new Set([
+    'blockquote',
+    'listItem',
+    'paragraph',
+    'codeFence',
+    'callout',
+    'toggle'
+]);
+const CALLOUT_CHILD_TYPES = BLOCKQUOTE_CHILD_TYPES;
+const ROOT_CHILD_TYPES = new Set([
+    'heading',
+    'paragraph',
+    'codeFence',
+    'listItem',
+    'blockquote',
+    'horizontalRule',
+    'table',
+    'callout',
+    'toggle',
+    'columns',
+    'toc'
+]);
+export function nestingAllowlistFor(parent) {
+    if (parent === null)
+        return ROOT_CHILD_TYPES;
+    switch (parent.type) {
+        case 'listItem':
+            return LIST_ITEM_CHILD_TYPES;
+        case 'paragraph':
+            return PARAGRAPH_CHILD_TYPES;
+        case 'blockquote':
+            return BLOCKQUOTE_CHILD_TYPES;
+        case 'callout':
+            return CALLOUT_CHILD_TYPES;
+        default:
+            return null;
+    }
+}
+export function canNestUnder(parent, childType) {
+    const allow = nestingAllowlistFor(parent);
+    return allow?.has(childType) ?? false;
+}
+export function blockCanMoveSibling(blocks, blockId, direction) {
+    const loc = findBlockLocation(blocks, blockId);
+    if (!loc)
+        return false;
+    const newIdx = direction === 'up' ? loc.index - 1 : loc.index + 1;
+    return newIdx >= 0 && newIdx < loc.siblings.length;
+}
+export function blockTreeDepth(blocks, blockId) {
+    return findBlockLocation(blocks, blockId)?.path.length ?? 0;
+}
+export function deepCloneBlock(block) {
+    return {
+        ...block,
+        data: typeof block.data === 'object' && block.data !== null && !Array.isArray(block.data)
+            ? { ...block.data }
+            : block.data,
+        inlines: block.inlines?.map((n) => ({ ...n })),
+        children: block.children?.map(deepCloneBlock)
+    };
+}
+export function deepCloneBlocks(blocks) {
+    return blocks.map(deepCloneBlock);
+}
+export function findBlockLocation(blocks, blockId, parent = null, siblings = blocks, pathPrefix = []) {
+    for (let i = 0; i < siblings.length; i++) {
+        const block = siblings[i];
+        const path = [...pathPrefix, i];
+        const topLevelIndex = path[0] ?? i;
+        if (block.id === blockId) {
+            return { block, parent, siblings, index: i, topLevelIndex, path };
+        }
+        if (block.children?.length) {
+            const found = findBlockLocation(blocks, blockId, block, block.children, path);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}
+export function findBlockInDocument(doc, blockId) {
+    return findBlockLocation(doc.blocks, blockId);
+}
+/** Relative index from `anchorId` to `focusId` among the same parent's children. */
+export function siblingIndexOffset(blocks, anchorId, focusId) {
+    const anchor = findBlockLocation(blocks, anchorId);
+    const focus = findBlockLocation(blocks, focusId);
+    if (!anchor || !focus || anchor.siblings !== focus.siblings)
+        return null;
+    return focus.index - anchor.index;
+}
+export function blockAtSiblingOffset(blocks, anchorId, offset) {
+    const anchor = findBlockLocation(blocks, anchorId);
+    if (!anchor)
+        return null;
+    return anchor.siblings[anchor.index + offset] ?? null;
+}
+/** Contiguous top-level {@link EditorBlock.type} `listItem` run containing `startIndex`. */
+export function listRegionBounds(blocks, startIndex) {
+    if (startIndex < 0 || startIndex >= blocks.length || blocks[startIndex]?.type !== 'listItem') {
+        return { start: startIndex, end: startIndex };
+    }
+    let start = startIndex;
+    while (start > 0 && blocks[start - 1]?.type === 'listItem')
+        start--;
+    let end = startIndex + 1;
+    while (end < blocks.length && blocks[end]?.type === 'listItem')
+        end++;
+    return { start, end };
+}
+export function listRegionBoundsForBlockId(blocks, blockId) {
+    const loc = findBlockLocation(blocks, blockId);
+    if (!loc || loc.parent !== null)
+        return null;
+    return listRegionBounds(blocks, loc.index);
+}
+export function sourceRangeForBlockSpan(blocks, start, end, source) {
+    const first = blocks[start];
+    const last = blocks[end - 1];
+    if (!first || !last)
+        return null;
+    if (first.sourceRange.start < 0 || last.sourceRange.end < 0)
+        return null;
+    return { start: first.sourceRange.start, end: last.sourceRange.end };
+}
+export function normalizeListOrdinalsInItems(items) {
+    let n = 1;
+    for (const item of items) {
+        if (item.type !== 'listItem')
+            continue;
+        const d = item.data;
+        if (d.ordered) {
+            item.data = { ...d, ordered: true, ordinalValue: n++ };
+        }
+        for (const ch of item.children ?? []) {
+            if (ch.type === 'listItem')
+                normalizeListOrdinalsInItems([ch]);
+            else if (ch.children?.length)
+                walkBlockTree(ch);
+        }
+    }
+}
+function walkBlockTree(block) {
+    if (block.type === 'listItem' && block.children?.length) {
+        const listItems = block.children.filter((c) => c.type === 'listItem');
+        if (listItems.length)
+            normalizeListOrdinalsInItems(block.children);
+    }
+    for (const ch of block.children ?? [])
+        walkBlockTree(ch);
+}
+export function normalizeListOrdinalsForest(blocks) {
+    const runs = [];
+    for (let i = 0; i < blocks.length; i++) {
+        if (blocks[i]?.type === 'listItem') {
+            const b = listRegionBounds(blocks, i);
+            runs.push(b);
+            i = b.end - 1;
+        }
+    }
+    for (const { start, end } of runs) {
+        normalizeListOrdinalsInItems(blocks.slice(start, end));
+    }
+    for (const b of blocks)
+        walkBlockTree(b);
+}
+export function blockAtPath(blocks, path) {
+    if (path.length === 0)
+        return null;
+    let node = blocks[path[0]];
+    for (let i = 1; i < path.length; i++) {
+        node = node?.children?.[path[i]];
+    }
+    return node ?? null;
+}

package/dist/editor/model/blockTreeDrop.d.ts

@@ -0,0 +1,9 @@
+import type { TransactionBuildResult } from './editorTransactions';
+import type { EditorBlock, EditorDocument, EditorOperation } from './types';
+export type TreeDropPlacement = 'before' | 'after' | 'nest' | 'outdent';
+export declare function buildStructuralReplaceOps(source: string, oldBlocks: EditorBlock[], newBlocks: EditorBlock[]): EditorOperation[];
+export declare function applyBlockTreeDrop(blocks: EditorBlock[], draggedId: string, targetId: string, placement: TreeDropPlacement): EditorBlock[] | null;
+export declare function canBlockTreeDrop(blocks: EditorBlock[], draggedId: string, targetId: string, placement: TreeDropPlacement): boolean;
+export declare function blockTreeDropTransaction(source: string, doc: EditorDocument, draggedId: string, targetId: string, placement: TreeDropPlacement): TransactionBuildResult;
+/** Tab / Shift+Tab reparent for any block in the document tree. */
+export declare function tabReparentBlockTransaction(source: string, doc: EditorDocument, blockId: string, shift: boolean): TransactionBuildResult;

package/dist/editor/model/blockTreeDrop.js

@@ -0,0 +1,295 @@
+import { serializeListRegion } from '../block-specs/list/serialize';
+import { canNestUnder, deepCloneBlocks, findBlockLocation, listRegionBounds, normalizeListOrdinalsForest, sourceRangeForBlockSpan } from './blockTree';
+import { insertSiblingRelative, isDescendantBlock, nestUnderTarget, removeBlockFromTree } from './blockTreeMutations';
+import { moveBlockToIndex, normalizeBlockSliceReplacement } from './blockEditCommands';
+import { serializeEditorBlock, serializeMarkdownDocument } from './serializeMarkdownDocument';
+function topLevelSegments(blocks) {
+    const segs = [];
+    let i = 0;
+    while (i < blocks.length) {
+        const b = blocks[i];
+        if (b.type === 'listItem') {
+            const { start, end } = listRegionBounds(blocks, i);
+            segs.push({ startIdx: start, endIdx: end, anchorId: blocks[start].id });
+            i = end;
+        }
+        else {
+            segs.push({ startIdx: i, endIdx: i + 1, anchorId: b.id });
+            i++;
+        }
+    }
+    return segs;
+}
+function serializeTopLevelSeg(blocks, seg, source) {
+    const { startIdx, endIdx } = seg;
+    if (startIdx >= endIdx || startIdx >= blocks.length)
+        return null;
+    if (blocks[startIdx]?.type === 'listItem') {
+        return serializeListRegion(blocks.slice(startIdx, endIdx), source);
+    }
+    if (endIdx - startIdx !== 1)
+        return null;
+    const block = blocks[startIdx];
+    if (block.sourceRange.synthetic || block.sourceRange.start < 0)
+        return null;
+    return serializeEditorBlock(block, source);
+}
+function oldSourceEndBeforeSegment(oldBlocks, newBlocks, newSeg, source) {
+    if (newSeg.startIdx === 0) {
+        const first = oldBlocks[0];
+        return first && first.sourceRange.start >= 0 ? first.sourceRange.start : 0;
+    }
+    for (let i = newSeg.startIdx - 1; i >= 0; i--) {
+        const prev = newBlocks[i];
+        const oldLoc = findBlockLocation(oldBlocks, prev.id);
+        if (!oldLoc)
+            continue;
+        if (oldLoc.parent !== null) {
+            const top = oldBlocks[oldLoc.topLevelIndex];
+            if (top?.sourceRange.end >= 0)
+                return top.sourceRange.end;
+            continue;
+        }
+        if (prev.type === 'listItem') {
+            const bounds = listRegionBounds(oldBlocks, oldLoc.index);
+            const last = oldBlocks[bounds.end - 1];
+            if (last?.sourceRange.end >= 0)
+                return last.sourceRange.end;
+        }
+        else if (oldLoc.block.sourceRange.end >= 0) {
+            return oldLoc.block.sourceRange.end;
+        }
+    }
+    return source.length;
+}
+function sourceSliceForSegment(source, blocks, seg) {
+    const range = sourceRangeForBlockSpan(blocks, seg.startIdx, seg.endIdx, source);
+    return range ? source.slice(range.start, range.end) : null;
+}
+function gapBetweenOldSegments(source, oldBlocks, left, right) {
+    const leftRange = sourceRangeForBlockSpan(oldBlocks, left.startIdx, left.endIdx, source);
+    const rightRange = sourceRangeForBlockSpan(oldBlocks, right.startIdx, right.endIdx, source);
+    if (!leftRange || !rightRange)
+        return null;
+    return source.slice(leftRange.end, rightRange.start);
+}
+function buildWholeDocumentReplaceOp(source, oldBlocks, newBlocks, oldSegs, newSegs) {
+    const docRange = sourceRangeForBlockSpan(oldBlocks, 0, oldBlocks.length, source);
+    if (!docRange)
+        return [];
+    const oldByAnchor = new Map(oldSegs.map((seg, idx) => [seg.anchorId, { seg, idx }]));
+    let text = '';
+    for (let i = 0; i < newSegs.length; i++) {
+        const newSeg = newSegs[i];
+        const oldMatch = oldByAnchor.get(newSeg.anchorId);
+        if (i > 0) {
+            const prevOldMatch = oldByAnchor.get(newSegs[i - 1].anchorId);
+            const adjacentOldGap = prevOldMatch && oldMatch && oldMatch.idx === prevOldMatch.idx + 1
+                ? gapBetweenOldSegments(source, oldBlocks, prevOldMatch.seg, oldMatch.seg)
+                : null;
+            text += adjacentOldGap ?? '\n\n';
+        }
+        const newText = serializeTopLevelSeg(newBlocks, newSeg, source);
+        if (newText === null)
+            return [];
+        const oldText = oldMatch ? serializeTopLevelSeg(oldBlocks, oldMatch.seg, source) : null;
+        const preservedText = oldMatch && oldText === newText
+            ? sourceSliceForSegment(source, oldBlocks, oldMatch.seg)
+            : null;
+        text += preservedText ?? newText;
+    }
+    if (text === source.slice(docRange.start, docRange.end))
+        return [];
+    return [{ type: 'replaceSlice', range: docRange, text }];
+}
+export function buildStructuralReplaceOps(source, oldBlocks, newBlocks) {
+    const oldSegs = topLevelSegments(oldBlocks);
+    const newSegs = topLevelSegments(newBlocks);
+    const newByAnchor = new Map(newSegs.map((s) => [s.anchorId, s]));
+    const oldAnchors = new Set(oldSegs.map((s) => s.anchorId));
+    const ops = [];
+    for (const oldSeg of oldSegs) {
+        const range = sourceRangeForBlockSpan(oldBlocks, oldSeg.startIdx, oldSeg.endIdx, source);
+        if (!range)
+            continue;
+        const newSeg = newByAnchor.get(oldSeg.anchorId);
+        if (!newSeg) {
+            ops.push({ type: 'replaceSlice', range, text: '' });
+            continue;
+        }
+        const oldText = serializeTopLevelSeg(oldBlocks, oldSeg, source);
+        const newText = serializeTopLevelSeg(newBlocks, newSeg, source);
+        if (oldText === null || newText === null)
+            continue;
+        if (oldText !== newText) {
+            ops.push({ type: 'replaceSlice', range, text: newText });
+        }
+    }
+    for (const newSeg of newSegs) {
+        if (oldAnchors.has(newSeg.anchorId))
+            continue;
+        const newText = serializeTopLevelSeg(newBlocks, newSeg, source);
+        if (newText === null)
+            continue;
+        const insertPos = oldSourceEndBeforeSegment(oldBlocks, newBlocks, newSeg, source);
+        if (insertPos === null)
+            continue;
+        const prefix = insertPos > 0 && newSeg.startIdx > 0 ? '\n\n' : '';
+        ops.push({
+            type: 'replaceSlice',
+            range: { start: insertPos, end: insertPos },
+            text: prefix + newText
+        });
+    }
+    if (ops.length > 1) {
+        return buildWholeDocumentReplaceOp(source, oldBlocks, newBlocks, oldSegs, newSegs);
+    }
+    ops.sort((a, b) => b.range.start - a.range.start);
+    return ops;
+}
+export function applyBlockTreeDrop(blocks, draggedId, targetId, placement) {
+    if (draggedId === targetId && placement !== 'nest')
+        return null;
+    const clone = deepCloneBlocks(blocks);
+    const draggedLocBefore = findBlockLocation(clone, draggedId);
+    if (!draggedLocBefore)
+        return null;
+    if (placement === 'outdent' && !draggedLocBefore.parent)
+        return null;
+    if (placement === 'nest' &&
+        (draggedId === targetId || isDescendantBlock(clone, draggedId, targetId))) {
+        return null;
+    }
+    const removed = removeBlockFromTree(clone, draggedId);
+    if (!removed)
+        return null;
+    if (placement === 'outdent') {
+        const parentId = draggedLocBefore.parent.id;
+        const parentLoc = findBlockLocation(clone, parentId);
+        if (!parentLoc)
+            return null;
+        if (!canNestUnder(parentLoc.parent, removed.type))
+            return null;
+        parentLoc.siblings.splice(parentLoc.index + 1, 0, removed);
+        normalizeListOrdinalsForest(clone);
+        return clone;
+    }
+    const targetLoc = findBlockLocation(clone, targetId);
+    if (!targetLoc)
+        return null;
+    if (placement === 'nest') {
+        if (!nestUnderTarget(clone, targetLoc, removed))
+            return null;
+    }
+    else if (!canNestUnder(targetLoc.parent, removed.type)) {
+        return null;
+    }
+    else {
+        insertSiblingRelative(clone, targetLoc, removed, placement);
+    }
+    normalizeListOrdinalsForest(clone);
+    return clone;
+}
+export function canBlockTreeDrop(blocks, draggedId, targetId, placement) {
+    return applyBlockTreeDrop(deepCloneBlocks(blocks), draggedId, targetId, placement) !== null;
+}
+export function blockTreeDropTransaction(source, doc, draggedId, targetId, placement) {
+    const nextBlocks = applyBlockTreeDrop(doc.blocks, draggedId, targetId, placement);
+    if (!nextBlocks)
+        return { ok: false, error: 'Block tree drop failed.' };
+    if (placement === 'nest' || placement === 'outdent') {
+        const draggedLocAfter = findBlockLocation(nextBlocks, draggedId);
+        const nextSource = serializeMarkdownDocument({ ...doc, source, blocks: nextBlocks });
+        if (nextSource === source) {
+            return { ok: false, error: 'Block tree drop made no source changes.' };
+        }
+        const caret = Math.min(draggedLocAfter?.block.sourceRange.start ?? 0, nextSource.length);
+        return {
+            ok: true,
+            transaction: {
+                id: `block-tree-drop:${draggedId}:${placement}:${targetId}`,
+                operations: [
+                    {
+                        type: 'replaceSlice',
+                        range: { start: 0, end: source.length },
+                        text: nextSource
+                    }
+                ],
+                selection: { anchor: caret, focus: caret }
+            }
+        };
+    }
+    const ops = buildStructuralReplaceOps(source, doc.blocks, nextBlocks);
+    if (ops.length === 0) {
+        const fromIndex = doc.blocks.findIndex((b) => b.id === draggedId);
+        const toIndex = nextBlocks.findIndex((b) => b.id === draggedId);
+        const sameTopLevelSet = doc.blocks.length === nextBlocks.length &&
+            doc.blocks.every((b) => nextBlocks.some((n) => n.id === b.id));
+        if (fromIndex >= 0 &&
+            toIndex >= 0 &&
+            fromIndex !== toIndex &&
+            sameTopLevelSet) {
+            const moved = moveBlockToIndex(source, doc, fromIndex, toIndex);
+            if (!moved.ok)
+                return { ok: false, error: moved.error };
+            const range = sourceRangeForBlockSpan(doc.blocks, 0, doc.blocks.length, source);
+            if (!range)
+                return { ok: false, error: 'Block tree drop has no source span.' };
+            const text = normalizeBlockSliceReplacement(source, range.start, range.end, moved.source.slice(range.start, range.end));
+            return {
+                ok: true,
+                transaction: {
+                    id: `block-tree-drop:${draggedId}:${placement}:${targetId}`,
+                    operations: [{ type: 'replaceSlice', range, text }],
+                    selection: moved.selection
+                }
+            };
+        }
+        return { ok: false, error: 'Block tree drop made no source changes.' };
+    }
+    let caret = doc.blocks[0]?.sourceRange.start ?? 0;
+    const caretLoc = findBlockLocation(nextBlocks, draggedId);
+    if (caretLoc?.block.sourceRange.start !== undefined && caretLoc.block.sourceRange.start >= 0) {
+        caret = caretLoc.block.sourceRange.start;
+    }
+    // Serialized block text omits the trailing newline that `sourceRange.end` covers; bake the
+    // normalization into the operations so the blank-line break after the slice is preserved.
+    const normalizedOps = ops.map((op) => op.type === 'replaceSlice'
+        ? {
+            ...op,
+            text: normalizeBlockSliceReplacement(source, op.range.start, op.range.end, op.text)
+        }
+        : op);
+    let nextSource = source;
+    for (const op of [...normalizedOps].sort((a, b) => b.range.start - a.range.start)) {
+        if (op.type === 'replaceSlice') {
+            nextSource = nextSource.slice(0, op.range.start) + op.text + nextSource.slice(op.range.end);
+        }
+    }
+    caret = Math.min(caret, nextSource.length);
+    return {
+        ok: true,
+        transaction: {
+            id: `block-tree-drop:${draggedId}:${placement}:${targetId}`,
+            operations: normalizedOps,
+            selection: { anchor: caret, focus: caret }
+        }
+    };
+}
+/** Tab / Shift+Tab reparent for any block in the document tree. */
+export function tabReparentBlockTransaction(source, doc, blockId, shift) {
+    const loc = findBlockLocation(doc.blocks, blockId);
+    if (!loc)
+        return { ok: false, error: 'Block not found.' };
+    if (shift) {
+        if (!loc.parent)
+            return { ok: false, error: 'Cannot outdent.' };
+        return blockTreeDropTransaction(source, doc, blockId, loc.parent.id, 'outdent');
+    }
+    if (loc.index === 0)
+        return { ok: false, error: 'Cannot nest.' };
+    const prev = loc.siblings[loc.index - 1];
+    if (!prev)
+        return { ok: false, error: 'Cannot nest.' };
+    return blockTreeDropTransaction(source, doc, blockId, prev.id, 'nest');
+}

package/dist/editor/model/blockTreeMutations.d.ts

@@ -0,0 +1,10 @@
+import { type BlockLocation } from './blockTree';
+import type { EditorBlock } from './types';
+export declare function isDescendantBlock(blocks: EditorBlock[], ancestorId: string, candidateId: string): boolean;
+export declare function removeBlockFromTree(blocks: EditorBlock[], blockId: string): EditorBlock | null;
+/** Promote one level: insert after parent in parent's siblings (Shift+Tab / outdent). */
+export declare function promoteOneLevel(blocks: EditorBlock[], blockId: string): EditorBlock[] | null;
+/** Nest under previous sibling (Tab on listItem). */
+export declare function nestUnderPreviousSibling(blocks: EditorBlock[], blockId: string, canNest?: (parent: EditorBlock, child: EditorBlock) => boolean): EditorBlock[] | null;
+export declare function insertSiblingRelative(blocks: EditorBlock[], targetLoc: BlockLocation, block: EditorBlock, placement: 'before' | 'after'): void;
+export declare function nestUnderTarget(blocks: EditorBlock[], targetLoc: BlockLocation, block: EditorBlock): boolean;

package/dist/editor/model/blockTreeMutations.js

@@ -0,0 +1,68 @@
+import { canNestUnder, deepCloneBlocks, findBlockLocation, normalizeListOrdinalsForest } from './blockTree';
+export function isDescendantBlock(blocks, ancestorId, candidateId) {
+    if (ancestorId === candidateId)
+        return true;
+    const ancestor = findBlockLocation(blocks, ancestorId);
+    if (!ancestor?.block.children?.length)
+        return false;
+    for (const child of ancestor.block.children) {
+        if (child.id === candidateId || isDescendantBlock(blocks, child.id, candidateId))
+            return true;
+    }
+    return false;
+}
+export function removeBlockFromTree(blocks, blockId) {
+    const loc = findBlockLocation(blocks, blockId);
+    if (!loc)
+        return null;
+    const [removed] = loc.siblings.splice(loc.index, 1);
+    return removed ?? null;
+}
+/** Promote one level: insert after parent in parent's siblings (Shift+Tab / outdent). */
+export function promoteOneLevel(blocks, blockId) {
+    const clone = deepCloneBlocks(blocks);
+    const loc = findBlockLocation(clone, blockId);
+    if (!loc?.parent)
+        return null;
+    const parentLoc = findBlockLocation(clone, loc.parent.id);
+    if (!parentLoc)
+        return null;
+    const removed = removeBlockFromTree(clone, blockId);
+    if (!removed)
+        return null;
+    if (!canNestUnder(parentLoc.parent, removed.type))
+        return null;
+    parentLoc.siblings.splice(parentLoc.index + 1, 0, removed);
+    normalizeListOrdinalsForest(clone);
+    return clone;
+}
+/** Nest under previous sibling (Tab on listItem). */
+export function nestUnderPreviousSibling(blocks, blockId, canNest = (parent, child) => canNestUnder(parent, child.type)) {
+    const clone = deepCloneBlocks(blocks);
+    const loc = findBlockLocation(clone, blockId);
+    if (!loc || loc.index === 0)
+        return null;
+    const removed = removeBlockFromTree(clone, blockId);
+    if (!removed)
+        return null;
+    const prev = loc.siblings[loc.index - 1];
+    if (!prev || !canNest(prev, removed))
+        return null;
+    if (!prev.children)
+        prev.children = [];
+    prev.children.push(removed);
+    normalizeListOrdinalsForest(clone);
+    return clone;
+}
+export function insertSiblingRelative(blocks, targetLoc, block, placement) {
+    const insertIdx = targetLoc.index + (placement === 'after' ? 1 : 0);
+    targetLoc.siblings.splice(insertIdx, 0, block);
+}
+export function nestUnderTarget(blocks, targetLoc, block) {
+    if (!canNestUnder(targetLoc.block, block.type))
+        return false;
+    if (!targetLoc.block.children)
+        targetLoc.block.children = [];
+    targetLoc.block.children.push(block);
+    return true;
+}

package/dist/editor/model/calloutEditCommands.d.ts

@@ -0,0 +1,39 @@
+import { type TreePath } from './blockTree';
+import type { EditorBlock } from './types';
+import type { EditorDocument } from './types';
+import type { TransactionBuildResult } from './editorTransactions';
+export type CalloutPath = TreePath;
+declare const EMPTY_PARAGRAPH_AFTER = "\n\n \n\n";
+export declare function calloutBodySyntheticParagraphId(calloutId: string): string;
+export declare function isCalloutBodySyntheticParagraphId(blockId: string): boolean;
+export declare function makeEmptyCalloutParagraph(): EditorBlock;
+export declare function makeCalloutBodySyntheticParagraph(calloutId: string): EditorBlock;
+/** Write the first empty `> ` body line for an opener-only callout. */
+export declare function ensureCalloutEmptyBodyTransaction(source: string, doc: EditorDocument, calloutBlockIndex: number): TransactionBuildResult;
+export declare function nodeAtCalloutPath(root: EditorBlock, path: CalloutPath): EditorBlock | null;
+/** Path from callout root to any descendant block id (excluding the callout root itself). */
+export declare function findCalloutDescendantPath(root: EditorBlock, blockId: string): CalloutPath | null;
+export declare function calloutParagraphDisplayPlain(block: EditorBlock): string;
+export declare function calloutChildCanMoveSibling(root: EditorBlock, blockId: string, direction: 'up' | 'down'): boolean;
+export declare function calloutMoveSibling(root: EditorBlock, blockId: string, direction: 'up' | 'down'): EditorBlock | null;
+export declare function calloutDeleteChild(root: EditorBlock, blockId: string): EditorBlock | null;
+export declare function calloutDuplicateChild(root: EditorBlock, blockId: string): EditorBlock | null;
+export declare function calloutSiblingIndexOffset(root: EditorBlock, anchorId: string, focusId: string): number | null;
+export declare function siblingFocusIdForCalloutDelete(root: EditorBlock, blockId: string): string | undefined;
+export type CalloutParagraphEnterResult = {
+    root: EditorBlock;
+    focusBlockId: string;
+    exitToParagraph?: false;
+};
+export type CalloutExitResult = {
+    root: EditorBlock;
+    exitToParagraph: true;
+};
+export declare function calloutParagraphEnterAtPlain(root: EditorBlock, blockId: string, offset: number, plainText: string): CalloutParagraphEnterResult | CalloutExitResult | null;
+export declare function calloutListItemEnterAtPlain(root: EditorBlock, itemId: string, offset: number, plainText: string, source: string): CalloutParagraphEnterResult | CalloutExitResult | null;
+export declare function calloutBlockquoteEnterAtPlain(root: EditorBlock, blockId: string, offset: number, plainText: string, source: string): CalloutParagraphEnterResult | CalloutExitResult | null;
+export declare function calloutExitReplacementMarkdown(calloutMd: string, caretInCallout: number): {
+    replacement: string;
+    caret: number;
+};
+export { EMPTY_PARAGRAPH_AFTER };