phormat 0.0.5

package/dist/editor/model/index.js

@@ -0,0 +1,19 @@
+export { clampSelection, normalizeSelectionRange, stableBlockId, syntheticRange } from './types';
+export { applyEditorTransaction, deleteBlockTransaction, duplicateBlockTransaction } from './editorTransactions';
+export { applyBlockTreeDrop, blockTreeDropTransaction, canBlockTreeDrop, tabReparentBlockTransaction } from './blockTreeDrop';
+export { blockCanMoveSibling, blockTreeDepth, canNestUnder } from './blockTree';
+export { applyListItemInlineWrapTransaction, applyQuoteParagraphInlineWrapTransaction, deleteListItemTransaction, deleteQuoteParagraphTransaction, duplicateListItemTransaction, duplicateQuoteParagraphTransaction, listItemTreeDropTransaction, listRegionStructMutation, moveListItemSiblingTransaction, moveQuoteParagraphSiblingTransaction, calloutBodyTreeDropTransaction, calloutDocumentStructMutation, deleteCalloutChildTransaction, duplicateCalloutChildTransaction, moveCalloutChildSiblingTransaction, quoteParagraphReorderTransaction, quoteStructMutationTransaction, siblingFocusIdForCalloutDelete, siblingFocusIdForListDelete, siblingFocusIdForQuoteDelete } from './nestedContainerTransactions';
+export { findEditorBlockById, tryRemapDocumentSelectionBlockId } from './documentSelection';
+export { documentSelectionFromSourceOffset } from './documentSelectionFromSource';
+export { findEditorBlockIdAtSourceOffset } from './findBlockAtSourceOffset';
+export { blockIdentityFingerprint, reconcileBlockIds } from './reconcileBlockIds';
+export { parseMarkdownDocument } from './parseMarkdownDocument';
+export { EMPTY_PARAGRAPH_MARKER, EMPTY_PARAGRAPH_INSERTION, normalizeEmptySource, isDisplayEmptyParagraph, isSoleEmptyParagraphDocument, emptyParagraphBlockData } from './emptyParagraph';
+export { applyInlineSecondPass, applyInlineSecondPassToBlockIndices } from './inlineSecondPass';
+export { tryIncrementalReparse, editRangeTouchesLinkDefinitions } from './incrementalReparse';
+export { mergeDraftInlineWithParser, draftInlineMergeFingerprint } from './inlineDraftMerge';
+export { FULL_REPARSE } from './reparseOptions';
+export { serializeEditorBlock, serializeMarkdownDocument, serializeMarkdownDocumentPreserving, serializeParagraphData } from './serializeMarkdownDocument';
+export { serializeInlineNodes } from './serializeInlineNodes';
+export { applyParagraphShortcut, applyStructuralMarkdownShortcut, isStructuralMarkdownShortcutLine, isStructuralMarkdownShortcutTrigger, markerOnlyListShortcutMarkdown, buildStructuralShortcutFocusOutcome, convertHeadingLevel, convertHeadingToParagraph, convertParagraphToHeading, deleteBlock, duplicateBlock, EDITOR_HISTORY_LIMIT, headingBodySourceRange, headingMarkdown, headingPlainOffsetToSourceOffset, buildEmptyParagraphInsertTransaction, insertEmptyParagraphRelative, mergeWithPreviousBlock, moveBlockDown, moveBlockToIndex, moveBlockUp, applyInlineWrap, paragraphBlockFromPlainText, paragraphBlockToPlainText, paragraphDisplayPlain, headingDisplayPlain, paragraphPlainOffsetToSourceOffset, replaceBlockMarkdownSlice, replaceSourceRange, splitBlockAtPlainOffset, swapAdjacentBlocks, updateBlockPlainText } from './blockEditCommands';
+export { documentBlocksToRenderBlocks } from './documentToRenderBlocks';

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

