@kusto/monaco-kusto 8.2.0 → 9.0.0

package/release/dev/monaco.contribution.js

@@ -1,11 +1,11 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 8.2.0(fa67d42b5fffde7c13ac41861bb1dbf769c5e00e)
+ * monaco-kusto version: 9.0.0(faf7ed5043d2e79738847656c64ca42816963d09)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
 
-define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/editor/editor.main', './schema-8dc56616'], (function (require, exports, monaco, schema) { 'use strict';
+define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/editor/editor.main', './schema-9a35b99a'], (function (require, exports, monaco, schema) { 'use strict';
 
     function _interopNamespaceDefault(e) {
         var n = Object.create(null);
@@ -76,7 +76,7 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
       };
     }
 
-    function _typeof$2(obj) { "@babel/helpers - typeof"; return _typeof$2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof$2(obj); }
+    function _typeof$2(o) { "@babel/helpers - typeof"; return _typeof$2 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof$2(o); }
     function _classCallCheck$2(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
     function _defineProperties$2(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey$2(descriptor.key), descriptor); } }
     function _createClass$2(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$2(Constructor.prototype, protoProps); if (staticProps) _defineProperties$2(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
@@ -143,7 +143,7 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
       className: 'selectionHighlight'
     });
 
-    function _typeof$1(obj) { "@babel/helpers - typeof"; return _typeof$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof$1(obj); }
+    function _typeof$1(o) { "@babel/helpers - typeof"; return _typeof$1 = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof$1(o); }
     function _defineProperties$1(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey$1(descriptor.key), descriptor); } }
     function _createClass$1(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties$1(Constructor.prototype, protoProps); if (staticProps) _defineProperties$1(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
     function _classCallCheck$1(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
@@ -182,7 +182,7 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
       });
     });
 
-    function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+    function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
     function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
     function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
     function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
@@ -526,10 +526,7 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
     exports.getEntityDataTypeFromCslType = schema.getEntityDataTypeFromCslType;
     exports.getExpression = schema.getExpression;
     exports.getInputParametersAsCslString = schema.getInputParametersAsCslString;
-    Object.defineProperty(exports, 'showSchema', {
-        enumerable: true,
-        get: function () { return schema.showSchema; }
-    });
+    exports.showSchema = schema.showSchema;
     exports.getCurrentCommandRange = getCurrentCommandRange;
     exports.getKustoWorker = getKustoWorker;
     exports.kustoDefaults = kustoDefaults;

package/release/dev/{schema-8dc56616.js → schema-9a35b99a.js}

@@ -1,11 +1,11 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 8.2.0(fa67d42b5fffde7c13ac41861bb1dbf769c5e00e)
+ * monaco-kusto version: 9.0.0(faf7ed5043d2e79738847656c64ca42816963d09)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
 
