@gooddata/sdk-ui-metric-component 0.0.0-stage → 11.65.0-alpha.4

package/esm/MaqlEditor/maql/MaqlEditor.tooltip.js

@@ -0,0 +1,187 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2021-2026 GoodData Corporation
+import { useEffect, useMemo, useRef, useState } from "react";
+import classNames from "classnames";
+import { FormattedMessage, IntlProvider } from "react-intl";
+import { BackendProvider, WorkspaceProvider } from "@gooddata/sdk-ui";
+import { destroyTooltip, renderTooltip } from "../components/ExpandableTooltip.js";
+import { useExpandableTooltip } from "../components/hooks/useExpandableTooltip.js";
+import { useCodeTheme } from "../hooks/useCodeTheme.js";
+import { MainClassContent, MonacoEditor, } from "../monaco/MonacoEditor.js";
+import { makeStyles } from "../theme/styles.js";
+import { LANGUAGE } from "./constants.js";
+import { useDecoration } from "./hooks/useDecoration.js";
+import { useLanguageService } from "./hooks/useLanguageService.js";
+import { MaqlTooltip, MaqlTooltipEditorClass, TooltipMaqlStyles } from "./MaqlEditor.styles.js";
+const BiggerClass = "bigger";
+const SmallerClass = "smaller";
+const ExpandedClass = "expanded";
+const useStyles = makeStyles()((theme) => {
+    const { title, description, colors, lineHeight, padding, readMore, space, tooltip } = theme.hoverMetric;
+    const { borders } = theme.tooltip;
+    const titleHeight = lineHeight + padding;
+    const descriptionHeightNormal = lineHeight * 2;
+    const descriptionHeightBigger = lineHeight * 4;
+    const expandIcon = 15;
+    const size = tooltip.normal.maxHeight - titleHeight - title.bottomSpace - space - borders.size;
+    const normalSize = size - descriptionHeightNormal;
+    const smallerSize = size - descriptionHeightBigger;
+    const link = {
+        color: colors.link,
+        textDecoration: "underline",
+        cursor: "pointer",
+    };
+    return {
+        content: {
+            display: "flex",
+            flexDirection: "column",
+            flexWrap: "nowrap",
+        },
+        title: {
+            margin: 0,
+            fontWeight: "normal",
+            padding: `${padding}px ${padding + expandIcon}px 0 ${padding}px`,
+            lineHeight: `${lineHeight}px`,
+            fontSize: `${title.fontSize}px`,
+            marginBottom: `${title.bottomSpace}px`,
+            maxHeight: `${titleHeight}px`,
+            whiteSpace: "nowrap",
+            textOverflow: "ellipsis",
+            overflow: "hidden",
+            width: `calc(100% - ${padding * 2 + expandIcon}px)`,
+            [`&.${BiggerClass}`]: {
+                position: "absolute",
+                width: `calc(100% - ${padding * 3 + expandIcon}px)`,
+                background: "white",
+                zIndex: 1,
+            },
+            [`&.${ExpandedClass}`]: {
+                position: "absolute",
+                background: "white",
+                zIndex: 1,
+            },
+        },
+        description: {
+            position: "relative",
+            overflow: "hidden",
+            fontSize: `${description.fontSize}px`,
+            lineHeight: `${lineHeight}px`,
+            padding: `0 ${padding}px 0px ${padding}px`,
+            marginBottom: `${space}px`,
+            color: colors.color,
+            maxHeight: `${descriptionHeightNormal}px`,
+            [`&.${BiggerClass}`]: {
+                padding: `${titleHeight + title.bottomSpace}px ${padding}px ${space}px ${padding}px`,
+                marginBottom: 0,
+                maxHeight: `${descriptionHeightBigger}px`,
+                overflow: "auto",
+            },
+            [`&.${ExpandedClass}`]: {
+                padding: `${titleHeight + title.bottomSpace}px ${padding}px ${space}px ${padding}px`,
+                marginBottom: 0,
+                maxHeight: `${tooltip.expanded.maxHeightDescription}px !important`,
+                overflow: "hidden",
+            },
+        },
+        readMore: {
+            bottom: 0,
+            position: "absolute",
+            right: `${padding}px`,
+            background: theme.tooltip.colors.background,
+            span: {
+                padding: `0 ${readMore.paddingText}px 0 0`,
+                color: colors.color,
+            },
+            a: link,
+        },
+        readLess: {
+            padding: `0 0 0 ${readMore.paddingText}px`,
+            a: link,
+        },
+        hr: {
+            width: "100%",
+            height: 0,
+            margin: 0,
+            borderTop: borders.default,
+        },
+        maql: {
+            [`.${MainClassContent}`]: {
+                minWidth: "100%",
+                maxWidth: "100%",
+                minHeight: `0 !important`,
+                maxHeight: `${normalSize}px !important`,
+                ".lines-content": {
+                    paddingLeft: `${padding}px !important`,
+                },
+                textarea: {
+                    marginLeft: `${padding + 1}px !important`,
+                },
+            },
+            [`&.${SmallerClass}`]: {
+                [`.${MainClassContent}`]: {
+                    maxHeight: `${smallerSize}px !important`,
+                },
+            },
+            [`&.${ExpandedClass}`]: {
+                [`.${MainClassContent}`]: {
+                    maxHeight: `${tooltip.expanded.maxHeight - tooltip.expanded.maxHeightDescription}px !important`,
+                },
+            },
+        },
+    };
+});
+function MaqlEditorTooltip({ content, intl, backend, workspaceId }) {
+    return (_jsx(IntlProvider, { locale: intl ? intl.locale : "en-US", defaultLocale: intl ? intl.locale : "en-US", messages: intl ? intl.messages : {}, children: _jsx(BackendProvider, { backend: backend, children: _jsx(WorkspaceProvider, { workspace: workspaceId, children: _jsx(MaqlEditorTooltipContent, { content: content }) }) }) }));
+}
+function MaqlEditorTooltipContent({ content }) {
+    const { classes, cx } = useStyles();
+    const { title, description, maql } = content;
+    const ls = useLanguageService();
+    const decoration = useDecoration(ls, true);
+    const [theme, themeData] = useCodeTheme();
+    const options = useEditorOptions();
+    const { expanded, setHasScrollbar } = useExpandableTooltip();
+    const [descriptionOpened, setDescriptionOpened] = useState(false);
+    const [readMore, setReadMore] = useState(false);
+    const descElementRef = useRef(null);
+    const descElement = descElementRef.current;
+    useEffect(() => setReadMore(Boolean(descElement && descElement.scrollHeight > descElement.offsetHeight)), [descElement]);
+    return (_jsx(_Fragment, { children: _jsxs("div", { className: classes.content, children: [_jsx("h2", { className: cx(classes.title, descriptionOpened && BiggerClass, expanded && ExpandedClass), children: title }), !expanded && (_jsxs("div", { className: cx(classes.description, descriptionOpened && BiggerClass), ref: descElementRef, children: [description, readMore && !descriptionOpened && (_jsxs("div", { className: classes.readMore, children: [_jsx("span", { children: "\u2026" }), _jsx("a", { onClick: () => {
+                                        setDescriptionOpened(true);
+                                        setHasScrollbar(true);
+                                    }, children: _jsx(FormattedMessage, { id: "metricComponent.editMetric.hover.more" }) })] })), readMore && descriptionOpened && (_jsx("span", { className: classes.readLess, children: _jsx("a", { onClick: () => {
+                                    setDescriptionOpened(false);
+                                    setHasScrollbar(false);
+                                    if (descElement) {
+                                        descElement.scrollTop = 0;
+                                    }
+                                }, children: _jsx(FormattedMessage, { id: "metricComponent.editMetric.hover.less" }) }) }))] })), expanded && _jsx("div", { className: cx(classes.description, ExpandedClass), children: description }), _jsx("div", { className: classes.hr }), _jsx("div", { className: cx(classes.maql, descriptionOpened && SmallerClass, expanded && ExpandedClass), children: _jsx(MonacoEditor, { className: MaqlTooltipEditorClass, inline: true, options: options, readonly: true, autofocus: false, defaultValue: maql, language: LANGUAGE, themeName: theme, themeData: themeData, onEditorMount: (editor) => decoration(editor) }) })] }) }));
+}
+export function renderMaqlTooltip(ref, { content, backend, workspaceId, intl, elements, anchor, readOnly, cachedPositions }, onOpen, onDestroy) {
+    if (!content) {
+        return;
+    }
+    // Validate elements
+    if (!elements || elements.length === 0) {
+        return;
+    }
+    renderTooltip(ref, {
+        elements,
+        anchor,
+        className: classNames("s_maql_tooltip", MaqlTooltip),
+        readOnly,
+        onOpen,
+        onDestroy,
+        cachedPositions,
+    }, _jsxs(_Fragment, { children: [_jsx(TooltipMaqlStyles, {}), _jsx(MaqlEditorTooltip, { content: content, backend: backend, workspaceId: workspaceId, intl: intl })] }));
+}
+export function destroyMaqlTooltip(ref) {
+    destroyTooltip(ref);
+}
+function useEditorOptions() {
+    return useMemo(() => ({
+        lineNumbers: "off",
+        lineNumbersMinChars: 0,
+        folding: false,
+    }), []);
+}

