@gooddata/sdk-ui-vis-commons 11.41.0-alpha.1 → 11.41.0-alpha.2

package/esm/customTooltip/referenceResolver.js

@@ -1,5 +1,6 @@
 // (C) 2026 GoodData Corporation
 import { REFERENCE_REGEX_MATCH } from "@gooddata/sdk-ui-kit";
+import { labelKey, metricKey, } from "./types.js";
 // Markdown metacharacters that, if present in a substituted value, would be
 // reinterpreted as formatting by `markdownToHtml`. Backslash-escape them so the
 // parser treats them as literal text. The set covers every char that can start
@@ -22,8 +23,8 @@ function renderReference(ref, strings) {
             return strings.noData;
         case "multiple":
             return strings.multipleItems;
-        case "error":
-        default:
+        case undefined:
+            // Absent reference → couldn't be resolved at this point.
             return strings.noFetch;
     }
 }
@@ -49,10 +50,10 @@ export function resolveReferences(content, values, strings) {
         return "";
     }
     return content.replace(REFERENCE_REGEX_MATCH, (_fullMatch, _wrapped, _key, prefix, identifier) => {
-        // The regex matches the prefix case-insensitively; storage uses
-        // lowercase prefixes so users can write either `{metric/foo}` or
-        // `{Metric/foo}`. LDM identifiers stay as-is — they are case-sensitive.
-        const ref = values[`${prefix.toLowerCase()}/${identifier}`];
-        return escapeMarkdownMetachars(renderReference(ref, strings));
+        // The regex captures the prefix case-insensitively (`metric` | `label`);
+        // route through the key helpers so the lookup format stays single-sourced
+        // with the write sites. LDM identifiers stay as-is — they are case-sensitive.
+        const key = prefix.toLowerCase() === "metric" ? metricKey(identifier) : labelKey(identifier);
+        return escapeMarkdownMetachars(renderReference(values[key], strings));
     });
 }

package/esm/customTooltip/tooltipExecution.d.ts

