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

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

@@ -0,0 +1,47 @@
+import type * as monaco from "monaco-editor/editor/editor.api.js";
+import { type IStandaloneEditorConstructionOptions } from "./MonacoEditor.js";
+export interface IMaqlEditorIcon {
+    base64: string;
+    width?: number;
+    height?: number;
+}
+export interface IMaqlEditorIcons {
+    fact?: IMaqlEditorIcon;
+    metric?: IMaqlEditorIcon;
+    dataset?: IMaqlEditorIcon;
+    label?: IMaqlEditorIcon;
+    attribute?: IMaqlEditorIcon;
+    keyword?: IMaqlEditorIcon;
+    function?: IMaqlEditorIcon;
+    detail?: IMaqlEditorIcon;
+    next?: IMaqlEditorIcon;
+    prev?: IMaqlEditorIcon;
+    close?: IMaqlEditorIcon;
+}
+export declare const DecoratorHovered = "hovered-decorator";
+export declare const DecoratorClassName = "decorator";
+export declare const DecoratorItemClassName = "decorator-item";
+type Decorators = {
+    [key: string]: {
+        decoratorItem: Array<string>;
+        decorator: Array<string>;
+    };
+};
+export declare const DecoratorFact = "fact";
+export declare const DecoratorAttribute = "attribute";
+export declare const DecoratorDateAttribute = "dateAttribute";
+export declare const DecoratorComputedAttribute = "computedAttribute";
+export declare const DecoratorLabel = "label";
+export declare const DecoratorDateLabel = "dateLabel";
+export declare const DecoratorMetric = "metric";
+export declare const DecoratorDataset = "dataset";
+export declare const DecoratorParameter = "parameter";
+export declare const Decorators: Decorators;
+export declare function MonacoStyles({ id, icons, themeData, options, }: {
+    id: string;
+    icons?: IMaqlEditorIcons;
+    themeData?: monaco.editor.IStandaloneThemeData;
+    options?: Partial<IStandaloneEditorConstructionOptions>;
+}): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=MonacoEditor.styles.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MonacoEditor.styles.d.ts","sourceRoot":"","sources":["../../../src/MaqlEditor/monaco/MonacoEditor.styles.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,MAAM,oCAAoC,CAAC;AAMlE,OAAO,EAAE,KAAK,oCAAoC,EAAE,MAAM,mBAAmB,CAAC;AAI9E,MAAM,WAAW,eAAe;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC7B,IAAI,CAAC,EAAE,eAAe,CAAC;IACvB,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,KAAK,CAAC,EAAE,eAAe,CAAC;IACxB,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,MAAM,CAAC,EAAE,eAAe,CAAC;IACzB,IAAI,CAAC,EAAE,eAAe,CAAC;IACvB,IAAI,CAAC,EAAE,eAAe,CAAC;IACvB,KAAK,CAAC,EAAE,eAAe,CAAC;CAC3B;AAED,eAAO,MAAM,gBAAgB,sBAAsB,CAAC;AACpD,eAAO,MAAM,kBAAkB,cAAc,CAAC;AAC9C,eAAO,MAAM,sBAAsB,mBAAmB,CAAC;AAEvD,KAAK,UAAU,GAAG;IACd,CAAC,GAAG,EAAE,MAAM,GAAG;QACX,aAAa,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;QAC7B,SAAS,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;KAC5B,CAAC;CACL,CAAC;AACF,eAAO,MAAM,aAAa,SAAS,CAAC;AACpC,eAAO,MAAM,kBAAkB,cAAc,CAAC;AAC9C,eAAO,MAAM,sBAAsB,kBAAkB,CAAC;AACtD,eAAO,MAAM,0BAA0B,sBAAsB,CAAC;AAC9D,eAAO,MAAM,cAAc,UAAU,CAAC;AACtC,eAAO,MAAM,kBAAkB,cAAc,CAAC;AAC9C,eAAO,MAAM,eAAe,WAAW,CAAC;AACxC,eAAO,MAAM,gBAAgB,YAAY,CAAC;AAC1C,eAAO,MAAM,kBAAkB,cAAc,CAAC;AAC9C,eAAO,MAAM,UAAU,EAAE,UAyCxB,CAAC;AAEF,wBAAgB,YAAY,CAAC,EACzB,EAAE,EACF,KAAK,EACL,SAAS,EACT,OAAY,GACf,EAAE;IACC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,oBAAoB,CAAC;IAC/C,OAAO,CAAC,EAAE,OAAO,CAAC,oCAAoC,CAAC,CAAC;CAC3D,2CAIA"}

