@kusto/monaco-kusto 7.0.0 → 7.2.0

package/release/dev/schema-9cf94ce1.js

@@ -0,0 +1,109 @@
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-kusto version: 7.2.0(ff25adc61b13954e5ec288fcdc16c92483943ef5)
+ * Released under the MIT license
+ * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
+ *-----------------------------------------------------------------------------*/
+
+define('vs/language/kusto/schema-9cf94ce1', ['exports'], (function (exports) { 'use strict';
+
+    // 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.
+     */
+
+    var 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'
+    };
+    var getCslTypeNameFromClrType = function getCslTypeNameFromClrType(clrType) {
+      return dotnetTypeToKustoType[clrType] || clrType;
+    };
+    var 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'
+    };
+    var getEntityDataTypeFromCslType = function getEntityDataTypeFromCslType(cslType) {
+      return kustoTypeToEntityDataType[cslType] || cslType;
+    };
+    var getCallName = function getCallName(fn) {
+      return "".concat(fn.name, "(").concat(fn.inputParameters.map(function (p) {
+        return "{".concat(p.name, "}");
+      }).join(','), ")");
+    };
+    var getExpression = function getExpression(fn) {
+      return "let ".concat(fn.name, " = ").concat(getInputParametersAsCslString(fn.inputParameters), " ").concat(fn.body);
+    };
+    var getInputParametersAsCslString = function getInputParametersAsCslString(inputParameters) {
+      return "(".concat(inputParameters.map(function (inputParameter) {
+        return getInputParameterAsCslString(inputParameter);
+      }).join(','), ")");
+    };
+    var getInputParameterAsCslString = function getInputParameterAsCslString(inputParameter) {
+      // If this is a tabular parameter
+      if (inputParameter.columns && inputParameter.columns.length > 0) {
+        var attributesAsString = inputParameter.columns.map(function (col) {
+          return "".concat(col.name, ":").concat(col.cslType || getCslTypeNameFromClrType(col.type));
+        }).join(',');
+        return "".concat(inputParameter.name, ":").concat(attributesAsString === '' ? '*' : attributesAsString);
+      } else {
+        return "".concat(inputParameter.name, ":").concat(inputParameter.cslType || getCslTypeNameFromClrType(inputParameter.type));
+      }
+    };
+
+    /**
+     * This is the schema of the output of kusto command
+     * .show schema as json
+     */
+    exports.showSchema = void 0;
+    (function (_showSchema) {})(exports.showSchema || (exports.showSchema = {}));
+
+    exports.getCallName = getCallName;
+    exports.getCslTypeNameFromClrType = getCslTypeNameFromClrType;
+    exports.getEntityDataTypeFromCslType = getEntityDataTypeFromCslType;
+    exports.getExpression = getExpression;
+    exports.getInputParametersAsCslString = getInputParametersAsCslString;
+
+}));

package/release/esm/kusto.worker.js

@@ -1,6 +1,6 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 7.0.0(f23f8fe8dd705f8413d0d094c76eb0af2131aace)
+ * monaco-kusto version: 7.2.0(ff25adc61b13954e5ec288fcdc16c92483943ef5)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
@@ -8,76 +8,12 @@
 import * as worker from 'monaco-editor/esm/vs/editor/editor.worker';
 import * as ls from 'vscode-languageserver-types';
 import XRegExp from 'xregexp';
+import { d as getEntityDataTypeFromCslType, a as getCallName, b as getExpression, g as getCslTypeNameFromClrType } from './schema-53127847.js';
 import '@kusto/language-service/bridge.min';
 import '@kusto/language-service/Kusto.JavaScript.Client.min';
 import '@kusto/language-service/newtonsoft.json.min';
 import '@kusto/language-service-next/Kusto.Language.Bridge.min';
 
-// 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)}`;
-  }
-};
-
 var k = Kusto.Data.IntelliSense;
 var parsing = Kusto.Language.Parsing;
 var k2 = Kusto.Language.Editor;
