@kusto/monaco-kusto 11.4.0 → 12.0.1

package/release/esm/kustoMode.d.ts

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

package/release/esm/kustoMode.js

@@ -47,115 +47,105 @@ 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';
-var kustoWorker;
-var resolveWorker;
-var rejectWorker;
-var workerPromise = new Promise(function (resolve, reject) {
-    resolveWorker = resolve;
-    rejectWorker = reject;
-});
-/**
- * Called when Kusto language is first needed (a model has the language set)
- * @param defaults
- */
+import { LANGUAGE_ID } from './globals';
+import { semanticTokensProviderRegistrarCreator } from './syntaxHighlighting/semanticTokensProviderRegistrar';
+import { kustoLanguageDefinition } from './syntaxHighlighting/kustoMonarchLanguageDefinition';
+var workerAccessor;
 export function setupMode(defaults, monacoInstance) {
-    var _this = this;
-    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) {
-        var more = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            more[_i - 1] = arguments[_i];
-        }
-        var augmentedSetSchema = function (schema, worker) { return __awaiter(_this, void 0, void 0, function () {
-            var workerPromise;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        workerPromise = worker.setSchema(schema);
-                        return [4 /*yield*/, workerPromise.then(function () {
-                                onSchemaChange.fire(schema);
-                            })];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        }); };
-        var worker = client.getLanguageServiceWorker.apply(client, [first].concat(more));
-        return worker.then(function (worker) { return (__assign(__assign({}, worker), { setSchema: function (schema) { return augmentedSetSchema(schema, worker); }, setSchemaFromShowSchema: function (schema, connection, database, globalScalarParameters, globalTabularParameters) {
-                return __awaiter(this, void 0, void 0, function () {
-                    return __generator(this, function (_a) {
-                        switch (_a.label) {
-                            case 0: return [4 /*yield*/, worker.normalizeSchema(schema, connection, database).then(function (schema) {
-                                    if (globalScalarParameters || globalTabularParameters) {
-                                        schema = __assign(__assign({}, schema), { globalScalarParameters: globalScalarParameters, globalTabularParameters: globalTabularParameters });
+    return __awaiter(this, void 0, void 0, function () {
+        var onSchemaChange, client, semanticTokensProviderRegistrar, completionAdapter, documentRangeFormattingAdapter, foldingRangeAdapter, definitionProvider, referenceProvider, hoverAdapter, documentFormattingAdapter, languageConfiguration;
+        var _this = this;
+        return __generator(this, function (_a) {
+            onSchemaChange = new monaco.Emitter();
+            client = new WorkerManager(monacoInstance, defaults);
+            semanticTokensProviderRegistrar = semanticTokensProviderRegistrarCreator();
+            workerAccessor = function (uri) { return __awaiter(_this, void 0, void 0, function () {
+                var worker, augmentedSetSchema, setSchemaFromShowSchema;
+                var _this = this;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, client.getLanguageServiceWorker(uri)];
+                        case 1:
+                            worker = _a.sent();
+                            augmentedSetSchema = function (schema) { return __awaiter(_this, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, worker.setSchema(schema)];
+                                        case 1:
+                                            _a.sent();
+                                            onSchemaChange.fire(schema);
+                                            semanticTokensProviderRegistrar(monacoInstance, worker);
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); };
+                            setSchemaFromShowSchema = function (schema, clusterConnectionString, databaseInContextName, globalScalarParameters, globalTabularParameters) { return __awaiter(_this, void 0, void 0, function () {
+                                var normalizedSchema;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, worker.normalizeSchema(schema, clusterConnectionString, databaseInContextName)];
+                                        case 1:
+                                            normalizedSchema = _a.sent();
+                                            normalizedSchema.globalScalarParameters = globalScalarParameters;
+                                            normalizedSchema.globalTabularParameters = globalTabularParameters;
+                                            return [4 /*yield*/, augmentedSetSchema(normalizedSchema)];
+                                        case 2:
+                                            _a.sent();
+                                            return [2 /*return*/];
                                     }
-                                    augmentedSetSchema(schema, worker);
-                                })];
-                            case 1:
-                                _a.sent();
-                                return [2 /*return*/];
-                        }
-                    });
+                                });
+                            }); };
+                            return [2 /*return*/, __assign(__assign({}, worker), { setSchema: augmentedSetSchema, setSchemaFromShowSchema: setSchemaFromShowSchema })];
+                    }
                 });
-            } })); });
-    };
-    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)));
-    if (defaults.languageSettings.enableHover) {
-        disposables.push(monacoInstance.languages.registerHoverProvider(language, new languageFeatures.HoverAdapter(workerAccessor)));
-    }
-    monacoInstance.languages.registerDocumentFormattingEditProvider(language, new languageFeatures.DocumentFormatAdapter(workerAccessor));
-    kustoWorker = workerAccessor;
-    resolveWorker(workerAccessor);
-    monacoInstance.languages.setLanguageConfiguration(language, {
-        folding: {
-            offSide: false,
-            markers: { start: /^\s*[\r\n]/gm, end: /^\s*[\r\n]/gm },
-        },
-        comments: {
-            lineComment: '//',
-            blockComment: null,
-        },
-        autoClosingPairs: [
-            { open: '{', close: '}' },
-            { open: '[', close: ']' },
-            { open: '(', close: ')' },
-            { open: "'", close: "'", notIn: ['string', 'comment'] },
-            { open: '"', close: '"', notIn: ['string', 'comment'] },
-        ],
+            }); };
+            monacoInstance.languages.setMonarchTokensProvider(LANGUAGE_ID, kustoLanguageDefinition);
+            completionAdapter = new languageFeatures.CompletionAdapter(workerAccessor, defaults.languageSettings);
+            monacoInstance.languages.registerCompletionItemProvider(LANGUAGE_ID, completionAdapter);
+            // this constructor has side effects and therefore doesn't need to be passed anywhere
+            new languageFeatures.DiagnosticsAdapter(monacoInstance, LANGUAGE_ID, workerAccessor, defaults, onSchemaChange.event);
+            documentRangeFormattingAdapter = new languageFeatures.FormatAdapter(workerAccessor);
+            monacoInstance.languages.registerDocumentRangeFormattingEditProvider(LANGUAGE_ID, documentRangeFormattingAdapter);
+            foldingRangeAdapter = new languageFeatures.FoldingAdapter(workerAccessor);
+            monacoInstance.languages.registerFoldingRangeProvider(LANGUAGE_ID, foldingRangeAdapter);
+            definitionProvider = new languageFeatures.DefinitionAdapter(workerAccessor);
+            monacoInstance.languages.registerDefinitionProvider(LANGUAGE_ID, definitionProvider);
+            monacoInstance.languages.registerRenameProvider(LANGUAGE_ID, new languageFeatures.RenameAdapter(workerAccessor));
+            referenceProvider = new languageFeatures.ReferenceAdapter(workerAccessor);
+            monacoInstance.languages.registerReferenceProvider(LANGUAGE_ID, referenceProvider);
+            if (defaults.languageSettings.enableHover) {
+                hoverAdapter = new languageFeatures.HoverAdapter(workerAccessor);
+                monacoInstance.languages.registerHoverProvider(LANGUAGE_ID, hoverAdapter);
+            }
+            documentFormattingAdapter = new languageFeatures.DocumentFormatAdapter(workerAccessor);
+            monacoInstance.languages.registerDocumentFormattingEditProvider(LANGUAGE_ID, documentFormattingAdapter);
+            languageConfiguration = {
+                folding: {
+                    offSide: false,
+                    markers: { start: /^\s*[\r\n]/gm, end: /^\s*[\r\n]/gm },
+                },
+                comments: {
+                    lineComment: '//',
+                    blockComment: null,
+                },
+                autoClosingPairs: [
+                    { open: '{', close: '}' },
+                    { open: '[', close: ']' },
+                    { open: '(', close: ')' },
+                    { open: "'", close: "'", notIn: ['string', 'comment'] },
+                    { open: '"', close: '"', notIn: ['string', 'comment'] },
+                ],
+            };
+            monacoInstance.languages.setLanguageConfiguration(LANGUAGE_ID, languageConfiguration);
+            return [2 /*return*/, workerAccessor];
+        });
     });
