@kusto/monaco-kusto 11.3.0 → 12.0.0

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;

package/release/esm/{schema-aeb83929.js → schema-66580db4.js}

@@ -1,6 +1,6 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 11.3.0(1980c071675308de7c009d1dcaeec2f7be442a6e)
+ * monaco-kusto version: 12.0.0(2f1838c12bdb98562467acf51b6fd3e396182e86)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
@@ -81,4 +81,14 @@ const getInputParameterAsCslString = inputParameter => {
  */
 let showSchema;
 
-export { getCallName as a, getExpression as b, getInputParametersAsCslString as c, getEntityDataTypeFromCslType as d, getCslTypeNameFromClrType as g, showSchema as s };
+const schema = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+    __proto__: null,
+    getCallName,
+    getCslTypeNameFromClrType,
+    getEntityDataTypeFromCslType,
+    getExpression,
+    getInputParametersAsCslString,
+    showSchema
+}, Symbol.toStringTag, { value: 'Module' }));
+
+export { getEntityDataTypeFromCslType as a, getCallName as b, getExpression as c, getInputParametersAsCslString as d, showSchema as e, getCslTypeNameFromClrType as g, schema as s };

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

@@ -0,0 +1,18 @@
+import type * as monaco from 'monaco-editor';
+import { editor } from 'monaco-editor';
+import { ClassificationRange } from './types';
+type ClassificationsGetter = (resource: monaco.Uri) => Promise<ClassificationRange[]>;
+export declare class SemanticTokensProvider implements monaco.languages.DocumentSemanticTokensProvider {
+    private readonly classificationsGetter;
+    constructor(classificationsGetter: ClassificationsGetter);
+    getLegend(): {
+        tokenTypes: import("./types").Token[];
+        tokenModifiers: any[];
+    };
+    provideDocumentSemanticTokens(model: editor.ITextModel): Promise<{
+        data: Uint32Array;
+        resultId: string;
+    }>;
+    releaseDocumentSemanticTokens(): void;
+}
+export {};

package/release/esm/syntaxHighlighting/SemanticTokensProvider.js

@@ -0,0 +1,78 @@
+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 };
+    }
+};
+import { tokenTypes } from './types';
+var SemanticTokensProvider = /** @class */ (function () {
+    function SemanticTokensProvider(classificationsGetter) {
+        this.classificationsGetter = classificationsGetter;
+    }
+    SemanticTokensProvider.prototype.getLegend = function () {
+        return { tokenTypes: tokenTypes, tokenModifiers: [] };
+    };
+    SemanticTokensProvider.prototype.provideDocumentSemanticTokens = function (model) {
+        return __awaiter(this, void 0, void 0, function () {
+            var resource, classifications, semanticTokens;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        resource = model.uri;
+                        return [4 /*yield*/, this.classificationsGetter(resource)];
+                    case 1:
+                        classifications = _a.sent();
+                        semanticTokens = classifications.map(function (classification, index) {
+                            var previousClassification = classifications[index - 1];
+                            return semanticTokenMaker(classification, previousClassification);
+                        });
+                        return [2 /*return*/, {
+                                data: new Uint32Array(semanticTokens.flat()),
+                                resultId: model.getVersionId().toString(),
+                            }];
+                }
+            });
+        });
+    };
+    SemanticTokensProvider.prototype.releaseDocumentSemanticTokens = function () { };
+    return SemanticTokensProvider;
+}());
+export { SemanticTokensProvider };
+var emptyClassification = { line: 0, character: 0, length: 0, kind: 0 };
+function semanticTokenMaker(classification, previousClassification) {
+    if (previousClassification === void 0) { previousClassification = emptyClassification; }
+    var line = classification.line, character = classification.character, length = classification.length, kind = classification.kind;
+    var deltaLine = line - previousClassification.line;
+    var deltaStart = deltaLine ? character : character - previousClassification.character;
+    return [deltaLine, deltaStart, length, kind, 0];
+}

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

@@ -0,0 +1,2 @@
+import type * as monaco from 'monaco-editor';
+export declare const kustoLanguageDefinition: monaco.languages.IMonarchLanguage;

package/release/esm/syntaxHighlighting/kustoMonarchLanguageDefinition.js

