@kusto/monaco-kusto 6.2.0 → 7.0.1

package/release/esm/languageFeatures.d.ts

@@ -1,12 +1,7 @@
-/// <reference types="../monaco" />
-/// <reference types="monaco-editor/monaco" />
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
-import type { LanguageServiceDefaultsImpl } from './monaco.contribution';
-import type { KustoWorker } from './kustoWorker';
+import type { LanguageServiceDefaults, LanguageSettings } from './monaco.contribution';
 import type { Schema } from './languageService/schema';
-export interface WorkerAccessor {
-    (first: monaco.Uri, ...more: monaco.Uri[]): Promise<KustoWorker>;
-}
+import { AugmentedWorkerAccessor } from './kustoMode';
 export declare class DiagnosticsAdapter {
     private _monacoInstance;
     private _languageId;
@@ -18,7 +13,7 @@ export declare class DiagnosticsAdapter {
     private _schemaListener;
     private _cursorListener;
     private _debouncedValidations;
-    constructor(_monacoInstance: typeof globalThis.monaco, _languageId: string, _worker: WorkerAccessor, defaults: LanguageServiceDefaultsImpl, onSchemaChange: monaco.IEvent<Schema>);
+    constructor(_monacoInstance: typeof globalThis.monaco, _languageId: string, _worker: AugmentedWorkerAccessor, defaults: LanguageServiceDefaults, onSchemaChange: monaco.IEvent<Schema>);
     private getMonacoCodeActions;
     private getOrCreateDebouncedValidation;
     dispose(): void;
@@ -33,7 +28,7 @@ export declare class ColorizationAdapter {
     private _configurationListener;
     private _schemaListener;
     private decorations;
-    constructor(_monacoInstance: typeof globalThis.monaco, _languageId: string, _worker: WorkerAccessor, defaults: LanguageServiceDefaultsImpl, onSchemaChange: monaco.IEvent<Schema>);
+    constructor(_monacoInstance: typeof globalThis.monaco, _languageId: string, _worker: AugmentedWorkerAccessor, defaults: LanguageServiceDefaults, onSchemaChange: monaco.IEvent<Schema>);
     dispose(): void;
     /**
      * Return true if the range doesn't intersect any of the line ranges.
@@ -46,42 +41,42 @@ export declare class ColorizationAdapter {
 export declare class CompletionAdapter implements monaco.languages.CompletionItemProvider {
     private _worker;
     private languageSettings;
-    constructor(_worker: WorkerAccessor, languageSettings: globalThis.monaco.languages.kusto.LanguageSettings);
+    constructor(_worker: AugmentedWorkerAccessor, languageSettings: LanguageSettings);
     get triggerCharacters(): string[];
     provideCompletionItems(model: monaco.editor.IReadOnlyModel, position: monaco.Position, context: monaco.languages.CompletionContext, token: monaco.CancellationToken): monaco.Thenable<monaco.languages.CompletionList>;
 }
 export declare class DefinitionAdapter {
     private _worker;
-    constructor(_worker: WorkerAccessor);
+    constructor(_worker: AugmentedWorkerAccessor);
     provideDefinition(model: monaco.editor.IReadOnlyModel, position: monaco.Position, token: monaco.CancellationToken): monaco.Thenable<monaco.languages.Definition>;
 }
 export declare class ReferenceAdapter implements monaco.languages.ReferenceProvider {
     private _worker;
-    constructor(_worker: WorkerAccessor);
+    constructor(_worker: AugmentedWorkerAccessor);
     provideReferences(model: monaco.editor.IReadOnlyModel, position: monaco.Position, context: monaco.languages.ReferenceContext, token: monaco.CancellationToken): monaco.Thenable<monaco.languages.Location[]>;
 }
 export declare class RenameAdapter implements monaco.languages.RenameProvider {
     private _worker;
-    constructor(_worker: WorkerAccessor);
+    constructor(_worker: AugmentedWorkerAccessor);
     provideRenameEdits(model: monaco.editor.IReadOnlyModel, position: monaco.Position, newName: string, token: monaco.CancellationToken): monaco.Thenable<monaco.languages.WorkspaceEdit>;
 }
 export declare class DocumentFormatAdapter implements monaco.languages.DocumentFormattingEditProvider {
     private _worker;
-    constructor(_worker: WorkerAccessor);
+    constructor(_worker: AugmentedWorkerAccessor);
     provideDocumentFormattingEdits(model: monaco.editor.IReadOnlyModel, options: monaco.languages.FormattingOptions, token: monaco.CancellationToken): monaco.languages.TextEdit[] | monaco.Thenable<monaco.languages.TextEdit[]>;
 }
 export declare class FormatAdapter implements monaco.languages.DocumentRangeFormattingEditProvider {
     private _worker;
-    constructor(_worker: WorkerAccessor);
+    constructor(_worker: AugmentedWorkerAccessor);
     provideDocumentRangeFormattingEdits(model: monaco.editor.IReadOnlyModel, range: monaco.Range, options: monaco.languages.FormattingOptions, token: monaco.CancellationToken): monaco.languages.TextEdit[] | monaco.Thenable<monaco.languages.TextEdit[]>;
 }
 export declare class FoldingAdapter implements monaco.languages.FoldingRangeProvider {
     private _worker;
-    constructor(_worker: WorkerAccessor);
+    constructor(_worker: AugmentedWorkerAccessor);
     provideFoldingRanges(model: monaco.editor.ITextModel, context: monaco.languages.FoldingContext, token: monaco.CancellationToken): monaco.languages.FoldingRange[] | PromiseLike<monaco.languages.FoldingRange[]>;
 }
 export declare class HoverAdapter implements monaco.languages.HoverProvider {
     private _worker;
-    constructor(_worker: WorkerAccessor);
+    constructor(_worker: AugmentedWorkerAccessor);
     provideHover(model: monaco.editor.IReadOnlyModel, position: monaco.Position, token: monaco.CancellationToken): monaco.Thenable<monaco.languages.Hover>;
 }

package/release/esm/languageService/kustoLanguageService.d.ts

@@ -10,6 +10,7 @@ import k = Kusto.Data.IntelliSense;
 import k2 = Kusto.Language.Editor;
 import { Database } from './schema';
 import type { RenderInfo } from './renderInfo';
+import type { ClusterReference, DatabaseReference } from '../types';
 export declare enum TokenKind {
     TableToken = 2,
     TableColumnToken = 4,
@@ -124,20 +125,13 @@ export interface LanguageService {
     getDatabaseReferences(document: TextDocument, cursorOffset: number): Promise<DatabaseReference[]>;
     getClusterReferences(document: TextDocument, cursorOffset: number): Promise<ClusterReference[]>;
     addDatabaseToSchema(document: TextDocument, clusterName: string, databaseSchema: Database): Promise<void>;
-    addClusterToSchema(document: TextDocument, clusterName: string, databaseNames: string[]): Promise<void>;
+    addClusterToSchema(document: TextDocument, clusterName: string, databaseNames: readonly string[]): Promise<void>;
 }
 export type CmSchema = {
     accounts: k.KustoIntelliSenseAccountEntity[];
     services: k.KustoIntelliSenseServiceEntity[];
     connectionString: string;
 };
-export interface DatabaseReference {
-    databaseName: string;
-    clusterName: string;
-}
-export interface ClusterReference {
-    clusterName: string;
-}
 /**
  * Obtain an instance of the kusto language service.
  */

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

@@ -1,2 +1,2 @@
-/// <reference types="monaco-editor/monaco" />
+import type * as monaco from 'monaco-editor/esm/vs/editor/editor.worker';
 export declare const KustoLanguageDefinition: monaco.languages.IMonarchLanguage;

package/release/esm/languageService/schema.d.ts

@@ -27,9 +27,14 @@ export interface TabularParameter {
     columns: Column[];
     docstring?: string;
 }
-export type InputParameter = ScalarParameter & {
+/**
+ * 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 interface InputParameter extends ScalarParameter {
     columns?: ScalarParameter[];
-};
+}
 export interface Function {
     name: string;
     body: string;

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

@@ -1,4 +1,4 @@
-/// <reference types="../monaco" />
+import type { OnDidProvideCompletionItems } from '../types';
 export interface LanguageSettings {
     includeControlCommands?: boolean;
     newlineAfterPipe?: boolean;
@@ -7,13 +7,13 @@ export interface LanguageSettings {
     useSemanticColorization?: boolean;
     useTokenColorization?: boolean;
     disabledCompletionItems?: string[];
-    onDidProvideCompletionItems?: monaco.languages.kusto.OnDidProvideCompletionItems;
+    onDidProvideCompletionItems?: OnDidProvideCompletionItems;
     enableHover?: boolean;
     formatter?: FormatterOptions;
     syntaxErrorAsMarkDown?: SyntaxErrorAsMarkDownOptions;
     enableQueryWarnings?: boolean;
     enableQuerySuggestions?: boolean;
-    disabledDiagnoticCodes?: string[];
+    disabledDiagnosticCodes?: string[];
     quickFixCodeActions?: QuickFixCodeActionOptions[];
     enableQuickFixes?: boolean;
 }
@@ -26,5 +26,5 @@ export interface SyntaxErrorAsMarkDownOptions {
     icon?: string;
     enableSyntaxErrorAsMarkDown?: boolean;
 }
-export type QuickFixCodeActionOptions = 'Extract Expression' | 'Extract Function' | 'Change to';
+export type QuickFixCodeActionOptions = 'Extract Expression' | 'Extract Function' | 'Change to' | 'FixAll';
 export type FormatterPlacementStyle = 'None' | 'NewLine' | 'Smart';

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

@@ -1,16 +1,21 @@
-/// <reference types="../monaco" />
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
-import type { KustoWorker } from './kustoWorker';
-export declare class LanguageServiceDefaultsImpl implements globalThis.globalThis.monaco.languages.kusto.LanguageServiceDefaults {
+import type { LanguageServiceDefaults, WorkerAccessor } from './types';
+import type { LanguageSettings } from './languageService/settings';
+export * from './languageService/schema';
+export * from './languageService/renderInfo';
+export * from './languageService/settings';
+export * from './types';
+export { getCurrentCommandRange } from './extendedEditor';
+declare class LanguageServiceDefaultsImpl implements LanguageServiceDefaults {
     private _onDidChange;
     private _languageSettings;
     private _workerMaxIdleTime;
-    constructor(languageSettings: globalThis.monaco.languages.kusto.LanguageSettings);
-    get onDidChange(): monaco.IEvent<globalThis.monaco.languages.kusto.LanguageServiceDefaults>;
-    get languageSettings(): globalThis.monaco.languages.kusto.LanguageSettings;
-    setLanguageSettings(options: globalThis.monaco.languages.kusto.LanguageSettings): void;
+    constructor(languageSettings: LanguageSettings);
+    get onDidChange(): monaco.IEvent<LanguageServiceDefaults>;
+    get languageSettings(): LanguageSettings;
+    setLanguageSettings(options: LanguageSettings): void;
     setMaximumWorkerIdleTime(value: number): void;
     getWorkerMaxIdleTime(): number;
 }
-export declare function getKustoWorker(): Promise<(first: monaco.Uri, ...more: monaco.Uri[]) => Promise<KustoWorker>>;
+export declare function getKustoWorker(): Promise<WorkerAccessor>;
 export declare const kustoDefaults: LanguageServiceDefaultsImpl;

package/release/esm/monaco.contribution.js

@@ -1,17 +1,67 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 6.2.0(8e26147bc7c3b5a7a3bc6ee55311dfa0b612c10c)
+ * monaco-kusto version: 7.0.1(d5a041ddb6e4a3a3ebcb2a1aa79da979a62b6da2)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
 
-import * as monaco$1 from 'monaco-editor/esm/vs/editor/editor.api';
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import { g as getCslTypeNameFromClrType, a as getCallName, b as getExpression, c as getInputParametersAsCslString, d as getEntityDataTypeFromCslType } from './schema-cdbe085f.js';
+export { s as showSchema } from './schema-cdbe085f.js';
+
+function getCurrentCommandRange(editor, cursorPosition) {
+  const zeroBasedCursorLineNumber = cursorPosition.lineNumber - 1;
+  const lines = editor.getModel().getLinesContent();
+  let commandOrdinal = 0;
+  const linesWithCommandOrdinal = [];
+  for (let lineNumber = 0; lineNumber < lines.length; lineNumber++) {
+    let isEmptyLine = lines[lineNumber].trim() === '';
+    if (isEmptyLine) {
+      // increase commandCounter - we'll be starting a new command.
+      linesWithCommandOrdinal.push({
+        commandOrdinal: commandOrdinal++,
+        lineNumber
+      });
+    } else {
+      linesWithCommandOrdinal.push({
+        commandOrdinal: commandOrdinal,
+        lineNumber
+      });
+    }
+
+    // No need to keep scanning if we're past our line and we've seen an empty line.
+    if (lineNumber > zeroBasedCursorLineNumber && commandOrdinal > linesWithCommandOrdinal[zeroBasedCursorLineNumber].commandOrdinal) {
+      break;
+    }
+  }
+  const currentCommandOrdinal = linesWithCommandOrdinal[zeroBasedCursorLineNumber].commandOrdinal;
+  const currentCommandLines = linesWithCommandOrdinal.filter(line => line.commandOrdinal === currentCommandOrdinal);
+  const currentCommandStartLine = currentCommandLines[0].lineNumber + 1;
+  const currentCommandEndLine = currentCommandLines[currentCommandLines.length - 1].lineNumber + 1;
+
+  // End-column of 1 means no characters will be highlighted - since columns are 1-based in monaco apis.
+  // Start-column of 1 and End column of 2 means 1st character is selected.
+  // Thus if a line has n column and we need to provide n+1 so that the entire line will be highlighted.
+  const commandEndColumn = lines[currentCommandEndLine - 1].length + 1;
+  return new monaco.Range(currentCommandStartLine, 1, currentCommandEndLine, commandEndColumn);
+}
+
+/**
+ * Extending ICode editor to contain additional kusto-specific methods.
+ * note that the extend method needs to be called at least once to take affect, otherwise this here code is useless.
+ */
+function extend(editor) {
+  const proto = Object.getPrototypeOf(editor);
+  proto.getCurrentCommandRange = function (cursorPosition) {
+    getCurrentCommandRange(this, cursorPosition);
+  };
+}
 
 /**
  * Highlights the command that surround cursor location
  */
 class KustoCommandHighlighter {
-  static ID = 'editor.contrib.kustoCommandHighliter';
+  static ID = 'editor.contrib.kustoCommandHighlighter';
   static CURRENT_COMMAND_HIGHLIGHT = {
     className: 'selectionHighlight'
   };
@@ -46,7 +96,7 @@ class KustoCommandHighlighter {
       this.decorations = this.editor.deltaDecorations(this.decorations, []);
       return;
     }
-    const commandRange = this.editor.getCurrentCommandRange(changeEvent.selection.getStartPosition());
+    const commandRange = getCurrentCommandRange(this.editor, changeEvent.selection.getStartPosition());
     const decorations = [{
       range: commandRange,
       options: KustoCommandHighlighter.CURRENT_COMMAND_HIGHLIGHT
@@ -87,54 +137,10 @@ class KustoCommandFormatter {
   }
 }
 
-/**
- * Extending ICode editor to contain additional kusto-specific methods.
- * note that the extend method needs to be called at least once to take affect, otherwise this here code is useless.
- */
-function extend(editor) {
-  const proto = Object.getPrototypeOf(editor);
-  proto.getCurrentCommandRange = function (cursorPosition) {
-    const zeroBasedCursorLineNumber = cursorPosition.lineNumber - 1;
-    const lines = this.getModel().getLinesContent();
-    let commandOrdinal = 0;
-    const linesWithCommandOrdinal = [];
-    for (let lineNumber = 0; lineNumber < lines.length; lineNumber++) {
-      let isEmptyLine = lines[lineNumber].trim() === '';
-      if (isEmptyLine) {
-        // increase commandCounter - we'll be starting a new command.
-        linesWithCommandOrdinal.push({
-          commandOrdinal: commandOrdinal++,
-          lineNumber
-        });
-      } else {
-        linesWithCommandOrdinal.push({
-          commandOrdinal: commandOrdinal,
-          lineNumber
-        });
-      }
-
-      // No need to keep scanning if we're past our line and we've seen an empty line.
-      if (lineNumber > zeroBasedCursorLineNumber && commandOrdinal > linesWithCommandOrdinal[zeroBasedCursorLineNumber].commandOrdinal) {
-        break;
-      }
-    }
-    const currentCommandOrdinal = linesWithCommandOrdinal[zeroBasedCursorLineNumber].commandOrdinal;
-    const currentCommandLines = linesWithCommandOrdinal.filter(line => line.commandOrdinal === currentCommandOrdinal);
-    const currentCommandStartLine = currentCommandLines[0].lineNumber + 1;
-    const currentCommandEndLine = currentCommandLines[currentCommandLines.length - 1].lineNumber + 1;
-
-    // End-column of 1 means no characters will be highlighted - since columns are 1-based in monaco apis.
-    // Start-column of 1 and End column of 2 means 1st character is selected.
-    // Thus if a line has n column and we need to provide n+1 so that the entire line will be highlighted.
-    const commandEndColumn = lines[currentCommandEndLine - 1].length + 1;
-    return new monaco.Range(currentCommandStartLine, 1, currentCommandEndLine, commandEndColumn);
-  };
-}
-
 // --- Kusto configuration and defaults ---------
 
 class LanguageServiceDefaultsImpl {
-  _onDidChange = new monaco$1.Emitter();
+  _onDidChange = new monaco.Emitter();
 
   // in milliseconds. For example - this is 2 minutes 2 * 60 * 1000
 
@@ -199,14 +205,14 @@ function withMode(callback) {
   import('./kustoMode.js').then(callback);
 }
 const kustoDefaults = new LanguageServiceDefaultsImpl(defaultLanguageSettings);
-monaco$1.languages.onLanguage('kusto', () => {
-  withMode(mode => mode.setupMode(kustoDefaults, monaco$1));
+monaco.languages.onLanguage('kusto', () => {
+  withMode(mode => mode.setupMode(kustoDefaults, monaco));
 });
-monaco$1.languages.register({
+monaco.languages.register({
   id: 'kusto',
   extensions: ['.csl', '.kql']
 });
-monaco$1.editor.defineTheme('kusto-light', {
+monaco.editor.defineTheme('kusto-light', {
   base: 'vs',
   inherit: true,
   rules: [{
@@ -290,7 +296,7 @@ monaco$1.editor.defineTheme('kusto-light', {
   }],
   colors: {}
 });
-monaco$1.editor.defineTheme('kusto-dark', {
+monaco.editor.defineTheme('kusto-dark', {
   base: 'vs-dark',
   inherit: true,
   rules: [{
@@ -376,7 +382,7 @@ monaco$1.editor.defineTheme('kusto-dark', {
     // see: https://code.visualstudio.com/api/references/theme-color#editor-widget-colors
   }
 });
-monaco$1.editor.defineTheme('kusto-dark2', {
+monaco.editor.defineTheme('kusto-dark2', {
   base: 'vs-dark',
   inherit: true,
   rules: [],
@@ -390,7 +396,7 @@ monaco$1.editor.defineTheme('kusto-dark2', {
 
 // 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
-monaco$1.editor.onDidCreateEditor(editor => {
+monaco.editor.onDidCreateEditor(editor => {
   // hook up extension methods to editor.
   extend(editor);
   new KustoCommandHighlighter(editor);
@@ -403,7 +409,7 @@ function triggerSuggestDialogWhenCompletionItemSelected(editor) {
   editor.onDidChangeCursorSelection(event => {
     // 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$1.editor.CursorChangeReason.NotSet;
+      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) {
@@ -423,9 +429,16 @@ function triggerSuggestDialogWhenCompletionItemSelected(editor) {
 function isStandaloneCodeEditor(editor) {
   return editor.addAction !== undefined;
 }
-monaco$1.languages.kusto = {
+const globalApi = {
+  getCslTypeNameFromClrType,
+  getCallName,
+  getExpression,
+  getInputParametersAsCslString,
+  getEntityDataTypeFromCslType,
   kustoDefaults,
-  getKustoWorker
+  getKustoWorker,
+  getCurrentCommandRange
 };
+monaco.languages.kusto = globalApi;
 
-export { LanguageServiceDefaultsImpl, getKustoWorker, kustoDefaults };
+export { getCallName, getCslTypeNameFromClrType, getCurrentCommandRange, getEntityDataTypeFromCslType, getExpression, getInputParametersAsCslString, getKustoWorker, kustoDefaults };

package/release/esm/schema-cdbe085f.js

@@ -0,0 +1,85 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-kusto version: 7.0.1(d5a041ddb6e4a3a3ebcb2a1aa79da979a62b6da2)
+ * Released under the MIT license
+ * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
+ *-----------------------------------------------------------------------------*/
+
+// Definition of schema object in the context of language services. This model is exposed to consumers of this library.
+
+/**
+ * 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.
+ */
+
+/**
+ * Schema types:
+ * Engine – The main schema type. Contains clusters, databases, tables, table columns and functions.
+ * Cluster Manager – Internal only. A schema for clusters that manages other clusters.
+ * Data Management – Internal only. A schema for ingestion point operations.
+ */
+
+const dotnetTypeToKustoType = {
+  'System.SByte': 'bool',
+  'System.Byte': 'uint8',
+  'System.Int16': 'int16',
+  'System.UInt16': 'uint16',
+  'System.Int32': 'int',
+  'System.UInt32': 'uint',
+  'System.Int64': 'long',
+  'System.UInt64': 'ulong',
+  'System.String': 'string',
+  'System.Single': 'float',
+  'System.Double': 'real',
+  'System.DateTime': 'datetime',
+  'System.TimeSpan': 'timespan',
+  'System.Guid': 'guid',
+  'System.Boolean': 'bool',
+  'Newtonsoft.Json.Linq.JArray': 'dynamic',
+  'Newtonsoft.Json.Linq.JObject': 'dynamic',
+  'Newtonsoft.Json.Linq.JToken': 'dynamic',
+  'System.Object': 'dynamic',
+  'System.Data.SqlTypes.SqlDecimal': 'decimal'
+};
+const getCslTypeNameFromClrType = clrType => dotnetTypeToKustoType[clrType] || clrType;
+const kustoTypeToEntityDataType = {
+  object: 'Object',
+  bool: 'Boolean',
+  uint8: 'Byte',
+  int16: 'Int16',
+  uint16: 'UInt16',
+  int: 'Int32',
+  uint: 'UInt32',
+  long: 'Int64',
+  ulong: 'UInt64',
+  float: 'Single',
+  real: 'Double',
+  decimal: 'Decimal',
+  datetime: 'DateTime',
+  string: 'String',
+  dynamic: 'Dynamic',
+  timespan: 'TimeSpan'
+};
+const getEntityDataTypeFromCslType = cslType => kustoTypeToEntityDataType[cslType] || cslType;
+const getCallName = fn => `${fn.name}(${fn.inputParameters.map(p => `{${p.name}}`).join(',')})`;
+const getExpression = fn => `let ${fn.name} = ${getInputParametersAsCslString(fn.inputParameters)} ${fn.body}`;
+const getInputParametersAsCslString = inputParameters => `(${inputParameters.map(inputParameter => getInputParameterAsCslString(inputParameter)).join(',')})`;
+const getInputParameterAsCslString = inputParameter => {
+  // If this is a tabular parameter
+  if (inputParameter.columns && inputParameter.columns.length > 0) {
+    const attributesAsString = inputParameter.columns.map(col => `${col.name}:${col.cslType || getCslTypeNameFromClrType(col.type)}`).join(',');
+    return `${inputParameter.name}:${attributesAsString === '' ? '*' : attributesAsString}`;
+  } else {
+    return `${inputParameter.name}:${inputParameter.cslType || getCslTypeNameFromClrType(inputParameter.type)}`;
+  }
+};
+
+/**
+ * This is the schema of the output of kusto command
+ * .show schema as json
+ */
+let showSchema;
+(function (_showSchema) {})(showSchema || (showSchema = {}));
+
+export { getCallName as a, getExpression as b, getInputParametersAsCslString as c, getEntityDataTypeFromCslType as d, getCslTypeNameFromClrType as g, showSchema as s };

package/release/esm/types.d.ts

@@ -0,0 +1,149 @@
+import type * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import type * as ls from 'vscode-languageserver-types';
+import type { Schema, ScalarParameter, TabularParameter, EngineSchema, Database, showSchema } from './languageService/schema';
+import type { RenderInfo } from './languageService/renderInfo';
+import type { LanguageSettings } from './languageService/settings';
+export interface LanguageServiceDefaults {
+    readonly onDidChange: monaco.IEvent<LanguageServiceDefaults>;
+    readonly languageSettings: LanguageSettings;
+    /**
+     * Configure language service settings.
+     */
+    setLanguageSettings(options: LanguageSettings): void;
+    /**
+     * Configure when the worker shuts down. By default that is 2mins.
+     *
+     * @param value The maximum idle time in milliseconds. Values less than one
+     * mean never shut down.
+     */
+    setMaximumWorkerIdleTime(value: number): void;
+    getWorkerMaxIdleTime(): number;
+}
+export interface KustoWorker {
+    setSchema(schema: Schema): Promise<void>;
+    setSchemaFromShowSchema(schema: any, clusterConnectionString: string, databaseInContextName: string, globalScalarParameters?: ScalarParameter[], globalTabularParameters?: TabularParameter[]): Promise<void>;
+    normalizeSchema(schema: showSchema.Result, clusterConnectionString: string, databaseInContextName: string): Promise<EngineSchema>;
+    getCommandInContext(uri: string, cursorOffset: number): Promise<string | null>;
+    getCommandAndLocationInContext(uri: string, offset: number): Promise<{
+        text: string;
+        range: monaco.IRange;
+    } | null>;
+    getCommandsInDocument(uri: string): Promise<{
+        absoluteStart: number;
+        absoluteEnd: number;
+        text: string;
+    }[]>;
+    getClientDirective(text: string): Promise<{
+        isClientDirective: boolean;
+        directiveWithoutLeadingComments: string;
+    }>;
+    getAdminCommand(text: string): Promise<{
+        isAdminCommand: boolean;
+        adminCommandWithoutLeadingComments: string;
+    }>;
+    /**
+     * Get all declared query parameters declared in current block if any.
+     */
+    getQueryParams(uri: string, cursorOffset: number): Promise<{
+        name: string;
+        type: string;
+    }[]>;
+    /**
+     * 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 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
+     * executing the query (so it will execute correctly)
+     */
+    getGlobalParams(uri: string): Promise<{
+        name: string;
+        type: string;
+    }[]>;
+    /**
+     * Get the global parameters that are actually being referenced in query.
+     * This is different from getQueryParams that will return the parameters using a query declaration
+     * statement.
+     * It is also different from getGlobalParams that will return all global parameters whether used or not.
+     */
+    getReferencedGlobalParams(uri: string, cursorOffset?: number): Promise<{
+        name: string;
+        type: string;
+    }[]>;
+    getReferencedSymbols(uri: string, cursorOffset?: number): Promise<{
+        name: string;
+        kind: string;
+        display: string;
+    }[]>;
+    /**
+     * Get visualization options in render command if present (null otherwise).
+     */
+    getRenderInfo(uri: string, cursorOffset: number): Promise<RenderInfo | null>;
+    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(scalarParameters: readonly ScalarParameter[], tabularParameters: readonly TabularParameter[]): Promise<void>;
+    /**
+     * 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')
+     * getDatabaseReferences will return [{ clusterName: 'help', databaseName 'Samples' }]
+     */
+    getDatabaseReferences(uri: string, cursorOffset: number): Promise<DatabaseReference[]>;
+    /**
+     * Get all the cluster references from the current command.
+     * If cluster's schema is already cached it will not be returned.
+     * This method should be used to get all the cross-clusters in a command, then schema for the cluster should be fetched and added with addClusterToSchema.
+     * cluster name is returned exactly as written in the KQL `cluster(<cluster name>)` function.
+     * @example
+     * If the current command includes: cluster('help')
+     * it returns [{ clusterName: 'help' }]
+     * @example
+     * If the current command includes: cluster('https://demo11.westus.kusto.windows.net')
+     * getClusterReferences will return [{ clusterName: 'https://demo11.westus.kusto.windows.net' }]
+     */
+    getClusterReferences(uri: string, cursorOffset: number): Promise<ClusterReference[]>;
+    /**
+     * Adds a database's scheme. Useful with getDatabaseReferences to load schema for cross-cluster commands.
+     * @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 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.
+     */
+    addDatabaseToSchema(uri: string, clusterName: string, databaseSchema: Database): Promise<void>;
+    /**
+     * Adds a cluster's databases to the schema. Useful when used with getClusterReferences in cross-cluster commands.
+     * @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 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: readonly string[]): Promise<void>;
+}
+/**
+ * A function that get a model Uri and returns a kusto worker that knows how to work
+ * with that document.
+ */
+export interface WorkerAccessor {
+    (first: monaco.Uri, ...more: monaco.Uri[]): Promise<KustoWorker>;
+}
+export interface DatabaseReference {
+    databaseName: string;
+    clusterName: string;
+}
+export interface ClusterReference {
+    clusterName: string;
+}
+export type OnDidProvideCompletionItems = (list: ls.CompletionList) => Promise<ls.CompletionList>;