package/esm/MaqlEditor/monaco/MonacoEditor.styles.js

@@ -0,0 +1,427 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2021-2026 GoodData Corporation
+import { useMemo } from "react";
+import { GlobalStyles } from "tss-react";
+import { makeStyles } from "../theme/styles.js";
+const useStyles = makeStyles()(() => ({}));
+export const DecoratorHovered = "hovered-decorator";
+export const DecoratorClassName = "decorator";
+export const DecoratorItemClassName = "decorator-item";
+export const DecoratorFact = "fact";
+export const DecoratorAttribute = "attribute";
+export const DecoratorDateAttribute = "dateAttribute";
+export const DecoratorComputedAttribute = "computedAttribute";
+export const DecoratorLabel = "label";
+export const DecoratorDateLabel = "dateLabel";
+export const DecoratorMetric = "metric";
+export const DecoratorDataset = "dataset";
+export const DecoratorParameter = "parameter";
+export const Decorators = {
+    [DecoratorFact]: {
+        decoratorItem: [DecoratorItemClassName, DecoratorFact],
+        decorator: [DecoratorClassName, DecoratorFact],
+    },
+    [DecoratorAttribute]: {
+        decoratorItem: [DecoratorItemClassName, DecoratorAttribute],
+        decorator: [DecoratorClassName, DecoratorAttribute],
+    },
+    [DecoratorDateAttribute]: {
+        decoratorItem: [DecoratorItemClassName, DecoratorDateAttribute],
+        decorator: [DecoratorClassName, DecoratorDateAttribute],
+    },
+    [DecoratorComputedAttribute]: {
+        decoratorItem: [DecoratorItemClassName, DecoratorComputedAttribute],
+        decorator: [DecoratorClassName, DecoratorComputedAttribute],
+    },
+    [DecoratorLabel]: {
+        decoratorItem: [DecoratorItemClassName, DecoratorLabel],
+        decorator: [DecoratorClassName, DecoratorLabel],
+    },
+    [DecoratorDateLabel]: {
+        decoratorItem: [DecoratorItemClassName, DecoratorDateLabel],
+        decorator: [DecoratorClassName, DecoratorDateLabel],
+    },
+    [DecoratorMetric]: {
+        decoratorItem: [DecoratorItemClassName, DecoratorMetric],
+        decorator: [DecoratorClassName, DecoratorMetric],
+    },
+    [DecoratorDataset]: {
+        decoratorItem: [DecoratorItemClassName, DecoratorDataset],
+        decorator: [DecoratorClassName, DecoratorDataset],
+    },
+    [DecoratorParameter]: {
+        decoratorItem: [DecoratorItemClassName, DecoratorParameter],
+        decorator: [DecoratorClassName, DecoratorParameter],
+    },
+    default: {
+        decoratorItem: [DecoratorItemClassName, "unknown"],
+        decorator: [DecoratorClassName, "unknown"],
+    },
+};
+export function MonacoStyles({ id, icons, themeData, options = {}, }) {
+    const styles = useMonacoStyles(id, options, icons, themeData);
+    return _jsx(GlobalStyles, { styles: styles });
+}
+const linePaddingLeft = 16;
+function useMonacoStyles(id, _options, icons, themeData) {
+    const { theme } = useStyles();
+    return useMemo(() => {
+        const customIcon = {
+            display: "block",
+        };
+        const editorLines = {
+            ".lines-content": {
+                paddingLeft: `${linePaddingLeft}px`,
+            },
+            textarea: {
+                marginLeft: `${linePaddingLeft + 1}px`,
+            },
+        };
+        const editor = {
+            ".bracket-match": {
+                backgroundColor: theme.content.colors.bracketMatch,
+                border: "none",
+            },
+            ".monaco-scrollable-element": {
+                borderLeft: "none",
+            },
+            ".line-numbers": {
+                color: theme.content.colors.lineNumber,
+            },
+            ".active-line-number.line-numbers": {
+                color: theme.content.colors.activeLineNumber,
+            },
+            ".monaco-scrollable-element > .scrollbar > .slider ": {
+                background: theme.content.colors.slider,
+                "&:hover": {
+                    background: theme.content.colors.sliderHover,
+                },
+            },
+            ".codicon-folding-expanded, .codicon-folding-collapsed": {
+                width: "16px !important",
+                height: "16px !important",
+                margin: "3px 0 !important",
+                fontSize: "100%",
+            },
+            ...editorLines,
+        };
+        const suggestionWidget = {
+            ".suggest-widget": {
+                height: "auto !important",
+                boxShadow: theme.suggestion.shadow,
+                borderColor: `${theme.suggestion.colors.line} !important`,
+                ".monaco-list .monaco-list-row": {
+                    fontFamily: theme.suggestion.font,
+                    background: theme.suggestion.colors.background,
+                    color: theme.globals.colors.font,
+                    fontSize: `${theme.suggestion.item.fontSize}px !important`,
+                    ".label-name": {
+                        "&:hover, &:focus, &:active": {
+                            textDecoration: "none",
+                        },
+                    },
+                    "&.focused, &.selected, &.focused:hover, &.selected:hover": {
+                        background: theme.suggestion.colors.selectedBackground,
+                        color: theme.globals.colors.font,
+                    },
+                    "&:hover:not(.selected):not(.focused)": {
+                        background: `${theme.suggestion.colors.selectedBackground} !important`,
+                        color: theme.globals.colors.font,
+                    },
+                    ".monaco-highlighted-label .highlight, &.focused .monaco-highlighted-label .highlight": {
+                        background: theme.suggestion.colors.highlightedBackground,
+                        color: theme.globals.colors.font,
+                    },
+                    "&.focused .readMore": {
+                        display: "inline-block !important",
+                        visibility: "visible !important",
+                        "&[aria-hidden='true']": {
+                            display: "none !important",
+                        },
+                        "&:before": {
+                            padding: "3px 0",
+                            display: "block",
+                            backgroundPosition: "center",
+                            ...createIconDefinition(icons?.detail),
+                        },
+                    },
+                    "&.focused:hover .details-label, &.focused .details-label": {
+                        width: "calc(100% - 32px) !important",
+                    },
+                    "& > .contents": {
+                        paddingLeft: "10px",
+                    },
+                    ".details-label": {
+                        fontSize: `${theme.suggestion.label.fontSize}px`,
+                        fontFamily: theme.globals.font,
+                        color: theme.suggestion.colors.active,
+                    },
+                    ".suggest-icon": {
+                        marginRight: "5px",
+                        "&.codicon-symbol-field:before": {
+                            ...customIcon,
+                            ...createIconDefinition(icons?.fact),
+                        },
+                        "&.codicon-symbol-variable:before": {
+                            ...customIcon,
+                            ...createIconDefinition(icons?.metric),
+                        },
+                        "&.codicon-symbol-constant:before": {
+                            ...customIcon,
+                            ...createIconDefinition(icons?.dataset),
+                        },
+                        "&.codicon-symbol-text:before": {
+                            ...customIcon,
+                            ...createIconDefinition(icons?.label),
+                        },
+                        "&.codicon-symbol-enum:before": {
+                            ...customIcon,
+                            ...createIconDefinition(icons?.attribute),
+                        },
+                        "&.codicon-symbol-keyword:before": {
+                            ...customIcon,
+                            ...createIconDefinition(icons?.keyword),
+                        },
+                        "&.codicon-symbol-function:before": {
+                            ...customIcon,
+                            ...createIconDefinition(icons?.function),
+                        },
+                    },
+                },
+            },
+        };
+        const suggestionsDetails = {
+            ".suggest-details": {
+                fontFamily: theme.globals.font,
+                minHeight: `${2 * theme.detail.padding + theme.detail.header.size}px`,
+                borderColor: `${theme.detail.colors.border} !important`,
+                boxShadow: `0 1px 20px ${theme.globals.colors.shadow}`,
+                ".monaco-scrollable-element .body": {
+                    color: theme.globals.colors.font,
+                    background: theme.detail.colors.background,
+                    padding: `${theme.detail.padding}px`,
+                    ".header": {
+                        fontSize: `${theme.detail.header.fontSize}px`,
+                        lineHeight: `${theme.detail.header.lineHeight}px`,
+                        color: theme.detail.colors.header,
+                        ".codicon-close": {
+                            width: "auto !important",
+                            height: "auto !important",
+                            fontFamily: theme.detail.header.close.font,
+                            fontSize: `${theme.detail.header.close.size}px`,
+                            top: `${theme.detail.padding}px`,
+                            right: `${theme.detail.padding}px`,
+                            "&::before": {
+                                content: '"\\e62d"',
+                            },
+                        },
+                        p: {
+                            margin: `0 ${theme.detail.padding * 2}px 0 0`,
+                            padding: 0,
+                        },
+                    },
+                },
+            },
+        };
+        const decorators = Object.keys(Decorators).reduce((prev, name) => {
+            const item = Decorators[name];
+            prev[`.${item.decorator.join(".")}`] = {
+                background: themeData?.colors[`editor.variable.${name}.background`] ?? "#cecece",
+                color: themeData?.colors[`editor.variable.${name}.color`] ?? "#7e7e7e",
+                ...theme.decorator,
+            };
+            prev[`.${item.decoratorItem.join(".")}`] = {
+                color: themeData?.colors[`editor.variable.${name}.color`] ?? "#000000",
+            };
+            return prev;
+        }, {});
+        const errorsView = {
+            ".zone-widget-container.peekview-widget": {
+                borderTopWidth: `${theme.errorsBar.border.topWidth}px !important`,
+                borderTopColor: `${theme.errorsBar.colors.error} !important`,
+                borderBottomColor: `${theme.errorsBar.colors.error} !important`,
+                left: theme.errorsBar.left,
+                width: `calc(100% - ${theme.errorsBar.left}px)`,
+                background: `${theme.errorsBar.colors.bodyBackground} !important`,
+                ".head": {
+                    background: `${theme.errorsBar.colors.headBackground} !important`,
+                    ".peekview-title": {
+                        marginLeft: `${theme.errorsBar.paddingHorizontal}px !important`,
+                    },
+                    ".filename": {
+                        display: "none",
+                    },
+                    ".dirname": {
+                        fontSize: `${theme.errorsBar.sizes.headerFontSize}px !important`,
+                        lineHeight: `${theme.errorsBar.sizes.lineHeight}px  !important`,
+                        fontFamily: theme.errorsBar.font,
+                        color: `${theme.errorsBar.colors.font} !important`,
+                    },
+                },
+                ".body": {
+                    borderColor: `${theme.errorsBar.colors.error} !important`,
+                    background: `${theme.errorsBar.colors.bodyBackground} !important`,
+                    ".monaco-scrollable-element": {
+                        border: "none !important",
+                        width: "auto !important",
+                        ".descriptioncontainer": {
+                            paddingLeft: `${theme.errorsBar.paddingHorizontal}px !important`,
+                            paddingRight: `${theme.errorsBar.paddingHorizontal}px !important`,
+                            paddingTop: `${theme.errorsBar.paddingVertical}px !important`,
+                        },
+                    },
+                    ".message": {
+                        fontFamily: `${theme.errorsBar.font} !important`,
+                        fontSize: `${theme.errorsBar.sizes.bodyFontSize}px !important`,
+                        color: `${theme.errorsBar.colors.body} !important`,
+                        "& > div::first-letter": {
+                            textTransform: "uppercase",
+                        },
+                    },
+                },
+                ".codicon-marker-navigation-next:before": {
+                    ...customIcon,
+                    ...createIconDefinition(icons?.next),
+                },
+                ".codicon-marker-navigation-previous:before": {
+                    ...customIcon,
+                    ...createIconDefinition(icons?.prev),
+                },
+                ".codicon-close:before": {
+                    ...customIcon,
+                    ...createIconDefinition(icons?.close),
+                },
+            },
+        };
+        const hoverView = {
+            ".monaco-hover": {
+                border: theme.hoverBar.border,
+                borderRadius: theme.hoverBar.sizes.borderRadius,
+                background: theme.hoverBar.colors.background,
+                boxShadow: theme.hoverBar.boxShadow,
+                fontFamily: theme.hoverBar.font,
+                ".monaco-scrollable-element": {
+                    border: "none !important",
+                },
+                ".monaco-hover-content": {
+                    ".hover-row": {
+                        borderTop: "none !important",
+                        ".marker.hover-contents": {
+                            fontFamily: `${theme.hoverBar.font} !important`,
+                            margin: theme.hoverBar.margin,
+                            padding: theme.hoverBar.padding,
+                            borderRadius: theme.hoverBar.sizes.borderRadiusInner,
+                            background: theme.hoverBar.colors.errorBackground,
+                            color: theme.hoverBar.colors.errorText,
+                            fontSize: `${theme.hoverBar.sizes.font}px !important`,
+                            "&::first-letter": {
+                                textTransform: "uppercase",
+                            },
+                        },
+                    },
+                    ".hover-row.status-bar": {
+                        display: "none",
+                    },
+                },
+            },
+        };
+        const hoverDecorator = {
+            [`.${DecoratorHovered}`]: {
+                background: `${theme.hoverMetric.colors.hover} !important`,
+                ...theme.decorator,
+            },
+        };
+        return {
+            [`#${id} .monaco-editor.vs`]: {
+                ...editor,
+                ...suggestionWidget,
+                ...suggestionsDetails,
+                ...decorators,
+                ...hoverDecorator,
+                ...errorsView,
+                ...hoverView,
+            },
+        };
+    }, [
+        id,
+        icons?.attribute,
+        icons?.detail,
+        icons?.fact,
+        icons?.function,
+        icons?.keyword,
+        icons?.label,
+        icons?.metric,
+        icons?.dataset,
+        icons?.next,
+        icons?.prev,
+        icons?.close,
+        theme.content.colors.activeLineNumber,
+        theme.content.colors.lineNumber,
+        theme.content.colors.slider,
+        theme.content.colors.sliderHover,
+        theme.content.colors.bracketMatch,
+        theme.detail.colors.background,
+        theme.detail.colors.border,
+        theme.detail.colors.header,
+        theme.detail.header.close.font,
+        theme.detail.header.close.size,
+        theme.detail.header.fontSize,
+        theme.detail.header.lineHeight,
+        theme.detail.header.size,
+        theme.detail.padding,
+        theme.globals.colors.font,
+        theme.globals.colors.shadow,
+        theme.globals.font,
+        theme.suggestion.colors.active,
+        theme.suggestion.colors.background,
+        theme.suggestion.colors.highlightedBackground,
+        theme.suggestion.colors.line,
+        theme.suggestion.colors.selectedBackground,
+        theme.suggestion.font,
+        theme.suggestion.item.fontSize,
+        theme.suggestion.label.fontSize,
+        theme.suggestion.shadow,
+        theme.errorsBar.colors.error,
+        theme.errorsBar.colors.headBackground,
+        theme.errorsBar.colors.bodyBackground,
+        theme.errorsBar.colors.font,
+        theme.errorsBar.colors.body,
+        theme.errorsBar.border.topWidth,
+        theme.errorsBar.sizes.lineHeight,
+        theme.errorsBar.sizes.headerFontSize,
+        theme.errorsBar.sizes.bodyFontSize,
+        theme.errorsBar.left,
+        theme.errorsBar.font,
+        theme.errorsBar.paddingHorizontal,
+        theme.errorsBar.paddingVertical,
+        theme.hoverBar.border,
+        theme.hoverBar.sizes.borderRadius,
+        theme.hoverBar.colors.background,
+        theme.hoverBar.boxShadow,
+        theme.hoverBar.font,
+        theme.hoverBar.margin,
+        theme.hoverBar.padding,
+        theme.hoverBar.sizes.borderRadiusInner,
+        theme.hoverBar.sizes.font,
+        theme.hoverBar.colors.errorBackground,
+        theme.hoverBar.colors.errorText,
+        theme.hoverMetric.colors.hover,
+        theme.decorator,
+        themeData?.colors,
+    ]);
+}
+function createIconDefinition(icon) {
+    const def = {};
+    if (icon) {
+        def["content"] = '""';
+        def["backgroundImage"] = `url("data:image/svg+xml;base64,${icon.base64}")`;
+        def["backgroundRepeat"] = "no-repeat";
+        if (icon.width) {
+            def["width"] = `${icon.width}px`;
+        }
+        if (icon.height) {
+            def["height"] = `${icon.height}px`;
+        }
+    }
+    return def;
+}

