@kusto/monaco-kusto 11.4.0 → 12.0.0

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

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,
@@ -675,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) {
@@ -1612,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);
@@ -1744,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;
-};

package/release/esm/monaco.contribution.js

@@ -1,13 +1,27 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 import KustoCommandHighlighter from './commandHighlighter';
 import KustoCommandFormatter from './commandFormatter';
-import { extend, getCurrentCommandRange } from './extendedEditor';
-import { getCslTypeNameFromClrType, getCallName, getExpression, getInputParametersAsCslString, getEntityDataTypeFromCslType, } from './languageServiceManager/schema';
+import { extend } from './extendedEditor';
+import { themes } from './syntaxHighlighting/themes';
+import { LANGUAGE_ID } from './globals';
+import * as schema from './languageServiceManager/schema';
+import { getRangeHtml } from './extendedGlobalApi';
 export * from './languageServiceManager/schema';
 export * from './languageServiceManager/renderInfo';
 export * from './languageServiceManager/settings';
 export * from './types';
-export { getCurrentCommandRange } from './extendedEditor';
+export * from './extendedGlobalApi';
 // --- Kusto configuration and defaults ---------
 var LanguageServiceDefaultsImpl = /** @class */ (function () {
     function LanguageServiceDefaultsImpl(languageSettings) {
@@ -53,8 +67,6 @@ var defaultLanguageSettings = {
     includeControlCommands: true,
     newlineAfterPipe: true,
     openSuggestionDialogAfterPreviousSuggestionAccepted: true,
-    useSemanticColorization: true,
-    useTokenColorization: false,
     enableHover: true,
     formatter: {
         indentationSize: 4,
@@ -81,75 +93,16 @@ function withMode(callback) {
     import('./kustoMode').then(callback);
 }
 export var kustoDefaults = new LanguageServiceDefaultsImpl(defaultLanguageSettings);
-export var themeNames = {
-    light: 'kusto-light',
-    dark: 'kusto-dark',
-    dark2: 'kusto-dark2',
-};
 monaco.languages.onLanguage('kusto', function () {
     withMode(function (mode) { return mode.setupMode(kustoDefaults, monaco); });
 });
 monaco.languages.register({
-    id: 'kusto',
+    id: LANGUAGE_ID,
     extensions: ['.csl', '.kql'],
 });
-monaco.editor.defineTheme(themeNames.light, {
-    base: 'vs',
-    inherit: true,
-    rules: [
-        { token: 'comment', foreground: '008000' }, // CommentToken Green
-        { token: 'variable.predefined', foreground: '800080' }, // CalculatedColumnToken Purple
-        { token: 'function', foreground: '0000FF' }, // FunctionNameToken Blue
-        { token: 'operator.sql', foreground: 'CC3700' }, // _WAS_ OperatorToken OrangeRed, but 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' },
-    ],
-    colors: {},
-});
-monaco.editor.defineTheme(themeNames.dark, {
-    base: 'vs-dark',
-    inherit: true,
-    rules: [
-        { token: 'comment', foreground: '608B4E' }, // CommentToken Green
-        { token: 'variable.predefined', foreground: '4ec9b0' }, // CalculatedColumnToken Purple
-        { token: 'function', foreground: 'dcdcaa' }, // FunctionNameToken Blue
-        { token: 'operator.sql', foreground: '9cdcfe' }, // OperatorToken OrangeRed
-        { token: 'string', foreground: 'ce9178' }, // StringLiteralToken Firebrick
-        { token: 'operator.scss', foreground: '569cd6' }, // SubOperatorToken Blue
-        { token: 'variable', foreground: '4ec9b0' }, // TableColumnToken MediumVioletRed
-        { token: 'variable.parameter', foreground: 'c586c0' }, // TableToken DarkOrchid
-        { token: '', foreground: 'd4d4d4' }, // UnknownToken, PlainTextToken  Black
-        { token: 'type', foreground: '569cd6' }, // DataTypeToken Blue
-        { token: 'tag', foreground: '569cd6' }, // ControlCommandToken Blue
-        { token: 'annotation', foreground: '9cdcfe' }, // QueryParametersToken FF2B91AF
-        { token: 'keyword', foreground: '569cd6' }, // CslCommandToken, PluginToken Blue
-        { token: 'number', foreground: 'd7ba7d' }, // LetVariablesToken MidnightBlue
-        { token: 'annotation', foreground: 'b5cea8' }, // ClientDirectiveToken DarkViolet
-        { token: 'invalid', background: 'cd3131' },
-    ],
-    colors: {
-    // see: https://code.visualstudio.com/api/references/theme-color#editor-widget-colors
-    },
-});
-monaco.editor.defineTheme(themeNames.dark2, {
-    base: 'vs-dark',
-    inherit: true,
-    rules: [],
-    colors: {
-        // see: https://code.visualstudio.com/api/references/theme-color#editor-widget-colors
-        'editor.background': '#1B1A19', // gray 200
-        'editorSuggestWidget.selectedBackground': '#004E8C',
-    },
+themes.forEach(function (_a) {
+    var name = _a.name, data = _a.data;
+    return monaco.editor.defineTheme(name, data);
 });
 // Initialize kusto specific language features that don't currently have a natural way to extend using existing apis.
 // Most other language features are initialized in kustoMode.ts
@@ -193,15 +146,5 @@ function triggerSuggestDialogWhenCompletionItemSelected(editor) {
 function isStandaloneCodeEditor(editor) {
     return editor.addAction !== undefined;
 }
-var globalApi = {
-    getCslTypeNameFromClrType: getCslTypeNameFromClrType,
-    getCallName: getCallName,
-    getExpression: getExpression,
-    getInputParametersAsCslString: getInputParametersAsCslString,
-    getEntityDataTypeFromCslType: getEntityDataTypeFromCslType,
-    kustoDefaults: kustoDefaults,
-    getKustoWorker: getKustoWorker,
-    getCurrentCommandRange: getCurrentCommandRange,
-    themeNames: themeNames,
-};
+var globalApi = __assign(__assign({}, schema), { kustoDefaults: kustoDefaults, getKustoWorker: getKustoWorker, getRangeHtml: getRangeHtml });
 monaco.languages.kusto = globalApi;