package/esm/MaqlEditor/maql/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const LANGUAGE = "maql";
+//# sourceMappingURL=constants.d.ts.map

package/esm/MaqlEditor/maql/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/MaqlEditor/maql/constants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,QAAQ,SAAS,CAAC"}

package/esm/MaqlEditor/maql/constants.js

@@ -0,0 +1,2 @@
+// (C) 2022-2026 GoodData Corporation
+export const LANGUAGE = "maql";

package/esm/MaqlEditor/maql/formatter.d.ts

@@ -0,0 +1,6 @@
+import * as monaco from "monaco-editor/editor/editor.api.js";
+import { type TextDocument } from "vscode-languageserver-textdocument";
+import { type MaqlLanguageService } from "@gooddata/sdk-maql-language-server";
+import { type FormattingOptions, type Range } from "../monaco/MonacoEditor.js";
+export declare function formatDocument(languageService: MaqlLanguageService, document: TextDocument, options: FormattingOptions, range?: Range): Promise<monaco.languages.TextEdit[]>;
+//# sourceMappingURL=formatter.d.ts.map

package/esm/MaqlEditor/maql/formatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatter.d.ts","sourceRoot":"","sources":["../../../src/MaqlEditor/maql/formatter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,MAAM,oCAAoC,CAAC;AAE7D,OAAO,EAAE,KAAK,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAEvE,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAG9E,OAAO,EAAE,KAAK,iBAAiB,EAAE,KAAK,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAE/E,wBAAgB,cAAc,CAC1B,eAAe,EAAE,mBAAmB,EACpC,QAAQ,EAAE,YAAY,EACtB,OAAO,EAAE,iBAAiB,EAC1B,KAAK,CAAC,EAAE,KAAK,GACd,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC,CAatC"}

