@kusto/monaco-kusto 5.3.9 → 5.3.11

package/release/esm/languageFeatures.js

@@ -3,7 +3,6 @@ import * as _ from './_deps/lodash/lodash';
 var Uri = monaco.Uri;
 var Range = monaco.Range;
 var ClassificationKind = Kusto.Language.Editor.ClassificationKind;
-// --- diagnostics ---
 var DiagnosticsAdapter = /** @class */ (function () {
     function DiagnosticsAdapter(_monacoInstance, _languageId, _worker, defaults, onSchemaChange) {
         var _this = this;
@@ -146,9 +145,9 @@ var DiagnosticsAdapter = /** @class */ (function () {
                 }
                 else {
                     // Add custom popup for syntax error: icon, header and message as markdown
-                    var header = syntaxErrorAsMarkDown.header ? "**" + syntaxErrorAsMarkDown.header + "** \n\n" : '';
-                    var icon = syntaxErrorAsMarkDown.icon ? "![](" + syntaxErrorAsMarkDown.icon + ")" : '';
-                    var popupErrorHoverHeaderMessage_1 = icon + " " + header;
+                    var header = syntaxErrorAsMarkDown.header ? "**".concat(syntaxErrorAsMarkDown.header, "** \n\n") : '';
+                    var icon = syntaxErrorAsMarkDown.icon ? "![](".concat(syntaxErrorAsMarkDown.icon, ")") : '';
+                    var popupErrorHoverHeaderMessage_1 = "".concat(icon, " ").concat(header);
                     var newDecorations = markers.map(function (marker) {
                         return {
                             range: {
@@ -175,8 +174,7 @@ var DiagnosticsAdapter = /** @class */ (function () {
                             },
                         };
                     });
-                    var oldMarkers = monaco.editor
-                        .getModelMarkers({
+                    var oldMarkers = monaco.editor.getModelMarkers({
                         owner: languageId,
                         resource: resource,
                     });
@@ -482,7 +480,7 @@ function getCssForClassification() {
     var classificationColorTriplets = getClassificationColorTriplets();
     var cssInnerHtml = classificationColorTriplets
         .map(function (pair) {
-        return ".vs ." + pair.classification + " {color: #" + pair.colorLight + ";} .vs-dark ." + pair.classification + " {color: #" + pair.colorDark + ";}";
+        return ".vs .".concat(pair.classification, " {color: #").concat(pair.colorLight, ";} .vs-dark .").concat(pair.classification, " {color: #").concat(pair.colorDark, ";}");
     })
         .join('\n');
     return cssInnerHtml;
@@ -583,7 +581,7 @@ function toTextEdit(textEdit) {
         text: textEdit.newText,
     };
 }
-var DOCS_BASE_URL = "https://learn.microsoft.com/azure/data-explorer/kusto/query";
+var DOCS_BASE_URL = 'https://learn.microsoft.com/azure/data-explorer/kusto/query';
 function formatDocLink(docString) {
     // If the docString is empty, we want to return undefined to prevent an empty documentation popup.
     if (!docString) {
@@ -593,9 +591,11 @@ function formatDocLink(docString) {
     var urisProxy = new Proxy(target, {
         get: function (_target, prop, _receiver) {
             // The link comes with a postfix of ".md" that we want to remove
-            var linkWithoutPostfix = prop.toString().replace(".md", "");
+            var linkWithoutPostfix = prop.toString().replace('.md', '');
             // Sometimes we get the link as a full URL. For example in the main doc link of the item
-            var fullURL = linkWithoutPostfix.startsWith("https") ? linkWithoutPostfix : DOCS_BASE_URL + "/" + linkWithoutPostfix;
+            var fullURL = linkWithoutPostfix.startsWith('https')
+                ? linkWithoutPostfix
+                : "".concat(DOCS_BASE_URL, "/").concat(linkWithoutPostfix);
             return monaco.Uri.parse(fullURL);
         },
     });

package/release/esm/languageService/kustoLanguageService.js

@@ -9,9 +9,15 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-/// <reference path="../../node_modules/@kusto/language-service/Kusto.JavaScript.Client.d.ts" />
-/// <reference path="../../node_modules/@kusto/language-service-next/Kusto.Language.Bridge.d.ts" />
-/// <reference path="../typings/refs.d.ts" />
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import * as s from './schema';
 // polyfill string endsWith
 if (!String.prototype.endsWith) {
@@ -117,7 +123,7 @@ var KustoLanguageService = /** @class */ (function () {
         /**
          * Taken from:
          * https://msazure.visualstudio.com/One/_git/Azure-Kusto-Service?path=/Src/Tools/Kusto.Explorer.Control/QueryEditors/KustoScriptEditor/KustoScriptEditorControl2.xaml.cs&version=GBdev&line=2075&lineEnd=2075&lineStartColumn=9&lineEndColumn=77&lineStyle=plain&_a=contents
-        */
+         */
         this._toOptionKind = (_a = {},
             _a[k2.CompletionKind.AggregateFunction] = k.OptionKind.FunctionAggregation,
             _a[k2.CompletionKind.BuiltInFunction] = k.OptionKind.FunctionScalar,
@@ -264,7 +270,7 @@ var KustoLanguageService = /** @class */ (function () {
         this._newlineAppendPipePolicy.Text = '\n| ';
     }
     KustoLanguageService.prototype.createDatabaseUniqueName = function (clusterName, databaseName) {
-        return clusterName + "_" + databaseName;
+        return "".concat(clusterName, "_").concat(databaseName);
     };
     Object.defineProperty(KustoLanguageService.prototype, "_kustoJsSchemaV2", {
         /**
@@ -311,20 +317,20 @@ var KustoLanguageService = /** @class */ (function () {
      */
     KustoLanguageService.prototype.debugGlobalState = function (globals) {
         // iterate over clusters
-        console.log("globals.Clusters.Count: " + globals.Clusters.Count);
+        console.log("globals.Clusters.Count: ".concat(globals.Clusters.Count));
         for (var i = 0; i < globals.Clusters.Count; i++) {
             var cluster = globals.Clusters.getItem(i);
-            console.log("cluster: " + cluster.Name);
+            console.log("cluster: ".concat(cluster.Name));
             // iterate over databases
-            console.log("cluster.Databases.Count: " + cluster.Databases.Count);
+            console.log("cluster.Databases.Count: ".concat(cluster.Databases.Count));
             for (var i2 = 0; i2 < cluster.Databases.Count; i2++) {
                 var database = cluster.Databases.getItem(i2);
-                console.log("cluster.database: [" + cluster.Name + "].[" + database.Name + "]");
+                console.log("cluster.database: [".concat(cluster.Name, "].[").concat(database.Name, "]"));
                 // iterate over tables
-                console.log("cluster.Databases.Tables.Count: " + database.Tables.Count);
+                console.log("cluster.Databases.Tables.Count: ".concat(database.Tables.Count));
                 for (var i3 = 0; i3 < database.Tables.Count; i3++) {
                     var table = database.Tables.getItem(i3);
-                    console.log("cluster.database.table: [" + cluster.Name + "].[" + database.Name + "].[" + table.Name + "]");
+                    console.log("cluster.database.table: [".concat(cluster.Name, "].[").concat(database.Name, "].[").concat(table.Name, "]"));
                 }
             }
         }
@@ -333,7 +339,7 @@ var KustoLanguageService = /** @class */ (function () {
      * Prepending the doc of the actual topic at the top
      */
     KustoLanguageService.prototype.formatHelpTopic = function (helpTopic) {
-        return "**" + helpTopic.Name + " [(view online)](" + helpTopic.Url + ")**\n\n" + helpTopic.LongDescription;
+        return "**".concat(helpTopic.Name, " [(view online)](").concat(helpTopic.Url, ")**\n\n").concat(helpTopic.LongDescription);
     };
     KustoLanguageService.prototype.doCompleteV2 = function (document, position) {
         var _this = this;
@@ -375,7 +381,7 @@ var KustoLanguageService = /** @class */ (function () {
                 ? {
                     // Need to escape dollar sign since it is used as a placeholder in snippet.
                     // Usually dollar sign is not a valid character in a function name, but grafana uses macros that start with dollars.
-                    textToInsert: kItem.EditText.replace('$', '\\$') + "$0" + kItem.AfterText,
+                    textToInsert: "".concat(kItem.EditText.replace('$', '\\$'), "$0").concat(kItem.AfterText),
                     format: ls.InsertTextFormat.Snippet,
                 }
                 : {
@@ -785,7 +791,7 @@ var KustoLanguageService = /** @class */ (function () {
             this._script = undefined;
             this._parsePropertiesV2 = undefined;
         }
-        // since V2 doesn't support control commands, we're initializing V1 intellisense for both cases and we'll going to use V1 intellisense for contorl commands.
+        // since V2 doesn't support control commands, we're initializing V1 intellisense for both cases and we'll going to use V1 intellisense for control commands.
         return new Promise(function (resolve, reject) {
             var kustoJsSchema = schema ? KustoLanguageService.convertToKustoJsSchema(schema) : undefined;
             _this._kustoJsSchema = kustoJsSchema;
@@ -793,13 +799,17 @@ var KustoLanguageService = /** @class */ (function () {
             resolve(undefined);
         });
     };
-    KustoLanguageService.prototype.setParameters = function (parameters) {
+    KustoLanguageService.prototype.setParameters = function (scalarParameters, tabularParameters) {
         if (!this._languageSettings.useIntellisenseV2 || this._schema.clusterType !== 'Engine') {
             throw new Error('setParameters requires intellisense V2 and Engine cluster');
         }
-        this._schema.globalParameters = parameters;
-        var symbols = parameters.map(function (param) { return KustoLanguageService.createParameterSymbol(param); });
-        this._kustoJsSchemaV2 = this._kustoJsSchemaV2.WithParameters(KustoLanguageService.toBridgeList(symbols));
+        this._schema.globalScalarParameters = scalarParameters;
+        this._schema.globalTabularParameters = tabularParameters;
+        var scalarSymbols = scalarParameters.map(function (param) { return KustoLanguageService.createParameterSymbol(param); });
+        var tabularSymbols = tabularParameters.map(function (param) {
+            return KustoLanguageService.createTabularParameterSymbol(param);
+        });
+        this._kustoJsSchemaV2 = this._kustoJsSchemaV2.WithParameters(KustoLanguageService.toBridgeList(__spreadArray(__spreadArray([], scalarSymbols, true), tabularSymbols, true)));
         return Promise.resolve(undefined);
     };
     /**
@@ -808,10 +818,10 @@ var KustoLanguageService = /** @class */ (function () {
      * @param clusterConnectionString cluster connection string
      * @param databaseInContextName name of database in context
      */
-    KustoLanguageService.prototype.setSchemaFromShowSchema = function (schema, clusterConnectionString, databaseInContextName, globalParameters) {
+    KustoLanguageService.prototype.setSchemaFromShowSchema = function (schema, clusterConnectionString, databaseInContextName, globalScalarParameters, globalTabularParameters) {
         var _this = this;
         return this.normalizeSchema(schema, clusterConnectionString, databaseInContextName).then(function (normalized) {
-            return _this.setSchema(__assign(__assign({}, normalized), { globalParameters: globalParameters }));
+            return _this.setSchema(__assign(__assign({}, normalized), { globalScalarParameters: globalScalarParameters, globalTabularParameters: globalTabularParameters }));
         });
     };
     /**
@@ -1446,8 +1456,8 @@ var KustoLanguageService = /** @class */ (function () {
      * @param params scalar parameters
      */
     KustoLanguageService.scalarParametersToSignature = function (params) {
-        var signatureWithoutParens = params.map(function (param) { return param.name + ": " + param.cslType; }).join(', ');
-        return "(" + signatureWithoutParens + ")";
+        var signatureWithoutParens = params.map(function (param) { return "".concat(param.name, ": ").concat(param.cslType); }).join(', ');
+        return "(".concat(signatureWithoutParens, ")");
     };
     /**
      * Returns something like '(x: string, T: (y: int))'
@@ -1459,14 +1469,14 @@ var KustoLanguageService = /** @class */ (function () {
             .map(function (param) {
             if (param.columns) {
                 var tableSignature = _this.scalarParametersToSignature(param.columns);
-                return param.name + ": " + tableSignature;
+                return "".concat(param.name, ": ").concat(tableSignature);
             }
             else {
-                return param.name + ": " + param.cslType;
+                return "".concat(param.name, ": ").concat(param.cslType);
             }
         })
             .join(', ');
-        return "(" + signatureWithoutParens + ")";
+        return "(".concat(signatureWithoutParens, ")");
     };
     /**
      * converts a function definition to a let statement.
@@ -1474,7 +1484,7 @@ var KustoLanguageService = /** @class */ (function () {
      */
     KustoLanguageService.toLetStatement = function (fn) {
         var signature = this.inputParameterToSignature(fn.inputParameters);
-        return "let " + fn.name + " = " + signature + " " + fn.body;
+        return "let ".concat(fn.name, " = ").concat(signature, " ").concat(fn.body);
     };
     KustoLanguageService.createColumnSymbol = function (col) {
         return new sym.ColumnSymbol(col.name, sym.ScalarTypes.GetSymbol(getCslTypeNameFromClrType(col.type)), col.docstring, null, null, col.examples ? KustoLanguageService.toBridgeList(col.examples) : null);
@@ -1483,6 +1493,11 @@ var KustoLanguageService = /** @class */ (function () {
         var paramSymbol = Kusto.Language.Symbols.ScalarTypes.GetSymbol(getCslTypeNameFromClrType(param.type));
         return new sym.ParameterSymbol(param.name, paramSymbol, null);
     };
+    KustoLanguageService.createTabularParameterSymbol = function (param) {
+        var columnSymbols = param.columns.map(function (col) { return KustoLanguageService.createColumnSymbol(col); });
+        var para = new Kusto.Language.Symbols.TableSymbol.$ctor4(param.name, columnSymbols);
+        return new sym.ParameterSymbol(param.name, para, param.docstring);
+    };
     KustoLanguageService.createParameter = function (param) {
         if (!param.columns) {
             var paramSymbol = Kusto.Language.Symbols.ScalarTypes.GetSymbol(getCslTypeNameFromClrType(param.type));
@@ -1532,6 +1547,7 @@ var KustoLanguageService = /** @class */ (function () {
         return databaseSymbol;
     };
     KustoLanguageService.prototype.convertToKustoJsSchemaV2 = function (schema) {
+        var _a, _b;
         var cached = this._schemaCache[schema.cluster.connectionString];
         // create a cache entry for the cluster if non yet exists.
         if (!cached) {
@@ -1575,12 +1591,16 @@ var KustoLanguageService = /** @class */ (function () {
         if (databaseInContext) {
             globalState = globalState.WithDatabase(databaseInContext);
         }
-        // Inject global parameters to global scope.
-        if (schema.globalParameters) {
-            var parameters = schema.globalParameters.map(function (param) {
-                return KustoLanguageService.createParameterSymbol(param);
-            });
-            globalState = globalState.WithParameters(KustoLanguageService.toBridgeList(parameters));
+        // Inject global scalar parameters to global scope.
+        var scalarParameters = ((_a = schema.globalScalarParameters) !== null && _a !== void 0 ? _a : []).map(function (param) {
+            return KustoLanguageService.createParameterSymbol(param);
+        });
+        // Inject global tabular parameters to global scope.
+        var tabularParameters = ((_b = schema.globalTabularParameters) !== null && _b !== void 0 ? _b : []).map(function (param) {
+            return KustoLanguageService.createTabularParameterSymbol(param);
+        });
+        if (tabularParameters.length || scalarParameters.length) {
+            globalState = globalState.WithParameters(KustoLanguageService.toBridgeList(__spreadArray(__spreadArray([], scalarParameters, true), tabularParameters, true)));
         }
         return globalState;
     };
@@ -1617,7 +1637,7 @@ var KustoLanguageService = /** @class */ (function () {
      */
     KustoLanguageService.prototype.getSortText = function (order) {
         if (order <= 0) {
-            throw new RangeError("order should be a number >= 1. instead got " + order);
+            throw new RangeError("order should be a number >= 1. instead got ".concat(order));
         }
         var sortText = '';
         var numCharacters = 26; // "z" - "a" + 1;

package/release/esm/languageService/kustoMonarchLanguageDefinition.js

@@ -1,23 +1,69 @@
 export var KustoLanguageDefinition = {
     name: 'kusto',
     mimeTypes: ['text/kusto'],
-    displayName: "Kusto",
-    defaultToken: "invalid",
-    brackets: [['[', ']', 'delimiter.square'],
-        ['(', ')', 'delimiter.parenthesis']],
+    displayName: 'Kusto',
+    defaultToken: 'invalid',
+    brackets: [
+        ['[', ']', 'delimiter.square'],
+        ['(', ')', 'delimiter.parenthesis'],
+    ],
     wordDefinition: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
     // .slice() call is for creating a shallow copy of the array since bridge.net shoves a $type property on the array which monaco doesn't like.
     promotedOperatorCommandTokens: Kusto.Data.IntelliSense.CslCommandParser.PromotedOperatorCommandTokens.slice(0),
     operatorCommandTokens: Kusto.Data.IntelliSense.CslCommandParser.OperatorCommandTokens.slice(0),
     keywords: [
-        'by', 'on', 'contains', 'notcontains', 'containscs', 'notcontainscs', 'startswith', 'has', 'matches', 'regex', 'true',
-        'false', 'and', 'or', 'typeof', 'int', 'string', 'date', 'datetime', 'time', 'long', 'real', '​boolean', 'bool'
+        'by',
+        'on',
+        'contains',
+        'notcontains',
+        'containscs',
+        'notcontainscs',
+        'startswith',
+        'has',
+        'matches',
+        'regex',
+        'true',
+        'false',
+        'and',
+        'or',
+        'typeof',
+        'int',
+        'string',
+        'date',
+        'datetime',
+        'time',
+        'long',
+        'real',
+        '​boolean',
+        'bool',
     ],
     operators: ['+', '-', '*', '/', '>', '<', '==', '<>', '<=', '>=', '~', '!~'],
     builtinFunctions: [
-        'countof', 'bin', 'extentid', 'extract', 'extractjson', 'floor', 'iif', 'isnull', 'isnotnull', 'notnull', 'isempty',
-        'isnotempty', 'notempty', 'now', 're2', 'strcat', 'strlen', 'toupper',
-        'tostring', 'count', 'cnt', 'sum', 'min', 'max', 'avg'
+        'countof',
+        'bin',
+        'extentid',
+        'extract',
+        'extractjson',
+        'floor',
+        'iif',
+        'isnull',
+        'isnotnull',
+        'notnull',
+        'isempty',
+        'isnotempty',
+        'notempty',
+        'now',
+        're2',
+        'strcat',
+        'strlen',
+        'toupper',
+        'tostring',
+        'count',
+        'cnt',
+        'sum',
+        'min',
+        'max',
+        'avg',
     ],
     tokenizer: {
         root: [
@@ -30,7 +76,9 @@ export var KustoLanguageDefinition = {
             [/[;,.]/, 'delimiter'],
             [/[()\[\]]/, '@brackets'],
             [/[<>=!%&+\-*/|~^]/, 'operator'],
-            [/[\w@#\-$]+/, {
+            [
+                /[\w@#\-$]+/,
+                {
                     cases: {
                         '@keywords': 'keyword',
                         '@promotedOperatorCommandTokens': 'operator.sql',
@@ -38,39 +86,42 @@ export var KustoLanguageDefinition = {
                         '@operators': 'operator',
                         '@builtinFunctions': 'predefined',
                         '@default': 'identifier',
-                    }
-                }],
+                    },
+                },
+            ],
         ],
         whitespace: [[/\s+/, 'white']],
-        comments: [["\\/\\/+.*", "comment"]],
+        comments: [['\\/\\/+.*', 'comment']],
         numbers: [
             [/0[xX][0-9a-fA-F]*/, 'number'],
             [/[$][+-]*\d*(\.\d*)?/, 'number'],
-            [/((\d+(\.\d*)?)|(\.\d+))([eE][\-+]?\d+)?/, 'number']
+            [/((\d+(\.\d*)?)|(\.\d+))([eE][\-+]?\d+)?/, 'number'],
         ],
         strings: [
             [/H'/, { token: 'string.quote', bracket: '@open', next: '@string' }],
             [/h'/, { token: 'string.quote', bracket: '@open', next: '@string' }],
-            [/'/, { token: 'string.quote', bracket: '@open', next: '@string' }]
+            [/'/, { token: 'string.quote', bracket: '@open', next: '@string' }],
         ],
         string: [
             [/[^']+/, 'string'],
             [/''/, 'string'],
-            [/'/, { token: 'string.quote', bracket: '@close', next: '@pop' }]
+            [/'/, { token: 'string.quote', bracket: '@close', next: '@pop' }],
         ],
         dqstrings: [
             [/H"/, { token: 'string.quote', bracket: '@open', next: '@dqstring' }],
             [/h"/, { token: 'string.quote', bracket: '@open', next: '@dqstring' }],
-            [/"/, { token: 'string.quote', bracket: '@open', next: '@dqstring' }]
+            [/"/, { token: 'string.quote', bracket: '@open', next: '@dqstring' }],
         ],
         dqstring: [
             [/[^"]+/, 'string'],
             [/""/, 'string'],
-            [/"/, { token: 'string.quote', bracket: '@close', next: '@pop' }]
+            [/"/, { token: 'string.quote', bracket: '@close', next: '@pop' }],
         ],
-        literals: [[/datetime\(\d{4}-\d{2}-\d{2}(\s+\d{2}:\d{2}(:\d{2}(\.\d{0,3})?)?)?\)/, 'number'],
+        literals: [
+            [/datetime\(\d{4}-\d{2}-\d{2}(\s+\d{2}:\d{2}(:\d{2}(\.\d{0,3})?)?)?\)/, 'number'],
             [/time\((\d+(s(ec(onds?)?)?|m(in(utes?)?)?|h(ours?)?|d(ays?)?)|(\s*(('[^']+')|("[^"]+"))\s*))\)/, 'number'],
             [/guid\([\da-fA-F]{8}-[\da-fA-F]{4}-[\da-fA-F]{4}-[\da-fA-F]{4}-[\da-fA-F]{12}\)/, 'number'],
-            [/typeof\((int|string|date|datetime|time|long|real|boolean|bool)\)/, 'number']]
-    }
+            [/typeof\((int|string|date|datetime|time|long|real|boolean|bool)\)/, 'number'],
+        ],
+    },
 };

package/release/esm/languageService/schema.js

@@ -19,7 +19,7 @@ var dotnetTypeToKustoType = {
     'Newtonsoft.Json.Linq.JObject': 'dynamic',
     'Newtonsoft.Json.Linq.JToken': 'dynamic',
     'System.Object': 'dynamic',
-    'System.Data.SqlTypes.SqlDecimal': 'decimal'
+    'System.Data.SqlTypes.SqlDecimal': 'decimal',
 };
 export var getCslTypeNameFromClrType = function (clrType) { return dotnetTypeToKustoType[clrType] || clrType; };
 var kustoTypeToEntityDataType = {
@@ -38,27 +38,27 @@ var kustoTypeToEntityDataType = {
     datetime: 'DateTime',
     string: 'String',
     dynamic: 'Dynamic',
-    timespan: 'TimeSpan'
+    timespan: 'TimeSpan',
 };
 export var getEntityDataTypeFromCslType = function (cslType) { return kustoTypeToEntityDataType[cslType] || cslType; };
 export var getCallName = function (fn) {
-    return fn.name + "(" + fn.inputParameters.map(function (p) { return "{" + p.name + "}"; }).join(',') + ")";
+    return "".concat(fn.name, "(").concat(fn.inputParameters.map(function (p) { return "{".concat(p.name, "}"); }).join(','), ")");
 };
 export var getExpression = function (fn) {
-    return "let " + fn.name + " = " + getInputParametersAsCslString(fn.inputParameters) + " " + fn.body;
+    return "let ".concat(fn.name, " = ").concat(getInputParametersAsCslString(fn.inputParameters), " ").concat(fn.body);
 };
 export var getInputParametersAsCslString = function (inputParameters) {
-    return "(" + inputParameters.map(function (inputParameter) { return getInputParameterAsCslString(inputParameter); }).join(',') + ")";
+    return "(".concat(inputParameters.map(function (inputParameter) { return getInputParameterAsCslString(inputParameter); }).join(','), ")");
 };
 var getInputParameterAsCslString = function (inputParameter) {
     // If this is a tabular parameter
     if (inputParameter.columns && inputParameter.columns.length > 0) {
         var attributesAsString = inputParameter.columns
-            .map(function (col) { return col.name + ":" + (col.cslType || getCslTypeNameFromClrType(col.type)); })
+            .map(function (col) { return "".concat(col.name, ":").concat(col.cslType || getCslTypeNameFromClrType(col.type)); })
             .join(',');
-        return inputParameter.name + ":" + (attributesAsString === '' ? '*' : attributesAsString);
+        return "".concat(inputParameter.name, ":").concat(attributesAsString === '' ? '*' : attributesAsString);
     }
     else {
-        return inputParameter.name + ":" + (inputParameter.cslType || getCslTypeNameFromClrType(inputParameter.type));
+        return "".concat(inputParameter.name, ":").concat(inputParameter.cslType || getCslTypeNameFromClrType(inputParameter.type));
     }
 };

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

@@ -1,3 +1,4 @@
+/// <reference types="monaco-editor-core/monaco" />
 import IEvent = monaco.IEvent;
 export declare class LanguageServiceDefaultsImpl implements monaco.languages.kusto.LanguageServiceDefaults {
     private _onDidChange;

package/release/esm/monaco.contribution.js

@@ -61,7 +61,7 @@ var defaultLanguageSettings = {
     },
     enableQueryWarnings: false,
     enableQuerySuggestions: false,
-    disabledDiagnoticCodes: [],
+    disabledDiagnosticCodes: [],
 };
 function getKustoWorker() {
     return new Promise(function (resolve, reject) {
@@ -89,7 +89,7 @@ export function setupMonacoKusto(monacoInstance) {
         id: 'kusto',
         extensions: ['.csl', '.kql'],
     });
-    // TODO: asked if there's a cleaner way to register an editor contribution. looks like monaco has an internal contribution regstrar but it's no exposed in the API.
+    // TODO: asked if there's a cleaner way to register an editor contribution. looks like monaco has an internal contribution registrar but it's no exposed in the API.
     // https://stackoverflow.com/questions/46700245/how-to-add-an-ieditorcontribution-to-monaco-editor
     var commandHighlighter;
     var commandFormatter;
@@ -164,14 +164,15 @@ export function setupMonacoKusto(monacoInstance) {
     });
     function triggerSuggestDialogWhenCompletionItemSelected(editor) {
         editor.onDidChangeCursorSelection(function (event) {
-            // checking the condition inside the event makes sure we will stay up to date whne kusto configuration changes at runtime.
+            // checking the condition inside the event makes sure we will stay up to date when kusto configuration changes at runtime.
             if (kustoDefaults &&
                 kustoDefaults.languageSettings &&
                 kustoDefaults.languageSettings.openSuggestionDialogAfterPreviousSuggestionAccepted) {
                 var didAcceptSuggestion = event.source === 'snippet' && event.reason === monaco.editor.CursorChangeReason.NotSet;
                 // If the word at the current position is not null - meaning we did not add a space after completion.
                 // In this case we don't want to activate the eager mode, since it will display the current selected word..
-                if (!didAcceptSuggestion || editor.getModel().getWordAtPosition(event.selection.getPosition()) !== null) {
+                if (!didAcceptSuggestion ||
+                    editor.getModel().getWordAtPosition(event.selection.getPosition()) !== null) {
                     return;
                 }
                 event.selection;

package/release/esm/monaco.d.ts

@@ -25,7 +25,7 @@ declare module monaco.languages.kusto {
         formatter?: FormatterOptions;
         enableQueryWarnings?: boolean;
         enableQuerySuggestions?: boolean;
-        disabledDiagnoticCodes?: string[];
+        disabledDiagnosticCodes?: string[];
     }
 
     export interface SyntaxErrorAsMarkDownOptions {
@@ -38,7 +38,7 @@ declare module monaco.languages.kusto {
         indentationSize?: number;
         pipeOperatorStyle?: FormatterPlacementStyle;
     }
-    
+
     export type FormatterPlacementStyle = 'None' | 'NewLine' | 'Smart';
 
     export interface LanguageServiceDefaults {
@@ -73,7 +73,8 @@ declare module monaco.languages.kusto {
             schema: any,
             clusterConnectionString: string,
             databaseInContextName: string,
-            globalParameters: ScalarParameter[]
+            globalScalarParameters: ScalarParameter[],
+            globalTabularParameters: TabularParameter[]
         ): Promise<void>;
         normalizeSchema(
             schema: any,
@@ -98,7 +99,7 @@ declare module monaco.languages.kusto {
 
         /**
          * Get all the ambient parameters defined in global scope.
-         * Ambient parameters are parameters that are not defined in the syntax such as in a query paramter declaration.
+         * Ambient parameters are parameters that are not defined in the syntax such as in a query parameter declaration.
          * These are parameters that are injected from outside, usually by a UX application that would like to offer
          * the user intellisense for a symbol, without forcing them to write a query declaration statement.
          * Usually  the same application injects the query declaration statement and the parameter values when
@@ -120,14 +121,22 @@ declare module monaco.languages.kusto {
         doDocumentFormat(uri: string): Promise<ls.TextEdit[]>;
         doRangeFormat(uri: string, range: ls.Range): Promise<ls.TextEdit[]>;
         doCurrentCommandFormat(uri: string, caretPosition: ls.Position): Promise<ls.TextEdit[]>;
-        doValidation(uri: string, intervals: { start: number; end: number }[], includeWarnings?: boolean, includeSuggestions?: boolean): Promise<ls.Diagnostic[]>;
-        setParameters(parameters: ScalarParameter[]): void;
+        doValidation(
+            uri: string,
+            intervals: { start: number; end: number }[],
+            includeWarnings?: boolean,
+            includeSuggestions?: boolean
+        ): Promise<ls.Diagnostic[]>;
+        setParameters(
+            scalarParameters: readonly ScalarParameter[],
+            tabularParameters: readonly TabularParameter[]
+        ): void;
         /**
-         * Get all the database references from the current command. 
+         * Get all the database references from the current command.
          * If database's schema is already cached in previous calls to setSchema or addDatabaseToSchema it will not be returned.
          * This method should be used to get all the cross-databases in a command, then schema for the database should be fetched and added with addDatabaseToSchema.
          * @example
-         * If the current command includes: cluster('help').database('Samples') 
+         * If the current command includes: cluster('help').database('Samples')
          * getDatabaseReferences will return [{ clusterName: 'help', databaseName 'Samples' }]
          */
         getDatabaseReferences(uri: string, cursorOffset: number): Promise<DatabaseReference[]>;
@@ -149,7 +158,7 @@ declare module monaco.languages.kusto {
          * @param clusterName the name of the cluster as returned from getDatabaseReferences/getClusterReferences.
          * @example
          * - User enters cluster('help').database('Samples')
-         * - hosting app calls getDatabaseReferences which returns [{ clusterName: 'help', databaseName: 'Samples' }]. 
+         * - hosting app calls getDatabaseReferences which returns [{ clusterName: 'help', databaseName: 'Samples' }].
          * - hosting app fetches the database Schema from https://help.kusto.windows.net
          * - hosting app calls 'addDatabaseToSchema' with the database's schema.
          * - now, when user types cluster('help').database('Samples') then the auto complete list will show all the tables.
@@ -160,12 +169,12 @@ declare module monaco.languages.kusto {
          * @param clusterName the name of the cluster as returned in getClusterReferences.
          * @example
          * - User enters cluster('help')
-         * - hosting app calls getClusterReferences which returns [{ clusterName: 'help' }]. 
+         * - hosting app calls getClusterReferences which returns [{ clusterName: 'help' }].
          * - hosting app fetches the list of databases from https://help.kusto.windows.net
          * - hosting app calls addClusterToSchema with the list of databases.
          * - now, when user type `cluster('help').database(` then the auto complete list will show all the databases.
          */
-        addClusterToSchema(uri: string, clusterName: string, databasesNames: string[]): Promise<void>;
+        addClusterToSchema(uri: string, clusterName: string, databasesNames: readonly string[]): Promise<void>;
     }
 
     /**
@@ -193,6 +202,12 @@ declare module monaco.languages.kusto {
         cslDefaultValue?: string;
     }
 
+    export interface TabularParameter {
+        name: string;
+        columns: Column[];
+        docstring?: string;
+    }
+
     // an input parameter either be a scalar in which case it has a name, type and cslType, or it can be columnar, in which case
     // it will have a name, and a list of scalar types which are the column types.
     export type InputParameter = ScalarParameter & { columns?: ScalarParameter[] };
@@ -283,11 +298,11 @@ declare module monaco.languages.kusto {
 
     export interface DatabaseReference {
         databaseName: string;
-        clusterName: string; 
-    };
+        clusterName: string;
+    }
 
     export interface ClusterReference {
-        clusterName: string; 
+        clusterName: string;
     }
 
     export type RenderOptionKeys = keyof RenderOptions;