@kusto/monaco-kusto 6.1.2 → 7.0.0

package/release/esm/monaco.contribution.js

@@ -1,11 +1,59 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 6.1.2(4c9ec21ad04b49f9f8e8a8f7fe773fe9a8b47334)
+ * monaco-kusto version: 7.0.0(f23f8fe8dd705f8413d0d094c76eb0af2131aace)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
 
-import 'monaco-editor';
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+
+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
@@ -46,7 +94,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
@@ -66,7 +114,7 @@ class KustoCommandFormatter {
         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
+      // 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,
@@ -87,52 +135,6 @@ 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);
-  };
-}
-
-// Import monaco-editor to ensure "monaco" global is available before any other
-
 // --- Kusto configuration and defaults ---------
 
 class LanguageServiceDefaultsImpl {
@@ -200,244 +202,236 @@ function getKustoWorker() {
 function withMode(callback) {
   import('./kustoMode.js').then(callback);
 }
-function setupMonacoKusto(monacoInstance) {
-  const kustoDefaults = new LanguageServiceDefaultsImpl(defaultLanguageSettings);
-  function createAPI() {
-    return {
-      kustoDefaults,
-      getKustoWorker
-    };
+const kustoDefaults = new LanguageServiceDefaultsImpl(defaultLanguageSettings);
+monaco.languages.onLanguage('kusto', () => {
+  withMode(mode => mode.setupMode(kustoDefaults, monaco));
+});
+monaco.languages.register({
+  id: 'kusto',
+  extensions: ['.csl', '.kql']
+});
+monaco.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: {}
+});
+monaco.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', () => {
-    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.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'
-    }
-  });
+});
+monaco.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);
+// 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);
+  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;
+      }
+      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);
     }
-    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;
-        }
-        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;
 }
+const globalApi = {
+  kustoDefaults,
+  getKustoWorker,
+  getCurrentCommandRange
+};
+monaco.languages.kusto = globalApi;
 
-// --- Registration to monaco editor ---
-if (monaco.editor) {
-  setupMonacoKusto(monaco);
-}
-
-export { LanguageServiceDefaultsImpl, setupMonacoKusto };
+export { getCurrentCommandRange, getKustoWorker, kustoDefaults };