package/esm/MaqlEditor/maql/formatter.js

@@ -0,0 +1,14 @@
+// (C) 2022-2026 GoodData Corporation
+import * as monaco from "monaco-editor/editor/editor.api.js";
+import { MonacoToProtocolConverter, ProtocolToMonacoConverter } from "monaco-languageclient/monaco-converter";
+export function formatDocument(languageService, document, options, range) {
+    const m2p = new MonacoToProtocolConverter(monaco);
+    const p2m = new ProtocolToMonacoConverter(monaco);
+    const formattingOptions = m2p.asFormattingOptions(options);
+    if (range) {
+        return languageService
+            .doFormatRange(document, m2p.asRange(range), formattingOptions)
+            .then((edits) => p2m.asTextEdits(edits));
+    }
+    return languageService.doFormat(document, formattingOptions).then((edits) => p2m.asTextEdits(edits));
+}

package/esm/MaqlEditor/maql/hooks/hover/doHover.d.ts

@@ -0,0 +1,12 @@
+import { type MutableRefObject } from "react";
+import type * as monaco from "monaco-editor/editor/editor.api.js";
+import { type ObjectContent } from "@gooddata/sdk-maql-language-server";
+import { type IMetadataObject } from "@gooddata/sdk-model";
+import { type IRootRef } from "../../../components/ExpandableTooltip.js";
+import { type IStandaloneCodeEditor } from "../../../monaco/MonacoEditor.js";
+import { type MaqlTooltipSettings } from "../../MaqlEditor.tooltip.js";
+export type HoverSettings = Omit<MaqlTooltipSettings, "elements" | "content"> & {
+    content: ObjectContent | null | undefined;
+};
+export declare function doHover(event: MouseEvent | KeyboardEvent | null, tooltip: MutableRefObject<IRootRef | null>, editor: IStandaloneCodeEditor, hover: monaco.languages.Hover | null, settings: HoverSettings, onOpen?: (editor: IStandaloneCodeEditor, object: IMetadataObject) => void): monaco.languages.Hover | null;
+//# sourceMappingURL=doHover.d.ts.map

