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

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

@@ -0,0 +1,77 @@
+// (C) 2021-2026 GoodData Corporation
+import { useEffect, useMemo, useRef } from "react";
+import * as monaco from "monaco-editor/editor/editor.api.js";
+import { MonacoToProtocolConverter, ProtocolToMonacoConverter } from "monaco-languageclient/monaco-converter";
+import { useIntl } from "react-intl";
+import { useBackendStrict, useWorkspaceStrict } from "@gooddata/sdk-ui";
+import { destroyMaqlTooltip } from "../MaqlEditor.tooltip.js";
+import { createDocument } from "../utils.js";
+import { doHover } from "./hover/doHover.js";
+import { useHoverEvent } from "./hover/useHoverEvent.js";
+export function useHover(editor, languageId, languageService, initializeData, onOpen) {
+    const tooltip = useRef(null);
+    const [isHoverShortcut, shortcut] = useHoverShortcut();
+    const currentEvent = useHoverEvent(editor?.getContainerDomNode() ?? null, tooltip, isHoverShortcut);
+    const backend = useBackendStrict();
+    const workspaceId = useWorkspaceStrict();
+    const intl = useIntl();
+    useEffect(() => {
+        if (!isReady(editor, languageService, initializeData)) {
+            return;
+        }
+        editor.addCommand(shortcut, () => {
+            editor.trigger("", "editor.action.showHover", "");
+        });
+        const m2p = new MonacoToProtocolConverter(monaco);
+        const p2m = new ProtocolToMonacoConverter(monaco);
+        const disposeHover = monaco.languages.registerHoverProvider(languageId, {
+            provideHover: (model, position) => {
+                const document = createDocument(model);
+                return languageService
+                    ?.doHover(document, m2p.asPosition(position.lineNumber, position.column))
+                    .then((hover) => {
+                    const readOnly = Boolean(editor.getRawOptions().readOnly || hover?.object?.isLocked);
+                    const monacoHover = p2m.asHover(hover) || null;
+                    const settings = {
+                        backend,
+                        workspaceId,
+                        intl,
+                        content: hover?.object,
+                        readOnly,
+                    };
+                    return doHover(currentEvent.current, tooltip, editor, monacoHover, settings, onOpen);
+                })
+                    .catch((_error) => {
+                    return null;
+                });
+            },
+        });
+        return () => {
+            disposeHover.dispose();
+            destroyMaqlTooltip(tooltip);
+        };
+    }, [
+        shortcut,
+        editor,
+        intl,
+        languageId,
+        languageService,
+        initializeData,
+        backend,
+        workspaceId,
+        currentEvent,
+        onOpen,
+    ]);
+}
+function isReady(editor, languageService, initializeData) {
+    return Boolean(editor && languageService && initializeData?.capabilities?.hoverProvider);
+}
+function useHoverShortcut() {
+    return useMemo(() => [
+        (e) => isCtrlOrCmd(e) && e.key === "u",
+        monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyU,
+    ], []);
+}
+function isCtrlOrCmd(e) {
+    return e.ctrlKey || e.metaKey;
+}

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

@@ -0,0 +1,4 @@
+import type * as monaco from "monaco-editor/editor/editor.api.js";
+export type ILanguageConfiguration = monaco.languages.LanguageConfiguration;
+export declare function useLanguageConfiguration(): ILanguageConfiguration;
+//# sourceMappingURL=useLanguageConfiguration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useLanguageConfiguration.d.ts","sourceRoot":"","sources":["../../../../src/MaqlEditor/maql/hooks/useLanguageConfiguration.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,MAAM,oCAAoC,CAAC;AAGlE,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,SAAS,CAAC,qBAAqB,CAAC;AAE5E,wBAAgB,wBAAwB,IAAI,sBAAsB,CAqBjE"}

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

