phormat 0.0.5

package/dist/editor/model/line-utils.js

@@ -0,0 +1,38 @@
+/** Split into lines with start/end indices in the original string (handles `\r`, `\r\n`, `\n`). */
+export function splitLinesWithOffsets(source) {
+    const rows = [];
+    let start = 0;
+    for (let i = 0; i < source.length;) {
+        const ch = source[i];
+        if (ch === '\r' || ch === '\n') {
+            rows.push({ line: source.slice(start, i), start, end: i });
+            i++;
+            if (ch === '\r' && source[i] === '\n')
+                i++;
+            start = i;
+        }
+        else {
+            i++;
+        }
+    }
+    rows.push({ line: source.slice(start, source.length), start, end: source.length });
+    return rows;
+}
+/** Line and character totals for editor chrome; uses the same line split as the parser. */
+export function sourceLineAndCharacterCount(source) {
+    return {
+        lineCount: splitLinesWithOffsets(source).length,
+        characterCount: source.length
+    };
+}
+/** Index just after the line's trailing `\r` / `\n` (or `source.length`). */
+export function afterLineTerminator(source, row) {
+    if (row.end >= source.length)
+        return source.length;
+    let p = row.end;
+    if (source[p] === '\r')
+        p++;
+    if (p < source.length && source[p] === '\n')
+        p++;
+    return p;
+}

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

@@ -0,0 +1,56 @@
+import { type TreePath } from './blockTree';
+import type { EditorBlock, TaskCheckboxState } from './types';
+export type ListPath = TreePath;
+export type ResolvedListItem = {
+    parent: EditorBlock | null;
+    siblings: EditorBlock[];
+    itemIndex: number;
+    item: EditorBlock;
+};
+export declare function deepCloneListRoot(block: EditorBlock): EditorBlock;
+export declare function listItemDisplayPlain(item: EditorBlock, source: string): string;
+/** @deprecated Use {@link listItemDisplayPlain} — same plain text the edit surface shows. */
+export declare function listItemBodyPlain(item: EditorBlock, source: string): string;
+export declare function setListItemBodyPlain(item: EditorBlock, plain: string): void;
+export declare function resolveListItem(blocks: EditorBlock[], path: ListPath): ResolvedListItem | null;
+/** @deprecated Pass document blocks; {@link resolveListItem} replaces container-root resolution. */
+export declare function resolveListItemFromRoot(rootList: EditorBlock, path: ListPath): ResolvedListItem | null;
+export declare function findListItemPath(blocks: EditorBlock[], itemId: string): ListPath | null;
+/** Increase nesting: item becomes last child of previous sibling listItem. */
+export declare function listIndentItem(blocks: EditorBlock[], itemId: string): EditorBlock[] | null;
+/** Move item one level up (insert after parent among its siblings). */
+export declare function listOutdentItem(blocks: EditorBlock[], itemId: string): EditorBlock[] | null;
+/** @deprecated Use {@link listSetTaskState} with **StatusCheckbox** cycle/snap. */
+export declare function listToggleTask(blocks: EditorBlock[], itemId: string): EditorBlock[] | null;
+export declare function listSetTaskState(blocks: EditorBlock[], itemId: string, task: TaskCheckboxState): EditorBlock[] | null;
+export type ListItemTaskBodyShortcutTrigger = 'space' | 'enter' | 'blur';
+/** Plain `[ ]` / `[x]` / … typed in a non-task **listItem** body (not the `-` leader). */
+export declare function isListItemTaskBodyShortcutPlain(plain: string): boolean;
+export declare function isListItemTaskBodyShortcutTrigger(plain: string, trigger: ListItemTaskBodyShortcutTrigger): boolean;
+/** Promote a non-task **listItem** when the body plain is a reserved task bracket prefix only. */
+export declare function listPromoteToTaskFromBodyShortcut(blocks: EditorBlock[], itemId: string, bodyPlain: string): EditorBlock[] | null;
+export type ListMergeWithPreviousResult = {
+    blocks: EditorBlock[];
+    focusBlockId: string;
+    joinPlainOffset: number;
+};
+export declare function listMergeWithPrevious(blocks: EditorBlock[], itemId: string, source: string): ListMergeWithPreviousResult | null;
+export declare function isEmptyListItemBody(item: EditorBlock, source: string, livePlain?: string): boolean;
+export declare function listDemoteEmptyItemAt(blocks: EditorBlock[], itemId: string): EditorBlock[] | null;
+export declare function listSplitItemAtPlain(blocks: EditorBlock[], itemId: string, offset: number, plainText: string, source: string): EditorBlock[] | null;
+export type ListEnterResult = {
+    blocks: EditorBlock[];
+    focusBlockId: string;
+    demoteToParagraph?: false;
+};
+export type ListDemotionResult = {
+    blocks: EditorBlock[];
+    demoteToParagraph: true;
+    focusBlockId: string;
+};
+export declare function listEnterAtPlain(blocks: EditorBlock[], itemId: string, offset: number, plainText: string, _source: string): ListEnterResult | ListDemotionResult | null;
+export declare function listMoveSibling(blocks: EditorBlock[], itemId: string, direction: 'up' | 'down'): EditorBlock[] | null;
+export declare function listDeleteItem(blocks: EditorBlock[], itemId: string): EditorBlock[] | null;
+export declare function listDuplicateItem(blocks: EditorBlock[], itemId: string): EditorBlock[] | null;
+export declare function listItemCanMoveSibling(blocks: EditorBlock[], itemId: string, direction: 'up' | 'down'): boolean;
+export declare function siblingFocusIdForListDelete(blocks: EditorBlock[], itemId: string): string | undefined;