package/esm/MaqlEditor/maql/hooks/hover/doHover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doHover.d.ts","sourceRoot":"","sources":["../../../../../src/MaqlEditor/maql/hooks/hover/doHover.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,OAAO,CAAC;AAE9C,OAAO,KAAK,KAAK,MAAM,MAAM,oCAAoC,CAAC;AAElE,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,oCAAoC,CAAC;AACxE,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAE3D,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,0CAA0C,CAAC;AACzE,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAM7E,OAAO,EAAE,KAAK,mBAAmB,EAAqB,MAAM,6BAA6B,CAAC;AAgB1F,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,mBAAmB,EAAE,UAAU,GAAG,SAAS,CAAC,GAAG;IAC5E,OAAO,EAAE,aAAa,GAAG,IAAI,GAAG,SAAS,CAAC;CAC7C,CAAC;AAEF,wBAAgB,OAAO,CACnB,KAAK,EAAE,UAAU,GAAG,aAAa,GAAG,IAAI,EACxC,OAAO,EAAE,gBAAgB,CAAC,QAAQ,GAAG,IAAI,CAAC,EAC1C,MAAM,EAAE,qBAAqB,EAC7B,KAAK,EAAE,MAAM,CAAC,SAAS,CAAC,KAAK,GAAG,IAAI,EACpC,QAAQ,EAAE,aAAa,EACvB,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,MAAM,EAAE,eAAe,KAAK,IAAI,GAC1E,MAAM,CAAC,SAAS,CAAC,KAAK,GAAG,IAAI,CAgF/B"}

package/esm/MaqlEditor/maql/hooks/hover/doHover.js