@@ -0,0 +1,21 @@
+// (C) 2022-2026 GoodData Corporation
+import { useMemo } from "react";
+export function useLanguageConfiguration() {
+    return useMemo(() => ({
+        comments: {
+            lineComment: "#",
+            blockComment: null,
+        },
+        brackets: [["(", ")"]],
+        autoClosingPairs: [
+            { open: "{", close: "}" },
+            { open: "(", close: ")" },
+            { open: '"', close: '"' },
+        ],
+        surroundingPairs: [
+            { open: "{", close: "}" },
+            { open: "(", close: ")" },
+            { open: '"', close: '"' },
+        ],
+    }), []);
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"useLanguageService.d.ts","sourceRoot":"","sources":["../../../../src/MaqlEditor/maql/hooks/useLanguageService.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,mBAAmB,EAAmB,MAAM,oCAAoC,CAAC;AAK1F,wBAAgB,kBAAkB,IAAI,mBAAmB,GAAG,SAAS,CAiBpE"}

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

@@ -0,0 +1,21 @@
+// (C) 2021-2026 GoodData Corporation
+import { useContext, useEffect, useState } from "react";
+import { MaqlLanguageService, MetadataService } from "@gooddata/sdk-maql-language-server";
+import { useBackendStrict, useWorkspaceStrict } from "@gooddata/sdk-ui";
+import { LanguageServiceContext } from "../../languageService/LanguageServiceContext.js";
+export function useLanguageService() {
+    const contextService = useContext(LanguageServiceContext);
+    const backend = useBackendStrict();
+    const workspaceId = useWorkspaceStrict();
+    const [languageService, setLanguageService] = useState();
+    useEffect(() => {
+        if (contextService) {
+            setLanguageService(contextService);
+        }
+        else {
+            const metadataService = MetadataService.withBackend(workspaceId, backend);
+            setLanguageService(new MaqlLanguageService(undefined, metadataService));
+        }
+    }, [contextService, backend, workspaceId]);
+    return languageService;
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"useLanguageServiceInitializer.d.ts","sourceRoot":"","sources":["../../../../src/MaqlEditor/maql/hooks/useLanguageServiceInitializer.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAE9E,wBAAgB,6BAA6B,CACzC,eAAe,EAAE,mBAAmB,GAAG,SAAS,GACjD,gBAAgB,GAAG,SAAS,CAU9B"}

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

@@ -0,0 +1,11 @@
+// (C) 2021-2026 GoodData Corporation
+import { useEffect, useState } from "react";
+export function useLanguageServiceInitializer(languageService) {
+    const [initializeData, setInitializeData] = useState();
+    useEffect(() => {
+        if (languageService) {
+            setInitializeData(languageService.initialize());
+        }
+    }, [languageService, setInitializeData]);
+    return initializeData;
+}

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

@@ -0,0 +1,21 @@
+import { type CompletionList } from "vscode-languageserver";
+import { type IMetadataObject } from "@gooddata/sdk-model";
+import { type IStandaloneCodeEditor, type Monaco } from "../../monaco/MonacoEditor.js";
+export type MonacoHandlers = {
+    onFocus?: (editor: IStandaloneCodeEditor, monaco: Monaco) => void;
+    onBlur?: (editor: IStandaloneCodeEditor, monaco: Monaco) => void;
+    onEditorMount?: (editor: IStandaloneCodeEditor, monaco: Monaco) => void;
+    onEditorUpdate?: (editor: IStandaloneCodeEditor, monaco: Monaco) => void;
+    onList: (list: CompletionList | null, el: HTMLElement | null) => void;
+    onChange?: (editor: IStandaloneCodeEditor, monaco: Monaco, value: string) => void;
+    onValid?: (editor: IStandaloneCodeEditor, monaco: Monaco, valid: boolean) => void;
+    onOpen?: (editor: IStandaloneCodeEditor, object: IMetadataObject) => void;
+};
+export declare function useMonaco(languageId: string, autohint: boolean, decorators: boolean, handlers: MonacoHandlers): {
+    onMount: (editor: IStandaloneCodeEditor, monaco: Monaco) => void;
+    onUpdate: (editor: IStandaloneCodeEditor, monaco: Monaco) => void;
+    autoformat: (editor: IStandaloneCodeEditor, monaco: Monaco) => void;
+    getValue: (editor: IStandaloneCodeEditor) => string;
+    getValid: (editor: IStandaloneCodeEditor, monaco: Monaco) => boolean;
+};
+//# sourceMappingURL=useMonaco.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useMonaco.d.ts","sourceRoot":"","sources":["../../../../src/MaqlEditor/maql/hooks/useMonaco.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,OAAO,EAAE,KAAK,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAQ3D,OAAO,EAAE,KAAK,qBAAqB,EAAE,KAAK,MAAM,EAAE,MAAM,8BAA8B,CAAC;AAavF,MAAM,MAAM,cAAc,GAAG;IACzB,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAClE,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACjE,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACxE,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACzE,MAAM,EAAE,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,EAAE,EAAE,EAAE,WAAW,GAAG,IAAI,KAAK,IAAI,CAAC;IACtE,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IAClF,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAClF,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,MAAM,EAAE,eAAe,KAAK,IAAI,CAAC;CAC7E,CAAC;AAEF,wBAAgB,SAAS,CACrB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,OAAO,EACjB,UAAU,EAAE,OAAO,EACnB,QAAQ,EAAE,cAAc,GACzB;IACC,OAAO,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACjE,QAAQ,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IAClE,UAAU,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACpE,QAAQ,EAAE,CAAC,MAAM,EAAE,qBAAqB,KAAK,MAAM,CAAC;IACpD,QAAQ,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC;CACxE,CAmFA"}

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

@@ -0,0 +1,75 @@
+// (C) 2021-2026 GoodData Corporation
+import { useCallback, useEffect, useState } from "react";
+import { useProp } from "../../../shared/hooks/useProp.js";
+import { useAutoformat } from "../../hooks/useAutoformat.js";
+import { useCleanCallback } from "../../hooks/useCleanCallback.js";
+import { useMountCallback } from "../../hooks/useMountCallback.js";
+import { useUpdateCallback } from "../../hooks/useUpdateCallback.js";
+import { useValueCallbacks } from "../../hooks/useValueCallbacks.js";
+import { onSuggestionElement } from "../../statusBar/SuggestionStatusBar.js";
+import { useAutocomplete } from "./useAutocomplete.js";
+import { useDecoration } from "./useDecoration.js";
+import { useDocumentFormatting } from "./useDocumentFormatting.js";
+import { useHover } from "./useHover.js";
+import { useLanguageService } from "./useLanguageService.js";
+import { useLanguageServiceInitializer } from "./useLanguageServiceInitializer.js";
+import { useSemanticHighlight } from "./useSemanticHighlight.js";
+import { useSyntaxHighlight } from "./useSyntaxHighlight.js";
+import { useValidation } from "./useValidation.js";
+export function useMonaco(languageId, autohint, decorators, handlers) {
+    const [hints, setHints] = useProp(autohint);
+    const [list, setList] = useState(null);
+    const [listElement, setListElement] = useState(null);
+    const [codeEditor, setCodeEditor] = useState(null);
+    const { onFocus, onBlur, onEditorMount, onEditorUpdate, onValid, onList, onChange, onOpen } = handlers;
+    const languageService = useLanguageService();
+    const initializeData = useLanguageServiceInitializer(languageService);
+    const validation = useValidation(languageService);
+    const decoration = useDecoration(languageService, decorators);
+    useEffect(() => onList(list, listElement), [list, listElement, onList]);
+    useEffect(() => decoration(codeEditor), [codeEditor, decoration]);
+    useAutocomplete(languageId, languageService, initializeData, setList);
+    useSyntaxHighlight(languageId);
+    useSemanticHighlight(languageId, languageService, initializeData);
+    useHover(codeEditor, languageId, languageService, initializeData, onOpen);
+    useDocumentFormatting(languageId, languageService);
+    const { getValue, getValid } = useValueCallbacks();
+    const [mountCallback, disposableMount] = useMountCallback({
+        setCodeEditor,
+        afterStart: useCallback((editor, monaco) => {
+            //suggestion element
+            onSuggestionElement(editor, setListElement);
+            //validate and decorate on start
+            decoration(editor);
+            validation(editor, monaco);
+        }, [decoration, validation]),
+    }, { onEditorMount });
+    const [updateCallback, disposableUpdate] = useUpdateCallback({
+        getValue,
+        getValid,
+        afterFocus: useCallback((editor) => {
+            if (hints) {
+                editor.trigger("", "editor.action.marker.next", "");
+            }
+        }, [hints]),
+        afterChange: useCallback((editor, monaco) => {
+            decoration(editor);
+            validation(editor, monaco);
+            setHints(false);
+        }, [decoration, setHints, validation]),
+        afterValidate: useCallback((_editor, _monaco, valid) => {
+            if (valid) {
+                setHints(false);
+            }
+        }, [setHints]),
+    }, { onFocus, onBlur, onValid, onChange, onEditorUpdate });
+    const autoformat = useAutoformat(onChange);
+    useCleanCallback(disposableMount, disposableUpdate);
+    return {
+        onMount: mountCallback,
+        onUpdate: updateCallback,
+        autoformat,
+        getValue,
+        getValid,
+    };
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"useSemanticHighlight.d.ts","sourceRoot":"","sources":["../../../../src/MaqlEditor/maql/hooks/useSemanticHighlight.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,KAAK,gBAAgB,EAAuB,MAAM,uBAAuB,CAAC;AAEnF,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAI9E,wBAAgB,oBAAoB,CAChC,UAAU,EAAE,MAAM,EAClB,eAAe,EAAE,mBAAmB,GAAG,SAAS,EAChD,cAAc,EAAE,gBAAgB,GAAG,SAAS,GAC7C,IAAI,CA+BN"}

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

@@ -0,0 +1,33 @@
+// (C) 2021-2026 GoodData Corporation
+import { useEffect } from "react";
+import * as monaco from "monaco-editor/editor/editor.api.js";
+import { createDocument } from "../utils.js";
+export function useSemanticHighlight(languageId, languageService, initializeData) {
+    useEffect(() => {
+        if (!languageService || !initializeData) {
+            return;
+        }
+        // Semantic highlighting - register a semantic tokens provider from MAQL LS
+        const disposeHighlighting = monaco.languages.registerDocumentSemanticTokensProvider(languageId, {
+            getLegend: () => initializeData.capabilities.semanticTokensProvider?.legend || {
+                tokenTypes: [],
+                tokenModifiers: [],
+            },
+            provideDocumentSemanticTokens: (model) => {
+                const document = createDocument(model);
+                return languageService.doSemanticTokens(document).then((tokens) => {
+                    return {
+                        ...tokens,
+                        data: new Uint32Array(tokens.data),
+                    };
+                });
+            },
+            releaseDocumentSemanticTokens: () => {
+                /*do nothing*/
+            },
+        });
+        return () => {
+            disposeHighlighting.dispose();
+        };
+    }, [languageId, languageService, initializeData]);
+}

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

@@ -0,0 +1,2 @@
+export declare function useSyntaxHighlight(languageId: string): void;
+//# sourceMappingURL=useSyntaxHighlight.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useSyntaxHighlight.d.ts","sourceRoot":"","sources":["../../../../src/MaqlEditor/maql/hooks/useSyntaxHighlight.ts"],"names":[],"mappings":"AAQA,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAwB3D"}

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

@@ -0,0 +1,28 @@
+// (C) 2021-2026 GoodData Corporation
+import { useEffect } from "react";
+import * as monaco from "monaco-editor/editor/editor.api.js";
+//more info in README.md
+export function useSyntaxHighlight(languageId) {
+    useEffect(() => {
+        // Syntax highlighting - register a tokens provider for MAQL - works for code blocks in Markdown
+        const disposeHighlighting = monaco.languages.setMonarchTokensProvider(languageId, {
+            tokenizer: {
+                root: [
+                    [/\{fact\/[^}]*\}/gi, "fact"],
+                    [/\{metric\/[^}]*\}/gi, "metric"],
+                    [/\{dataset\/[^}]*\}/gi, "dataset"],
+                    [/\{attribute\/[^}]*\}/gi, "attribute"],
+                    [/\{computed_attribute\/[^}]*\}/gi, "attribute"],
+                    [/\{label\/[^}]*\}/gi, "label"],
+                    [/\{[^}]*\}/g, "variable"],
+                    [/\w+/g, "keyword"],
+                    [/"(?:[^"\\]|\\.)*"/g, "string"],
+                    [/#[^\n]*/g, "comment"],
+                ],
+            },
+        });
+        return () => {
+            disposeHighlighting.dispose();
+        };
+    }, [languageId]);
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"useValidation.d.ts","sourceRoot":"","sources":["../../../../src/MaqlEditor/maql/hooks/useValidation.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,oCAAoC,CAAC;AAG9E,OAAO,EAAoB,KAAK,qBAAqB,EAAE,KAAK,MAAM,EAAE,MAAM,8BAA8B,CAAC;AAMzG,wBAAgB,aAAa,CACzB,eAAe,EAAE,mBAAmB,GAAG,SAAS,GACjD,CAAC,MAAM,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CA6DzD"}

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

