@kusto/monaco-kusto 5.6.6 → 6.0.0

package/release/dev/languageFeatures.d.ts

@@ -0,0 +1,91 @@
+/// <reference types="monaco-editor-core/monaco" />
+/// <reference types="../monaco" />
+import type { LanguageServiceDefaultsImpl } from './monaco.contribution';
+import type { KustoWorker } from './kustoWorker';
+import Uri = monaco.Uri;
+import Position = monaco.Position;
+import Range = monaco.Range;
+import Thenable = monaco.Thenable;
+import CancellationToken = monaco.CancellationToken;
+import type { Schema } from './languageService/schema';
+export interface WorkerAccessor {
+    (first: Uri, ...more: Uri[]): Promise<KustoWorker>;
+}
+export declare class DiagnosticsAdapter {
+    private _monacoInstance;
+    private _languageId;
+    private _worker;
+    private defaults;
+    private _disposables;
+    private _contentListener;
+    private _configurationListener;
+    private _schemaListener;
+    private _cursorListener;
+    private _debouncedValidations;
+    constructor(_monacoInstance: typeof monaco, _languageId: string, _worker: WorkerAccessor, defaults: LanguageServiceDefaultsImpl, onSchemaChange: monaco.IEvent<Schema>);
+    private getMonacoCodeActions;
+    private getOrCreateDebouncedValidation;
+    dispose(): void;
+    private _doValidate;
+}
+export declare class ColorizationAdapter {
+    private _monacoInstance;
+    private _languageId;
+    private _worker;
+    private _disposables;
+    private _contentListener;
+    private _configurationListener;
+    private _schemaListener;
+    private decorations;
+    constructor(_monacoInstance: typeof monaco, _languageId: string, _worker: WorkerAccessor, defaults: LanguageServiceDefaultsImpl, onSchemaChange: monaco.IEvent<Schema>);
+    dispose(): void;
+    /**
+     * Return true if the range doesn't intersect any of the line ranges.
+     * @param range Range
+     * @param impactedLineRanges an array of line ranges
+     */
+    private _rangeDoesNotIntersectAny;
+    private _doColorization;
+}
+export declare class CompletionAdapter implements monaco.languages.CompletionItemProvider {
+    private _worker;
+    private languageSettings;
+    constructor(_worker: WorkerAccessor, languageSettings: monaco.languages.kusto.LanguageSettings);
+    get triggerCharacters(): string[];
+    provideCompletionItems(model: monaco.editor.IReadOnlyModel, position: Position, context: monaco.languages.CompletionContext, token: CancellationToken): Thenable<monaco.languages.CompletionList>;
+}
+export declare class DefinitionAdapter {
+    private _worker;
+    constructor(_worker: WorkerAccessor);
+    provideDefinition(model: monaco.editor.IReadOnlyModel, position: Position, token: CancellationToken): Thenable<monaco.languages.Definition>;
+}
+export declare class ReferenceAdapter implements monaco.languages.ReferenceProvider {
+    private _worker;
+    constructor(_worker: WorkerAccessor);
+    provideReferences(model: monaco.editor.IReadOnlyModel, position: Position, context: monaco.languages.ReferenceContext, token: CancellationToken): Thenable<monaco.languages.Location[]>;
+}
+export declare class RenameAdapter implements monaco.languages.RenameProvider {
+    private _worker;
+    constructor(_worker: WorkerAccessor);
+    provideRenameEdits(model: monaco.editor.IReadOnlyModel, position: Position, newName: string, token: CancellationToken): Thenable<monaco.languages.WorkspaceEdit>;
+}
+export declare class DocumentFormatAdapter implements monaco.languages.DocumentFormattingEditProvider {
+    private _worker;
+    constructor(_worker: WorkerAccessor);
+    provideDocumentFormattingEdits(model: monaco.editor.IReadOnlyModel, options: monaco.languages.FormattingOptions, token: CancellationToken): monaco.languages.TextEdit[] | Thenable<monaco.languages.TextEdit[]>;
+}
+export declare class FormatAdapter implements monaco.languages.DocumentRangeFormattingEditProvider {
+    private _worker;
+    constructor(_worker: WorkerAccessor);
+    provideDocumentRangeFormattingEdits(model: monaco.editor.IReadOnlyModel, range: Range, options: monaco.languages.FormattingOptions, token: CancellationToken): monaco.languages.TextEdit[] | Thenable<monaco.languages.TextEdit[]>;
+}
+export declare class FoldingAdapter implements monaco.languages.FoldingRangeProvider {
+    private _worker;
+    constructor(_worker: WorkerAccessor);
+    provideFoldingRanges(model: monaco.editor.ITextModel, context: monaco.languages.FoldingContext, token: CancellationToken): monaco.languages.FoldingRange[] | PromiseLike<monaco.languages.FoldingRange[]>;
+}
+export declare class HoverAdapter implements monaco.languages.HoverProvider {
+    private _worker;
+    constructor(_worker: WorkerAccessor);
+    provideHover(model: monaco.editor.IReadOnlyModel, position: Position, token: CancellationToken): Thenable<monaco.languages.Hover>;
+}