@@ -0,0 +1,17 @@
+import { type SourceEditResult } from './blockEditCommands';
+import type { CalloutBlock } from '../block-specs/callout/types';
+import type { EditorBlock, EditorDocument, InlineNode } from './types';
+/** Persist paragraph draft inlines to Markdown source. */
+export declare function commitParagraphInlineDraft(source: string, doc: EditorDocument, blockIndex: number, inlines: InlineNode[], plainCaret: number): SourceEditResult;
+/** Persist heading draft inlines to Markdown source. */
+export declare function commitHeadingInlineDraft(source: string, doc: EditorDocument, blockIndex: number, inlines: InlineNode[], plainCaret: number): SourceEditResult;
+/** Persist blockquote first-line body draft inlines on a nested quote node. */
+export declare function commitBlockquoteBodyInlineDraft(source: string, topBlock: EditorBlock, quoteBlockId: string, inlines: InlineNode[]): SourceEditResult;
+/** Persist nested paragraph draft inlines inside a blockquote subtree. */
+export declare function commitBlockquoteParagraphInlineDraft(source: string, topBlock: EditorBlock, paragraphId: string, inlines: InlineNode[]): SourceEditResult;
+/** Update callout opener metadata (`type`, `title`) on the root or a nested callout node. */
+export declare function commitCalloutOpenerDraft(source: string, topBlock: EditorBlock, calloutId: string, data: CalloutBlock): SourceEditResult;
+/** Persist nested paragraph draft inlines inside a callout body. */
+export declare function commitCalloutParagraphInlineDraft(source: string, topBlock: EditorBlock, paragraphId: string, inlines: InlineNode[]): SourceEditResult;
+/** Persist list item body draft inlines inside a callout body. */
+export declare function commitCalloutListItemInlineDraft(source: string, topBlock: EditorBlock, itemId: string, inlines: InlineNode[]): SourceEditResult;

package/dist/editor/model/inlineDraftCommit.js

