@kusto/monaco-kusto 5.6.6 → 6.0.0

package/release/esm/monaco.contribution.js

@@ -1,198 +1,441 @@
-var Emitter = monaco.Emitter;
-import KustoCommandHighlighter from './commandHighlighter';
-import KustoCommandFormatter from './commandFormatter';
-import { extend } from './extendedEditor';
-// --- Kusto configuration and defaults ---------
-var LanguageServiceDefaultsImpl = /** @class */ (function () {
-    function LanguageServiceDefaultsImpl(languageSettings) {
-        this._onDidChange = new Emitter();
-        this.setLanguageSettings(languageSettings);
-        // default to never kill worker when idle.
-        // reason: when killing worker - schema gets lost. We transmit the schema back to main process when killing
-        // the worker, but in some extreme cases web worker runs out of memory while stringifying the schema.
-        // This stems from the fact that web workers have much more limited memory that the main process.
-        // An alternative solution (not currently implemented) is to just save the schema in the main process whenever calling
-        // setSchema. That way we don't need to stringify the schema on the worker side when killing the web worker.
-        this._workerMaxIdleTime = 0;
-    }
-    Object.defineProperty(LanguageServiceDefaultsImpl.prototype, "onDidChange", {
-        get: function () {
-            return this._onDidChange.event;
-        },
-        enumerable: false,
-        configurable: true
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-kusto version: 6.0.0(d333d5bf2aa3d56b17120ed36803a7fb5bcfb87a)
+ * Released under the MIT license
+ * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
+ *-----------------------------------------------------------------------------*/
+
+/**
+ * Highlights the command that surround cursor location
+ */
+class KustoCommandHighlighter {
+  static ID = 'editor.contrib.kustoCommandHighliter';
+  static CURRENT_COMMAND_HIGHLIGHT = {
+    className: 'selectionHighlight'
+  };
+  disposables = [];
+  decorations = [];
+
+  /**
+   * Register to cursor movement and seleciton events.
+   * @param editor monaco editor instance
+   */
+  constructor(editor) {
+    this.editor = editor;
+    // Note that selection update is triggered not only for selection changes, but also just when no text selection is occuring and cursor just moves around.
+    // This case is counted as a 0-length selection starting and ending on the cursor position.
+    this.editor.onDidChangeCursorSelection(changeEvent => {
+      if (this.editor.getModel().getLanguageId() !== 'kusto') {
+        return;
+      }
+      this.highlightCommandUnderCursor(changeEvent);
     });
-    Object.defineProperty(LanguageServiceDefaultsImpl.prototype, "languageSettings", {
-        get: function () {
-            return this._languageSettings;
-        },
-        enumerable: false,
-        configurable: true
+  }
+  getId() {
+    return KustoCommandHighlighter.ID;
+  }
+  dispose() {
+    this.disposables.forEach(d => d.dispose());
+  }
+  highlightCommandUnderCursor(changeEvent) {
+    // Looks like the user selected a bunch of text. we don't want to highlight the entire command in this case - since highlighting
+    // the text is more helpful.
+    if (!changeEvent.selection.isEmpty()) {
+      this.decorations = this.editor.deltaDecorations(this.decorations, []);
+      return;
+    }
+    const commandRange = this.editor.getCurrentCommandRange(changeEvent.selection.getStartPosition());
+    const decorations = [{
+      range: commandRange,
+      options: KustoCommandHighlighter.CURRENT_COMMAND_HIGHLIGHT
+    }];
+    this.decorations = this.editor.deltaDecorations(this.decorations, decorations);
+  }
+}
+
+class KustoCommandFormatter {
+  actionAdded = false;
+  constructor(editor) {
+    this.editor = editor;
+    // selection also represents no selection - for example the event gets triggered when moving cursor from point
+    // a to point b. in the case start position will equal end position.
+    editor.onDidChangeCursorSelection(changeEvent => {
+      if (this.editor.getModel().getLanguageId() !== 'kusto') {
+        return;
+      }
+      // Theoretically you would expect this code to run only once in onDidCreateEditor.
+      // Turns out that onDidCreateEditor is fired before the IStandaloneEditor is completely created (it is emmited by
+      // the super ctor before the child ctor was able to fully run).
+      // Thus we don't have  a key binding provided yet when onDidCreateEditor is run, which is essential to call addAction.
+      // By adding the action here in onDidChangeCursorSelection we're making sure that the editor has a key binding provider,
+      // and we just need to make sure that this happens only once.
+      if (!this.actionAdded) {
+        editor.addAction({
+          id: 'editor.action.kusto.formatCurrentCommand',
+          label: 'Format Command Under Cursor',
+          keybindings: [monaco.KeyMod.chord(monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyK, monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyF)],
+          run: ed => {
+            editor.trigger('KustoCommandFormatter', 'editor.action.formatSelection', null);
+          },
+          contextMenuGroupId: '1_modification'
+        });
+        this.actionAdded = true;
+      }
     });
-    LanguageServiceDefaultsImpl.prototype.setLanguageSettings = function (options) {
-        this._languageSettings = options || Object.create(null);
-        this._onDidChange.fire(this);
-    };
-    LanguageServiceDefaultsImpl.prototype.setMaximumWorkerIdleTime = function (value) {
-        // doesn't fire an event since no
-        // worker restart is required here
-        this._workerMaxIdleTime = value;
-    };
-    LanguageServiceDefaultsImpl.prototype.getWorkerMaxIdleTime = function () {
-        return this._workerMaxIdleTime;
-    };
-    return LanguageServiceDefaultsImpl;
-}());
-export { LanguageServiceDefaultsImpl };
-var defaultLanguageSettings = {
-    includeControlCommands: true,
-    newlineAfterPipe: true,
-    openSuggestionDialogAfterPreviousSuggestionAccepted: true,
-    useIntellisenseV2: true,
-    useSemanticColorization: true,
-    useTokenColorization: false,
-    enableHover: true,
-    formatter: {
-        indentationSize: 4,
-        pipeOperatorStyle: 'Smart',
-    },
-    syntaxErrorAsMarkDown: {
-        enableSyntaxErrorAsMarkDown: false,
-    },
-    enableQueryWarnings: false,
-    enableQuerySuggestions: false,
-    disabledDiagnosticCodes: [],
-    quickFixCodeActions: ['Change to'],
-    enableQuickFixes: false,
+  }
+}
+
+/**
+ * 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);
+  };
+}
+
+var Emitter = monaco.Emitter;
+monaco.IEvent;
+
+// declare var require: <T>(moduleId: [string], callback: (module: T) => void) => void;
+
+// --- Kusto configuration and defaults ---------
+
+class LanguageServiceDefaultsImpl {
+  _onDidChange = new Emitter();
+  constructor(languageSettings) {
+    this.setLanguageSettings(languageSettings);
+    // default to never kill worker when idle.
+    // reason: when killing worker - schema gets lost. We transmit the schema back to main process when killing
+    // the worker, but in some extreme cases web worker runs out of memory while stringifying the schema.
+    // This stems from the fact that web workers have much more limited memory that the main process.
+    // An alternative solution (not currently implemented) is to just save the schema in the main process whenever calling
+    // setSchema. That way we don't need to stringify the schema on the worker side when killing the web worker.
+    this._workerMaxIdleTime = 0;
+  }
+  get onDidChange() {
+    return this._onDidChange.event;
+  }
+  get languageSettings() {
+    return this._languageSettings;
+  }
+  setLanguageSettings(options) {
+    this._languageSettings = options || Object.create(null);
+    this._onDidChange.fire(this);
+  }
+  setMaximumWorkerIdleTime(value) {
+    // doesn't fire an event since no
+    // worker restart is required here
+    this._workerMaxIdleTime = value;
+  }
+  getWorkerMaxIdleTime() {
+    return this._workerMaxIdleTime;
+  }
+}
+const defaultLanguageSettings = {
+  includeControlCommands: true,
+  newlineAfterPipe: true,
+  openSuggestionDialogAfterPreviousSuggestionAccepted: true,
+  useIntellisenseV2: true,
+  useSemanticColorization: true,
+  useTokenColorization: false,
+  enableHover: true,
+  formatter: {
+    indentationSize: 4,
+    pipeOperatorStyle: 'Smart'
+  },
+  syntaxErrorAsMarkDown: {
+    enableSyntaxErrorAsMarkDown: false
+  },
+  enableQueryWarnings: false,
+  enableQuerySuggestions: false,
+  disabledDiagnosticCodes: [],
+  quickFixCodeActions: ['Change to'],
+  enableQuickFixes: false
 };
 function getKustoWorker() {
-    return new Promise(function (resolve, reject) {
-        withMode(function (mode) {
-            mode.getKustoWorker().then(resolve, reject);
-        });
+  return new Promise((resolve, reject) => {
+    withMode(mode => {
+      mode.getKustoWorker().then(resolve, reject);
     });
+  });
 }
 function withMode(callback) {
-    require(['vs/language/kusto/kustoMode'], callback);
+  import('./kustoMode.js').then(callback);
 }
-export function setupMonacoKusto(monacoInstance) {
-    var kustoDefaults = new LanguageServiceDefaultsImpl(defaultLanguageSettings);
-    function createAPI() {
-        return {
-            kustoDefaults: kustoDefaults,
-            getKustoWorker: getKustoWorker,
-        };
+function setupMonacoKusto(monacoInstance) {
+  const kustoDefaults = new LanguageServiceDefaultsImpl(defaultLanguageSettings);
+  function createAPI() {
+    return {
+      kustoDefaults,
+      getKustoWorker
+    };
+  }
+  monacoInstance.languages.kusto = createAPI();
+  monacoInstance.languages.onLanguage('kusto', () => {
+    withMode(mode => mode.setupMode(kustoDefaults, monacoInstance));
+  });
+  monacoInstance.languages.register({
+    id: 'kusto',
+    extensions: ['.csl', '.kql']
+  });
+  monacoInstance.editor.defineTheme('kusto-light', {
+    base: 'vs',
+    inherit: true,
+    rules: [{
+      token: 'comment',
+      foreground: '008000'
+    },
+    // CommentToken Green
+    {
+      token: 'variable.predefined',
+      foreground: '800080'
+    },
+    // CalculatedColumnToken Purple
+    {
+      token: 'function',
+      foreground: '0000FF'
+    },
+    // FunctionNameToken Blue
+    {
+      token: 'operator.sql',
+      foreground: 'CC3700'
+    },
+    // _WAS_ OperatorToken OrangeRed, but wasn't accessible.
+    {
+      token: 'string',
+      foreground: 'B22222'
+    },
+    // StringLiteralToken Firebrick
+    {
+      token: 'operator.scss',
+      foreground: '0000FF'
+    },
+    // SubOperatorToken Blue
+    {
+      token: 'variable',
+      foreground: 'C71585'
+    },
+    // TableColumnToken MediumVioletRed
+    {
+      token: 'variable.parameter',
+      foreground: '9932CC'
+    },
+    // TableToken DarkOrchid
+    {
+      token: '',
+      foreground: '000000'
+    },
+    // UnknownToken, PlainTextToken  Black
+    {
+      token: 'type',
+      foreground: '0000FF'
+    },
+    // DataTypeToken Blue
+    {
+      token: 'tag',
+      foreground: '0000FF'
+    },
+    // ControlCommandToken Blue
+    {
+      token: 'annotation',
+      foreground: '2B91AF'
+    },
+    // QueryParametersToken FF2B91AF
+    {
+      token: 'keyword',
+      foreground: '0000FF'
+    },
+    // CslCommandToken, PluginToken Blue
+    {
+      token: 'number',
+      foreground: '191970'
+    },
+    // LetVariablesToken MidnightBlue
+    {
+      token: 'annotation',
+      foreground: '9400D3'
+    },
+    // ClientDirectiveToken DarkViolet
+    {
+      token: 'invalid',
+      background: 'cd3131'
+    }],
+    colors: {}
+  });
+  monacoInstance.editor.defineTheme('kusto-dark', {
+    base: 'vs-dark',
+    inherit: true,
+    rules: [{
+      token: 'comment',
+      foreground: '608B4E'
+    },
+    // CommentToken Green
+    {
+      token: 'variable.predefined',
+      foreground: '4ec9b0'
+    },
+    // CalculatedColumnToken Purple
+    {
+      token: 'function',
+      foreground: 'dcdcaa'
+    },
+    // FunctionNameToken Blue
+    {
+      token: 'operator.sql',
+      foreground: '9cdcfe'
+    },
+    // OperatorToken OrangeRed
+    {
+      token: 'string',
+      foreground: 'ce9178'
+    },
+    // StringLiteralToken Firebrick
+    {
+      token: 'operator.scss',
+      foreground: '569cd6'
+    },
+    // SubOperatorToken Blue
+    {
+      token: 'variable',
+      foreground: '4ec9b0'
+    },
+    // TableColumnToken MediumVioletRed
+    {
+      token: 'variable.parameter',
+      foreground: 'c586c0'
+    },
+    // TableToken DarkOrchid
+    {
+      token: '',
+      foreground: 'd4d4d4'
+    },
+    // UnknownToken, PlainTextToken  Black
+    {
+      token: 'type',
+      foreground: '569cd6'
+    },
+    // DataTypeToken Blue
+    {
+      token: 'tag',
+      foreground: '569cd6'
+    },
+    // ControlCommandToken Blue
+    {
+      token: 'annotation',
+      foreground: '9cdcfe'
+    },
+    // QueryParametersToken FF2B91AF
+    {
+      token: 'keyword',
+      foreground: '569cd6'
+    },
+    // CslCommandToken, PluginToken Blue
+    {
+      token: 'number',
+      foreground: 'd7ba7d'
+    },
+    // LetVariablesToken MidnightBlue
+    {
+      token: 'annotation',
+      foreground: 'b5cea8'
+    },
+    // ClientDirectiveToken DarkViolet
+    {
+      token: 'invalid',
+      background: 'cd3131'
+    }],
+    colors: {
+      // see: https://code.visualstudio.com/api/references/theme-color#editor-widget-colors
     }
-    monacoInstance.languages.kusto = createAPI();
-    monacoInstance.languages.onLanguage('kusto', function () {
-        withMode(function (mode) { return mode.setupMode(kustoDefaults, monacoInstance); });
-    });
-    monacoInstance.languages.register({
-        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 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;
-    monacoInstance.editor.defineTheme('kusto-light', {
-        base: 'vs',
-        inherit: true,
-        rules: [
-            { token: 'comment', foreground: '008000' },
-            { token: 'variable.predefined', foreground: '800080' },
-            { token: 'function', foreground: '0000FF' },
-            { token: 'operator.sql', foreground: 'CC3700' },
-            { token: 'string', foreground: 'B22222' },
-            { token: 'operator.scss', foreground: '0000FF' },
-            { token: 'variable', foreground: 'C71585' },
-            { token: 'variable.parameter', foreground: '9932CC' },
-            { token: '', foreground: '000000' },
-            { token: 'type', foreground: '0000FF' },
-            { token: 'tag', foreground: '0000FF' },
-            { token: 'annotation', foreground: '2B91AF' },
-            { token: 'keyword', foreground: '0000FF' },
-            { token: 'number', foreground: '191970' },
-            { token: 'annotation', foreground: '9400D3' },
-            { token: 'invalid', background: 'cd3131' },
-        ],
-        colors: {},
-    });
-    monacoInstance.editor.defineTheme('kusto-dark', {
-        base: 'vs-dark',
-        inherit: true,
-        rules: [
-            { token: 'comment', foreground: '608B4E' },
-            { token: 'variable.predefined', foreground: '4ec9b0' },
-            { token: 'function', foreground: 'dcdcaa' },
-            { token: 'operator.sql', foreground: '9cdcfe' },
-            { token: 'string', foreground: 'ce9178' },
-            { token: 'operator.scss', foreground: '569cd6' },
-            { token: 'variable', foreground: '4ec9b0' },
-            { token: 'variable.parameter', foreground: 'c586c0' },
-            { token: '', foreground: 'd4d4d4' },
-            { token: 'type', foreground: '569cd6' },
-            { token: 'tag', foreground: '569cd6' },
-            { token: 'annotation', foreground: '9cdcfe' },
-            { token: 'keyword', foreground: '569cd6' },
-            { token: 'number', foreground: 'd7ba7d' },
-            { token: 'annotation', foreground: 'b5cea8' },
-            { token: 'invalid', background: 'cd3131' },
-        ],
-        colors: {
-        // see: https://code.visualstudio.com/api/references/theme-color#editor-widget-colors
-        },
-    });
-    monacoInstance.editor.defineTheme('kusto-dark2', {
-        base: 'vs-dark',
-        inherit: true,
-        rules: [],
-        colors: {
-            // see: https://code.visualstudio.com/api/references/theme-color#editor-widget-colors
-            'editor.background': '#1B1A19',
-            'editorSuggestWidget.selectedBackground': '#004E8C',
-        },
-    });
-    // 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
-    monacoInstance.editor.onDidCreateEditor(function (editor) {
-        // hook up extension methods to editor.
-        extend(editor);
-        commandHighlighter = new KustoCommandHighlighter(editor);
-        if (isStandaloneCodeEditor(editor)) {
-            commandFormatter = new KustoCommandFormatter(editor);
+  });
+  monacoInstance.editor.defineTheme('kusto-dark2', {
+    base: 'vs-dark',
+    inherit: true,
+    rules: [],
+    colors: {
+      // see: https://code.visualstudio.com/api/references/theme-color#editor-widget-colors
+      'editor.background': '#1B1A19',
+      // gray 200
+      'editorSuggestWidget.selectedBackground': '#004E8C'
+    }
+  });
+
+  // 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
+  monacoInstance.editor.onDidCreateEditor(editor => {
+    // hook up extension methods to editor.
+    extend(editor);
+    new KustoCommandHighlighter(editor);
+    if (isStandaloneCodeEditor(editor)) {
+      new KustoCommandFormatter(editor);
+    }
+    triggerSuggestDialogWhenCompletionItemSelected(editor);
+  });
+  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.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) {
+          return;
         }
-        triggerSuggestDialogWhenCompletionItemSelected(editor);
+        event.selection;
+        // OK so now we in a situation where we know a suggestion was selected and we want to trigger another one.
+        // the only problem is that the suggestion widget itself listens to this same event in order to know it needs to close.
+        // The only problem is that we're ahead in line, so we're triggering a suggest operation that will be shut down once
+        // the next callback is called. This is why we're waiting here - to let all the callbacks run synchronously and be
+        // the 'last' subscriber to run. Granted this is hacky, but until monaco provides a specific event for suggestions,
+        // this is the best we have.
+        setTimeout(() => editor.trigger('monaco-kusto', 'editor.action.triggerSuggest', {}), 10);
+      }
     });
-    function triggerSuggestDialogWhenCompletionItemSelected(editor) {
-        editor.onDidChangeCursorSelection(function (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.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) {
-                    return;
-                }
-                event.selection;
-                // OK so now we in a situation where we know a suggestion was selected and we want to trigger another one.
-                // the only problem is that the suggestion widget itself listens to this same event in order to know it needs to close.
-                // The only problem is that we're ahead in line, so we're triggering a suggest operation that will be shut down once
-                // the next callback is called. This is why we're waiting here - to let all the callbacks run synchronously and be
-                // the 'last' subscriber to run. Granted this is hacky, but until monaco provides a specific event for suggestions,
-                // this is the best we have.
-                setTimeout(function () { return editor.trigger('monaco-kusto', 'editor.action.triggerSuggest', {}); }, 10);
-            }
-        });
-    }
+  }
 }
 function isStandaloneCodeEditor(editor) {
-    return editor.addAction !== undefined;
+  return editor.addAction !== undefined;
 }
+
 // --- Registration to monaco editor ---
 if (monaco.editor) {
-    setupMonacoKusto(monaco);
+  setupMonacoKusto(monaco);
 }
+
+export { LanguageServiceDefaultsImpl, setupMonacoKusto };

package/release/esm/workerManager.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="../monaco" />
+/// <reference types="monaco-editor-core/monaco" />
+import type { LanguageServiceDefaultsImpl } from './monaco.contribution';
+import type { KustoWorker } from './kustoWorker';
+type Uri = monaco.Uri;
+export declare class WorkerManager {
+    private _monacoInstance;
+    private _storedState;
+    private _defaults;
+    private _idleCheckInterval;
+    private _lastUsedTime;
+    private _configChangeListener;
+    private _worker;
+    private _client;
+    constructor(_monacoInstance: typeof monaco, defaults: LanguageServiceDefaultsImpl);
+    private _stopWorker;
+    private _saveStateAndStopWorker;
+    dispose(): void;
+    private _checkIfIdle;
+    private _getClient;
+    getLanguageServiceWorker(...resources: Uri[]): Promise<KustoWorker>;
+}
+export {};

package/release/min/commandFormatter.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="monaco-editor-core/monaco" />
+export default class KustoCommandFormatter {
+    private editor;
+    private actionAdded;
+    constructor(editor: monaco.editor.IStandaloneCodeEditor);
+}