@kusto/monaco-kusto 6.2.0 → 7.0.1

package/release/dev/{main-81df16b2.js → main-a33ab1e1.js}

@@ -1,11 +1,11 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 6.2.0(8e26147bc7c3b5a7a3bc6ee55311dfa0b612c10c)
+ * monaco-kusto version: 7.0.1(d5a041ddb6e4a3a3ebcb2a1aa79da979a62b6da2)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
 
-define('vs/language/kusto/main-81df16b2', ['exports'], (function (exports) { 'use strict';
+define('vs/language/kusto/main-a33ab1e1', ['exports'], (function (exports) { 'use strict';
 
     /* --------------------------------------------------------------------------------------------
      * Copyright (c) Microsoft Corporation. All rights reserved.

package/release/dev/monaco.contribution.js

@@ -1,11 +1,11 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 6.2.0(8e26147bc7c3b5a7a3bc6ee55311dfa0b612c10c)
+ * monaco-kusto version: 7.0.1(d5a041ddb6e4a3a3ebcb2a1aa79da979a62b6da2)
  * 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'], (function (require, exports, monaco$1) { 'use strict';
+define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/editor/editor.main', './schema-0bb01ba6'], (function (require, exports, monaco, schema) { 'use strict';
 
     function _interopNamespaceDefault(e) {
         var n = Object.create(null);
@@ -24,7 +24,57 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
         return Object.freeze(n);
     }
 
-    var monaco__namespace = /*#__PURE__*/_interopNamespaceDefault(monaco$1);
+    var monaco__namespace = /*#__PURE__*/_interopNamespaceDefault(monaco);
+
+    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__namespace.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.
+     */
+    function extend(editor) {
+      var proto = Object.getPrototypeOf(editor);
+      proto.getCurrentCommandRange = function (cursorPosition) {
+        getCurrentCommandRange(this, cursorPosition);
+      };
+    }
 
     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 _classCallCheck$2(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
@@ -33,6 +83,7 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
     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); }
+
     /**
      * Highlights the command that surround cursor location
      */
@@ -77,7 +128,7 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
             this.decorations = this.editor.deltaDecorations(this.decorations, []);
             return;
           }
-          var commandRange = this.editor.getCurrentCommandRange(changeEvent.selection.getStartPosition());
+          var commandRange = getCurrentCommandRange(this.editor, changeEvent.selection.getStartPosition());
           var decorations = [{
             range: commandRange,
             options: KustoCommandHighlighter.CURRENT_COMMAND_HIGHLIGHT
@@ -87,7 +138,7 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
       }]);
       return KustoCommandHighlighter;
     }();
-    _defineProperty$2(KustoCommandHighlighter, "ID", 'editor.contrib.kustoCommandHighliter');
+    _defineProperty$2(KustoCommandHighlighter, "ID", 'editor.contrib.kustoCommandHighlighter');
     _defineProperty$2(KustoCommandHighlighter, "CURRENT_COMMAND_HIGHLIGHT", {
       className: 'selectionHighlight'
     });
@@ -120,7 +171,7 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
           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)],
+            keybindings: [monaco__namespace.KeyMod.chord(monaco__namespace.KeyMod.CtrlCmd | monaco__namespace.KeyCode.KeyK, monaco__namespace.KeyMod.CtrlCmd | monaco__namespace.KeyCode.KeyF)],
             run: function run(ed) {
               editor.trigger('KustoCommandFormatter', 'editor.action.formatSelection', null);
             },
@@ -131,52 +182,6 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
       });
     });
 
-    /**
-     * 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.
-     */
-    function extend(editor) {
-      var proto = Object.getPrototypeOf(editor);
-      proto.getCurrentCommandRange = function (cursorPosition) {
-        var zeroBasedCursorLineNumber = cursorPosition.lineNumber - 1;
-        var lines = this.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);
-      };
-    }
-
     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 _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); } }
@@ -184,8 +189,8 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
     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); }
-    // --- Kusto configuration and defaults ---------
 
