@kusto/monaco-kusto 6.2.0 → 7.0.0

package/release/esm/monaco.contribution.js

@@ -1,11 +1,59 @@
 /*!-----------------------------------------------------------------------------
  * Copyright (c) Microsoft Corporation. All rights reserved.
- * monaco-kusto version: 6.2.0(8e26147bc7c3b5a7a3bc6ee55311dfa0b612c10c)
+ * monaco-kusto version: 7.0.0(f23f8fe8dd705f8413d0d094c76eb0af2131aace)
  * Released under the MIT license
  * https://https://github.com/Azure/monaco-kusto/blob/master/README.md
  *-----------------------------------------------------------------------------*/
 
-import * as monaco$1 from 'monaco-editor/esm/vs/editor/editor.api';
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+
+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
@@ -87,54 +135,10 @@ class KustoCommandFormatter {
   }
 }
 
-/**
- * Extending ICode editor to contain additional kusto-specific methods.
- * note that the extend method needs to be called at least once to take affect, otherwise this here code is useless.
- */
-function extend(editor) {
-  const proto = Object.getPrototypeOf(editor);
-  proto.getCurrentCommandRange = function (cursorPosition) {
-    const zeroBasedCursorLineNumber = cursorPosition.lineNumber - 1;
-    const lines = this.getModel().getLinesContent();
-    let commandOrdinal = 0;
-    const linesWithCommandOrdinal = [];
-    for (let lineNumber = 0; lineNumber < lines.length; lineNumber++) {
-      let isEmptyLine = lines[lineNumber].trim() === '';
-      if (isEmptyLine) {
-        // increase commandCounter - we'll be starting a new command.
-        linesWithCommandOrdinal.push({
-          commandOrdinal: commandOrdinal++,
-          lineNumber
-        });
-      } else {
-        linesWithCommandOrdinal.push({
-          commandOrdinal: commandOrdinal,
-          lineNumber
-        });
-      }
-
-      // No need to keep scanning if we're past our line and we've seen an empty line.
-      if (lineNumber > zeroBasedCursorLineNumber && commandOrdinal > linesWithCommandOrdinal[zeroBasedCursorLineNumber].commandOrdinal) {
-        break;
-      }
-    }
-    const currentCommandOrdinal = linesWithCommandOrdinal[zeroBasedCursorLineNumber].commandOrdinal;
-    const currentCommandLines = linesWithCommandOrdinal.filter(line => line.commandOrdinal === currentCommandOrdinal);
-    const currentCommandStartLine = currentCommandLines[0].lineNumber + 1;
-    const currentCommandEndLine = currentCommandLines[currentCommandLines.length - 1].lineNumber + 1;
-
-    // End-column of 1 means no characters will be highlighted - since columns are 1-based in monaco apis.
-    // Start-column of 1 and End column of 2 means 1st character is selected.
-    // Thus if a line has n column and we need to provide n+1 so that the entire line will be highlighted.
-    const commandEndColumn = lines[currentCommandEndLine - 1].length + 1;
-    return new monaco.Range(currentCommandStartLine, 1, currentCommandEndLine, commandEndColumn);
-  };
-}
-
 // --- Kusto configuration and defaults ---------
 
 class LanguageServiceDefaultsImpl {
-  _onDidChange = new monaco$1.Emitter();
+  _onDidChange = new monaco.Emitter();
 
   // in milliseconds. For example - this is 2 minutes 2 * 60 * 1000
 
@@ -199,14 +203,14 @@ function withMode(callback) {
   import('./kustoMode.js').then(callback);
 }
 const kustoDefaults = new LanguageServiceDefaultsImpl(defaultLanguageSettings);
-monaco$1.languages.onLanguage('kusto', () => {
-  withMode(mode => mode.setupMode(kustoDefaults, monaco$1));
+monaco.languages.onLanguage('kusto', () => {
+  withMode(mode => mode.setupMode(kustoDefaults, monaco));
 });
-monaco$1.languages.register({
+monaco.languages.register({
   id: 'kusto',
   extensions: ['.csl', '.kql']
 });
-monaco$1.editor.defineTheme('kusto-light', {
+monaco.editor.defineTheme('kusto-light', {
   base: 'vs',
   inherit: true,
   rules: [{
@@ -290,7 +294,7 @@ monaco$1.editor.defineTheme('kusto-light', {
   }],
   colors: {}
 });
-monaco$1.editor.defineTheme('kusto-dark', {
+monaco.editor.defineTheme('kusto-dark', {
   base: 'vs-dark',
   inherit: true,
   rules: [{
@@ -376,7 +380,7 @@ monaco$1.editor.defineTheme('kusto-dark', {
     // see: https://code.visualstudio.com/api/references/theme-color#editor-widget-colors
   }
 });
-monaco$1.editor.defineTheme('kusto-dark2', {
+monaco.editor.defineTheme('kusto-dark2', {
   base: 'vs-dark',
   inherit: true,
   rules: [],
@@ -390,7 +394,7 @@ monaco$1.editor.defineTheme('kusto-dark2', {
 
 // Initialize kusto specific language features that don't currently have a natural way to extend using existing apis.
 // Most other language features are initialized in kustoMode.ts
-monaco$1.editor.onDidCreateEditor(editor => {
+monaco.editor.onDidCreateEditor(editor => {
   // hook up extension methods to editor.
   extend(editor);
   new KustoCommandHighlighter(editor);
@@ -403,7 +407,7 @@ function triggerSuggestDialogWhenCompletionItemSelected(editor) {
   editor.onDidChangeCursorSelection(event => {
     // checking the condition inside the event makes sure we will stay up to date when kusto configuration changes at runtime.
     if (kustoDefaults && kustoDefaults.languageSettings && kustoDefaults.languageSettings.openSuggestionDialogAfterPreviousSuggestionAccepted) {
-      var didAcceptSuggestion = event.source === 'snippet' && event.reason === monaco$1.editor.CursorChangeReason.NotSet;
+      var didAcceptSuggestion = event.source === 'snippet' && event.reason === monaco.editor.CursorChangeReason.NotSet;
       // If the word at the current position is not null - meaning we did not add a space after completion.
       // In this case we don't want to activate the eager mode, since it will display the current selected word..
       if (!didAcceptSuggestion || editor.getModel().getWordAtPosition(event.selection.getPosition()) !== null) {
@@ -423,9 +427,11 @@ function triggerSuggestDialogWhenCompletionItemSelected(editor) {
 function isStandaloneCodeEditor(editor) {
   return editor.addAction !== undefined;
 }
-monaco$1.languages.kusto = {
+const globalApi = {
   kustoDefaults,
-  getKustoWorker
+  getKustoWorker,
+  getCurrentCommandRange
 };
+monaco.languages.kusto = globalApi;
 
-export { LanguageServiceDefaultsImpl, getKustoWorker, kustoDefaults };
+export { getCurrentCommandRange, getKustoWorker, kustoDefaults };

package/release/esm/types.d.ts

@@ -0,0 +1,261 @@
+import type * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import type * as ls from 'vscode-languageserver-types';
+export interface LanguageSettings {
+    includeControlCommands?: boolean;
+    newlineAfterPipe?: boolean;
+    syntaxErrorAsMarkDown?: SyntaxErrorAsMarkDownOptions;
+    openSuggestionDialogAfterPreviousSuggestionAccepted?: boolean;
+    useIntellisenseV2?: boolean;
+    useSemanticColorization?: boolean;
+    useTokenColorization?: boolean;
+    disabledCompletionItems?: string[];
+    onDidProvideCompletionItems?: OnDidProvideCompletionItems;
+    enableHover?: boolean;
+    formatter?: FormatterOptions;
+    enableQueryWarnings?: boolean;
+    enableQuerySuggestions?: boolean;
+    disabledDiagnosticCodes?: string[];
+    quickFixCodeActions?: QuickFixCodeActionOptions[];
+    enableQuickFixes?: boolean;
+}
+export interface SyntaxErrorAsMarkDownOptions {
+    header?: string;
+    icon?: string;
+    enableSyntaxErrorAsMarkDown?: boolean;
+}
+export type QuickFixCodeActionOptions = 'Extract Expression' | 'Extract Function' | 'Change to' | 'FixAll';
+export interface FormatterOptions {
+    indentationSize?: number;
+    pipeOperatorStyle?: FormatterPlacementStyle;
+}
+export type FormatterPlacementStyle = 'None' | 'NewLine' | 'Smart';
+export interface LanguageServiceDefaults {
+    readonly onDidChange: monaco.IEvent<LanguageServiceDefaults>;
+    readonly languageSettings: LanguageSettings;
+    /**
+     * Configure language service settings.
+     */
+    setLanguageSettings(options: LanguageSettings): void;
+    /**
+     * Configure when the worker shuts down. By default that is 2mins.
+     *
+     * @param value The maximum idle time in milliseconds. Values less than one
+     * mean never shut down.
+     */
+    setMaximumWorkerIdleTime(value: number): void;
+    getWorkerMaxIdleTime(): number;
+}
+export interface KustoWorker {
+    setSchema(schema: Schema): Promise<void>;
+    setSchemaFromShowSchema(schema: any, clusterConnectionString: string, databaseInContextName: string, globalScalarParameters: ScalarParameter[], globalTabularParameters: TabularParameter[]): Promise<void>;
+    normalizeSchema(schema: any, clusterConnectionString: string, databaseInContextName: string): Promise<EngineSchema>;
+    getCommandInContext(uri: string, cursorOffset: number): Promise<string | null>;
+    getCommandAndLocationInContext(uri: string, offset: number): Promise<{
+        text: string;
+        range: monaco.IRange;
+    } | null>;
+    getCommandsInDocument(uri: string): Promise<{
+        absoluteStart: number;
+        absoluteEnd: number;
+        text: string;
+    }[]>;
+    getClientDirective(text: string): Promise<{
+        isClientDirective: boolean;
+        directiveWithoutLeadingComments: string;
+    }>;
+    getAdminCommand(text: string): Promise<{
+        isAdminCommand: boolean;
+        adminCommandWithoutLeadingComments: string;
+    }>;
+    /**
+     * Get all declared query parameters declared in current block if any.
+     */
+    getQueryParams(uri: string, cursorOffset: number): Promise<{
+        name: string;
+        type: string;
+    }[]>;
+    /**
+     * Get all the ambient parameters defined in global scope.
+     * Ambient parameters are parameters that are not defined in the syntax such as in a query parameter declaration.
+     * These are parameters that are injected from outside, usually by a UX application that would like to offer
+     * the user intellisense for a symbol, without forcing them to write a query declaration statement.
+     * Usually  the same application injects the query declaration statement and the parameter values when
+     * executing the query (so it will execute correctly)
+     */
+    getGlobalParams(uri: string): Promise<{
+        name: string;
+        type: string;
+    }[]>;
+    /**
+     * Get the global parameters that are actually being referenced in query.
+     * This is different from getQueryParams that will return the parameters declare using a query declaration
+     * statement.
+     * It is also different from getGlobalParams that will return all global parameters whether used or not.
+     */
+    getReferencedGlobalParams(uri: string, cursorOffset?: number): Promise<{
+        name: string;
+        type: string;
+    }[]>;
+    getReferencedSymbols(document: ls.TextDocument, cursorOffset?: number): Promise<{
+        name: string;
+        kind: string;
+        display: string;
+    }[]>;
+    /**
+     * Get visualization options in render command if present (null otherwise).
+     */
+    getRenderInfo(uri: string, cursorOffset: number): Promise<RenderInfo | null>;
+    doDocumentFormat(uri: string): Promise<ls.TextEdit[]>;
+    doRangeFormat(uri: string, range: ls.Range): Promise<ls.TextEdit[]>;
+    doCurrentCommandFormat(uri: string, caretPosition: ls.Position): Promise<ls.TextEdit[]>;
+    doValidation(uri: string, intervals: {
+        start: number;
+        end: number;
+    }[], includeWarnings?: boolean, includeSuggestions?: boolean): Promise<ls.Diagnostic[]>;
+    setParameters(scalarParameters: readonly ScalarParameter[], tabularParameters: readonly TabularParameter[]): void;
+    /**
+     * Get all the database references from the current command.
+     * If database's schema is already cached in previous calls to setSchema or addDatabaseToSchema it will not be returned.
+     * This method should be used to get all the cross-databases in a command, then schema for the database should be fetched and added with addDatabaseToSchema.
+     * @example
+     * If the current command includes: cluster('help').database('Samples')
+     * getDatabaseReferences will return [{ clusterName: 'help', databaseName 'Samples' }]
+     */
+    getDatabaseReferences(uri: string, cursorOffset: number): Promise<DatabaseReference[]>;
+    /**
+     * Get all the cluster references from the current command.
+     * If cluster's schema is already cached it will not be returned.
+     * This method should be used to get all the cross-clusters in a command, then schema for the cluster should be fetched and added with addClusterToSchema.
+     * cluster name is returned exactly as written in the KQL `cluster(<cluster name>)` function.
+     * @example
+     * If the current command includes: cluster('help')
+     * it returns [{ clusterName: 'help' }]
+     * @example
+     * If the current command includes: cluster('https://demo11.westus.kusto.windows.net')
+     * getClusterReferences will return [{ clusterName: 'https://demo11.westus.kusto.windows.net' }]
+     */
+    getClusterReferences(uri: string, cursorOffset: number): Promise<ClusterReference[]>;
+    /**
+     * Adds a database's scheme. Useful with getDatabaseReferences to load schema for cross-cluster commands.
+     * @param clusterName the name of the cluster as returned from getDatabaseReferences/getClusterReferences.
+     * @example
+     * - User enters cluster('help').database('Samples')
+     * - hosting app calls getDatabaseReferences which returns [{ clusterName: 'help', databaseName: 'Samples' }].
+     * - hosting app fetches the database Schema from https://help.kusto.windows.net
+     * - hosting app calls 'addDatabaseToSchema' with the database's schema.
+     * - now, when user types cluster('help').database('Samples') then the auto complete list will show all the tables.
+     */
+    addDatabaseToSchema(uri: string, clusterName: string, databaseSchema: Database): Promise<void>;
+    /**
+     * Adds a cluster's databases to the schema. Useful when used with getClusterReferences in cross-cluster commands.
+     * @param clusterName the name of the cluster as returned in getClusterReferences.
+     * @example
+     * - User enters cluster('help')
+     * - hosting app calls getClusterReferences which returns [{ clusterName: 'help' }].
+     * - hosting app fetches the list of databases from https://help.kusto.windows.net
+     * - hosting app calls addClusterToSchema with the list of databases.
+     * - now, when user type `cluster('help').database(` then the auto complete list will show all the databases.
+     */
+    addClusterToSchema(uri: string, clusterName: string, databasesNames: readonly string[]): Promise<void>;
+}
+/**
+ * A function that get a model Uri and returns a kusto worker that knows how to work
+ * with that document.
+ */
+export interface WorkerAccessor {
+    (first: monaco.Uri, ...more: monaco.Uri[]): Promise<KustoWorker>;
+}
+export interface Column {
+    name: string;
+    type: string;
+    docstring?: string;
+}
+export interface Table {
+    name: string;
+    columns: Column[];
+    docstring?: string;
+}
+export interface ScalarParameter {
+    name: string;
+    type?: string;
+    cslType?: string;
+    cslDefaultValue?: string;
+}
+export interface TabularParameter {
+    name: string;
+    columns: Column[];
+    docstring?: string;
+}
+export type InputParameter = ScalarParameter & {
+    columns?: ScalarParameter[];
+};
+export interface Function {
+    name: string;
+    body: string;
+    docstring?: string;
+    inputParameters: InputParameter[];
+}
+export interface Database {
+    name: string;
+    tables: Table[];
+    functions: Function[];
+    majorVersion: number;
+    minorVersion: number;
+}
+export interface EngineSchema {
+    clusterType: 'Engine';
+    cluster: {
+        connectionString: string;
+        databases: Database[];
+    };
+    database: Database | undefined;
+}
+export interface ClusterMangerSchema {
+    clusterType: 'ClusterManager';
+    accounts: string[];
+    services: string[];
+    connectionString: string;
+}
+export interface DataManagementSchema {
+    clusterType: 'DataManagement';
+}
+export type Schema = EngineSchema | ClusterMangerSchema | DataManagementSchema;
+export declare type VisualizationType = 'anomalychart' | 'areachart' | 'barchart' | 'columnchart' | 'ladderchart' | 'linechart' | 'piechart' | 'pivotchart' | 'scatterchart' | 'stackedareachart' | 'timechart' | 'table' | 'timeline' | 'timepivot' | 'card';
+export declare type Scale = 'linear' | 'log';
+export declare type LegendVisibility = 'visible' | 'hidden';
+export declare type YSplit = 'none' | 'axes' | 'panels';
+export declare type Kind = 'default' | 'unstacked' | 'stacked' | 'stacked100' | 'map';
+export interface RenderOptions {
+    visualization?: null | VisualizationType;
+    title?: null | string;
+    xcolumn?: null | string;
+    series?: null | string[];
+    ycolumns?: null | string[];
+    xtitle?: null | string;
+    ytitle?: null | string;
+    xaxis?: null | Scale;
+    yaxis?: null | Scale;
+    legend?: null | LegendVisibility;
+    ySplit?: null | YSplit;
+    accumulate?: null | boolean;
+    kind?: null | Kind;
+    anomalycolumns?: null | string[];
+    ymin?: null | number;
+    ymax?: null | number;
+}
+export interface RenderInfo {
+    options: RenderOptions;
+    location: {
+        startOffset: number;
+        endOffset: number;
+    };
+}
+export interface DatabaseReference {
+    databaseName: string;
+    clusterName: string;
+}
+export interface ClusterReference {
+    clusterName: string;
+}
+export type RenderOptionKeys = keyof RenderOptions;
+export type OnDidProvideCompletionItems = (list: ls.CompletionList) => Promise<ls.CompletionList>;

package/release/esm/workerManager.d.ts

@@ -1,7 +1,5 @@
-/// <reference types="../monaco" />
-/// <reference types="monaco-editor/monaco" />
-import type { Uri } from 'monaco-editor/esm/vs/editor/editor.api';
-import type { LanguageServiceDefaultsImpl } from './monaco.contribution';
+import type * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import type { LanguageServiceDefaults } from './monaco.contribution';
 import type { KustoWorker } from './kustoWorker';
 export declare class WorkerManager {
     private _monacoInstance;
@@ -12,11 +10,11 @@ export declare class WorkerManager {
     private _configChangeListener;
     private _worker;
     private _client;
-    constructor(_monacoInstance: typeof monaco, defaults: LanguageServiceDefaultsImpl);
+    constructor(_monacoInstance: typeof monaco, defaults: LanguageServiceDefaults);
     private _stopWorker;
     private _saveStateAndStopWorker;
     dispose(): void;
     private _checkIfIdle;
     private _getClient;
-    getLanguageServiceWorker(...resources: Uri[]): Promise<KustoWorker>;
+    getLanguageServiceWorker(...resources: monaco.Uri[]): Promise<KustoWorker>;
 }