How to use custom line numbers when peeking to another file/model?

[mrlacey]

I'm trying to find a way to use custom line numbering that is relative to the model/file being displayed and so works when I peek a definition.

The intention is that line numbers are used for a purpose other than displaying the actual line from the file but something relative to the content.

So, in the repro below, line numbers would either start with 'A' or '10' depending on the models.

Minimal repro of what I'm trying to do within the playground with this code:

const Model1Content = `line A
line B
line C
line D
etc.`;
const Model2Content = `line 10
line 11
line 12
line 13
line 14`;

var model1 = monaco.editor.createModel(Model1Content, "testlang", monaco.Uri.parse("model1"));
var model2 = monaco.editor.createModel(Model2Content, "testlang", monaco.Uri.parse("model2"));

monaco.languages.register({ id: "testlang" });

const customLineNumbers = (num) => {
        if (myEditor.getModel().uri == model1.uri) {
            const map = [ '', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'];
            return (num < map.length) ? map[num] : ' ';
        }
 
        return num;
}

const myEditor = monaco.editor.create(document.getElementById("container"), {
    language: 'testlang',
    automaticLayout: true,
    readOnly: true,
    codeLens: true,
    showFoldingControls: "never",
    definitionLinkOpensInPeek: true,
    occurrencesHighlight: "off",
    minimap: { enabled: false },
    lineNumbers: customLineNumbers,
    lineNumbersMinChars: 3,
    wordWrap: "on",
    scrollBeyondLastLine: false,
    scrollbar: { horizontal: 'hidden' },

    "semanticHighlighting.enabled": true,
});

myEditor.setModel(model1);

monaco.languages.registerDefinitionProvider("testlang", {
    provideDefinition: function (model, position) {

        if (model.uri == model1.uri) {

            if (position.lineNumber == 2) {
                return {
                    uri: model2.uri,
                    range: {
                        startLineNumber: 1,
                        startColumn: 1,
                        endLineNumber: 2,
                        endColumn: 1,
                    },
                }
            }
        }

        return undefined
    }
});

var commandId = myEditor.addCommand(
    0,
    function () {
        myEditor.setPosition({ lineNumber: 2, column: 2 });
        myEditor.trigger('source', 'editor.action.peekDefinition');
    },
    ""
);

monaco.languages.registerCodeLensProvider("testlang", {
    provideCodeLenses: function (model, token) {
        if (model.uri == model1.uri) {
            return {
                lenses: [
                    {
                        range: {
                            startLineNumber: 2,
                            startColumn: 1,
                            endLineNumber: 3,
                            endColumn: 1,
                        },
                        command: {
                            id: commandId,
                            title: "Peek other model",
                        },
                    },
                ],
                dispose: () => { },
            };
        }
        else
        {
            return undefined;
        }
    },
    resolveCodeLens: function (model, codeLens, token) {
        return codeLens;
    },
});

This currently produces this when clicking on the definition link:

The editor always seems to think the model is the one I originally set, not the one from the definition and the one being shown inline.
Is the inline editor (used for peeking) part of the same "editor" or is it a different one?
Is there a way to do what I'm trying?
Also, is there a way to tell if a model is being displayed in a peeked/inline way?

[mrlacey]

I found a way to do this with onDidCreateEditor.

When that is fired, I look at the uri of the new model and use an appropriate method to set the different line number.

Like this:

const customLineNumbersAlpha = (num) => {
    const map = [ '', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'];
    return (num < map.length) ? map[num] : ' ';
}

const customLineNumbersFrom10 = (num) => {
    const map = [ '', '10', '11', '12', '13', '14', '15', '16'];
    return (num < map.length) ? map[num] : ' ';
}


monaco.editor.onDidCreateEditor(newEditor => {
    newEditor.onDidChangeModel(e => {

        if (e.newModelUrl == model1.uri)
        {
                newEditor.updateOptions({ lineNumbers: customLineNumbersAlpha });
        }
        else if (e.newModelUrl == model2.uri)
        {
                newEditor.updateOptions({ lineNumbers: customLineNumbersFrom10 });
        }
    });
});

See it working in the playground