@owomark/core 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,364 @@
+import { B as BlockNode, a as BlockContextType, O as OwoMarkSelection, C as CoreStateSnapshot, S as SlashState, b as CommandRegistry, c as OwoMarkDocument, D as DirtyRange, P as PreviewBlockKind, d as PreviewBlock, e as BlockTransform, f as OwoMarkSharedStateController, I as InlineToken, g as InlineTokenType } from './dom-adapter-IZEW91gZ.js';
+export { h as BeforeInputIntent, i as BlockContext, j as BlockContextListener, k as BlockInsertType, l as BlockType, m as CommandContext, n as CommandDefinition, o as CompositionState, p as CoreApplyAction, q as CoreApplyResult, r as CoreSelectionSnapshot, s as CreateOwoMarkCoreOptions, t as Decorator, u as DecoratorType, v as DocumentChangeCallback, w as DomAdapterInstance, H as HeadingLevel, x as HistoryEntry, y as IndentMode, z as IndentResult, J as JsonPrimitive, A as JsonValue, K as KeyDownIntent, L as Leaf, E as OwoMarkCommands, F as OwoMarkCore, G as OwoMarkEditorInstance, M as OwoMarkEditorLike, N as OwoMarkSharedState, Q as OwoMarkSharedStateStore, R as PasteIntent, T as PreviewDirtyReason, U as SlashStateListener, V as SlashTriggerInfo, W as VirtualPosition, X as VirtualSelection, Y as applyMarkdownIndent, Z as createOwoMarkCore, _ as getBlockIndexForPosition, $ as isVirtualSelectionCollapsed, a0 as linearToVirtual, a1 as linearToVirtualPosition, a2 as resolveIndentSize, a3 as virtualPositionToLinear, a4 as virtualPositionsEqual, a5 as virtualToLinear } from './dom-adapter-IZEW91gZ.js';
+export { enableMapSet, produce } from 'immer';
+
+/**
+ * Resolve the extended BlockContextType from a BlockNode.
+ *
+ * Now that math-block and table are first-class document model types,
+ * this module is a thin projection layer. The only derived type is
+ * 'empty' (blank paragraphs) for UI convenience.
+ */
+
+/**
+ * Map a document-model BlockNode to BlockContextType.
+ *
+ * @param block The BlockNode at cursor position
+ */
+declare function resolveBlockContextType(block: BlockNode): BlockContextType;
+
+type CoreChangeListener = (markdown: string) => void;
+type CoreSelectionListener = (selection: OwoMarkSelection) => void;
+type CoreCompositionListener = (active: boolean) => void;
+type CoreStateListener = (snapshot: CoreStateSnapshot) => void;
+type CoreSlashStateListener = (state: SlashState) => void;
+type CoreEventHub = {
+    onChange(callback: CoreChangeListener): () => void;
+    onSelectionChange(callback: CoreSelectionListener): () => void;
+    onCompositionStateChange(callback: CoreCompositionListener): () => void;
+    onStateChange(callback: CoreStateListener): () => void;
+    onSlashStateChange(callback: CoreSlashStateListener): () => void;
+    emitChange(markdown: string): void;
+    emitSelectionChange(selection: OwoMarkSelection): void;
+    emitCompositionChange(active: boolean): void;
+    emitStateChange(snapshot: CoreStateSnapshot): void;
+    emitSlashStateChange(state: SlashState): void;
+};
+
+declare function createCommandRegistry(): CommandRegistry;
+
+type BlockIdGenerator = () => string;
+/** Create a per-instance block ID generator. */
+declare function createBlockIdGenerator(): BlockIdGenerator;
+/** Reset the default block ID counter (for testing). */
+declare function resetBlockIdCounter(): void;
+declare function parseMarkdownToDocument(markdown: string, genId?: BlockIdGenerator): OwoMarkDocument;
+/**
+ * Reconcile old and new block arrays using head+tail scanning.
+ * Unchanged blocks at the head and tail preserve old identity (including ID).
+ * Middle blocks (inserted, deleted, or modified) use new identity.
+ */
+declare function reconcileBlocks(oldBlocks: readonly BlockNode[], newBlocks: readonly BlockNode[]): BlockNode[];
+declare function serializeDocument(doc: OwoMarkDocument): string;
+declare function getBlockById(doc: OwoMarkDocument, blockId: string): BlockNode | undefined;
+declare function getBlockIndexById(doc: OwoMarkDocument, blockId: string): number;
+declare function getBlockAtOffset(doc: OwoMarkDocument, offset: number): {
+    blockIndex: number;
+    offsetInBlock: number;
+};
+declare function getBlockStartOffset(doc: OwoMarkDocument, blockIndex: number): number;
+
+/**
+ * Convert a DOM Selection/Range to a linear character offset relative to
+ * the editor root element.
+ */
+declare function domRangeToOffset(root: HTMLElement, range: {
+    startContainer: Node;
+    startOffset: number;
+    endContainer: Node;
+    endOffset: number;
+}): OwoMarkSelection | null;
+/**
+ * Convert a linear character offset back to a DOM Range within the editor root.
+ */
+declare function offsetToDomRange(root: HTMLElement, selection: OwoMarkSelection): Range | null;
+/**
+ * Restore a selection on the editor root from linear offsets.
+ */
+declare function restoreSelection(root: HTMLElement, selection: OwoMarkSelection): void;
+/**
+ * Read current DOM selection as linear offsets.
+ */
+declare function readSelection(root: HTMLElement): OwoMarkSelection | null;
+/** Invalidate the cached block element list. Call after every DOM render. */
+declare function invalidateBlockCache(root: HTMLElement): void;
+
+/**
+ * Merge a new dirty block index into an existing dirty range.
+ */
+declare function expandDirtyRange(current: DirtyRange | null, blockIndex: number, totalBlocks: number): DirtyRange | null;
+/**
+ * Expand dirty range to include adjacent context blocks.
+ */
+declare function expandWithContext(range: DirtyRange, totalBlocks: number, context?: number): DirtyRange | null;
+
+/**
+ * Stable block identity derivation.
+ *
+ * Both editor and preview sides derive blockId from the same source line
+ * range, ensuring they share a common identity without runtime DOM coupling.
+ */
+declare function deriveBlockId(startLine: number, endLine: number): string;
+
+/**
+ * Derive a stable render key for a preview block.
+ *
+ * The render key determines cache validity. If the key is unchanged,
+ * the preview can skip re-rendering and reuse the cached result.
+ */
+
+declare function deriveRenderKey(raw: string, kind: PreviewBlockKind, themeKey?: string): string;
+
+/**
+ * Project a OwoMarkDocument into PreviewBlocks.
+ *
+ * Groups adjacent same-type container blocks (lists, blockquotes) into
+ * single preview blocks, computes source line ranges, and derives stable
+ * blockIds and renderKeys.
+ */
+
+declare function projectToPreviewBlocks(doc: OwoMarkDocument, themeKey?: string, transforms?: BlockTransform[]): PreviewBlock[];
+/**
+ * Compare two preview block arrays and return the dirty range.
+ * Uses two-pointer scan to find the tightest changed range (EV3).
+ * Returns null if no blocks changed.
+ * endBlock is always clamped to valid newBlocks range (RISK-3).
+ */
+declare function computePreviewDirtyRange(oldBlocks: PreviewBlock[], newBlocks: PreviewBlock[]): {
+    startBlock: number;
+    endBlock: number;
+} | null;
+
+/**
+ * Framework-agnostic shared state store for editor <-> preview coordination.
+ *
+ * Wraps a OwoMarkEditorLike and produces OwoMarkSharedState snapshots
+ * that the preview engine can consume incrementally.
+ */
+
+type CreateSharedStateOptions = {
+    initialMarkdown?: string;
+    themeKey?: string;
+    /** Block transforms applied during projection (shared by preview & build). */
+    transforms?: BlockTransform[];
+};
+declare function createSharedStateStore(options?: CreateSharedStateOptions): OwoMarkSharedStateController;
+
+/**
+ * Tokenize inline Markdown content into decoration tokens.
+ * Pure function, no DOM dependency.
+ */
+declare function tokenizeInline(raw: string, baseOffset?: number): InlineToken[];
+
+/**
+ * Tokenize a single block's raw text into InlineToken[].
+ * Block-level markers (heading #, list bullet, etc.) get their own token types.
+ */
+declare function tokenizeBlock(raw: string, blockType: string, baseOffset?: number): InlineToken[];
+
+/**
+ * Enter key handling: list continuation, blockquote continuation,
+ * code fence auto-close and indent continuation.
+ *
+ * Migrated from admin-editor-writing-assists.ts — pure function,
+ * operates on text + selection, no DOM dependency.
+ */
+type CommandResult = {
+    handled: boolean;
+    value: string;
+    selectionStart: number;
+    selectionEnd: number;
+};
+declare const NOT_HANDLED: CommandResult;
+declare function handleMarkdownEnter(params: {
+    text: string;
+    selectionStart: number;
+    selectionEnd: number;
+    enableSideAnnotation?: boolean;
+}): CommandResult;
+
+/**
+ * Character input handling: paired symbol completion and forward delete pairing.
+ * Migrated from admin-editor-writing-assists.ts — pure function.
+ */
+
+declare function handleCharInput(params: {
+    key: string;
+    text: string;
+    selectionStart: number;
+    selectionEnd: number;
+    isComposing: boolean;
+}): CommandResult;
+declare function handleSmartDelete(params: {
+    text: string;
+    selectionStart: number;
+    selectionEnd: number;
+}): CommandResult;
+
+/**
+ * Backspace handling: paired deletion and structural line collapse.
+ *
+ * Kept separate from char-input so structural Backspace rules
+ * (such as side-annotation continuation cleanup) can evolve independently.
+ */
+
+declare function handleSmartBackspace(params: {
+    text: string;
+    selectionStart: number;
+    selectionEnd: number;
+}): CommandResult;
+
+/**
+ * Inline formatting commands: bold, italic, link, code fence.
+ * Operates on text + selection, no DOM dependency.
+ */
+
+declare function toggleBold(params: {
+    text: string;
+    selectionStart: number;
+    selectionEnd: number;
+}): CommandResult;
+declare function toggleItalic(params: {
+    text: string;
+    selectionStart: number;
+    selectionEnd: number;
+}): CommandResult;
+declare function insertLink(params: {
+    text: string;
+    selectionStart: number;
+    selectionEnd: number;
+    url?: string;
+}): CommandResult;
+declare function insertCodeFence(params: {
+    text: string;
+    selectionStart: number;
+    selectionEnd: number;
+    language?: string;
+}): CommandResult;
+declare function insertMathBlock(params: {
+    text: string;
+    selectionStart: number;
+    selectionEnd: number;
+}): CommandResult;
+declare function insertTable(params: {
+    text: string;
+    selectionStart: number;
+    selectionEnd: number;
+}): CommandResult;
+declare function insertImage(params: {
+    text: string;
+    selectionStart: number;
+    selectionEnd: number;
+}): CommandResult;
+/**
+ * Insert side annotation syntax around selected blocks.
+ *
+ * Strategy (per spec):
+ * - 1-3 lines selected: wrap each line with inline (>} ...) + (>+)
+ * - 4+ lines selected: wrap in :::side container
+ * - No selection: insert skeleton (>} annotation) at cursor
+ */
+declare function insertSideAnnotation(params: {
+    text: string;
+    selectionStart: number;
+    selectionEnd: number;
+    type?: string;
+}): CommandResult;
+
+type WordBoundaryResult = {
+    newText: string;
+    newPos: number;
+};
+declare function deleteWordBackward(text: string, pos: number): WordBoundaryResult;
+declare function deleteWordForward(text: string, pos: number): WordBoundaryResult;
+declare function deleteToLineStart(text: string, pos: number): WordBoundaryResult;
+declare function deleteToLineEnd(text: string, pos: number): WordBoundaryResult;
+
+/**
+ * Block transform: extract image dimensions from Markdown image syntax.
+ *
+ * Supports three configurable syntaxes:
+ * - obsidian: ![alt|800x600](url)   or  ![alt|100%x300](url)
+ * - pandoc:   ![alt](url){width=800 height=600}  or  {w=800 h=600}
+ * - mou:      ![alt](url =300x200)
+ *
+ * Also always parses <img> width/height attributes in HTML blocks.
+ *
+ * Extracted dimensions are stored in block.attributes.images as an array
+ * of { src, width, height } objects.
+ */
+
+type ImageSizeSyntax = 'obsidian' | 'pandoc' | 'mou' | 'none';
+/**
+ * Create a BlockTransform that extracts image dimensions.
+ *
+ * When images with size info are found, the block's `attributes.images`
+ * is set to an array of `{ src, width, height }` objects.
+ */
+declare function createImageSizeTransform(syntax?: ImageSizeSyntax): BlockTransform;
+
+declare function normalizeMarkdownPaste(raw: string, tabSize?: number): string;
+
+/**
+ * Incremental DOM patch: only re-render dirty blocks.
+ */
+
+/**
+ * Full render: build entire editor DOM from document model.
+ */
+declare function fullRender(root: HTMLElement, doc: OwoMarkDocument): void;
+/**
+ * Incremental patch: only re-render blocks in dirty range.
+ */
+declare function patchDirtyBlocks(root: HTMLElement, doc: OwoMarkDocument, dirty: DirtyRange): void;
+/**
+ * Detect changed blocks between old and new document, then render minimally.
+ * Falls back to full render when block count changes or no dirty blocks found
+ * despite text difference (structural shift).
+ */
+declare function detectAndRenderDirty(root: HTMLElement, oldDoc: OwoMarkDocument, newDoc: OwoMarkDocument, fullFallback?: boolean): void;
+
+/**
+ * Render a block's inline tokens into DOM nodes within a block container.
+ * Each block is a <div data-owo-block="index"> containing text/span nodes.
+ */
+
+declare const TOKEN_TO_CLASS: Record<InlineTokenType, string>;
+declare const BLOCK_TYPE_TO_CLASS: Record<string, string>;
+declare function createBlockElement(doc: Document, tokens: InlineToken[], blockIndex: number, blockType: string, headingLevel?: number, depth?: number): HTMLDivElement;
+/**
+ * Update an existing block element's content with new tokens.
+ * Returns true if the block was modified.
+ */
+declare function updateBlockElement(doc: Document, existing: HTMLDivElement, tokens: InlineToken[], blockType: string, headingLevel?: number, depth?: number): boolean;
+
+declare const BQ_STEP: number;
+/**
+ * Build the CSS box-shadow value for nested blockquote bars.
+ * Returns null when depth <= 1 (no extra bars needed — the first bar is
+ * rendered by the block's own border/class styling).
+ */
+declare function buildBlockquoteBarsBoxShadow(depth: number): string | null;
+
+/** A flattened row for virtual list computation. */
+type VirtualRow = {
+    blockIndex: number;
+    blockId: string;
+    height: number;
+};
+/** Result of visible range computation. */
+type VisibleRange = {
+    startIndex: number;
+    endIndex: number;
+    totalHeight: number;
+    offsetTop: number;
+    offsetBottom: number;
+};
+/** Estimate a block's height in the editor (source view). */
+declare function estimateEditorBlockHeight(block: BlockNode, charsPerLine?: number): number;
+/** Build VirtualRow[] from blocks + height cache. */
+declare function buildVirtualRows(blocks: readonly BlockNode[], heightCache: Map<string, number>, charsPerLine?: number): VirtualRow[];
+/** Compute the visible range given scroll state. */
+declare function computeVisibleRange(rows: VirtualRow[], scrollTop: number, viewportHeight: number, overscan?: number): VisibleRange;
+
+export { BLOCK_TYPE_TO_CLASS, BQ_STEP, BlockContextType, type BlockIdGenerator, BlockNode, BlockTransform, CommandRegistry, type CommandResult, type CoreEventHub, type CoreSlashStateListener, CoreStateSnapshot, type CreateSharedStateOptions, DirtyRange, type ImageSizeSyntax, InlineToken, InlineTokenType, NOT_HANDLED, OwoMarkDocument, OwoMarkSelection, OwoMarkSharedStateController, PreviewBlock, PreviewBlockKind, SlashState, TOKEN_TO_CLASS, type VirtualRow, type VisibleRange, type WordBoundaryResult, buildBlockquoteBarsBoxShadow, buildVirtualRows, computePreviewDirtyRange, computeVisibleRange, createBlockElement, createBlockIdGenerator, createCommandRegistry, createImageSizeTransform, createSharedStateStore, deleteToLineEnd, deleteToLineStart, deleteWordBackward, deleteWordForward, deriveBlockId, deriveRenderKey, detectAndRenderDirty, domRangeToOffset, estimateEditorBlockHeight, expandDirtyRange, expandWithContext, fullRender, getBlockAtOffset, getBlockById, getBlockIndexById, getBlockStartOffset, handleCharInput, handleMarkdownEnter, handleSmartBackspace, handleSmartDelete, insertCodeFence, insertImage, insertLink, insertMathBlock, insertSideAnnotation, insertTable, invalidateBlockCache, normalizeMarkdownPaste, offsetToDomRange, parseMarkdownToDocument, patchDirtyBlocks, projectToPreviewBlocks, readSelection, reconcileBlocks, resetBlockIdCounter, resolveBlockContextType, restoreSelection, serializeDocument, toggleBold, toggleItalic, tokenizeBlock, tokenizeInline, updateBlockElement };