@@ -0,0 +1,56 @@
+// (C) 2021-2026 GoodData Corporation
+import { useMemo } from "react";
+import * as monaco from "monaco-editor/editor/editor.api.js";
+import { ProtocolToMonacoConverter } from "monaco-languageclient/monaco-converter";
+import { createDocument } from "../utils.js";
+// pending validations are stored here, so we don't run multiple validations on same document
+const pendingValidationRequests = new Map();
+export function useValidation(languageService) {
+    return useMemo(() => {
+        const p2m = new ProtocolToMonacoConverter(monaco);
+        // validate function should be called with some debounce
+        function validate(editor, monaco) {
+            const model = editor?.getModel();
+            if (model) {
+                const document = createDocument(model);
+                cleanPendingValidation(document);
+                pendingValidationRequests.set(document.uri, window.setTimeout(() => {
+                    // validations are stored as timeouts, so we can cancel the promise easily
+                    doValidate(document, editor, monaco);
+                    pendingValidationRequests.delete(document.uri);
+                }));
+            }
+        }
+        function cleanPendingValidation(document) {
+            const request = pendingValidationRequests.get(document.uri);
+            if (request !== undefined) {
+                clearTimeout(request);
+                pendingValidationRequests.delete(document.uri);
+            }
+        }
+        function doValidate(document, editor, monaco) {
+            if (document.getText().length === 0) {
+                setModelMarkers([], editor, monaco);
+                return;
+            }
+            if (languageService) {
+                languageService
+                    .doValidation(document)
+                    .then((diagnostics) => {
+                    const markers = p2m.asDiagnostics(diagnostics);
+                    setModelMarkers(markers, editor, monaco);
+                })
+                    .catch((_reason) => {
+                    setModelMarkers([], editor, monaco); // validation failed - clear previous diagnostics
+                });
+            }
+        }
+        function setModelMarkers(markers, editor, monaco) {
+            const model = editor?.getModel();
+            if (model) {
+                monaco?.editor.setModelMarkers(model, "default", markers);
+            }
+        }
+        return validate;
+    }, [languageService]);
+}

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