+    // --- Kusto configuration and defaults ---------
     var LanguageServiceDefaultsImpl = /*#__PURE__*/function () {
       // in milliseconds. For example - this is 2 minutes 2 * 60 * 1000
 
@@ -492,12 +497,28 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
     function isStandaloneCodeEditor(editor) {
       return editor.addAction !== undefined;
     }
-    monaco__namespace.languages.kusto = {
+    var globalApi = {
+      getCslTypeNameFromClrType: schema.getCslTypeNameFromClrType,
+      getCallName: schema.getCallName,
+      getExpression: schema.getExpression,
+      getInputParametersAsCslString: schema.getInputParametersAsCslString,
+      getEntityDataTypeFromCslType: schema.getEntityDataTypeFromCslType,
       kustoDefaults: kustoDefaults,
-      getKustoWorker: getKustoWorker
+      getKustoWorker: getKustoWorker,
+      getCurrentCommandRange: getCurrentCommandRange
     };
+    monaco__namespace.languages.kusto = globalApi;
 
-    exports.LanguageServiceDefaultsImpl = LanguageServiceDefaultsImpl;
+    exports.getCallName = schema.getCallName;
+    exports.getCslTypeNameFromClrType = schema.getCslTypeNameFromClrType;
+    exports.getEntityDataTypeFromCslType = schema.getEntityDataTypeFromCslType;
+    exports.getExpression = schema.getExpression;
+    exports.getInputParametersAsCslString = schema.getInputParametersAsCslString;
+    Object.defineProperty(exports, 'showSchema', {
+        enumerable: true,
+        get: function () { return schema.showSchema; }
+    });
+    exports.getCurrentCommandRange = getCurrentCommandRange;
     exports.getKustoWorker = getKustoWorker;
     exports.kustoDefaults = kustoDefaults;
 

package/release/dev/schema-0bb01ba6.js

@@ -0,0 +1,109 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-kusto version: 7.0.1(d5a041ddb6e4a3a3ebcb2a1aa79da979a62b6da2)
+ * Released under the MIT license
+ * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
+ *-----------------------------------------------------------------------------*/
+
+define('vs/language/kusto/schema-0bb01ba6', ['exports'], (function (exports) { 'use strict';
+
+    // Definition of schema object in the context of language services. This model is exposed to consumers of this library.
+
+    /**
+     * An input parameter either be a scalar in which case it has a name, type and
+     * cslType, or it can be columnar, in which case it will have a name, and a list
+     * of scalar types which are the column types.
+     */
+
+    /**
+     * Schema types:
+     * Engine – The main schema type. Contains clusters, databases, tables, table columns and functions.
+     * Cluster Manager – Internal only. A schema for clusters that manages other clusters.
+     * Data Management – Internal only. A schema for ingestion point operations.
+     */
+
+    var dotnetTypeToKustoType = {
+      'System.SByte': 'bool',
+      'System.Byte': 'uint8',
+      'System.Int16': 'int16',
+      'System.UInt16': 'uint16',
+      'System.Int32': 'int',
+      'System.UInt32': 'uint',
+      'System.Int64': 'long',
+      'System.UInt64': 'ulong',
+      'System.String': 'string',
+      'System.Single': 'float',
+      'System.Double': 'real',
+      'System.DateTime': 'datetime',
+      'System.TimeSpan': 'timespan',
+      'System.Guid': 'guid',
+      'System.Boolean': 'bool',
+      'Newtonsoft.Json.Linq.JArray': 'dynamic',
+      'Newtonsoft.Json.Linq.JObject': 'dynamic',
+      'Newtonsoft.Json.Linq.JToken': 'dynamic',
+      'System.Object': 'dynamic',
+      'System.Data.SqlTypes.SqlDecimal': 'decimal'
+    };
+    var getCslTypeNameFromClrType = function getCslTypeNameFromClrType(clrType) {
+      return dotnetTypeToKustoType[clrType] || clrType;
+    };
+    var kustoTypeToEntityDataType = {
+      object: 'Object',
+      bool: 'Boolean',
+      uint8: 'Byte',
+      int16: 'Int16',
+      uint16: 'UInt16',
+      int: 'Int32',
+      uint: 'UInt32',
+      long: 'Int64',
+      ulong: 'UInt64',
+      float: 'Single',
+      real: 'Double',
+      decimal: 'Decimal',
+      datetime: 'DateTime',
+      string: 'String',
+      dynamic: 'Dynamic',
+      timespan: 'TimeSpan'
+    };
+    var getEntityDataTypeFromCslType = function getEntityDataTypeFromCslType(cslType) {
+      return kustoTypeToEntityDataType[cslType] || cslType;
+    };
+    var getCallName = function getCallName(fn) {
+      return "".concat(fn.name, "(").concat(fn.inputParameters.map(function (p) {
+        return "{".concat(p.name, "}");
+      }).join(','), ")");
+    };
+    var getExpression = function getExpression(fn) {
+      return "let ".concat(fn.name, " = ").concat(getInputParametersAsCslString(fn.inputParameters), " ").concat(fn.body);
+    };
+    var getInputParametersAsCslString = function getInputParametersAsCslString(inputParameters) {
+      return "(".concat(inputParameters.map(function (inputParameter) {
+        return getInputParameterAsCslString(inputParameter);
+      }).join(','), ")");
+    };
+    var getInputParameterAsCslString = function getInputParameterAsCslString(inputParameter) {
+      // If this is a tabular parameter
+      if (inputParameter.columns && inputParameter.columns.length > 0) {
+        var attributesAsString = inputParameter.columns.map(function (col) {
+          return "".concat(col.name, ":").concat(col.cslType || getCslTypeNameFromClrType(col.type));
+        }).join(',');
+        return "".concat(inputParameter.name, ":").concat(attributesAsString === '' ? '*' : attributesAsString);
+      } else {
+        return "".concat(inputParameter.name, ":").concat(inputParameter.cslType || getCslTypeNameFromClrType(inputParameter.type));
+      }
+    };
+
+    /**
+     * This is the schema of the output of kusto command
+     * .show schema as json
+     */
+    exports.showSchema = void 0;
+    (function (_showSchema) {})(exports.showSchema || (exports.showSchema = {}));
+
+    exports.getCallName = getCallName;
+    exports.getCslTypeNameFromClrType = getCslTypeNameFromClrType;
+    exports.getEntityDataTypeFromCslType = getEntityDataTypeFromCslType;
+    exports.getExpression = getExpression;
+    exports.getInputParametersAsCslString = getInputParametersAsCslString;
+
+}));

package/release/esm/commandFormatter.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="monaco-editor/monaco" />
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 export default class KustoCommandFormatter {
     private editor;
     private actionAdded;

package/release/esm/commandHighlighter.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="../monaco" />
-/// <reference types="monaco-editor/monaco" />
+import type * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 /**
  * Highlights the command that surround cursor location
  */

package/release/esm/extendedEditor.d.ts

@@ -1,5 +1,5 @@
-/// <reference types="../monaco" />
-/// <reference types="monaco-editor/monaco" />
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+export declare function getCurrentCommandRange(editor: monaco.editor.ICodeEditor, cursorPosition: monaco.Position): monaco.Range;
 /**
  * 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.

package/release/esm/kusto.worker.js

@@ -1,6 +1,6 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 6.2.0(8e26147bc7c3b5a7a3bc6ee55311dfa0b612c10c)
+ * monaco-kusto version: 7.0.1(d5a041ddb6e4a3a3ebcb2a1aa79da979a62b6da2)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
@@ -8,76 +8,12 @@
 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-cdbe085f.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';
 
-// Definition of schema object in the context of language services. This model is exposed to consumers of this library.
-
-// an input parameter either be a scalar in which case it has a name, type and cslType, or it can be columnar, in which case
-// it will have a name, and a list of scalar types which are the column types.
-/**
- * Schema types:
- * Engine – The main schema type. Contains clusters, databases, tables, table columns and functions.
- * Cluster Manager – Internal only. A schema for clusters that manages other clusters.
- * Data Management – Internal only. A schema for ingestion point operations.
- */
-const dotnetTypeToKustoType = {
-  'System.SByte': 'bool',
-  'System.Byte': 'uint8',
-  'System.Int16': 'int16',
-  'System.UInt16': 'uint16',
-  'System.Int32': 'int',
-  'System.UInt32': 'uint',
-  'System.Int64': 'long',
-  'System.UInt64': 'ulong',
-  'System.String': 'string',
-  'System.Single': 'float',
-  'System.Double': 'real',
-  'System.DateTime': 'datetime',
-  'System.TimeSpan': 'timespan',
-  'System.Guid': 'guid',
-  'System.Boolean': 'bool',
-  'Newtonsoft.Json.Linq.JArray': 'dynamic',
-  'Newtonsoft.Json.Linq.JObject': 'dynamic',
-  'Newtonsoft.Json.Linq.JToken': 'dynamic',
-  'System.Object': 'dynamic',
-  'System.Data.SqlTypes.SqlDecimal': 'decimal'
-};
-const getCslTypeNameFromClrType = clrType => dotnetTypeToKustoType[clrType] || clrType;
-const kustoTypeToEntityDataType = {
-  object: 'Object',
-  bool: 'Boolean',
-  uint8: 'Byte',
-  int16: 'Int16',
-  uint16: 'UInt16',
-  int: 'Int32',
-  uint: 'UInt32',
-  long: 'Int64',
-  ulong: 'UInt64',
-  float: 'Single',
-  real: 'Double',
-  decimal: 'Decimal',
-  datetime: 'DateTime',
-  string: 'String',
-  dynamic: 'Dynamic',
-  timespan: 'TimeSpan'
-};
-const getEntityDataTypeFromCslType = cslType => kustoTypeToEntityDataType[cslType] || cslType;
-const getCallName = fn => `${fn.name}(${fn.inputParameters.map(p => `{${p.name}}`).join(',')})`;
-const getExpression = fn => `let ${fn.name} = ${getInputParametersAsCslString(fn.inputParameters)} ${fn.body}`;
-const getInputParametersAsCslString = inputParameters => `(${inputParameters.map(inputParameter => getInputParameterAsCslString(inputParameter)).join(',')})`;
-const getInputParameterAsCslString = inputParameter => {
-  // If this is a tabular parameter
-  if (inputParameter.columns && inputParameter.columns.length > 0) {
-    const attributesAsString = inputParameter.columns.map(col => `${col.name}:${col.cslType || getCslTypeNameFromClrType(col.type)}`).join(',');
-    return `${inputParameter.name}:${attributesAsString === '' ? '*' : attributesAsString}`;
-  } else {
-    return `${inputParameter.name}:${inputParameter.cslType || getCslTypeNameFromClrType(inputParameter.type)}`;
-  }
-};
-
 var k = Kusto.Data.IntelliSense;
 var parsing = Kusto.Language.Parsing;
 var k2 = Kusto.Language.Editor;
@@ -604,7 +540,7 @@ class KustoLanguageService {
         const warningAndSuggestionDiagnostics = block.Service.GetAnalyzerDiagnostics(true);
         const filterredDiagnostics = this.toArray(warningAndSuggestionDiagnostics).filter(d => {
           const allowSeverity = enableWarnings && d.Severity === 'Warning' || enableSuggestions && d.Severity === 'Suggestion';
-          const allowCode = !this._languageSettings.disabledDiagnoticCodes?.includes(d.Code);
+          const allowCode = !this._languageSettings.disabledDiagnosticCodes?.includes(d.Code);
           return allowSeverity && allowCode;
         });
         diagnostics = diagnostics.concat(filterredDiagnostics);
@@ -1975,7 +1911,13 @@ function getKustoLanguageService() {
   return languageService;
 }
 
-class KustoWorker {
+/**
+ * We're using this interface to send messages to a worker, so using
+ * `InterfaceFor` to make it not nominal is more accurate. {@link KustoWorker}
+ * is the public, more limited version of this interface.
+ */
+
+class KustoWorkerImpl {
   // --- model sync -----------------------
 
   constructor(ctx, createData) {
@@ -2235,6 +2177,6 @@ class KustoWorker {
 self.onmessage = () => {
   // ignore the first message
   worker.initialize((ctx, createData) => {
-    return new KustoWorker(ctx, createData);
+    return new KustoWorkerImpl(ctx, createData);
   });
 };

package/release/esm/kustoMode.d.ts

@@ -1,10 +1,14 @@
-/// <reference types="../monaco" />
-/// <reference types="monaco-editor/monaco" />
-import type { LanguageServiceDefaultsImpl } from './monaco.contribution';
-import * as languageFeatures from './languageFeatures';
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import type { KustoWorker, LanguageServiceDefaults } from './monaco.contribution';
+import type { IKustoWorkerImpl } from './kustoWorker';
+export interface AugmentedWorker extends KustoWorker, Omit<IKustoWorkerImpl, 'setSchemaFromShowSchema'> {
+}
+export interface AugmentedWorkerAccessor {
+    (first: monaco.Uri, ...more: monaco.Uri[]): Promise<AugmentedWorker>;
+}
 /**
  * Called when Kusto language is first needed (a model has the language set)
  * @param defaults
  */
-export declare function setupMode(defaults: LanguageServiceDefaultsImpl, monacoInstance: typeof globalThis.monaco): languageFeatures.WorkerAccessor;
-export declare function getKustoWorker(): Promise<languageFeatures.WorkerAccessor>;
+export declare function setupMode(defaults: LanguageServiceDefaults, monacoInstance: typeof globalThis.monaco): AugmentedWorkerAccessor;
+export declare function getKustoWorker(): Promise<AugmentedWorkerAccessor>;

package/release/esm/kustoMode.js

@@ -1,6 +1,6 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 6.2.0(8e26147bc7c3b5a7a3bc6ee55311dfa0b612c10c)
+ * monaco-kusto version: 7.0.1(d5a041ddb6e4a3a3ebcb2a1aa79da979a62b6da2)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
@@ -862,12 +862,14 @@ class CompletionAdapter {
           insertText: entry.insertText,
           sortText: entry.sortText,
           filterText: entry.filterText,
+          // TODO: Is this cast safe?
           documentation: formatDocLink(entry.documentation?.value),
           detail: entry.detail,
           range: wordRange,
           kind: toCompletionItemKind(entry.kind)
         };
         if (entry.textEdit) {
+          // TODO: Where is the "range" property coming from?
           item.range = toRange(entry.textEdit.range);
           item.insertText = entry.textEdit.newText;
         }
@@ -1083,9 +1085,9 @@ function setupMode(defaults, monacoInstance) {
   const client = new WorkerManager(monacoInstance, defaults);
   disposables.push(client);
   const workerAccessor = (first, ...more) => {
-    const augmentedSetSchema = (schema, worker, globalScalarParameters, globalTabularParameters) => {
+    const augmentedSetSchema = async (schema, worker) => {
       const workerPromise = worker.setSchema(schema);
-      workerPromise.then(() => {
+      await workerPromise.then(() => {
         onSchemaChange.fire(schema);
       });
     };
@@ -1093,12 +1095,17 @@ function setupMode(defaults, monacoInstance) {
     return worker.then(worker => ({
       ...worker,
       setSchema: schema => augmentedSetSchema(schema, worker),
-      setSchemaFromShowSchema: (schema, connection, database, globalScalarParameters, globalTabularParameters) => {
-        worker.normalizeSchema(schema, connection, database).then(schema => globalScalarParameters ? {
-          ...schema,
-          globalScalarParameters,
-          globalTabularParameters
-        } : schema).then(normalized => augmentedSetSchema(normalized, worker));
+      async setSchemaFromShowSchema(schema, connection, database, globalScalarParameters, globalTabularParameters) {
+        await worker.normalizeSchema(schema, connection, database).then(schema => {
+          if (globalScalarParameters || globalTabularParameters) {
+            schema = {
+              ...schema,
+              globalScalarParameters,
+              globalTabularParameters
+            };
+          }
+          augmentedSetSchema(schema, worker);
+        });
       }
     }));
   };

package/release/esm/kustoWorker.d.ts

@@ -1,18 +1,29 @@
-/// <reference types="monaco-editor/monaco" />
 import * as ls from 'vscode-languageserver-types';
+import type { worker } from 'monaco-editor/esm/vs/editor/editor.worker';
+import type { IRange } from 'monaco-editor/esm/vs/editor/editor.api';
 import * as kustoService from './languageService/kustoLanguageService';
 import type { LanguageSettings } from './languageService/settings';
 import { Schema, showSchema, ScalarParameter, Database, TabularParameter } from './languageService/schema';
 import type { ColorizationRange } from './languageService/kustoLanguageService';
 import type { RenderInfo } from './languageService/renderInfo';
-export declare class KustoWorker {
+import type { ClusterReference, DatabaseReference } from './types';
+export type InterfaceFor<C> = {
+    [Member in keyof C]: C[Member];
+};
+/**
+ * We're using this interface to send messages to a worker, so using
+ * `InterfaceFor` to make it not nominal is more accurate. {@link KustoWorker}
+ * is the public, more limited version of this interface.
+ */
+export type IKustoWorkerImpl = InterfaceFor<KustoWorkerImpl>;
+export declare class KustoWorkerImpl {
     private _ctx;
     private _languageService;
     private _languageId;
     private _languageSettings;
-    constructor(ctx: monaco.worker.IWorkerContext, createData: ICreateData);
+    constructor(ctx: worker.IWorkerContext, createData: ICreateData);
     setSchema(schema: Schema): Promise<void>;
-    addClusterToSchema(uri: string, clusterName: string, databasesNames: string[]): Promise<void>;
+    addClusterToSchema(uri: string, clusterName: string, databasesNames: readonly string[]): Promise<void>;
     addDatabaseToSchema(uri: string, clusterName: string, databaseSchema: Database): Promise<void>;
     setSchemaFromShowSchema(schema: any, clusterConnectionString: string, databaseInContextName: string): Promise<void>;
     normalizeSchema(schema: showSchema.Result, clusterConnectionString: string, databaseInContextName: string): Promise<import("./languageService/schema").EngineSchema>;
@@ -44,7 +55,7 @@ export declare class KustoWorker {
      */
     getCommandAndLocationInContext(uri: string, cursorOffset: number): Promise<{
         text: string;
-        range: monaco.IRange;
+        range: IRange;
     } | null>;
     getCommandsInDocument(uri: string): Promise<{
         absoluteStart: number;
@@ -78,12 +89,15 @@ export declare class KustoWorker {
     doRename(uri: string, position: ls.Position, newName: string): Promise<ls.WorkspaceEdit>;
     doHover(uri: string, position: ls.Position): Promise<ls.Hover>;
     setParameters(scalarParameters: readonly ScalarParameter[], tabularParameters: readonly TabularParameter[]): Promise<void>;
-    getClusterReferences(uri: string, cursorOffset: number): Promise<kustoService.ClusterReference[]>;
-    getDatabaseReferences(uri: string, cursorOffset: number): Promise<kustoService.DatabaseReference[]>;
+    getClusterReferences(uri: string, cursorOffset: number): Promise<ClusterReference[]>;
+    getDatabaseReferences(uri: string, cursorOffset: number): Promise<DatabaseReference[]>;
     private _getTextDocument;
 }
 export interface ICreateData {
     languageId: string;
     languageSettings: LanguageSettings;
 }
-export declare function create(ctx: monaco.worker.IWorkerContext, createData: ICreateData): KustoWorker;
+/**
+ * Used when monaco-editor is resolved via amd modules
+ */
+export declare function create(ctx: worker.IWorkerContext, createData: ICreateData): IKustoWorkerImpl;