@gooddata/sdk-ui-metric-component 11.65.0-alpha.8 → 11.65.0

package/esm/MaqlEditor/maql/monacoConverter.js

@@ -0,0 +1,528 @@
+// (C) 2026 GoodData Corporation
+import { Command, CompletionItemKind, CompletionItemLabelDetails, InsertReplaceEdit, InsertTextFormat, MarkupContent, MarkupKind, Range, } from "vscode-languageserver-types";
+function isProtocolCompletionItem(item) {
+    return typeof item === "object" && item !== null && "data" in item;
+}
+function isRangeReplace(value) {
+    return value.insert !== undefined;
+}
+function isString(value) {
+    return typeof value === "string" || value instanceof String;
+}
+function isNumber(value) {
+    return typeof value === "number" || value instanceof Number;
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every(isString);
+}
+/**
+ * Converts Monaco editor structures to the language server protocol ones.
+ */
+export class MonacoToProtocolConverter {
+    _monaco;
+    constructor(_monaco) {
+        this._monaco = _monaco;
+    }
+    asPosition(lineNumber, column) {
+        const line = lineNumber === undefined || lineNumber === null ? undefined : lineNumber - 1;
+        const character = column === undefined || column === null ? undefined : column - 1;
+        return { line, character };
+    }
+    asRange(range) {
+        if (range === undefined) {
+            return undefined;
+        }
+        if (range === null) {
+            return null;
+        }
+        if (isRangeReplace(range)) {
+            return this.asRange(range.insert);
+        }
+        const start = this.asPosition(range.startLineNumber, range.startColumn);
+        const end = this.asPosition(range.endLineNumber, range.endColumn);
+        return { start, end };
+    }
+    asCompletionItem(item) {
+        const result = { label: item.label };
+        const protocolItem = isProtocolCompletionItem(item) ? item : undefined;
+        if (item.detail) {
+            result.detail = item.detail;
+        }
+        if (item.documentation) {
+            if (typeof item.documentation === "string") {
+                result.documentation = item.documentation;
+            }
+            else {
+                result.documentation = this.asDocumentation(protocolItem?.documentationFormat ?? MarkupKind.Markdown, item.documentation);
+            }
+        }
+        if (item.filterText) {
+            result.filterText = item.filterText;
+        }
+        this.fillPrimaryInsertText(result, item);
+        if (isNumber(item.kind)) {
+            result.kind = this.asCompletionItemKind(item.kind, protocolItem?.originalItemKind);
+        }
+        if (item.sortText) {
+            result.sortText = item.sortText;
+        }
+        if (item.additionalTextEdits) {
+            result.additionalTextEdits = this.asTextEdits(item.additionalTextEdits);
+        }
+        if (item.commitCharacters) {
+            result.commitCharacters = item.commitCharacters.slice();
+        }
+        if (item.command) {
+            result.command = this.asCommand(item.command);
+        }
+        if (item.preselect === true || item.preselect === false) {
+            result.preselect = item.preselect;
+        }
+        if (protocolItem) {
+            if (protocolItem.data !== undefined) {
+                result.data = protocolItem.data;
+            }
+            if (protocolItem.deprecated === true || protocolItem.deprecated === false) {
+                result.deprecated = protocolItem.deprecated;
+            }
+        }
+        if (item.tags) {
+            result.tags = item.tags.slice();
+        }
+        return result;
+    }
+    asFormattingOptions(options) {
+        return { tabSize: options.tabSize, insertSpaces: options.insertSpaces };
+    }
+    asTextEdit(edit) {
+        return {
+            range: this.asRange(edit.range),
+            newText: edit.text || "",
+        };
+    }
+    asTextEdits(items) {
+        if (!items) {
+            return undefined;
+        }
+        return items.map((item) => this.asTextEdit(item));
+    }
+    asCommand(item) {
+        if (item) {
+            const args = item.arguments || [];
+            return Command.create(item.title, item.id, ...args);
+        }
+        return undefined;
+    }
+    asCompletionItemKind(value, original) {
+        if (original !== undefined) {
+            return original;
+        }
+        const kinds = this._monaco.languages.CompletionItemKind;
+        switch (value) {
+            case kinds.Method:
+                return CompletionItemKind.Method;
+            case kinds.Function:
+                return CompletionItemKind.Function;
+            case kinds.Constructor:
+                return CompletionItemKind.Constructor;
+            case kinds.Field:
+                return CompletionItemKind.Field;
+            case kinds.Variable:
+                return CompletionItemKind.Variable;
+            case kinds.Class:
+                return CompletionItemKind.Class;
+            case kinds.Struct:
+                return CompletionItemKind.Struct;
+            case kinds.Interface:
+                return CompletionItemKind.Interface;
+            case kinds.Module:
+                return CompletionItemKind.Module;
+            case kinds.Property:
+                return CompletionItemKind.Property;
+            case kinds.Event:
+                return CompletionItemKind.Event;
+            case kinds.Operator:
+                return CompletionItemKind.Operator;
+            case kinds.Unit:
+                return CompletionItemKind.Unit;
+            case kinds.Value:
+                return CompletionItemKind.Value;
+            case kinds.Constant:
+                return CompletionItemKind.Constant;
+            case kinds.Enum:
+                return CompletionItemKind.Enum;
+            case kinds.EnumMember:
+                return CompletionItemKind.EnumMember;
+            case kinds.Keyword:
+                return CompletionItemKind.Keyword;
+            case kinds.Text:
+                return CompletionItemKind.Text;
+            case kinds.Color:
+                return CompletionItemKind.Color;
+            case kinds.File:
+                return CompletionItemKind.File;
+            case kinds.Reference:
+                return CompletionItemKind.Reference;
+            case kinds.Customcolor:
+                return CompletionItemKind.Color;
+            case kinds.Folder:
+                return CompletionItemKind.Folder;
+            case kinds.TypeParameter:
+                return CompletionItemKind.TypeParameter;
+            case kinds.Snippet:
+                return CompletionItemKind.Snippet;
+            default:
+                return (value + 1);
+        }
+    }
+    asDocumentation(format, documentation) {
+        switch (format) {
+            case MarkupKind.PlainText:
+                return { kind: format, value: documentation };
+            case MarkupKind.Markdown:
+                return { kind: format, value: documentation.value };
+            default:
+                return `Unsupported Markup content received. Kind is: ${format}`;
+        }
+    }
+    fillPrimaryInsertText(target, source) {
+        // insertTextRules is a bit set; the snippet flag is tested with a bitmask, as upstream does.
+        const snippetRule = this._monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet;
+        const hasSnippetRule = source.insertTextRules !== undefined && (source.insertTextRules & snippetRule) !== 0;
+        const format = source.insertTextRules !== undefined && !hasSnippetRule
+            ? InsertTextFormat.Snippet
+            : InsertTextFormat.PlainText;
+        target.insertTextFormat = format;
+        const text = source.insertText;
+        const range = source.range ? this.asRange(source.range) : undefined;
+        if (source.fromEdit && text && range) {
+            target.textEdit = { newText: text, range };
+        }
+        else {
+            target.insertText = text;
+        }
+        target.insertTextMode = source.insertTextMode;
+    }
+}
+/**
+ * Converts language server protocol structures to the Monaco editor ones.
+ */
+export class ProtocolToMonacoConverter {
+    _monaco;
+    constructor(_monaco) {
+        this._monaco = _monaco;
+    }
+    asTextEdit(edit) {
+        return {
+            range: this.asRange(edit.range),
+            text: edit.newText,
+        };
+    }
+    asTextEdits(items) {
+        if (!items) {
+            return undefined;
+        }
+        return items.map((item) => this.asTextEdit(item));
+    }
+    asCommand(command) {
+        if (!command) {
+            return undefined;
+        }
+        return {
+            id: command.command,
+            title: command.title,
+            arguments: command.arguments,
+        };
+    }
+    asHover(hover) {
+        if (!hover) {
+            return undefined;
+        }
+        return {
+            contents: this.asHoverContent(hover.contents),
+            range: this.asRange(hover.range),
+        };
+    }
+    asHoverContent(contents) {
+        if (Array.isArray(contents)) {
+            return contents.map((content) => this.asMarkdownString(content));
+        }
+        return [this.asMarkdownString(contents)];
+    }
+    asDocumentation(value) {
+        if (isString(value)) {
+            return value;
+        }
+        if (value.kind === MarkupKind.PlainText) {
+            return value.value;
+        }
+        return this.asMarkdownString(value);
+    }
+    asMarkdownString(content) {
+        if (MarkupContent.is(content)) {
+            return { value: content.value };
+        }
+        if (isString(content)) {
+            return { value: content };
+        }
+        const { language, value } = content;
+        return { value: "```" + language + "\n" + value + "\n```" };
+    }
+    asSeverity(severity) {
+        if (severity === 1) {
+            return this._monaco.MarkerSeverity.Error;
+        }
+        if (severity === 2) {
+            return this._monaco.MarkerSeverity.Warning;
+        }
+        if (severity === 3) {
+            return this._monaco.MarkerSeverity.Info;
+        }
+        return this._monaco.MarkerSeverity.Hint;
+    }
+    asDiagnostics(diagnostics) {
+        if (!diagnostics) {
+            return undefined;
+        }
+        return diagnostics.map((diagnostic) => this.asDiagnostic(diagnostic));
+    }
+    asDiagnostic(diagnostic) {
+        return {
+            code: typeof diagnostic.code === "number" ? diagnostic.code.toString() : diagnostic.code,
+            severity: this.asSeverity(diagnostic.severity),
+            message: diagnostic.message,
+            source: diagnostic.source,
+            startLineNumber: diagnostic.range.start.line + 1,
+            startColumn: diagnostic.range.start.character + 1,
+            endLineNumber: diagnostic.range.end.line + 1,
+            endColumn: diagnostic.range.end.character + 1,
+            relatedInformation: this.asRelatedInformations(diagnostic.relatedInformation),
+            tags: diagnostic.tags,
+        };
+    }
+    asRelatedInformations(relatedInformation) {
+        if (!relatedInformation) {
+            return undefined;
+        }
+        return relatedInformation.map((item) => this.asRelatedInformation(item));
+    }
+    asRelatedInformation(relatedInformation) {
+        return {
+            resource: this._monaco.Uri.parse(relatedInformation.location.uri),
+            startLineNumber: relatedInformation.location.range.start.line + 1,
+            startColumn: relatedInformation.location.range.start.character + 1,
+            endLineNumber: relatedInformation.location.range.end.line + 1,
+            endColumn: relatedInformation.location.range.end.character + 1,
+            message: relatedInformation.message,
+        };
+    }
+    asCompletionResult(result, defaultMonacoRange) {
+        if (!result) {
+            return { incomplete: false, suggestions: [] };
+        }
+        if (Array.isArray(result)) {
+            return {
+                incomplete: false,
+                suggestions: result.map((item) => this.asCompletionItem(item, defaultMonacoRange)),
+            };
+        }
+        const defaultRange = this.getCompletionItemDefaultRange(result);
+        return {
+            incomplete: result.isIncomplete,
+            suggestions: result.items.map((item) => this.asCompletionItem(item, defaultMonacoRange, defaultRange, result.itemDefaults)),
+        };
+    }
+    asCompletionItem(item, defaultMonacoRange, defaultRange, itemDefaults) {
+        const result = { label: this.asCompletionItemLabel(item) };
+        if (item.detail) {
+            result.detail = item.detail;
+        }
+        if (item.documentation) {
+            result.documentation = this.asDocumentation(item.documentation);
+            result.documentationFormat = isString(item.documentation) ? undefined : item.documentation.kind;
+        }
+        if (item.filterText) {
+            result.filterText = item.filterText;
+        }
+        const insertText = this.asCompletionInsertText(item, defaultRange, itemDefaults?.insertTextFormat);
+        result.insertText = insertText.insertText;
+        result.range = insertText.range ?? defaultMonacoRange;
+        result.fromEdit = insertText.fromEdit;
+        if (insertText.isSnippet) {
+            result.insertTextRules = this._monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet;
+        }
+        if (isNumber(item.kind)) {
+            const [itemKind, original] = this.asCompletionItemKind(item.kind);
+            result.kind = itemKind;
+            if (original) {
+                result.originalItemKind = original;
+            }
+        }
+        if (item.sortText) {
+            result.sortText = item.sortText;
+        }
+        if (item.additionalTextEdits) {
+            result.additionalTextEdits = this.asTextEdits(item.additionalTextEdits);
+        }
+        if (isStringArray(item.commitCharacters)) {
+            result.commitCharacters = item.commitCharacters.slice();
+        }
+        if (item.command) {
+            result.command = this.asCommand(item.command);
+        }
+        if (item.deprecated === true || item.deprecated === false) {
+            result.deprecated = item.deprecated;
+        }
+        if (item.preselect === true || item.preselect === false) {
+            result.preselect = item.preselect;
+        }
+        const data = item.data ?? itemDefaults?.data;
+        if (data !== undefined) {
+            result.data = data;
+        }
+        const insertTextMode = item.insertTextMode ?? itemDefaults?.insertTextMode;
+        if (insertTextMode) {
+            result.insertTextMode = insertTextMode;
+        }
+        if (item.tags) {
+            result.tags = item.tags;
+        }
+        return result;
+    }
+    getCompletionItemDefaultRange(list) {
+        const rangeDefaults = list.itemDefaults?.editRange;
+        if (Range.is(rangeDefaults)) {
+            return this.asRange(rangeDefaults);
+        }
+        return rangeDefaults === undefined
+            ? undefined
+            : { insert: this.asRange(rangeDefaults.insert), replace: this.asRange(rangeDefaults.replace) };
+    }
+    asCompletionItemLabel(item) {
+        if (CompletionItemLabelDetails.is(item.labelDetails)) {
+            return {
+                label: item.label,
+                detail: item.labelDetails.detail,
+                description: item.labelDetails.description,
+            };
+        }
+        return item.label;
+    }
+    asCompletionItemKind(value) {
+        const kinds = this._monaco.languages.CompletionItemKind;
+        if (CompletionItemKind.Text <= value && value <= CompletionItemKind.TypeParameter) {
+            switch (value) {
+                case CompletionItemKind.Text:
+                    return [kinds.Text, undefined];
+                case CompletionItemKind.Method:
+                    return [kinds.Method, undefined];
+                case CompletionItemKind.Function:
+                    return [kinds.Function, undefined];
+                case CompletionItemKind.Constructor:
+                    return [kinds.Constructor, undefined];
+                case CompletionItemKind.Field:
+                    return [kinds.Field, undefined];
+                case CompletionItemKind.Variable:
+                    return [kinds.Variable, undefined];
+                case CompletionItemKind.Class:
+                    return [kinds.Class, undefined];
+                case CompletionItemKind.Interface:
+                    return [kinds.Interface, undefined];
+                case CompletionItemKind.Module:
+                    return [kinds.Module, undefined];
+                case CompletionItemKind.Property:
+                    return [kinds.Property, undefined];
+                case CompletionItemKind.Unit:
+                    return [kinds.Unit, undefined];
+                case CompletionItemKind.Value:
+                    return [kinds.Value, undefined];
+                case CompletionItemKind.Enum:
+                    return [kinds.Enum, undefined];
+                case CompletionItemKind.Keyword:
+                    return [kinds.Keyword, undefined];
+                case CompletionItemKind.Snippet:
+                    return [kinds.Snippet, undefined];
+                case CompletionItemKind.Color:
+                    return [kinds.Color, undefined];
+                case CompletionItemKind.File:
+                    return [kinds.File, undefined];
+                case CompletionItemKind.Reference:
+                    return [kinds.Reference, undefined];
+                case CompletionItemKind.Folder:
+                    return [kinds.Folder, undefined];
+                case CompletionItemKind.EnumMember:
+                    return [kinds.EnumMember, undefined];
+                case CompletionItemKind.Constant:
+                    return [kinds.Constant, undefined];
+                case CompletionItemKind.Struct:
+                    return [kinds.Struct, undefined];
+                case CompletionItemKind.Event:
+                    return [kinds.Event, undefined];
+                case CompletionItemKind.Operator:
+                    return [kinds.Operator, undefined];
+                case CompletionItemKind.TypeParameter:
+                    return [kinds.TypeParameter, undefined];
+                default:
+                    return [value - 1, undefined];
+            }
+        }
+        return [CompletionItemKind.Text, value];
+    }
+    asCompletionInsertText(item, defaultRange, defaultInsertTextFormat) {
+        const insertTextFormat = item.insertTextFormat ?? defaultInsertTextFormat;
+        const isSnippet = insertTextFormat === InsertTextFormat.Snippet;
+        if (item.textEdit !== undefined || defaultRange !== undefined) {
+            const [range, newText] = item.textEdit === undefined
+                ? [defaultRange, item.textEditText ?? item.label]
+                : this.getCompletionRangeAndText(item.textEdit);
+            return { insertText: newText, range, fromEdit: true, isSnippet };
+        }
+        if (item.insertText) {
+            return { isSnippet, insertText: item.insertText, fromEdit: false, range: defaultRange };
+        }
+        return { insertText: item.label, range: defaultRange, fromEdit: false, isSnippet: false };
+    }
+    getCompletionRangeAndText(value) {
+        if (InsertReplaceEdit.is(value)) {
+            return [
+                { insert: this.asRange(value.insert), replace: this.asRange(value.replace) },
+                value.newText,
+            ];
+        }
+        return [this.asRange(value.range), value.newText];
+    }
+    asRange(range) {
+        if (range === undefined) {
+            return undefined;
+        }
+        if (range === null) {
+            return null;
+        }
+        const start = this.asPosition(range.start);
+        const end = this.asPosition(range.end);
+        if (start instanceof this._monaco.Position && end instanceof this._monaco.Position) {
+            return new this._monaco.Range(start.lineNumber, start.column, end.lineNumber, end.column);
+        }
+        return {
+            startLineNumber: start?.lineNumber,
+            startColumn: start?.column,
+            endLineNumber: end?.lineNumber,
+            endColumn: end?.column,
+        };
+    }
+    asPosition(position) {
+        if (position === undefined) {
+            return undefined;
+        }
+        if (position === null) {
+            return null;
+        }
+        const { line, character } = position;
+        const lineNumber = line === undefined ? undefined : line + 1;
+        const column = character === undefined ? undefined : character + 1;
+        if (lineNumber !== undefined && column !== undefined) {
+            return new this._monaco.Position(lineNumber, column);
+        }
+        return { lineNumber, column };
+    }
+}

