github-forks
/
monaco-editor
mirror of https://github.com/microsoft/monaco-editor.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

adopt selection provider & rename provider

Browse Source
pull/2748/head
Martin Aeschlimann 5 years ago
parent 24a660f022
commit adf61a891c
3 changed files with 159 additions and 86 deletions
Show Stats Download Patch File Download Diff File

2
src/htmlMode.ts
Unescape Escape View File

@ -29,6 +29,8 @@ export function setupMode(defaults: LanguageServiceDefaultsImpl): void {
monaco.languages.registerLinkProvider(languageId, new languageFeatures.DocumentLinkAdapter(worker));
monaco.languages.registerFoldingRangeProvider(languageId, new languageFeatures.FoldingRangeAdapter(worker));
monaco.languages.registerDocumentSymbolProvider(languageId, new languageFeatures.DocumentSymbolAdapter(worker));
monaco.languages.registerSelectionRangeProvider(languageId, new languageFeatures.SelectionRangeAdapter(worker));
monaco.languages.registerRenameProvider(languageId, new languageFeatures.RenameAdapter(worker));
// only html
if (languageId === 'html') {

13
src/htmlWorker.ts
Unescape Escape View File

@ -65,11 +65,22 @@ export class HTMLWorker {
let symbols = this._languageService.findDocumentSymbols(document, htmlDocument);
return Promise.resolve(symbols);
}
provideFoldingRanges(uri: string, context?: { rangeLimit?: number; }): Thenable<htmlService.FoldingRange[]> {
getFoldingRanges(uri: string, context?: { rangeLimit?: number; }): Thenable<htmlService.FoldingRange[]> {
let document = this._getTextDocument(uri);
let ranges = this._languageService.getFoldingRanges(document, context);
return Promise.resolve(ranges);
}
getSelectionRanges(uri: string, positions: htmlService.Position[]): Thenable<htmlService.SelectionRange[]> {
let document = this._getTextDocument(uri);
let ranges = this._languageService.getSelectionRanges(document, positions);
return Promise.resolve(ranges);
}
doRename(uri: string, position: htmlService.Position, newName: string): Thenable<htmlService.WorkspaceEdit> {
let document = this._getTextDocument(uri);
let htmlDocument = this._languageService.parseHTMLDocument(document);
let renames = this._languageService.doRename(document, position, newName, htmlDocument);
return Promise.resolve(renames);
}
private _getTextDocument(uri: string): htmlService.TextDocument {
let models = this._ctx.getMirrorModels();
for (let model of models) {

230
src/languageFeatures.ts
Unescape Escape View File

@ -7,7 +7,7 @@
import { LanguageServiceDefaultsImpl } from './monaco.contribution';
import { HTMLWorker } from './htmlWorker';
import * as ls from 'vscode-languageserver-types';
import * as htmlService from 'vscode-html-languageservice';
import Uri = monaco.Uri;
import Position = monaco.Position;
@ -103,16 +103,16 @@ export class DiagnosticsAdapter {
function toSeverity(lsSeverity: number): monaco.MarkerSeverity {
switch (lsSeverity) {
case ls.DiagnosticSeverity.Error: return monaco.MarkerSeverity.Error;
case ls.DiagnosticSeverity.Warning: return monaco.MarkerSeverity.Warning;
case ls.DiagnosticSeverity.Information: return monaco.MarkerSeverity.Info;
case ls.DiagnosticSeverity.Hint: return monaco.MarkerSeverity.Hint;
case htmlService.DiagnosticSeverity.Error: return monaco.MarkerSeverity.Error;
case htmlService.DiagnosticSeverity.Warning: return monaco.MarkerSeverity.Warning;
case htmlService.DiagnosticSeverity.Information: return monaco.MarkerSeverity.Info;
case htmlService.DiagnosticSeverity.Hint: return monaco.MarkerSeverity.Hint;
default:
return monaco.MarkerSeverity.Info;
}
}
function toDiagnostics(resource: Uri, diag: ls.Diagnostic): monaco.editor.IMarkerData {
function toDiagnostics(resource: Uri, diag: htmlService.Diagnostic): monaco.editor.IMarkerData {
const code = typeof diag.code === 'number' ? String(diag.code) : <string>diag.code;
return {
@ -129,21 +129,21 @@ function toDiagnostics(resource: Uri, diag: ls.Diagnostic): monaco.editor.IMarke
// --- completion ------
function fromPosition(position: Position): ls.Position {
function fromPosition(position: Position): htmlService.Position {
if (!position) {
return void 0;
}
return { character: position.column - 1, line: position.lineNumber - 1 };
}
function fromRange(range: Range): ls.Range {
function fromRange(range: Range): htmlService.Range {
if (!range) {
return void 0;
}
return { start: fromPosition(range.getStartPosition()), end: fromPosition(range.getEndPosition()) };
}
function toRange(range: ls.Range): Range {
function toRange(range: htmlService.Range): Range {
if (!range) {
return void 0;
}
@ -154,55 +154,55 @@ function toCompletionItemKind(kind: number): monaco.languages.CompletionItemKind
const mItemKind = monaco.languages.CompletionItemKind;
switch (kind) {
case ls.CompletionItemKind.Text: return mItemKind.Text;
case ls.CompletionItemKind.Method: return mItemKind.Method;
case ls.CompletionItemKind.Function: return mItemKind.Function;
case ls.CompletionItemKind.Constructor: return mItemKind.Constructor;
case ls.CompletionItemKind.Field: return mItemKind.Field;
case ls.CompletionItemKind.Variable: return mItemKind.Variable;
case ls.CompletionItemKind.Class: return mItemKind.Class;
case ls.CompletionItemKind.Interface: return mItemKind.Interface;
case ls.CompletionItemKind.Module: return mItemKind.Module;
case ls.CompletionItemKind.Property: return mItemKind.Property;
case ls.CompletionItemKind.Unit: return mItemKind.Unit;
case ls.CompletionItemKind.Value: return mItemKind.Value;
case ls.CompletionItemKind.Enum: return mItemKind.Enum;
case ls.CompletionItemKind.Keyword: return mItemKind.Keyword;
case ls.CompletionItemKind.Snippet: return mItemKind.Snippet;
case ls.CompletionItemKind.Color: return mItemKind.Color;
case ls.CompletionItemKind.File: return mItemKind.File;
case ls.CompletionItemKind.Reference: return mItemKind.Reference;
case htmlService.CompletionItemKind.Text: return mItemKind.Text;
case htmlService.CompletionItemKind.Method: return mItemKind.Method;
case htmlService.CompletionItemKind.Function: return mItemKind.Function;
case htmlService.CompletionItemKind.Constructor: return mItemKind.Constructor;
case htmlService.CompletionItemKind.Field: return mItemKind.Field;
case htmlService.CompletionItemKind.Variable: return mItemKind.Variable;
case htmlService.CompletionItemKind.Class: return mItemKind.Class;
case htmlService.CompletionItemKind.Interface: return mItemKind.Interface;
case htmlService.CompletionItemKind.Module: return mItemKind.Module;
case htmlService.CompletionItemKind.Property: return mItemKind.Property;
case htmlService.CompletionItemKind.Unit: return mItemKind.Unit;
case htmlService.CompletionItemKind.Value: return mItemKind.Value;
case htmlService.CompletionItemKind.Enum: return mItemKind.Enum;
case htmlService.CompletionItemKind.Keyword: return mItemKind.Keyword;
case htmlService.CompletionItemKind.Snippet: return mItemKind.Snippet;
case htmlService.CompletionItemKind.Color: return mItemKind.Color;
case htmlService.CompletionItemKind.File: return mItemKind.File;
case htmlService.CompletionItemKind.Reference: return mItemKind.Reference;
}
return mItemKind.Property;
}
function fromCompletionItemKind(kind: monaco.languages.CompletionItemKind): ls.CompletionItemKind {
function fromCompletionItemKind(kind: monaco.languages.CompletionItemKind): htmlService.CompletionItemKind {
const mItemKind = monaco.languages.CompletionItemKind;
switch (kind) {
case mItemKind.Text: return ls.CompletionItemKind.Text;
case mItemKind.Method: return ls.CompletionItemKind.Method;
case mItemKind.Function: return ls.CompletionItemKind.Function;
case mItemKind.Constructor: return ls.CompletionItemKind.Constructor;
case mItemKind.Field: return ls.CompletionItemKind.Field;
case mItemKind.Variable: return ls.CompletionItemKind.Variable;
case mItemKind.Class: return ls.CompletionItemKind.Class;
case mItemKind.Interface: return ls.CompletionItemKind.Interface;
case mItemKind.Module: return ls.CompletionItemKind.Module;
case mItemKind.Property: return ls.CompletionItemKind.Property;
case mItemKind.Unit: return ls.CompletionItemKind.Unit;
case mItemKind.Value: return ls.CompletionItemKind.Value;
case mItemKind.Enum: return ls.CompletionItemKind.Enum;
case mItemKind.Keyword: return ls.CompletionItemKind.Keyword;
case mItemKind.Snippet: return ls.CompletionItemKind.Snippet;
case mItemKind.Color: return ls.CompletionItemKind.Color;
case mItemKind.File: return ls.CompletionItemKind.File;
case mItemKind.Reference: return ls.CompletionItemKind.Reference;
}
return ls.CompletionItemKind.Property;
case mItemKind.Text: return htmlService.CompletionItemKind.Text;
case mItemKind.Method: return htmlService.CompletionItemKind.Method;
case mItemKind.Function: return htmlService.CompletionItemKind.Function;
case mItemKind.Constructor: return htmlService.CompletionItemKind.Constructor;
case mItemKind.Field: return htmlService.CompletionItemKind.Field;
case mItemKind.Variable: return htmlService.CompletionItemKind.Variable;
case mItemKind.Class: return htmlService.CompletionItemKind.Class;
case mItemKind.Interface: return htmlService.CompletionItemKind.Interface;
case mItemKind.Module: return htmlService.CompletionItemKind.Module;
case mItemKind.Property: return htmlService.CompletionItemKind.Property;
case mItemKind.Unit: return htmlService.CompletionItemKind.Unit;
case mItemKind.Value: return htmlService.CompletionItemKind.Value;
case mItemKind.Enum: return htmlService.CompletionItemKind.Enum;
case mItemKind.Keyword: return htmlService.CompletionItemKind.Keyword;
case mItemKind.Snippet: return htmlService.CompletionItemKind.Snippet;
case mItemKind.Color: return htmlService.CompletionItemKind.Color;
case mItemKind.File: return htmlService.CompletionItemKind.File;
case mItemKind.Reference: return htmlService.CompletionItemKind.Reference;
}
return htmlService.CompletionItemKind.Property;
}
function toTextEdit(textEdit: ls.TextEdit): monaco.editor.ISingleEditOperation {
function toTextEdit(textEdit: htmlService.TextEdit): monaco.editor.ISingleEditOperation {
if (!textEdit) {
return void 0;
}
@ -251,7 +251,7 @@ export class CompletionAdapter implements monaco.languages.CompletionItemProvide
if (entry.additionalTextEdits) {
item.additionalTextEdits = entry.additionalTextEdits.map(toTextEdit)
}
if (entry.insertTextFormat === ls.InsertTextFormat.Snippet) {
if (entry.insertTextFormat === htmlService.InsertTextFormat.Snippet) {
item.insertTextRules = monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet;
}
return item;
@ -267,11 +267,11 @@ export class CompletionAdapter implements monaco.languages.CompletionItemProvide
// --- hover ------
function isMarkupContent(thing: any): thing is ls.MarkupContent {
return thing && typeof thing === 'object' && typeof (<ls.MarkupContent>thing).kind === 'string';
function isMarkupContent(thing: any): thing is htmlService.MarkupContent {
return thing && typeof thing === 'object' && typeof (<htmlService.MarkupContent>thing).kind === 'string';
}
function toMarkdownString(entry: ls.MarkupContent | ls.MarkedString): monaco.IMarkdownString {
function toMarkdownString(entry: htmlService.MarkupContent | htmlService.MarkedString): monaco.IMarkdownString {
if (typeof entry === 'string') {
return {
value: entry
@ -291,7 +291,7 @@ function toMarkdownString(entry: ls.MarkupContent | ls.MarkedString): monaco.IMa
return { value: '```' + entry.language + '\n' + entry.value + '\n```\n' };
}
function toMarkedStringArray(contents: ls.MarkupContent | ls.MarkedString | ls.MarkedString[]): monaco.IMarkdownString[] {
function toMarkedStringArray(contents: htmlService.MarkupContent | htmlService.MarkedString | htmlService.MarkedString[]): monaco.IMarkdownString[] {
if (!contents) {
return void 0;
}
@ -325,13 +325,13 @@ export class HoverAdapter implements monaco.languages.HoverProvider {
// --- document highlights ------
function toHighlighKind(kind: ls.DocumentHighlightKind): monaco.languages.DocumentHighlightKind {
function toHighlighKind(kind: htmlService.DocumentHighlightKind): monaco.languages.DocumentHighlightKind {
const mKind = monaco.languages.DocumentHighlightKind;
switch (kind) {
case ls.DocumentHighlightKind.Read: return mKind.Read;
case ls.DocumentHighlightKind.Write: return mKind.Write;
case ls.DocumentHighlightKind.Text: return mKind.Text;
case htmlService.DocumentHighlightKind.Read: return mKind.Read;
case htmlService.DocumentHighlightKind.Write: return mKind.Write;
case htmlService.DocumentHighlightKind.Text: return mKind.Text;
}
return mKind.Text;
}
@ -359,28 +359,28 @@ export class DocumentHighlightAdapter implements monaco.languages.DocumentHighli
// --- document symbols ------
function toSymbolKind(kind: ls.SymbolKind): monaco.languages.SymbolKind {
function toSymbolKind(kind: htmlService.SymbolKind): monaco.languages.SymbolKind {
let mKind = monaco.languages.SymbolKind;
switch (kind) {
case ls.SymbolKind.File: return mKind.Array;
case ls.SymbolKind.Module: return mKind.Module;
case ls.SymbolKind.Namespace: return mKind.Namespace;
case ls.SymbolKind.Package: return mKind.Package;
case ls.SymbolKind.Class: return mKind.Class;
case ls.SymbolKind.Method: return mKind.Method;
case ls.SymbolKind.Property: return mKind.Property;
case ls.SymbolKind.Field: return mKind.Field;
case ls.SymbolKind.Constructor: return mKind.Constructor;
case ls.SymbolKind.Enum: return mKind.Enum;
case ls.SymbolKind.Interface: return mKind.Interface;
case ls.SymbolKind.Function: return mKind.Function;
case ls.SymbolKind.Variable: return mKind.Variable;
case ls.SymbolKind.Constant: return mKind.Constant;
case ls.SymbolKind.String: return mKind.String;
case ls.SymbolKind.Number: return mKind.Number;
case ls.SymbolKind.Boolean: return mKind.Boolean;
case ls.SymbolKind.Array: return mKind.Array;
case htmlService.SymbolKind.File: return mKind.Array;
case htmlService.SymbolKind.Module: return mKind.Module;
case htmlService.SymbolKind.Namespace: return mKind.Namespace;
case htmlService.SymbolKind.Package: return mKind.Package;
case htmlService.SymbolKind.Class: return mKind.Class;
case htmlService.SymbolKind.Method: return mKind.Method;
case htmlService.SymbolKind.Property: return mKind.Property;
case htmlService.SymbolKind.Field: return mKind.Field;
case htmlService.SymbolKind.Constructor: return mKind.Constructor;
case htmlService.SymbolKind.Enum: return mKind.Enum;
case htmlService.SymbolKind.Interface: return mKind.Interface;
case htmlService.SymbolKind.Function: return mKind.Function;
case htmlService.SymbolKind.Variable: return mKind.Variable;
case htmlService.SymbolKind.Constant: return mKind.Constant;
case htmlService.SymbolKind.String: return mKind.String;
case htmlService.SymbolKind.Number: return mKind.Number;
case htmlService.SymbolKind.Boolean: return mKind.Boolean;
case htmlService.SymbolKind.Array: return mKind.Array;
}
return mKind.Function;
}
@ -433,7 +433,7 @@ export class DocumentLinkAdapter implements monaco.languages.LinkProvider {
}
function fromFormattingOptions(options: monaco.languages.FormattingOptions): ls.FormattingOptions {
function fromFormattingOptions(options: monaco.languages.FormattingOptions): htmlService.FormattingOptions {
return {
tabSize: options.tabSize,
insertSpaces: options.insertSpaces
@ -478,6 +478,42 @@ export class DocumentRangeFormattingEditProvider implements monaco.languages.Doc
}
}
export class RenameAdapter implements monaco.languages.RenameProvider {
constructor(private _worker: WorkerAccessor) {
}
provideRenameEdits(model: monaco.editor.IReadOnlyModel, position: Position, newName: string, token: CancellationToken): Thenable<monaco.languages.WorkspaceEdit> {
const resource = model.uri;
return this._worker(resource).then(worker => {
return worker.doRename(resource.toString(), fromPosition(position), newName);
}).then(edit => {
return toWorkspaceEdit(edit);
});
}
}
function toWorkspaceEdit(edit: htmlService.WorkspaceEdit): monaco.languages.WorkspaceEdit {
if (!edit || !edit.changes) {
return void 0;
}
let resourceEdits: monaco.languages.ResourceTextEdit[] = [];
for (let uri in edit.changes) {
let edits: monaco.languages.TextEdit[] = [];
for (let e of edit.changes[uri]) {
edits.push({
range: toRange(e.range),
text: e.newText
});
}
resourceEdits.push({ resource: Uri.parse(uri), edits: edits });
}
return {
edits: resourceEdits
}
}
export class FoldingRangeAdapter implements monaco.languages.FoldingRangeProvider {
constructor(private _worker: WorkerAccessor) {
@ -486,7 +522,7 @@ export class FoldingRangeAdapter implements monaco.languages.FoldingRangeProvide
public provideFoldingRanges(model: monaco.editor.IReadOnlyModel, context: monaco.languages.FoldingContext, token: CancellationToken): Thenable<monaco.languages.FoldingRange[]> {
const resource = model.uri;
return this._worker(resource).then(worker => worker.provideFoldingRanges(resource.toString(), context)).then(ranges => {
return this._worker(resource).then(worker => worker.getFoldingRanges(resource.toString(), context)).then(ranges => {
if (!ranges) {
return;
}
@ -496,7 +532,7 @@ export class FoldingRangeAdapter implements monaco.languages.FoldingRangeProvide
end: range.endLine + 1
};
if (typeof range.kind !== 'undefined') {
result.kind = toFoldingRangeKind(<ls.FoldingRangeKind>range.kind);
result.kind = toFoldingRangeKind(<htmlService.FoldingRangeKind>range.kind);
}
return result;
});
@ -505,11 +541,35 @@ export class FoldingRangeAdapter implements monaco.languages.FoldingRangeProvide
}
function toFoldingRangeKind(kind: ls.FoldingRangeKind): monaco.languages.FoldingRangeKind {
function toFoldingRangeKind(kind: htmlService.FoldingRangeKind): monaco.languages.FoldingRangeKind {
switch (kind) {
case ls.FoldingRangeKind.Comment: return monaco.languages.FoldingRangeKind.Comment;
case ls.FoldingRangeKind.Imports: return monaco.languages.FoldingRangeKind.Imports;
case ls.FoldingRangeKind.Region: return monaco.languages.FoldingRangeKind.Region;
case htmlService.FoldingRangeKind.Comment: return monaco.languages.FoldingRangeKind.Comment;
case htmlService.FoldingRangeKind.Imports: return monaco.languages.FoldingRangeKind.Imports;
case htmlService.FoldingRangeKind.Region: return monaco.languages.FoldingRangeKind.Region;
}
return void 0;
}
export class SelectionRangeAdapter implements monaco.languages.SelectionRangeProvider {
constructor(private _worker: WorkerAccessor) {
}
public provideSelectionRanges(model: monaco.editor.IReadOnlyModel, positions: Position[], token: CancellationToken): Thenable<monaco.languages.SelectionRange[][]> {
const resource = model.uri;
return this._worker(resource).then(worker => worker.getSelectionRanges(resource.toString(), positions.map(fromPosition))).then(selectionRanges => {
if (!selectionRanges) {
return;
}
return selectionRanges.map(selectionRange => {
const result: monaco.languages.SelectionRange[] = [];
while (selectionRange) {
result.push({ range: toRange(selectionRange.range) });
selectionRange = selectionRange.parent;
}
return result;
});
});
}
}
Write Preview
Loading…
Cancel
Save