@kusto/monaco-kusto 11.4.0 → 12.0.0

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

@@ -1,6 +1,6 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 11.4.0(7572339ea10d5d0fdd55c4a2b813f3663acab903)
+ * 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 {};

package/release/esm/syntaxHighlighting/themes.js

@@ -0,0 +1,103 @@
+import { Token } from './types';
+export var ThemeName;
+(function (ThemeName) {
+    ThemeName["light"] = "kusto-light";
+    ThemeName["dark"] = "kusto-dark";
+})(ThemeName || (ThemeName = {}));
+var colors = {
+    white: '#DCDCDC',
+    lightGoldenrodYellow: '#FAFAD2',
+    softGold: '#D7BA7D',
+    paleChestnut: '#D69D85',
+    paleVioletRed: '#DB7093',
+    firebrick: '#B22222',
+    orangeRed: '#FF4500',
+    mediumVioletRed: '#C71585',
+    magenta: '#FF00FF', // for debugging
+    darkOrchid: '#9932CC',
+    darkViolet: '#9400D3',
+    midnightBlue: '#191970',
+    blue: '#0000FF',
+    blueSapphire: '#004E8C',
+    tealBlue: '#2B91AF',
+    skyBlue: '#569CD6',
+    lightSkyBlue: '#92CAF4',
+    mediumTurquoise: '#4EC9B0',
+    oliveDrab: '#608B4E',
+    green: '#008000',
+    jetBlack: '#1B1A19',
+    black: '#000000',
+};
+var light = {
+    base: 'vs',
+    inherit: true,
+    rules: [
+        { token: '', foreground: colors.black },
+        { token: Token.PlainText, foreground: colors.black },
+        { token: Token.Comment, foreground: colors.green },
+        { token: Token.Punctuation, foreground: colors.black },
+        { token: Token.Directive, foreground: colors.darkViolet },
+        { token: Token.Literal, foreground: colors.black },
+        { token: Token.StringLiteral, foreground: colors.firebrick },
+        { token: Token.Type, foreground: colors.blue },
+        { token: Token.Column, foreground: colors.mediumVioletRed },
+        { token: Token.Table, foreground: colors.darkOrchid },
+        { token: Token.Database, foreground: colors.darkOrchid },
+        { token: Token.Function, foreground: colors.blue },
+        { token: Token.Parameter, foreground: colors.midnightBlue },
+        { token: Token.Variable, foreground: colors.midnightBlue },
+        { token: Token.Identifier, foreground: colors.black },
+        { token: Token.ClientParameter, foreground: colors.tealBlue },
+        { token: Token.QueryParameter, foreground: colors.tealBlue },
+        { token: Token.ScalarParameter, foreground: colors.blue },
+        { token: Token.MathOperator, foreground: colors.black },
+        { token: Token.QueryOperator, foreground: colors.orangeRed },
+        { token: Token.Command, foreground: colors.blue },
+        { token: Token.Keyword, foreground: colors.blue },
+        { token: Token.MaterializedView, foreground: colors.darkOrchid },
+        { token: Token.SchemaMember, foreground: colors.black },
+        { token: Token.SignatureParameter, foreground: colors.black },
+        { token: Token.Option, foreground: colors.black },
+    ],
+    colors: {},
+};
+var dark = {
+    base: 'vs-dark',
+    inherit: true,
+    rules: [
+        { token: '', foreground: colors.white },
+        { token: Token.PlainText, foreground: colors.white },
+        { token: Token.Comment, foreground: colors.oliveDrab },
+        { token: Token.Punctuation, foreground: colors.white },
+        { token: Token.Directive, foreground: colors.lightGoldenrodYellow },
+        { token: Token.Literal, foreground: colors.white },
+        { token: Token.StringLiteral, foreground: colors.paleChestnut },
+        { token: Token.Type, foreground: colors.skyBlue },
+        { token: Token.Column, foreground: colors.paleVioletRed },
+        { token: Token.Table, foreground: colors.softGold },
+        { token: Token.Database, foreground: colors.softGold },
+        { token: Token.Function, foreground: colors.skyBlue },
+        { token: Token.Parameter, foreground: colors.lightSkyBlue },
+        { token: Token.Variable, foreground: colors.lightSkyBlue },
+        { token: Token.Identifier, foreground: colors.white },
+        { token: Token.ClientParameter, foreground: colors.tealBlue },
+        { token: Token.QueryParameter, foreground: colors.tealBlue },
+        { token: Token.ScalarParameter, foreground: colors.skyBlue },
+        { token: Token.MathOperator, foreground: colors.white },
+        { token: Token.QueryOperator, foreground: colors.mediumTurquoise },
+        { token: Token.Command, foreground: colors.skyBlue },
+        { token: Token.Keyword, foreground: colors.skyBlue },
+        { token: Token.MaterializedView, foreground: colors.softGold },
+        { token: Token.SchemaMember, foreground: colors.black },
+        { token: Token.SignatureParameter, foreground: colors.black },
+        { token: Token.Option, foreground: colors.black },
+    ],
+    colors: {
+        'editor.background': colors.jetBlack,
+        'editorSuggestWidget.selectedBackground': colors.blueSapphire,
+    },
+};
+export var themes = [
+    { name: ThemeName.light, data: light },
+    { name: ThemeName.dark, data: dark },
+];

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

@@ -0,0 +1,41 @@
+/// <reference types="@kusto/language-service-next/Kusto.Language.Bridge" />
+export type ClassificationKind = Kusto.Language.Editor.ClassificationKind;
+export declare enum Token {
+    PlainText = "plainText",
+    Comment = "comment",
+    Punctuation = "punctuation",
+    Directive = "directive",
+    Literal = "literal",
+    StringLiteral = "stringLiteral",
+    Type = "type",
+    Column = "column",
+    Table = "table",
+    Database = "database",
+    Function = "function",
+    Parameter = "parameter",
+    Variable = "variable",
+    Identifier = "identifier",
+    ClientParameter = "clientParameter",
+    QueryParameter = "queryParameter",
+    ScalarParameter = "scalarParameter",
+    MathOperator = "mathOperator",
+    QueryOperator = "queryOperator",
+    Command = "command",
+    Keyword = "keyword",
+    MaterializedView = "materializedView",
+    SchemaMember = "schemaMember",
+    SignatureParameter = "signatureParameter",
+    Option = "option"
+}
+export declare const tokenTypes: Token[];
+export interface ClassificationRange {
+    line: number;
+    character: number;
+    length: number;
+    kind: ClassificationKind;
+}
+type DeltaLine = number;
+type DeltaStart = number;
+type Length = number;
+export type DocumentSemanticToken = [DeltaLine, DeltaStart, Length, Kusto.Language.Editor.ClassificationKind, 0];
+export {};