@@ -0,0 +1,187 @@
+import { headingMarkdown, headingPlainOffsetToSourceOffset } from '../block-specs/heading/edit';
+import { paragraphBlockFromPlainText, paragraphPlainOffsetToSourceOffset } from '../block-specs/paragraph/edit';
+import { replaceBlockSourceRange } from './blockEditCommands';
+import { deepCloneBlock } from './blockTree';
+import { cloneInlineNodeDeep } from './inlineEditCommands';
+import { inlineNodesToPlainText } from './inlinePlain';
+import { findQuoteBlockPath, nodeAtQuotePath } from './quoteEditCommands';
+import { serializeEditorBlock } from './serializeMarkdownDocument';
+import { serializeInlineNodes } from './serializeInlineNodes';
+import { clampSelection } from './types';
+function paragraphCommitResult(source, block, inlines, plainCaret) {
+    const p = block.data;
+    const replacement = serializeInlineNodes(inlines);
+    const newPlain = inlineNodesToPlainText(inlines);
+    const newSource = replaceBlockSourceRange(source, block.sourceRange.start, block.sourceRange.end, replacement);
+    const tmpBlock = {
+        type: 'paragraph',
+        id: 'tmp',
+        sourceRange: { start: 0, end: replacement.length, startLine: 0, endLine: 0 },
+        data: paragraphBlockFromPlainText(newPlain, p.startLineIndex),
+        inlines: inlines.map(cloneInlineNodeDeep)
+    };
+    const inner = paragraphPlainOffsetToSourceOffset(tmpBlock, plainCaret);
+    const anchor = block.sourceRange.start + inner;
+    return {
+        ok: true,
+        source: newSource,
+        selection: clampSelection({ anchor, focus: anchor }, newSource.length)
+    };
+}
+function headingCommitResult(source, block, inlines, plainCaret) {
+    const hb = block.data;
+    const bodyMd = serializeInlineNodes(inlines);
+    const replacement = headingMarkdown(hb.level, bodyMd);
+    const newPlain = inlineNodesToPlainText(inlines);
+    const newSource = replaceBlockSourceRange(source, block.sourceRange.start, block.sourceRange.end, replacement);
+    const tmpHeadingBlock = {
+        type: 'heading',
+        id: 'tmp',
+        sourceRange: { start: 0, end: replacement.length, startLine: 0, endLine: 0 },
+        data: { ...hb, text: newPlain },
+        inlines: inlines.map(cloneInlineNodeDeep)
+    };
+    const inner = headingPlainOffsetToSourceOffset(tmpHeadingBlock, replacement, Math.min(plainCaret, newPlain.length));
+    const anchor = block.sourceRange.start + inner;
+    return {
+        ok: true,
+        source: newSource,
+        selection: clampSelection({ anchor, focus: anchor }, newSource.length)
+    };
+}
+/** Persist paragraph draft inlines to Markdown source. */
+export function commitParagraphInlineDraft(source, doc, blockIndex, inlines, plainCaret) {
+    const block = doc.blocks[blockIndex];
+    if (!block || block.type !== 'paragraph')
+        return { ok: false, error: 'Invalid paragraph block.' };
+    if (block.sourceRange.synthetic || block.sourceRange.start < 0) {
+        return { ok: false, error: 'Block is not editable.' };
+    }
+    return paragraphCommitResult(source, block, inlines, plainCaret);
+}
+/** Persist heading draft inlines to Markdown source. */
+export function commitHeadingInlineDraft(source, doc, blockIndex, inlines, plainCaret) {
+    const block = doc.blocks[blockIndex];
+    if (!block || block.type !== 'heading')
+        return { ok: false, error: 'Invalid heading block.' };
+    if (block.sourceRange.synthetic || block.sourceRange.start < 0) {
+        return { ok: false, error: 'Block is not editable.' };
+    }
+    return headingCommitResult(source, block, inlines, plainCaret);
+}
+/** Persist blockquote first-line body draft inlines on a nested quote node. */
+export function commitBlockquoteBodyInlineDraft(source, topBlock, quoteBlockId, inlines) {
+    if (topBlock.type !== 'blockquote')
+        return { ok: false, error: 'Invalid blockquote.' };
+    const draftRoot = deepCloneBlock(topBlock);
+    const path = findQuoteBlockPath(draftRoot, quoteBlockId);
+    if (path === null)
+        return { ok: false, error: 'Blockquote node not found.' };
+    const node = nodeAtQuotePath(draftRoot, path);
+    if (!node || node.type !== 'blockquote')
+        return { ok: false, error: 'Invalid blockquote node.' };
+    node.inlines = inlines.map(cloneInlineNodeDeep);
+    const replacement = serializeEditorBlock(draftRoot, source);
+    const newSource = replaceBlockSourceRange(source, topBlock.sourceRange.start, topBlock.sourceRange.end, replacement);
+    return {
+        ok: true,
+        source: newSource,
+        selection: clampSelection({ anchor: topBlock.sourceRange.start, focus: topBlock.sourceRange.start }, newSource.length)
+    };
+}
+/** Persist nested paragraph draft inlines inside a blockquote subtree. */
+export function commitBlockquoteParagraphInlineDraft(source, topBlock, paragraphId, inlines) {
+    if (topBlock.type !== 'blockquote')
+        return { ok: false, error: 'Invalid blockquote.' };
+    const draftRoot = deepCloneBlock(topBlock);
+    function walk(node) {
+        if (node.id === paragraphId && node.type === 'paragraph') {
+            node.inlines = inlines.map(cloneInlineNodeDeep);
+            const newPlain = inlineNodesToPlainText(inlines);
+            node.data = paragraphBlockFromPlainText(newPlain, node.data.startLineIndex);
+            return true;
+        }
+        for (const ch of node.children ?? []) {
+            if (walk(ch))
+                return true;
+        }
+        return false;
+    }
+    if (!walk(draftRoot))
+        return { ok: false, error: 'Blockquote paragraph not found.' };
+    const replacement = serializeEditorBlock(draftRoot, source);
+    const newSource = replaceBlockSourceRange(source, topBlock.sourceRange.start, topBlock.sourceRange.end, replacement);
+    return {
+        ok: true,
+        source: newSource,
+        selection: clampSelection({ anchor: topBlock.sourceRange.start, focus: topBlock.sourceRange.start }, newSource.length)
+    };
+}
+function commitCalloutSubtree(source, topBlock, mutate) {
+    if (topBlock.type !== 'callout')
+        return { ok: false, error: 'Invalid callout.' };
+    const draftRoot = deepCloneBlock(topBlock);
+    if (!mutate(draftRoot))
+        return { ok: false, error: 'Callout node not found.' };
+    const replacement = serializeEditorBlock(draftRoot, source);
+    const newSource = replaceBlockSourceRange(source, topBlock.sourceRange.start, topBlock.sourceRange.end, replacement);
+    return {
+        ok: true,
+        source: newSource,
+        selection: clampSelection({ anchor: topBlock.sourceRange.start, focus: topBlock.sourceRange.start }, newSource.length)
+    };
+}
+/** Update callout opener metadata (`type`, `title`) on the root or a nested callout node. */
+export function commitCalloutOpenerDraft(source, topBlock, calloutId, data) {
+    return commitCalloutSubtree(source, topBlock, (draft) => {
+        function walk(node) {
+            if (node.id === calloutId && node.type === 'callout') {
+                const prev = node.data;
+                node.data = { ...data, lineIndex: prev.lineIndex };
+                return true;
+            }
+            for (const ch of node.children ?? []) {
+                if (walk(ch))
+                    return true;
+            }
+            return false;
+        }
+        return walk(draft);
+    });
+}
+/** Persist nested paragraph draft inlines inside a callout body. */
+export function commitCalloutParagraphInlineDraft(source, topBlock, paragraphId, inlines) {
+    return commitCalloutSubtree(source, topBlock, (draft) => {
+        function walk(node) {
+            if (node.id === paragraphId && node.type === 'paragraph') {
+                node.inlines = inlines.map(cloneInlineNodeDeep);
+                const newPlain = inlineNodesToPlainText(inlines);
+                node.data = paragraphBlockFromPlainText(newPlain, node.data.startLineIndex);
+                return true;
+            }
+            for (const ch of node.children ?? []) {
+                if (walk(ch))
+                    return true;
+            }
+            return false;
+        }
+        return walk(draft);
+    });
+}
+/** Persist list item body draft inlines inside a callout body. */
+export function commitCalloutListItemInlineDraft(source, topBlock, itemId, inlines) {
+    return commitCalloutSubtree(source, topBlock, (draft) => {
+        function walk(node) {
+            if (node.id === itemId && node.type === 'listItem') {
+                node.inlines = inlines.map(cloneInlineNodeDeep);
+                return true;
+            }
+            for (const ch of node.children ?? []) {
+                if (walk(ch))
+                    return true;
+            }
+            return false;
+        }
+        return walk(draft);
+    });
+}

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