@@ -0,0 +1,401 @@
+import { LANGUAGE_ID } from '../globals';
+import { Token } from './types';
+var queryOperators = [
+    'as',
+    'consume',
+    'distinct',
+    'evaluate',
+    'extend',
+    'getschema',
+    'graph-match',
+    'graph-merge',
+    'graph-to-table',
+    'invoke',
+    'join',
+    'limit',
+    'lookup',
+    'make-graph',
+    'make-series',
+    'mv-apply',
+    'mv-expand',
+    'order',
+    'parse',
+    'parse-kv',
+    'parse-where',
+    'project',
+    'project-away',
+    'project-keep',
+    'project-rename',
+    'project-reorder',
+    'range',
+    'reduce',
+    'render',
+    'sample',
+    'sample-distinct',
+    'scan',
+    'serialize',
+    'sort',
+    'summarize',
+    'take',
+    'top',
+    'top-hitters',
+    'top-nested',
+    'union',
+    'where',
+    'filter',
+    'fork',
+    'facet',
+    'range',
+    'consume',
+    'find',
+    'search',
+    'print',
+    'partition',
+    'lookup',
+];
+var queryParameters = ['kind'];
+var types = ['bool', 'datetime', 'decimal', 'double', 'dynamic', 'guid', 'int', 'long', 'real', 'string', 'timespan'];
+var commands = [
+    '.add',
+    '.alter',
+    '.alter-merge',
+    '.append',
+    '.as',
+    '.assert',
+    '.attach',
+    '.consume',
+    '.count',
+    '.create',
+    '.create-merge',
+    '.create-or-alter',
+    '.create-set',
+    '.datatable',
+    '.default',
+    '.define',
+    '.delete',
+    '.detach',
+    '.distinct',
+    '.drop',
+    '.drop-pretend',
+    '.dup-next-failed-ingest',
+    '.dup-next-ingest',
+    '.evaluate',
+    '.export',
+    '.extend',
+    '.externaldata',
+    '.filter',
+    '.find',
+    '.fork',
+    '.getschema',
+    '.ingest',
+    '.join',
+    '.limit',
+    '.load',
+    '.make-series',
+    '.materialize',
+    '.move',
+    '.mv-expand',
+    '.order',
+    '.parse',
+    '.parse-where',
+    '.partition',
+    '.pivot',
+    '.print',
+    '.project',
+    '.project-away',
+    '.project-keep',
+    '.project-rename',
+    '.reduce',
+    '.remove',
+    '.rename',
+    '.replace',
+    '.restrict',
+    '.run',
+    '.sample',
+    '.sample-distinct',
+    '.save',
+    '.search',
+    '.serialize',
+    '.set',
+    '.set-or-append',
+    '.set-or-replace',
+    '.show',
+    '.sort',
+    '.summarize',
+    '.take',
+    '.top',
+    '.top-hitters',
+    '.top-nested',
+    '.union',
+];
+var functions = [
+    'abs',
+    'acos',
+    'ago',
+    'array_concat',
+    'array_length',
+    'array_slice',
+    'array_split',
+    'asin',
+    'atan',
+    'atan2',
+    'avg',
+    'bag_keys',
+    'base64_decodestring',
+    'base64_encodestring',
+    'bin',
+    'bin_at',
+    'binary_and',
+    'binary_not',
+    'binary_or',
+    'binary_shift_left',
+    'binary_shift_right',
+    'binary_xor',
+    'case',
+    'ceiling',
+    'coalesce',
+    'columnifexists',
+    'cos',
+    'count',
+    'countof',
+    'cot',
+    'cursor_after',
+    'datatable',
+    'datepart',
+    'datetime_add',
+    'datetime_diff',
+    'datetime_part',
+    'dayofmonth',
+    'dayofweek',
+    'dayofyear',
+    'dcount',
+    'dcount_hll',
+    'degrees',
+    'endofday',
+    'endofmonth',
+    'endofweek',
+    'endofyear',
+    'exp',
+    'exp10',
+    'exp2',
+    'extract',
+    'extractall',
+    'extractjson',
+    'format_datetime',
+    'format_timespan',
+    'floor',
+    'gamma',
+    'geo_distance_2points',
+    'geo_geohash_to_central_point',
+    'geo_point_in_circle',
+    'geo_point_in_polygon',
+    'geo_point_to_geohash',
+    'getmonth',
+    'gettype',
+    'getyear',
+    'hash',
+    'hash_sha256',
+    'hll_merge',
+    'iif',
+    'indexof',
+    'isempty',
+    'isfinite',
+    'isinf',
+    'isascii',
+    'isnan',
+    'isnotempty',
+    'isnotnull',
+    'isnull',
+    'isutf8',
+    'log',
+    'log10',
+    'log2',
+    'loggamma',
+    'make_datetime',
+    'make_string',
+    'make_timespan',
+    'materialize',
+    'max',
+    'max_of',
+    'min',
+    'min_of',
+    'monthofyear',
+    'next',
+    'not',
+    'pack',
+    'pack_array',
+    'pack_dictionary',
+    'parse_csv',
+    'parse_ipv4',
+    'parse_json',
+    'parse_path',
+    'parse_url',
+    'parse_urlquery',
+    'parse_user_agent',
+    'parse_version',
+    'parse_xml',
+    'parsejson',
+    'percentrank_tdigest',
+    'percentile_tdigest',
+    'pow',
+    'prev',
+    'radians',
+    'rand',
+    'rank_tdigest',
+    'repeat',
+    'replace',
+    'reverse',
+    'round',
+    'row_cumsum',
+    'row_window_session',
+    'series_add',
+    'series_decompose',
+    'series_decompose_anomalies',
+    'series_decompose_forecast',
+    'series_divide',
+    'series_equals',
+    'series_fill_backward',
+    'series_fill_const',
+    'series_fill_forward',
+    'series_fill_linear',
+    'series_fir',
+    'series_fit_2lines',
+    'series_fit_2lines_dynamic',
+    'series_fit_line',
+    'series_fit_line_dynamic',
+    'series_greater',
+    'series_greater_equals',
+    'series_iir',
+    'series_less',
+    'series_less_equals',
+    'series_multiply',
+    'series_not_equals',
+    'series_outliers',
+    'series_pearson_correlation',
+    'series_periods_detect',
+    'series_periods_validate',
+    'series_seasonal',
+    'series_stats',
+    'series_stats_dynamic',
+    'series_subtract',
+    'sign',
+    'sin',
+    'split',
+    'sqrt',
+    'startofday',
+    'startofmonth',
+    'startofweek',
+    'startofyear',
+    'strcat',
+    'strcat_array',
+    'strcat_delim',
+    'strcmp',
+    'strlen',
+    'strrep',
+    'string_size',
+    'substring',
+    'sum',
+    'tan',
+    'tdigest_merge',
+    'tobool',
+    'toboolean',
+    'todecimal',
+    'todouble',
+    'todynamic',
+    'tofloat',
+    'toguid',
+    'tohex',
+    'toint',
+    'tolong',
+    'tolower',
+    'toobject',
+    'toreal',
+    'toscalar',
+    'tostring',
+    'totimespan',
+    'toupper',
+    'translate',
+    'trim',
+    'trim_end',
+    'trim_start',
+    'typeof',
+    'url_decode',
+    'url_encode',
+    'week_of_year',
+    'welch_test',
+];
+var keywords = [
+    'and',
+    'as',
+    'asc',
+    'between',
+    'by',
+    'contains',
+    'count',
+    'desc',
+    'extend',
+    'false',
+    'filter',
+    'find',
+    'from',
+    'has',
+    'in',
+    'inner',
+    'join',
+    'leftouter',
+    'let',
+    'not',
+    'on',
+    'or',
+    'policy',
+    'project',
+    'project-away',
+    'project-rename',
+    'project-reorder',
+    'project-keep',
+    'range',
+    'rename',
+    'retention',
+    'summarize',
+    'table',
+    'take',
+    'to',
+    'true',
+    'where',
+    'with',
+];
+export var kustoLanguageDefinition = {
+    name: LANGUAGE_ID,
+    mimeTypes: ['text/kusto'],
+    displayName: 'Kusto',
+    defaultToken: 'invalid',
+    queryOperators: queryOperators,
+    queryParameters: queryParameters,
+    types: types,
+    commands: commands,
+    functions: functions,
+    keywords: keywords,
+    tokenizer: {
+        root: [
+            [/(\/\/.*$)/, Token.Comment],
+            [/[\(\)\{\}\|\[\]\:\=\,\<|\.\..]/, Token.Punctuation],
+            [/[\+\-\*\/\%\!\<\<=\>\>=\=\==\!=\<>\:\;\,\=~\@\?\=>\!~]/, Token.MathOperator],
+            [/"([^"\\]*(\\.[^"\\]*)*)"/, Token.StringLiteral],
+            [/'([^"\\]*(\\.[^"\\]*)*)'/, Token.StringLiteral],
+            [
+                /[\w@#\-$\.]+/,
+                {
+                    cases: {
+                        '@queryOperators': Token.QueryOperator,
+                        '@queryParameters': Token.QueryParameter,
+                        '@types': Token.Type,
+                        '@commands': Token.Command,
+                        '@functions': Token.Function,
+                        '@keywords': Token.Keyword,
+                        '@default': 'identifier',
+                    },
+                },
+            ],
+        ],
+    },
+};

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

@@ -0,0 +1,11 @@
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+export declare enum ThemeName {
+    light = "kusto-light",
+    dark = "kusto-dark"
+}
+interface Theme {
+    name: ThemeName;
+    data: monaco.editor.IStandaloneThemeData;
+}
+export declare const themes: Theme[];
+export {};