@@ -0,0 +1,126 @@
+// (C) 2021-2026 GoodData Corporation
+import { DecoratorClassName, DecoratorHovered, DecoratorItemClassName, } from "../../../monaco/MonacoEditor.styles.js";
+import { renderMaqlTooltip } from "../../MaqlEditor.tooltip.js";
+// Position cache using WeakMap to avoid modifying elements directly
+const positionCache = new WeakMap();
+export function doHover(event, tooltip, editor, hover, settings, onOpen) {
+    // Early return cases
+    if (!hover || !event || tooltip.current || !settings.content) {
+        return settings.content ? null : hover;
+    }
+    const containerNode = editor.getContainerDomNode();
+    if (!containerNode) {
+        return null;
+    }
+    try {
+        // Collect valid DOM elements and ensure they have valid dimensions
+        const rawElements = collectElements(containerNode, event);
+        const elements = rawElements.filter((el) => {
+            const isValid = el && document.body.contains(el);
+            if (isValid) {
+                const rect = el.getBoundingClientRect();
+                // Store position in the WeakMap instead of on the element
+                positionCache.set(el, {
+                    top: rect.top,
+                    left: rect.left,
+                    width: rect.width,
+                    height: rect.height,
+                });
+                return rect.width > 0 && rect.height > 0;
+            }
+            return false;
+        });
+        if (elements.length === 0) {
+            return null;
+        }
+        // Create a decorator for the hovered element
+        const decorator = createDecorator(editor, hover);
+        // Prepare the callback for when the tooltip is opened
+        const handleOpen = () => {
+            if (!settings.content)
+                return;
+            onOpen?.(editor, {
+                type: "measure",
+                ...settings.content,
+                deprecated: false,
+                production: true,
+                unlisted: false,
+                uri: "",
+            });
+        };
+        // Prepare the cleanup callback for when the tooltip is closed
+        const handleDestroy = () => {
+            removeDecorator(editor, decorator);
+        };
+        // Render the tooltip immediately
+        renderMaqlTooltip(tooltip, {
+            ...settings,
+            elements,
+            // the hovered spans are re-rendered by Monaco (the hover decoration added above
+            // already triggers that), so the editor node is the stable owner of the tooltip
+            anchor: containerNode,
+            content: settings.content,
+            cachedPositions: elements.map((el) => positionCache.get(el)),
+        }, handleOpen, handleDestroy);
+    }
+    catch {
+        // Silent error handling
+    }
+    // Return null to prevent monaco from showing its default tooltip
+    return null;
+}
+function collectElements(parent, event) {
+    const element = collectTarget(parent, event);
+    if (!element)
+        return [];
+    const items = [];
+    if (isDecorator(element)) {
+        items.push(element);
+    }
+    if (element) {
+        let current = element.previousElementSibling;
+        while (current && isDecorator(current)) {
+            items.unshift(current);
+            current = current.previousElementSibling;
+        }
+        current = element.nextElementSibling;
+        while (current && isDecorator(current)) {
+            items.push(current);
+            current = current.nextElementSibling;
+        }
+    }
+    return items;
+}
+function collectTarget(parent, event) {
+    if (event.type === "keydown") {
+        const cursor = parent.querySelector(".cursor.monaco-mouse-cursor-text");
+        if (cursor) {
+            const { x, y, height } = cursor.getBoundingClientRect();
+            const elementFromPoint = document.elementFromPoint(x - 1, y + height / 2);
+            return elementFromPoint || null;
+        }
+    }
+    const target = event.target;
+    return target || null;
+}
+function isDecorator(el) {
+    if (!el)
+        return false;
+    return el.classList.contains(DecoratorClassName) || el.classList.contains(DecoratorItemClassName);
+}
+function createDecorator(editor, hover) {
+    if (!hover.range) {
+        return [];
+    }
+    return editor.deltaDecorations([], [
+        {
+            range: hover.range,
+            options: {
+                inlineClassName: DecoratorHovered,
+            },
+        },
+    ]);
+}
+function removeDecorator(editor, decorator) {
+    editor.deltaDecorations(decorator, []);
+}

package/esm/MaqlEditor/maql/hooks/hover/useHoverEvent.d.ts

@@ -0,0 +1,4 @@
+import { type MutableRefObject } from "react";
+import { type IRootRef } from "../../../components/ExpandableTooltip.js";
+export declare function useHoverEvent(editorElement: HTMLElement | null, tooltip: MutableRefObject<IRootRef | null>, isHoverShortcut: (e: KeyboardEvent) => boolean): MutableRefObject<MouseEvent | KeyboardEvent | null>;
+//# sourceMappingURL=useHoverEvent.d.ts.map

package/esm/MaqlEditor/maql/hooks/hover/useHoverEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHoverEvent.d.ts","sourceRoot":"","sources":["../../../../../src/MaqlEditor/maql/hooks/hover/useHoverEvent.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,gBAAgB,EAAqB,MAAM,OAAO,CAAC;AAEjE,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,0CAA0C,CAAC;AAGzE,wBAAgB,aAAa,CACzB,aAAa,EAAE,WAAW,GAAG,IAAI,EACjC,OAAO,EAAE,gBAAgB,CAAC,QAAQ,GAAG,IAAI,CAAC,EAC1C,eAAe,EAAE,CAAC,CAAC,EAAE,aAAa,KAAK,OAAO,GAC/C,gBAAgB,CAAC,UAAU,GAAG,aAAa,GAAG,IAAI,CAAC,CAkCrD"}

package/esm/MaqlEditor/maql/hooks/hover/useHoverEvent.js