package/release/dev/languageService/kustoLanguageService.d.ts

@@ -0,0 +1,142 @@
+/// <reference types="@kusto/language-service-next/Kusto.Language.Bridge" />
+/// <reference types="@kusto/language-service/Kusto.JavaScript.Client" />
+import * as s from './schema';
+import * as ls from 'vscode-languageserver-types';
+import type { TextDocument } from 'vscode-languageserver-textdocument';
+import type { FoldingRange } from 'vscode-languageserver-types';
+import type { LanguageSettings } from './settings';
+import k = Kusto.Data.IntelliSense;
+import k2 = Kusto.Language.Editor;
+import { Database } from './schema';
+import type { RenderInfo } from './renderInfo';
+export declare enum TokenKind {
+    TableToken = 2,
+    TableColumnToken = 4,
+    OperatorToken = 8,
+    SubOperatorToken = 16,
+    CalculatedColumnToken = 32,
+    StringLiteralToken = 64,
+    FunctionNameToken = 128,
+    UnknownToken = 256,
+    CommentToken = 512,
+    PlainTextToken = 1024,
+    DataTypeToken = 2048,
+    ControlCommandToken = 4096,
+    CommandPartToken = 8192,
+    QueryParametersToken = 16384,
+    CslCommandToken = 32768,
+    LetVariablesToken = 65536,
+    PluginToken = 131072,
+    BracketRangeToken = 262144,
+    ClientDirectiveToken = 524288
+}
+/**
+ * A plain old javascript object that is roughly equivalent to the @kusto/language-service-next object, but without
+ * all the Bridge.Net properties and methods. this object is being sent from web worker to main thread and turns out
+ * that when posting the message we lose all properties (and functions), thus we use a POJO instead.
+ * This issue started happening once upgrading to 0.20.0 from 0.15.5.
+ */
+export interface ClassifiedRange {
+    kind: k2.ClassificationKind;
+    start: number;
+    length: number;
+    end: number;
+}
+/**
+ * colorization data for specific line range.
+ */
+export interface ColorizationRange {
+    classifications: ClassifiedRange[];
+    absoluteStart: number;
+    absoluteEnd: number;
+}
+export interface ResultAction {
+    title: string;
+    changes: {
+        start: number;
+        deleteLength: number;
+        insertText: string | null;
+    }[];
+}
+export interface LanguageService {
+    doComplete(document: TextDocument, position: ls.Position): Promise<ls.CompletionList>;
+    doRangeFormat(document: TextDocument, range: ls.Range): Promise<ls.TextEdit[]>;
+    doDocumentFormat(document: TextDocument): Promise<ls.TextEdit[]>;
+    doCurrentCommandFormat(document: TextDocument, caretPosition: ls.Position): Promise<ls.TextEdit[]>;
+    doFolding(document: TextDocument): Promise<FoldingRange[]>;
+    doValidation(document: TextDocument, intervals: {
+        start: number;
+        end: number;
+    }[], includeWarnings?: boolean, includeSuggestions?: boolean): Promise<ls.Diagnostic[]>;
+    getResultActions(document: TextDocument, start: number, end: number): Promise<ResultAction[]>;
+    doColorization(document: TextDocument, intervals: {
+        start: number;
+        end: number;
+    }[]): Promise<ColorizationRange[]>;
+    doRename(document: TextDocument, position: ls.Position, newName: string): Promise<ls.WorkspaceEdit | undefined>;
+    doHover(document: TextDocument, position: ls.Position): Promise<ls.Hover | undefined>;
+    setParameters(scalarParameters: readonly s.ScalarParameter[], tabularParameters: readonly s.TabularParameter[]): Promise<void>;
+    setSchema(schema: s.Schema): Promise<void>;
+    setSchemaFromShowSchema(schema: s.showSchema.Result, clusterConnectionString: string, databaseInContextName: string, globalScalarParameters?: s.ScalarParameter[], globalTabularParameters?: s.TabularParameter[]): Promise<void>;
+    normalizeSchema(schema: s.showSchema.Result, clusterConnectionString: string, databaseInContextName: string): Promise<s.EngineSchema>;
+    getSchema(): Promise<s.Schema>;
+    getCommandInContext(document: TextDocument, cursorOffset: number): Promise<string>;
+    getCommandAndLocationInContext(document: TextDocument, cursorOffset: number): Promise<{
+        text: string;
+        location: ls.Location;
+    } | null>;
+    getCommandsInDocument(document: TextDocument): Promise<{
+        absoluteStart: number;
+        absoluteEnd: number;
+        text: string;
+    }[]>;
+    configure(languageSettings: LanguageSettings): void;
+    getClientDirective(text: string): Promise<{
+        isClientDirective: boolean;
+        directiveWithoutLeadingComments: string;
+    }>;
+    getAdminCommand(text: string): Promise<{
+        isAdminCommand: boolean;
+        adminCommandWithoutLeadingComments: string;
+    }>;
+    findDefinition(document: TextDocument, position: ls.Position): Promise<ls.Location[]>;
+    findReferences(document: TextDocument, position: ls.Position): Promise<ls.Location[]>;
+    getQueryParams(document: TextDocument, cursorOffset: number): Promise<{
+        name: string;
+        type: string;
+    }[]>;
+    getGlobalParams(document: TextDocument): Promise<{
+        name: string;
+        type: string;
+    }[]>;
+    getReferencedSymbols(document: TextDocument, offset?: number): Promise<{
+        name: string;
+        kind: string;
+        display: string;
+    }[]>;
+    getReferencedGlobalParams(document: TextDocument, offset?: number): Promise<{
+        name: string;
+        type: string;
+    }[]>;
+    getRenderInfo(document: TextDocument, cursorOffset: number): Promise<RenderInfo | undefined>;
+    getDatabaseReferences(document: TextDocument, cursorOffset: number): Promise<DatabaseReference[]>;
+    getClusterReferences(document: TextDocument, cursorOffset: number): Promise<ClusterReference[]>;
+    addDatabaseToSchema(document: TextDocument, clusterName: string, databaseSchema: Database): Promise<void>;
+    addClusterToSchema(document: TextDocument, clusterName: string, databaseNames: string[]): Promise<void>;
+}
+export type CmSchema = {
+    accounts: k.KustoIntelliSenseAccountEntity[];
+    services: k.KustoIntelliSenseServiceEntity[];
+    connectionString: string;
+};
+export interface DatabaseReference {
+    databaseName: string;
+    clusterName: string;
+}
+export interface ClusterReference {
+    clusterName: string;
+}
+/**
+ * Obtain an instance of the kusto language service.
+ */
+export declare function getKustoLanguageService(): LanguageService;