@@ -0,0 +1,4 @@
+import { TextDocument } from "vscode-languageserver-textdocument";
+import { type IReadOnlyModel, type Range } from "../monaco/MonacoEditor.js";
+export declare function createDocument(model: IReadOnlyModel, range?: Range): TextDocument;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/MaqlEditor/maql/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAElE,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,KAAK,EAAE,MAAM,2BAA2B,CAAC;AAG5E,wBAAgB,cAAc,CAAC,KAAK,EAAE,cAAc,EAAE,KAAK,CAAC,EAAE,KAAK,GAAG,YAAY,CAOjF"}

package/esm/MaqlEditor/maql/utils.js

@@ -0,0 +1,6 @@
+// (C) 2021-2026 GoodData Corporation
+import { TextDocument } from "vscode-languageserver-textdocument";
+const MODEL_URI = "inmemory://model.maql";
+export function createDocument(model, range) {
+    return TextDocument.create(MODEL_URI, model.getLanguageId(), model.getVersionId(), range ? model.getValueInRange(range) : model.getValue());
+}

package/esm/MaqlEditor/mock/monaco-shim.d.ts

@@ -0,0 +1,2 @@
+export declare function shimMaqlEditor(): void;
+//# sourceMappingURL=monaco-shim.d.ts.map

