@kusto/monaco-kusto 12.0.8 → 12.0.10

package/release/esm/monaco.contribution.js

@@ -1,197 +1,500 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
+/*!-----------------------------------------------------------------------------
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * monaco-kusto version: 12.0.10(45043a1eff35e1151edde6f70c24b55565dda115)
+ * 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 KustoCommandHighlighter from './commandHighlighter';
-import KustoCommandFormatter from './commandFormatter';
-import { extend } from './extendedEditor';
-import { themes } from './syntaxHighlighting/themes';
-import { LANGUAGE_ID } from './globals';
-import { getCslTypeNameFromClrType, getCallName, getExpression, getInputParametersAsCslString, getEntityDataTypeFromCslType, } from './languageServiceManager/schema';
-import { getRangeHtml } from './extendedGlobalApi';
-export * from './languageServiceManager/schema';
-export * from './languageServiceManager/renderInfo';
-export * from './languageServiceManager/settings';
-export * from './types';
-export * from './extendedGlobalApi';
-// --- Kusto configuration and defaults ---------
-var LanguageServiceDefaultsImpl = /** @class */ (function () {
-    function LanguageServiceDefaultsImpl(languageSettings) {
-        this._onDidChange = new monaco.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;
+import { editor } from 'monaco-editor/esm/vs/editor/editor.api';
+import { T as Token, L as LANGUAGE_ID } from './globals-60173baa.js';
+import { g as getCslTypeNameFromClrType, a as getCallName, b as getExpression, c as getInputParametersAsCslString, d as getEntityDataTypeFromCslType } from './schema-e459243d.js';
+export { s as showSchema } from './schema-e459243d.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;
     }
-    Object.defineProperty(LanguageServiceDefaultsImpl.prototype, "onDidChange", {
-        get: function () {
-            return this._onDidChange.event;
-        },
-        enumerable: false,
-        configurable: true
+  }
+  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.kustoCommandHighlighter';
+  static CURRENT_COMMAND_HIGHLIGHT = {
+    className: 'selectionHighlight'
+  };
+  disposables = [];
+  decorations = [];
+
+  /**
+   * Register to cursor movement and selection 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 occurring 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 = getCurrentCommandRange(this.editor, 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 emitted 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;
-}());
-var defaultLanguageSettings = {
-    includeControlCommands: true,
-    newlineAfterPipe: true,
-    openSuggestionDialogAfterPreviousSuggestionAccepted: true,
-    enableHover: true,
-    formatter: {
-        indentationSize: 4,
-        pipeOperatorStyle: 'Smart',
-    },
-    syntaxErrorAsMarkDown: {
-        enableSyntaxErrorAsMarkDown: false,
-    },
-    enableQueryWarnings: false,
-    enableQuerySuggestions: false,
-    disabledDiagnosticCodes: [],
-    quickFixCodeActions: ['Change to', 'FixAll'],
-    enableQuickFixes: false,
-    completionOptions: { includeExtendedSyntax: false },
+  }
+}
+
+let ThemeName = /*#__PURE__*/function (ThemeName) {
+  ThemeName["light"] = "kusto-light";
+  ThemeName["dark"] = "kusto-dark";
+  return ThemeName;
+}({});
+const colors = {
+  white: '#DCDCDC',
+  lightGoldenrodYellow: '#FAFAD2',
+  softGold: '#D7BA7D',
+  paleChestnut: '#D69D85',
+  paleVioletRed: '#DB7093',
+  firebrick: '#B22222',
+  orangeRed: '#FF4500',
+  mediumVioletRed: '#C71585',
+  magenta: '#FF00FF',
+  // for debugging
+  darkOrchid: '#9932CC',
+  darkViolet: '#9400D3',
+  midnightBlue: '#191970',
+  blue: '#0000FF',
+  blueSapphire: '#004E8C',
+  tealBlue: '#2B91AF',
+  skyBlue: '#569CD6',
+  lightSkyBlue: '#92CAF4',
+  mediumTurquoise: '#4EC9B0',
+  oliveDrab: '#608B4E',
+  green: '#008000',
+  jetBlack: '#1B1A19',
+  black: '#000000'
 };
-export function getKustoWorker() {
-    return new Promise(function (resolve, reject) {
-        withMode(function (mode) {
-            mode.getKustoWorker().then(resolve, reject);
-        });
+const light = {
+  base: 'vs',
+  inherit: true,
+  rules: [{
+    token: '',
+    foreground: colors.black
+  }, {
+    token: Token.PlainText,
+    foreground: colors.black
+  }, {
+    token: Token.Comment,
+    foreground: colors.green
+  }, {
+    token: Token.Punctuation,
+    foreground: colors.black
+  }, {
+    token: Token.Directive,
+    foreground: colors.darkViolet
+  }, {
+    token: Token.Literal,
+    foreground: colors.black
+  }, {
+    token: Token.StringLiteral,
+    foreground: colors.firebrick
+  }, {
+    token: Token.Type,
+    foreground: colors.blue
+  }, {
+    token: Token.Column,
+    foreground: colors.mediumVioletRed
+  }, {
+    token: Token.Table,
+    foreground: colors.darkOrchid
+  }, {
+    token: Token.Database,
+    foreground: colors.darkOrchid
+  }, {
+    token: Token.Function,
+    foreground: colors.blue
+  }, {
+    token: Token.Parameter,
+    foreground: colors.midnightBlue
+  }, {
+    token: Token.Variable,
+    foreground: colors.midnightBlue
+  }, {
+    token: Token.Identifier,
+    foreground: colors.black
+  }, {
+    token: Token.ClientParameter,
+    foreground: colors.tealBlue
+  }, {
+    token: Token.QueryParameter,
+    foreground: colors.tealBlue
+  }, {
+    token: Token.ScalarParameter,
+    foreground: colors.blue
+  }, {
+    token: Token.MathOperator,
+    foreground: colors.black
+  }, {
+    token: Token.QueryOperator,
+    foreground: colors.orangeRed
+  }, {
+    token: Token.Command,
+    foreground: colors.blue
+  }, {
+    token: Token.Keyword,
+    foreground: colors.blue
+  }, {
+    token: Token.MaterializedView,
+    foreground: colors.darkOrchid
+  }, {
+    token: Token.SchemaMember,
+    foreground: colors.black
+  }, {
+    token: Token.SignatureParameter,
+    foreground: colors.black
+  }, {
+    token: Token.Option,
+    foreground: colors.black
+  }],
+  colors: {}
+};
+const dark = {
+  base: 'vs-dark',
+  inherit: true,
+  rules: [{
+    token: '',
+    foreground: colors.white
+  }, {
+    token: Token.PlainText,
+    foreground: colors.white
+  }, {
+    token: Token.Comment,
+    foreground: colors.oliveDrab
+  }, {
+    token: Token.Punctuation,
+    foreground: colors.white
+  }, {
+    token: Token.Directive,
+    foreground: colors.lightGoldenrodYellow
+  }, {
+    token: Token.Literal,
+    foreground: colors.white
+  }, {
+    token: Token.StringLiteral,
+    foreground: colors.paleChestnut
+  }, {
+    token: Token.Type,
+    foreground: colors.skyBlue
+  }, {
+    token: Token.Column,
+    foreground: colors.paleVioletRed
+  }, {
+    token: Token.Table,
+    foreground: colors.softGold
+  }, {
+    token: Token.Database,
+    foreground: colors.softGold
+  }, {
+    token: Token.Function,
+    foreground: colors.skyBlue
+  }, {
+    token: Token.Parameter,
+    foreground: colors.lightSkyBlue
+  }, {
+    token: Token.Variable,
+    foreground: colors.lightSkyBlue
+  }, {
+    token: Token.Identifier,
+    foreground: colors.white
+  }, {
+    token: Token.ClientParameter,
+    foreground: colors.tealBlue
+  }, {
+    token: Token.QueryParameter,
+    foreground: colors.tealBlue
+  }, {
+    token: Token.ScalarParameter,
+    foreground: colors.skyBlue
+  }, {
+    token: Token.MathOperator,
+    foreground: colors.white
+  }, {
+    token: Token.QueryOperator,
+    foreground: colors.mediumTurquoise
+  }, {
+    token: Token.Command,
+    foreground: colors.skyBlue
+  }, {
+    token: Token.Keyword,
+    foreground: colors.skyBlue
+  }, {
+    token: Token.MaterializedView,
+    foreground: colors.softGold
+  }, {
+    token: Token.SchemaMember,
+    foreground: colors.white
+  }, {
+    token: Token.SignatureParameter,
+    foreground: colors.white
+  }, {
+    token: Token.Option,
+    foreground: colors.white
+  }],
+  colors: {
+    'editor.background': colors.jetBlack,
+    'editorSuggestWidget.selectedBackground': colors.blueSapphire
+  }
+};
+const themes = [{
+  name: ThemeName.light,
+  data: light
+}, {
+  name: ThemeName.dark,
+  data: dark
+}];
+
+function getRangeHtml(model, range) {
+  const {
+    startLineNumber,
+    endLineNumber,
+    endColumn
+  } = range;
+  const isLastLineEmpty = endColumn === 1;
+  const actualLastLine = isLastLineEmpty ? endLineNumber - 1 : endLineNumber;
+  const totalLines = actualLastLine - startLineNumber + 1;
+  const colorizedLines = new Array(totalLines).fill(undefined).map((_, index) => editor.colorizeModelLine(model, startLineNumber + index));
+  return colorizedLines.join('<br/>');
+}
+
+// --- Kusto configuration and defaults ---------
+
+class LanguageServiceDefaultsImpl {
+  _onDidChange = new monaco.Emitter();
+
+  // in milliseconds. For example - this is 2 minutes 2 * 60 * 1000
+
+  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,
+  enableHover: true,
+  formatter: {
+    indentationSize: 4,
+    pipeOperatorStyle: 'Smart'
+  },
+  syntaxErrorAsMarkDown: {
+    enableSyntaxErrorAsMarkDown: false
+  },
+  enableQueryWarnings: false,
+  enableQuerySuggestions: false,
+  disabledDiagnosticCodes: [],
+  quickFixCodeActions: ['Change to', 'FixAll'],
+  enableQuickFixes: false,
+  completionOptions: {
+    includeExtendedSyntax: false
+  }
+};
+function getKustoWorker() {
+  return new Promise((resolve, reject) => {
+    withMode(mode => {
+      mode.getKustoWorker().then(resolve, reject);
     });
+  });
 }
 function withMode(callback) {
-    return import('./kustoMode').then(callback);
+  return import('./kustoMode.js').then(callback);
 }
-export var kustoDefaults = new LanguageServiceDefaultsImpl(defaultLanguageSettings);
-var disposable;
-monaco.languages.onLanguage('kusto', function () { return __awaiter(void 0, void 0, void 0, function () {
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0: return [4 /*yield*/, withMode(function (mode) { return mode.setupMode(kustoDefaults, monaco); })];
-            case 1:
-                disposable = _a.sent();
-                return [2 /*return*/];
-        }
-    });
-}); });
-monaco.editor.onWillDisposeModel(function (model) {
-    disposable.dispose();
+const kustoDefaults = new LanguageServiceDefaultsImpl(defaultLanguageSettings);
+let disposable;
+monaco.languages.onLanguage('kusto', async () => {
+  disposable = await withMode(mode => mode.setupMode(kustoDefaults, monaco));
 });
-monaco.languages.register({
-    id: LANGUAGE_ID,
-    extensions: ['.csl', '.kql'],
+monaco.editor.onWillDisposeModel(model => {
+  disposable.dispose();
 });
-themes.forEach(function (_a) {
-    var name = _a.name, data = _a.data;
-    return monaco.editor.defineTheme(name, data);
+monaco.languages.register({
+  id: LANGUAGE_ID,
+  extensions: ['.csl', '.kql']
 });
+themes.forEach(({
+  name,
+  data
+}) => monaco.editor.defineTheme(name, data));
+
 // 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(function (editor) {
-    var _a;
-    if ((_a = window.MonacoEnvironment) === null || _a === void 0 ? void 0 : _a.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);
-    }
-    triggerSuggestDialogWhenCompletionItemSelected(editor);
+monaco.editor.onDidCreateEditor(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);
+  }
+  triggerSuggestDialogWhenCompletionItemSelected(editor);
 });
 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);
-        }
-    });
+  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;
+      }
+      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 isStandaloneCodeEditor(editor) {
-    return editor.addAction !== undefined;
+  return editor.addAction !== undefined;
 }
-var globalApi = {
-    getCslTypeNameFromClrType: getCslTypeNameFromClrType,
-    getCallName: getCallName,
-    getExpression: getExpression,
-    getInputParametersAsCslString: getInputParametersAsCslString,
-    getEntityDataTypeFromCslType: getEntityDataTypeFromCslType,
-    kustoDefaults: kustoDefaults,
-    getKustoWorker: getKustoWorker,
-    getRangeHtml: getRangeHtml,
+const globalApi = {
+  getCslTypeNameFromClrType,
+  getCallName,
+  getExpression,
+  getInputParametersAsCslString,
+  getEntityDataTypeFromCslType,
+  kustoDefaults,
+  getKustoWorker,
+  getRangeHtml
 };
 monaco.languages.kusto = globalApi;
-// I am not sure why this is needed, but it is. Without it, parcel production build removes this function.
-export { getRangeHtml };
+
+export { getCallName, getCslTypeNameFromClrType, getEntityDataTypeFromCslType, getExpression, getInputParametersAsCslString, getKustoWorker, getRangeHtml, kustoDefaults };