package/esm/MaqlEditor/monaco/hooks/useAutofocus.d.ts

@@ -0,0 +1,3 @@
+import type { IStandaloneCodeEditor } from "../MonacoEditor.js";
+export declare function useAutofocus(element: HTMLDivElement | null, editor: IStandaloneCodeEditor | null, autofocus: boolean): void;
+//# sourceMappingURL=useAutofocus.d.ts.map

package/esm/MaqlEditor/monaco/hooks/useAutofocus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAutofocus.d.ts","sourceRoot":"","sources":["../../../../src/MaqlEditor/monaco/hooks/useAutofocus.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAEhE,wBAAgB,YAAY,CACxB,OAAO,EAAE,cAAc,GAAG,IAAI,EAC9B,MAAM,EAAE,qBAAqB,GAAG,IAAI,EACpC,SAAS,EAAE,OAAO,GACnB,IAAI,CAgBN"}

package/esm/MaqlEditor/monaco/hooks/useAutofocus.js

@@ -0,0 +1,33 @@
+// (C) 2021-2026 GoodData Corporation
+import { useEffect, useRef } from "react";
+export function useAutofocus(element, editor, autofocus) {
+    const timer = useRef(-1);
+    useEffect(() => {
+        clearInterval(timer);
+        if (editor && autofocus) {
+            createInterval(timer, () => isVisible(element), () => editor.focus());
+        }
+        return () => clearInterval(timer);
+    }, [editor, autofocus, element]);
+}
+function isVisible(element) {
+    if (element) {
+        const style = window.getComputedStyle(element);
+        const notHidden = style.visibility !== "hidden";
+        const notNone = style.display !== "none";
+        const hasSize = element.offsetHeight > 0;
+        return notHidden && notNone && hasSize;
+    }
+    return false;
+}
+function clearInterval(timer) {
+    window.clearInterval(timer.current);
+}
+function createInterval(timer, check, done) {
+    timer.current = window.setInterval(() => {
+        if (check()) {
+            done();
+            clearInterval(timer);
+        }
+    }, 25);
+}