package/esm/MaqlEditor/mock/monaco-shim.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monaco-shim.d.ts","sourceRoot":"","sources":["../../../src/MaqlEditor/mock/monaco-shim.ts"],"names":[],"mappings":"AAEA,wBAAgB,cAAc,IAAI,IAAI,CAmCrC"}

package/esm/MaqlEditor/mock/monaco-shim.js

@@ -0,0 +1,36 @@
+// (C) 2021-2026 GoodData Corporation
+export function shimMaqlEditor() {
+    const noop = () => void 0;
+    //monaco shim methods
+    if (!document.queryCommandSupported) {
+        document.queryCommandSupported = () => false;
+    }
+    if (!global.matchMedia) {
+        global.matchMedia = () => {
+            return {
+                matches: false,
+                media: "",
+                dispatchEvent: noop,
+                addEventListener: noop,
+                removeEventListener: noop,
+                addListener: noop,
+                removeListener: noop,
+                onchange: noop,
+            };
+        };
+    }
+    if (!global.ResizeObserver) {
+        class ResizeObserver {
+            observe() {
+                // do nothing
+            }
+            unobserve() {
+                // do nothing
+            }
+            disconnect() {
+                // do nothing
+            }
+        }
+        global.ResizeObserver = ResizeObserver;
+    }
+}

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

