@kusto/monaco-kusto 11.3.0 → 12.0.0

package/release/esm/kusto.worker.js

@@ -1,6 +1,6 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 11.3.0(1980c071675308de7c009d1dcaeec2f7be442a6e)
+ * monaco-kusto version: 12.0.0(2f1838c12bdb98562467acf51b6fd3e396182e86)
  * 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-aeb83929.js';
+import { a as getEntityDataTypeFromCslType, b as getCallName, c as getExpression, g as getCslTypeNameFromClrType } from './schema-66580db4.js';
 import '@kusto/language-service/bridge.min';
 import '@kusto/language-service/Kusto.JavaScript.Client.min';
 import '@kusto/language-service/newtonsoft.json.min';
@@ -67,19 +67,6 @@ let TokenKind = /*#__PURE__*/function (TokenKind) {
  * This issue started happening once upgrading to 0.20.0 from 0.15.5.
  */
 
-/**
- * convert the bridge.net object to a plain javascript object that only contains data.
- * @param k2Classifications @kusto/language-service-next bridge.net object
- */
-function toClassifiedRange(k2Classifications) {
-  return k2Classifications.map(classification => ({
-    start: classification.Start,
-    end: classification.End,
-    length: classification.Length,
-    kind: classification.Kind
-  }));
-}
-
 /**
  * colorization data for specific line range.
  */
@@ -312,9 +299,6 @@ class KustoLanguageService {
         value: this.formatHelpTopic(helpTopic),
         kind: ls.MarkupKind.Markdown
       } : undefined;
-      lsItem.data = {
-        forcePrecedence: kItem.Kind === k2.CompletionKind.Column
-      };
       return lsItem;
     });
     return Promise.resolve(ls.CompletionList.create(items));
@@ -337,22 +321,6 @@ class KustoLanguageService {
     }
     return k.CslDocumentation.Instance.GetTopic(completionOption);
   }
-  disabledCompletionItemsV1 = {
-    capacity: k.OptionKind.Policy,
-    callout: k.OptionKind.Policy,
-    encoding: k.OptionKind.Policy,
-    batching: k.OptionKind.Policy,
-    querythrottling: k.OptionKind.Policy,
-    merge: k.OptionKind.Policy,
-    querylimit: k.OptionKind.Policy,
-    rowstore: k.OptionKind.Policy,
-    streamingingestion: k.OptionKind.Policy,
-    restricted_view_access: k.OptionKind.Policy,
-    sharding: k.OptionKind.Policy,
-    'restricted-viewers': k.OptionKind.Policy,
-    attach: k.OptionKind.Command,
-    purge: k.OptionKind.Command
-  };
   doRangeFormat(document, range) {
     if (!document) {
       return Promise.resolve([]);
@@ -589,44 +557,31 @@ class KustoLanguageService {
       return ls.Diagnostic.create(range, diag.Message, severity, diag.Code);
     });
   }