package/esm/MaqlEditor/monaco/hooks/useDefaultValue.d.ts

@@ -0,0 +1,3 @@
+import type { IStandaloneCodeEditor } from "../MonacoEditor.js";
+export declare function useDefaultValue(editor: IStandaloneCodeEditor | null, defaultValue: string): void;
+//# sourceMappingURL=useDefaultValue.d.ts.map

package/esm/MaqlEditor/monaco/hooks/useDefaultValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDefaultValue.d.ts","sourceRoot":"","sources":["../../../../src/MaqlEditor/monaco/hooks/useDefaultValue.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAEhE,wBAAgB,eAAe,CAAC,MAAM,EAAE,qBAAqB,GAAG,IAAI,EAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CAahG"}

package/esm/MaqlEditor/monaco/hooks/useDefaultValue.js

@@ -0,0 +1,14 @@
+// (C) 2021-2026 GoodData Corporation
+import { useEffect } from "react";
+export function useDefaultValue(editor, defaultValue) {
+    useEffect(() => {
+        if (!editor) {
+            return;
+        }
+        const editorModel = editor.getModel();
+        const currentValue = editorModel?.getValue();
+        if (defaultValue !== currentValue) {
+            editor.setValue(defaultValue);
+        }
+    }, [defaultValue, editor]);
+}