@@ -28,8 +28,9 @@ export interface ITooltipExecutionBundle {
  * plus per-reference bundles used as an isolation fallback. When the batch
  * rejects (e.g. a single invalid reference 400s the whole AFM), the consumer
  * re-runs the per-reference bundles so one bad reference can't suppress the
- * rest. `perRef` is a thunk: the bundles are built lazily, only when the batch
- * fails, so consumers that never fan out (e.g. geo) pay nothing for it.
+ * rest. Both Highcharts and geo fan out this way. `perRef` is a thunk: the
+ * bundles are built lazily, only when the batch fails, so the success path
+ * pays nothing for it.
  *
  * @internal
  */

package/esm/customTooltip/tooltipExecution.js

@@ -166,7 +166,8 @@ export function buildTooltipExecution(executionFactory, chartDefinition, tooltip
     if (!batch) {
         return null;
     }
-    // Lazy: built only on batch failure (the Highcharts fan-out); geo never calls it.
+    // Lazy: built only on batch failure (Highcharts and geo both fan out); the
+    // success path never invokes it.
     const perRef = () => externalRefs
         .map((ref) => buildBundle(executionFactory, chartDefinition, [ref], options))
         .filter((bundle) => bundle !== null);

package/esm/customTooltip/types.d.ts

@@ -61,11 +61,10 @@ export interface ICustomTooltipConfig {
 /**
  * Resolution outcome for a single `{metric/id}` / `{label/id}` reference at a
  * data point. A discriminated union so the renderer maps each state to its own
- * localized message instead of collapsing every "missing" case into one
- * fallback: `empty` → "(No data)", `multiple` → "(Multiple items)", `error` →
- * "(Data could not be retrieved)". `error` is emitted only when a value was
- * genuinely unretrievable (e.g. a reference whose fetch failed); it is never a
- * default for an unclassified value.
+ * localized message instead of collapsing them: `empty` → "(No data)",
+ * `multiple` → "(Multiple items)". A reference that couldn't be resolved at all
+ * is represented by *absence* from the lookup (`undefined`), which the renderer
+ * maps to "(Data could not be retrieved)" — there is no explicit error variant.
  *
  * @internal
  */
@@ -76,8 +75,6 @@ export type ResolvedReference = {
     readonly kind: "empty";
 } | {
     readonly kind: "multiple";
-} | {
-    readonly kind: "error";
 };
 /**
  * Lookup of resolved reference statuses keyed by `metric/id` or `label/id`.
@@ -90,8 +87,9 @@ export interface IResolvedReferenceValues {
 /**
  * Builds the `metric/<id>` lookup key for a metric reference. A reference key
  * has exactly two shapes ({@link metricKey}, {@link labelKey}); keeping the
- * convention here is the single source for every write site. The read side
- * parses references via `REFERENCE_REGEX_MATCH` in `resolveReferences`.
+ * convention here makes it the single source for both the write sites and the
+ * read in `resolveReferences` (which routes the parsed prefix through these
+ * helpers rather than rebuilding the key).
  *
  * @internal
  */

package/esm/customTooltip/types.js

@@ -2,8 +2,9 @@
 /**
  * Builds the `metric/<id>` lookup key for a metric reference. A reference key
  * has exactly two shapes ({@link metricKey}, {@link labelKey}); keeping the
- * convention here is the single source for every write site. The read side
- * parses references via `REFERENCE_REGEX_MATCH` in `resolveReferences`.
+ * convention here makes it the single source for both the write sites and the
+ * read in `resolveReferences` (which routes the parsed prefix through these
+ * helpers rather than rebuilding the key).
  *
  * @internal
  */

package/esm/customTooltip/useTooltipLookupExecutions.d.ts

@@ -1,18 +1,6 @@
-import { type IPreparedExecution } from "@gooddata/sdk-backend-spi";
 import { type ISeparators } from "@gooddata/sdk-model";
-import { type ITooltipExecution, type ITooltipExecutionMeta } from "./tooltipExecution.js";
+import { type ITooltipExecution } from "./tooltipExecution.js";
 import { type IResolvedReferenceValues } from "./types.js";
-/**
- * Built lookup plus references that could not be retrieved at all (their fetch
- * rejected even in the per-reference fallback). Errored references render as
- * "(Data could not be retrieved)" at every point.
- *
- * @internal
- */
-export interface ITooltipLookupResult {
-    lookup: Map<string, IResolvedReferenceValues>;
-    erroredRefs: ReadonlySet<string>;
-}
 /**
  * Single-execution variant for chart families that have one tooltip execution
  * per chart (e.g. Highcharts). Returns `undefined` while no execution is
@@ -21,21 +9,21 @@ export interface ITooltipLookupResult {
  *
  * @internal
  */
-export declare function useTooltipLookup(execution: ITooltipExecution | undefined, separators?: ISeparators): ITooltipLookupResult | undefined;
+export declare function useTooltipLookup(execution: ITooltipExecution | undefined, separators?: ISeparators): Map<string, IResolvedReferenceValues> | undefined;
 /**
- * One prepared tooltip execution paired with a caller-owned key and the
- * context that travels with the built lookup.
+ * One tooltip execution plan paired with a caller-owned key and the context
+ * that travels with the built lookup.
  *
  * @internal
  */
 export interface ITooltipLookupExecutionEntry<TContext> {
     key: string;
-    execution: IPreparedExecution;
-    meta: ITooltipExecutionMeta;
+    execution: ITooltipExecution;
     context: TContext;
 }
 /**
- * Built lookup for one tooltip execution entry.
+ * Built lookup for one tooltip execution entry (per-entry fan-out, mirroring
+ * the single-execution variant).
  *
  * @internal
  */
@@ -45,9 +33,9 @@ export interface ITooltipLookupExecutionResult<TContext> {
 }
 /**
  * Multi-execution variant for chart families that key tooltip executions per
- * sub-target (e.g. geo per-layer). `context` is required so the produced
- * lookup carries whatever the caller needs to interpret the result —
- * downstream code does not have to defensively check for missing context.
+ * sub-target (e.g. geo per-layer). Each entry runs through the same batch →
+ * per-reference fan-out as the single-execution variant. `context` travels with
+ * the built lookup so downstream code needn't defensively check for it.
  *
  * @internal
  */

package/esm/customTooltip/useTooltipLookupExecutions.js

@@ -2,63 +2,51 @@
 import { useMemo } from "react";
 import { useCancelablePromise } from "@gooddata/sdk-ui";
 import { buildLookupTable } from "./tooltipLookup.js";
-import { labelKey, metricKey } from "./types.js";
 async function executeOne(execution) {
     const result = await execution.execute();
     return result.readAll();
 }
-/**
- * Reference keys (`metric/id`, `label/id`) a bundle's meta covers. Used to mark
- * a failed per-reference bundle's references as errored.
- */
-function refKeysOfMeta(meta) {
-    return [
-        ...Object.values(meta.measureIdMap).map(metricKey),
-        ...Object.values(meta.labelIdMap).map(labelKey),
-    ];
-}
 /**
  * Execute the batch; on failure, fan out to per-reference bundles so a single
- * bad reference (e.g. one that 400s the batched AFM) only errors itself while
- * the rest still resolve. No reliance on parsing the backend error — failure is
- * isolated structurally by which per-reference execution rejects.
+ * bad reference (e.g. one that 400s the batched AFM) only takes itself down
+ * while the rest still resolve. Isolation is structural — a failed reference is
+ * left out of the returned inputs and renders the unresolved default, with no
+ * parsing of the backend error. Fan-out fires on *any* batch rejection (a
+ * transient 5xx/timeout too, not just a bad-ref 400), so a flaky backend can
+ * produce N follow-up executions per plan.
  */
 async function runWithFallback(execution) {
     try {
         const dataView = await executeOne(execution.batch.execution);
-        return { inputs: [{ dataView, meta: execution.batch.meta }], erroredRefs: new Set() };
+        return [{ dataView, meta: execution.batch.meta }];
     }
     catch {
-        // Build the per-reference bundles now (lazy) and isolate each.
+        // Build the per-reference bundles now (lazy) and keep the ones that resolve.
         const perRef = execution.perRef();
         const settled = await Promise.allSettled(perRef.map((bundle) => executeOne(bundle.execution)));
         const inputs = [];
-        const erroredRefs = new Set();
         settled.forEach((result, index) => {
-            const bundle = perRef[index];
             if (result.status === "fulfilled") {
-                inputs.push({ dataView: result.value, meta: bundle.meta });
-            }
-            else {
-                refKeysOfMeta(bundle.meta).forEach((key) => erroredRefs.add(key));
+                inputs.push({ dataView: result.value, meta: perRef[index].meta });
             }
         });
-        return { inputs, erroredRefs };
+        return inputs;
     }
 }
 /**
  * Merge per-execution lookups into one map (by point key, shallow-merging the
- * per-point reference statuses) and pair it with the errored references.
+ * per-point reference statuses). Built in a memo so a separators change rebuilds
+ * without re-executing.
  */
-function buildResult(outcome, separators) {
+function buildLookup(inputs, separators) {
     const lookup = new Map();
-    for (const { dataView, meta } of outcome.inputs) {
+    for (const { dataView, meta } of inputs) {
         for (const [pointKey, values] of buildLookupTable(dataView, meta, separators)) {
             const existing = lookup.get(pointKey);
             lookup.set(pointKey, existing ? { ...existing, ...values } : values);
         }
     }
-    return { lookup, erroredRefs: outcome.erroredRefs };
+    return lookup;
 }
 /**
  * Single-execution variant for chart families that have one tooltip execution
@@ -73,22 +61,30 @@ export function useTooltipLookup(execution, separators) {
     const { result } = useCancelablePromise({
         promise: execution ? () => runWithFallback(execution) : undefined,
     }, [fingerprint]);
-    return useMemo(() => (result ? buildResult(result, separators) : undefined), [result, separators]);
+    return useMemo(() => (result ? buildLookup(result, separators) : undefined), [result, separators]);
 }
 const EMPTY_LOOKUPS = new Map();
 function getEntriesFingerprint(entries) {
-    return entries.map((entry) => `${entry.key}::${entry.execution.fingerprint()}`).join("||");
+    return entries
+        .map((entry) => `${entry.key}::${entry.execution.batch.execution.fingerprint()}`)
+        .join("||");
 }
 async function executeAll(entries) {
-    const settled = await Promise.allSettled(entries.map(async (entry) => ({ ...entry, dataView: await executeOne(entry.execution) })));
-    // Failed entries drop out silently; callers fall back when a lookup is missing.
+    // runWithFallback resolves for any execution failure (a failed reference is
+    // just omitted), so allSettled only guards a stray throw — one layer can't
+    // drop the rest.
+    const settled = await Promise.allSettled(entries.map(async (entry) => ({
+        key: entry.key,
+        inputs: await runWithFallback(entry.execution),
+        context: entry.context,
+    })));
     return settled.flatMap((result) => (result.status === "fulfilled" ? [result.value] : []));
 }
 /**
  * Multi-execution variant for chart families that key tooltip executions per
- * sub-target (e.g. geo per-layer). `context` is required so the produced
- * lookup carries whatever the caller needs to interpret the result —
- * downstream code does not have to defensively check for missing context.
+ * sub-target (e.g. geo per-layer). Each entry runs through the same batch →
+ * per-reference fan-out as the single-execution variant. `context` travels with
+ * the built lookup so downstream code needn't defensively check for it.
  *
  * @internal
  */
@@ -103,10 +99,8 @@ export function useTooltipLookupExecutions(entries, separators) {
         }
         const lookups = new Map();
         for (const entry of result) {
-            lookups.set(entry.key, {
-                lookup: buildLookupTable(entry.dataView, entry.meta, separators),
-                context: entry.context,
-            });
+            const lookup = buildLookup(entry.inputs, separators);
+            lookups.set(entry.key, { lookup, context: entry.context });
         }
         return lookups;
     }, [result, separators]);

package/esm/index.d.ts

@@ -35,7 +35,6 @@ export { measureReference, labelReference } from "./customTooltip/referenceStatu
 export { buildTooltipLocalizedStrings } from "./customTooltip/localizedStrings.js";
 export { resolveMeasureLdmIdentifier } from "./customTooltip/measureLdmIdentifier.js";
 export { buildTooltipExecution, type IBuildTooltipExecutionOptions, type ITooltipExecution, type ITooltipExecutionBundle, type ITooltipExecutionMeta, } from "./customTooltip/tooltipExecution.js";
-export { buildLookupTable } from "./customTooltip/tooltipLookup.js";
 export { buildKeySegment, joinKeySegments } from "./customTooltip/tooltipKey.js";
 export { composeCustomTooltipSectionHtml } from "./customTooltip/composeSectionHtml.js";
-export { useTooltipLookup, useTooltipLookupExecutions, type ITooltipLookupResult, type ITooltipLookupExecutionEntry, type ITooltipLookupExecutionResult, } from "./customTooltip/useTooltipLookupExecutions.js";
+export { useTooltipLookup, useTooltipLookupExecutions, type ITooltipLookupExecutionEntry, type ITooltipLookupExecutionResult, } from "./customTooltip/useTooltipLookupExecutions.js";

package/esm/index.js

@@ -36,7 +36,6 @@ export { measureReference, labelReference } from "./customTooltip/referenceStatu
 export { buildTooltipLocalizedStrings } from "./customTooltip/localizedStrings.js";
 export { resolveMeasureLdmIdentifier } from "./customTooltip/measureLdmIdentifier.js";
 export { buildTooltipExecution, } from "./customTooltip/tooltipExecution.js";
-export { buildLookupTable } from "./customTooltip/tooltipLookup.js";
 export { buildKeySegment, joinKeySegments } from "./customTooltip/tooltipKey.js";
 export { composeCustomTooltipSectionHtml } from "./customTooltip/composeSectionHtml.js";
 export { useTooltipLookup, useTooltipLookupExecutions, } from "./customTooltip/useTooltipLookupExecutions.js";

package/esm/sdk-ui-vis-commons.d.ts

@@ -56,16 +56,6 @@ export declare class AttributeColorStrategy extends ColorStrategy {
  */
 export declare function buildKeySegment(displayFormId: string, uri: string): string;
 
-/**
- * Build a per-data-point lookup keyed by `${displayFormId}:${uri}` segments
- * (joined by `|`, sorted). Iteration is orientation-agnostic via slices/series.
- * Each reference is tagged with a {@link ResolvedReference} status; localized
- * placeholder strings are applied later, at the render site.
- *
- * @internal
- */
-export declare function buildLookupTable(dataView: IDataView, meta: ITooltipExecutionMeta, separators?: ISeparators): Map<string, IResolvedReferenceValues>;
-
 /**
  * Returns `null` when the content has no references or all references are
  * already in the chart (resolvable from drill data without a secondary call).
@@ -804,8 +794,9 @@ export declare type ItemBorderRadiusPredicate = (item: any) => boolean;
  * plus per-reference bundles used as an isolation fallback. When the batch
  * rejects (e.g. a single invalid reference 400s the whole AFM), the consumer
  * re-runs the per-reference bundles so one bad reference can't suppress the
- * rest. `perRef` is a thunk: the bundles are built lazily, only when the batch
- * fails, so consumers that never fan out (e.g. geo) pay nothing for it.
+ * rest. Both Highcharts and geo fan out this way. `perRef` is a thunk: the
+ * bundles are built lazily, only when the batch fails, so the success path
+ * pays nothing for it.
  *
  * @internal
  */
@@ -853,20 +844,20 @@ export declare interface ITooltipLocalizedStrings {
 }
 
 /**
- * One prepared tooltip execution paired with a caller-owned key and the
- * context that travels with the built lookup.
+ * One tooltip execution plan paired with a caller-owned key and the context
+ * that travels with the built lookup.
  *
  * @internal
  */
 export declare interface ITooltipLookupExecutionEntry<TContext> {
     key: string;
-    execution: IPreparedExecution;
-    meta: ITooltipExecutionMeta;
+    execution: ITooltipExecution;
     context: TContext;
 }
 
 /**
- * Built lookup for one tooltip execution entry.
+ * Built lookup for one tooltip execution entry (per-entry fan-out, mirroring
+ * the single-execution variant).
  *
  * @internal
  */
@@ -875,18 +866,6 @@ export declare interface ITooltipLookupExecutionResult<TContext> {
     context: TContext;
 }
 
-/**
- * Built lookup plus references that could not be retrieved at all (their fetch
- * rejected even in the per-reference fallback). Errored references render as
- * "(Data could not be retrieved)" at every point.
- *
- * @internal
- */
-export declare interface ITooltipLookupResult {
-    lookup: Map<string, IResolvedReferenceValues>;
-    erroredRefs: ReadonlySet<string>;
-}
-
 /**
  * @internal
  */
@@ -961,8 +940,9 @@ export declare function measureReference(rawValue: number | string | null | unde
 /**
  * Builds the `metric/<id>` lookup key for a metric reference. A reference key
  * has exactly two shapes ({@link metricKey}, {@link labelKey}); keeping the
- * convention here is the single source for every write site. The read side
- * parses references via `REFERENCE_REGEX_MATCH` in `resolveReferences`.
+ * convention here makes it the single source for both the write sites and the
+ * read in `resolveReferences` (which routes the parsed prefix through these
+ * helpers rather than rebuilding the key).
  *
  * @internal
  */
@@ -1033,11 +1013,10 @@ export declare type PositionType = "left" | "right" | "top" | "bottom" | "auto";
 /**
  * Resolution outcome for a single `{metric/id}` / `{label/id}` reference at a
  * data point. A discriminated union so the renderer maps each state to its own
- * localized message instead of collapsing every "missing" case into one
- * fallback: `empty` → "(No data)", `multiple` → "(Multiple items)", `error` →
- * "(Data could not be retrieved)". `error` is emitted only when a value was
- * genuinely unretrievable (e.g. a reference whose fetch failed); it is never a
- * default for an unclassified value.
+ * localized message instead of collapsing them: `empty` → "(No data)",
+ * `multiple` → "(Multiple items)". A reference that couldn't be resolved at all
+ * is represented by *absence* from the lookup (`undefined`), which the renderer
+ * maps to "(Data could not be retrieved)" — there is no explicit error variant.
  *
  * @internal
  */
@@ -1048,8 +1027,6 @@ export declare type ResolvedReference = {
     readonly kind: "empty";
 } | {
     readonly kind: "multiple";
-} | {
-    readonly kind: "error";
 };
 
 /**
@@ -1111,13 +1088,13 @@ export declare const SupportedLegendPositions: PositionType[];
  *
  * @internal
  */
-export declare function useTooltipLookup(execution: ITooltipExecution | undefined, separators?: ISeparators): ITooltipLookupResult | undefined;
+export declare function useTooltipLookup(execution: ITooltipExecution | undefined, separators?: ISeparators): Map<string, IResolvedReferenceValues> | undefined;
 
 /**
  * Multi-execution variant for chart families that key tooltip executions per
- * sub-target (e.g. geo per-layer). `context` is required so the produced
- * lookup carries whatever the caller needs to interpret the result —
- * downstream code does not have to defensively check for missing context.
+ * sub-target (e.g. geo per-layer). Each entry runs through the same batch →
+ * per-reference fan-out as the single-execution variant. `context` travels with
+ * the built lookup so downstream code needn't defensively check for it.
  *
  * @internal
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddata/sdk-ui-vis-commons",
-  "version": "11.41.0-alpha.1",
+  "version": "11.41.0-alpha.2",
   "description": "GoodData.UI SDK - common functionality for different types of visualizations",
   "license": "MIT",
   "author": "GoodData Corporation",
@@ -36,11 +36,11 @@
     "react-intl": "7.1.11",
     "react-measure": "^2.5.2",
     "tslib": "2.8.1",
-    "@gooddata/sdk-backend-spi": "11.41.0-alpha.1",
-    "@gooddata/sdk-model": "11.41.0-alpha.1",
-    "@gooddata/sdk-ui": "11.41.0-alpha.1",
-    "@gooddata/sdk-ui-theme-provider": "11.41.0-alpha.1",
-    "@gooddata/sdk-ui-kit": "11.41.0-alpha.1"
+    "@gooddata/sdk-backend-spi": "11.41.0-alpha.2",
+    "@gooddata/sdk-ui": "11.41.0-alpha.2",
+    "@gooddata/sdk-ui-kit": "11.41.0-alpha.2",
+    "@gooddata/sdk-ui-theme-provider": "11.41.0-alpha.2",
+    "@gooddata/sdk-model": "11.41.0-alpha.2"
   },
   "devDependencies": {
     "@microsoft/api-documenter": "^7.17.0",
@@ -81,11 +81,11 @@
     "typescript": "5.9.3",
     "vitest": "4.1.8",
     "vitest-dom": "0.1.1",
-    "@gooddata/eslint-config": "11.41.0-alpha.1",
-    "@gooddata/oxlint-config": "11.41.0-alpha.1",
-    "@gooddata/sdk-backend-mockingbird": "11.41.0-alpha.1",
-    "@gooddata/stylelint-config": "11.41.0-alpha.1",
-    "@gooddata/reference-workspace": "11.41.0-alpha.1"
+    "@gooddata/eslint-config": "11.41.0-alpha.2",
+    "@gooddata/oxlint-config": "11.41.0-alpha.2",
+    "@gooddata/reference-workspace": "11.41.0-alpha.2",
+    "@gooddata/sdk-backend-mockingbird": "11.41.0-alpha.2",
+    "@gooddata/stylelint-config": "11.41.0-alpha.2"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0",