-
-  /**
-   * Colorize one or more kusto blocks (a.k.a commands), or just the entire document.
-   * Supports multi-cursor editing (colorizes blocks on multiple changes).
-   * @param document The document to colorize
-   * @param changeIntervals an array containing 0 or more changed intervals. if the array is empty - just colorize the entire row.
-   * if the array contains a single change - just color the kusto blocks that wraps this change. If multiple changes are provided,
-   * colorize all blocks that intersect these changes.
-   * The code will try to only parse once if this is the same command.
-   */
-  doColorization(document, changeIntervals) {
-    if (!document || !this._languageSettings.useSemanticColorization) {
-      return Promise.resolve([]);
-    }
-
-    // V2 intellisense
-    const script = this.parseDocumentV2(document);
-    if (changeIntervals.length > 0) {
-      const blocks = this.toArray(script.Blocks);
-      const affectedBlocks = this.getAffectedBlocks(blocks, changeIntervals);
-      const result = affectedBlocks.map(block => ({
-        classifications: toClassifiedRange(this.toArray(block.Service.GetClassifications(block.Start, block.End).Classifications)),
-        absoluteStart: block.Start,
-        absoluteEnd: block.End
-      }));
-      return Promise.resolve(result);
-    }
-
-    // Entire document requested
-    const blocks = this.toArray(script.Blocks);
-    const classifications = blocks.map(block => {
-      return this.toArray(block.Service.GetClassifications(block.Start, block.Length).Classifications);
-    }).reduce((prev, curr) => prev.concat(curr), []);
-    return Promise.resolve([{
-      classifications: toClassifiedRange(classifications),
-      absoluteStart: 0,
-      absoluteEnd: document.getText().length
-    }]);
+  async getClassifications(document) {
+    const codeScript = this.parseDocumentV2(document);
+    const codeBlocks = this.toArray(codeScript.Blocks);
+    const classificationRanges = codeBlocks.map(block => {
+      const {
+        Classifications
+      } = block.Service.GetClassifications(block.Start, block.Length);
+      return this.toArray(Classifications);
+    });
+    return classificationRanges.flatMap(ranges => {
+      return ranges.map(range => {
+        const {
+          line,
+          character
+        } = document.positionAt(range.Start);
+        const length = range.Length;
+        const kind = range.Kind;
+        return {
+          line,
+          character,
+          length,
+          kind
+        };
+      });
+    });
   }
   getAffectedBlocks(blocks, changeIntervals) {
     return blocks.filter(block =>
@@ -1264,15 +1219,15 @@ class KustoLanguageService {
    * Here it gets converted to the bridge.Net schema
    * @param schema Language Service schema
    */
-  static convertToKustoJsSchema(schema) {
-    switch (schema.clusterType) {
+  static convertToKustoJsSchema(schema$1) {
+    switch (schema$1.clusterType) {
       case 'Engine':
-        const currentDatabaseName = schema.database ? schema.database.name : undefined;
+        const currentDatabaseName = schema$1.database ? schema$1.database.name : undefined;
         const kCluster = new k.KustoIntelliSenseClusterEntity();
         let kDatabaseInContext = undefined;
-        kCluster.ConnectionString = schema.cluster.connectionString;
+        kCluster.ConnectionString = schema$1.cluster.connectionString;
         const databases = [];
-        schema.cluster.databases.forEach(database => {
+        schema$1.cluster.databases.forEach(database => {
           const kDatabase = new k.KustoIntelliSenseDatabaseEntity();
           kDatabase.Name = database.name;
           const tables = [];
@@ -1305,17 +1260,17 @@ class KustoLanguageService {
         const kSchema = new k.KustoIntelliSenseQuerySchema(kCluster, kDatabaseInContext);
         return kSchema;
       case 'ClusterManager':
-        const accounts = schema.accounts.map(account => {
+        const accounts = schema$1.accounts.map(account => {
           const kAccount = new k.KustoIntelliSenseAccountEntity();
           kAccount.Name = account;
           return kAccount;
         });
-        const services = schema.services.map(service => {
+        const services = schema$1.services.map(service => {
           const kService = new k.KustoIntelliSenseServiceEntity();
           kService.Name = service;
           return kService;
         });
-        const connectionString = schema.connectionString;
+        const connectionString = schema$1.connectionString;
         const result = {
           accounts,
           services,
@@ -1325,7 +1280,7 @@ class KustoLanguageService {
       case 'DataManagement':
         return undefined;
       default:
-        return assertNever(schema);
+        return assertNever(schema$1);
     }
   }
 
@@ -1533,8 +1488,7 @@ class KustoLanguageService {
     return command;
   }
   getCurrentCommandV2(script, offset) {
-    let block = script.GetBlockAtPosition(offset);
-    return block;
+    return script.GetBlockAtPosition(offset);
   }
   getTextToInsert(rule, option) {
     const beforeApplyInfo = rule.GetBeforeApplyInfo(option.Value);
@@ -1757,7 +1711,6 @@ class KustoLanguageService {
 }
 let languageService = new KustoLanguageService(KustoLanguageService.dummySchema, {
   includeControlCommands: true,
-  useSemanticColorization: true,
   completionOptions: {
     includeExtendedSyntax: false
   }
@@ -1777,17 +1730,12 @@ function getKustoLanguageService() {
  */
 
 class KustoWorkerImpl {
-  // --- model sync -----------------------
-
   constructor(ctx, createData) {
     this._ctx = ctx;
     this._languageSettings = createData.languageSettings;
     this._languageService = getKustoLanguageService();
     this._languageService.configure(this._languageSettings);
   }
-
-  // --- language service host ---------------
-
   setSchema(schema) {
     return this._languageService.setSchema(schema);
   }
@@ -1972,12 +1920,9 @@ class KustoWorkerImpl {
     const formatted = this._languageService.doCurrentCommandFormat(document, caretPosition);
     return formatted;
   }
-
-  // Colorize document. if offsets provided, will only colorize commands at these offsets. otherwise - will color the entire document.
-  doColorization(uri, colorizationIntervals) {
+  getClassifications(uri) {
     const document = this._getTextDocument(uri);
-    const colorizationInfo = this._languageService.doColorization(document, colorizationIntervals);
-    return colorizationInfo;
+    return this._languageService.getClassifications(document);
   }
   getClientDirective(text) {
     return this._languageService.getClientDirective(text);

package/release/esm/kustoMode.js

@@ -47,8 +47,10 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 import { WorkerManager } from './workerManager';
-import { KustoLanguageDefinition } from './languageServiceManager/kustoMonarchLanguageDefinition';
 import * as languageFeatures from './languageFeatures';
+import { SemanticTokensProvider } from './syntaxHighlighting/SemanticTokensProvider';
+import { kustoLanguageDefinition } from './syntaxHighlighting/kustoMonarchLanguageDefinition';
+import { LANGUAGE_ID } from './globals';
 var kustoWorker;
 var resolveWorker;
 var rejectWorker;
@@ -65,7 +67,6 @@ export function setupMode(defaults, monacoInstance) {
     var onSchemaChange = new monaco.Emitter();
     // TODO: when should we dispose of these? seems like monaco-css and monaco-typescript don't dispose of these.
     var disposables = [];
-    var monarchTokensProvider;
     var client = new WorkerManager(monacoInstance, defaults);
     disposables.push(client);
     var workerAccessor = function (first) {
@@ -107,37 +108,22 @@ export function setupMode(defaults, monacoInstance) {
                 });
             } })); });
     };
-    var language = 'kusto';
-    disposables.push(monacoInstance.languages.registerCompletionItemProvider(language, new languageFeatures.CompletionAdapter(workerAccessor, defaults.languageSettings)));
-    // Monaco tokenization runs in main thread so we're using a quick schema-unaware tokenization.
-    // a web worker will run semantic colorization in the background (ColorizationAdapter).
-    if (defaults.languageSettings.useTokenColorization) {
-        monarchTokensProvider = monacoInstance.languages.setMonarchTokensProvider(language, KustoLanguageDefinition);
-    }
-    // listen to configuration changes and if we're switching from semantic to monarch colorization, do the switch.
-    defaults.onDidChange(function (e) {
-        if (!e.languageSettings.useTokenColorization && monarchTokensProvider !== undefined) {
-            monarchTokensProvider.dispose();
-            monarchTokensProvider = undefined;
-        }
-        if (e.languageSettings.useTokenColorization && monarchTokensProvider == undefined) {
-            monarchTokensProvider = monacoInstance.languages.setMonarchTokensProvider(language, KustoLanguageDefinition);
-        }
-    });
-    disposables.push(new languageFeatures.DiagnosticsAdapter(monacoInstance, language, workerAccessor, defaults, onSchemaChange.event));
-    disposables.push(new languageFeatures.ColorizationAdapter(monacoInstance, language, workerAccessor, defaults, onSchemaChange.event));
-    disposables.push(monacoInstance.languages.registerDocumentRangeFormattingEditProvider(language, new languageFeatures.FormatAdapter(workerAccessor)));
-    disposables.push(monacoInstance.languages.registerFoldingRangeProvider(language, new languageFeatures.FoldingAdapter(workerAccessor)));
-    disposables.push(monacoInstance.languages.registerDefinitionProvider(language, new languageFeatures.DefinitionAdapter(workerAccessor)));
-    disposables.push(monacoInstance.languages.registerRenameProvider(language, new languageFeatures.RenameAdapter(workerAccessor)));
-    disposables.push(monacoInstance.languages.registerReferenceProvider(language, new languageFeatures.ReferenceAdapter(workerAccessor)));
+    disposables.push(monacoInstance.languages.registerCompletionItemProvider(LANGUAGE_ID, new languageFeatures.CompletionAdapter(workerAccessor, defaults.languageSettings)));
+    setMonarchTokensProvider(monacoInstance, disposables);
+    registerDocumentSemanticTokensProvider(workerAccessor, monacoInstance);
+    disposables.push(new languageFeatures.DiagnosticsAdapter(monacoInstance, LANGUAGE_ID, workerAccessor, defaults, onSchemaChange.event));
+    disposables.push(monacoInstance.languages.registerDocumentRangeFormattingEditProvider(LANGUAGE_ID, new languageFeatures.FormatAdapter(workerAccessor)));
+    disposables.push(monacoInstance.languages.registerFoldingRangeProvider(LANGUAGE_ID, new languageFeatures.FoldingAdapter(workerAccessor)));
+    disposables.push(monacoInstance.languages.registerDefinitionProvider(LANGUAGE_ID, new languageFeatures.DefinitionAdapter(workerAccessor)));
+    disposables.push(monacoInstance.languages.registerRenameProvider(LANGUAGE_ID, new languageFeatures.RenameAdapter(workerAccessor)));
+    disposables.push(monacoInstance.languages.registerReferenceProvider(LANGUAGE_ID, new languageFeatures.ReferenceAdapter(workerAccessor)));
     if (defaults.languageSettings.enableHover) {
-        disposables.push(monacoInstance.languages.registerHoverProvider(language, new languageFeatures.HoverAdapter(workerAccessor)));
+        disposables.push(monacoInstance.languages.registerHoverProvider(LANGUAGE_ID, new languageFeatures.HoverAdapter(workerAccessor)));
     }
-    monacoInstance.languages.registerDocumentFormattingEditProvider(language, new languageFeatures.DocumentFormatAdapter(workerAccessor));
+    monacoInstance.languages.registerDocumentFormattingEditProvider(LANGUAGE_ID, new languageFeatures.DocumentFormatAdapter(workerAccessor));
     kustoWorker = workerAccessor;
     resolveWorker(workerAccessor);
-    monacoInstance.languages.setLanguageConfiguration(language, {
+    monacoInstance.languages.setLanguageConfiguration(LANGUAGE_ID, {
         folding: {
             offSide: false,
             markers: { start: /^\s*[\r\n]/gm, end: /^\s*[\r\n]/gm },
@@ -159,3 +145,27 @@ export function setupMode(defaults, monacoInstance) {
 export function getKustoWorker() {
     return workerPromise.then(function () { return kustoWorker; });
 }
+// This function sets the Monarch token provider,
+// enabling fast syntax highlighting before the language service is called for semantic coloring.
+function setMonarchTokensProvider(monacoInstance, disposables) {
+    var monarchTokensProvider = monacoInstance.languages.setMonarchTokensProvider(LANGUAGE_ID, kustoLanguageDefinition);
+    disposables.push(monarchTokensProvider);
+}
+// This function registers a semantic token provider that utilizes the language service
+// for more context-relevant syntax highlighting.
+function registerDocumentSemanticTokensProvider(workerAccessor, monacoInstance) {
+    var _this = this;
+    var classificationsGetter = function (resource) { return __awaiter(_this, void 0, void 0, function () {
+        var worker;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, workerAccessor(resource)];
+                case 1:
+                    worker = _a.sent();
+                    return [2 /*return*/, worker.getClassifications(resource.toString())];
+            }
+        });
+    }); };
+    var semanticTokenProvider = new SemanticTokensProvider(classificationsGetter);
+    monacoInstance.languages.registerDocumentSemanticTokensProvider(LANGUAGE_ID, semanticTokenProvider);
+}

package/release/esm/kustoWorker.d.ts

@@ -4,9 +4,9 @@ import type { IRange } from 'monaco-editor/esm/vs/editor/editor.api';
 import * as kustoService from './languageServiceManager/kustoLanguageService';
 import type { LanguageSettings } from './languageServiceManager/settings';
 import { Schema, showSchema, ScalarParameter, Database, TabularParameter } from './languageServiceManager/schema';
-import type { ColorizationRange } from './languageServiceManager/kustoLanguageService';
 import type { RenderInfo } from './languageServiceManager/renderInfo';
 import type { ClusterReference, DatabaseReference } from './types';
+import { ClassificationRange } from './syntaxHighlighting/types';
 export type InterfaceFor<C> = {
     [Member in keyof C]: C[Member];
 };
@@ -75,10 +75,7 @@ export declare class KustoWorkerImpl {
     doFolding(uri: string): Promise<ls.FoldingRange[]>;
     doDocumentFormat(uri: string): Promise<ls.TextEdit[]>;
     doCurrentCommandFormat(uri: string, caretPosition: ls.Position): Promise<ls.TextEdit[]>;
-    doColorization(uri: string, colorizationIntervals: {
-        start: number;
-        end: number;
-    }[]): Promise<ColorizationRange[]>;
+    getClassifications(uri: string): Promise<ClassificationRange[]>;
     getClientDirective(text: string): Promise<{
         isClientDirective: boolean;
         directiveWithoutLeadingComments: string;

package/release/esm/kustoWorker.js

@@ -7,7 +7,6 @@ var KustoWorkerImpl = /** @class */ (function () {
         this._languageService = kustoService.getKustoLanguageService();
         this._languageService.configure(this._languageSettings);
     }
-    // --- language service host ---------------
     KustoWorkerImpl.prototype.setSchema = function (schema) {
         return this._languageService.setSchema(schema);
     };
@@ -182,11 +181,9 @@ var KustoWorkerImpl = /** @class */ (function () {
         var formatted = this._languageService.doCurrentCommandFormat(document, caretPosition);
         return formatted;
     };
-    // Colorize document. if offsets provided, will only colorize commands at these offsets. otherwise - will color the entire document.
-    KustoWorkerImpl.prototype.doColorization = function (uri, colorizationIntervals) {
+    KustoWorkerImpl.prototype.getClassifications = function (uri) {
         var document = this._getTextDocument(uri);
-        var colorizationInfo = this._languageService.doColorization(document, colorizationIntervals);
-        return colorizationInfo;
+        return this._languageService.getClassifications(document);
     };
     KustoWorkerImpl.prototype.getClientDirective = function (text) {
         return this._languageService.getClientDirective(text);

package/release/esm/languageFeatures.d.ts

@@ -19,19 +19,6 @@ export declare class DiagnosticsAdapter {
     dispose(): void;
     private _doValidate;
 }
-export declare class ColorizationAdapter {
-    private _monacoInstance;
-    private _languageId;
-    private _worker;
-    private _disposables;
-    private _contentListener;
-    private _configurationListener;
-    private _schemaListener;
-    private decorations;
-    constructor(_monacoInstance: typeof globalThis.monaco, _languageId: string, _worker: AugmentedWorkerAccessor, defaults: LanguageServiceDefaults, onSchemaChange: monaco.IEvent<Schema>);
-    dispose(): void;
-    private _doColorization;
-}
 export declare class CompletionAdapter implements monaco.languages.CompletionItemProvider {
     private readonly languageSettings;
     private completionCacheManager;