@kusto/monaco-kusto 10.0.22 → 11.1.0

package/release/dev/{main-2c182d5b.js → main-326a932b.js}

@@ -1,11 +1,11 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 10.0.22(7ecae10b6d90b8762a88e3cd029274be6df0fbd3)
+ * 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/main-2c182d5b', ['exports'], (function (exports) { 'use strict';
+define('vs/language/kusto/main-326a932b', ['exports'], (function (exports) { 'use strict';
 
     /* --------------------------------------------------------------------------------------------
      * Copyright (c) Microsoft Corporation. All rights reserved.
@@ -13,11 +13,11 @@ define('vs/language/kusto/main-2c182d5b', ['exports'], (function (exports) { 'us
      * ------------------------------------------------------------------------------------------ */
 
     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 _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 _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); }
     var DocumentUri;
     (function (DocumentUri) {
       function is(value) {
@@ -1902,7 +1902,7 @@ define('vs/language/kusto/main-2c182d5b', ['exports'], (function (exports) { 'us
         this._content = content;
         this._lineOffsets = undefined;
       }
-      _createClass(FullTextDocument, [{
+      return _createClass(FullTextDocument, [{
         key: "uri",
         get: function get() {
           return this._uri;
@@ -2001,7 +2001,6 @@ define('vs/language/kusto/main-2c182d5b', ['exports'], (function (exports) { 'us
           return this.getLineOffsets().length;
         }
       }]);
-      return FullTextDocument;
     }();
     var Is;
     (function (Is) {

package/release/dev/monaco.contribution.js

@@ -1,11 +1,11 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 10.0.22(7ecae10b6d90b8762a88e3cd029274be6df0fbd3)
+ * 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-c6f82d74'], (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,13 +234,11 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
           return this._workerMaxIdleTime;
         }
       }]);
-      return LanguageServiceDefaultsImpl;
     }();
     var defaultLanguageSettings = {
       includeControlCommands: true,
       newlineAfterPipe: true,
       openSuggestionDialogAfterPreviousSuggestionAccepted: true,
-      useIntellisenseV2: true,
       useSemanticColorization: true,
       useTokenColorization: false,
       enableHover: true,

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

@@ -1,11 +1,11 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 10.0.22(7ecae10b6d90b8762a88e3cd029274be6df0fbd3)
+ * 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-c6f82d74', ['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: 10.0.22(7ecae10b6d90b8762a88e3cd029274be6df0fbd3)
+ * monaco-kusto version: 11.1.0(a4f4a803b61d72aca89d2412b0c7849259e4fd91)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
@@ -8,12 +8,37 @@
 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-f88560be.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;
 var k2 = Kusto.Language.Editor;
@@ -213,7 +238,7 @@ class KustoLanguageService {
     this.createRulesProvider(this._kustoJsSchema, this._schema.clusterType);
   }
   doComplete(document, position) {
-    return this.isIntellisenseV2() ? this.doCompleteV2(document, position) : this.doCompleteV1(document, position);
+    return this.doCompleteV2(document, position);
   }
   disabledCompletionItemsV2 = {
     // render charts
@@ -280,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, i) => {
+    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.
@@ -299,31 +325,26 @@ class KustoLanguageService {
         format: ls.InsertTextFormat.PlainText
       };
       const lsItem = ls.CompletionItem.create(kItem.DisplayText);
-
-      // Adding to columns a prefix to their sortText so they will appear first in the list
-      let sortTextPrefix = lsItem.kind === ls.CompletionItemKind.Field ? 0 : itemsAsArray.length;
-      const countOfWords = lsItem.label.split('_').filter(item => !!item).length;
-      // We always want results with multiple words to show after shorter options.
-      // For example: to show "count_distinct" after "count"
-      sortTextPrefix = sortTextPrefix * countOfWords;
       const startPosition = document.positionAt(completionItems.EditStart);
       const endPosition = document.positionAt(completionItems.EditStart + completionItems.EditLength);
       lsItem.textEdit = ls.TextEdit.replace(ls.Range.create(startPosition, endPosition), textToInsert);
-      lsItem.sortText = this.getSortText(sortTextPrefix + i + 1);
       // Changing the first letter to be lower case, to ignore case-sensitive matching
       lsItem.filterText = kItem.MatchText.charAt(0).toLowerCase() + kItem.MatchText.slice(1);
       lsItem.kind = this.kustoKindToLsKindV2(kItem.Kind);
+      lsItem.sortText = createSortingText(index);
       lsItem.insertTextFormat = format;
       lsItem.detail = helpTopic ? helpTopic.ShortDescription : undefined;
       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));
   }
-  isIntellisenseV2 = () => this._languageSettings.useIntellisenseV2 && this._schema && this._schema.clusterType === 'Engine';
 
   /**
    * when trying to get a topic we need the function name (abs, toLower, ETC).
@@ -358,58 +379,6 @@ class KustoLanguageService {
     attach: k.OptionKind.Command,
     purge: k.OptionKind.Command
   };
-  doCompleteV1(document, position) {
-    // TODO: fix typing in CslCommandParser to allow rulesProvider to be query only.
-    let caretAbsolutePosition = document.offsetAt(position);
-
-    // find out what's the current command to only parse this one.
-    this.parseDocumentV1(document, k.ParseMode.CommandTokensOnly);
-    let currentCommand = this.getCurrentCommand(document, caretAbsolutePosition);
-    let commandTextUntilCursor = '';
-    if (currentCommand) {
-      currentCommand.AbsoluteStart;
-      this.parseTextV1(currentCommand.Text, k.ParseMode.TokenizeAllText);
-      const caretRelativePosition = caretAbsolutePosition - currentCommand.AbsoluteStart;
-      commandTextUntilCursor = currentCommand.Text.substring(currentCommand.CslExpressionStartPosition, caretRelativePosition);
-    }
-    let commandTextWithoutLastWord = this.getCommandWithoutLastWord(commandTextUntilCursor);
-    let context = this._rulesProvider.AnalyzeCommand$1(commandTextUntilCursor, currentCommand).Context;
-    let result = {
-      v: null
-    };
-    this._rulesProvider.TryMatchAnyRule(commandTextWithoutLastWord, result);
-    let rule = result.v;
-    if (rule) {
-      const completionOptions = this.toArray(rule.GetCompletionOptions(context));
-
-      // TODO once AppendPipePolicy becomes a public static member of ApplyPolicy in our c# code, and bridge.Net transplies this,
-      //  remove the 'as any' part..
-      // Also = DefaultApplyPolicy is internal in c# code, so not exposed in d.ts, so we cast it to any.
-      if (this._languageSettings.newlineAfterPipe && rule.DefaultAfterApplyPolicy === Kusto.Data.IntelliSense.ApplyPolicy.AppendPipePolicy) {
-        rule.DefaultAfterApplyPolicy = this._newlineAppendPipePolicy;
-      }
-      let options = completionOptions.filter(option => !(option && option.Value && this.disabledCompletionItemsV1[option.Value] === option.Kind)).map((option, ordinal) => {
-        const {
-          insertText,
-          insertTextFormat
-        } = this.getTextToInsert(rule, option);
-        const helpTopic = k.CslDocumentation.Instance.GetTopic(option);
-        const item = ls.CompletionItem.create(option.Value);
-        item.kind = this.kustoKindToLsKind(option.Kind);
-        item.insertText = insertText;
-        item.insertTextFormat = insertTextFormat;
-        item.sortText = this.getSortText(ordinal + 1);
-        item.detail = helpTopic ? helpTopic.ShortDescription : undefined;
-        item.documentation = helpTopic ? {
-          value: helpTopic.LongDescription,
-          kind: ls.MarkupKind.Markdown
-        } : undefined;
-        return item;
-      });
-      return Promise.resolve(ls.CompletionList.create(options));
-    }
-    return Promise.resolve(ls.CompletionList.create([]));
-  }
   doRangeFormat(document, range) {
     if (!document) {
       return Promise.resolve([]);
@@ -525,7 +494,7 @@ class KustoLanguageService {
   }
   doValidation(document, changeIntervals, includeWarnings, includeSuggestions) {
     // didn't implement validation for v1.
-    if (!document || !this.isIntellisenseV2()) {
+    if (!document) {
       return Promise.resolve([]);
     }
     const script = this.parseDocumentV2(document);
@@ -661,56 +630,6 @@ class KustoLanguageService {
       return Promise.resolve([]);
     }
 
-    // V1 intellisense
-    if (!this.isIntellisenseV2()) {
-      // Handle specific ranges changes (and not the whole doc)
-      if (changeIntervals.length > 0) {
-        this.parseDocumentV1(document, k.ParseMode.CommandTokensOnly);
-        const affectedCommands = this.toArray(this._parser.Results).filter(command =>
-        // a command is affected if it intersects at least on of changed ranges.
-        command // command can be null. we're filtering all nulls in the array.
-        ? changeIntervals.some(({
-          start: changeStart,
-          end: changeEnd
-        }) =>
-        // both intervals intersect if either the start or the end of interval A is inside interval B.
-        // If we deleted something at the end of a command, the interval will not intersect the current command.
-        // so we also want consider affected commands commands the end where the interval begins.
-        // hence the + 1.
-        command.AbsoluteStart >= changeStart && command.AbsoluteStart <= changeEnd || changeStart >= command.AbsoluteStart && changeStart <= command.AbsoluteEnd + 1) : false);
-
-        // We're not on any command so don't return any classifications.
-        // this can happen if we're at the and of the file and deleting empty rows (for example).
-        if (!affectedCommands || affectedCommands.length === 0) {
-          return Promise.resolve([{
-            classifications: [],
-            absoluteStart: changeIntervals[0].start,
-            absoluteEnd: changeIntervals[0].end
-          }]);
-        }
-        const results = affectedCommands.map(command => {
-          this.parseTextV1(command.Text, k.ParseMode.TokenizeAllText);
-          const k2Classifications = this.getClassificationsFromParseResult(command.AbsoluteStart);
-          const classifications = toClassifiedRange(k2Classifications);
-          return {
-            classifications: classifications,
-            absoluteStart: command.AbsoluteStart,
-            absoluteEnd: command.AbsoluteEnd
-          };
-        });
-        return Promise.resolve(results);
-      }
-
-      // Entire document requested
-      this.parseDocumentV1(document, k.ParseMode.TokenizeAllText);
-      const classifications = this.getClassificationsFromParseResult();
-      return Promise.resolve([{
-        classifications: toClassifiedRange(classifications),
-        absoluteStart: 0,
-        absoluteEnd: document.getText().length
-      }]);
-    }
-
     // V2 intellisense
     const script = this.parseDocumentV2(document);
     if (changeIntervals.length > 0) {
@@ -790,7 +709,7 @@ class KustoLanguageService {
   setSchema(schema) {
     this._schema = schema;
     // We support intellisenseV2 only if the clusterType is "Engine", even if the setting is enabled
-    if (this._languageSettings.useIntellisenseV2 && schema && schema.clusterType === 'Engine') {
+    if (schema && schema.clusterType === 'Engine') {
       let kustoJsSchemaV2 = this.convertToKustoJsSchemaV2(schema);
       this._kustoJsSchemaV2 = kustoJsSchemaV2;
       this._script = undefined;
@@ -805,7 +724,7 @@ class KustoLanguageService {
     return Promise.resolve();
   }
   setParameters(scalarParameters, tabularParameters) {
-    if (!this._languageSettings.useIntellisenseV2 || this._schema.clusterType !== 'Engine') {
+    if (this._schema.clusterType !== 'Engine') {
       throw new Error('setParameters requires intellisense V2 and Engine cluster');
     }
     this._schema.globalScalarParameters = scalarParameters;
@@ -934,11 +853,11 @@ class KustoLanguageService {
     return Promise.resolve(this._schema);
   }
   getCommandInContext(document, cursorOffset) {
-    return this.isIntellisenseV2() ? this.getCommandInContextV2(document, cursorOffset) : this.getCommandInContextV1(document, cursorOffset);
+    return this.getCommandInContextV2(document, cursorOffset);
   }
   getCommandAndLocationInContext(document, cursorOffset) {
     // We are going to remove v1 intellisense. no use to keep parity.
-    if (!document || !this.isIntellisenseV2()) {
+    if (!document) {
       return Promise.resolve(null);
     }
     const script = this.parseDocumentV2(document);
@@ -955,14 +874,6 @@ class KustoLanguageService {
       location
     });
   }
-  getCommandInContextV1(document, cursorOffset) {
-    this.parseDocumentV1(document, k.ParseMode.CommandTokensOnly);
-    const command = this.getCurrentCommand(document, cursorOffset);
-    if (!command) {
-      return Promise.resolve(null);
-    }
-    return Promise.resolve(command.Text);
-  }
   getCommandInContextV2(document, cursorOffset) {
     if (!document) {
       return Promise.resolve(null);
@@ -984,7 +895,7 @@ class KustoLanguageService {
     if (!document) {
       return Promise.resolve([]);
     }
-    return this.isIntellisenseV2() ? this.getCommandsInDocumentV2(document) : this.getCommandsInDocumentV1(document);
+    return this.getCommandsInDocumentV2(document);
   }
   getCommandsInDocumentV1(document) {
     this.parseDocumentV1(document, k.ParseMode.CommandTokensOnly);
@@ -1088,7 +999,7 @@ class KustoLanguageService {
     });
   }
   findDefinition(document, position) {
-    if (!document || !this.isIntellisenseV2()) {
+    if (!document) {
       return Promise.resolve([]);
     }
     const script = this.parseDocumentV2(document);
@@ -1110,7 +1021,7 @@ class KustoLanguageService {
     return Promise.resolve([location]);
   }
   findReferences(document, position) {
-    if (!document || !this.isIntellisenseV2()) {
+    if (!document) {
       return Promise.resolve([]);
     }
     const script = this.parseDocumentV2(document);
@@ -1134,10 +1045,9 @@ class KustoLanguageService {
     return Promise.resolve(references);
   }
   getQueryParams(document, cursorOffset) {
-    if (!document || !this.isIntellisenseV2()) {
+    if (!document) {
       return Promise.resolve([]);
     }
-    this.parseDocumentV2(document);
     const parsedAndAnalyzed = this.parseAndAnalyze(document, cursorOffset);
     const queryParamStatements = this.toArray(parsedAndAnalyzed.Syntax.GetDescendants(Kusto.Language.Syntax.QueryParametersStatement));
     if (!queryParamStatements || queryParamStatements.length == 0) {
@@ -1285,9 +1195,6 @@ class KustoLanguageService {
     return Promise.resolve(result);
   }
   getGlobalParams(document) {
-    if (!this.isIntellisenseV2()) {
-      return Promise.resolve([]);
-    }
     const params = this.toArray(this._kustoJsSchemaV2.Parameters);
     const result = params.map(param => ({
       name: param.Name,
@@ -1296,7 +1203,7 @@ class KustoLanguageService {
     return Promise.resolve(result);
   }
   doRename(document, position, newName) {
-    if (!document || !this.isIntellisenseV2()) {
+    if (!document) {
       return Promise.resolve(undefined);
     }
     const script = this.parseDocumentV2(document);
@@ -1329,7 +1236,7 @@ class KustoLanguageService {
     return Promise.resolve(workspaceEdit);
   }
   doHover(document, position) {
-    if (!document || !this.isIntellisenseV2()) {
+    if (!document) {
       return Promise.resolve(undefined);
     }
     const script = this.parseDocumentV2(document);
@@ -1597,30 +1504,6 @@ class KustoLanguageService {
     return newRange;
   }
 
-  /**
-   * Maps numbers to strings, such that if a>b numerically, f(a)>f(b) lexicographically.
-   * 1 -> "a", 26 -> "z", 27 -> "za", 28 -> "zb", 52 -> "zz", 53 ->"zza"
-   * @param order - The number to be converted to a sorting-string. order should start at 1.
-   * @returns A string repenting the order.
-   */
-  getSortText(order) {
-    if (order <= 0) {
-      throw new RangeError(`order should be a number >= 1. instead got ${order}`);
-    }
-    let sortText = '';
-    let numCharacters = 26; // "z" - "a" + 1;
-
-    let div = Math.floor(order / numCharacters);
-    for (let i = 0; i < div; ++i) {
-      sortText += 'z';
-    }
-    let reminder = order % numCharacters;
-    if (reminder > 0) {
-      sortText += String.fromCharCode(96 + reminder);
-    }
-    return sortText;
-  }
-
   /**
    * ParseTextV1 parses the given text with the given parse mode.
    * Additionally - it will make sure not to provide rules provider for non-engine clusters
@@ -1855,7 +1738,7 @@ class KustoLanguageService {
     return conversion || k2.ClassificationKind.PlainText;
   }
   parseAndAnalyze(document, cursorOffset) {
-    if (!document || !this.isIntellisenseV2()) {
+    if (!document) {
       return undefined;
     }
     const script = this.parseDocumentV2(document);
@@ -1900,7 +1783,6 @@ class KustoLanguageService {
 }
 let languageService = new KustoLanguageService(KustoLanguageService.dummySchema, {
   includeControlCommands: true,
-  useIntellisenseV2: true,
   useSemanticColorization: true,
   completionOptions: {
     includeExtendedSyntax: false

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;