@kusto/monaco-kusto 8.2.0 → 8.3.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: 8.3.0(b1e36a8cfc8e35c070743997d6e7770ea8081289)
  * 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-7d65ed04'], (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-7d65ed04.js}

@@ -1,11 +1,11 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 8.2.0(fa67d42b5fffde7c13ac41861bb1dbf769c5e00e)
+ * monaco-kusto version: 8.3.0(b1e36a8cfc8e35c070743997d6e7770ea8081289)
  * 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-7d65ed04', ['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: 8.3.0(b1e36a8cfc8e35c070743997d6e7770ea8081289)
  * 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-ee621489.js';
 import '@kusto/language-service/bridge.min';
 import '@kusto/language-service/Kusto.JavaScript.Client.min';
 import '@kusto/language-service/newtonsoft.json.min';