go to definition - different model: loading via http

[mbana]

i'm adding a go to definition feature using a langserver.

monaco notices it's a new model 👍, and then tries to load it.
the ranges of the place that contains definition is correct.

does monaco support in-place replacement of the model?
what i'm seeing is that it just offers to download the whole
file containing the resulting definition, i.e., this line
window.open(data.resource.toString());.

---

https://github.com/Microsoft/vscode/blob/0d6a9f8389cd044851ac994e527969bd53d2d387/src/vs/editor/browser/standalone/simpleServices.ts#L134

in my monaco build:

private doOpenEditor(editor:editorCommon.ICommonCodeEditor, data:IResourceInput): IEditor {
	var model = this.findModel(editor, data);
	if (!model) {
		if (data.resource) {
			if (this.openEditorDelegate) {
				this.openEditorDelegate(data.resource.toString());
				return null;
			} else {
				var schema = data.resource.scheme;
				if (schema === Schemas.http || schema === Schemas.https) {
					// This is a fully qualified http or https URL
					window.open(data.resource.toString());
					return this.editor;
				}
			}
		}
		return null;
	}


	var selection = <editorCommon.IRange>data.options.selection;
	if (selection) {
		if (typeof selection.endLineNumber === 'number' && typeof selection.endColumn === 'number') {
			editor.setSelection(selection);
			editor.revealRangeInCenter(selection);
		} else {
			var pos = {
				lineNumber: selection.startLineNumber,
				column: selection.startColumn
			};
			editor.setPosition(pos);
			editor.revealPositionInCenter(pos);
		}
	}

	return this.editor;
}

[alexdima]

You would need to provide a custom implementation of IEditorService. Services can be overriden when creating the editor (last argument):

    /**
     * Create a new editor under `domElement`.
     * `domElement` should be empty (not contain other dom nodes).
     * The editor will read the size of `domElement`.
     */
    export function create(domElement: HTMLElement, options?: IEditorConstructionOptions, override?: IEditorOverrideServices): IStandaloneCodeEditor;

i.e.

monaco.editor.create(domNode, options, { editorService: myEditorServiceInstanceHere });

You would need to find the service shape from vscode's sources, we do not plan to expose all services shapes in the public API (monaco.d.ts). You can also consult the simple services implementation we ship with simpleServices.ts

[kitsonk]

@alexandrudima I have tried doing as instructed, but I am not getting the editor service called when I would expect it to...

Here is the stub service I have at the moment:

class EditorService {
	_serviceBrand: any;
	openEditor(input: ResourceInput, sideBySide?: boolean): Promise<monaco.editor.IEditor> {
		console.log('openEditor', input);
		return Promise.resolve({});
	}
	resolveEditor(input: ResourceInput, refresh?: boolean): Promise<TextEditorModel> {
		console.log('resolveEditor', input);
		return Promise.resolve({});
	}
}

And here is how I am creating my editor instance:

const editorService = new EditorService();
const editor = monaco.editor.create(_root, options, { editorService });

But I can't seem to find any action in the editor that calls those methods. I have tried the "Go to Definition" and the other commands and I am just not getting anything logged to the console. It feels like there is something else I need to wire up...

[alexdima]

@kitsonk 👍 That is the correct way to inject a different editorService in the editor. Here is a complete self-contained example that triggers the editorService:

You can run it anywhere in the playground

monaco.languages.register({ id: 'mySpecialLanguage' });

monaco.languages.registerDefinitionProvider('mySpecialLanguage', {
    provideDefinition: function(model, position, cancellationToken) {
        return {
            uri: monaco.Uri.parse('http://a/different/file.txt'),
            range: new monaco.Range(3, 1, 3, 1)
        };
    }
});

var editorService = {
	openEditor: function() {
		alert(`open editor called!` + JSON.stringify(arguments));
	},
	resolveEditor: function() {
		alert(`resolve editor called!` + JSON.stringify(arguments));
	}
};

monaco.editor.create(document.getElementById("container"), {
	value: '\n\Go to definition on this text',
	language: 'mySpecialLanguage'
}, { editorService: editorService });

[kitsonk]

Ok, thanks!! I will try again and try to figure where I got it wrong. 😁

[kitsonk]

Just for future generations... I was missing a definition provider for the language I was trying to provide the editor service for. Without a definition provider, the editor service doesn't get called.

[AviVahl]

You would need to find the service shape from vscode's sources, we do not plan to expose all services shapes in the public API (monaco.d.ts).

I find this statement a bit counter productive and am asking the monaco/vscode team to reconsider.

I am writing a custom integration to monaco where I have to replace some of these services as well.
Instead of enjoying the fact that vscode/monaco are written using TypeScript, I find myself having to go to original sources and copy-paste interfaces to get a properly typed integration.

The types are there, and the implementation can be overridden using the public API (third parameter of constructor). Is there any con to exposing all services interfaces as well?

[alexdima]

@AviVahl Exposing the services will leak hundreds of new types to monaco.d.ts. It would require quite a lot of work in monaco.d.ts.recipe to accomodate all those types that need to be added. The types in monaco.d.ts do not reflect the reality of the code. The code is written with AMD, while monaco.d.ts uses namespaces. It would also make a lot of the changes my teammates do in vscode to result in changes to monaco.d.ts, which is not something the team appreciates.

The 3rd argument is there exactly to allow custom more advanced integrators to do fun things... If you are doing such custom advanced stuff, I hope you can spend the extra few minutes to copy-paste the services types from the vscode repo and into your project... I know it is not optimal, but please keep in mind that the Monaco Editor is a by-product of VS Code and its sole reason for existance is VS Code.