package/release/dev/languageService/kustoMonarchLanguageDefinition.d.ts

@@ -0,0 +1 @@
+export declare const KustoLanguageDefinition: any;

package/release/dev/languageService/renderInfo.d.ts

@@ -0,0 +1,31 @@
+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 type RenderOptionKeys = keyof RenderOptions;

package/release/dev/languageService/schema.d.ts

@@ -0,0 +1,144 @@
+export interface Column {
+    name: string;
+    type: string;
+    docstring?: string;
+    examples?: string[];
+}
+export interface Table {
+    name: string;
+    entityType?: TableEntityType;
+    columns: Column[];
+    docstring?: string;
+}
+export interface MaterializedViewTable extends Table {
+    entityType: 'MaterializedViewTable';
+    mvQuery?: string;
+}
+export interface ScalarParameter {
+    name: string;
+    type?: string;
+    cslType?: string;
+    docstring?: string;
+    cslDefaultValue?: string;
+    examples?: string[];
+}
+export interface TabularParameter {
+    name: string;
+    columns: Column[];
+    docstring?: string;
+}
+export type InputParameter = ScalarParameter & {
+    columns?: ScalarParameter[];
+};
+export interface Function {
+    name: string;
+    body: string;
+    inputParameters: InputParameter[];
+    docstring?: string;
+}
+export interface Database {
+    name: string;
+    tables: Table[];
+    functions: Function[];
+    majorVersion: number;
+    minorVersion: number;
+}
+export type ClusterType = 'Engine' | 'DataManagement' | 'ClusterManager';
+export interface EngineSchema {
+    clusterType: 'Engine';
+    cluster: {
+        connectionString: string;
+        databases: Database[];
+    };
+    database: Database | undefined;
+    globalScalarParameters?: ScalarParameter[];
+    globalTabularParameters?: TabularParameter[];
+}
+export type TableEntityType = 'Table' | 'ExternalTable' | 'MaterializedViewTable';
+export interface ClusterMangerSchema {
+    clusterType: 'ClusterManager';
+    accounts: string[];
+    services: string[];
+    connectionString: string;
+}
+export interface DataManagementSchema {
+    clusterType: 'DataManagement';
+}
+/**
+ * Schema types:
+ * Engine – The main schema type. Contains clusters, databases, tables, table columns and functions.
+ * Cluster Manager – Internal only. A schema for clusters that manages other clusters.
+ * Data Management – Internal only. A schema for ingestion point operations.
+ */
+export type Schema = EngineSchema | ClusterMangerSchema | DataManagementSchema;
+export declare const getCslTypeNameFromClrType: (clrType: string) => string;
+export declare const getEntityDataTypeFromCslType: (cslType: string) => string;
+export declare const getCallName: (fn: Function) => string;
+export declare const getExpression: (fn: Function) => string;
+export declare const getInputParametersAsCslString: (inputParameters: InputParameter[]) => any;
+/**
+ * This is the schema of the output of kusto command
+ * .show schema as json
+ */
+export declare namespace showSchema {
+    interface Column {
+        Name: string;
+        Type: string;
+        CslType: string;
+        DocString?: string;
+        Examples?: string[];
+    }
+    interface Table {
+        Name: string;
+        EntityType: TableEntityType;
+        OrderedColumns: Column[];
+        DocString?: string;
+    }
+    interface Tables {
+        [tableName: string]: Table;
+    }
+    interface ScalarParameter {
+        Name: string;
+        Type?: string;
+        CslType?: string;
+        DocString?: string;
+        CslDefaultValue?: string;
+    }
+    interface TabularParameter {
+        Name: string;
+        Columns: Column[];
+        DocString?: string;
+    }
+    type InputParameter = ScalarParameter & {
+        Columns?: ScalarParameter[];
+    };
+    interface Function {
+        Name: string;
+        InputParameters: InputParameter[];
+        Body: string;
+        Folder: string;
+        DocString: string;
+        FunctionKind: string;
+        OutputColumns: any[];
+    }
+    interface Functions {
+        [functionName: string]: Function;
+    }
+    interface Database {
+        Name: string;
+        Tables: Tables;
+        ExternalTables: Tables;
+        MaterializedViews: Table;
+        MajorVersion: number;
+        MinorVersion: number;
+        Functions: Functions;
+        DatabaseAccessMode: string;
+    }
+    interface Databases {
+        [dbName: string]: Database;
+    }
+    interface Result {
+        Plugins: Plugin[];
+        Databases: Databases;
+    }
+}