package/dist/editor/model/listEditCommands.js

@@ -0,0 +1,299 @@
+import { taskCheckboxFromMarker } from '../block-specs/list/parse';
+import { paragraphBlockFromPlainText } from '../block-specs/paragraph/edit';
+import { deepCloneBlock, deepCloneBlocks, findBlockLocation, normalizeListOrdinalsForest } from './blockTree';
+import { nestUnderPreviousSibling, promoteOneLevel } from './blockTreeMutations';
+import { inlineTextNode } from './inlineEditCommands';
+import { inlineNodesToPlainText } from './inlinePlain';
+function syntheticRange() {
+    return { start: -1, end: -1, startLine: -1, endLine: -1, synthetic: true };
+}
+export function deepCloneListRoot(block) {
+    return deepCloneBlock(block);
+}
+export function listItemDisplayPlain(item, source) {
+    if (item.inlines?.length)
+        return inlineNodesToPlainText(item.inlines);
+    if (item.sourceRange.start >= 0 && !item.sourceRange.synthetic) {
+        const slice = source.slice(item.sourceRange.start, item.sourceRange.end);
+        const firstLine = slice.split('\n')[0] ?? '';
+        const taskUm = firstLine.match(/^\s*[-*+][ \t]+\[[^\]]+\][ \t]+(.*)$/);
+        const taskOm = firstLine.match(/^\s*\d+\.[ \t]+\[[^\]]+\][ \t]+(.*)$/);
+        const tm = taskUm ?? taskOm;
+        if (tm)
+            return (tm[1] ?? '').trimEnd();
+        const um = firstLine.match(/^\s*[-*+][ \t]+(.*)$/);
+        const om = firstLine.match(/^\s*\d+\.[ \t]+(.*)$/);
+        const m = um ?? om;
+        return (m ? m[1] : firstLine).trimEnd();
+    }
+    return '';
+}
+/** @deprecated Use {@link listItemDisplayPlain} — same plain text the edit surface shows. */
+export function listItemBodyPlain(item, source) {
+    return listItemDisplayPlain(item, source);
+}
+export function setListItemBodyPlain(item, plain) {
+    item.inlines = plain.length > 0 ? [inlineTextNode(plain)] : [];
+}
+export function resolveListItem(blocks, path) {
+    if (path.length === 0)
+        return null;
+    let siblings = blocks;
+    let parent = null;
+    for (let pi = 0; pi < path.length - 1; pi++) {
+        const node = siblings[path[pi]];
+        if (!node)
+            return null;
+        parent = node;
+        siblings = node.children ?? [];
+    }
+    const itemIndex = path[path.length - 1];
+    const item = siblings[itemIndex];
+    if (!item || item.type !== 'listItem')
+        return null;
+    return { parent, siblings, itemIndex, item };
+}
+/** @deprecated Pass document blocks; {@link resolveListItem} replaces container-root resolution. */
+export function resolveListItemFromRoot(rootList, path) {
+    if (rootList.type !== 'listItem')
+        return resolveListItem([rootList], path);
+    return resolveListItem([rootList], path);
+}
+export function findListItemPath(blocks, itemId) {
+    const loc = findBlockLocation(blocks, itemId);
+    if (!loc || loc.block.type !== 'listItem')
+        return null;
+    return loc.path;
+}
+function extractListItem(siblings, index) {
+    const [removed] = siblings.splice(index, 1);
+    return removed ?? null;
+}
+/** Increase nesting: item becomes last child of previous sibling listItem. */
+export function listIndentItem(blocks, itemId) {
+    return nestUnderPreviousSibling(blocks, itemId, (parent, child) => parent.type === 'listItem' && child.type === 'listItem');
+}
+/** Move item one level up (insert after parent among its siblings). */
+export function listOutdentItem(blocks, itemId) {
+    const loc = findBlockLocation(blocks, itemId);
+    if (!loc || loc.block.type !== 'listItem')
+        return null;
+    return promoteOneLevel(blocks, itemId);
+}
+/** @deprecated Use {@link listSetTaskState} with **StatusCheckbox** cycle/snap. */
+export function listToggleTask(blocks, itemId) {
+    const loc = findBlockLocation(blocks, itemId);
+    if (!loc || loc.block.type !== 'listItem')
+        return null;
+    const d = loc.block.data;
+    if (d.task === undefined)
+        return null;
+    const next = d.task === 'done' ? 'todo' : 'done';
+    return listSetTaskState(blocks, itemId, next);
+}
+export function listSetTaskState(blocks, itemId, task) {
+    const clone = deepCloneBlocks(blocks);
+    const loc = findBlockLocation(clone, itemId);
+    if (!loc || loc.block.type !== 'listItem')
+        return null;
+    const d = loc.block.data;
+    if (d.task === undefined)
+        return null;
+    loc.block.data = { ...d, task };
+    if (task !== 'other') {
+        delete loc.block.data.taskMarkerChar;
+    }
+    return clone;
+}
+const LIST_ITEM_TASK_BODY_MARKER_ONLY = /^\[([ xX/>])\]$/;
+const LIST_ITEM_TASK_BODY_COMPLETE = /^\[([ xX/>])\]\s+$/;
+/** Plain `[ ]` / `[x]` / … typed in a non-task **listItem** body (not the `-` leader). */
+export function isListItemTaskBodyShortcutPlain(plain) {
+    return LIST_ITEM_TASK_BODY_MARKER_ONLY.test(plain) || LIST_ITEM_TASK_BODY_COMPLETE.test(plain);
+}
+export function isListItemTaskBodyShortcutTrigger(plain, trigger) {
+    if (trigger === 'blur')
+        return LIST_ITEM_TASK_BODY_COMPLETE.test(plain);
+    return LIST_ITEM_TASK_BODY_MARKER_ONLY.test(plain);
+}
+/** Promote a non-task **listItem** when the body plain is a reserved task bracket prefix only. */
+export function listPromoteToTaskFromBodyShortcut(blocks, itemId, bodyPlain) {
+    const marker = bodyPlain.match(LIST_ITEM_TASK_BODY_MARKER_ONLY)?.[1];
+    if (marker === undefined)
+        return null;
+    const task = taskCheckboxFromMarker(marker);
+    if (task === 'other')
+        return null;
+    const clone = deepCloneBlocks(blocks);
+    const loc = findBlockLocation(clone, itemId);
+    if (!loc || loc.block.type !== 'listItem')
+        return null;
+    const d = loc.block.data;
+    if (d.task !== undefined)
+        return null;
+    loc.block.data = { ...d, task };
+    setListItemBodyPlain(loc.block, '');
+    return clone;
+}
+export function listMergeWithPrevious(blocks, itemId, source) {
+    const clone = deepCloneBlocks(blocks);
+    const loc = findBlockLocation(clone, itemId);
+    if (!loc || loc.index === 0 || loc.block.type !== 'listItem')
+        return null;
+    const prev = loc.siblings[loc.index - 1];
+    if (!prev || prev.type !== 'listItem')
+        return null;
+    const joinPlainOffset = listItemDisplayPlain(prev, source).replace(/[ \t]+$/, '').length;
+    const a = listItemBodyPlain(prev, source);
+    const b = listItemBodyPlain(loc.block, source);
+    setListItemBodyPlain(prev, a + b);
+    const childrenToReparent = loc.block.children ?? [];
+    if (childrenToReparent.length > 0) {
+        if (!prev.children)
+            prev.children = [];
+        prev.children.push(...childrenToReparent);
+    }
+    loc.siblings.splice(loc.index, 1);
+    normalizeListOrdinalsForest(clone);
+    return { blocks: clone, focusBlockId: prev.id, joinPlainOffset };
+}
+export function isEmptyListItemBody(item, source, livePlain) {
+    const plain = livePlain ?? listItemDisplayPlain(item, source);
+    return plain.trim().length === 0;
+}
+export function listDemoteEmptyItemAt(blocks, itemId) {
+    const result = listEnterAtPlain(blocks, itemId, 0, '', '');
+    if (!result || !('demoteToParagraph' in result) || !result.demoteToParagraph)
+        return null;
+    return result.blocks;
+}
+export function listSplitItemAtPlain(blocks, itemId, offset, plainText, source) {
+    const result = listEnterAtPlain(blocks, itemId, offset, plainText, source);
+    return result && !('demoteToParagraph' in result && result.demoteToParagraph) ? result.blocks : null;
+}
+function listItemToParagraph(item) {
+    const lineIndex = item.sourceRange.startLine >= 0 ? item.sourceRange.startLine : 0;
+    // Empty paragraphs need one source byte; otherwise serializing the demotion
+    // deletes the list line instead of materializing an editable paragraph.
+    const emptyParagraphPlain = ' ';
+    return {
+        type: 'paragraph',
+        id: item.id,
+        sourceRange: { ...item.sourceRange },
+        data: paragraphBlockFromPlainText(emptyParagraphPlain, lineIndex),
+        inlines: [],
+        children: item.children?.map(deepCloneBlock)
+    };
+}
+function makeEmptyListItemLike(item) {
+    const d = item.data;
+    const data = d.task !== undefined
+        ? { ...d, task: 'todo', taskMarkerChar: undefined }
+        : { ...d };
+    return {
+        type: 'listItem',
+        id: crypto.randomUUID(),
+        sourceRange: syntheticRange(),
+        data,
+        children: [],
+        inlines: []
+    };
+}
+export function listEnterAtPlain(blocks, itemId, offset, plainText, _source) {
+    const clone = deepCloneBlocks(blocks);
+    const loc = findBlockLocation(clone, itemId);
+    if (!loc || loc.block.type !== 'listItem')
+        return null;
+    const body = plainText;
+    if (body.trim().length === 0) {
+        const focusBlockId = loc.block.id;
+        loc.siblings[loc.index] = listItemToParagraph(loc.block);
+        normalizeListOrdinalsForest(clone);
+        return { blocks: clone, demoteToParagraph: true, focusBlockId };
+    }
+    if (offset <= 0) {
+        const newItem = makeEmptyListItemLike(loc.block);
+        loc.siblings.splice(loc.index, 0, newItem);
+        normalizeListOrdinalsForest(clone);
+        return { blocks: clone, focusBlockId: newItem.id };
+    }
+    if (offset >= body.length) {
+        const newItem = makeEmptyListItemLike(loc.block);
+        loc.siblings.splice(loc.index + 1, 0, newItem);
+        normalizeListOrdinalsForest(clone);
+        return { blocks: clone, focusBlockId: newItem.id };
+    }
+    const left = body.slice(0, offset);
+    const right = body.slice(offset);
+    setListItemBodyPlain(loc.block, left);
+    const newItem = makeEmptyListItemLike(loc.block);
+    setListItemBodyPlain(newItem, right);
+    loc.siblings.splice(loc.index + 1, 0, newItem);
+    normalizeListOrdinalsForest(clone);
+    return { blocks: clone, focusBlockId: newItem.id };
+}
+export function listMoveSibling(blocks, itemId, direction) {
+    const clone = deepCloneBlocks(blocks);
+    const loc = findBlockLocation(clone, itemId);
+    if (!loc || loc.block.type !== 'listItem')
+        return null;
+    const newIdx = direction === 'up' ? loc.index - 1 : loc.index + 1;
+    if (newIdx < 0 || newIdx >= loc.siblings.length)
+        return null;
+    const [removed] = loc.siblings.splice(loc.index, 1);
+    if (!removed)
+        return null;
+    loc.siblings.splice(newIdx, 0, removed);
+    normalizeListOrdinalsForest(clone);
+    return clone;
+}
+export function listDeleteItem(blocks, itemId) {
+    const clone = deepCloneBlocks(blocks);
+    const loc = findBlockLocation(clone, itemId);
+    if (!loc || loc.block.type !== 'listItem')
+        return null;
+    const removed = extractListItem(loc.siblings, loc.index);
+    if (!removed)
+        return null;
+    normalizeListOrdinalsForest(clone);
+    return clone;
+}
+function cloneListItemSubtree(item) {
+    const copy = deepCloneBlock(item);
+    copy.id = crypto.randomUUID();
+    function reId(node) {
+        node.id = crypto.randomUUID();
+        for (const ch of node.children ?? [])
+            reId(ch);
+    }
+    reId(copy);
+    return copy;
+}
+export function listDuplicateItem(blocks, itemId) {
+    const clone = deepCloneBlocks(blocks);
+    const loc = findBlockLocation(clone, itemId);
+    if (!loc || loc.block.type !== 'listItem')
+        return null;
+    const dup = cloneListItemSubtree(loc.block);
+    loc.siblings.splice(loc.index + 1, 0, dup);
+    normalizeListOrdinalsForest(clone);
+    return clone;
+}
+export function listItemCanMoveSibling(blocks, itemId, direction) {
+    const loc = findBlockLocation(blocks, itemId);
+    if (!loc || loc.block.type !== 'listItem')
+        return false;
+    const newIdx = direction === 'up' ? loc.index - 1 : loc.index + 1;
+    return newIdx >= 0 && newIdx < loc.siblings.length;
+}
+export function siblingFocusIdForListDelete(blocks, itemId) {
+    const loc = findBlockLocation(blocks, itemId);
+    if (!loc || loc.block.type !== 'listItem')
+        return undefined;
+    const { siblings, index } = loc;
+    if (index > 0)
+        return siblings[index - 1]?.id;
+    if (index + 1 < siblings.length)
+        return siblings[index + 1]?.id;
+    return undefined;
+}

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

