@gooddata/sdk-ui-theme-provider 11.42.0-alpha.3 → 11.42.0-alpha.4

package/esm/ThemeProvider/ThemeProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ThemeProvider.d.ts","sourceRoot":"","sources":["../../src/ThemeProvider/ThemeProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAA+B,MAAM,OAAO,CAAC;AAEpE,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAWlD;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;AAEtD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAChC;;;;;;;OAOG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAE7B;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,QAAQ,CAAC,EAAE,aAAa,CAAC;IAEzB;;;;;;OAMG;IACH,0BAA0B,CAAC,EAAE,OAAO,CAAC;IAErC;;;;OAIG;IACH,0BAA0B,CAAC,EAAE,OAAO,CAAC;IAErC;;OAEG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC;CACxB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,EAC1B,QAAQ,EACR,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,YAAY,EACrB,SAAS,EAAE,cAAc,EACzB,QAAmB,EACnB,0BAAiC,EACjC,0BAAiC,EACpC,EAAE,mBAAmB,2CA2DrB"}
+{"version":3,"file":"ThemeProvider.d.ts","sourceRoot":"","sources":["../../src/ThemeProvider/ThemeProvider.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,SAAS,EAA+B,MAAM,OAAO,CAAC;AAEpE,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAWlD;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;AAEtD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAChC;;;;;;;OAOG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,kBAAkB,CAAC;IAE7B;;;;;;OAMG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,QAAQ,CAAC,EAAE,aAAa,CAAC;IAEzB;;;;;;OAMG;IACH,0BAA0B,CAAC,EAAE,OAAO,CAAC;IAErC;;;;OAIG;IACH,0BAA0B,CAAC,EAAE,OAAO,CAAC;IAErC;;OAEG;IACH,QAAQ,CAAC,EAAE,SAAS,CAAC;CACxB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,EAC1B,QAAQ,EACR,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,YAAY,EACrB,SAAS,EAAE,cAAc,EACzB,QAAmB,EACnB,0BAAiC,EACjC,0BAAiC,EACpC,EAAE,mBAAmB,2CAoFrB"}

package/esm/ThemeProvider/ThemeProvider.js

@@ -27,13 +27,31 @@ export function ThemeProvider({ children, theme: themeParam, backend: backendPar
     const lastWorkspace = useRef(undefined);
     lastWorkspace.current = workspace;
     useEffect(() => {
+        // A malformed theme (e.g. an unparseable color) must never block rendering. Preparing and
+        // applying the theme is wrapped so any failure falls back to the default theme and always
+        // resolves the loading state, instead of leaving the app stuck on the loading screen.
+        const applyTheme = (themeToApply) => {
+            try {
+                const preparedTheme = prepareTheme(themeToApply, enableComplementaryPalette);
+                setTheme(preparedTheme);
+                clearCssProperties();
+                setCssProperties(preparedTheme, isDarkTheme(preparedTheme));
+            }
+            catch (error) {
+                console.error("Failed to apply the theme, falling back to the default theme.", error);
+                // reset both channels (context theme and global CSS) to the default theme so
+                // context consumers stay consistent with the cleared CSS variables
+                setTheme({});
+                clearCssProperties();
+            }
+            finally {
+                setIsLoading(false);
+                setStatus("success");
+            }
+        };
         // no need to load anything if the themeParam is present
         if (themeParam) {
-            const preparedTheme = prepareTheme(themeParam, enableComplementaryPalette);
-            setTheme(preparedTheme);
-            setStatus("success");
-            clearCssProperties();
-            setCssProperties(preparedTheme, isDarkTheme(preparedTheme));
+            applyTheme(themeParam);
             return;
         }
         const fetchData = async () => {
@@ -43,15 +61,23 @@ export function ThemeProvider({ children, theme: themeParam, backend: backendPar
             }
             setIsLoading(true);
             setStatus("loading");
-            const selectedTheme = await backend.workspace(workspace).styling().getTheme();
-            if (lastWorkspace.current === workspace) {
-                const modifiedTheme = modifier(selectedTheme);
-                const preparedTheme = prepareTheme(modifiedTheme, enableComplementaryPalette);
-                setTheme(preparedTheme);
-                clearCssProperties();
-                setCssProperties(preparedTheme, isDarkTheme(preparedTheme));
-                setIsLoading(false);
-                setStatus("success");
+            try {
+                const selectedTheme = await backend.workspace(workspace).styling().getTheme();
+                if (lastWorkspace.current === workspace) {
+                    applyTheme(modifier(selectedTheme));
+                }
+            }
+            catch (error) {
+                if (lastWorkspace.current === workspace) {
+                    // covers both the backend fetch and the modifier transformation of the theme
+                    console.error("Failed to load or process the theme from the backend.", error);
+                    // reset both channels (context theme and global CSS) to the default theme so
+                    // context consumers stay consistent with the cleared CSS variables
+                    setTheme({});
+                    clearCssProperties();
+                    setIsLoading(false);
+                    setStatus("success");
+                }
             }
         };
         void fetchData();

package/esm/ThemeProvider/prepareTheme.d.ts

@@ -1,4 +1,16 @@
 import { type ITheme } from "@gooddata/sdk-model";
+/**
+ * Drops palette colors that the `polished` color functions cannot parse.
+ *
+ * @remarks
+ * A single invalid color (e.g. a typo like "#1616D") would otherwise make theme application throw.
+ * An invalid color is treated exactly like an omitted one: it is removed so the standard default
+ * applies (missing shades are interpolated, missing family/complementary colors fall back to the
+ * default theme), while every other valid color is preserved. A color family whose base is invalid
+ * is dropped as a whole, since the family is meaningless without a base. The try/catch in
+ * ThemeProvider remains the hard backstop for any color path not covered here.
+ */
+export declare const sanitizePalette: (theme: ITheme) => ITheme;
 export declare const prepareComplementaryPalette: (theme: ITheme) => ITheme;
 export declare const prepareBaseColors: (theme: ITheme) => ITheme;
 export declare const stripComplementaryPalette: (theme: ITheme) => ITheme;

package/esm/ThemeProvider/prepareTheme.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prepareTheme.d.ts","sourceRoot":"","sources":["../../src/ThemeProvider/prepareTheme.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAYlD,eAAO,MAAM,2BAA2B,2BAYvC,CAAC;AAEF,eAAO,MAAM,iBAAiB,2BAoB7B,CAAC;AAEF,eAAO,MAAM,yBAAyB,2BAgBrC,CAAC;AAEF,eAAO,MAAM,mBAAmB,2BAsB/B,CAAC;AAEF,eAAO,MAAM,YAAY,iEAQxB,CAAC"}
+{"version":3,"file":"prepareTheme.d.ts","sourceRoot":"","sources":["../../src/ThemeProvider/prepareTheme.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,MAAM,EAA2D,MAAM,qBAAqB,CAAC;AAmD3G;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,2BA0B3B,CAAC;AAEF,eAAO,MAAM,2BAA2B,2BAYvC,CAAC;AAEF,eAAO,MAAM,iBAAiB,2BAe7B,CAAC;AAEF,eAAO,MAAM,yBAAyB,2BAgBrC,CAAC;AAEF,eAAO,MAAM,mBAAmB,2BAsB/B,CAAC;AAEF,eAAO,MAAM,YAAY,iEAUxB,CAAC"}

package/esm/ThemeProvider/prepareTheme.js

@@ -1,5 +1,6 @@
-// (C) 2021-2025 GoodData Corporation
+// (C) 2021-2026 GoodData Corporation
 import { getContrast, shade } from "polished";
+import { isValidThemeColor } from "../colorValidation.js";
 import { getComplementaryPalette } from "../complementaryPalette.js";
 /**
  * Minimum contrast ratio n:1 recommended by W3C
@@ -7,6 +8,69 @@ import { getComplementaryPalette } from "../complementaryPalette.js";
  */
 const MIN_CONTRAST_RATIO = 3;
 const DEFAULT_BACKGROUND_COLOR = "#fff";
+const DEFAULT_PRIMARY = "#14b2e2";
+const DEFAULT_SUCCESS = "#00c18d";
+const DEFAULT_ERROR = "#e54d42";
+const DEFAULT_WARNING = "#f18600";
+const sanitizeColorFamily = (family) => {
+    // without a usable base the whole family is dropped, so a default base is supplied downstream
+    if (!isValidThemeColor(family.base)) {
+        return undefined;
+    }
+    const sanitized = { base: family.base };
+    ["light", "dark", "contrast"].forEach((key) => {
+        const value = family[key];
+        if (value !== undefined && isValidThemeColor(value)) {
+            sanitized[key] = value;
+        }
+    });
+    return sanitized;
+};
+const sanitizeComplementaryPalette = (complementary) => {
+    const sanitized = {};
+    Object.keys(complementary).forEach((key) => {
+        const value = complementary[key];
+        if (value !== undefined && isValidThemeColor(value)) {
+            sanitized[key] = value;
+        }
+    });
+    return sanitized;
+};
+/**
+ * Drops palette colors that the `polished` color functions cannot parse.
+ *
+ * @remarks
+ * A single invalid color (e.g. a typo like "#1616D") would otherwise make theme application throw.
+ * An invalid color is treated exactly like an omitted one: it is removed so the standard default
+ * applies (missing shades are interpolated, missing family/complementary colors fall back to the
+ * default theme), while every other valid color is preserved. A color family whose base is invalid
+ * is dropped as a whole, since the family is meaningless without a base. The try/catch in
+ * ThemeProvider remains the hard backstop for any color path not covered here.
+ */
+export const sanitizePalette = (theme) => {
+    if (!theme?.palette) {
+        return theme;
+    }
+    const palette = { ...theme.palette };
+    const families = ["primary", "error", "warning", "success", "info"];
+    families.forEach((key) => {
+        const family = palette[key];
+        if (family === undefined) {
+            return;
+        }
+        const sanitized = sanitizeColorFamily(family);
+        if (sanitized) {
+            palette[key] = sanitized;
+        }
+        else {
+            delete palette[key];
+        }
+    });
+    if (palette.complementary) {
+        palette.complementary = sanitizeComplementaryPalette(palette.complementary);
+    }
+    return { ...theme, palette };
+};
 export const prepareComplementaryPalette = (theme) => {
     if (theme?.palette?.complementary) {
         return {
@@ -20,19 +84,15 @@ export const prepareComplementaryPalette = (theme) => {
     return theme;
 };
 export const prepareBaseColors = (theme) => {
-    const defaultPrimary = "#14b2e2";
-    const defaultSuccess = "#00c18d";
-    const defaultError = "#e54d42";
-    const defaultWarning = "#f18600";
     if (theme?.palette?.complementary) {
         return {
             ...theme,
             palette: {
                 ...theme.palette,
-                ...(theme.palette.primary ? {} : { primary: { base: defaultPrimary } }),
-                ...(theme.palette.success ? {} : { success: { base: defaultSuccess } }),
-                ...(theme.palette.error ? {} : { error: { base: defaultError } }),
-                ...(theme.palette.warning ? {} : { warning: { base: defaultWarning } }),
+                ...(theme.palette.primary ? {} : { primary: { base: DEFAULT_PRIMARY } }),
+                ...(theme.palette.success ? {} : { success: { base: DEFAULT_SUCCESS } }),
+                ...(theme.palette.error ? {} : { error: { base: DEFAULT_ERROR } }),
+                ...(theme.palette.warning ? {} : { warning: { base: DEFAULT_WARNING } }),
             },
         };
     }
@@ -74,10 +134,11 @@ export const preparePrimaryColor = (theme) => {
     };
 };
 export const prepareTheme = (theme, enableComplementaryPalette = true) => {
+    const sanitizedTheme = sanitizePalette(theme);
     if (!enableComplementaryPalette) {
-        const themeWithContrastPrimaryColor = preparePrimaryColor(theme);
+        const themeWithContrastPrimaryColor = preparePrimaryColor(sanitizedTheme);
         return stripComplementaryPalette(themeWithContrastPrimaryColor);
     }
-    const themeWithComplementaryPalette = prepareComplementaryPalette(theme);
+    const themeWithComplementaryPalette = prepareComplementaryPalette(sanitizedTheme);
     return prepareBaseColors(themeWithComplementaryPalette);
 };

package/esm/colorValidation.d.ts

@@ -0,0 +1,35 @@
+import { type ITheme } from "@gooddata/sdk-model";
+/**
+ * Returns true if the provided value is a color string that the `polished` library can parse
+ * (hex, rgb(a), hsl(a) or a named color).
+ *
+ * @remarks
+ * `polished` is the single source of truth for what the theme application code can consume:
+ * the same parser (`parseToRgb`) backs `mix`, `getContrast`, `shade`, `transparentize` and
+ * `getLuminance`. Validating with it guarantees this check agrees exactly with the functions
+ * that would otherwise throw on an unparseable color.
+ *
+ * @internal
+ */
+export declare const isValidThemeColor: (color: unknown) => boolean;
+/**
+ * A palette color that cannot be parsed, together with its dot-separated location in the palette
+ * (e.g. `complementary.c9` or `primary.base`).
+ *
+ * @internal
+ */
+export interface IInvalidThemeColor {
+    path: string;
+    value: string;
+}
+/**
+ * Walks the theme palette and returns the colors that cannot be parsed, each with its location.
+ *
+ * @remarks
+ * Only palette colors are inspected, as those are the values fed into the `polished` color
+ * functions during theme application. An empty array means every palette color is valid.
+ *
+ * @internal
+ */
+export declare const findInvalidThemeColors: (theme: ITheme | undefined) => IInvalidThemeColor[];
+//# sourceMappingURL=colorValidation.d.ts.map

package/esm/colorValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colorValidation.d.ts","sourceRoot":"","sources":["../src/colorValidation.ts"],"names":[],"mappings":"AAIA,OAAO,EACH,KAAK,MAAM,EAId,MAAM,qBAAqB,CAAC;AAE7B;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iBAAiB,6BAW7B,CAAC;AAEF;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACjB;AA6BD;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,qDAelC,CAAC"}

package/esm/colorValidation.js

@@ -0,0 +1,66 @@
+// (C) 2026 GoodData Corporation
+import { parseToRgb } from "polished";
+/**
+ * Returns true if the provided value is a color string that the `polished` library can parse
+ * (hex, rgb(a), hsl(a) or a named color).
+ *
+ * @remarks
+ * `polished` is the single source of truth for what the theme application code can consume:
+ * the same parser (`parseToRgb`) backs `mix`, `getContrast`, `shade`, `transparentize` and
+ * `getLuminance`. Validating with it guarantees this check agrees exactly with the functions
+ * that would otherwise throw on an unparseable color.
+ *
+ * @internal
+ */
+export const isValidThemeColor = (color) => {
+    if (typeof color !== "string" || color.trim() === "") {
+        return false;
+    }
+    try {
+        parseToRgb(color);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const colorFamilyKeys = ["base", "light", "dark", "contrast"];
+const collectInvalidFamilyColors = (family, familyKey) => {
+    if (!family) {
+        return [];
+    }
+    return colorFamilyKeys
+        .filter((key) => family[key] !== undefined && !isValidThemeColor(family[key]))
+        .map((key) => ({ path: `${familyKey}.${key}`, value: family[key] }));
+};
+const collectInvalidComplementaryColors = (complementary) => {
+    if (!complementary) {
+        return [];
+    }
+    return Object.keys(complementary)
+        .filter((key) => complementary[key] !== undefined && !isValidThemeColor(complementary[key]))
+        .map((key) => ({ path: `complementary.${key}`, value: complementary[key] }));
+};
+/**
+ * Walks the theme palette and returns the colors that cannot be parsed, each with its location.
+ *
+ * @remarks
+ * Only palette colors are inspected, as those are the values fed into the `polished` color
+ * functions during theme application. An empty array means every palette color is valid.
+ *
+ * @internal
+ */
+export const findInvalidThemeColors = (theme) => {
+    const palette = theme?.palette;
+    if (!palette) {
+        return [];
+    }
+    return [
+        ...collectInvalidFamilyColors(palette.primary, "primary"),
+        ...collectInvalidFamilyColors(palette.error, "error"),
+        ...collectInvalidFamilyColors(palette.warning, "warning"),
+        ...collectInvalidFamilyColors(palette.success, "success"),
+        ...collectInvalidFamilyColors(palette.info, "info"),
+        ...collectInvalidComplementaryColors(palette.complementary),
+    ];
+};

package/esm/index.d.ts

@@ -14,4 +14,5 @@ export { ScopedThemeProvider, type IScopedThemeProviderProps } from "./ThemeProv
 export { ConditionalScopedThemeProvider } from "./ThemeProvider/ConditionalScopedThemeProvider.js";
 export { isDarkTheme } from "./ThemeProvider/isDarkTheme.js";
 export { withTheme, useTheme, useThemeIsLoading, useIsScopeThemed, useThemeStatus, useIsDarkTheme, ThemeContextProvider, type IThemeContextProviderProps, type ThemeStatus, } from "./ThemeProvider/Context.js";
+export { isValidThemeColor, findInvalidThemeColors, type IInvalidThemeColor } from "./colorValidation.js";
 //# sourceMappingURL=index.d.ts.map

package/esm/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAC3E,OAAO,EACH,aAAa,EACb,KAAK,mBAAmB,EACxB,KAAK,aAAa,GACrB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,mBAAmB,EAAE,KAAK,yBAAyB,EAAE,MAAM,wCAAwC,CAAC;AAC7G,OAAO,EAAE,8BAA8B,EAAE,MAAM,mDAAmD,CAAC;AACnG,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EACH,SAAS,EACT,QAAQ,EACR,iBAAiB,EACjB,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,oBAAoB,EACpB,KAAK,0BAA0B,EAC/B,KAAK,WAAW,GACnB,MAAM,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA;;;;;;;;;GASG;AACH,OAAO,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAC3E,OAAO,EACH,aAAa,EACb,KAAK,mBAAmB,EACxB,KAAK,aAAa,GACrB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EAAE,mBAAmB,EAAE,KAAK,yBAAyB,EAAE,MAAM,wCAAwC,CAAC;AAC7G,OAAO,EAAE,8BAA8B,EAAE,MAAM,mDAAmD,CAAC;AACnG,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAC7D,OAAO,EACH,SAAS,EACT,QAAQ,EACR,iBAAiB,EACjB,gBAAgB,EAChB,cAAc,EACd,cAAc,EACd,oBAAoB,EACpB,KAAK,0BAA0B,EAC/B,KAAK,WAAW,GACnB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,KAAK,kBAAkB,EAAE,MAAM,sBAAsB,CAAC"}

package/esm/index.js

@@ -16,3 +16,4 @@ export { ScopedThemeProvider } from "./ThemeProvider/ScopedThemeProvider.js";
 export { ConditionalScopedThemeProvider } from "./ThemeProvider/ConditionalScopedThemeProvider.js";
 export { isDarkTheme } from "./ThemeProvider/isDarkTheme.js";
 export { withTheme, useTheme, useThemeIsLoading, useIsScopeThemed, useThemeStatus, useIsDarkTheme, ThemeContextProvider, } from "./ThemeProvider/Context.js";
+export { isValidThemeColor, findInvalidThemeColors } from "./colorValidation.js";

package/esm/sdk-ui-theme-provider.d.ts

@@ -37,6 +37,28 @@ export declare function ConditionalScopedThemeProvider({ children }: {
  */
 export declare const defaultHeaderTheme: IThemeHeader;
 
+/**
+ * Walks the theme palette and returns the colors that cannot be parsed, each with its location.
+ *
+ * @remarks
+ * Only palette colors are inspected, as those are the values fed into the `polished` color
+ * functions during theme application. An empty array means every palette color is valid.
+ *
+ * @internal
+ */
+export declare const findInvalidThemeColors: (theme: ITheme | undefined) => IInvalidThemeColor[];
+
+/**
+ * A palette color that cannot be parsed, together with its dot-separated location in the palette
+ * (e.g. `complementary.c9` or `primary.base`).
+ *
+ * @internal
+ */
+export declare interface IInvalidThemeColor {
+    path: string;
+    value: string;
+}
+
 /**
  * @internal
  */
@@ -95,6 +117,20 @@ export declare interface IScopedThemeProviderProps {
  */
 export declare const isDarkTheme: (theme: ITheme | undefined) => boolean;
 
+/**
+ * Returns true if the provided value is a color string that the `polished` library can parse
+ * (hex, rgb(a), hsl(a) or a named color).
+ *
+ * @remarks
+ * `polished` is the single source of truth for what the theme application code can consume:
+ * the same parser (`parseToRgb`) backs `mix`, `getContrast`, `shade`, `transparentize` and
+ * `getLuminance`. Validating with it guarantees this check agrees exactly with the functions
+ * that would otherwise throw on an unparseable color.
+ *
+ * @internal
+ */
+export declare const isValidThemeColor: (color: unknown) => boolean;
+
 /**
  * @public
  */

package/esm/variablesSpec/internal/geo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geo.d.ts","sourceRoot":"","sources":["../../../src/variablesSpec/internal/geo.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAE5D,eAAO,MAAM,yBAAyB,EAAE,wBAAwB,EAW/D,CAAC"}
+{"version":3,"file":"geo.d.ts","sourceRoot":"","sources":["../../../src/variablesSpec/internal/geo.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAE5D,eAAO,MAAM,yBAAyB,EAAE,wBAAwB,EAwB/D,CAAC"}

package/esm/variablesSpec/internal/geo.js

@@ -1,4 +1,4 @@
-// (C) 2025 GoodData Corporation
+// (C) 2025-2026 GoodData Corporation
 export const internalGeoThemeVariables = [
     {
         type: "internal",
@@ -10,4 +10,17 @@ export const internalGeoThemeVariables = [
         variableName: "--gd-geo-multi-layer-legend__toggle-duration",
         defaultValue: "0.2s",
     },
+    // Tooltip background, shared between the card and its clipped-content fade; referenced without a
+    // fallback, so no default value to validate.
+    {
+        type: "internal",
+        variableName: "--gd-viz-tooltip-bg",
+        defaultValue: null,
+    },
+    // Dynamic height cap fed from JS; unset (none) means no clamp.
+    {
+        type: "internal",
+        variableName: "--gd-viz-tooltip-max-height",
+        defaultValue: "none",
+    },
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddata/sdk-ui-theme-provider",
-  "version": "11.42.0-alpha.3",
+  "version": "11.42.0-alpha.4",
   "description": "GoodData SDK - Theme provider",
   "license": "MIT",
   "author": "GoodData Corporation",
@@ -32,10 +32,10 @@
     "postcss-value-parser": "^4.2.0",
     "ts-invariant": "0.10.3",
     "tslib": "2.8.1",
-    "@gooddata/sdk-model": "11.42.0-alpha.3",
-    "@gooddata/util": "11.42.0-alpha.3",
-    "@gooddata/sdk-backend-spi": "11.42.0-alpha.3",
-    "@gooddata/sdk-ui": "11.42.0-alpha.3"
+    "@gooddata/sdk-backend-spi": "11.42.0-alpha.4",
+    "@gooddata/sdk-model": "11.42.0-alpha.4",
+    "@gooddata/sdk-ui": "11.42.0-alpha.4",
+    "@gooddata/util": "11.42.0-alpha.4"
   },
   "devDependencies": {
     "@microsoft/api-documenter": "^7.17.0",
@@ -73,10 +73,10 @@
     "react-dom": "19.1.1",
     "typescript": "5.9.3",
     "vitest": "4.1.8",
-    "@gooddata/eslint-config": "11.42.0-alpha.3",
-    "@gooddata/oxlint-config": "11.42.0-alpha.3",
-    "@gooddata/reference-workspace": "11.42.0-alpha.3",
-    "@gooddata/sdk-backend-mockingbird": "11.42.0-alpha.3"
+    "@gooddata/eslint-config": "11.42.0-alpha.4",
+    "@gooddata/oxlint-config": "11.42.0-alpha.4",
+    "@gooddata/reference-workspace": "11.42.0-alpha.4",
+    "@gooddata/sdk-backend-mockingbird": "11.42.0-alpha.4"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",