Struct BlockEditorModel 

pub struct BlockEditorModel { /* private fields */ }

Headless editor facade (spike name). Phase 3 wraps this in the BlockEditorState entity.

Implementations

impl BlockEditorModel

pub fn insert_text( &mut self, text: &str, origin: EditOrigin, ) -> Result<(), CommandError>

Insert plain text at the selection (replacing it); \n splits blocks.

pub fn paste_inline_markdown( &mut self, text: &str, ) -> Result<bool, CommandError>

Paste the editor’s own inline Markdown copy (D17): each line is parsed as inline Markdown (marks survive), lines become blocks as typed. Edge whitespace stays literal. One undo step. In a code block the marks are dropped (the text is inserted raw); Ok(false) when the target cannot take it (a table cell with several lines).

pub fn delete(&mut self, forward: bool) -> Result<(), CommandError>

Backspace (forward == false) or Delete: a grapheme, the selection, a join with the neighbouring block, or (next to a table) select the table.

pub fn split_block(&mut self) -> Result<(), CommandError>

Enter: split the text block (in a list, a new item; in an empty item, exit or outdent).

pub fn paste_blocks(&mut self, text: &str) -> Result<bool, CommandError>

Paste Markdown as blocks, as one undo step. Text without a line break, or that parses to a single paragraph, is left to plain insertion (insert_text). Otherwise the text is parsed: a leading paragraph merges into the text before the caret, a trailing one into the text after it, and the blocks between are inserted between the two halves. Returns whether it applied (false for single-line text or when the caret is not in an editable text block; the caller then inserts plain text).

pub fn run(&mut self, command: EditorCommand) -> Result<bool, CommandError>

Run an EditorCommand; returns whether the document or selection changed.

impl BlockEditorModel

pub fn from_markdown( source: &str, extensions: MarkdownExtensions, ) -> Result<Self, SharedString>

Parse Markdown into a model.

pub fn set_source(&mut self, source: &str) -> Result<(), SharedString>

Replace the content. Fresh ids (old positions fail with UnknownBlock), history cleared.

pub fn source(&self) -> String

The document as canonical Markdown.

pub fn revision(&self) -> u64

Document revision; bumped by every committed transaction.

pub fn document(&self) -> DocumentRef<'_>

Read-only view of the block tree.

pub fn selection(&self) -> &BlockSelection

The current selection.

pub fn set_selection( &mut self, selection: BlockSelection, ) -> Result<(), SelectionError>

Set the selection after validating it against the document.

pub fn caret(&self) -> Option<BlockPosition>

The caret (head of a text selection); None for a block selection.

pub fn active_marks(&self) -> MarkSet

Marks the next typed text gets (stored marks, else inherited at the caret).

pub fn mark_state(&self, kind: MarkKind) -> MarkState

Whether kind is on, off or mixed over the selection.

pub fn block_kind_at_caret(&self) -> Option<BlockKind>

Kind of the text block holding the caret, if any.

pub fn break_coalescing(&mut self)

End the current typing group, so the next edit is its own undo step.

pub fn can_undo(&self) -> bool

Whether there is something to undo.

pub fn can_redo(&self) -> bool

Whether there is something to redo.

pub fn undo(&mut self) -> bool

Undo one group; returns whether anything changed.

pub fn redo(&mut self) -> bool

Redo one group; returns whether anything changed.

impl BlockEditorModel

pub fn source_snapshot(&self) -> SourceSnapshot

pub fn capture_caret(&self) -> Result<CapturedRange, CapturedRangeError>

Capture the head/caret, inserting there even when text is selected.

pub fn capture_selection(&self) -> Result<CapturedRange, CapturedRangeError>

Capture the current text selection for one atomic replacement.

pub fn caret_prefix_snapshot(&self) -> Option<SharedString>

Text before the caret in its editable leaf. Completion engines inspect this plain text, not escaped or reformatted canonical source. Revision/selection-keyed shared native prefix. Repeated query/render reads do not clone a large caret leaf’s bytes.

pub fn caret_prefix(&self) -> Option<&str>

pub fn capture_suffix( &self, len: usize, ) -> Result<CapturedRange, CapturedRangeError>

Capture a UTF-8 suffix of the caret’s leaf for completion acceptance.

pub fn capture_leaf_range( &self, range: Range<usize>, ) -> Result<CapturedRange, CapturedRangeError>

Capture an exact UTF-8 range in the caret’s editing leaf. This range is measured in plain leaf text, never canonical Markdown. Useful when a completion token ends before trailing text/newlines in that same leaf.

pub fn is_capture_current(&self, capture: &CapturedRange) -> bool

pub fn replace_captured( &mut self, capture: &mut CapturedRange, text: &str, ) -> Result<(), CapturedRangeError>

Replace only a captured range with plain text. One undoable transaction per replacement; does not reparse, apply input rules or submit. Errors leave both the document and capture intact. The caller retains domain ownership (session/window/request) and rejects its own stale callbacks.

pub fn invalidate_captures(&mut self)

Invalidate outstanding host captures without changing document/source. Hosts call this when the external owner (session/window/request) changes.

pub fn select_end(&mut self) -> Result<(), SelectionError>

impl BlockEditorModel

pub fn selected_cells(&self) -> Option<Vec<Vec<BlockId>>>

The cells of a BlockSelection::Cells rectangle, row by row.

pub fn whole_columns_selected(&self) -> bool

Whether the selection is whole column(s): a cell selection over every row of its table.

pub fn column_align_at_caret(&self) -> Option<ColumnAlign>

The alignment of the column holding the selection head.

pub fn select_table_line( &mut self, table: BlockId, line: TableLine, ) -> Result<bool, CommandError>

Select a whole row or column of table as BlockSelection::Cells.