package/esm/MaqlEditor/monaco/hooks/useEditorInit.d.ts

@@ -0,0 +1,3 @@
+import type { IMonacoEditorProps, IStandaloneCodeEditor } from "../MonacoEditor.js";
+export declare function useEditorInit(element: HTMLDivElement | null, editor: IStandaloneCodeEditor | null, setEditor: (editor: IStandaloneCodeEditor) => void, props: Omit<IMonacoEditorProps, "autofocus" | "icons">): void;
+//# sourceMappingURL=useEditorInit.d.ts.map

package/esm/MaqlEditor/monaco/hooks/useEditorInit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEditorInit.d.ts","sourceRoot":"","sources":["../../../../src/MaqlEditor/monaco/hooks/useEditorInit.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAER,kBAAkB,EAClB,qBAAqB,EAGxB,MAAM,oBAAoB,CAAC;AAK5B,wBAAgB,aAAa,CACzB,OAAO,EAAE,cAAc,GAAG,IAAI,EAC9B,MAAM,EAAE,qBAAqB,GAAG,IAAI,EACpC,SAAS,EAAE,CAAC,MAAM,EAAE,qBAAqB,KAAK,IAAI,EAClD,KAAK,EAAE,IAAI,CAAC,kBAAkB,EAAE,WAAW,GAAG,OAAO,CAAC,GACvD,IAAI,CAoEN"}