@@ -0,0 +1,36 @@
+import { type InlineWrapKind } from './inlineEditCommands';
+import type { EditorBlock, EditorDocument } from './types';
+import type { TransactionBuildResult } from './editorTransactions';
+import { type TreeDropPlacement } from './blockTreeDrop';
+import { siblingFocusIdForListDelete } from './listEditCommands';
+import { siblingFocusIdForCalloutDelete } from './calloutEditCommands';
+import { type QuotePath } from './quoteEditCommands';
+export type { TreeDropPlacement } from './blockTreeDrop';
+export { applyBlockTreeDrop, blockTreeDropTransaction, canBlockTreeDrop } from './blockTreeDrop';
+export { isDescendantBlock, nestUnderPreviousSibling, nestUnderTarget, promoteOneLevel, removeBlockFromTree } from './blockTreeMutations';
+export declare function listRegionStructMutation(source: string, doc: EditorDocument, itemId: string, mutate: (blocks: EditorBlock[]) => EditorBlock[] | null, txId: string, caretBlockId?: string): TransactionBuildResult;
+export declare function moveListItemSiblingTransaction(source: string, doc: EditorDocument, _itemIndex: number, itemId: string, direction: 'up' | 'down'): TransactionBuildResult;
+export declare function listItemTreeDropTransaction(source: string, doc: EditorDocument, _blockIndex: number, draggedId: string, targetId: string, placement: TreeDropPlacement): TransactionBuildResult;
+export declare function deleteListItemTransaction(source: string, doc: EditorDocument, _blockIndex: number, itemId: string, focusAfterId?: string): TransactionBuildResult;
+export declare function duplicateListItemTransaction(source: string, doc: EditorDocument, _blockIndex: number, itemId: string): TransactionBuildResult;
+export { siblingFocusIdForListDelete };
+export declare function moveQuoteBlockSiblingTransaction(source: string, doc: EditorDocument, blockIndex: number, quoteBlockId: string, direction: 'up' | 'down'): TransactionBuildResult;
+export declare function deleteQuoteBlockTransaction(source: string, doc: EditorDocument, blockIndex: number, quoteBlockId: string, focusAfterId?: string): TransactionBuildResult;
+export declare function duplicateQuoteBlockTransaction(source: string, doc: EditorDocument, blockIndex: number, quoteBlockId: string): TransactionBuildResult;
+export declare function applyListItemInlineWrapTransaction(source: string, doc: EditorDocument, _blockIndex: number, itemId: string, plainStart: number, plainEnd: number, kind: InlineWrapKind, linkHref?: string): TransactionBuildResult;
+export declare function applyQuoteBlockInlineWrapTransaction(source: string, doc: EditorDocument, blockIndex: number, quoteBlockId: string, plainStart: number, plainEnd: number, kind: InlineWrapKind, linkHref?: string): TransactionBuildResult;
+export declare function quoteStructMutationTransaction(source: string, doc: EditorDocument, blockIndex: number, quoteBlockId: string, mutate: (root: EditorBlock) => EditorBlock | null, txId: string, caretBlockId?: string): TransactionBuildResult;
+export declare const moveQuoteParagraphSiblingTransaction: typeof moveQuoteBlockSiblingTransaction;
+export declare const deleteQuoteParagraphTransaction: typeof deleteQuoteBlockTransaction;
+export declare const duplicateQuoteParagraphTransaction: typeof duplicateQuoteBlockTransaction;
+export declare const applyQuoteParagraphInlineWrapTransaction: typeof applyQuoteBlockInlineWrapTransaction;
+export declare function siblingFocusIdForQuoteDelete(block: EditorBlock, quoteBlockId: string): string | undefined;
+export declare function quoteParagraphReorderTransaction(source: string, doc: EditorDocument, blockIndex: number, quotePath: QuotePath, fromIndex: number, toIndex: number, paragraphId: string): TransactionBuildResult;
+export declare function calloutStructMutationTransaction(source: string, doc: EditorDocument, blockIndex: number, childBlockId: string, mutate: (root: EditorBlock) => EditorBlock | null, txId: string, caretBlockId?: string): TransactionBuildResult;
+export declare function calloutExitTransaction(source: string, doc: EditorDocument, blockIndex: number, rootAfterExit: EditorBlock): TransactionBuildResult;
+export declare function moveCalloutChildSiblingTransaction(source: string, doc: EditorDocument, blockIndex: number, childId: string, direction: 'up' | 'down'): TransactionBuildResult;
+export declare function deleteCalloutChildTransaction(source: string, doc: EditorDocument, blockIndex: number, childId: string, focusAfterId?: string): TransactionBuildResult;
+export declare function duplicateCalloutChildTransaction(source: string, doc: EditorDocument, blockIndex: number, childId: string): TransactionBuildResult;
+export declare function calloutBodyTreeDropTransaction(source: string, doc: EditorDocument, _blockIndex: number, draggedId: string, targetId: string, placement: TreeDropPlacement): TransactionBuildResult;
+export declare function calloutDocumentStructMutation(source: string, doc: EditorDocument, calloutBlockIndex: number, anchorBlockId: string, mutate: (blocks: EditorBlock[]) => EditorBlock[] | null, txId: string, caretBlockId?: string): TransactionBuildResult;
+export { siblingFocusIdForCalloutDelete };