-define('vs/language/kusto/schema-8dc56616', ['exports'], (function (exports) { 'use strict';
+define('vs/language/kusto/schema-9a35b99a', ['exports'], (function (exports) { 'use strict';
 
     // Definition of schema object in the context of language services. This model is exposed to consumers of this library.
 
@@ -97,13 +97,13 @@ define('vs/language/kusto/schema-8dc56616', ['exports'], (function (exports) { '
      * This is the schema of the output of kusto command
      * .show schema as json
      */
-    exports.showSchema = void 0;
-    (function (_showSchema) {})(exports.showSchema || (exports.showSchema = {}));
+    var showSchema;
 
     exports.getCallName = getCallName;
     exports.getCslTypeNameFromClrType = getCslTypeNameFromClrType;
     exports.getEntityDataTypeFromCslType = getEntityDataTypeFromCslType;
     exports.getExpression = getExpression;
     exports.getInputParametersAsCslString = getInputParametersAsCslString;
+    exports.showSchema = showSchema;
 
 }));

package/release/esm/commandFormatter.js

@@ -0,0 +1,37 @@
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+var KustoCommandFormatter = /** @class */ (function () {
+    function KustoCommandFormatter(editor) {
+        var _this = this;
+        this.editor = editor;
+        this.actionAdded = false;
+        // selection also represents no selection - for example the event gets triggered when moving cursor from point
+        // a to point b. in the case start position will equal end position.
+        editor.onDidChangeCursorSelection(function (changeEvent) {
+            if (_this.editor.getModel().getLanguageId() !== 'kusto') {
+                return;
+            }
+            // Theoretically you would expect this code to run only once in onDidCreateEditor.
+            // Turns out that onDidCreateEditor is fired before the IStandaloneEditor is completely created (it is emitted by
+            // the super ctor before the child ctor was able to fully run).
+            // Thus we don't have  a key binding provided yet when onDidCreateEditor is run, which is essential to call addAction.
+            // By adding the action here in onDidChangeCursorSelection we're making sure that the editor has a key binding provider,
+            // and we just need to make sure that this happens only once.
+            if (!_this.actionAdded) {
+                editor.addAction({
+                    id: 'editor.action.kusto.formatCurrentCommand',
+                    label: 'Format Command Under Cursor',
+                    keybindings: [
+                        monaco.KeyMod.chord(monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyK, monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyF),
+                    ],
+                    run: function (ed) {
+                        editor.trigger('KustoCommandFormatter', 'editor.action.formatSelection', null);
+                    },
+                    contextMenuGroupId: '1_modification',
+                });
+                _this.actionAdded = true;
+            }
+        });
+    }
+    return KustoCommandFormatter;
+}());
+export default KustoCommandFormatter;

package/release/esm/commandHighlighter.js

@@ -0,0 +1,52 @@
+import { getCurrentCommandRange } from './extendedEditor';
+/**
+ * Highlights the command that surround cursor location
+ */
+var KustoCommandHighlighter = /** @class */ (function () {
+    /**
+     * Register to cursor movement and selection events.
+     * @param editor monaco editor instance
+     */
+    function KustoCommandHighlighter(editor) {
+        var _this = this;
+        this.editor = editor;
+        this.disposables = [];
+        this.decorations = [];
+        // Note that selection update is triggered not only for selection changes, but also just when no text selection is occurring and cursor just moves around.
+        // This case is counted as a 0-length selection starting and ending on the cursor position.
+        this.editor.onDidChangeCursorSelection(function (changeEvent) {
+            if (_this.editor.getModel().getLanguageId() !== 'kusto') {
+                return;
+            }
+            _this.highlightCommandUnderCursor(changeEvent);
+        });
+    }
+    KustoCommandHighlighter.prototype.getId = function () {
+        return KustoCommandHighlighter.ID;
+    };
+    KustoCommandHighlighter.prototype.dispose = function () {
+        this.disposables.forEach(function (d) { return d.dispose(); });
+    };
+    KustoCommandHighlighter.prototype.highlightCommandUnderCursor = function (changeEvent) {
+        // Looks like the user selected a bunch of text. we don't want to highlight the entire command in this case - since highlighting
+        // the text is more helpful.
+        if (!changeEvent.selection.isEmpty()) {
+            this.decorations = this.editor.deltaDecorations(this.decorations, []);
+            return;
+        }
+        var commandRange = getCurrentCommandRange(this.editor, changeEvent.selection.getStartPosition());
+        var decorations = [
+            {
+                range: commandRange,
+                options: KustoCommandHighlighter.CURRENT_COMMAND_HIGHLIGHT,
+            },
+        ];
+        this.decorations = this.editor.deltaDecorations(this.decorations, decorations);
+    };
+    KustoCommandHighlighter.ID = 'editor.contrib.kustoCommandHighlighter';
+    KustoCommandHighlighter.CURRENT_COMMAND_HIGHLIGHT = {
+        className: 'selectionHighlight',
+    };
+    return KustoCommandHighlighter;
+}());
+export default KustoCommandHighlighter;

package/release/esm/extendedEditor.js

@@ -0,0 +1,41 @@
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+export function getCurrentCommandRange(editor, cursorPosition) {
+    var zeroBasedCursorLineNumber = cursorPosition.lineNumber - 1;
+    var lines = editor.getModel().getLinesContent();
+    var commandOrdinal = 0;
+    var linesWithCommandOrdinal = [];
+    for (var lineNumber = 0; lineNumber < lines.length; lineNumber++) {
+        var isEmptyLine = lines[lineNumber].trim() === '';
+        if (isEmptyLine) {
+            // increase commandCounter - we'll be starting a new command.
+            linesWithCommandOrdinal.push({ commandOrdinal: commandOrdinal++, lineNumber: lineNumber });
+        }
+        else {
+            linesWithCommandOrdinal.push({ commandOrdinal: commandOrdinal, lineNumber: lineNumber });
+        }
+        // No need to keep scanning if we're past our line and we've seen an empty line.
+        if (lineNumber > zeroBasedCursorLineNumber &&
+            commandOrdinal > linesWithCommandOrdinal[zeroBasedCursorLineNumber].commandOrdinal) {
+            break;
+        }
+    }
+    var currentCommandOrdinal = linesWithCommandOrdinal[zeroBasedCursorLineNumber].commandOrdinal;
+    var currentCommandLines = linesWithCommandOrdinal.filter(function (line) { return line.commandOrdinal === currentCommandOrdinal; });
+    var currentCommandStartLine = currentCommandLines[0].lineNumber + 1;
+    var currentCommandEndLine = currentCommandLines[currentCommandLines.length - 1].lineNumber + 1;
+    // End-column of 1 means no characters will be highlighted - since columns are 1-based in monaco apis.
+    // Start-column of 1 and End column of 2 means 1st character is selected.
+    // Thus if a line has n column and we need to provide n+1 so that the entire line will be highlighted.
+    var commandEndColumn = lines[currentCommandEndLine - 1].length + 1;
+    return new monaco.Range(currentCommandStartLine, 1, currentCommandEndLine, commandEndColumn);
+}
+/**
+ * Extending ICode editor to contain additional kusto-specific methods.
+ * note that the extend method needs to be called at least once to take affect, otherwise this here code is useless.
+ */
+export function extend(editor) {
+    var proto = Object.getPrototypeOf(editor);
+    proto.getCurrentCommandRange = function (cursorPosition) {
+        getCurrentCommandRange(this, cursorPosition);
+    };
+}

package/release/esm/kusto.worker.js

@@ -1,6 +1,6 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 8.2.0(fa67d42b5fffde7c13ac41861bb1dbf769c5e00e)
+ * monaco-kusto version: 9.0.0(faf7ed5043d2e79738847656c64ca42816963d09)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
@@ -8,7 +8,7 @@
 import * as worker from 'monaco-editor/esm/vs/editor/editor.worker';
 import * as ls from 'vscode-languageserver-types';
 import XRegExp from 'xregexp';
-import { d as getEntityDataTypeFromCslType, a as getCallName, b as getExpression, g as getCslTypeNameFromClrType } from './schema-1d41f705.js';
+import { d as getEntityDataTypeFromCslType, a as getCallName, b as getExpression, g as getCslTypeNameFromClrType } from './schema-6a20da13.js';
 import '@kusto/language-service/bridge.min';
 import '@kusto/language-service/Kusto.JavaScript.Client.min';
 import '@kusto/language-service/newtonsoft.json.min';
@@ -813,9 +813,12 @@ class KustoLanguageService {
    * @param schema schema json as received from .show schema as json
    * @param clusterConnectionString cluster connection string
    * @param databaseInContextName name of database in context
+   * @param globalScalarParameters
+   * @param globalTabularParameters
+   * @param databaseInContextAlternateName alternate name of database in context
    */
-  setSchemaFromShowSchema(schema, clusterConnectionString, databaseInContextName, globalScalarParameters, globalTabularParameters) {
-    return this.normalizeSchema(schema, clusterConnectionString, databaseInContextName).then(normalized => this.setSchema({
+  setSchemaFromShowSchema(schema, clusterConnectionString, databaseInContextName, globalScalarParameters, globalTabularParameters, databaseInContextAlternateName) {
+    return this.normalizeSchema(schema, clusterConnectionString, databaseInContextName, databaseInContextAlternateName).then(normalized => this.setSchema({
       ...normalized,
       globalScalarParameters,
       globalTabularParameters
@@ -827,20 +830,27 @@ class KustoLanguageService {
    * @param schema result of show schema
    * @param clusterConnectionString cluster connection string`
    * @param databaseInContextName database in context name
+   * @param databaseInContextAlternateName database in context alternate name
    */
-  normalizeSchema(schema, clusterConnectionString, databaseInContextName) {
+  normalizeSchema(schema, clusterConnectionString, databaseInContextName, databaseInContextAlternateName) {
     const databases = Object.keys(schema.Databases).map(key => schema.Databases[key]).map(({
       Name,
       Tables,
       ExternalTables,
       MaterializedViews,
       Functions,
+      EntityGroups = {},
       MinorVersion,
       MajorVersion
     }) => ({
       name: Name,
+      alternateName: databaseInContextAlternateName || null,
       minorVersion: MinorVersion,
       majorVersion: MajorVersion,
+      entityGroups: Object.entries(EntityGroups).map(([name, members]) => ({
+        name,
+        members
+      })),
       tables: [].concat(...[[Tables, 'Table'], [MaterializedViews, 'MaterializedView'], [ExternalTables, 'ExternalTable']].filter(([tableContainer]) => tableContainer).map(([tableContainer, tableEntity]) => Object.values(tableContainer).map(({
         Name,
         OrderedColumns,
@@ -1332,7 +1342,9 @@ class KustoLanguageService {
     const database = {
       majorVersion: 0,
       minorVersion: 0,
+      entityGroups: [],
       name: 'Kuskus',
+      alternateName: null,
       tables: [{
         name: 'KustoLogs',
         columns: [{
@@ -1510,34 +1522,10 @@ class KustoLanguageService {
     return new sym.Parameter.$ctor2(param.name, argumentType);
   }
   static convertToDatabaseSymbol(db) {
-    const createFunctionSymbol = fn => {
-      const parameters = fn.inputParameters.map(param => KustoLanguageService.createParameter(param));
-
-      // TODO: handle outputColumns (right now it doesn't seem to be implemented for any function).
-      return new sym.FunctionSymbol.$ctor14(fn.name, fn.body, KustoLanguageService.toBridgeList(parameters), fn.docstring);
-    };
-    const createTableSymbol = tbl => {
-      const columnSymbols = tbl.columns.map(col => KustoLanguageService.createColumnSymbol(col));
-      let symbol = new sym.TableSymbol.$ctor4(tbl.name, columnSymbols);
-      symbol.Description = tbl.docstring;
-      switch (tbl.entityType) {
-        case 'MaterializedViewTable':
-          const mvQuery = tbl.mvQuery ?? null;
-          symbol = new sym.MaterializedViewSymbol.$ctor2(tbl.name, symbol.Columns, mvQuery, tbl.docstring);
-          symbol = symbol.WithIsMaterializedView(true);
-          break;
-        case 'ExternalTable':
-          symbol = symbol.WithIsExternal(true);
-          break;
-      }
-      return symbol;
-    };
-    const createDatabaseSymbol = db => {
-      const tableSymbols = db.tables ? db.tables.map(tbl => createTableSymbol(tbl)) : [];
-      const functionSymbols = db.functions ? db.functions.map(fun => createFunctionSymbol(fun)) : [];
-      return new sym.DatabaseSymbol.ctor(db.name, tableSymbols.concat(functionSymbols));
-    };
-    const databaseSymbol = createDatabaseSymbol(db);
+    const tableSymbols = (db.tables || []).map(this.createTableSymbol);
+    const functionSymbols = (db.functions || []).map(this.createFunctionSymbol);
+    const entityGroupsSymbols = (db.entityGroups || []).map(this.createEntityGroupSymbol);
+    const databaseSymbol = new sym.DatabaseSymbol.$ctor2(db.name, db.alternateName, tableSymbols.concat(functionSymbols).concat(entityGroupsSymbols));
     return databaseSymbol;
   }
   convertToKustoJsSchemaV2(schema) {
@@ -1898,6 +1886,33 @@ class KustoLanguageService {
     const parsedAndAnalyzed = Kusto.Language.KustoCode.ParseAndAnalyze(text, this._kustoJsSchemaV2);
     return parsedAndAnalyzed;
   }
+  static createFunctionSymbol(fn) {
+    const parameters = fn.inputParameters.map(param => KustoLanguageService.createParameter(param));
+
+    // TODO: handle outputColumns (right now it doesn't seem to be implemented for any function).
+    return new sym.FunctionSymbol.$ctor14(fn.name, fn.body, KustoLanguageService.toBridgeList(parameters), fn.docstring);
+  }
+  static createTableSymbol({
+    name,
+    columns,
+    entityType,
+    docstring,
+    ...tbl
+  }) {
+    const columnSymbols = new Bridge.ArrayEnumerable(columns.map(col => KustoLanguageService.createColumnSymbol(col)));
+    switch (entityType) {
+      case 'MaterializedViewTable':
+        const mvQuery = tbl.mvQuery ?? null;
+        return new sym.MaterializedViewSymbol.$ctor2(name, columnSymbols, mvQuery, docstring);
+      case 'ExternalTable':
+        return new sym.ExternalTableSymbol.$ctor3(name, columnSymbols, docstring);
+      default:
+        return new sym.TableSymbol.$ctor6(name, columnSymbols, docstring);
+    }
+  }
+  static createEntityGroupSymbol(entityGroup) {
+    return new sym.EntityGroupSymbol.$ctor3(entityGroup.name, entityGroup.members.join(), null);
+  }
 }
 let languageService = new KustoLanguageService(KustoLanguageService.dummySchema, {
   includeControlCommands: true,