@kusto/monaco-kusto 11.3.0 → 12.0.0

package/release/esm/languageFeatures.js

@@ -47,7 +47,7 @@ import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 import * as ls from 'vscode-languageserver-types';
 import debounce from 'lodash-es/debounce';
 import { createCompletionCacheManager } from './completionCacheManager/completionCacheManager';
-import { createCompletionFilteredText } from './languageFeatures.utils';
+import { createCompletionFilteredText, getFocusedItem } from './languageFeatures.utils';
 var DiagnosticsAdapter = /** @class */ (function () {
     function DiagnosticsAdapter(_monacoInstance, _languageId, _worker, defaults, onSchemaChange) {
         var _this = this;
@@ -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) {
@@ -762,26 +463,28 @@ var CompletionAdapter = /** @class */ (function () {
         var wordInfo = model.getWordUntilPosition(position);
         var wordRange = new monaco.Range(position.lineNumber, wordInfo.startColumn, position.lineNumber, wordInfo.endColumn);
         var resource = model.uri;
-        var word = (_a = model === null || model === void 0 ? void 0 : model.getWordAtPosition(position)) === null || _a === void 0 ? void 0 : _a.word;
+        var userInput = (_a = model === null || model === void 0 ? void 0 : model.getWordAtPosition(position)) === null || _a === void 0 ? void 0 : _a.word;
         var onDidProvideCompletionItems = this.languageSettings.onDidProvideCompletionItems;
         return this.completionCacheManager
-            .getCompletionItems(word, resource, fromPosition(position))
+            .getCompletionItems(userInput, resource, fromPosition(position))
             .then(function (info) { return (onDidProvideCompletionItems ? onDidProvideCompletionItems(info) : info); })
             .then(function (info) {
             if (!info)
                 return;
-            var items = info.items.map(function (entry) {
+            var selectedItem = getFocusedItem(info.items, userInput);
+            var items = info.items.map(function (entry, index) {
                 var _a;
                 var item = {
                     label: entry.label,
                     insertText: entry.insertText,
                     sortText: entry.sortText,
-                    filterText: createCompletionFilteredText(word, entry),
+                    filterText: createCompletionFilteredText(userInput, entry),
                     // TODO: Is this cast safe?
                     documentation: _this.formatDocLink((_a = entry.documentation) === null || _a === void 0 ? void 0 : _a.value),
                     detail: entry.detail,
                     range: wordRange,
                     kind: toCompletionItemKind(entry.kind),
+                    preselect: selectedItem.filterText === entry.filterText,
                 };
                 if (entry.textEdit) {
                     // TODO: Where is the "range" property coming from?

package/release/esm/languageFeatures.utils.d.ts

@@ -1,2 +1,3 @@
 import * as ls from 'vscode-languageserver-types';
-export declare function createCompletionFilteredText(searchWord: string | undefined, completionItem: ls.CompletionItem): string;
+export declare function createCompletionFilteredText(userInput: string | undefined, completionItem: ls.CompletionItem): string;
+export declare function getFocusedItem(completionItems: ls.CompletionItem[], userInput: string): ls.CompletionItem;

package/release/esm/languageFeatures.utils.js

@@ -1,7 +1,15 @@
-export function createCompletionFilteredText(searchWord, completionItem) {
-    if (!searchWord)
+export function createCompletionFilteredText(userInput, completionItem) {
+    if (!userInput)
         return completionItem.filterText;
-    var containedInFilterText = completionItem.filterText.toLowerCase().includes(searchWord.toLowerCase());
-    var shouldPrependSearchWord = completionItem.data.forcePrecedence && containedInFilterText;
-    return shouldPrependSearchWord ? "".concat(searchWord).concat(completionItem.filterText) : completionItem.filterText;
+    var containedInFilterText = completionItem.filterText.toLowerCase().includes(userInput.toLowerCase());
+    if (!containedInFilterText)
+        return completionItem.filterText;
+    return "".concat(userInput).concat(completionItem.filterText);
+}
+export function getFocusedItem(completionItems, userInput) {
+    var firstCompletionItem = completionItems[0];
+    if (!userInput)
+        return firstCompletionItem;
+    var firstMatchingItem = completionItems.find(function (item) { var _a; return (_a = item.filterText) === null || _a === void 0 ? void 0 : _a.toLowerCase().startsWith(userInput.toLowerCase()); });
+    return firstMatchingItem !== null && firstMatchingItem !== void 0 ? firstMatchingItem : firstCompletionItem;
 }

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>;

package/release/esm/languageServiceManager/kustoLanguageService.js

@@ -9,6 +9,42 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 var __rest = (this && this.__rest) || function (s, e) {
     var t = {};
     for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
@@ -86,18 +122,6 @@ export var TokenKind;
     TokenKind[TokenKind["BracketRangeToken"] = 262144] = "BracketRangeToken";
     TokenKind[TokenKind["ClientDirectiveToken"] = 524288] = "ClientDirectiveToken";
 })(TokenKind || (TokenKind = {}));
-/**
- * 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(function (classification) { return ({
-        start: classification.Start,
-        end: classification.End,
-        length: classification.Length,
-        kind: classification.Kind,
-    }); });
-}
 var symbolKindToName = (_a = {},
     _a[sym.SymbolKind.Cluster] = 'Cluster',
     _a[sym.SymbolKind.Column] = 'Column',
@@ -182,22 +206,6 @@ var KustoLanguageService = /** @class */ (function () {
             '3Dchart': k2.CompletionKind.RenderChart,
             list: k2.CompletionKind.RenderChart,
         };
-        this.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,
-        };
         this._kustoKindtolsKind = (_b = {},
             _b[k.OptionKind.None] = ls.CompletionItemKind.Interface,
             _b[k.OptionKind.Operator] = ls.CompletionItemKind.Method,
@@ -421,7 +429,6 @@ var KustoLanguageService = /** @class */ (function () {
             lsItem.documentation = helpTopic
                 ? { value: _this.formatHelpTopic(helpTopic), kind: ls.MarkupKind.Markdown }
                 : undefined;
-            lsItem.data = { forcePrecedence: kItem.Kind === k2.CompletionKind.Column };
             return lsItem;
         });
         return Promise.resolve(ls.CompletionList.create(items));
@@ -676,46 +683,27 @@ var KustoLanguageService = /** @class */ (function () {
             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.
-     */
-    KustoLanguageService.prototype.doColorization = function (document, changeIntervals) {
-        var _this = this;
-        if (!document || !this._languageSettings.useSemanticColorization) {
-            return Promise.resolve([]);
-        }
-        // V2 intellisense
-        var script = this.parseDocumentV2(document);
-        if (changeIntervals.length > 0) {
-            var blocks_1 = this.toArray(script.Blocks);
-            var affectedBlocks = this.getAffectedBlocks(blocks_1, changeIntervals);
-            var result = affectedBlocks.map(function (block) { return ({
-                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
-        var blocks = this.toArray(script.Blocks);
-        var classifications = blocks
-            .map(function (block) {
-            return _this.toArray(block.Service.GetClassifications(block.Start, block.Length).Classifications);
-        })
-            .reduce(function (prev, curr) { return prev.concat(curr); }, []);
-        return Promise.resolve([
-            {
-                classifications: toClassifiedRange(classifications),
-                absoluteStart: 0,
-                absoluteEnd: document.getText().length,
-            },
-        ]);
+    KustoLanguageService.prototype.getClassifications = function (document) {
+        return __awaiter(this, void 0, void 0, function () {
+            var codeScript, codeBlocks, classificationRanges;
+            var _this = this;
+            return __generator(this, function (_a) {
+                codeScript = this.parseDocumentV2(document);
+                codeBlocks = this.toArray(codeScript.Blocks);
+                classificationRanges = codeBlocks.map(function (block) {
+                    var Classifications = block.Service.GetClassifications(block.Start, block.Length).Classifications;
+                    return _this.toArray(Classifications);
+                });
+                return [2 /*return*/, classificationRanges.flatMap(function (ranges) {
+                        return ranges.map(function (range) {
+                            var _a = document.positionAt(range.Start), line = _a.line, character = _a.character;
+                            var length = range.Length;
+                            var kind = range.Kind;
+                            return { line: line, character: character, length: length, kind: kind };
+                        });
+                    })];
+            });
+        });
     };
     KustoLanguageService.prototype.getAffectedBlocks = function (blocks, changeIntervals) {
         return blocks.filter(function (block) {
@@ -1613,8 +1601,7 @@ var KustoLanguageService = /** @class */ (function () {
         return command;
     };
     KustoLanguageService.prototype.getCurrentCommandV2 = function (script, offset) {
-        var block = script.GetBlockAtPosition(offset);
-        return block;
+        return script.GetBlockAtPosition(offset);
     };
     KustoLanguageService.prototype.getTextToInsert = function (rule, option) {
         var beforeApplyInfo = rule.GetBeforeApplyInfo(option.Value);
@@ -1745,7 +1732,6 @@ var KustoLanguageService = /** @class */ (function () {
 }());
 var languageService = new KustoLanguageService(KustoLanguageService.dummySchema, {
     includeControlCommands: true,
-    useSemanticColorization: true,
     completionOptions: { includeExtendedSyntax: false },
 });
 /**

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

@@ -3,8 +3,6 @@ export interface LanguageSettings {
     includeControlCommands?: boolean;
     newlineAfterPipe?: boolean;
     openSuggestionDialogAfterPreviousSuggestionAccepted?: boolean;
-    useSemanticColorization?: boolean;
-    useTokenColorization?: boolean;
     disabledCompletionItems?: string[];
     onDidProvideCompletionItems?: OnDidProvideCompletionItems;
     enableHover?: boolean;

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

@@ -5,7 +5,7 @@ export * from './languageServiceManager/schema';
 export * from './languageServiceManager/renderInfo';
 export * from './languageServiceManager/settings';
 export * from './types';
-export { getCurrentCommandRange } from './extendedEditor';
+export * from './extendedGlobalApi';
 declare class LanguageServiceDefaultsImpl implements LanguageServiceDefaults {
     private _onDidChange;
     private _languageSettings;
@@ -19,8 +19,3 @@ declare class LanguageServiceDefaultsImpl implements LanguageServiceDefaults {
 }
 export declare function getKustoWorker(): Promise<WorkerAccessor>;
 export declare const kustoDefaults: LanguageServiceDefaultsImpl;
-export declare const themeNames: {
-    light: string;
-    dark: string;
-    dark2: string;
-};