@@ -0,0 +1,8 @@
+import type { InlineNode } from './types';
+/**
+ * **Draft inline merge** — controlled wrap marks and atoms stay authoritative;
+ * parser fills plain-text gaps in the session draft.
+ */
+export declare function mergeDraftInlineWithParser(draft: InlineNode[]): InlineNode[];
+/** Stable fingerprint for merge scheduling — ignores volatile `sourceRange` fields. */
+export declare function draftInlineMergeFingerprint(inlines: InlineNode[]): string;

package/dist/editor/model/inlineDraftMerge.js

@@ -0,0 +1,81 @@
+import { buildRichInlinesForRange, createRichInlineContext } from './richInlines';
+import { cloneInlineNodeDeep } from './inlineEditCommands';
+function parsePlainGap(gapPlain) {
+    if (!gapPlain)
+        return [];
+    const ctx = createRichInlineContext(gapPlain);
+    return buildRichInlinesForRange(gapPlain, 0, gapPlain.length, ctx);
+}
+/**
+ * **Draft inline merge** — controlled wrap marks and atoms stay authoritative;
+ * parser fills plain-text gaps in the session draft.
+ */
+export function mergeDraftInlineWithParser(draft) {
+    const out = [];
+    let gapPlain = '';
+    const flushGap = () => {
+        if (!gapPlain)
+            return;
+        out.push(...parsePlainGap(gapPlain));
+        gapPlain = '';
+    };
+    for (const node of draft) {
+        if (node.type === 'text') {
+            gapPlain += node.text;
+            continue;
+        }
+        flushGap();
+        out.push(cloneInlineNodeDeep(node));
+    }
+    flushGap();
+    return out;
+}
+/** Stable fingerprint for merge scheduling — ignores volatile `sourceRange` fields. */
+export function draftInlineMergeFingerprint(inlines) {
+    const parts = [];
+    const walk = (nodes) => {
+        for (const n of nodes) {
+            if (n.type === 'text') {
+                parts.push(`t:${n.text}`);
+            }
+            else if (n.type === 'code') {
+                parts.push(`c:${n.text}`);
+            }
+            else if (n.type === 'link') {
+                parts.push(`l:${n.href}:${walkPlain(n.children)}`);
+            }
+            else if (n.type === 'image') {
+                parts.push(`i:${n.href ?? ''}`);
+            }
+            else if (n.type === 'autolink') {
+                parts.push(`a:${n.href}`);
+            }
+            else if (n.type === 'wikiLink') {
+                parts.push(`w:${n.target}:${n.label}`);
+            }
+            else if (n.type === 'mention') {
+                parts.push(`m:${n.kind}:${n.name}`);
+            }
+            else if (n.type === 'strong' || n.type === 'emphasis' || n.type === 'strikethrough') {
+                parts.push(`${n.type}:${walkPlain(n.children)}`);
+            }
+            else if (n.type === 'highlight') {
+                parts.push(`highlight:${n.color ?? ''}:${walkPlain(n.children)}`);
+            }
+        }
+    };
+    const walkPlain = (nodes) => {
+        let s = '';
+        for (const n of nodes) {
+            if (n.type === 'text')
+                s += n.text;
+            else if ('children' in n && n.children)
+                s += walkPlain(n.children);
+            else if (n.type === 'code')
+                s += n.text;
+        }
+        return s;
+    };
+    walk(inlines);
+    return parts.join('|');
+}

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

