@vscode/markdown-editor 0.0.2-66 → 0.0.2-68

package/dist/index.d.ts

@@ -956,6 +956,9 @@ export declare class EditorController extends Disposable {
     private _lastPointerDown;
     constructor(_model: EditorModel, _view: EditorView, options?: EditorControllerOptions);
     private readonly _handleTextUpdate;
+    /** Handle typed, pasted, or command-generated text while a paragraph is pending. */
+    private _handlePendingInput;
+    private _deletePendingText;
     private readonly _handlePointerDown;
     private _makeCursorContext;
     private _makeVisualCursorContext;
@@ -1096,11 +1099,12 @@ export declare class EditorModel {
     /**
      * Read-only mode. When `true`, the editor never reveals a block's source
      * markers (markdown special characters like `**`, `#`, list bullets, code
-     * fences, `$…$`) — every block stays in its clean rendered form regardless
-     * of where the caret/selection is — and source-mutating edits are ignored.
-     * Plain text selection still works everywhere (so the user can copy). The
-     * default (`false`) is the normal editing mode where the active block
-     * reveals its markers.
+     * fences, `$…$`) — every block stays in its clean rendered form regardless of
+     * where the caret/selection is — and text-editing commands are ignored.
+     * Explicit interactions with rendered controls, such as task checkboxes,
+     * remain available. Plain text selection still works everywhere (so the user
+     * can copy). The default (`false`) is the normal editing mode where the active
+     * block reveals its markers.
      */
     readonly readonlyMode: ISettableObservable<boolean, void>;
     /**
@@ -1143,7 +1147,7 @@ export declare class EditorModel {
      * The transient empty-paragraph editing state, or `undefined` when none is
      * armed. See {@link PendingParagraph}. This is *not* document data — it is
      * cleared by any source edit and lives only between the Enter that armed it
-     * and the next keystroke.
+     * and the next content-producing edit.
      */
     readonly pendingParagraph: ISettableObservable<PendingParagraph | undefined, void>;
     readonly cursorOffset: IObservableWithChange<number | undefined, void>;
@@ -1152,8 +1156,8 @@ export declare class EditorModel {
      * The parsed document. Threads the previous document into the parser so
      * unchanged blocks keep their object identity across reparses (see
      * {@link MarkdownParser.parse}). Writing `previous` inside the compute is
-     * a safe optimization: `derived` only recomputes when `sourceText`
-     * changes, and the result is structurally identical to a full reparse.
+     * safe: unchanged source reuses it directly, while changed source produces
+     * a result structurally identical to a full reparse.
      */
     readonly document: IObservableWithChange<DocumentAstNode, void>;
     /**
@@ -1198,7 +1202,7 @@ export declare class EditorModel {
      * AST node for it, and park the caret at the gap start. No source edit is
      * applied — the blank line exists only in the view until it is materialized.
      */
-    armPendingParagraph(req: Omit<PendingParagraph, 'syntheticAst' | 'cursorLine'>): void;
+    armPendingParagraph(req: Omit<PendingParagraph, 'syntheticAst' | 'cursorLine' | 'text'>): void;
     /** Discard the pending paragraph (if any) without touching the source. */
     cancelPendingParagraph(): void;
     /**
@@ -1207,12 +1211,16 @@ export declare class EditorModel {
      * state anchored to the previous parse.
      */
     replaceSourceText(text: StringValue): void;
+    /** Replace the transient horizontal whitespace on the pending line. */
+    setPendingParagraphText(text: string): void;
     /**
      * Turn the pending paragraph into real source: rewrite its gap so the typed
-     * `text` becomes its own paragraph, separated from its neighbours by blank
-     * lines, and place the caret after the inserted text.
+     * text, including any transient indentation, is separated from its neighbours
+     * by blank lines, and place the caret after it.
      */
     materializePendingParagraph(text: string): void;
+    /** Sets a rendered task checkbox state in either editing or read-only mode. */
+    setTaskCheckboxChecked(item: ListItemAstNode, checked: boolean): void;
     applyEdit(edit: StringEdit, selection?: Selection_2): void;
     applyEditForSelection(edit: StringEdit): void;
     private _applySourceEdit;
@@ -1433,12 +1441,13 @@ export declare class EditorView extends Disposable {
      */
     isPointInContent(point: Point2D): boolean;
     /**
-     * Whether `node` sits inside the rendered source text — the region whose
-     * selection this editor paints itself from `model.selection`. Overlays
-     * anchored beside the text (comment widgets and the like) are *not* part of
-     * it and keep their own native selection behaviour.
+     * Whether `range` intersects the rendered source text — the region whose
+     * selection this editor paints itself from `model.selection`. This also
+     * catches select-all ranges whose endpoints surround the rendered content.
+     * Overlays anchored beside the text (comment widgets and the like) are *not*
+     * part of it and keep their own native selection behaviour.
      */
-    containsRenderedContent(node: Node | null | undefined): boolean;
+    intersectsRenderedContent(range: Range): boolean;
     private readonly _renderAutorun;
     /** Current mounted blocks, or empty before the first render. */
     private get _blocks();
@@ -2563,6 +2572,11 @@ declare interface PendingParagraph {
     readonly separateFromPreviousBlock: boolean;
     /** Whether {@link replaceRange} ends at the end of the document. */
     readonly atEof: boolean;
+    /**
+     * Horizontal whitespace typed on the source-less line. It remains transient
+     * until other input materializes the paragraph. Contains only spaces and tabs.
+     */
+    readonly text: string;
     /** The source-less visual line occupied by the pending caret. */
     readonly cursorLine: VirtualCursorLine;
     /**
@@ -2584,29 +2598,34 @@ declare interface PendingParagraphResult {
 
 /**
  * View-data for the transient empty paragraph (see `PendingParagraph` in the
- * model). It carries only the throwaway {@link ParagraphAstNode} that gives the
- * rendered blank line a stable identity across frames, its anchor block, and
- * its source-less cursor line. It has no source content or selection range.
+ * model). It carries the throwaway {@link ParagraphAstNode} that gives the
+ * rendered line a stable identity across frames, its anchor block, source-less
+ * cursor line, and transient horizontal whitespace. It has no source content or
+ * selection range.
  */
 declare class PendingParagraphViewData {
     readonly ast: ParagraphAstNode;
     readonly anchorBlock: BlockAstNode;
     readonly cursorLine: VirtualCursorLine;
+    readonly text: string;
     readonly kind = "pendingParagraph";
-    constructor(ast: ParagraphAstNode, anchorBlock: BlockAstNode, cursorLine: VirtualCursorLine);
+    constructor(ast: ParagraphAstNode, anchorBlock: BlockAstNode, cursorLine: VirtualCursorLine, text: string);
 }
 
 /**
  * The mounted transient empty paragraph: a `<p class="md-pending-paragraph">`
- * holding a single `<br>` so it occupies a line's height. It is a leaf view
- * node with no inline source content; the document view publishes its element
- * geometry as a virtual visual line.
+ * holding either a `<br>` or decorated transient horizontal whitespace. It is a
+ * leaf view node with no inline source content; the document view publishes its
+ * element geometry as a virtual visual line.
  */
 declare class PendingParagraphViewNode extends ViewNode {
     readonly element: HTMLElement;
     readonly anchorBlock: BlockAstNode;
     readonly cursorLine: VirtualCursorLine;
+    private _text;
     constructor(view: PendingParagraphViewData);
+    update(text: string): void;
+    getCaretClientRect(): DOMRect;
 }
 
 /**