Expose undo stops in API?

[KevinWuWon]

Monaco has a concept of "undo stops" but doesn't give a way to access it without actually invoking undo.

I instrumented the onDidChangeContent with:

const model = editor.getModel();
model.onDidChangeContent(() => {
  console.log(model.getAlternativeVersionId());
});

And I can see that if I type "one two" then press undo, I see:

1 // o
2 // n
3 // e
4 // space
5 // t
6 // w
7 // o
3 // undo restores the text to "one"

So Monaco has decided to put an undo-stop in after version 3 based on some internal logic.

My wish: I'd like a field in IModelContentChangedEvent to indicate when an undo stop is created. eg.

model.onDidChangeContent(({isNewUndoStackElement}) => {
  // In the above example, isNewUndoStackElement would be true on the 1st and 4th call
});

The reason I want this is so I can integrate this into the broader undo stack of the document in which the monaco editor is embedded. eg. my document would have many monaco editors and when the user invokes undo, it would pick which of the monacos to send that undo request to; but in order to do so correctly, I would need an accurate recording of how many undo stops are being emitted by each of the monaco editors as their models change. For even more context, see here.

[smacke]

@KevinWuWon apologies for resurrecting an extremely old issue, but I'm trying to do something similar, and was wondering if you had any luck / workarounds with exposing the undo stop functionality in monaco -- any pointers are very much appreciated!

[KevinWuWon]

I did not, sorry.

[smacke]

I did not, sorry.

No worries; really appreciate your taking the time to respond!

[TheUnlocked]

For anyone looking at this in the future, after looking through the source code (in the microsoft/vscode repo, not this one) I came up with a hacky solution which appears to be working for my purposes (though of course ymmv with these kinds of things). The idea is to just intercept Monaco at the relevant functions so we can create our own event emitter (and then use that to set a flag when the stack updates and clear it after you're done processing it).

Here's what I'm using, depending on your use case you may want to change it a bit.

function interceptMonacoEditStack(model: editor.ITextModel, beforePushOrPop: () => void): { destroy(): void } {
    const pushStackElement = model.pushStackElement;
    const popStackElement = model.popStackElement;
    
    model.pushStackElement = function pushStackElement_hijacked() {
        beforePushOrPop();
        pushStackElement.apply(this);
    };

    model.popStackElement = function popStackElement_hijacked() {
        beforePushOrPop();
        popStackElement.apply(this);
    };
    
    return {
        destroy() {
            model.pushStackElement = pushStackElement;
            model.popStackElement = popStackElement;
        }
    };
}

Useful links in case you want to go digging through the source yourself:

• src/vs/editor/browser/widget/codeEditorWidget.ts
• src/vs/editor/common/model/textModel.ts
• src/vs/editor/common/model/editStack.ts

[smacke]

This is the approach I ended up taking too (patching pushStackElement). The other things needed were:

1. A way to check whether the model actually had any pending changes that got pushed, since this method could be called even when there was nothing to be done. This could be checked via model._commandManager._undoRedoService.getLastElement(model.uri)?._data?._changes != null

2. Registering hotkeys that override the default behavior for undo / redo -- when orchestrating across multiple editors, an undo in editor A may actually need to trigger a "local undo" in some other editor B.

I ended up not patching popStackElement since for my use case I only needed to see when an undo stop got pushed due to normal interactions of text input (and undo stops only get popped when you explicitly ask for an undo).

I also needed to make my patched pushStackElement default to the original behavior in case something like a redo was explicitly applied, which I didn't want to watch (just wanted to watch when undo stops were pushed via typing / text input).