-    return kustoWorker;
 }
 export function getKustoWorker() {
-    return workerPromise.then(function () { return kustoWorker; });
+    return __awaiter(this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            return [2 /*return*/, workerAccessor];
+        });
+    });
 }

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

@@ -13,25 +13,12 @@ export declare class DiagnosticsAdapter {
     private _schemaListener;
     private _cursorListener;
     private _debouncedValidations;
-    constructor(_monacoInstance: typeof globalThis.monaco, _languageId: string, _worker: AugmentedWorkerAccessor, defaults: LanguageServiceDefaults, onSchemaChange: monaco.IEvent<Schema>);
+    constructor(_monacoInstance: typeof monaco, _languageId: string, _worker: AugmentedWorkerAccessor, defaults: LanguageServiceDefaults, onSchemaChange: monaco.IEvent<Schema>);
     private getMonacoCodeActions;
     private getOrCreateDebouncedValidation;
     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;

package/release/esm/languageFeatures.js

@@ -362,305 +362,6 @@ function toDiagnostics(resource, diag) {
         source: diag.source,
     };
 }
-/**
- * Copy of Kusto.Language.Editor.ClassificationKind we don't have to depend on it in this file
- */
-var ClassificationKind = {
-    PlainText: 0,
-    Comment: 1,
-    Punctuation: 2,
-    Directive: 3,
-    Literal: 4,
-    StringLiteral: 5,
-    Type: 6,
-    Column: 7,
-    Table: 8,
-    Database: 9,
-    Function: 10,
-    Parameter: 11,
-    Variable: 12,
-    Identifier: 13,
-    ClientParameter: 14,
-    QueryParameter: 15,
-    ScalarOperator: 16,
-    MathOperator: 17,
-    QueryOperator: 18,
-    Command: 19,
-    Keyword: 20,
-    MaterializedView: 21,
-    SchemaMember: 22,
-    SignatureParameter: 23,
-    Option: 24,
-};
-var ClassificationKindNames = {};
-for (var _i = 0, _a = Object.entries(ClassificationKind); _i < _a.length; _i++) {
-    var _b = _a[_i], key = _b[0], value = _b[1];
-    ClassificationKindNames[value] = key;
-}
-// commented here is the color definitions are were defined by v1 intellisense terminology:
-// { token: 'comment', foreground: '008000' }, // CommentToken Green
-// { token: 'variable.predefined', foreground: '800080' }, // CalculatedColumnToken Purple
-// { token: 'function', foreground: '0000FF' }, // FunctionNameToken Blue
-// { token: 'operator.sql', foreground: 'FF4500' }, // OperatorToken OrangeRed (now changed to darker color CC3700 because wasn't accessible)
-// { token: 'string', foreground: 'B22222' }, // StringLiteralToken Firebrick
-// { token: 'operator.scss', foreground: '0000FF' }, // SubOperatorToken Blue
-// { token: 'variable', foreground: 'C71585' }, // TableColumnToken MediumVioletRed
-// { token: 'variable.parameter', foreground: '9932CC' }, // TableToken DarkOrchid
-// { token: '', foreground: '000000' }, // UnknownToken, PlainTextToken  Black
-// { token: 'type', foreground: '0000FF' }, // DataTypeToken Blue
-// { token: 'tag', foreground: '0000FF' }, // ControlCommandToken Blue
-// { token: 'annotation', foreground: '2B91AF' }, // QueryParametersToken FF2B91AF
-// { token: 'keyword', foreground: '0000FF' }, // CslCommandToken, PluginToken Blue
-// { token: 'number', foreground: '191970' }, // LetVariablesToken MidnightBlue
-// { token: 'annotation', foreground: '9400D3' }, // ClientDirectiveToken DarkViolet
-// { token: 'invalid', background: 'cd3131' },
-var classificationToColorLight = {
-    Column: 'C71585',
-    Comment: '008000',
-    Database: 'C71585',
-    Function: '0000FF',
-    Identifier: '000000',
-    Keyword: '0000FF',
-    Literal: 'B22222',
-    ScalarOperator: '0000FF',
-    MaterializedView: 'C71585',
-    MathOperator: '000000',
-    Command: '0000FF',
-    Parameter: '2B91AF',
-    PlainText: '000000',
-    Punctuation: '000000',
-    QueryOperator: 'CC3700',
-    QueryParameter: 'CC3700',
-    StringLiteral: 'B22222',
-    Table: 'C71585',
-    Type: '0000FF',
-    Variable: '191970',
-    Directive: '9400D3',
-    ClientParameter: 'b5cea8',
-    SchemaMember: 'C71585',
-    SignatureParameter: '2B91AF',
-    Option: '000000',
-};
-var classificationToColorDark = {
-    Column: '4ec9b0',
-    Comment: '6A9B34',
-    Database: 'c586c0',
-    Function: 'dcdcaa',
-    Identifier: 'd4d4d4',
-    Keyword: '569cd6',
-    Literal: 'ce9178',
-    ScalarOperator: '569cd6',
-    MaterializedView: 'c586c0',
-    MathOperator: 'd4d4d4',
-    Command: 'd4d4d4',
-    Parameter: '2B91AF',
-    PlainText: 'd4d4d4',
-    Punctuation: 'd4d4d4',
-    QueryOperator: '9cdcfe',
-    QueryParameter: '9cdcfe',
-    StringLiteral: 'ce9178',
-    Table: 'c586c0',
-    Type: '569cd6',
-    Variable: 'd7ba7d',
-    Directive: 'b5cea8',
-    ClientParameter: 'b5cea8',
-    SchemaMember: '4ec9b0',
-    SignatureParameter: '2B91AF',
-    Option: 'd4d4d4',
-};
-var ColorizationAdapter = /** @class */ (function () {
-    function ColorizationAdapter(_monacoInstance, _languageId, _worker, defaults, onSchemaChange) {
-        var _this = this;
-        this._monacoInstance = _monacoInstance;
-        this._languageId = _languageId;
-        this._worker = _worker;
-        this._disposables = [];
-        this._contentListener = Object.create(null);
-        this._configurationListener = Object.create(null);
-        this._schemaListener = Object.create(null);
-        this.decorations = [];
-        injectCss();
-        var onModelAdd = function (model) {
-            var languageId = model.getLanguageId();
-            if (languageId !== _this._languageId) {
-                return;
-            }
-            var debouncedColorization = debounce(function (intervals) { return _this._doColorization(model, languageId, intervals); }, 500);
-            var handle;
-            _this._contentListener[model.uri.toString()] = model.onDidChangeContent(function (e) {
-                // Changes are represented as a range in doc before change, plus the text that it was replaced with.
-                // We are interested in the range _after_ the change (since that's what we need to colorize).
-                // following logic calculates that.
-                var intervalsToColorize = changeEventToIntervals(e);
-                debouncedColorization(intervalsToColorize);
-            });
-            _this._configurationListener[model.uri.toString()] = defaults.onDidChange(function () {
-                self.setTimeout(function () { return _this._doColorization(model, languageId, []); }, 0);
-            });
-            _this._schemaListener[model.uri.toString()] = onSchemaChange(function () {
-                self.setTimeout(function () { return _this._doColorization(model, languageId, []); }, 0);
-            });
-        };
-        var onModelRemoved = function (model) {
-            model.deltaDecorations(_this.decorations, []);
-            var uriStr = model.uri.toString();
-            var contentListener = _this._contentListener[uriStr];
-            if (contentListener) {
-                contentListener.dispose();
-                delete _this._contentListener[uriStr];
-            }
-            var configurationListener = _this._configurationListener[uriStr];
-            if (configurationListener) {
-                configurationListener.dispose();
-                delete _this._configurationListener[uriStr];
-            }
-            var schemaListener = _this._configurationListener[uriStr];
-            if (schemaListener) {
-                schemaListener.dispose();
-                delete _this._schemaListener[uriStr];
-            }
-        };
-        this._disposables.push(this._monacoInstance.editor.onDidCreateModel(onModelAdd));
-        this._disposables.push(this._monacoInstance.editor.onWillDisposeModel(onModelRemoved));
-        this._disposables.push(this._monacoInstance.editor.onDidChangeModelLanguage(function (event) {
-            onModelRemoved(event.model);
-            onModelAdd(event.model);
-        }));
-        this._disposables.push({
-            dispose: function () {
-                for (var key in _this._contentListener) {
-                    _this._contentListener[key].dispose();
-                }
-            },
-        });
-        this._monacoInstance.editor.getModels().forEach(onModelAdd);
-    }
-    ColorizationAdapter.prototype.dispose = function () {
-        this._disposables.forEach(function (d) { return d && d.dispose(); });
-        this._disposables = [];
-    };
-    ColorizationAdapter.prototype._doColorization = function (model, languageId, intervals) {
-        var _this = this;
-        if (model.isDisposed()) {
-            return;
-        }
-        var resource = model.uri;
-        var versionNumberBeforeColorization = model.getVersionId();
-        this._worker(resource)
-            .then(function (worker) {
-            if (model.isDisposed()) {
-                return;
-            }
-            return worker.doColorization(resource.toString(), intervals);
-        })
-            .then(function (colorizationRanges) {
-            if (model.isDisposed()) {
-                return;
-            }
-            var newModel = _this._monacoInstance.editor.getModel(model.uri);
-            var versionId = newModel.getVersionId();
-            // don't colorize an older version of the document.
-            if (versionId !== versionNumberBeforeColorization) {
-                return;
-            }
-            var decorationRanges = colorizationRanges.map(function (colorizationRange) {
-                var decorations = colorizationRange.classifications
-                    .map(function (classification) { return toDecoration(model, classification); })
-                    // The following line will prevent things that aren't going to be colorized anyway to get a CSS class.
-                    // This will prevent the case where the non-semantic colorizer already figured out that a keyword needs
-                    // to be colorized, but the outdated semantic colorizer still thinks it's a plain text and wants it colored
-                    // in black.
-                    .filter(function (d) {
-                    return d.options.inlineClassName !== 'PlainText' && d.options.inlineClassName != 'Identifier';
-                });
-                var firstImpactedLine = model.getPositionAt(colorizationRange.absoluteStart).lineNumber;
-                var endPosition = model.getPositionAt(colorizationRange.absoluteEnd);
-                // A token that ends in the first column of the next line is not considered to be part of that line.
-                var lastImpactedLine = endPosition.column == 1 && endPosition.lineNumber > 1
-                    ? endPosition.lineNumber - 1
-                    : endPosition.lineNumber;
-                return { decorations: decorations, firstImpactedLine: firstImpactedLine, lastImpactedLine: lastImpactedLine };
-            });
-            // Compute the previous decorations we want to replace with the new ones.
-            var oldDecorations = decorationRanges
-                .map(function (range) {
-                return model
-                    .getLinesDecorations(range.firstImpactedLine, range.lastImpactedLine)
-                    .filter(function (d) { return classificationToColorLight[d.options.inlineClassName]; }) // Don't delete any other decorations
-                    .map(function (d) { return d.id; });
-            })
-                .reduce(function (prev, curr) { return prev.concat(curr); }, []);
-            // Flatten decoration groups to an array of decorations
-            var newDecorations = decorationRanges.reduce(function (prev, next) { return prev.concat(next.decorations); }, []);
-            if (model && model.getLanguageId() === languageId) {
-                _this.decorations = model.deltaDecorations(oldDecorations, newDecorations);
-            }
-        })
-            .catch(function (err) {
-            // Hack to avoid crashing calling code, while still logging the
-            // error. Might be better to just let the error propagate
-            // normally, but that would require more investigation.
-            setTimeout(function () {
-                throw err;
-            }, 0);
-        });
-    };
-    return ColorizationAdapter;
-}());
-export { ColorizationAdapter };
-/**
- * Generates a mapping between ClassificationKind and color.
- */
-function getClassificationColorTriplets() {
-    var result = Object.keys(ClassificationKind).map(function (key) { return ({
-        classification: key,
-        colorLight: classificationToColorLight[key],
-        colorDark: classificationToColorDark[key],
-    }); });
-    return result;
-}
-/**
- * Returns a string which is a css describing all tokens and their colors.
- * looks a little bit something like this:
- *
- * .vs .Literal {color: '#000000';} .vs-dark .Literal {color: '#FFFFFF';}
- * .vs .Comment {color: '#111111';} .vs-dark .Comment {color: '#EEEEEE';}
- */
-function getCssForClassification() {
-    var classificationColorTriplets = getClassificationColorTriplets();
-    var cssInnerHtml = classificationColorTriplets
-        .map(function (pair) {
-        return ".vs .".concat(pair.classification, " {color: #").concat(pair.colorLight, ";} .vs-dark .").concat(pair.classification, " {color: #").concat(pair.colorDark, ";}");
-    })
-        .join('\n');
-    return cssInnerHtml;
-}
-/**
- * Inject a CSS sheet to the head of document, coloring kusto elements by classification.
- * TODO: make idempotent
- */
-function injectCss() {
-    var container = document.getElementsByTagName('head')[0];
-    var style = document.createElement('style');
-    style.type = 'text/css';
-    style.media = 'screen';
-    container.appendChild(style);
-    ClassificationKind;
-    style.innerHTML = getCssForClassification();
-}
-function toDecoration(model, classification) {
-    var start = model.getPositionAt(classification.start);
-    var end = model.getPositionAt(classification.start + classification.length);
-    var range = new monaco.Range(start.lineNumber, start.column, end.lineNumber, end.column);
-    var inlineClassName = ClassificationKindNames[classification.kind];
-    return {
-        range: range,
-        options: {
-            inlineClassName: inlineClassName,
-            stickiness: monaco.editor.TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges,
-        },
-    };
-}
 // --- completion ------
 function fromPosition(position) {
     if (!position) {

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

@@ -11,6 +11,7 @@ import k2 = Kusto.Language.Editor;
 import { Database } from './schema';
 import type { RenderInfo } from './renderInfo';
 import type { ClusterReference, DatabaseReference } from '../types';
+import { ClassificationRange } from '../syntaxHighlighting/types';
 export declare enum TokenKind {
     TableToken = 2,
     TableColumnToken = 4,
@@ -72,10 +73,7 @@ export interface LanguageService {
         end: number;
     }[], includeWarnings?: boolean, includeSuggestions?: boolean): Promise<ls.Diagnostic[]>;
     getResultActions(document: TextDocument, start: number, end: number): Promise<ResultAction[]>;
-    doColorization(document: TextDocument, intervals: {
-        start: number;
-        end: number;
-    }[]): Promise<ColorizationRange[]>;
+    getClassifications(document: TextDocument): Promise<ClassificationRange[]>;
     doRename(document: TextDocument, position: ls.Position, newName: string): Promise<ls.WorkspaceEdit | undefined>;
     doHover(document: TextDocument, position: ls.Position): Promise<ls.Hover | undefined>;
     setParameters(scalarParameters: readonly s.ScalarParameter[], tabularParameters: readonly s.TabularParameter[]): Promise<void>;