package/release/dev/languageService/settings.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="../monaco" />
+export interface LanguageSettings {
+    includeControlCommands?: boolean;
+    newlineAfterPipe?: boolean;
+    openSuggestionDialogAfterPreviousSuggestionAccepted?: boolean;
+    useIntellisenseV2: boolean;
+    useSemanticColorization?: boolean;
+    useTokenColorization?: boolean;
+    disabledCompletionItems?: string[];
+    onDidProvideCompletionItems?: monaco.languages.kusto.OnDidProvideCompletionItems;
+    enableHover?: boolean;
+    formatter?: FormatterOptions;
+    syntaxErrorAsMarkDown?: SyntaxErrorAsMarkDownOptions;
+    enableQueryWarnings?: boolean;
+    enableQuerySuggestions?: boolean;
+    disabledDiagnoticCodes?: string[];
+    quickFixCodeActions?: QuickFixCodeActionOptions[];
+    enableQuickFixes?: boolean;
+}
+export interface FormatterOptions {
+    indentationSize?: number;
+    pipeOperatorStyle?: FormatterPlacementStyle;
+}
+export interface SyntaxErrorAsMarkDownOptions {
+    header?: string;
+    icon?: string;
+    enableSyntaxErrorAsMarkDown?: boolean;
+}
+export type QuickFixCodeActionOptions = 'Extract Expression' | 'Extract Function' | 'Change to';
+export type FormatterPlacementStyle = 'None' | 'NewLine' | 'Smart';