@@ -0,0 +1,32 @@
+// (C) 2021-2026 GoodData Corporation
+import { useEffect, useRef } from "react";
+import { destroyMaqlTooltip } from "../../MaqlEditor.tooltip.js";
+export function useHoverEvent(editorElement, tooltip, isHoverShortcut) {
+    const currentEvent = useRef(null);
+    useEffect(() => {
+        const handlerEvent = (e) => {
+            // Store the current event for use in hover provider
+            currentEvent.current = e;
+        };
+        const handleKey = (e) => {
+            //Do not hide if there is triggered shortcut Ctrl/Cmd + u
+            if (isHoverShortcut(e)) {
+                return;
+            }
+            destroyMaqlTooltip(tooltip);
+        };
+        if (editorElement) {
+            editorElement.addEventListener("mousemove", handlerEvent);
+            editorElement.addEventListener("keydown", handlerEvent);
+            editorElement.addEventListener("keydown", handleKey);
+        }
+        return () => {
+            if (editorElement) {
+                editorElement.removeEventListener("mousemove", handlerEvent);
+                editorElement.removeEventListener("keydown", handlerEvent);
+                editorElement.removeEventListener("keydown", handleKey);
+            }
+        };
+    }, [editorElement, tooltip, isHoverShortcut]);
+    return currentEvent;
+}

package/esm/MaqlEditor/maql/hooks/useAutocomplete.d.ts

@@ -0,0 +1,4 @@
+import { type CompletionList, type InitializeResult } from "vscode-languageserver";
+import { type MaqlLanguageService } from "@gooddata/sdk-maql-language-server";
+export declare function useAutocomplete(languageId: string, languageService: MaqlLanguageService | undefined, initializeData: InitializeResult | undefined, onList: (list: CompletionList) => void): void;
+//# sourceMappingURL=useAutocomplete.d.ts.map

package/esm/MaqlEditor/maql/hooks/useAutocomplete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAutocomplete.d.ts","sourceRoot":"","sources":["../../../../src/MaqlEditor/maql/hooks/useAutocomplete.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,gBAAgB,EAAY,MAAM,uBAAuB,CAAC;AAG7F,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAW9E,wBAAgB,eAAe,CAC3B,UAAU,EAAE,MAAM,EAClB,eAAe,EAAE,mBAAmB,GAAG,SAAS,EAChD,cAAc,EAAE,gBAAgB,GAAG,SAAS,EAC5C,MAAM,EAAE,CAAC,IAAI,EAAE,cAAc,KAAK,IAAI,GACvC,IAAI,CAwDN"}

package/esm/MaqlEditor/maql/hooks/useAutocomplete.js

@@ -0,0 +1,60 @@
+// (C) 2021-2026 GoodData Corporation
+import { useEffect } from "react";
+import * as monaco from "monaco-editor/editor/editor.api.js";
+import { MonacoToProtocolConverter, ProtocolToMonacoConverter } from "monaco-languageclient/monaco-converter";
+//more info in README.md
+import { TextEdit } from "vscode-languageserver";
+import { createDocument } from "../utils.js";
+const triggerSuggestCommand = {
+    title: "trigger suggestion",
+    command: "editor.action.triggerSuggest",
+};
+let completionRequestCounter = 0;
+export function useAutocomplete(languageId, languageService, initializeData, onList) {
+    useEffect(() => {
+        if (!languageService || !initializeData) {
+            return;
+        }
+        const m2p = new MonacoToProtocolConverter(monaco);
+        const p2m = new ProtocolToMonacoConverter(monaco);
+        const disposeCompletion = monaco.languages.registerCompletionItemProvider(languageId, {
+            triggerCharacters: initializeData.capabilities.completionProvider?.triggerCharacters,
+            provideCompletionItems: (model, position) => {
+                const document = createDocument(model);
+                const wordUntil = model.getWordUntilPosition(position);
+                const defaultRange = new monaco.Range(position.lineNumber, wordUntil.startColumn, position.lineNumber, wordUntil.endColumn);
+                onList({ isIncomplete: false, items: [] });
+                ++completionRequestCounter;
+                return languageService
+                    ?.doCompletion(document, m2p.asPosition(position.lineNumber, position.column))
+                    .then((list) => {
+                    const modifiedList = {
+                        isIncomplete: list.isIncomplete,
+                        items: list.items.map((item) => {
+                            return {
+                                ...item,
+                                textEdit: TextEdit.is(item.textEdit) ? item.textEdit : undefined,
+                                command: triggerSuggestCommand,
+                            };
+                        }),
+                    };
+                    if (completionRequestCounter == 1) {
+                        onList(modifiedList);
+                    }
+                    return p2m.asCompletionResult(modifiedList, defaultRange);
+                })
+                    .finally(() => --completionRequestCounter);
+            },
+            resolveCompletionItem: (item) => languageService.doCompletionResolve(m2p.asCompletionItem(item)).then((result) => {
+                const protocolItem = p2m.asCompletionItem(result, item.range);
+                return {
+                    ...item,
+                    ...protocolItem,
+                };
+            }),
+        });
+        return () => {
+            disposeCompletion.dispose();
+        };
+    }, [languageId, languageService, initializeData, onList]);
+}