@@ -0,0 +1,49 @@
+import { type Ref } from "react";
+import type * as monaco from "monaco-editor/editor/editor.api.js";
+import { type IMaqlEditorIcons } from "./MonacoEditor.styles.js";
+export type Monaco = typeof monaco;
+export interface IMonacoEditorProps {
+    inline?: boolean;
+    readonly?: boolean;
+    options?: Partial<IStandaloneEditorConstructionOptions>;
+    icons?: IMaqlEditorIcons;
+    autofocus?: boolean;
+    className?: string;
+    language?: string;
+    languageConfiguration?: monaco.languages.LanguageConfiguration;
+    defaultValue?: string;
+    themeName?: string;
+    themeData?: IStandaloneThemeData;
+    onEditorMount?: (editor: IStandaloneCodeEditor, monaco: Monaco) => void;
+    onEditorUpdate?: (editor: IStandaloneCodeEditor, monaco: Monaco) => void;
+    onContentSizeChange?: (editor: IStandaloneCodeEditor, monaco: Monaco, width: number, height: number) => void;
+    heightOffset?: number;
+    ref?: Ref<IStandaloneCodeEditor | null>;
+}
+export type IDisposable = monaco.IDisposable;
+export type IStandaloneCodeEditor = monaco.editor.IStandaloneCodeEditor;
+export type IStandaloneEditorConstructionOptions = monaco.editor.IStandaloneEditorConstructionOptions;
+export type IEditorContribution = monaco.editor.IEditorContribution;
+export type IStandaloneThemeData = monaco.editor.IStandaloneThemeData;
+export type IMarkerData = monaco.editor.IMarkerData;
+export type IReadOnlyModel = monaco.editor.IReadOnlyModel;
+export type FormattingOptions = monaco.languages.FormattingOptions;
+export type Range = monaco.Range;
+export type ISuggestContribution = IEditorContribution & {
+    widget: {
+        value: {
+            onDidShow: (handler: () => void) => void;
+            onDidHide: (handler: () => void) => void;
+            element: {
+                domNode: HTMLElement;
+            };
+        };
+    };
+};
+export type IMarkersContribution = IEditorContribution & {
+    close(focusEditor?: boolean): void;
+};
+export declare const MainClass = "maql-editor";
+export declare const MainClassContent = "maql-editor-content";
+export declare const MonacoEditor: import("react").ForwardRefExoticComponent<Omit<IMonacoEditorProps, "ref"> & import("react").RefAttributes<monaco.editor.IStandaloneCodeEditor | null>>;
+//# sourceMappingURL=MonacoEditor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MonacoEditor.d.ts","sourceRoot":"","sources":["../../../src/MaqlEditor/monaco/MonacoEditor.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,GAAG,EAA0D,MAAM,OAAO,CAAC;AAGzF,OAAO,KAAK,KAAK,MAAM,MAAM,oCAAoC,CAAC;AAOlE,OAAO,EAAE,KAAK,gBAAgB,EAAgB,MAAM,0BAA0B,CAAC;AAE/E,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC;AAEnC,MAAM,WAAW,kBAAkB;IAC/B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC,oCAAoC,CAAC,CAAC;IACxD,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qBAAqB,CAAC,EAAE,MAAM,CAAC,SAAS,CAAC,qBAAqB,CAAC;IAC/D,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,oBAAoB,CAAC;IACjC,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACxE,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,qBAAqB,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACzE,mBAAmB,CAAC,EAAE,CAClB,MAAM,EAAE,qBAAqB,EAC7B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,KACb,IAAI,CAAC;IACV,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,GAAG,CAAC,EAAE,GAAG,CAAC,qBAAqB,GAAG,IAAI,CAAC,CAAC;CAC3C;AAED,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC;AAC7C,MAAM,MAAM,qBAAqB,GAAG,MAAM,CAAC,MAAM,CAAC,qBAAqB,CAAC;AACxE,MAAM,MAAM,oCAAoC,GAAG,MAAM,CAAC,MAAM,CAAC,oCAAoC,CAAC;AACtG,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,CAAC,mBAAmB,CAAC;AACpE,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,MAAM,CAAC,oBAAoB,CAAC;AACtE,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC;AACpD,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC;AAC1D,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,SAAS,CAAC,iBAAiB,CAAC;AACnE,MAAM,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;AACjC,MAAM,MAAM,oBAAoB,GAAG,mBAAmB,GAAG;IACrD,MAAM,EAAE;QACJ,KAAK,EAAE;YACH,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;YACzC,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;YACzC,OAAO,EAAE;gBACL,OAAO,EAAE,WAAW,CAAC;aACxB,CAAC;SACL,CAAC;KACL,CAAC;CACL,CAAC;AACF,MAAM,MAAM,oBAAoB,GAAG,mBAAmB,GAAG;IACrD,KAAK,CAAC,WAAW,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;CACtC,CAAC;AAmBF,eAAO,MAAM,SAAS,gBAAgB,CAAC;AACvC,eAAO,MAAM,gBAAgB,wBAAwB,CAAC;AAEtD,eAAO,MAAM,YAAY,wJAwDxB,CAAC"}

