Bump Monaco to 0.18.1

CHANGELOG.md

@@ -1,6 +1,10 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+## [0.10.3] - 2019-10-01
+
+- Upgraded  to Monaco 0.18.1
+
 ## [0.10.2] - 2019-09-10
 
 - register language features regardless whether a language is registered (https://github.com/TypeFox/monaco-languageclient/commit/0559be6c20744182ede699f594fdbe6d9f3d7145)
@@ -130,6 +134,7 @@ In order to use `vscode-languageclient` directly the compatibility layer was imp
 ## 0.1.0 - 2017-0
 - initial 0.1.0 release, depends on Monaco 0.9.0
 
+[0.10.3]: https://github.com/TypeFox/monaco-languageclient/compare/v0.10.2...v0.10.3
 [0.10.2]: https://github.com/TypeFox/monaco-languageclient/compare/v0.10.1...v0.10.2
 [0.10.1]: https://github.com/TypeFox/monaco-languageclient/compare/v0.10.0...v0.10.1
 [0.10.0]: https://github.com/TypeFox/monaco-languageclient/compare/v0.9.0...v0.10.0

client/src/monaco-converter.ts

@@ -17,7 +17,7 @@ import {
     SymbolInformation, DocumentSymbolParams, CodeActionContext, DiagnosticSeverity,
     Command, CodeLens, FormattingOptions, TextEdit, WorkspaceEdit, DocumentLinkParams, DocumentLink,
     MarkedString, MarkupContent, ColorInformation, ColorPresentation, FoldingRange, FoldingRangeKind,
-    DiagnosticRelatedInformation, MarkupKind, SymbolKind, DocumentSymbol, CodeAction
+    DiagnosticRelatedInformation, MarkupKind, SymbolKind, DocumentSymbol, CodeAction, SignatureHelpContext, SignatureHelpTriggerKind
 } from './services';
 import IReadOnlyModel = monaco.editor.IReadOnlyModel;
 
@@ -34,7 +34,7 @@ export namespace ProtocolDocumentLink {
     }
 }
 
