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

Avoid loading the entire language service on the main thread code

Browse Source
pull/2757/head
Alex Dima 3 years ago
parent 9eba6e70b8
commit a6ebcecf27
No known key found for this signature in database
GPG Key ID: 39563C1504FDD0C9
6 changed files with 241 additions and 249 deletions
Show Stats Download Patch File Download Diff File

1
.prettierignore
Unescape Escape View File

@ -21,3 +21,4 @@
/monaco-typescript/out/
/monaco-typescript/release/
/monaco-typescript/src/lib/
/release/

5
gulpfile.js
Unescape Escape View File

@ -939,7 +939,10 @@ const generateTestSamplesTask = function () {
'</body>',
'</html>'
];
fs.writeFileSync(path.join(__dirname, 'monaco-editor/test/playground.generated/index.html'), index.join('\n'));
fs.writeFileSync(
path.join(__dirname, 'monaco-editor/test/playground.generated/index.html'),
index.join('\n')
);
};
function createSimpleServer(rootDir, port) {

128
monaco-css/src/languageFeatures.ts
Unescape Escape View File

@ -5,7 +5,7 @@
import { LanguageServiceDefaults } from './monaco.contribution';
import type { CSSWorker } from './cssWorker';
import * as cssService from 'vscode-css-languageservice';
import * as lsTypes from 'vscode-languageserver-types';
import {
languages,
editor,
@ -116,20 +116,20 @@ export class DiagnosticsAdapter {
function toSeverity(lsSeverity: number): MarkerSeverity {
switch (lsSeverity) {
case cssService.DiagnosticSeverity.Error:
case lsTypes.DiagnosticSeverity.Error:
return MarkerSeverity.Error;
case cssService.DiagnosticSeverity.Warning:
case lsTypes.DiagnosticSeverity.Warning:
return MarkerSeverity.Warning;
case cssService.DiagnosticSeverity.Information:
case lsTypes.DiagnosticSeverity.Information:
return MarkerSeverity.Info;
case cssService.DiagnosticSeverity.Hint:
case lsTypes.DiagnosticSeverity.Hint:
return MarkerSeverity.Hint;
default:
return MarkerSeverity.Info;
}
}
function toDiagnostics(resource: Uri, diag: cssService.Diagnostic): editor.IMarkerData {
function toDiagnostics(resource: Uri, diag: lsTypes.Diagnostic): editor.IMarkerData {
let code = typeof diag.code === 'number' ? String(diag.code) : <string>diag.code;
return {
@ -146,14 +146,14 @@ function toDiagnostics(resource: Uri, diag: cssService.Diagnostic): editor.IMark
// --- completion ------
function fromPosition(position: Position): cssService.Position {
function fromPosition(position: Position): lsTypes.Position {
if (!position) {
return void 0;
}
return { character: position.column - 1, line: position.lineNumber - 1 };
}
function fromRange(range: IRange): cssService.Range {
function fromRange(range: IRange): lsTypes.Range {
if (!range) {
return void 0;
}
@ -166,7 +166,7 @@ function fromRange(range: IRange): cssService.Range {
};
}
function toRange(range: cssService.Range): Range {
function toRange(range: lsTypes.Range): Range {
if (!range) {
return void 0;
}
@ -189,47 +189,47 @@ function toCompletionItemKind(kind: number): languages.CompletionItemKind {
let mItemKind = languages.CompletionItemKind;
switch (kind) {
case cssService.CompletionItemKind.Text:
case lsTypes.CompletionItemKind.Text:
return mItemKind.Text;
case cssService.CompletionItemKind.Method:
case lsTypes.CompletionItemKind.Method:
return mItemKind.Method;
case cssService.CompletionItemKind.Function:
case lsTypes.CompletionItemKind.Function:
return mItemKind.Function;
case cssService.CompletionItemKind.Constructor:
case lsTypes.CompletionItemKind.Constructor:
return mItemKind.Constructor;
case cssService.CompletionItemKind.Field:
case lsTypes.CompletionItemKind.Field:
return mItemKind.Field;
case cssService.CompletionItemKind.Variable:
case lsTypes.CompletionItemKind.Variable:
return mItemKind.Variable;
case cssService.CompletionItemKind.Class:
case lsTypes.CompletionItemKind.Class:
return mItemKind.Class;
case cssService.CompletionItemKind.Interface:
case lsTypes.CompletionItemKind.Interface:
return mItemKind.Interface;
case cssService.CompletionItemKind.Module:
case lsTypes.CompletionItemKind.Module:
return mItemKind.Module;
case cssService.CompletionItemKind.Property:
case lsTypes.CompletionItemKind.Property:
return mItemKind.Property;
case cssService.CompletionItemKind.Unit:
case lsTypes.CompletionItemKind.Unit:
return mItemKind.Unit;
case cssService.CompletionItemKind.Value:
case lsTypes.CompletionItemKind.Value:
return mItemKind.Value;
case cssService.CompletionItemKind.Enum:
case lsTypes.CompletionItemKind.Enum:
return mItemKind.Enum;
case cssService.CompletionItemKind.Keyword:
case lsTypes.CompletionItemKind.Keyword:
return mItemKind.Keyword;
case cssService.CompletionItemKind.Snippet:
case lsTypes.CompletionItemKind.Snippet:
return mItemKind.Snippet;
case cssService.CompletionItemKind.Color:
case lsTypes.CompletionItemKind.Color:
return mItemKind.Color;
case cssService.CompletionItemKind.File:
case lsTypes.CompletionItemKind.File:
return mItemKind.File;
case cssService.CompletionItemKind.Reference:
case lsTypes.CompletionItemKind.Reference:
return mItemKind.Reference;
}
return mItemKind.Property;
}
function toTextEdit(textEdit: cssService.TextEdit): editor.ISingleEditOperation {
function toTextEdit(textEdit: lsTypes.TextEdit): editor.ISingleEditOperation {
if (!textEdit) {
return void 0;
}
@ -239,7 +239,7 @@ function toTextEdit(textEdit: cssService.TextEdit): editor.ISingleEditOperation
};
}
function toCommand(c: cssService.Command | undefined): languages.Command {
function toCommand(c: lsTypes.Command | undefined): languages.Command {
return c && c.command === 'editor.action.triggerSuggest'
? { id: c.command, title: c.title, arguments: c.arguments }
: undefined;
@ -302,7 +302,7 @@ export class CompletionAdapter implements languages.CompletionItemProvider {
if (entry.additionalTextEdits) {
item.additionalTextEdits = entry.additionalTextEdits.map(toTextEdit);
}
if (entry.insertTextFormat === cssService.InsertTextFormat.Snippet) {
if (entry.insertTextFormat === lsTypes.InsertTextFormat.Snippet) {
item.insertTextRules = languages.CompletionItemInsertTextRule.InsertAsSnippet;
}
return item;
@ -316,15 +316,13 @@ export class CompletionAdapter implements languages.CompletionItemProvider {
}
}
function isMarkupContent(thing: any): thing is cssService.MarkupContent {
function isMarkupContent(thing: any): thing is lsTypes.MarkupContent {
return (
thing && typeof thing === 'object' && typeof (<cssService.MarkupContent>thing).kind === 'string'
thing && typeof thing === 'object' && typeof (<lsTypes.MarkupContent>thing).kind === 'string'
);
}
function toMarkdownString(
entry: cssService.MarkupContent | cssService.MarkedString
): IMarkdownString {
function toMarkdownString(entry: lsTypes.MarkupContent | lsTypes.MarkedString): IMarkdownString {
if (typeof entry === 'string') {
return {
value: entry
@ -345,7 +343,7 @@ function toMarkdownString(
}
function toMarkedStringArray(
contents: cssService.MarkupContent | cssService.MarkedString | cssService.MarkedString[]
contents: lsTypes.MarkupContent | lsTypes.MarkedString | lsTypes.MarkedString[]
): IMarkdownString[] {
if (!contents) {
return void 0;
@ -388,11 +386,11 @@ export class HoverAdapter implements languages.HoverProvider {
function toDocumentHighlightKind(kind: number): languages.DocumentHighlightKind {
switch (kind) {
case cssService.DocumentHighlightKind.Read:
case lsTypes.DocumentHighlightKind.Read:
return languages.DocumentHighlightKind.Read;
case cssService.DocumentHighlightKind.Write:
case lsTypes.DocumentHighlightKind.Write:
return languages.DocumentHighlightKind.Write;
case cssService.DocumentHighlightKind.Text:
case lsTypes.DocumentHighlightKind.Text:
return languages.DocumentHighlightKind.Text;
}
return languages.DocumentHighlightKind.Text;
@ -428,7 +426,7 @@ export class DocumentHighlightAdapter implements languages.DocumentHighlightProv
// --- definition ------
function toLocation(location: cssService.Location): languages.Location {
function toLocation(location: lsTypes.Location): languages.Location {
return {
uri: Uri.parse(location.uri),
range: toRange(location.range)
@ -486,7 +484,7 @@ export class ReferenceAdapter implements languages.ReferenceProvider {
// --- rename ------
function toWorkspaceEdit(edit: cssService.WorkspaceEdit): languages.WorkspaceEdit {
function toWorkspaceEdit(edit: lsTypes.WorkspaceEdit): languages.WorkspaceEdit {
if (!edit || !edit.changes) {
return void 0;
}
@ -532,45 +530,45 @@ export class RenameAdapter implements languages.RenameProvider {
// --- document symbols ------
function toSymbolKind(kind: cssService.SymbolKind): languages.SymbolKind {
function toSymbolKind(kind: lsTypes.SymbolKind): languages.SymbolKind {
let mKind = languages.SymbolKind;
switch (kind) {
case cssService.SymbolKind.File:
case lsTypes.SymbolKind.File:
return mKind.Array;
case cssService.SymbolKind.Module:
case lsTypes.SymbolKind.Module:
return mKind.Module;
case cssService.SymbolKind.Namespace:
case lsTypes.SymbolKind.Namespace:
return mKind.Namespace;
case cssService.SymbolKind.Package:
case lsTypes.SymbolKind.Package:
return mKind.Package;
case cssService.SymbolKind.Class:
case lsTypes.SymbolKind.Class:
return mKind.Class;
case cssService.SymbolKind.Method:
case lsTypes.SymbolKind.Method:
return mKind.Method;
case cssService.SymbolKind.Property:
case lsTypes.SymbolKind.Property:
return mKind.Property;
case cssService.SymbolKind.Field:
case lsTypes.SymbolKind.Field:
return mKind.Field;
case cssService.SymbolKind.Constructor:
case lsTypes.SymbolKind.Constructor:
return mKind.Constructor;
case cssService.SymbolKind.Enum:
case lsTypes.SymbolKind.Enum:
return mKind.Enum;
case cssService.SymbolKind.Interface:
case lsTypes.SymbolKind.Interface:
return mKind.Interface;
case cssService.SymbolKind.Function:
case lsTypes.SymbolKind.Function:
return mKind.Function;
case cssService.SymbolKind.Variable:
case lsTypes.SymbolKind.Variable:
return mKind.Variable;
case cssService.SymbolKind.Constant:
case lsTypes.SymbolKind.Constant:
return mKind.Constant;
case cssService.SymbolKind.String:
case lsTypes.SymbolKind.String:
return mKind.String;
case cssService.SymbolKind.Number:
case lsTypes.SymbolKind.Number:
return mKind.Number;
case cssService.SymbolKind.Boolean:
case lsTypes.SymbolKind.Boolean:
return mKind.Boolean;
case cssService.SymbolKind.Array:
case lsTypes.SymbolKind.Array:
return mKind.Array;
}
return mKind.Function;
@ -679,7 +677,7 @@ export class FoldingRangeAdapter implements languages.FoldingRangeProvider {
end: range.endLine + 1
};
if (typeof range.kind !== 'undefined') {
result.kind = toFoldingRangeKind(<cssService.FoldingRangeKind>range.kind);
result.kind = toFoldingRangeKind(<lsTypes.FoldingRangeKind>range.kind);
}
return result;
});
@ -687,13 +685,13 @@ export class FoldingRangeAdapter implements languages.FoldingRangeProvider {
}
}
function toFoldingRangeKind(kind: cssService.FoldingRangeKind): languages.FoldingRangeKind {
function toFoldingRangeKind(kind: lsTypes.FoldingRangeKind): languages.FoldingRangeKind {
switch (kind) {
case cssService.FoldingRangeKind.Comment:
case lsTypes.FoldingRangeKind.Comment:
return languages.FoldingRangeKind.Comment;
case cssService.FoldingRangeKind.Imports:
case lsTypes.FoldingRangeKind.Imports:
return languages.FoldingRangeKind.Imports;
case cssService.FoldingRangeKind.Region:
case lsTypes.FoldingRangeKind.Region:
return languages.FoldingRangeKind.Region;
}
}

8
monaco-editor/test/dev-setup.js
Unescape Escape View File

@ -142,7 +142,13 @@
let RESOLVED_CORE = new Component('editor', 'vs', METADATA.CORE.paths);
self.RESOLVED_CORE_PATH = RESOLVED_CORE.getResolvedPath('');
let RESOLVED_PLUGINS = METADATA.PLUGINS.map(function (plugin) {
return new Component(plugin.name, plugin.modulePrefix, plugin.paths, plugin.rootPath, plugin.contrib);
return new Component(
plugin.name,
plugin.modulePrefix,
plugin.paths,
plugin.rootPath,
plugin.contrib
);
});
METADATA = null;

174
monaco-html/src/languageFeatures.ts
Unescape Escape View File

@ -4,7 +4,7 @@
*--------------------------------------------------------------------------------------------*/
import type { HTMLWorker } from './htmlWorker';
import * as htmlService from 'vscode-html-languageservice';
import * as lsTypes from 'vscode-languageserver-types';
import {
languages,
editor,
@ -21,14 +21,14 @@ export interface WorkerAccessor {
// --- completion ------
function fromPosition(position: Position): htmlService.Position {
function fromPosition(position: Position): lsTypes.Position {
if (!position) {
return void 0;
}
return { character: position.column - 1, line: position.lineNumber - 1 };
}
function fromRange(range: Range): htmlService.Range {
function fromRange(range: Range): lsTypes.Range {
if (!range) {
return void 0;
}
@ -38,7 +38,7 @@ function fromRange(range: Range): htmlService.Range {
};
}
function toRange(range: htmlService.Range): Range {
function toRange(range: lsTypes.Range): Range {
if (!range) {
return void 0;
}
@ -51,11 +51,11 @@ function toRange(range: htmlService.Range): Range {
}
function isInsertReplaceEdit(
edit: htmlService.TextEdit | htmlService.InsertReplaceEdit
): edit is htmlService.InsertReplaceEdit {
edit: lsTypes.TextEdit | lsTypes.InsertReplaceEdit
): edit is lsTypes.InsertReplaceEdit {
return (
typeof (<htmlService.InsertReplaceEdit>edit).insert !== 'undefined' &&
typeof (<htmlService.InsertReplaceEdit>edit).replace !== 'undefined'
typeof (<lsTypes.InsertReplaceEdit>edit).insert !== 'undefined' &&
typeof (<lsTypes.InsertReplaceEdit>edit).replace !== 'undefined'
);
}
@ -63,93 +63,91 @@ function toCompletionItemKind(kind: number): languages.CompletionItemKind {
const mItemKind = languages.CompletionItemKind;
switch (kind) {
case htmlService.CompletionItemKind.Text:
case lsTypes.CompletionItemKind.Text:
return mItemKind.Text;
case htmlService.CompletionItemKind.Method:
case lsTypes.CompletionItemKind.Method:
return mItemKind.Method;
case htmlService.CompletionItemKind.Function:
case lsTypes.CompletionItemKind.Function:
return mItemKind.Function;
case htmlService.CompletionItemKind.Constructor:
case lsTypes.CompletionItemKind.Constructor:
return mItemKind.Constructor;
case htmlService.CompletionItemKind.Field:
case lsTypes.CompletionItemKind.Field:
return mItemKind.Field;
case htmlService.CompletionItemKind.Variable:
case lsTypes.CompletionItemKind.Variable:
return mItemKind.Variable;
case htmlService.CompletionItemKind.Class:
case lsTypes.CompletionItemKind.Class:
return mItemKind.Class;
case htmlService.CompletionItemKind.Interface:
case lsTypes.CompletionItemKind.Interface:
return mItemKind.Interface;
case htmlService.CompletionItemKind.Module:
case lsTypes.CompletionItemKind.Module:
return mItemKind.Module;
case htmlService.CompletionItemKind.Property:
case lsTypes.CompletionItemKind.Property:
return mItemKind.Property;
case htmlService.CompletionItemKind.Unit:
case lsTypes.CompletionItemKind.Unit:
return mItemKind.Unit;
case htmlService.CompletionItemKind.Value:
case lsTypes.CompletionItemKind.Value:
return mItemKind.Value;
case htmlService.CompletionItemKind.Enum:
case lsTypes.CompletionItemKind.Enum:
return mItemKind.Enum;
case htmlService.CompletionItemKind.Keyword:
case lsTypes.CompletionItemKind.Keyword:
return mItemKind.Keyword;
case htmlService.CompletionItemKind.Snippet:
case lsTypes.CompletionItemKind.Snippet:
return mItemKind.Snippet;
case htmlService.CompletionItemKind.Color:
case lsTypes.CompletionItemKind.Color:
return mItemKind.Color;
case htmlService.CompletionItemKind.File:
case lsTypes.CompletionItemKind.File:
return mItemKind.File;
case htmlService.CompletionItemKind.Reference:
case lsTypes.CompletionItemKind.Reference:
return mItemKind.Reference;
}
return mItemKind.Property;
}
function fromCompletionItemKind(
kind: languages.CompletionItemKind
): htmlService.CompletionItemKind {
function fromCompletionItemKind(kind: languages.CompletionItemKind): lsTypes.CompletionItemKind {
const mItemKind = languages.CompletionItemKind;
switch (kind) {
case mItemKind.Text:
return htmlService.CompletionItemKind.Text;
return lsTypes.CompletionItemKind.Text;
case mItemKind.Method:
return htmlService.CompletionItemKind.Method;
return lsTypes.CompletionItemKind.Method;
case mItemKind.Function:
return htmlService.CompletionItemKind.Function;
return lsTypes.CompletionItemKind.Function;
case mItemKind.Constructor:
return htmlService.CompletionItemKind.Constructor;
return lsTypes.CompletionItemKind.Constructor;
case mItemKind.Field:
return htmlService.CompletionItemKind.Field;
return lsTypes.CompletionItemKind.Field;
case mItemKind.Variable:
return htmlService.CompletionItemKind.Variable;
return lsTypes.CompletionItemKind.Variable;
case mItemKind.Class:
return htmlService.CompletionItemKind.Class;
return lsTypes.CompletionItemKind.Class;
case mItemKind.Interface:
return htmlService.CompletionItemKind.Interface;
return lsTypes.CompletionItemKind.Interface;
case mItemKind.Module:
return htmlService.CompletionItemKind.Module;
return lsTypes.CompletionItemKind.Module;
case mItemKind.Property:
return htmlService.CompletionItemKind.Property;
return lsTypes.CompletionItemKind.Property;
case mItemKind.Unit:
return htmlService.CompletionItemKind.Unit;
return lsTypes.CompletionItemKind.Unit;
case mItemKind.Value:
return htmlService.CompletionItemKind.Value;
return lsTypes.CompletionItemKind.Value;
case mItemKind.Enum:
return htmlService.CompletionItemKind.Enum;
return lsTypes.CompletionItemKind.Enum;
case mItemKind.Keyword:
return htmlService.CompletionItemKind.Keyword;
return lsTypes.CompletionItemKind.Keyword;
case mItemKind.Snippet:
return htmlService.CompletionItemKind.Snippet;
return lsTypes.CompletionItemKind.Snippet;
case mItemKind.Color:
return htmlService.CompletionItemKind.Color;
return lsTypes.CompletionItemKind.Color;
case mItemKind.File:
return htmlService.CompletionItemKind.File;
return lsTypes.CompletionItemKind.File;
case mItemKind.Reference:
return htmlService.CompletionItemKind.Reference;
return lsTypes.CompletionItemKind.Reference;
}
return htmlService.CompletionItemKind.Property;
return lsTypes.CompletionItemKind.Property;
}
function toTextEdit(textEdit: htmlService.TextEdit): editor.ISingleEditOperation {
function toTextEdit(textEdit: lsTypes.TextEdit): editor.ISingleEditOperation {
if (!textEdit) {
return void 0;
}
@ -159,7 +157,7 @@ function toTextEdit(textEdit: htmlService.TextEdit): editor.ISingleEditOperation
};
}
function toCommand(c: htmlService.Command | undefined): languages.Command {
function toCommand(c: lsTypes.Command | undefined): languages.Command {
return c && c.command === 'editor.action.triggerSuggest'
? { id: c.command, title: c.title, arguments: c.arguments }
: undefined;
@ -222,7 +220,7 @@ export class CompletionAdapter implements languages.CompletionItemProvider {
if (entry.additionalTextEdits) {
item.additionalTextEdits = entry.additionalTextEdits.map(toTextEdit);
}
if (entry.insertTextFormat === htmlService.InsertTextFormat.Snippet) {
if (entry.insertTextFormat === lsTypes.InsertTextFormat.Snippet) {
item.insertTextRules = languages.CompletionItemInsertTextRule.InsertAsSnippet;
}
return item;
@ -238,17 +236,13 @@ export class CompletionAdapter implements languages.CompletionItemProvider {
// --- hover ------
function isMarkupContent(thing: any): thing is htmlService.MarkupContent {
function isMarkupContent(thing: any): thing is lsTypes.MarkupContent {
return (
thing &&
typeof thing === 'object' &&
typeof (<htmlService.MarkupContent>thing).kind === 'string'
thing && typeof thing === 'object' && typeof (<lsTypes.MarkupContent>thing).kind === 'string'
);
}
function toMarkdownString(
entry: htmlService.MarkupContent | htmlService.MarkedString
): IMarkdownString {
function toMarkdownString(entry: lsTypes.MarkupContent | lsTypes.MarkedString): IMarkdownString {
if (typeof entry === 'string') {
return {
value: entry
@ -269,7 +263,7 @@ function toMarkdownString(
}
function toMarkedStringArray(
contents: htmlService.MarkupContent | htmlService.MarkedString | htmlService.MarkedString[]
contents: lsTypes.MarkupContent | lsTypes.MarkedString | lsTypes.MarkedString[]
): IMarkdownString[] {
if (!contents) {
return void 0;
@ -308,15 +302,15 @@ export class HoverAdapter implements languages.HoverProvider {
// --- document highlights ------
function toHighlighKind(kind: htmlService.DocumentHighlightKind): languages.DocumentHighlightKind {
function toHighlighKind(kind: lsTypes.DocumentHighlightKind): languages.DocumentHighlightKind {
const mKind = languages.DocumentHighlightKind;
switch (kind) {
case htmlService.DocumentHighlightKind.Read:
case lsTypes.DocumentHighlightKind.Read:
return mKind.Read;
case htmlService.DocumentHighlightKind.Write:
case lsTypes.DocumentHighlightKind.Write:
return mKind.Write;
case htmlService.DocumentHighlightKind.Text:
case lsTypes.DocumentHighlightKind.Text:
return mKind.Text;
}
return mKind.Text;
@ -348,45 +342,45 @@ export class DocumentHighlightAdapter implements languages.DocumentHighlightProv
// --- document symbols ------
function toSymbolKind(kind: htmlService.SymbolKind): languages.SymbolKind {
function toSymbolKind(kind: lsTypes.SymbolKind): languages.SymbolKind {
let mKind = languages.SymbolKind;
switch (kind) {
case htmlService.SymbolKind.File:
case lsTypes.SymbolKind.File:
return mKind.Array;
case htmlService.SymbolKind.Module:
case lsTypes.SymbolKind.Module:
return mKind.Module;
case htmlService.SymbolKind.Namespace:
case lsTypes.SymbolKind.Namespace:
return mKind.Namespace;
case htmlService.SymbolKind.Package:
case lsTypes.SymbolKind.Package:
return mKind.Package;
case htmlService.SymbolKind.Class:
case lsTypes.SymbolKind.Class:
return mKind.Class;
case htmlService.SymbolKind.Method:
case lsTypes.SymbolKind.Method:
return mKind.Method;
case htmlService.SymbolKind.Property:
case lsTypes.SymbolKind.Property:
return mKind.Property;
case htmlService.SymbolKind.Field:
case lsTypes.SymbolKind.Field:
return mKind.Field;
case htmlService.SymbolKind.Constructor:
case lsTypes.SymbolKind.Constructor:
return mKind.Constructor;
case htmlService.SymbolKind.Enum:
case lsTypes.SymbolKind.Enum:
return mKind.Enum;
case htmlService.SymbolKind.Interface:
case lsTypes.SymbolKind.Interface:
return mKind.Interface;
case htmlService.SymbolKind.Function:
case lsTypes.SymbolKind.Function:
return mKind.Function;
case htmlService.SymbolKind.Variable:
case lsTypes.SymbolKind.Variable:
return mKind.Variable;
case htmlService.SymbolKind.Constant:
case lsTypes.SymbolKind.Constant:
return mKind.Constant;
case htmlService.SymbolKind.String:
case lsTypes.SymbolKind.String:
return mKind.String;
case htmlService.SymbolKind.Number:
case lsTypes.SymbolKind.Number:
return mKind.Number;
case htmlService.SymbolKind.Boolean:
case lsTypes.SymbolKind.Boolean:
return mKind.Boolean;
case htmlService.SymbolKind.Array:
case lsTypes.SymbolKind.Array:
return mKind.Array;
}
return mKind.Function;
@ -445,9 +439,7 @@ export class DocumentLinkAdapter implements languages.LinkProvider {
}
}
function fromFormattingOptions(
options: languages.FormattingOptions
): htmlService.FormattingOptions {
function fromFormattingOptions(options: languages.FormattingOptions): lsTypes.FormattingOptions {
return {
tabSize: options.tabSize,
insertSpaces: options.insertSpaces
@ -524,7 +516,7 @@ export class RenameAdapter implements languages.RenameProvider {
}
}
function toWorkspaceEdit(edit: htmlService.WorkspaceEdit): languages.WorkspaceEdit {
function toWorkspaceEdit(edit: lsTypes.WorkspaceEdit): languages.WorkspaceEdit {
if (!edit || !edit.changes) {
return void 0;
}
@ -568,7 +560,7 @@ export class FoldingRangeAdapter implements languages.FoldingRangeProvider {
end: range.endLine + 1
};
if (typeof range.kind !== 'undefined') {
result.kind = toFoldingRangeKind(<htmlService.FoldingRangeKind>range.kind);
result.kind = toFoldingRangeKind(<lsTypes.FoldingRangeKind>range.kind);
}
return result;
});
@ -576,13 +568,13 @@ export class FoldingRangeAdapter implements languages.FoldingRangeProvider {
}
}
function toFoldingRangeKind(kind: htmlService.FoldingRangeKind): languages.FoldingRangeKind {
function toFoldingRangeKind(kind: lsTypes.FoldingRangeKind): languages.FoldingRangeKind {
switch (kind) {
case htmlService.FoldingRangeKind.Comment:
case lsTypes.FoldingRangeKind.Comment:
return languages.FoldingRangeKind.Comment;
case htmlService.FoldingRangeKind.Imports:
case lsTypes.FoldingRangeKind.Imports:
return languages.FoldingRangeKind.Imports;
case htmlService.FoldingRangeKind.Region:
case lsTypes.FoldingRangeKind.Region:
return languages.FoldingRangeKind.Region;
}
}

174
monaco-json/src/languageFeatures.ts
Unescape Escape View File

@ -17,7 +17,7 @@ import {
MarkerSeverity,
IMarkdownString
} from './fillers/monaco-editor-core';
import * as jsonService from 'vscode-json-languageservice';
import * as lsTypes from 'vscode-languageserver-types';
export interface WorkerAccessor {
(...more: Uri[]): Promise<JSONWorker>;
@ -127,20 +127,20 @@ export class DiagnosticsAdapter {
function toSeverity(lsSeverity: number): MarkerSeverity {
switch (lsSeverity) {
case jsonService.DiagnosticSeverity.Error:
case lsTypes.DiagnosticSeverity.Error:
return MarkerSeverity.Error;
case jsonService.DiagnosticSeverity.Warning:
case lsTypes.DiagnosticSeverity.Warning:
return MarkerSeverity.Warning;
case jsonService.DiagnosticSeverity.Information:
case lsTypes.DiagnosticSeverity.Information:
return MarkerSeverity.Info;
case jsonService.DiagnosticSeverity.Hint:
case lsTypes.DiagnosticSeverity.Hint:
return MarkerSeverity.Hint;
default:
return MarkerSeverity.Info;
}
}
function toDiagnostics(resource: Uri, diag: jsonService.Diagnostic): editor.IMarkerData {
function toDiagnostics(resource: Uri, diag: lsTypes.Diagnostic): editor.IMarkerData {
let code = typeof diag.code === 'number' ? String(diag.code) : <string>diag.code;
return {
@ -157,14 +157,14 @@ function toDiagnostics(resource: Uri, diag: jsonService.Diagnostic): editor.IMar
// --- completion ------
function fromPosition(position: Position): jsonService.Position {
function fromPosition(position: Position): lsTypes.Position {
if (!position) {
return void 0;
}
return { character: position.column - 1, line: position.lineNumber - 1 };
}
function fromRange(range: IRange): jsonService.Range {
function fromRange(range: IRange): lsTypes.Range {
if (!range) {
return void 0;
}
@ -176,7 +176,7 @@ function fromRange(range: IRange): jsonService.Range {
end: { line: range.endLineNumber - 1, character: range.endColumn - 1 }
};
}
function toRange(range: jsonService.Range): Range {
function toRange(range: lsTypes.Range): Range {
if (!range) {
return void 0;
}
@ -196,15 +196,15 @@ interface InsertReplaceEdit {
/**
* The range if the insert is requested
*/
insert: jsonService.Range;
insert: lsTypes.Range;
/**
* The range if the replace is requested.
*/
replace: jsonService.Range;
replace: lsTypes.Range;
}
function isInsertReplaceEdit(
edit: jsonService.TextEdit | InsertReplaceEdit
edit: lsTypes.TextEdit | InsertReplaceEdit
): edit is InsertReplaceEdit {
return (
typeof (<InsertReplaceEdit>edit).insert !== 'undefined' &&
@ -216,93 +216,91 @@ function toCompletionItemKind(kind: number): languages.CompletionItemKind {
let mItemKind = languages.CompletionItemKind;
switch (kind) {
case jsonService.CompletionItemKind.Text:
case lsTypes.CompletionItemKind.Text:
return mItemKind.Text;
case jsonService.CompletionItemKind.Method:
case lsTypes.CompletionItemKind.Method:
return mItemKind.Method;
case jsonService.CompletionItemKind.Function:
case lsTypes.CompletionItemKind.Function:
return mItemKind.Function;
case jsonService.CompletionItemKind.Constructor:
case lsTypes.CompletionItemKind.Constructor:
return mItemKind.Constructor;
case jsonService.CompletionItemKind.Field:
case lsTypes.CompletionItemKind.Field:
return mItemKind.Field;
case jsonService.CompletionItemKind.Variable:
case lsTypes.CompletionItemKind.Variable:
return mItemKind.Variable;
case jsonService.CompletionItemKind.Class:
case lsTypes.CompletionItemKind.Class:
return mItemKind.Class;
case jsonService.CompletionItemKind.Interface:
case lsTypes.CompletionItemKind.Interface:
return mItemKind.Interface;
case jsonService.CompletionItemKind.Module:
case lsTypes.CompletionItemKind.Module:
return mItemKind.Module;
case jsonService.CompletionItemKind.Property:
case lsTypes.CompletionItemKind.Property:
return mItemKind.Property;
case jsonService.CompletionItemKind.Unit:
case lsTypes.CompletionItemKind.Unit:
return mItemKind.Unit;
case jsonService.CompletionItemKind.Value:
case lsTypes.CompletionItemKind.Value:
return mItemKind.Value;
case jsonService.CompletionItemKind.Enum:
case lsTypes.CompletionItemKind.Enum:
return mItemKind.Enum;
case jsonService.CompletionItemKind.Keyword:
case lsTypes.CompletionItemKind.Keyword:
return mItemKind.Keyword;
case jsonService.CompletionItemKind.Snippet:
case lsTypes.CompletionItemKind.Snippet:
return mItemKind.Snippet;
case jsonService.CompletionItemKind.Color:
case lsTypes.CompletionItemKind.Color:
return mItemKind.Color;
case jsonService.CompletionItemKind.File:
case lsTypes.CompletionItemKind.File:
return mItemKind.File;
case jsonService.CompletionItemKind.Reference:
case lsTypes.CompletionItemKind.Reference:
return mItemKind.Reference;
}
return mItemKind.Property;
}
function fromCompletionItemKind(
kind: languages.CompletionItemKind
): jsonService.CompletionItemKind {
function fromCompletionItemKind(kind: languages.CompletionItemKind): lsTypes.CompletionItemKind {
let mItemKind = languages.CompletionItemKind;
switch (kind) {
case mItemKind.Text:
return jsonService.CompletionItemKind.Text;
return lsTypes.CompletionItemKind.Text;
case mItemKind.Method:
return jsonService.CompletionItemKind.Method;
return lsTypes.CompletionItemKind.Method;
case mItemKind.Function:
return jsonService.CompletionItemKind.Function;
return lsTypes.CompletionItemKind.Function;
case mItemKind.Constructor:
return jsonService.CompletionItemKind.Constructor;
return lsTypes.CompletionItemKind.Constructor;
case mItemKind.Field:
return jsonService.CompletionItemKind.Field;
return lsTypes.CompletionItemKind.Field;
case mItemKind.Variable:
return jsonService.CompletionItemKind.Variable;
return lsTypes.CompletionItemKind.Variable;
case mItemKind.Class:
return jsonService.CompletionItemKind.Class;
return lsTypes.CompletionItemKind.Class;
case mItemKind.Interface:
return jsonService.CompletionItemKind.Interface;
return lsTypes.CompletionItemKind.Interface;
case mItemKind.Module:
return jsonService.CompletionItemKind.Module;
return lsTypes.CompletionItemKind.Module;
case mItemKind.Property:
return jsonService.CompletionItemKind.Property;
return lsTypes.CompletionItemKind.Property;
case mItemKind.Unit:
return jsonService.CompletionItemKind.Unit;
return lsTypes.CompletionItemKind.Unit;
case mItemKind.Value:
return jsonService.CompletionItemKind.Value;
return lsTypes.CompletionItemKind.Value;
case mItemKind.Enum:
return jsonService.CompletionItemKind.Enum;
return lsTypes.CompletionItemKind.Enum;
case mItemKind.Keyword:
return jsonService.CompletionItemKind.Keyword;
return lsTypes.CompletionItemKind.Keyword;
case mItemKind.Snippet:
return jsonService.CompletionItemKind.Snippet;
return lsTypes.CompletionItemKind.Snippet;
case mItemKind.Color:
return jsonService.CompletionItemKind.Color;
return lsTypes.CompletionItemKind.Color;
case mItemKind.File:
return jsonService.CompletionItemKind.File;
return lsTypes.CompletionItemKind.File;
case mItemKind.Reference:
return jsonService.CompletionItemKind.Reference;
return lsTypes.CompletionItemKind.Reference;
}
return jsonService.CompletionItemKind.Property;
return lsTypes.CompletionItemKind.Property;
}
function toTextEdit(textEdit: jsonService.TextEdit): editor.ISingleEditOperation {
function toTextEdit(textEdit: lsTypes.TextEdit): editor.ISingleEditOperation {
if (!textEdit) {
return void 0;
}
@ -312,7 +310,7 @@ function toTextEdit(textEdit: jsonService.TextEdit): editor.ISingleEditOperation
};
}
function toCommand(c: jsonService.Command | undefined): languages.Command {
function toCommand(c: lsTypes.Command | undefined): languages.Command {
return c && c.command === 'editor.action.triggerSuggest'
? { id: c.command, title: c.title, arguments: c.arguments }
: undefined;
@ -375,7 +373,7 @@ export class CompletionAdapter implements languages.CompletionItemProvider {
if (entry.additionalTextEdits) {
item.additionalTextEdits = entry.additionalTextEdits.map(toTextEdit);
}
if (entry.insertTextFormat === jsonService.InsertTextFormat.Snippet) {
if (entry.insertTextFormat === lsTypes.InsertTextFormat.Snippet) {
item.insertTextRules = languages.CompletionItemInsertTextRule.InsertAsSnippet;
}
return item;
@ -389,17 +387,13 @@ export class CompletionAdapter implements languages.CompletionItemProvider {
}
}
function isMarkupContent(thing: any): thing is jsonService.MarkupContent {
function isMarkupContent(thing: any): thing is lsTypes.MarkupContent {
return (
thing &&
typeof thing === 'object' &&
typeof (<jsonService.MarkupContent>thing).kind === 'string'
thing && typeof thing === 'object' && typeof (<lsTypes.MarkupContent>thing).kind === 'string'
);
}
function toMarkdownString(
entry: jsonService.MarkupContent | jsonService.MarkedString
): IMarkdownString {
function toMarkdownString(entry: lsTypes.MarkupContent | lsTypes.MarkedString): IMarkdownString {
if (typeof entry === 'string') {
return {
value: entry
@ -420,7 +414,7 @@ function toMarkdownString(
}
function toMarkedStringArray(
contents: jsonService.MarkupContent | jsonService.MarkedString | jsonService.MarkedString[]
contents: lsTypes.MarkupContent | lsTypes.MarkedString | lsTypes.MarkedString[]
): IMarkdownString[] {
if (!contents) {
return void 0;
@ -461,7 +455,7 @@ export class HoverAdapter implements languages.HoverProvider {
// --- definition ------
function toLocation(location: jsonService.Location): languages.Location {
function toLocation(location: lsTypes.Location): languages.Location {
return {
uri: Uri.parse(location.uri),
range: toRange(location.range)
@ -470,45 +464,45 @@ function toLocation(location: jsonService.Location): languages.Location {
// --- document symbols ------
function toSymbolKind(kind: jsonService.SymbolKind): languages.SymbolKind {
function toSymbolKind(kind: lsTypes.SymbolKind): languages.SymbolKind {
let mKind = languages.SymbolKind;
switch (kind) {
case jsonService.SymbolKind.File:
case lsTypes.SymbolKind.File:
return mKind.Array;
case jsonService.SymbolKind.Module:
case lsTypes.SymbolKind.Module:
return mKind.Module;
case jsonService.SymbolKind.Namespace:
case lsTypes.SymbolKind.Namespace:
return mKind.Namespace;
case jsonService.SymbolKind.Package:
case lsTypes.SymbolKind.Package:
return mKind.Package;
case jsonService.SymbolKind.Class:
case lsTypes.SymbolKind.Class:
return mKind.Class;
case jsonService.SymbolKind.Method:
case lsTypes.SymbolKind.Method:
return mKind.Method;
case jsonService.SymbolKind.Property:
case lsTypes.SymbolKind.Property:
return mKind.Property;
case jsonService.SymbolKind.Field:
case lsTypes.SymbolKind.Field:
return mKind.Field;
case jsonService.SymbolKind.Constructor:
case lsTypes.SymbolKind.Constructor:
return mKind.Constructor;
case jsonService.SymbolKind.Enum:
case lsTypes.SymbolKind.Enum:
return mKind.Enum;
case jsonService.SymbolKind.Interface:
case lsTypes.SymbolKind.Interface:
return mKind.Interface;
case jsonService.SymbolKind.Function:
case lsTypes.SymbolKind.Function:
return mKind.Function;
case jsonService.SymbolKind.Variable:
case lsTypes.SymbolKind.Variable:
return mKind.Variable;
case jsonService.SymbolKind.Constant:
case lsTypes.SymbolKind.Constant:
return mKind.Constant;
case jsonService.SymbolKind.String:
case lsTypes.SymbolKind.String:
return mKind.String;
case jsonService.SymbolKind.Number:
case lsTypes.SymbolKind.Number:
return mKind.Number;
case jsonService.SymbolKind.Boolean:
case lsTypes.SymbolKind.Boolean:
return mKind.Boolean;
case jsonService.SymbolKind.Array:
case lsTypes.SymbolKind.Array:
return mKind.Array;
}
return mKind.Function;
@ -542,9 +536,7 @@ export class DocumentSymbolAdapter implements languages.DocumentSymbolProvider {
}
}
function fromFormattingOptions(
options: languages.FormattingOptions
): jsonService.FormattingOptions {
function fromFormattingOptions(options: languages.FormattingOptions): lsTypes.FormattingOptions {
return {
tabSize: options.tabSize,
insertSpaces: options.insertSpaces
@ -675,7 +667,7 @@ export class FoldingRangeAdapter implements languages.FoldingRangeProvider {
end: range.endLine + 1
};
if (typeof range.kind !== 'undefined') {
result.kind = toFoldingRangeKind(<jsonService.FoldingRangeKind>range.kind);
result.kind = toFoldingRangeKind(<lsTypes.FoldingRangeKind>range.kind);
}
return result;
});
@ -683,13 +675,13 @@ export class FoldingRangeAdapter implements languages.FoldingRangeProvider {
}
}
function toFoldingRangeKind(kind: jsonService.FoldingRangeKind): languages.FoldingRangeKind {
function toFoldingRangeKind(kind: lsTypes.FoldingRangeKind): languages.FoldingRangeKind {
switch (kind) {
case jsonService.FoldingRangeKind.Comment:
case lsTypes.FoldingRangeKind.Comment:
return languages.FoldingRangeKind.Comment;
case jsonService.FoldingRangeKind.Imports:
case lsTypes.FoldingRangeKind.Imports:
return languages.FoldingRangeKind.Imports;
case jsonService.FoldingRangeKind.Region:
case lsTypes.FoldingRangeKind.Region:
return languages.FoldingRangeKind.Region;
}
return void 0;

Write Preview
Loading…
Cancel
Save