package/esm/MaqlEditor/monaco/MonacoEditor.js

@@ -0,0 +1,71 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// (C) 2021-2026 GoodData Corporation
+import { forwardRef, useCallback, useImperativeHandle, useState } from "react";
+import classNames from "classnames";
+//more info in README.md
+import { makeStyles } from "../theme/styles.js";
+import { useAutofocus } from "./hooks/useAutofocus.js";
+import { useMonaco } from "./hooks/useMonaco.js";
+import { MonacoStyles } from "./MonacoEditor.styles.js";
+const useStyles = makeStyles()(() => ({
+    editor: {
+        display: "flex",
+        position: "relative",
+        textAlign: "initial",
+        width: "100%",
+        height: "100%",
+    },
+    inline: {
+        width: "100%",
+        height: "100%",
+    },
+    content: {
+        width: "100%",
+    },
+}));
+export const MainClass = "maql-editor";
+export const MainClassContent = "maql-editor-content";
+export const MonacoEditor = forwardRef(function MonacoEditor({ icons, options, autofocus = false, className = "", language = "", languageConfiguration, defaultValue = "", themeName = "", themeData, onEditorMount = () => { }, onEditorUpdate = () => { }, inline = false, readonly = false, }, ref) {
+    const [element, setElement] = useState(null);
+    const [uniqueId] = useState(`${MainClassContent}-${Math.random().toString(36).slice(2)}`);
+    const { width, height, onContentSizeChange } = useContentSize(inline);
+    const editor = useMonaco(element, {
+        className: [MainClass, className].join(" "),
+        options,
+        language,
+        languageConfiguration,
+        defaultValue,
+        themeName,
+        themeData,
+        inline,
+        readonly,
+        onEditorMount,
+        onEditorUpdate,
+        onContentSizeChange,
+    });
+    useImperativeHandle(ref, () => editor, [
+        editor,
+    ]);
+    const { classes } = useStyles();
+    useAutofocus(element, editor, autofocus || false);
+    return (_jsxs("section", { id: uniqueId, className: classNames(classes.editor, MainClassContent, inline && classes.inline), style: getStyles(width, height, inline), children: [_jsx(MonacoStyles, { id: uniqueId, icons: icons, themeData: themeData, options: options }), _jsx("div", { ref: (ref) => setElement(ref), className: classes.content })] }));
+});
+function useContentSize(inline) {
+    const [height, setHeight] = useState(0);
+    const [width, setWidth] = useState(0);
+    const onContentSizeChange = useCallback(
+    // oxlint-disable-next-line @typescript-eslint/no-explicit-any
+    (...[, , currentWidth, currentHeight]) => {
+        if (inline) {
+            setWidth(currentWidth);
+            setHeight(currentHeight);
+        }
+    }, [inline]);
+    return { width, height, onContentSizeChange };
+}
+function getStyles(width, height, inline) {
+    if (inline && width > 0 && height > 0) {
+        return { height, width };
+    }
+    return {};
+}