@kusto/monaco-kusto 5.3.12 → 5.5.0

package/release/esm/languageService/kustoLanguageService.js

@@ -18,6 +18,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
+var _a;
 import * as s from './schema';
 // polyfill string endsWith
 if (!String.prototype.endsWith) {
@@ -102,6 +103,30 @@ function toClassifiedRange(k2Classifications) {
         kind: classification.Kind,
     }); });
 }
+var symbolKindToName = (_a = {},
+    _a[sym.SymbolKind.Cluster] = 'Cluster',
+    _a[sym.SymbolKind.Column] = 'Column',
+    _a[sym.SymbolKind.Command] = 'Command',
+    _a[sym.SymbolKind.Database] = 'Database',
+    _a[sym.SymbolKind.EntityGroup] = 'EntityGroup',
+    _a[sym.SymbolKind.EntityGroupElement] = 'EntityGroupElement',
+    _a[sym.SymbolKind.Error] = 'Error',
+    _a[sym.SymbolKind.Function] = 'Function',
+    _a[sym.SymbolKind.Graph] = 'Graph',
+    _a[sym.SymbolKind.Group] = 'Group',
+    _a[sym.SymbolKind.MaterializedView] = 'MaterializedView',
+    _a[sym.SymbolKind.None] = 'None',
+    _a[sym.SymbolKind.Operator] = 'Operator',
+    _a[sym.SymbolKind.Option] = 'Option',
+    _a[sym.SymbolKind.Parameter] = 'Parameter',
+    _a[sym.SymbolKind.Pattern] = 'Pattern',
+    _a[sym.SymbolKind.QueryOperatorParameter] = 'QueryOperatorParameter',
+    _a[sym.SymbolKind.Scalar] = 'Scalar',
+    _a[sym.SymbolKind.Table] = 'Table',
+    _a[sym.SymbolKind.Tuple] = 'Tuple',
+    _a[sym.SymbolKind.Variable] = 'Variable',
+    _a[sym.SymbolKind.Void] = 'Void',
+    _a);
 /**
  * Kusto Language service translates the kusto object model (transpiled from C# by Bridge.Net)
  * to the vscode language server types, which are used by vscode language extensions.
@@ -618,6 +643,53 @@ var KustoLanguageService = /** @class */ (function () {
         var lsDiagnostics = this.toLsDiagnostics(diagnostics, document);
         return Promise.resolve(lsDiagnostics);
     };
+    KustoLanguageService.prototype.getApplyCodeActions = function (document, start, end) {
+        var script = this.parseDocumentV2(document);
+        var block = this.getAffectedBlocks(this.toArray(script.Blocks), [{ start: start, end: end }])[0];
+        var codeActionInfo = block.Service.GetCodeActions(start, start, end - start + 1, null, true, null, new Kusto.Language.Utils.CancellationToken());
+        var codeActions = this.toArray(codeActionInfo.Actions);
+        // Some code actions are of type "MenuAction". We want to flat them out, to show them seperately.
+        var flatCodeActions = [];
+        for (var i = 0; i < codeActions.length; i++) {
+            flatCodeActions.push.apply(flatCodeActions, this.flattenCodeActions(codeActions[i]));
+        }
+        return flatCodeActions;
+    };
+    KustoLanguageService.prototype.getResultActions = function (document, start, end) {
+        var _this = this;
+        var script = this.parseDocumentV2(document);
+        var block = this.getAffectedBlocks(this.toArray(script.Blocks), [{ start: start, end: end }])[0];
+        var applyCodeActions = this.getApplyCodeActions(document, start, end);
+        var resultActionsMap = applyCodeActions
+            .map(function (applyCodeAction) {
+            var changes = [];
+            var codeActionResults = _this.toArray(block.Service.ApplyCodeAction(applyCodeAction, start).Actions);
+            var changeTextAction = codeActionResults.find(function (c) { return c instanceof Kusto.Language.Editor.ChangeTextAction; });
+            if (changeTextAction) {
+                changes = _this.toArray(changeTextAction.Changes).map(function (change) { return ({
+                    start: change.Start + block.Start,
+                    deleteLength: change.DeleteLength,
+                    insertText: change.InsertText,
+                }); });
+            }
+            return { title: applyCodeAction.Title, changes: changes };
+        })
+            .filter(function (resultAction) { return resultAction.changes.length; });
+        return Promise.resolve(resultActionsMap);
+    };
+    KustoLanguageService.prototype.flattenCodeActions = function (codeAction) {
+        var applyActions = [];
+        if (codeAction instanceof k2.ApplyAction) {
+            applyActions.push(codeAction);
+        }
+        else if (codeAction instanceof k2.MenuAction) {
+            var nestedCodeActions = this.toArray(codeAction.Actions);
+            for (var i = 0; i < nestedCodeActions.length; i++) {
+                applyActions.push.apply(applyActions, this.flattenCodeActions(nestedCodeActions[i]));
+            }
+        }
+        return applyActions;
+    };
     KustoLanguageService.prototype.toLsDiagnostics = function (diagnostics, document) {
         return diagnostics
             .filter(function (diag) { return diag.HasLocation; })
@@ -1211,17 +1283,30 @@ var KustoLanguageService = /** @class */ (function () {
         };
         return Promise.resolve(renderInfo);
     };
-    KustoLanguageService.prototype.getReferencedGlobalParams = function (document, cursorOffset) {
-        if (!document || !this.isIntellisenseV2()) {
-            return Promise.resolve([]);
+    KustoLanguageService.prototype.getReferencedSymbols = function (document, offset) {
+        var parsedAndAnalyzed = this.parseAndAnalyze(document, offset);
+        if (!parsedAndAnalyzed) {
+            Promise.resolve([]);
         }
-        var script = this.parseDocumentV2(document);
-        var currentBlock = this.getCurrentCommandV2(script, cursorOffset);
-        if (!currentBlock) {
-            return Promise.resolve([]);
+        // We take all referenced symbols in the query
+        var referencedSymbols = this.toArray(parsedAndAnalyzed.Syntax.GetDescendants(Kusto.Language.Syntax.Expression))
+            .filter(function (expression) { return expression.ReferencedSymbol !== null; })
+            .map(function (x) { return x.ReferencedSymbol; });
+        var result = referencedSymbols.map(function (sym) {
+            var _a;
+            return ({
+                name: sym.Name,
+                kind: (_a = symbolKindToName[sym.Kind]) !== null && _a !== void 0 ? _a : "".concat(sym.Kind),
+                display: sym.Display,
+            });
+        });
+        return Promise.resolve(result);
+    };
+    KustoLanguageService.prototype.getReferencedGlobalParams = function (document, cursorOffset) {
+        var parsedAndAnalyzed = this.parseAndAnalyze(document, cursorOffset);
+        if (!parsedAndAnalyzed) {
+            Promise.resolve([]);
         }
-        var text = currentBlock.Text;
-        var parsedAndAnalyzed = Kusto.Language.KustoCode.ParseAndAnalyze(text, this._kustoJsSchemaV2);
         // We take the ambient parameters
         var ambientParameters = this.toArray(this._kustoJsSchemaV2.Parameters);
         // We take all referenced symbols in the query
@@ -1801,11 +1886,14 @@ var KustoLanguageService = /** @class */ (function () {
             return undefined;
         }
         var script = this.parseDocumentV2(document);
-        var currentBlock = this.getCurrentCommandV2(script, cursorOffset);
-        if (!currentBlock) {
-            return undefined;
+        var text = script.Text;
+        if (cursorOffset !== undefined) {
+            var currentBlock = this.getCurrentCommandV2(script, cursorOffset);
+            if (!currentBlock) {
+                return undefined;
+            }
+            text = currentBlock.Text;
         }
-        var text = currentBlock.Text;
         var parsedAndAnalyzed = Kusto.Language.KustoCode.ParseAndAnalyze(text, this._kustoJsSchemaV2);
         return parsedAndAnalyzed;
     };

package/release/esm/monaco.contribution.js

@@ -62,6 +62,7 @@ var defaultLanguageSettings = {
     enableQueryWarnings: false,
     enableQuerySuggestions: false,
     disabledDiagnosticCodes: [],
+    quickFixCodeActions: ['Change to'],
 };
 function getKustoWorker() {
     return new Promise(function (resolve, reject) {

package/release/esm/monaco.d.ts

@@ -26,6 +26,7 @@ declare module monaco.languages.kusto {
         enableQueryWarnings?: boolean;
         enableQuerySuggestions?: boolean;
         disabledDiagnosticCodes?: string[];
+        quickFixCodeActions?: QuickFixCodeActionOptions[];
     }
 
     export interface SyntaxErrorAsMarkDownOptions {
@@ -34,6 +35,8 @@ declare module monaco.languages.kusto {
         enableSyntaxErrorAsMarkDown?: boolean;
     }
 
+    export type QuickFixCodeActionOptions = 'Extract Expression' | 'Extract Function' | 'Change to';
+
     export interface FormatterOptions {
         indentationSize?: number;
         pipeOperatorStyle?: FormatterPlacementStyle;
@@ -112,8 +115,12 @@ declare module monaco.languages.kusto {
          * statement.
          * It is also different from getGlobalParams that will return all global parameters whether used or not.
          */
-        getReferencedGlobalParams(uri: string, cursorOffset: number): Promise<{ name: string; type: string }[]>;
+        getReferencedGlobalParams(uri: string, cursorOffset?: number): Promise<{ name: string; type: string }[]>;
 
+        getReferencedSymbols(
+            document: TextDocument,
+            cursorOffset?: number
+        ): Promise<{ name: string; kind: string; display: string }[]>;
         /**
          * Get visualization options in render command if present (null otherwise).
          */