-export interface ProtocolCodeLens extends monaco.languages.ICodeLensSymbol {
+export interface ProtocolCodeLens extends monaco.languages.CodeLens {
     data?: any;
 }
 export namespace ProtocolCodeLens {
@@ -113,12 +113,71 @@ export class MonacoToProtocolConverter {
 
     asCompletionContext(context: monaco.languages.CompletionContext): CompletionContext {
         return {
-            triggerKind: this.asTriggerKind(context.triggerKind),
+            triggerKind: this.asCompletionTriggerKind(context.triggerKind),
             triggerCharacter: context.triggerCharacter
         }
     }
 
-    asTriggerKind(triggerKind: monaco.languages.CompletionTriggerKind): CompletionTriggerKind {
+    asSignatureHelpContext(context: monaco.languages.SignatureHelpContext) : SignatureHelpContext {
+        return {
+            triggerKind: this.asSignatureHelpTriggerKind(context.triggerKind),
+            triggerCharacter: context.triggerCharacter,
+            isRetrigger: context.isRetrigger,
+            activeSignatureHelp: this.asSignatureHelp(context.activeSignatureHelp)
+        };
+    }
+
+    asSignatureHelp(signatureHelp: monaco.languages.SignatureHelp | undefined) : SignatureHelp | undefined {
+        if(signatureHelp === undefined) {
+            return undefined;
+        }
+        return {
+            signatures: signatureHelp.signatures.map(signatureInfo => this.asSignatureInformation(signatureInfo)),
+            activeParameter: signatureHelp.activeParameter,
+            activeSignature: signatureHelp.activeSignature
+        };
+    }
+
+    asSignatureInformation(signatureInformation: monaco.languages.SignatureInformation) : SignatureInformation {
+        return {
+            documentation: this.asMarkupContent(signatureInformation.documentation),
+            label: signatureInformation.label,
+            parameters: signatureInformation.parameters.map(paramInfo => this.asParameterInformation(paramInfo))
+        };
+    }
+
+    asParameterInformation(parameterInformation: monaco.languages.ParameterInformation) : ParameterInformation {
+        return {
+            documentation: this.asMarkupContent(parameterInformation.documentation),
+            label: parameterInformation.label
+        };
+    }
+
+    asMarkupContent(markupContent: (string | monaco.IMarkdownString | undefined)): string | MarkupContent | undefined {
+        if(markupContent === undefined) {
+            return undefined;
+        }
+        if(typeof markupContent === "string") {
+            return markupContent;
+        }
+        return {
+            kind: MarkupKind.Markdown,
+            value: markupContent.value
+        };
+    }
+
+    asSignatureHelpTriggerKind(triggerKind: monaco.languages.SignatureHelpTriggerKind) : SignatureHelpTriggerKind {
+        switch  (triggerKind) {
+            case monaco.languages.SignatureHelpTriggerKind.ContentChange:
+                return SignatureHelpTriggerKind.ContentChange;
+            case monaco.languages.SignatureHelpTriggerKind.TriggerCharacter:
+                return SignatureHelpTriggerKind.TriggerCharacter;
+            default:
+                return SignatureHelpTriggerKind.Invoke;
+        }
+    }
+
+    asCompletionTriggerKind(triggerKind: monaco.languages.CompletionTriggerKind): CompletionTriggerKind {
         switch (triggerKind) {
             case monaco.languages.CompletionTriggerKind.TriggerCharacter:
                 return CompletionTriggerKind.TriggerCharacter;
@@ -322,7 +381,7 @@ export class MonacoToProtocolConverter {
         return undefined;
     }
 
-    asCodeLens(item: monaco.languages.ICodeLensSymbol): CodeLens {
+    asCodeLens(item: monaco.languages.CodeLens): CodeLens {
         let result = CodeLens.create(this.asRange(item.range));
         if (item.command) { result.command = this.asCommand(item.command); }
         if (ProtocolCodeLens.is(item)) {
@@ -462,10 +521,10 @@ export class ProtocolToMonacoConverter {
         return items.map(item => this.asTextEdit(item));
     }
 
-    asCodeLens(item: CodeLens): monaco.languages.ICodeLensSymbol;
+    asCodeLens(item: CodeLens): monaco.languages.CodeLens;
     asCodeLens(item: undefined | null): undefined;
-    asCodeLens(item: CodeLens | undefined | null): monaco.languages.ICodeLensSymbol | undefined;
-    asCodeLens(item: CodeLens | undefined | null): monaco.languages.ICodeLensSymbol | undefined {
+    asCodeLens(item: CodeLens | undefined | null): monaco.languages.CodeLens | undefined;
+    asCodeLens(item: CodeLens | undefined | null): monaco.languages.CodeLens | undefined {
         if (!item) {
             return undefined;
         }
@@ -476,21 +535,27 @@ export class ProtocolToMonacoConverter {
         return result;
     }
 
-    asCodeLenses(items: CodeLens[]): monaco.languages.ICodeLensSymbol[];
-    asCodeLenses(items: undefined | null): undefined;
-    asCodeLenses(items: CodeLens[] | undefined | null): monaco.languages.ICodeLensSymbol[] | undefined;
-    asCodeLenses(items: CodeLens[] | undefined | null): monaco.languages.ICodeLensSymbol[] | undefined {
+    asCodeLensList(items: CodeLens[]): monaco.languages.CodeLensList;
+    asCodeLensList(items: undefined | null): undefined;
+    asCodeLensList(items: CodeLens[] | undefined | null): monaco.languages.CodeLensList | undefined;
+    asCodeLensList(items: CodeLens[] | undefined | null): monaco.languages.CodeLensList | undefined {
         if (!items) {
             return undefined;
         }
-        return items.map((codeLens) => this.asCodeLens(codeLens));
+        return {
+            lenses: items.map((codeLens) => this.asCodeLens(codeLens)),
+            dispose: () => {}
+        };
     }
 
-    asCodeActions(actions: (Command | CodeAction)[]): (monaco.languages.Command | monaco.languages.CodeAction)[] {
-        return actions.map(action => this.asCodeAction(action));
+    asCodeActionList(actions: (Command | CodeAction)[]): monaco.languages.CodeActionList {
+        return {
+            actions: actions.map(action => this.asCodeAction(action)),
+            dispose: () => {}
+        };
     }
 
-    asCodeAction(item: Command | CodeAction): monaco.languages.Command | monaco.languages.CodeAction {
+    asCodeAction(item: Command | CodeAction): monaco.languages.CodeAction {
         if (CodeAction.is(item)) {
             return {
                 title: item.title,
@@ -530,6 +595,7 @@ export class ProtocolToMonacoConverter {
             name: value.name,
             detail: value.detail || "",
             kind: this.asSymbolKind(value.kind),
+            tags: [],
             range: this.asRange(value.range),
             selectionRange: this.asRange(value.selectionRange),
             children
@@ -560,6 +626,7 @@ export class ProtocolToMonacoConverter {
             detail: '',
             containerName: item.containerName,
             kind: this.asSymbolKind(item.kind),
+            tags: [],
             range: location.range,
             selectionRange: location.range
         };
@@ -639,10 +706,10 @@ export class ProtocolToMonacoConverter {
         }
     }
 
-    asSignatureHelp(item: undefined | null): undefined;
-    asSignatureHelp(item: SignatureHelp): monaco.languages.SignatureHelp;
-    asSignatureHelp(item: SignatureHelp | undefined | null): monaco.languages.SignatureHelp | undefined;
-    asSignatureHelp(item: SignatureHelp | undefined | null): monaco.languages.SignatureHelp | undefined {
+    asSignatureHelpResult(item: undefined | null): undefined;
+    asSignatureHelpResult(item: SignatureHelp): monaco.languages.SignatureHelpResult;
+    asSignatureHelpResult(item: SignatureHelp | undefined | null): monaco.languages.SignatureHelpResult | undefined;
+    asSignatureHelpResult(item: SignatureHelp | undefined | null): monaco.languages.SignatureHelpResult | undefined {
         if (!item) {
             return undefined;
         }
@@ -664,7 +731,10 @@ export class ProtocolToMonacoConverter {
         } else {
             result.signatures = [];
         }
-        return result;
+        return {
+            value: result,
+            dispose: () => {}
+        };
     }
 
     asSignatureInformations(items: SignatureInformation[]): monaco.languages.SignatureInformation[] {

client/src/monaco-languages.ts

@@ -125,20 +125,16 @@ export class MonacoLanguages implements Languages {
 
     protected createSignatureHelpProvider(selector: DocumentSelector, provider: SignatureHelpProvider, ...triggerCharacters: string[]): monaco.languages.SignatureHelpProvider {
         const signatureHelpTriggerCharacters = [...(provider.triggerCharacters || triggerCharacters || [])];
-        // TODO support regrigger characters after Monaco udpate
         return {
             signatureHelpTriggerCharacters,
-            provideSignatureHelp: async (model, position, token) => {
+            signatureHelpRetriggerCharacters: provider.retriggerCharacters,
+            provideSignatureHelp: async (model, position, token, context) => {
                 if (!this.matchModel(selector, MonacoModelIdentifier.fromModel(model))) {
                     return undefined;
                 }
                 const params = this.m2p.asTextDocumentPositionParams(model, position);
-                const signatureHelp = await provider.provideSignatureHelp(params, token, {
-                    // TODO pass context from monaco after Monaco udpate
-                    triggerKind: 1,
-                    isRetrigger: false
-                });
-                return signatureHelp && this.p2m.asSignatureHelp(signatureHelp);
+                const signatureHelp = await provider.provideSignatureHelp(params, token, this.m2p.asSignatureHelpContext(context))
+                return signatureHelp && this.p2m.asSignatureHelpResult(signatureHelp);
             }
         }
     }
@@ -250,7 +246,7 @@ export class MonacoLanguages implements Languages {
                 const params = this.m2p.asCodeActionParams(model, range, context);
                 const result = await provider.provideCodeActions(params, token);
                 // FIXME: get rid of `|| undefined!` when https://github.com/microsoft/monaco-editor/issues/1560 is resolved
-                return result && this.p2m.asCodeActions(result) || undefined!;
+                return result && this.p2m.asCodeActionList(result) || undefined!;
             }
         }
     }
@@ -272,7 +268,7 @@ export class MonacoLanguages implements Languages {
                 }
                 const params = this.m2p.asCodeLensParams(model);
                 const result = await provider.provideCodeLenses(params, token);
-                return result && this.p2m.asCodeLenses(result);
+                return result && this.p2m.asCodeLensList(result);
             },
             resolveCodeLens: provider.resolveCodeLens ? async (model, codeLens, token) => {
                 if (!this.matchModel(selector, MonacoModelIdentifier.fromModel(model))) {

example/package.json

@@ -4,7 +4,7 @@
   "version": "0.10.2",
   "dependencies": {
     "express": "^4.15.2",
-    "monaco-editor-core": "^0.17.0",
+    "monaco-editor-core": "^0.18.1",
     "monaco-languageclient": "^0.10.2",
     "normalize-url": "^2.0.1",
     "reconnecting-websocket": "^3.2.2",

lerna.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.10.2",
+  "version": "0.10.3",
   "npmClient": "yarn",
   "useWorkspaces": true,
   "command": {

package.json

@@ -8,7 +8,7 @@
     "@types/vscode": "1.33.0",
     "css-loader": "^0.28.11",
     "lerna": "^3.16.4",
-    "monaco-editor-core": "^0.17.0",
+    "monaco-editor-core": "^0.18.1",
     "rimraf": "^2.6.2",
     "source-map-loader": "^0.2.3",
     "style-loader": "^0.20.3",

yarn.lock

@@ -4469,10 +4469,10 @@ modify-values@^1.0.0:
   resolved "https://registry.yarnpkg.com/modify-values/-/modify-values-1.0.1.tgz#b3939fa605546474e3e3e3c63d64bd43b4ee6022"
   integrity sha512-xV2bxeN6F7oYjZWTe/YPAy6MN2M+sL4u/Rlm2AHCIVGfo2p1yGmBHQ6vHehl4bRTZBdHu3TSkWdYgkwpYzAGSw==
 
-monaco-editor-core@^0.17.0:
-  version "0.17.0"
-  resolved "https://registry.yarnpkg.com/monaco-editor-core/-/monaco-editor-core-0.17.0.tgz#8d2b7f7e02ac68f68eecc881d7a26457cbc09b49"
-  integrity sha512-8q7b0itiX4UDv6e2F/EJc53G0iLL7P905IZsemu/bXffS7mIcjKKtX+TlzT13YbkuGFC/86Q32ANXERaJTM+mw==
+monaco-editor-core@^0.18.1:
+  version "0.18.1"
+  resolved "https://registry.yarnpkg.com/monaco-editor-core/-/monaco-editor-core-0.18.1.tgz#6aa739a4a3b7444183876db83bac5c55e86c58e6"
+  integrity sha512-euzXzmwjZFG0oAPGjICMwINcZBzQDyfGDYlAR5YNMBJZO9Bmkqq1xpTTze/qQ0KKbVmawFXiwgUbg7WVgebP9Q==
 
 move-concurrently@^1.0.1:
   version "1.0.1"