@kusto/monaco-kusto 14.1.0 → 14.2.2

package/README.md

@@ -168,6 +168,18 @@ This section provides a high-level overview of the main files and their responsi
 
 ## Changelog
 
+### 14.2.2
+
+-   docs: add external references to semver-classification skill
+
+### 14.2.1
+
+-   chore: bump CI Node.js version to 22
+
+### 14.2.0
+
+-   feat: add `onSchemaUpdateComplete` event emitter so consumers can react to schema refresh completion
+
 ### 14.1.0
 
 -   feat: support graph schema

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kusto/monaco-kusto",
-    "version": "14.1.0",
+    "version": "14.2.2",
     "description": "CSL, KQL plugin for the Monaco Editor",
     "author": {
         "name": "Microsoft"

package/release/dev/kustoMode.js

@@ -1,11 +1,11 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 14.1.0(a07433e158c993af04f2cfb3a1453ddac68ec2bd)
+ * monaco-kusto version: 14.2.2(22fb70324f78ec316d3733a3c97919f80215e03d)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
 
-define('vs/language/kusto/kustoMode', ['exports', 'vs/editor/editor.main', './main-374ffef1', './types-330e461e'], (function (exports, monaco, main, types$1) { 'use strict';
+define('vs/language/kusto/kustoMode', ['exports', 'vs/editor/editor.main', './main-2d6da563', './types-fb9b493a'], (function (exports, monaco, main, types$1) { 'use strict';
 
     function _interopNamespaceDefault(e) {
         var n = Object.create(null);
@@ -1556,9 +1556,10 @@ define('vs/language/kusto/kustoMode', ['exports', 'vs/editor/editor.main', './ma
     function _toPropertyKey$1(t) { var i = _toPrimitive$1(t, "string"); return "symbol" == _typeof$2(i) ? i : i + ""; }
     function _toPrimitive$1(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); }
     var SemanticTokensProvider = /*#__PURE__*/function () {
-      function SemanticTokensProvider(classificationsGetter) {
+      function SemanticTokensProvider(classificationsGetter, onTokensProvided) {
         _classCallCheck(this, SemanticTokensProvider);
         this.classificationsGetter = classificationsGetter;
+        this.onTokensProvided = onTokensProvided;
       }
       return _createClass(SemanticTokensProvider, [{
         key: "getLegend",
@@ -1572,7 +1573,8 @@ define('vs/language/kusto/kustoMode', ['exports', 'vs/editor/editor.main', './ma
         key: "provideDocumentSemanticTokens",
         value: function () {
           var _provideDocumentSemanticTokens = _asyncToGenerator$2( /*#__PURE__*/_regeneratorRuntime$2().mark(function _callee(model) {
-            var resource, classifications, tokens, prevLine, prevChar, _iterator, _step, classification, parts, _i, _parts, part, _part, absLine, absChar, length, kind, modifiers, deltaLine, deltaChar;
+            var _this$onTokensProvide;
+            var resource, classifications, tokens, prevLine, prevChar, _iterator, _step, classification, parts, _i, _parts, part, _part, absLine, absChar, length, kind, modifiers, deltaLine, deltaChar, result;
             return _regeneratorRuntime$2().wrap(function _callee$(_context) {
               while (1) switch (_context.prev = _context.next) {
                 case 0:
@@ -1604,11 +1606,13 @@ define('vs/language/kusto/kustoMode', ['exports', 'vs/editor/editor.main', './ma
                   } finally {
                     _iterator.f();
                   }
-                  return _context.abrupt("return", {
+                  result = {
                     data: new Uint32Array(tokens.flat(2)),
                     resultId: model.getVersionId().toString()
-                  });
-                case 10:
+                  };
+                  (_this$onTokensProvide = this.onTokensProvided) === null || _this$onTokensProvide === void 0 || _this$onTokensProvide.call(this, resource);
+                  return _context.abrupt("return", result);
+                case 12:
                 case "end":
                   return _context.stop();
               }
@@ -1651,10 +1655,10 @@ define('vs/language/kusto/kustoMode', ['exports', 'vs/editor/editor.main', './ma
     function _asyncToGenerator$1(n) { return function () { var t = this, e = arguments; return new Promise(function (r, o) { var a = n.apply(t, e); function _next(n) { asyncGeneratorStep$1(a, r, o, _next, _throw, "next", n); } function _throw(n) { asyncGeneratorStep$1(a, r, o, _next, _throw, "throw", n); } _next(void 0); }); }; }
     // Registers semantic token provider that utilizes the language service
     // for more context-relevant syntax highlighting.
-    function semanticTokensProviderRegistrarCreator() {
+    function semanticTokensProviderRegistrarCreator(onTokensProvided) {
       var semanticTokensProviderRegistrar = semanticTokensProviderRegistrarCreatorForTest();
       return function (monacoInstance, workerAccessor) {
-        var semanticTokensProvider = semanticTokensProviderMaker(workerAccessor);
+        var semanticTokensProvider = semanticTokensProviderMaker(workerAccessor, onTokensProvided);
         semanticTokensProviderRegistrar(monacoInstance, semanticTokensProvider);
       };
     }
@@ -1667,7 +1671,7 @@ define('vs/language/kusto/kustoMode', ['exports', 'vs/editor/editor.main', './ma
         semanticTokensDisposable = monacoInstance.languages.registerDocumentSemanticTokensProvider(types$1.LANGUAGE_ID, semanticTokensProvider);
       };
     }
-    function semanticTokensProviderMaker(workerAccessor) {
+    function semanticTokensProviderMaker(workerAccessor, onTokensProvided) {
       var classificationsGetter = /*#__PURE__*/function () {
         var _ref = _asyncToGenerator$1( /*#__PURE__*/_regeneratorRuntime$1().mark(function _callee(resource) {
           var worker;
@@ -1689,7 +1693,7 @@ define('vs/language/kusto/kustoMode', ['exports', 'vs/editor/editor.main', './ma
           return _ref.apply(this, arguments);
         };
       }();
-      return new SemanticTokensProvider(classificationsGetter);
+      return new SemanticTokensProvider(classificationsGetter, onTokensProvided);
     }
 
     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); }
@@ -1717,10 +1721,16 @@ define('vs/language/kusto/kustoMode', ['exports', 'vs/editor/editor.main', './ma
     /**
      * Called when Kusto language is first needed (a model has the language set)
      * @param defaults
+     * @param monacoInstance
+     * @param onSchemaUpdateCompleteEmitter Optional,fired when the language service has finished all schema-related work
      */
-    function setupMode(defaults, monacoInstance) {
+    function setupMode(defaults, monacoInstance, onSchemaUpdateCompleteEmitter) {
       var onSchemaChange = new monaco__namespace.Emitter();
-      var semanticTokensProviderRegistrar = semanticTokensProviderRegistrarCreator();
+      var semanticTokensProviderRegistrar = semanticTokensProviderRegistrarCreator(function (uri) {
+        onSchemaUpdateCompleteEmitter === null || onSchemaUpdateCompleteEmitter === void 0 || onSchemaUpdateCompleteEmitter.fire({
+          uri: uri
+        });
+      });
       var client = new WorkerManager(monacoInstance, defaults);
       var workerAccessor = function workerAccessor(first) {
         var augmentedSetSchema = /*#__PURE__*/function () {

package/release/dev/kustoWorker.js

@@ -1,11 +1,11 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 14.1.0(a07433e158c993af04f2cfb3a1453ddac68ec2bd)
+ * monaco-kusto version: 14.2.2(22fb70324f78ec316d3733a3c97919f80215e03d)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
 
-define('vs/language/kusto/kustoWorker', ['exports', './main-374ffef1', './schema-778d43e4'], (function (exports, main, schema) { 'use strict';
+define('vs/language/kusto/kustoWorker', ['exports', './main-2d6da563', './schema-c2628e1d'], (function (exports, main, schema) { 'use strict';
 
     function _slicedToArray$2(r, e) { return _arrayWithHoles$2(r) || _iterableToArrayLimit$2(r, e) || _unsupportedIterableToArray$3(r, e) || _nonIterableRest$2(); }
     function _nonIterableRest$2() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }

package/release/dev/{main-374ffef1.js → main-2d6da563.js}

@@ -1,11 +1,11 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 14.1.0(a07433e158c993af04f2cfb3a1453ddac68ec2bd)
+ * monaco-kusto version: 14.2.2(22fb70324f78ec316d3733a3c97919f80215e03d)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
 
-define('vs/language/kusto/main-374ffef1', ['exports'], (function (exports) { 'use strict';
+define('vs/language/kusto/main-2d6da563', ['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: 14.1.0(a07433e158c993af04f2cfb3a1453ddac68ec2bd)
+ * monaco-kusto version: 14.2.2(22fb70324f78ec316d3733a3c97919f80215e03d)
  * 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', './types-330e461e', './schema-778d43e4'], (function (require, exports, monaco, types, schema) { 'use strict';
+define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/editor/editor.main', './types-fb9b493a', './schema-c2628e1d'], (function (require, exports, monaco, types, schema) { 'use strict';
 
     function _interopNamespaceDefault(e) {
         var n = Object.create(null);
@@ -594,6 +594,10 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
         });
       });
     }
+
+    // Fires after semantic tokens are (re)computed following a schema update; payload carries the model URI.
+    var onSchemaUpdateCompleteEmitter = new monaco__namespace.Emitter();
+    var onSchemaUpdateComplete = onSchemaUpdateCompleteEmitter.event;
     function withMode(callback) {
       return new Promise(function (resolve, reject) { require(['./kustoMode'], resolve, reject); }).then(callback);
     }
@@ -604,7 +608,7 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
           case 0:
             _context.next = 2;
             return withMode(function (mode) {
-              return mode.setupMode(kustoDefaults, monaco__namespace);
+              return mode.setupMode(kustoDefaults, monaco__namespace, onSchemaUpdateCompleteEmitter);
             });
           case 2:
           case "end":
@@ -675,7 +679,8 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
       getEntityDataTypeFromCslType: schema.getEntityDataTypeFromCslType,
       kustoDefaults: kustoDefaults,
       getKustoWorker: getKustoWorker,
-      getRangeHtml: getRangeHtml
+      getRangeHtml: getRangeHtml,
+      onSchemaUpdateComplete: onSchemaUpdateComplete
     };
     monaco__namespace.languages.kusto = globalApi;
 
@@ -688,5 +693,6 @@ define('vs/language/kusto/monaco.contribution', ['require', 'exports', 'vs/edito
     exports.getKustoWorker = getKustoWorker;
     exports.getRangeHtml = getRangeHtml;
     exports.kustoDefaults = kustoDefaults;
+    exports.onSchemaUpdateComplete = onSchemaUpdateComplete;
 
 }));

package/release/dev/{schema-778d43e4.js → schema-c2628e1d.js}

@@ -1,11 +1,11 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 14.1.0(a07433e158c993af04f2cfb3a1453ddac68ec2bd)
+ * monaco-kusto version: 14.2.2(22fb70324f78ec316d3733a3c97919f80215e03d)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
 
-define('vs/language/kusto/schema-778d43e4', ['exports'], (function (exports) { 'use strict';
+define('vs/language/kusto/schema-c2628e1d', ['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/dev/{types-330e461e.js → types-fb9b493a.js}

@@ -1,11 +1,11 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 14.1.0(a07433e158c993af04f2cfb3a1453ddac68ec2bd)
+ * monaco-kusto version: 14.2.2(22fb70324f78ec316d3733a3c97919f80215e03d)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
 
-define('vs/language/kusto/types-330e461e', ['exports'], (function (exports) { 'use strict';
+define('vs/language/kusto/types-fb9b493a', ['exports'], (function (exports) { 'use strict';
 
     var LANGUAGE_ID = 'kusto';
 

package/release/esm/{globals-bfe000bf.js → globals-2482dd04.js}

@@ -1,6 +1,6 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 14.1.0(a07433e158c993af04f2cfb3a1453ddac68ec2bd)
+ * monaco-kusto version: 14.2.2(22fb70324f78ec316d3733a3c97919f80215e03d)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/

package/release/esm/kusto.worker.js

@@ -1,6 +1,6 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 14.1.0(a07433e158c993af04f2cfb3a1453ddac68ec2bd)
+ * monaco-kusto version: 14.2.2(22fb70324f78ec316d3733a3c97919f80215e03d)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
@@ -8,7 +8,7 @@
 import * as worker from 'monaco-editor/esm/vs/editor/editor.worker';
 import * as ls from 'vscode-languageserver-types';
 import XRegExp from 'xregexp';
-import { d as getEntityDataTypeFromCslType, a as getCallName, b as getExpression, g as getCslTypeNameFromClrType } from './schema-9bf4386b.js';
+import { d as getEntityDataTypeFromCslType, a as getCallName, b as getExpression, g as getCslTypeNameFromClrType } from './schema-6e15bdaa.js';
 import '@kusto/language-service/bridge.min';
 import '@kusto/language-service/Kusto.JavaScript.Client.min';
 import '@kusto/language-service/newtonsoft.json.min';

package/release/esm/kustoMode.d.ts

@@ -9,6 +9,10 @@ export interface AugmentedWorkerAccessor {
 /**
  * Called when Kusto language is first needed (a model has the language set)
  * @param defaults
+ * @param monacoInstance
+ * @param onSchemaUpdateCompleteEmitter Optional,fired when the language service has finished all schema-related work
  */
-export declare function setupMode(defaults: LanguageServiceDefaults, monacoInstance: typeof globalThis.monaco): void;
+export declare function setupMode(defaults: LanguageServiceDefaults, monacoInstance: typeof monaco, onSchemaUpdateCompleteEmitter?: monaco.Emitter<{
+    uri: monaco.Uri;
+}>): void;
 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: 14.1.0(a07433e158c993af04f2cfb3a1453ddac68ec2bd)
+ * monaco-kusto version: 14.2.2(22fb70324f78ec316d3733a3c97919f80215e03d)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
@@ -9,7 +9,7 @@ import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 import { languages } from 'monaco-editor/esm/vs/editor/editor.api';
 import * as ls from 'vscode-languageserver-types';
 import debounce from 'lodash-es/debounce';
-import { L as LANGUAGE_ID, T as Token, t as tokenTypes } from './globals-bfe000bf.js';
+import { L as LANGUAGE_ID, T as Token, t as tokenTypes } from './globals-2482dd04.js';
 
 class WorkerManager {
   constructor(_monacoInstance, defaults) {
@@ -792,8 +792,9 @@ const kustoLanguageDefinition = {
 };
 
 class SemanticTokensProvider {
-  constructor(classificationsGetter) {
+  constructor(classificationsGetter, onTokensProvided) {
     this.classificationsGetter = classificationsGetter;
+    this.onTokensProvided = onTokensProvided;
   }
   getLegend() {
     return {
@@ -818,10 +819,12 @@ class SemanticTokensProvider {
         prevChar = absChar;
       }
     }
-    return {
+    const result = {
       data: new Uint32Array(tokens.flat(2)),
       resultId: model.getVersionId().toString()
     };
+    this.onTokensProvided?.(resource);
+    return result;
   }
   releaseDocumentSemanticTokens() {}
 }
@@ -850,10 +853,10 @@ function toSemanticTokens(classification, model) {
 
 // Registers semantic token provider that utilizes the language service
 // for more context-relevant syntax highlighting.
-function semanticTokensProviderRegistrarCreator() {
+function semanticTokensProviderRegistrarCreator(onTokensProvided) {
   const semanticTokensProviderRegistrar = semanticTokensProviderRegistrarCreatorForTest();
   return (monacoInstance, workerAccessor) => {
-    const semanticTokensProvider = semanticTokensProviderMaker(workerAccessor);
+    const semanticTokensProvider = semanticTokensProviderMaker(workerAccessor, onTokensProvided);
     semanticTokensProviderRegistrar(monacoInstance, semanticTokensProvider);
   };
 }
@@ -866,12 +869,12 @@ function semanticTokensProviderRegistrarCreatorForTest() {
     semanticTokensDisposable = monacoInstance.languages.registerDocumentSemanticTokensProvider(LANGUAGE_ID, semanticTokensProvider);
   };
 }
-function semanticTokensProviderMaker(workerAccessor) {
+function semanticTokensProviderMaker(workerAccessor, onTokensProvided) {
   const classificationsGetter = async resource => {
     const worker = await workerAccessor(resource);
     return worker.getClassifications(resource.toString());
   };
-  return new SemanticTokensProvider(classificationsGetter);
+  return new SemanticTokensProvider(classificationsGetter, onTokensProvided);
 }
 
 languages.LanguageConfiguration;
@@ -884,10 +887,16 @@ let workerPromise = new Promise((resolve, reject) => {
 /**
  * Called when Kusto language is first needed (a model has the language set)
  * @param defaults
+ * @param monacoInstance
+ * @param onSchemaUpdateCompleteEmitter Optional,fired when the language service has finished all schema-related work
  */
-function setupMode(defaults, monacoInstance) {
+function setupMode(defaults, monacoInstance, onSchemaUpdateCompleteEmitter) {
   const onSchemaChange = new monaco.Emitter();
-  const semanticTokensProviderRegistrar = semanticTokensProviderRegistrarCreator();
+  const semanticTokensProviderRegistrar = semanticTokensProviderRegistrarCreator(uri => {
+    onSchemaUpdateCompleteEmitter?.fire({
+      uri
+    });
+  });
   const client = new WorkerManager(monacoInstance, defaults);
   const workerAccessor = (first, ...more) => {
     const augmentedSetSchema = async (schema, worker) => {

package/release/esm/monaco.contribution.d.ts

@@ -19,5 +19,8 @@ declare class LanguageServiceDefaultsImpl implements LanguageServiceDefaults {
     getWorkerMaxIdleTime(): number;
 }
 export declare function getKustoWorker(): Promise<WorkerAccessor>;
+export declare const onSchemaUpdateComplete: monaco.IEvent<{
+    uri: monaco.Uri;
+}>;
 export declare const kustoDefaults: LanguageServiceDefaultsImpl;
 export { getRangeHtml };

package/release/esm/monaco.contribution.js

@@ -1,15 +1,15 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 14.1.0(a07433e158c993af04f2cfb3a1453ddac68ec2bd)
+ * monaco-kusto version: 14.2.2(22fb70324f78ec316d3733a3c97919f80215e03d)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
 
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 import { editor } from 'monaco-editor/esm/vs/editor/editor.api';
-import { T as Token, L as LANGUAGE_ID } from './globals-bfe000bf.js';
-import { g as getCslTypeNameFromClrType, a as getCallName, b as getExpression, c as getInputParametersAsCslString, d as getEntityDataTypeFromCslType } from './schema-9bf4386b.js';
-export { s as showSchema } from './schema-9bf4386b.js';
+import { T as Token, L as LANGUAGE_ID } from './globals-2482dd04.js';
+import { g as getCslTypeNameFromClrType, a as getCallName, b as getExpression, c as getInputParametersAsCslString, d as getEntityDataTypeFromCslType } from './schema-6e15bdaa.js';
+export { s as showSchema } from './schema-6e15bdaa.js';
 
 function getCurrentCommandRange(editor, cursorPosition) {
   const zeroBasedCursorLineNumber = cursorPosition.lineNumber - 1;
@@ -516,12 +516,16 @@ function getKustoWorker() {
     });
   });
 }
+
+// Fires after semantic tokens are (re)computed following a schema update; payload carries the model URI.
+const onSchemaUpdateCompleteEmitter = new monaco.Emitter();
+const onSchemaUpdateComplete = onSchemaUpdateCompleteEmitter.event;
 function withMode(callback) {
   return import('./kustoMode.js').then(callback);
 }
 const kustoDefaults = new LanguageServiceDefaultsImpl(defaultLanguageSettings);
 monaco.languages.onLanguage('kusto', async () => {
-  await withMode(mode => mode.setupMode(kustoDefaults, monaco));
+  await withMode(mode => mode.setupMode(kustoDefaults, monaco, onSchemaUpdateCompleteEmitter));
 });
 monaco.languages.register({
   id: LANGUAGE_ID,
@@ -582,8 +586,9 @@ const globalApi = {
   getEntityDataTypeFromCslType,
   kustoDefaults,
   getKustoWorker,
-  getRangeHtml
+  getRangeHtml,
+  onSchemaUpdateComplete
 };
 monaco.languages.kusto = globalApi;
 
-export { getCallName, getCslTypeNameFromClrType, getEntityDataTypeFromCslType, getExpression, getInputParametersAsCslString, getKustoWorker, getRangeHtml, kustoDefaults };
+export { getCallName, getCslTypeNameFromClrType, getEntityDataTypeFromCslType, getExpression, getInputParametersAsCslString, getKustoWorker, getRangeHtml, kustoDefaults, onSchemaUpdateComplete };

package/release/esm/{schema-9bf4386b.js → schema-6e15bdaa.js}

@@ -1,6 +1,6 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 14.1.0(a07433e158c993af04f2cfb3a1453ddac68ec2bd)
+ * monaco-kusto version: 14.2.2(22fb70324f78ec316d3733a3c97919f80215e03d)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/

package/release/esm/syntaxHighlighting/SemanticTokensProvider.d.ts

@@ -2,9 +2,11 @@ import type * as monaco from 'monaco-editor';
 import { editor } from 'monaco-editor';
 import { ClassificationRange } from './types';
 type ClassificationsGetter = (resource: monaco.Uri) => Promise<ClassificationRange[]>;
+type OnTokensProvided = (uri: monaco.Uri) => void;
 export declare class SemanticTokensProvider implements monaco.languages.DocumentSemanticTokensProvider {
     private readonly classificationsGetter;
-    constructor(classificationsGetter: ClassificationsGetter);
+    private readonly onTokensProvided?;
+    constructor(classificationsGetter: ClassificationsGetter, onTokensProvided?: OnTokensProvided);
     getLegend(): {
         tokenTypes: import("./types").Token[];
         tokenModifiers: any[];

package/release/esm/syntaxHighlighting/SemanticTokensProvider.js

@@ -36,22 +36,24 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 import { tokenTypes } from './types';
 var SemanticTokensProvider = /** @class */ (function () {
-    function SemanticTokensProvider(classificationsGetter) {
+    function SemanticTokensProvider(classificationsGetter, onTokensProvided) {
         this.classificationsGetter = classificationsGetter;
+        this.onTokensProvided = onTokensProvided;
     }
     SemanticTokensProvider.prototype.getLegend = function () {
         return { tokenTypes: tokenTypes, tokenModifiers: [] };
     };
     SemanticTokensProvider.prototype.provideDocumentSemanticTokens = function (model) {
         return __awaiter(this, void 0, void 0, function () {
-            var resource, classifications, tokens, prevLine, prevChar, _i, classifications_1, classification, parts, _a, parts_1, part, absLine, absChar, length_1, kind, modifiers, deltaLine, deltaChar;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            var resource, classifications, tokens, prevLine, prevChar, _i, classifications_1, classification, parts, _a, parts_1, part, absLine, absChar, length_1, kind, modifiers, deltaLine, deltaChar, result;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
                     case 0:
                         resource = model.uri;
                         return [4 /*yield*/, this.classificationsGetter(resource)];
                     case 1:
-                        classifications = _b.sent();
+                        classifications = _c.sent();
                         tokens = [];
                         prevLine = 0;
                         prevChar = 0;
@@ -68,10 +70,12 @@ var SemanticTokensProvider = /** @class */ (function () {
                                 prevChar = absChar;
                             }
                         }
-                        return [2 /*return*/, {
-                                data: new Uint32Array(tokens.flat(2)),
-                                resultId: model.getVersionId().toString(),
-                            }];
+                        result = {
+                            data: new Uint32Array(tokens.flat(2)),
+                            resultId: model.getVersionId().toString(),
+                        };
+                        (_b = this.onTokensProvided) === null || _b === void 0 ? void 0 : _b.call(this, resource);
+                        return [2 /*return*/, result];
                 }
             });
         });

package/release/esm/syntaxHighlighting/semanticTokensProviderRegistrar.d.ts

@@ -2,5 +2,5 @@ import monaco from 'monaco-editor/esm/vs/editor/editor.api';
 import { SemanticTokensProvider } from './SemanticTokensProvider';
 import { AugmentedWorkerAccessor } from '../kustoMode';
 export type SemanticTokensProviderRegistrar = (monacoInstance: typeof monaco, semanticTokensProvider: SemanticTokensProvider) => void;
-export declare function semanticTokensProviderRegistrarCreator(): (monacoInstance: typeof monaco, workerAccessor: AugmentedWorkerAccessor) => void;
+export declare function semanticTokensProviderRegistrarCreator(onTokensProvided?: (uri: monaco.Uri) => void): (monacoInstance: typeof monaco, workerAccessor: AugmentedWorkerAccessor) => void;
 export declare function semanticTokensProviderRegistrarCreatorForTest(): (monacoInstance: typeof monaco, semanticTokensProvider: SemanticTokensProvider) => void;

package/release/esm/syntaxHighlighting/semanticTokensProviderRegistrar.js

@@ -38,10 +38,10 @@ import { LANGUAGE_ID } from '../globals';
 import { SemanticTokensProvider } from './SemanticTokensProvider';
 // Registers semantic token provider that utilizes the language service
 // for more context-relevant syntax highlighting.
-export function semanticTokensProviderRegistrarCreator() {
+export function semanticTokensProviderRegistrarCreator(onTokensProvided) {
     var semanticTokensProviderRegistrar = semanticTokensProviderRegistrarCreatorForTest();
     return function (monacoInstance, workerAccessor) {
-        var semanticTokensProvider = semanticTokensProviderMaker(workerAccessor);
+        var semanticTokensProvider = semanticTokensProviderMaker(workerAccessor, onTokensProvided);
         semanticTokensProviderRegistrar(monacoInstance, semanticTokensProvider);
     };
 }
@@ -54,7 +54,7 @@ export function semanticTokensProviderRegistrarCreatorForTest() {
         semanticTokensDisposable = monacoInstance.languages.registerDocumentSemanticTokensProvider(LANGUAGE_ID, semanticTokensProvider);
     };
 }
-function semanticTokensProviderMaker(workerAccessor) {
+function semanticTokensProviderMaker(workerAccessor, onTokensProvided) {
     var _this = this;
     var classificationsGetter = function (resource) { return __awaiter(_this, void 0, void 0, function () {
         var worker;
@@ -67,5 +67,5 @@ function semanticTokensProviderMaker(workerAccessor) {
             }
         });
     }); };
-    return new SemanticTokensProvider(classificationsGetter);
+    return new SemanticTokensProvider(classificationsGetter, onTokensProvided);
 }