package/esm/MaqlEditor/monaco/hooks/useEditorInit.js

@@ -0,0 +1,84 @@
+// (C) 2021-2026 GoodData Corporation
+//more info in README.md
+import { useEffect, useRef } from "react";
+import * as monaco from "monaco-editor/editor/editor.api.js";
+import { setupMonacoWorkers } from "../monacoWorkers.js";
+import { useEditorOptions } from "./useEditorOptions.js";
+export function useEditorInit(element, editor, setEditor, props) {
+    const { inline = false, readonly = false, defaultValue = "", options, themeName, themeData, language, languageConfiguration, className, onEditorMount = () => { }, onEditorUpdate = () => { }, onContentSizeChange = () => { }, } = props;
+    const init = useRef(false);
+    const defaultOptions = useEditorOptions(readonly, inline, options);
+    useEffect(() => {
+        if (!element) {
+            return;
+        }
+        //NOTE: if editor is already initialized and editor is set, update editor
+        if (init.current && editor) {
+            onEditorUpdate(editor, monaco);
+            return initDisposable(editor, onContentSizeChange);
+        }
+        //NOTE: if editor is already initialized, do not initialize it again
+        // This is case where editor is initialized but still not in state
+        if (init.current) {
+            return;
+        }
+        // Must run before the first `monaco.editor.create` — Monaco reads `MonacoEnvironment` when it
+        // lazily spawns its editor worker.
+        setupMonacoWorkers();
+        const opts = { ...defaultOptions, automaticLayout: true };
+        updateTheme(opts, themeName, themeData);
+        updateLanguage(opts, language, languageConfiguration);
+        updateClassName(opts, className);
+        opts.value = defaultValue;
+        init.current = true;
+        const currentEditor = monaco.editor.create(element, opts);
+        setEditor(currentEditor);
+        onEditorMount(currentEditor, monaco);
+        onEditorUpdate(currentEditor, monaco);
+        return initDisposable(currentEditor, onContentSizeChange);
+    }, [
+        defaultValue,
+        defaultOptions,
+        themeName,
+        themeData,
+        language,
+        languageConfiguration,
+        className,
+        element,
+        editor,
+        onEditorMount,
+        onEditorUpdate,
+        onContentSizeChange,
+        setEditor,
+    ]);
+}
+function updateTheme(options, themeName, themeData) {
+    if (themeName && themeData) {
+        monaco.editor.defineTheme(themeName, themeData);
+        options.theme = themeName;
+    }
+}
+function updateLanguage(options, language, configuration) {
+    if (language) {
+        monaco.languages.register({ id: language });
+        if (configuration) {
+            monaco.languages.setLanguageConfiguration(language, configuration);
+        }
+        options.language = language;
+    }
+}
+function updateClassName(options, className) {
+    if (className) {
+        options.extraEditorClassName = className;
+    }
+}
+function initDisposable(editor, onContentSizeChange) {
+    const disposable = [];
+    disposable.push(onContentSizeChanged(editor, onContentSizeChange));
+    return () => disposable.forEach((dis) => {
+        dis.dispose();
+    });
+}
+function onContentSizeChanged(editor, onContentSizeChange) {
+    return editor.onDidContentSizeChange(() => onContentSizeChange?.(editor, monaco, editor.getContentWidth(), editor.getContentHeight()));
+}

package/esm/MaqlEditor/monaco/hooks/useEditorOptions.d.ts

@@ -0,0 +1,3 @@
+import { type IStandaloneEditorConstructionOptions } from "../MonacoEditor.js";
+export declare function useEditorOptions(readonly: boolean, inline: boolean | undefined, options?: Partial<IStandaloneEditorConstructionOptions>): IStandaloneEditorConstructionOptions;
+//# sourceMappingURL=useEditorOptions.d.ts.map

package/esm/MaqlEditor/monaco/hooks/useEditorOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEditorOptions.d.ts","sourceRoot":"","sources":["../../../../src/MaqlEditor/monaco/hooks/useEditorOptions.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,oCAAoC,EAAE,MAAM,oBAAoB,CAAC;AAE/E,wBAAgB,gBAAgB,CAC5B,QAAQ,EAAE,OAAO,EACjB,MAAM,EAAE,OAAO,GAAG,SAAS,EAC3B,OAAO,GAAE,OAAO,CAAC,oCAAoC,CAAM,GAC5D,oCAAoC,CAmDtC"}