package/esm/MaqlEditor/monaco/monacoWorkers.d.ts

@@ -1,3 +1,44 @@
+/**
+ * URL of the self-contained editor worker file that this package ships, relative to this module.
+ *
+ * @remarks
+ * The relative path is the same from `src/MaqlEditor/monaco/` and from `esm/MaqlEditor/monaco/`, so
+ * it also holds when a dev server serves this package from its sources. webpack and Vite recognise
+ * the `new URL("...", import.meta.url)` pattern and emit the file as an asset. A pre-bundled
+ * dependency, other bundlers and a Module Federation remote on another origin leave a URL that does
+ * not exist or that the page cannot start a worker from. The URL must therefore be checked before
+ * the worker starts, see {@link resolveEditorWorkerUrl}.
+ *
+ * @internal
+ */
+export declare function getBundledEditorWorkerUrl(): string;
+/**
+ * Resolves the URL the editor worker starts from: the bundled worker file when the bundler emitted
+ * it next to the page, the inline worker otherwise.
+ *
+ * @param assetUrl - URL of the bundled worker file, defaults to {@link getBundledEditorWorkerUrl}
+ * @internal
+ */
+export declare function resolveEditorWorkerUrl(assetUrl?: string): Promise<string>;
+/**
+ * Name of the Trusted Types policy that turns the worker URL into a `TrustedScriptURL`. A page whose
+ * content security policy lists the allowed policy names must allow this one.
+ *
+ * @internal
+ */
+export declare const EDITOR_WORKER_TRUSTED_TYPES_POLICY = "gdMetricEditorWorker";
+/**
+ * Creates the `MonacoEnvironment.getWorker` that starts the bundled editor worker.
+ *
+ * @remarks
+ * The worker URL and the Trusted Types policy are created once and shared by all workers, which is why
+ * the cache lives in the created function: tests create their own, the runtime uses one. A failed
+ * resolution is not cached, so the next worker tries again.
+ *
+ * @param resolveWorkerUrl - resolves the URL of the worker this package ships
+ * @internal
+ */
+export declare function createEditorWorkerFactory(resolveWorkerUrl?: () => Promise<string>): (workerId: string, label: string) => Promise<Worker>;
 /**
  * Point Monaco at the bundled `editorWorkerService` worker.
  *

package/esm/MaqlEditor/monaco/monacoWorkers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"monacoWorkers.d.ts","sourceRoot":"","sources":["../../../src/MaqlEditor/monaco/monacoWorkers.ts"],"names":[],"mappings":"AA2CA;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CASzC"}
+{"version":3,"file":"monacoWorkers.d.ts","sourceRoot":"","sources":["../../../src/MaqlEditor/monaco/monacoWorkers.ts"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;GAYG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,CAElD;AAiED;;;;;;GAMG;AACH,wBAAsB,sBAAsB,CACxC,QAAQ,GAAE,MAAoC,GAC/C,OAAO,CAAC,MAAM,CAAC,CAEjB;AAKD;;;;;GAKG;AACH,eAAO,MAAM,kCAAkC,yBAAyB,CAAC;AA2BzE;;;;;;;;;;GAUG;AACH,wBAAgB,yBAAyB,CACrC,gBAAgB,GAAE,MAAM,OAAO,CAAC,MAAM,CAA0B,GACjE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAetD;AAID;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CASzC"}