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/out/
/monaco-typescript/release/ /monaco-typescript/release/
/monaco-typescript/src/lib/ /monaco-typescript/src/lib/
/release/

5
gulpfile.js
Unescape Escape View File

@ -939,7 +939,10 @@ const generateTestSamplesTask = function () {
'</body>', '</body>',
'</html>' '</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) { function createSimpleServer(rootDir, port) {

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

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

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

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

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

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

Write Preview
Loading…
Cancel
Save