@vscode/markdown-editor 0.0.2-39 → 0.0.2-40

package/dist/index.d.ts

@@ -875,6 +875,7 @@ export declare class EditorController extends Disposable {
     private _desiredColumn;
     private readonly _keyboardPlatform;
     private readonly _keyboardProfile;
+    private readonly _historyStrategy;
     /** Running click count for the current multi-click sequence (1, 2, 3, …). */
     private _clickCount;
     /** Timestamp and position of the previous pointer-down, for multi-click detection. */
@@ -886,6 +887,7 @@ export declare class EditorController extends Disposable {
     private _makeVisualCursorContext;
     private _executeCursorCommand;
     private _executeEditCommand;
+    private _runUndoableEdit;
     private _executeVisualCursorCommand;
     /** Move the cursor down one visual line (Arrow Down). */
     cursorDown(extend?: boolean): void;
@@ -930,6 +932,12 @@ export declare interface EditorControllerOptions {
      * strategy (e.g. `AsyncClipboardStrategy`) in hosts that swallow them.
      */
     readonly clipboardStrategy?: IClipboardStrategy;
+    /**
+     * Where undo and redo are executed: `LocalHistoryStrategy` for a
+     * self-contained editor, or a strategy that forwards to the host's own
+     * document history. Left unset, the chords are passed on to the host.
+     */
+    readonly historyStrategy?: IHistoryStrategy;
     readonly keyboardPlatform?: KeyboardPlatform;
     readonly keyboardProfile?: KeyboardProfile;
 }
@@ -969,6 +977,9 @@ export declare type EditorKeyboardAction = {
 } | {
     readonly kind: 'edit';
     readonly command: EditKeyboardAction;
+} | {
+    readonly kind: 'history';
+    readonly command: HistoryKeyboardAction;
 } | {
     readonly kind: 'selectAll';
 } | {
@@ -1094,6 +1105,12 @@ export declare class EditorModel {
     }): void;
     /** Discard the pending paragraph (if any) without touching the source. */
     cancelPendingParagraph(): void;
+    /**
+     * Replace the source with an authoritative value from the host, mapping the
+     * selection through the changed span and atomically discarding transient
+     * state anchored to the previous parse.
+     */
+    replaceSourceText(text: StringValue): 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
@@ -1478,6 +1495,8 @@ declare class HeadingViewData {
 
 export declare function hiddenCursorRanges(doc: DocumentAstNode, markerVisibleBlocks: ReadonlySet<BlockAstNode>, cursor: number): readonly OffsetRange[];
 
+declare type HistoryKeyboardAction = 'undo' | 'redo';
+
 /**
  * The editor operations a clipboard strategy drives. The strategy never
  * touches the model or the DOM directly — it asks through this seam, so the
@@ -1577,6 +1596,22 @@ declare interface IEmbeddedCodeEditorFactory {
     create(language: string, initialContent: string): IEmbeddedCodeEditor | undefined;
 }
 
+/**
+ * Routes undo and redo to whatever owns the document's history: the editor
+ * itself on a standalone page, or the enclosing document in a host like
+ * VS Code.
+ */
+export declare interface IHistoryStrategy {
+    undo(): void;
+    redo(): void;
+    /**
+     * Invoked around each source mutation so the strategy can record it.
+     * Implemented only by strategies that build their own history; a host that
+     * forwards edits to a VS Code `TextDocument` lets it record them instead.
+     */
+    record?(operation: () => void, edit?: StringEdit): void;
+}
+
 export declare class ImageAstNode extends AstNode {
     readonly alt: string;
     readonly url: string;
@@ -1851,6 +1886,32 @@ declare class ListViewData {
     constructor(ast: ListAstNode, content: readonly AnyViewData[]);
 }
 
+/**
+ * Compact in-memory history for editors that hold the only copy of the
+ * document, such as a standalone browser page. Where the surrounding host
+ * already records history — a VS Code `TextDocument` — forward to that
+ * instead.
+ */
+export declare class LocalHistoryStrategy implements IHistoryStrategy {
+    private readonly _model;
+    private readonly _past;
+    private readonly _future;
+    /**
+     * The source text as of the last change this strategy recorded or applied.
+     * Any other value means the document was replaced behind its back, so the
+     * stored edits no longer line up and must be discarded rather than applied.
+     */
+    private _lastKnownText;
+    constructor(_model: EditorModel);
+    record(operation: () => void, edit?: StringEdit): void;
+    undo(): void;
+    redo(): void;
+    /** The entry on top of `stack`, or `undefined` when it cannot be applied. */
+    private _peekApplicable;
+    private _apply;
+    private _clear;
+}
+
 /**
  * Parses markdown into a {@link DocumentAstNode}.
  *
@@ -2126,7 +2187,7 @@ declare class ParagraphViewData {
 /**
  * A *transient* editing state: the empty paragraph the user conjured by
  * pressing Enter at the end of a paragraph. Markdown has no empty-paragraph
- * node, so this never lives in {@link EditorModel.sourceText} or the parsed
+ * node, so this never lives in {@link EditorModel['sourceText']} or the parsed
  * {@link EditorModel.document} — it is pure edit intent that the view renders
  * as a synthetic blank line and that the controller either *materializes* (the
  * user types) or *cancels* (the user navigates away / backspaces).
@@ -2401,6 +2462,11 @@ export declare class StringReplacement {
     constructor(replaceRange: OffsetRange, newText: string);
     get isEmpty(): boolean;
     equals(other: StringReplacement): boolean;
+    /**
+     * Narrows this replacement to the span that actually changes, by trimming
+     * the prefix and suffix it shares with the text it replaces in `source`.
+     */
+    removeCommonSuffixPrefix(source: string): StringReplacement;
     toString(): string;
 }