@kusto/monaco-kusto 11.0.0 → 11.1.0

package/release/dev/monaco.contribution.js

@@ -1,11 +1,11 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 11.0.0(2cd16f8743253b5a0133f2ba4f53203e02c1673c)
+ * monaco-kusto version: 11.1.0(a4f4a803b61d72aca89d2412b0c7849259e4fd91)
  * 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-d4b2563b'], (function (require, exports, monaco, schema) { 'use strict';
+define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/editor/editor.main', './schema-26bd7933'], (function (require, exports, monaco, schema) { 'use strict';
 
     function _interopNamespaceDefault(e) {
         var n = Object.create(null);
@@ -77,12 +77,12 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
     }
 
     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; }
-    function _defineProperty$2(obj, key, value) { key = _toPropertyKey$2(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-    function _toPropertyKey$2(arg) { var key = _toPrimitive$2(arg, "string"); return _typeof$2(key) === "symbol" ? key : String(key); }
-    function _toPrimitive$2(input, hint) { if (_typeof$2(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof$2(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+    function _classCallCheck$2(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+    function _defineProperties$2(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey$2(o.key), o); } }
+    function _createClass$2(e, r, t) { return r && _defineProperties$2(e.prototype, r), t && _defineProperties$2(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+    function _defineProperty$2(e, r, t) { return (r = _toPropertyKey$2(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+    function _toPropertyKey$2(t) { var i = _toPrimitive$2(t, "string"); return "symbol" == _typeof$2(i) ? i : i + ""; }
+    function _toPrimitive$2(t, r) { if ("object" != _typeof$2(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof$2(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 
     /**
      * Highlights the command that surround cursor location
@@ -107,7 +107,7 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
           _this.highlightCommandUnderCursor(changeEvent);
         });
       }
-      _createClass$2(KustoCommandHighlighter, [{
+      return _createClass$2(KustoCommandHighlighter, [{
         key: "getId",
         value: function getId() {
           return KustoCommandHighlighter.ID;
@@ -136,7 +136,6 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
           this.decorations = this.editor.deltaDecorations(this.decorations, decorations);
         }
       }]);
-      return KustoCommandHighlighter;
     }();
     _defineProperty$2(KustoCommandHighlighter, "ID", 'editor.contrib.kustoCommandHighlighter');
     _defineProperty$2(KustoCommandHighlighter, "CURRENT_COMMAND_HIGHLIGHT", {
@@ -144,12 +143,12 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
     });
 
     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"); } }
-    function _defineProperty$1(obj, key, value) { key = _toPropertyKey$1(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-    function _toPropertyKey$1(arg) { var key = _toPrimitive$1(arg, "string"); return _typeof$1(key) === "symbol" ? key : String(key); }
-    function _toPrimitive$1(input, hint) { if (_typeof$1(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof$1(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+    function _defineProperties$1(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey$1(o.key), o); } }
+    function _createClass$1(e, r, t) { return r && _defineProperties$1(e.prototype, r), t && _defineProperties$1(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+    function _classCallCheck$1(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+    function _defineProperty$1(e, r, t) { return (r = _toPropertyKey$1(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+    function _toPropertyKey$1(t) { var i = _toPrimitive$1(t, "string"); return "symbol" == _typeof$1(i) ? i : i + ""; }
+    function _toPrimitive$1(t, r) { if ("object" != _typeof$1(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof$1(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
     var KustoCommandFormatter = /*#__PURE__*/_createClass$1(function KustoCommandFormatter(editor) {
       var _this = this;
       _classCallCheck$1(this, KustoCommandFormatter);
@@ -183,12 +182,12 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
     });
 
     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; }
-    function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-    function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
-    function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+    function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+    function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+    function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+    function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+    function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+    function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 
     // --- Kusto configuration and defaults ---------
     var LanguageServiceDefaultsImpl = /*#__PURE__*/function () {
@@ -206,7 +205,7 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
         // setSchema. That way we don't need to stringify the schema on the worker side when killing the web worker.
         this._workerMaxIdleTime = 0;
       }
-      _createClass(LanguageServiceDefaultsImpl, [{
+      return _createClass(LanguageServiceDefaultsImpl, [{
         key: "onDidChange",
         get: function get() {
           return this._onDidChange.event;
@@ -235,7 +234,6 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
           return this._workerMaxIdleTime;
         }
       }]);
-      return LanguageServiceDefaultsImpl;
     }();
     var defaultLanguageSettings = {
       includeControlCommands: true,

package/release/dev/{schema-d4b2563b.js → schema-26bd7933.js}

@@ -1,11 +1,11 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 11.0.0(2cd16f8743253b5a0133f2ba4f53203e02c1673c)
+ * monaco-kusto version: 11.1.0(a4f4a803b61d72aca89d2412b0c7849259e4fd91)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
 
-define('vs/language/kusto/schema-d4b2563b', ['exports'], (function (exports) { 'use strict';
+define('vs/language/kusto/schema-26bd7933', ['exports'], (function (exports) { 'use strict';
 
     // Definition of schema object in the context of language services. This model is exposed to consumers of this library.
 

package/release/esm/completionCacheManager/completionCacheManager.d.ts

@@ -0,0 +1,7 @@
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import * as ls from 'vscode-languageserver-types';
+export declare const createCompletionCacheManager: (getFromLanguageService: GetFromLanguageService) => {
+    getCompletionItems: (word: string | undefined, resource: monaco.Uri, position: ls.Position) => Promise<ls.CompletionList>;
+};
+export type CompletionCacheManager = ReturnType<typeof createCompletionCacheManager>;
+export type GetFromLanguageService = (resource: monaco.Uri, position: ls.Position) => Promise<ls.CompletionList>;

package/release/esm/completionCacheManager/completionCacheManager.js

@@ -0,0 +1,14 @@
+export var createCompletionCacheManager = function (getFromLanguageService) {
+    var completionList;
+    var lastWord;
+    return {
+        getCompletionItems: function (word, resource, position) {
+            var shouldGetItems = !lastWord || !word || !(word === null || word === void 0 ? void 0 : word.includes(lastWord));
+            if (shouldGetItems) {
+                completionList = getFromLanguageService(resource, position);
+            }
+            lastWord = word;
+            return completionList;
+        },
+    };
+};

package/release/esm/kusto.worker.js

@@ -1,6 +1,6 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 11.0.0(2cd16f8743253b5a0133f2ba4f53203e02c1673c)
+ * monaco-kusto version: 11.1.0(a4f4a803b61d72aca89d2412b0c7849259e4fd91)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
@@ -8,15 +8,36 @@
 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-390a6d13.js';
+import { d as getEntityDataTypeFromCslType, a as getCallName, b as getExpression, g as getCslTypeNameFromClrType } from './schema-33d2a0bc.js';
 import '@kusto/language-service/bridge.min';
 import '@kusto/language-service/Kusto.JavaScript.Client.min';
 import '@kusto/language-service/newtonsoft.json.min';
 import '@kusto/language-service-next/Kusto.Language.Bridge.min';
 
+Kusto.Language.Editor;
 const createSortingText = priority => {
   return priority.toString().padStart(10, '0');
 };
+function sortByMatchTextKeepingKindOrder(items) {
+  const groupedByKind = groupContiguousByKind(items);
+  const sortedGroupedItems = sortGroupedItems(groupedByKind);
+  return sortedGroupedItems.flat();
+}
+function sortGroupedItems(groupedItems) {
+  return groupedItems.map(group => group.sort((i1, i2) => i1.MatchText.localeCompare(i2.MatchText)));
+}
+function groupContiguousByKind(items) {
+  return items.reduce((result, item) => {
+    const lastGroup = last(result);
+    const shouldCreateNewGroup = !lastGroup || last(lastGroup)?.Kind !== item.Kind;
+    if (shouldCreateNewGroup) result.push([]);
+    last(result).push(item);
+    return result;
+  }, []);
+}
+function last(array) {
+  return array.length > 0 ? array[array.length - 1] : undefined;
+}
 
 var k = Kusto.Data.IntelliSense;
 var parsing = Kusto.Language.Parsing;
@@ -284,7 +305,8 @@ class KustoLanguageService {
       });
     }
     const itemsAsArray = this.toArray(completionItems.Items);
-    let items = itemsAsArray.filter(item => !(item && item.MatchText && disabledItems[item.MatchText] !== undefined && (disabledItems[item.MatchText] === k2.CompletionKind.Unknown || disabledItems[item.MatchText] === item.Kind))).map((kItem, index) => {
+    const sortedArray = sortByMatchTextKeepingKindOrder(itemsAsArray);
+    let items = sortedArray.filter(item => !(item && item.MatchText && disabledItems[item.MatchText] !== undefined && (disabledItems[item.MatchText] === k2.CompletionKind.Unknown || disabledItems[item.MatchText] === item.Kind))).map((kItem, index) => {
       const v1CompletionOption = new k.CompletionOption(this._toOptionKind[kItem.Kind] || k.OptionKind.None, kItem.DisplayText);
       const helpTopic = this.getTopic(v1CompletionOption);
       // If we have AfterText it means that the cursor should not be placed at end of suggested text.
@@ -316,6 +338,9 @@ class KustoLanguageService {
         value: this.formatHelpTopic(helpTopic),
         kind: ls.MarkupKind.Markdown
       } : undefined;
+      lsItem.data = {
+        forcePrecedence: kItem.Kind === k2.CompletionKind.Column
+      };
       return lsItem;
     });
     return Promise.resolve(ls.CompletionList.create(items));

package/release/esm/languageFeatures.d.ts

@@ -33,9 +33,9 @@ export declare class ColorizationAdapter {
     private _doColorization;
 }
 export declare class CompletionAdapter implements monaco.languages.CompletionItemProvider {
-    private _worker;
-    private languageSettings;
-    constructor(_worker: AugmentedWorkerAccessor, languageSettings: LanguageSettings);
+    private readonly languageSettings;
+    private completionCacheManager;
+    constructor(workerAccessor: AugmentedWorkerAccessor, languageSettings: LanguageSettings);
     get triggerCharacters(): string[];
     provideCompletionItems(model: monaco.editor.IReadOnlyModel, position: monaco.Position, context: monaco.languages.CompletionContext, token: monaco.CancellationToken): monaco.Thenable<monaco.languages.CompletionList>;
     private formatDocLink;

package/release/esm/languageFeatures.js

@@ -46,6 +46,8 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 import * as ls from 'vscode-languageserver-types';
 import debounce from 'lodash-es/debounce';
+import { createCompletionCacheManager } from './completionCacheManager/completionCacheManager';
+import { createCompletionFilteredText } from './languageFeatures.utils';
 var DiagnosticsAdapter = /** @class */ (function () {
     function DiagnosticsAdapter(_monacoInstance, _languageId, _worker, defaults, onSchemaChange) {
         var _this = this;
@@ -167,9 +169,9 @@ var DiagnosticsAdapter = /** @class */ (function () {
         this._monacoInstance.editor.getEditors().forEach(onEditorAdd);
     }
     DiagnosticsAdapter.prototype.getMonacoCodeActions = function (model, startOffset, endOffset, enableQuickFix) {
-        var _a;
         return __awaiter(this, void 0, void 0, function () {
             var actions, worker, resource, codeActions, _loop_1, this_1, i, state_1;
+            var _a;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
@@ -291,8 +293,8 @@ var DiagnosticsAdapter = /** @class */ (function () {
                                 hoverMessage: {
                                     value: popupErrorHoverHeaderMessage_1 + marker.message,
                                 },
-                                className: 'squiggly-error',
-                                zIndex: 100,
+                                className: 'squiggly-error', // monaco syntax error style (red underline)
+                                zIndex: 100, // This message will be the upper most mesage in the popup
                                 overviewRuler: {
                                     // The color indication on the right ruler
                                     color: 'rgb(255, 18, 18, 0.7)',
@@ -731,9 +733,21 @@ function toTextEdit(textEdit) {
 }
 var DEFAULT_DOCS_BASE_URL = 'https://learn.microsoft.com/azure/data-explorer/kusto/query';
 var CompletionAdapter = /** @class */ (function () {
-    function CompletionAdapter(_worker, languageSettings) {
-        this._worker = _worker;
+    function CompletionAdapter(workerAccessor, languageSettings) {
+        var _this = this;
         this.languageSettings = languageSettings;
+        var getFromLanguageService = function (resource, position) { return __awaiter(_this, void 0, void 0, function () {
+            var worker;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, workerAccessor(resource)];
+                    case 1:
+                        worker = _a.sent();
+                        return [2 /*return*/, worker.doComplete(resource.toString(), position)];
+                }
+            });
+        }); };
+        this.completionCacheManager = createCompletionCacheManager(getFromLanguageService);
     }
     Object.defineProperty(CompletionAdapter.prototype, "triggerCharacters", {
         get: function () {
@@ -744,26 +758,25 @@ var CompletionAdapter = /** @class */ (function () {
     });
     CompletionAdapter.prototype.provideCompletionItems = function (model, position, context, token) {
         var _this = this;
+        var _a;
         var wordInfo = model.getWordUntilPosition(position);
         var wordRange = new monaco.Range(position.lineNumber, wordInfo.startColumn, position.lineNumber, wordInfo.endColumn);
         var resource = model.uri;
+        var word = (_a = model === null || model === void 0 ? void 0 : model.getWordAtPosition(position)) === null || _a === void 0 ? void 0 : _a.word;
         var onDidProvideCompletionItems = this.languageSettings.onDidProvideCompletionItems;
-        return this._worker(resource)
-            .then(function (worker) {
-            return worker.doComplete(resource.toString(), fromPosition(position));
-        })
+        return this.completionCacheManager
+            .getCompletionItems(word, resource, fromPosition(position))
             .then(function (info) { return (onDidProvideCompletionItems ? onDidProvideCompletionItems(info) : info); })
             .then(function (info) {
-            if (!info) {
+            if (!info)
                 return;
-            }
             var items = info.items.map(function (entry) {
                 var _a;
                 var item = {
                     label: entry.label,
                     insertText: entry.insertText,
                     sortText: entry.sortText,
-                    filterText: entry.filterText,
+                    filterText: createCompletionFilteredText(word, entry),
                     // TODO: Is this cast safe?
                     documentation: _this.formatDocLink((_a = entry.documentation) === null || _a === void 0 ? void 0 : _a.value),
                     detail: entry.detail,
@@ -781,7 +794,7 @@ var CompletionAdapter = /** @class */ (function () {
                 return item;
             });
             return {
-                isIncomplete: info.isIncomplete,
+                incomplete: true,
                 suggestions: items,
             };
         });

package/release/esm/languageFeatures.utils.d.ts

@@ -0,0 +1,2 @@
+import * as ls from 'vscode-languageserver-types';
+export declare function createCompletionFilteredText(searchWord: string | undefined, completionItem: ls.CompletionItem): string;

package/release/esm/languageFeatures.utils.js

@@ -0,0 +1,7 @@
+export function createCompletionFilteredText(searchWord, completionItem) {
+    if (!searchWord)
+        return completionItem.filterText;
+    var containedInFilterText = completionItem.filterText.toLowerCase().includes(searchWord.toLowerCase());
+    var shouldPrependSearchWord = completionItem.data.forcePrecedence && containedInFilterText;
+    return shouldPrependSearchWord ? "".concat(searchWord).concat(completionItem.filterText) : completionItem.filterText;
+}

package/release/esm/languageServiceManager/competionItemSort.d.ts

@@ -1 +1,4 @@
+/// <reference types="@kusto/language-service-next/Kusto.Language.Bridge" />
+import k2 = Kusto.Language.Editor;
 export declare const createSortingText: (priority: number) => string;
+export declare function sortByMatchTextKeepingKindOrder(items: k2.CompletionItem[]): k2.CompletionItem[];

package/release/esm/languageServiceManager/competionItemSort.js

@@ -1,3 +1,25 @@
 export var createSortingText = function (priority) {
     return priority.toString().padStart(10, '0');
 };
+export function sortByMatchTextKeepingKindOrder(items) {
+    var groupedByKind = groupContiguousByKind(items);
+    var sortedGroupedItems = sortGroupedItems(groupedByKind);
+    return sortedGroupedItems.flat();
+}
+function sortGroupedItems(groupedItems) {
+    return groupedItems.map(function (group) { return group.sort(function (i1, i2) { return i1.MatchText.localeCompare(i2.MatchText); }); });
+}
+function groupContiguousByKind(items) {
+    return items.reduce(function (result, item) {
+        var _a;
+        var lastGroup = last(result);
+        var shouldCreateNewGroup = !lastGroup || ((_a = last(lastGroup)) === null || _a === void 0 ? void 0 : _a.Kind) !== item.Kind;
+        if (shouldCreateNewGroup)
+            result.push([]);
+        last(result).push(item);
+        return result;
+    }, []);
+}
+function last(array) {
+    return array.length > 0 ? array[array.length - 1] : undefined;
+}

package/release/esm/languageServiceManager/kustoLanguageService.d.ts

@@ -14,8 +14,8 @@ import type { ClusterReference, DatabaseReference } from '../types';
 export declare enum TokenKind {
     TableToken = 2,
     TableColumnToken = 4,
-    OperatorToken = 8,
-    SubOperatorToken = 16,
+    OperatorToken = 8,// where, project, ...
+    SubOperatorToken = 16,// has, contains, ...
     CalculatedColumnToken = 32,
     StringLiteralToken = 64,
     FunctionNameToken = 128,

package/release/esm/languageServiceManager/kustoLanguageService.js

@@ -41,7 +41,7 @@ var k2 = Kusto.Language.Editor;
 var sym = Kusto.Language.Symbols;
 var GlobalState = Kusto.Language.GlobalState;
 import { getCslTypeNameFromClrType, getEntityDataTypeFromCslType } from './schema';
-import { createSortingText } from './competionItemSort';
+import { createSortingText, sortByMatchTextKeepingKindOrder } from './competionItemSort';
 var List = System.Collections.Generic.List$1;
 function assertNever(x) {
     throw new Error('Unexpected object: ' + x);
@@ -269,13 +269,13 @@ var KustoLanguageService = /** @class */ (function () {
             _d[TokenKind.CommentToken] = k2.ClassificationKind.Comment,
             _d[TokenKind.PlainTextToken] = k2.ClassificationKind.PlainText,
             _d[TokenKind.DataTypeToken] = k2.ClassificationKind.Type,
-            _d[TokenKind.ControlCommandToken] = k2.ClassificationKind.PlainText,
-            _d[TokenKind.CommandPartToken] = k2.ClassificationKind.PlainText,
+            _d[TokenKind.ControlCommandToken] = k2.ClassificationKind.PlainText, // TODO ?
+            _d[TokenKind.CommandPartToken] = k2.ClassificationKind.PlainText, // TODO ?
             _d[TokenKind.QueryParametersToken] = k2.ClassificationKind.QueryParameter,
-            _d[TokenKind.CslCommandToken] = k2.ClassificationKind.Keyword,
-            _d[TokenKind.LetVariablesToken] = k2.ClassificationKind.Identifier,
+            _d[TokenKind.CslCommandToken] = k2.ClassificationKind.Keyword, // TODO ?
+            _d[TokenKind.LetVariablesToken] = k2.ClassificationKind.Identifier, // TODO ?
             _d[TokenKind.PluginToken] = k2.ClassificationKind.Function,
-            _d[TokenKind.BracketRangeToken] = k2.ClassificationKind.Keyword,
+            _d[TokenKind.BracketRangeToken] = k2.ClassificationKind.Keyword, // TODO ?
             _d[TokenKind.ClientDirectiveToken] = k2.ClassificationKind.Keyword,
             _d);
         this._schemaCache = {};
@@ -384,7 +384,8 @@ var KustoLanguageService = /** @class */ (function () {
             });
         }
         var itemsAsArray = this.toArray(completionItems.Items);
-        var items = itemsAsArray
+        var sortedArray = sortByMatchTextKeepingKindOrder(itemsAsArray);
+        var items = sortedArray
             .filter(function (item) {
             return !(item &&
                 item.MatchText &&
@@ -422,6 +423,7 @@ var KustoLanguageService = /** @class */ (function () {
             lsItem.documentation = helpTopic
                 ? { value: _this.formatHelpTopic(helpTopic), kind: ls.MarkupKind.Markdown }
                 : undefined;
+            lsItem.data = { forcePrecedence: kItem.Kind === k2.CompletionKind.Column };
             return lsItem;
         });
         return Promise.resolve(ls.CompletionList.create(items));

package/release/esm/languageServiceManager/kustoMonarchLanguageDefinition.js

@@ -6,7 +6,7 @@ export var KustoLanguageDefinition = {
     brackets: [
         ['[', ']', 'delimiter.square'],
         ['(', ')', 'delimiter.parenthesis'],
-    ],
+    ], // types are wrong
     wordDefinition: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
     // .slice() call is for creating a shallow copy of the array since bridge.net shoves a $type property on the array which monaco doesn't like.
     // Kusto.Data.IntelliSense.CslCommandParser.PromotedOperatorCommandTokens.slice(0),

package/release/esm/monaco.contribution.js

@@ -97,21 +97,21 @@ monaco.editor.defineTheme(themeNames.light, {
     base: 'vs',
     inherit: true,
     rules: [
-        { token: 'comment', foreground: '008000' },
-        { token: 'variable.predefined', foreground: '800080' },
-        { token: 'function', foreground: '0000FF' },
-        { token: 'operator.sql', foreground: 'CC3700' },
-        { token: 'string', foreground: 'B22222' },
-        { token: 'operator.scss', foreground: '0000FF' },
-        { token: 'variable', foreground: 'C71585' },
-        { token: 'variable.parameter', foreground: '9932CC' },
-        { token: '', foreground: '000000' },
-        { token: 'type', foreground: '0000FF' },
-        { token: 'tag', foreground: '0000FF' },
-        { token: 'annotation', foreground: '2B91AF' },
-        { token: 'keyword', foreground: '0000FF' },
-        { token: 'number', foreground: '191970' },
-        { token: 'annotation', foreground: '9400D3' },
+        { token: 'comment', foreground: '008000' }, // CommentToken Green
+        { token: 'variable.predefined', foreground: '800080' }, // CalculatedColumnToken Purple
+        { token: 'function', foreground: '0000FF' }, // FunctionNameToken Blue
+        { token: 'operator.sql', foreground: 'CC3700' }, // _WAS_ OperatorToken OrangeRed, but wasn't accessible.
+        { token: 'string', foreground: 'B22222' }, // StringLiteralToken Firebrick
+        { token: 'operator.scss', foreground: '0000FF' }, // SubOperatorToken Blue
+        { token: 'variable', foreground: 'C71585' }, // TableColumnToken MediumVioletRed
+        { token: 'variable.parameter', foreground: '9932CC' }, // TableToken DarkOrchid
+        { token: '', foreground: '000000' }, // UnknownToken, PlainTextToken  Black
+        { token: 'type', foreground: '0000FF' }, // DataTypeToken Blue
+        { token: 'tag', foreground: '0000FF' }, // ControlCommandToken Blue
+        { token: 'annotation', foreground: '2B91AF' }, // QueryParametersToken FF2B91AF
+        { token: 'keyword', foreground: '0000FF' }, // CslCommandToken, PluginToken Blue
+        { token: 'number', foreground: '191970' }, // LetVariablesToken MidnightBlue
+        { token: 'annotation', foreground: '9400D3' }, // ClientDirectiveToken DarkViolet
         { token: 'invalid', background: 'cd3131' },
     ],
     colors: {},
@@ -120,21 +120,21 @@ monaco.editor.defineTheme(themeNames.dark, {
     base: 'vs-dark',
     inherit: true,
     rules: [
-        { token: 'comment', foreground: '608B4E' },
-        { token: 'variable.predefined', foreground: '4ec9b0' },
-        { token: 'function', foreground: 'dcdcaa' },
-        { token: 'operator.sql', foreground: '9cdcfe' },
-        { token: 'string', foreground: 'ce9178' },
-        { token: 'operator.scss', foreground: '569cd6' },
-        { token: 'variable', foreground: '4ec9b0' },
-        { token: 'variable.parameter', foreground: 'c586c0' },
-        { token: '', foreground: 'd4d4d4' },
-        { token: 'type', foreground: '569cd6' },
-        { token: 'tag', foreground: '569cd6' },
-        { token: 'annotation', foreground: '9cdcfe' },
-        { token: 'keyword', foreground: '569cd6' },
-        { token: 'number', foreground: 'd7ba7d' },
-        { token: 'annotation', foreground: 'b5cea8' },
+        { token: 'comment', foreground: '608B4E' }, // CommentToken Green
+        { token: 'variable.predefined', foreground: '4ec9b0' }, // CalculatedColumnToken Purple
+        { token: 'function', foreground: 'dcdcaa' }, // FunctionNameToken Blue
+        { token: 'operator.sql', foreground: '9cdcfe' }, // OperatorToken OrangeRed
+        { token: 'string', foreground: 'ce9178' }, // StringLiteralToken Firebrick
+        { token: 'operator.scss', foreground: '569cd6' }, // SubOperatorToken Blue
+        { token: 'variable', foreground: '4ec9b0' }, // TableColumnToken MediumVioletRed
+        { token: 'variable.parameter', foreground: 'c586c0' }, // TableToken DarkOrchid
+        { token: '', foreground: 'd4d4d4' }, // UnknownToken, PlainTextToken  Black
+        { token: 'type', foreground: '569cd6' }, // DataTypeToken Blue
+        { token: 'tag', foreground: '569cd6' }, // ControlCommandToken Blue
+        { token: 'annotation', foreground: '9cdcfe' }, // QueryParametersToken FF2B91AF
+        { token: 'keyword', foreground: '569cd6' }, // CslCommandToken, PluginToken Blue
+        { token: 'number', foreground: 'd7ba7d' }, // LetVariablesToken MidnightBlue
+        { token: 'annotation', foreground: 'b5cea8' }, // ClientDirectiveToken DarkViolet
         { token: 'invalid', background: 'cd3131' },
     ],
     colors: {
@@ -147,7 +147,7 @@ monaco.editor.defineTheme(themeNames.dark2, {
     rules: [],
     colors: {
         // see: https://code.visualstudio.com/api/references/theme-color#editor-widget-colors
-        'editor.background': '#1B1A19',
+        'editor.background': '#1B1A19', // gray 200
         'editorSuggestWidget.selectedBackground': '#004E8C',
     },
 });

package/release/esm/{schema-390a6d13.js → schema-33d2a0bc.js}

@@ -1,6 +1,6 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 11.0.0(2cd16f8743253b5a0133f2ba4f53203e02c1673c)
+ * monaco-kusto version: 11.1.0(a4f4a803b61d72aca89d2412b0c7849259e4fd91)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/