@@ -0,0 +1,28 @@
+import type { InlineNode, SourceRange } from './types';
+export declare function syntheticInlineSourceRange(): SourceRange;
+export declare function inlineTextNode(text: string): InlineNode;
+export type InlineWrapKind = 'strong' | 'emphasis' | 'code' | 'strikethrough' | 'highlight' | 'link';
+export declare function nodePlainLength(n: InlineNode): number;
+export declare function inlineRangeFullyCoveredByKind(nodes: InlineNode[], start: number, end: number, kind: InlineWrapKind): boolean;
+export declare function cloneInlineNodeDeep(n: InlineNode): InlineNode;
+/** Split `nodes` into plain-offset prefix / suffix at `offset` (0-based into concatenated plain text). */
+export declare function splitInlineNodesAtPlainOffset(nodes: InlineNode[], offset: number): {
+    left: InlineNode[];
+    right: InlineNode[];
+};
+export declare function wrapInlineSelection(nodes: InlineNode[], start: number, end: number, kind: InlineWrapKind, linkHref?: string): InlineNode[] | null;
+/** Returns updated nodes when `newPlain` differs by a single insert/delete; otherwise `null`. */
+export declare function mergePlainTypingIntoInlines(nodes: InlineNode[], newPlain: string): InlineNode[] | null;
+export declare function isInlineAtom(n: InlineNode): boolean;
+/** Clone block `inlines` for a session draft, or seed from display plain. */
+export declare function draftInlinesFromBlock(inlines: InlineNode[] | undefined, displayPlain: string): InlineNode[];
+/** Remove plain-text range `[start, end)` from inline AST. */
+export declare function deletePlainRange(nodes: InlineNode[], start: number, end: number): InlineNode[];
+export declare function deleteCharBefore(nodes: InlineNode[], pos: number): InlineNode[] | null;
+export declare function deleteCharAfter(nodes: InlineNode[], pos: number): InlineNode[] | null;
+/** Insert plain text at offset; optionally strip newlines (heading single-line). */
+export declare function insertTextAtPlainOffset(nodes: InlineNode[], pos: number, text: string, options?: {
+    stripNewlines?: boolean;
+}): InlineNode[];
+/** Apply a controlled-input delta; falls back to plain flattening when merge fails. */
+export declare function applyControlledPlainEdit(nodes: InlineNode[], oldPlain: string, newPlain: string): InlineNode[];