package/esm/MaqlEditor/maql/hooks/useDecoration.d.ts

@@ -0,0 +1,4 @@
+import { type MaqlLanguageService } from "@gooddata/sdk-maql-language-server";
+import { type IStandaloneCodeEditor } from "../../monaco/MonacoEditor.js";
+export declare function useDecoration(languageService: MaqlLanguageService | undefined, decorators: boolean): (editor: IStandaloneCodeEditor | null) => void;
+//# sourceMappingURL=useDecoration.d.ts.map

package/esm/MaqlEditor/maql/hooks/useDecoration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDecoration.d.ts","sourceRoot":"","sources":["../../../../src/MaqlEditor/maql/hooks/useDecoration.ts"],"names":[],"mappings":"AAQA,OAAO,EAAoB,KAAK,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAGhG,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAI1E,wBAAgB,aAAa,CACzB,eAAe,EAAE,mBAAmB,GAAG,SAAS,EAChD,UAAU,EAAE,OAAO,GACpB,CAAC,MAAM,EAAE,qBAAqB,GAAG,IAAI,KAAK,IAAI,CAoChD"}

package/esm/MaqlEditor/maql/hooks/useDecoration.js

@@ -0,0 +1,73 @@
+// (C) 2021-2026 GoodData Corporation
+import { useCallback, useEffect, useRef } from "react";
+import * as monaco from "monaco-editor/editor/editor.api.js";
+import { ProtocolToMonacoConverter } from "monaco-languageclient/monaco-converter";
+import { Decorators } from "../../monaco/MonacoEditor.styles.js";
+import { createDocument } from "../utils.js";
+export function useDecoration(languageService, decorators) {
+    const decoratorsCollection = useRef(null);
+    const editorRef = useRef(null);
+    // Apply decorations in an effect to ensure proper timing with React 18
+    useEffect(() => {
+        if (editorRef.current) {
+            doDecorate(languageService, getDocument(editorRef.current), editorRef.current, decoratorsCollection, decorators);
+        }
+        // Capture the current value of decoratorsCollection.current to use in cleanup
+        const currentCollection = decoratorsCollection.current;
+        // Cleanup function to clear decorations when component unmounts
+        return () => {
+            if (currentCollection) {
+                currentCollection.clear();
+            }
+        };
+    }, [languageService, decorators]);
+    return useCallback((editor) => {
+        if (editor) {
+            editorRef.current = editor;
+            doDecorate(languageService, getDocument(editor), editor, decoratorsCollection, decorators);
+        }
+    }, [decorators, languageService]);
+}
+function getDocument(editor) {
+    const model = editor?.getModel();
+    return model ? createDocument(model) : null;
+}
+function doDecorate(languageService, document, editor, decoratorsCollection, state) {
+    const p2m = new ProtocolToMonacoConverter(monaco);
+    if (!languageService || !document) {
+        return;
+    }
+    if (!decoratorsCollection.current) {
+        decoratorsCollection.current = editor.createDecorationsCollection([]);
+    }
+    //decorators are turned off
+    if (!state) {
+        decoratorsCollection.current.clear();
+        return;
+    }
+    //decorators are turned on
+    languageService.doDecoration(document).then((lspDecorations) => {
+        // Check if the collection still exists before setting decorations
+        if (decoratorsCollection.current) {
+            decoratorsCollection.current.set(asDecorations(p2m, lspDecorations));
+        }
+    });
+}
+function asDecorations(p2m, decorations) {
+    return decorations.map((decoration) => {
+        const def = Decorators[decoration.options.type] || Decorators["default"];
+        return {
+            range: p2m.asRange(decoration.range),
+            options: {
+                hoverMessage: decoration.options.hoverMessage,
+                inlineClassName: def.decoratorItem.join(" "),
+                before: {
+                    inlineClassName: def.decorator.join(" "),
+                    inlineClassNameAffectsLetterSpacing: true,
+                    //NOTE: Keep space before and after to simulate padding
+                    content: ` ${decoration.options.label} `,
+                },
+            },
+        };
+    });
+}