@@ -604,7 +540,7 @@ class KustoLanguageService {
         const warningAndSuggestionDiagnostics = block.Service.GetAnalyzerDiagnostics(true);
         const filterredDiagnostics = this.toArray(warningAndSuggestionDiagnostics).filter(d => {
           const allowSeverity = enableWarnings && d.Severity === 'Warning' || enableSuggestions && d.Severity === 'Suggestion';
-          const allowCode = !this._languageSettings.disabledDiagnoticCodes?.includes(d.Code);
+          const allowCode = !this._languageSettings.disabledDiagnosticCodes?.includes(d.Code);
           return allowSeverity && allowCode;
         });
         diagnostics = diagnostics.concat(filterredDiagnostics);
@@ -1975,7 +1911,13 @@ function getKustoLanguageService() {
   return languageService;
 }
 
-class KustoWorker {
+/**
+ * We're using this interface to send messages to a worker, so using
+ * `InterfaceFor` to make it not nominal is more accurate. {@link KustoWorker}
+ * is the public, more limited version of this interface.
+ */
+
+class KustoWorkerImpl {
   // --- model sync -----------------------
 
   constructor(ctx, createData) {
@@ -2235,6 +2177,6 @@ class KustoWorker {
 self.onmessage = () => {
   // ignore the first message
   worker.initialize((ctx, createData) => {
-    return new KustoWorker(ctx, createData);
+    return new KustoWorkerImpl(ctx, createData);
   });
 };

package/release/esm/kustoMode.d.ts

@@ -1,8 +1,14 @@
-import type { LanguageServiceDefaults } from './monaco.contribution';
-import * as languageFeatures from './languageFeatures';
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import type { KustoWorker, LanguageServiceDefaults } from './monaco.contribution';
+import type { IKustoWorkerImpl } from './kustoWorker';
+export interface AugmentedWorker extends KustoWorker, Omit<IKustoWorkerImpl, 'setSchemaFromShowSchema'> {
+}
+export interface AugmentedWorkerAccessor {
+    (first: monaco.Uri, ...more: monaco.Uri[]): Promise<AugmentedWorker>;
+}
 /**
  * Called when Kusto language is first needed (a model has the language set)
  * @param defaults
  */
-export declare function setupMode(defaults: LanguageServiceDefaults, monacoInstance: typeof globalThis.monaco): languageFeatures.WorkerAccessor;
-export declare function getKustoWorker(): Promise<languageFeatures.WorkerAccessor>;
+export declare function setupMode(defaults: LanguageServiceDefaults, monacoInstance: typeof globalThis.monaco): AugmentedWorkerAccessor;
+export declare function getKustoWorker(): Promise<AugmentedWorkerAccessor>;

package/release/esm/kustoMode.js

@@ -1,6 +1,6 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 7.0.0(f23f8fe8dd705f8413d0d094c76eb0af2131aace)
+ * monaco-kusto version: 7.2.0(ff25adc61b13954e5ec288fcdc16c92483943ef5)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
@@ -1085,9 +1085,9 @@ function setupMode(defaults, monacoInstance) {
   const client = new WorkerManager(monacoInstance, defaults);
   disposables.push(client);
   const workerAccessor = (first, ...more) => {
-    const augmentedSetSchema = (schema, worker, globalScalarParameters, globalTabularParameters) => {
+    const augmentedSetSchema = async (schema, worker) => {
       const workerPromise = worker.setSchema(schema);
-      workerPromise.then(() => {
+      await workerPromise.then(() => {
         onSchemaChange.fire(schema);
       });
     };
@@ -1095,12 +1095,17 @@ function setupMode(defaults, monacoInstance) {
     return worker.then(worker => ({
       ...worker,
       setSchema: schema => augmentedSetSchema(schema, worker),
-      setSchemaFromShowSchema: (schema, connection, database, globalScalarParameters, globalTabularParameters) => {
-        worker.normalizeSchema(schema, connection, database).then(schema => globalScalarParameters ? {
-          ...schema,
-          globalScalarParameters,
-          globalTabularParameters
-        } : schema).then(normalized => augmentedSetSchema(normalized, worker));
+      async setSchemaFromShowSchema(schema, connection, database, globalScalarParameters, globalTabularParameters) {
+        await worker.normalizeSchema(schema, connection, database).then(schema => {
+          if (globalScalarParameters || globalTabularParameters) {
+            schema = {
+              ...schema,
+              globalScalarParameters,
+              globalTabularParameters
+            };
+          }
+          augmentedSetSchema(schema, worker);
+        });
       }
     }));
   };

package/release/esm/kustoWorker.d.ts

@@ -1,18 +1,29 @@
 import * as ls from 'vscode-languageserver-types';
-import type * as monaco from 'monaco-editor/esm/vs/editor/editor.worker';
+import type { worker } from 'monaco-editor/esm/vs/editor/editor.worker';
+import type { IRange } from 'monaco-editor/esm/vs/editor/editor.api';
 import * as kustoService from './languageService/kustoLanguageService';
 import type { LanguageSettings } from './languageService/settings';
 import { Schema, showSchema, ScalarParameter, Database, TabularParameter } from './languageService/schema';
 import type { ColorizationRange } from './languageService/kustoLanguageService';
 import type { RenderInfo } from './languageService/renderInfo';
-export declare class KustoWorker {
+import type { ClusterReference, DatabaseReference } from './types';
+export type InterfaceFor<C> = {
+    [Member in keyof C]: C[Member];
+};
+/**
+ * We're using this interface to send messages to a worker, so using
+ * `InterfaceFor` to make it not nominal is more accurate. {@link KustoWorker}
+ * is the public, more limited version of this interface.
+ */
+export type IKustoWorkerImpl = InterfaceFor<KustoWorkerImpl>;
+export declare class KustoWorkerImpl {
     private _ctx;
     private _languageService;
     private _languageId;
     private _languageSettings;
-    constructor(ctx: monaco.worker.IWorkerContext, createData: ICreateData);
+    constructor(ctx: worker.IWorkerContext, createData: ICreateData);
     setSchema(schema: Schema): Promise<void>;
-    addClusterToSchema(uri: string, clusterName: string, databasesNames: string[]): Promise<void>;
+    addClusterToSchema(uri: string, clusterName: string, databasesNames: readonly string[]): Promise<void>;
     addDatabaseToSchema(uri: string, clusterName: string, databaseSchema: Database): Promise<void>;
     setSchemaFromShowSchema(schema: any, clusterConnectionString: string, databaseInContextName: string): Promise<void>;
     normalizeSchema(schema: showSchema.Result, clusterConnectionString: string, databaseInContextName: string): Promise<import("./languageService/schema").EngineSchema>;
@@ -44,7 +55,7 @@ export declare class KustoWorker {
      */
     getCommandAndLocationInContext(uri: string, cursorOffset: number): Promise<{
         text: string;
-        range: monaco.IRange;
+        range: IRange;
     } | null>;
     getCommandsInDocument(uri: string): Promise<{
         absoluteStart: number;
@@ -78,12 +89,15 @@ export declare class KustoWorker {
     doRename(uri: string, position: ls.Position, newName: string): Promise<ls.WorkspaceEdit>;
     doHover(uri: string, position: ls.Position): Promise<ls.Hover>;
     setParameters(scalarParameters: readonly ScalarParameter[], tabularParameters: readonly TabularParameter[]): Promise<void>;
-    getClusterReferences(uri: string, cursorOffset: number): Promise<kustoService.ClusterReference[]>;
-    getDatabaseReferences(uri: string, cursorOffset: number): Promise<kustoService.DatabaseReference[]>;
+    getClusterReferences(uri: string, cursorOffset: number): Promise<ClusterReference[]>;
+    getDatabaseReferences(uri: string, cursorOffset: number): Promise<DatabaseReference[]>;
     private _getTextDocument;
 }
 export interface ICreateData {
     languageId: string;
     languageSettings: LanguageSettings;
 }
-export declare function create(ctx: monaco.worker.IWorkerContext, createData: ICreateData): KustoWorker;
+/**
+ * Used when monaco-editor is resolved via amd modules
+ */
+export declare function create(ctx: worker.IWorkerContext, createData: ICreateData): IKustoWorkerImpl;

package/release/esm/languageFeatures.d.ts

@@ -1,10 +1,7 @@
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 import type { LanguageServiceDefaults, LanguageSettings } from './monaco.contribution';
-import type { KustoWorker } from './kustoWorker';
 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;
@@ -16,7 +13,7 @@ export declare class DiagnosticsAdapter {
     private _schemaListener;
     private _cursorListener;
     private _debouncedValidations;
-    constructor(_monacoInstance: typeof globalThis.monaco, _languageId: string, _worker: WorkerAccessor, defaults: LanguageServiceDefaults, 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;
@@ -31,7 +28,7 @@ export declare class ColorizationAdapter {
     private _configurationListener;
     private _schemaListener;
     private decorations;
-    constructor(_monacoInstance: typeof globalThis.monaco, _languageId: string, _worker: WorkerAccessor, defaults: LanguageServiceDefaults, 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.
@@ -44,42 +41,42 @@ export declare class ColorizationAdapter {
 export declare class CompletionAdapter implements monaco.languages.CompletionItemProvider {
     private _worker;
     private languageSettings;
-    constructor(_worker: WorkerAccessor, languageSettings: 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/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

@@ -13,7 +13,7 @@ export interface LanguageSettings {
     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,6 +1,9 @@
 import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
-import type { KustoWorker } from './kustoWorker';
-import type { LanguageServiceDefaults, LanguageSettings } from './types';
+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 {
@@ -14,5 +17,10 @@ declare class LanguageServiceDefaultsImpl implements LanguageServiceDefaults {
     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;
+export declare const themeNames: {
+    light: string;
+    dark: string;
+    dark2: string;
+};

package/release/esm/monaco.contribution.js

@@ -1,11 +1,13 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 7.0.0(f23f8fe8dd705f8413d0d094c76eb0af2131aace)
+ * monaco-kusto version: 7.2.0(ff25adc61b13954e5ec288fcdc16c92483943ef5)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
 
 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-53127847.js';
+export { s as showSchema } from './schema-53127847.js';
 
 function getCurrentCommandRange(editor, cursorPosition) {
   const zeroBasedCursorLineNumber = cursorPosition.lineNumber - 1;
@@ -59,7 +61,7 @@ function extend(editor) {
  * 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'
   };
@@ -203,6 +205,11 @@ function withMode(callback) {
   import('./kustoMode.js').then(callback);
 }
 const kustoDefaults = new LanguageServiceDefaultsImpl(defaultLanguageSettings);
+const themeNames = {
+  light: 'kusto-light',
+  dark: 'kusto-dark',
+  dark2: 'kusto-dark2'
+};
 monaco.languages.onLanguage('kusto', () => {
   withMode(mode => mode.setupMode(kustoDefaults, monaco));
 });
@@ -210,7 +217,7 @@ monaco.languages.register({
   id: 'kusto',
   extensions: ['.csl', '.kql']
 });
-monaco.editor.defineTheme('kusto-light', {
+monaco.editor.defineTheme(themeNames.light, {
   base: 'vs',
   inherit: true,
   rules: [{
@@ -294,7 +301,7 @@ monaco.editor.defineTheme('kusto-light', {
   }],
   colors: {}
 });
-monaco.editor.defineTheme('kusto-dark', {
+monaco.editor.defineTheme(themeNames.dark, {
   base: 'vs-dark',
   inherit: true,
   rules: [{
@@ -380,7 +387,7 @@ monaco.editor.defineTheme('kusto-dark', {
     // see: https://code.visualstudio.com/api/references/theme-color#editor-widget-colors
   }
 });
-monaco.editor.defineTheme('kusto-dark2', {
+monaco.editor.defineTheme(themeNames.dark2, {
   base: 'vs-dark',
   inherit: true,
   rules: [],
@@ -395,8 +402,13 @@ monaco.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.editor.onDidCreateEditor(editor => {
-  // hook up extension methods to editor.
-  extend(editor);
+  if (window.MonacoEnvironment?.globalAPI) {
+    // hook up extension methods to editor.
+    extend(editor);
+  }
+
+  // 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
   new KustoCommandHighlighter(editor);
   if (isStandaloneCodeEditor(editor)) {
     new KustoCommandFormatter(editor);
@@ -428,10 +440,16 @@ function isStandaloneCodeEditor(editor) {
   return editor.addAction !== undefined;
 }
 const globalApi = {
+  getCslTypeNameFromClrType,
+  getCallName,
+  getExpression,
+  getInputParametersAsCslString,
+  getEntityDataTypeFromCslType,
   kustoDefaults,
   getKustoWorker,
-  getCurrentCommandRange
+  getCurrentCommandRange,
+  themeNames
 };
 monaco.languages.kusto = globalApi;
 
-export { getCurrentCommandRange, getKustoWorker, kustoDefaults };
+export { getCallName, getCslTypeNameFromClrType, getCurrentCommandRange, getEntityDataTypeFromCslType, getExpression, getInputParametersAsCslString, getKustoWorker, kustoDefaults, themeNames };