package/esm/MaqlEditor/maql/hooks/useDocumentFormatting.d.ts

@@ -0,0 +1,3 @@
+import { type MaqlLanguageService } from "@gooddata/sdk-maql-language-server";
+export declare function useDocumentFormatting(languageId: string, languageService: MaqlLanguageService | undefined): void;
+//# sourceMappingURL=useDocumentFormatting.d.ts.map

package/esm/MaqlEditor/maql/hooks/useDocumentFormatting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDocumentFormatting.d.ts","sourceRoot":"","sources":["../../../../src/MaqlEditor/maql/hooks/useDocumentFormatting.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAK9E,wBAAgB,qBAAqB,CACjC,UAAU,EAAE,MAAM,EAClB,eAAe,EAAE,mBAAmB,GAAG,SAAS,GACjD,IAAI,CA4BN"}

package/esm/MaqlEditor/maql/hooks/useDocumentFormatting.js

@@ -0,0 +1,29 @@
+// (C) 2022-2026 GoodData Corporation
+//more info in README.md
+import { useEffect } from "react";
+import * as monaco from "monaco-editor/editor/editor.api.js";
+import { formatDocument } from "../formatter.js";
+import { createDocument } from "../utils.js";
+export function useDocumentFormatting(languageId, languageService) {
+    useEffect(() => {
+        if (!languageService) {
+            return;
+        }
+        const disposeFormatting = monaco.languages.registerDocumentFormattingEditProvider(languageId, {
+            provideDocumentFormattingEdits: (model, options) => {
+                const document = createDocument(model);
+                return formatDocument(languageService, document, options);
+            },
+        });
+        const disposeRangeFormatting = monaco.languages.registerDocumentRangeFormattingEditProvider(languageId, {
+            provideDocumentRangeFormattingEdits: (model, range, options) => {
+                const document = createDocument(model);
+                return formatDocument(languageService, document, options, range);
+            },
+        });
+        return () => {
+            disposeFormatting.dispose();
+            disposeRangeFormatting.dispose();
+        };
+    }, [languageId, languageService]);
+}

package/esm/MaqlEditor/maql/hooks/useHover.d.ts

@@ -0,0 +1,6 @@
+import { type InitializeResult } from "vscode-languageserver";
+import { type MaqlLanguageService } from "@gooddata/sdk-maql-language-server";
+import { type IMetadataObject } from "@gooddata/sdk-model";
+import { type IStandaloneCodeEditor } from "../../monaco/MonacoEditor.js";
+export declare function useHover(editor: IStandaloneCodeEditor | null, languageId: string, languageService: MaqlLanguageService | undefined, initializeData: InitializeResult | undefined, onOpen?: (editor: IStandaloneCodeEditor, object: IMetadataObject) => void): void;
+//# sourceMappingURL=useHover.d.ts.map

package/esm/MaqlEditor/maql/hooks/useHover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useHover.d.ts","sourceRoot":"","sources":["../../../../src/MaqlEditor/maql/hooks/useHover.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAC9E,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAK3D,OAAO,EAAE,KAAK,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAO1E,wBAAgB,QAAQ,CACpB,MAAM,EAAE,qBAAqB,GAAG,IAAI,EACpC,UAAU,EAAE,MAAM,EAClB,eAAe,EAAE,mBAAmB,GAAG,SAAS,EAChD,cAAc,EAAE,gBAAgB,GAAG,SAAS,EAC5C,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,MAAM,EAAE,eAAe,KAAK,IAAI,GAC1E,IAAI,CA6DN"}