Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

Add labels to scalar tab in Metrics Viewer (#72541)

Kevin Kelleher43fa71b2a51a
diff --git a/frontend/src/metabase/metrics-viewer/hooks/use-metrics-viewer.ts b/frontend/src/metabase/metrics-viewer/hooks/use-metrics-viewer.ts
index da431ecbcea..9ca0d136fb1 100644
--- a/frontend/src/metabase/metrics-viewer/hooks/use-metrics-viewer.ts
+++ b/frontend/src/metabase/metrics-viewer/hooks/use-metrics-viewer.ts
@@ -191,21 +191,16 @@ export function useMetricsViewer({
return buildSeries({
formulaEntities: state.formulaEntities,
definitions: state.definitions,
- metricSlots,
- dimensionMapping: activeTab.dimensionMapping,
display: activeTab.display,
resultsByEntityIndex,
- modifiedDefinitionsBySlotIndex,
sourceBreakoutColors,
extraVizSettings: activeTab.visualizationSettings,
});
}, [
state.formulaEntities,
state.definitions,
- metricSlots,
activeTab,
resultsByEntityIndex,
- modifiedDefinitionsBySlotIndex,
sourceBreakoutColors,
]);
diff --git a/frontend/src/metabase/metrics-viewer/pages/MetricsViewerPage/MetricsViewerPage.tsx b/frontend/src/metabase/metrics-viewer/pages/MetricsViewerPage/MetricsViewerPage.tsx
index 4734056c25f..0b52db4b571 100644
--- a/frontend/src/metabase/metrics-viewer/pages/MetricsViewerPage/MetricsViewerPage.tsx
+++ b/frontend/src/metabase/metrics-viewer/pages/MetricsViewerPage/MetricsViewerPage.tsx
@@ -161,11 +161,13 @@ export function MetricsViewerPage(props: MetricsViewerPageProps) {
<MetricsViewerNoTabsEmptyState />
) : null}
</Flex>
- <BreakoutLegend
- formulaEntities={formulaEntities}
- definitions={definitions}
- activeBreakoutColors={activeBreakoutColors}
- />
+ {activeTab?.type !== "scalar" && (
+ <BreakoutLegend
+ formulaEntities={formulaEntities}
+ definitions={definitions}
+ activeBreakoutColors={activeBreakoutColors}
+ />
+ )}
</Flex>
</Stack>
</Flex>
diff --git a/frontend/src/metabase/metrics-viewer/utils/geo-dimensions.ts b/frontend/src/metabase/metrics-viewer/utils/geo-dimensions.ts
deleted file mode 100644
index a6f80a3f5b5..00000000000
--- a/frontend/src/metabase/metrics-viewer/utils/geo-dimensions.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import type { DimensionMetadata } from "metabase-lib/metric";
-import * as LibMetric from "metabase-lib/metric";
-
-export function getMapRegionForDimension(
- dimension: DimensionMetadata,
-): string | null {
- if (LibMetric.isState(dimension)) {
- return "us_states";
- }
- if (LibMetric.isCountry(dimension)) {
- return "world_countries";
- }
- return null;
-}
diff --git a/frontend/src/metabase/metrics-viewer/utils/geo-dimensions.unit.spec.ts b/frontend/src/metabase/metrics-viewer/utils/geo-dimensions.unit.spec.ts
deleted file mode 100644
index 6db14d6199b..00000000000
--- a/frontend/src/metabase/metrics-viewer/utils/geo-dimensions.unit.spec.ts
+++ /dev/null
@@ -1,51 +0,0 @@
-import * as LibMetric from "metabase-lib/metric";
-
-import {
- GEO_DIM_IDX,
- GEO_METRIC,
- createMetricMetadata,
- setupDefinition,
-} from "./__tests__/test-helpers";
-import { getMapRegionForDimension } from "./geo-dimensions";
-
-const metadata = createMetricMetadata([GEO_METRIC]);
-const geoDefinition = setupDefinition(metadata, GEO_METRIC.id);
-const geoDimensions = LibMetric.projectionableDimensions(geoDefinition);
-
-describe("getMapRegionForDimension", () => {
- it("returns us_states for state dimensions", () => {
- expect(getMapRegionForDimension(geoDimensions[GEO_DIM_IDX.STATE])).toBe(
- "us_states",
- );
- });
-
- it("returns world_countries for country dimensions", () => {
- expect(getMapRegionForDimension(geoDimensions[GEO_DIM_IDX.COUNTRY])).toBe(
- "world_countries",
- );
- });
-
- it("returns null for city dimensions", () => {
- expect(
- getMapRegionForDimension(geoDimensions[GEO_DIM_IDX.CITY]),
- ).toBeNull();
- });
-
- it("returns null for latitude dimensions", () => {
- expect(
- getMapRegionForDimension(geoDimensions[GEO_DIM_IDX.LATITUDE]),
- ).toBeNull();
- });
-
- it("returns null for longitude dimensions", () => {
- expect(
- getMapRegionForDimension(geoDimensions[GEO_DIM_IDX.LONGITUDE]),
- ).toBeNull();
- });
-
- it("returns null for datetime dimensions", () => {
- expect(
- getMapRegionForDimension(geoDimensions[GEO_DIM_IDX.DATE_TIME]),
- ).toBeNull();
- });
-});
diff --git a/frontend/src/metabase/metrics-viewer/utils/index.ts b/frontend/src/metabase/metrics-viewer/utils/index.ts
index 7ddd1650331..63168b469e8 100644
--- a/frontend/src/metabase/metrics-viewer/utils/index.ts
+++ b/frontend/src/metabase/metrics-viewer/utils/index.ts
@@ -1,6 +1,5 @@
export * from "./source-ids";
export * from "./dimension-filters";
-export * from "./geo-dimensions";
export * from "./dimension-lookup";
export * from "./definition-builder";
export * from "./definition-entries";
diff --git a/frontend/src/metabase/metrics-viewer/utils/series.ts b/frontend/src/metabase/metrics-viewer/utils/series.ts
index 8947231ce95..85484f0e072 100644
--- a/frontend/src/metabase/metrics-viewer/utils/series.ts
+++ b/frontend/src/metabase/metrics-viewer/utils/series.ts
@@ -10,7 +10,6 @@ import type {
import type { IconName } from "metabase/ui";
import { getColorsForValues } from "metabase/ui/colors/charts";
import { isNotNull } from "metabase/utils/types";
-import { getColorplethColorScale } from "metabase/visualizations/components/ChoroplethMap";
import {
formatBreakoutValue,
getBreakoutSeriesName,
@@ -28,10 +27,8 @@ import type {
MetricBreakoutValuesResponse,
RowValue,
RowValues,
- SeriesSettings,
SingleSeries,
TemporalUnit,
- VisualizationDisplay,
VisualizationSettings,
} from "metabase-types/api";
@@ -57,7 +54,6 @@ import {
getEffectiveDefinitionEntry,
getEntryBreakout,
} from "./definition-entries";
-import { findDimensionById } from "./dimension-lookup";
import { type MetricSlot, slotsForEntity } from "./metric-slots";
import { nextSyntheticCardId, parseSourceId } from "./source-ids";
import { DISPLAY_TYPE_REGISTRY } from "./tab-config";
@@ -67,10 +63,7 @@ interface BuildSeriesParams {
formulaEntities: MetricsViewerFormulaEntity[];
definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;
resultsByEntityIndex: Map<number, Dataset>;
- metricSlots: MetricSlot[];
- dimensionMapping: Record<number, DimensionId | null>;
display: MetricsViewerDisplayType;
- modifiedDefinitionsBySlotIndex: Map<number, MetricDefinition>;
sourceBreakoutColors: SourceBreakoutColorMap;
extraVizSettings?: Partial<VisualizationSettings>;
}
@@ -79,10 +72,7 @@ export function buildSeries({
formulaEntities,
definitions,
resultsByEntityIndex,
- metricSlots,
- dimensionMapping,
display,
- modifiedDefinitionsBySlotIndex,
sourceBreakoutColors,
extraVizSettings,
}: BuildSeriesParams): {
@@ -102,7 +92,6 @@ export function buildSeries({
const series = Array.from(resultsByEntityIndex.entries()).flatMap(
([entityIndex, result]) => {
- let vizSettings: VisualizationSettings | null = null;
const entity = formulaEntities[entityIndex];
const name = uniqueNamesByEntityIndex.get(entityIndex);
@@ -112,84 +101,53 @@ export function buildSeries({
const colors = sourceBreakoutColors[entityIndex];
const color = getSingleColor(colors);
+ const hasEnoughColsForBreakout = displayType.dimensionRequired
+ ? result.data.cols.length > 2
+ : result.data.cols.length > 1;
const hasBreakout =
isMetricEntry(entity) &&
entryHasBreakout(getEffectiveDefinitionEntry(entity, definitions)) &&
- result.data.rows.length > 0;
- const breakoutIsSameAsDimension =
- hasBreakout && result.data.cols.length === 2;
- const nativeBreakout =
- hasBreakout &&
- !breakoutIsSameAsDimension &&
- displayType.supportsMultipleSeries;
+ result.data.rows.length > 0 &&
+ hasEnoughColsForBreakout &&
+ colors instanceof Map;
+ const nativeBreakout = hasBreakout && displayType.supportsMultipleSeries;
const needsManualBreakoutSplit = hasBreakout && !nativeBreakout;
- if (nativeBreakout) {
- vizSettings = buildCartesianVizSettings(
- result.data,
- true,
- formulaEntities.length > 1,
- name,
- colors instanceof Map ? colors : undefined,
- );
- } else {
- vizSettings = getVizSettings(
- dimensionMapping,
- display,
- modifiedDefinitionsBySlotIndex,
- metricSlots
- .filter((slot) => slot.entityIndex === entityIndex)
- .map((slot) => slot.slotIndex),
- );
- }
- if (!vizSettings) {
- return [];
- }
+ const vizSettings = displayType.getSettings({
+ entity,
+ cols: result.data.cols,
+ color: color,
+ breakoutColors: hasBreakout ? colors : undefined,
+ isFirstSeries,
+ hasMultipleSeries: formulaEntities.length > 1,
+ cardName: name,
+ definitions,
+ });
const cardId = nextSyntheticCardId();
-
- const seriesKey = isFirstSeries ? result.data.cols[1]?.name : name;
-
- const vizSettingsOverride: Partial<VisualizationSettings> = nativeBreakout
- ? {}
- : computeColorVizSettings({
- displayType: display,
- seriesKey,
- color,
- });
-
- if (isFirstSeries && isExpressionEntry(entity) && seriesKey && name) {
- vizSettingsOverride.series_settings = {
- ...vizSettingsOverride.series_settings,
- [seriesKey]: {
- ...vizSettingsOverride.series_settings?.[seriesKey],
- title: name,
- },
- };
- }
-
const singleSeries: SingleSeries = {
card: createSeriesCard(cardId, name, display, {
...vizSettings,
- ...vizSettingsOverride,
...extraVizSettings,
}),
data: result.data,
};
let entrySeries: SingleSeries[];
- if (needsManualBreakoutSplit && colors instanceof Map) {
- const { series, activeBreakoutColorMap } = splitByBreakout(
- singleSeries,
- formulaEntities.length,
+ if (needsManualBreakoutSplit) {
+ const { series, activeBreakoutColorMap } = splitByBreakout({
+ entity,
+ series: singleSeries,
+ breakoutColorMap: colors,
isFirstSeries,
- colors,
- vizSettings,
- );
+ hasMultipleSeries: formulaEntities.length > 1,
+ display,
+ definitions,
+ });
entrySeries = series;
activeBreakoutColors[entityIndex] = activeBreakoutColorMap;
} else {
entrySeries = [singleSeries];
- if (hasBreakout && !needsManualBreakoutSplit && colors instanceof Map) {
+ if (hasBreakout) {
activeBreakoutColors[entityIndex] = filterBreakoutColorsByData(
colors,
result.data,
@@ -217,34 +175,6 @@ export function buildSeries({
return { series, cardIdToEntityIndex, activeBreakoutColors };
}
-function getVizSettings(
- dimensionMapping: Record<number, DimensionId | null>,
- display: MetricsViewerDisplayType,
- modifiedDefinitionsBySlotIndex: Map<number, MetricDefinition>,
- slotIndices: number[],
-): VisualizationSettings | null {
- const displayConfig = DISPLAY_TYPE_REGISTRY[display];
- for (const slotIndex of slotIndices) {
- const modifiedDefinition = modifiedDefinitionsBySlotIndex.get(slotIndex);
- if (!modifiedDefinition) {
- continue;
- }
- const dimensionId = dimensionMapping[slotIndex];
- if (displayConfig.dimensionRequired) {
- if (!dimensionId) {
- continue;
- }
- const dimension = findDimensionById(modifiedDefinition, dimensionId);
- if (!dimension) {
- continue;
- }
- return displayConfig.getSettings(modifiedDefinition, dimension);
- }
- return displayConfig.getSettings(modifiedDefinition);
- }
- return null;
-}
-
/**
* Compute unique display names for each formula entity, disambiguating
* duplicate names by appending " (N)" starting from the second occurrence.
@@ -401,9 +331,9 @@ export function getSingleColor(
}
// Result data columns layout: [dimension, breakout, metric].
-const DIMENSION_COLUMN_INDEX = 0;
-const BREAKOUT_COLUMN_INDEX = 1;
-const METRIC_COLUMN_INDEX = 2;
+export const DIMENSION_COLUMN_INDEX = 0;
+export const BREAKOUT_COLUMN_INDEX = 1;
+export const METRIC_COLUMN_INDEX = 2;
// When the breakout dimension is the same as the tab's dimension,
// the query avoids adding it twice, so we get [breakout, metric] instead of [dimension, breakout, metric].
@@ -444,13 +374,25 @@ function filterBreakoutColorsByData(
return filtered;
}
-export function splitByBreakout(
- series: SingleSeries,
- seriesCount: number,
- isFirstSeries: boolean,
- breakoutColorMap: BreakoutColorMap,
- vizSettings: VisualizationSettings,
-): {
+export interface SplitByBreakoutParams {
+ entity: MetricsViewerFormulaEntity;
+ series: SingleSeries;
+ breakoutColorMap: BreakoutColorMap;
+ isFirstSeries: boolean;
+ hasMultipleSeries: boolean;
+ display: MetricsViewerDisplayType;
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;
+}
+
+export function splitByBreakout({
+ entity,
+ series,
+ breakoutColorMap,
+ isFirstSeries,
+ hasMultipleSeries,
+ display,
+ definitions,
+}: SplitByBreakoutParams): {
series: SingleSeries[];
activeBreakoutColorMap: BreakoutColorMap | string | undefined;
} {
@@ -476,7 +418,7 @@ export function splitByBreakout(
if (rowsByBreakoutValue.size > MAX_SERIES) {
return {
series: [series],
- activeBreakoutColorMap: breakoutColorMap.values().next().value,
+ activeBreakoutColorMap: getSingleColor(breakoutColorMap),
};
}
}
@@ -486,6 +428,7 @@ export function splitByBreakout(
] as RowValues);
}
+ const displayConfig = DISPLAY_TYPE_REGISTRY[display];
const activeBreakoutColorMap: BreakoutColorMap = new Map();
const breakoutSeries = Array.from(breakoutColorMap)
@@ -497,14 +440,17 @@ export function splitByBreakout(
activeBreakoutColorMap.set(breakoutValue, color);
- const name = getBreakoutSeriesName(
+ const vizSettings = displayConfig.getSettings({
+ entity,
+ cols,
+ color,
breakoutValue,
- breakout.column,
- seriesCount > 1,
- card.name,
- );
+ isFirstSeries,
+ hasMultipleSeries,
+ cardName: card.name,
+ definitions,
+ });
- const seriesKey = isFirstSeries ? metricCol?.name : name;
isFirstSeries = false;
return {
@@ -512,15 +458,7 @@ export function splitByBreakout(
card: {
...card,
id: nextSyntheticCardId(),
- name,
- visualization_settings: {
- ...vizSettings,
- ...computeColorVizSettings({
- displayType: card.display,
- seriesKey,
- color,
- }),
- },
+ visualization_settings: vizSettings,
},
data: {
...data,
@@ -533,35 +471,6 @@ export function splitByBreakout(
return { series: breakoutSeries, activeBreakoutColorMap };
}
-export function buildCartesianVizSettings(
- data: DatasetData,
- hasBreakout: boolean,
- hasMultipleCards: boolean,
- cardName: string | null,
- breakoutColors?: BreakoutColorMap,
-): VisualizationSettings {
- const { cols } = data;
- const dimensions = [cols[DIMENSION_COLUMN_INDEX].name];
- if (hasBreakout) {
- dimensions.push(cols[BREAKOUT_COLUMN_INDEX].name);
- }
-
- return {
- "graph.x_axis.labels_enabled": false,
- "graph.y_axis.labels_enabled": false,
- "graph.dimensions": dimensions,
- "graph.metrics": [cols[cols.length - 1].name],
- ...(hasBreakout && breakoutColors
- ? computeBreakoutColorSettings(
- breakoutColors,
- cols[BREAKOUT_COLUMN_INDEX],
- hasMultipleCards,
- cardName,
- )
- : {}),
- };
-}
-
function createSeriesCard(
id: number,
name: string | null,
@@ -576,55 +485,6 @@ function createSeriesCard(
} as Card;
}
-export function computeBreakoutColorSettings(
- breakoutColors: BreakoutColorMap,
- breakoutCol: DatasetColumn,
- hasMultipleCards: boolean,
- cardName: string | null,
-): Pick<VisualizationSettings, "series_settings"> {
- const seriesSettings: Record<string, SeriesSettings> = {};
- for (const [formattedValue, color] of breakoutColors) {
- const seriesName = getBreakoutSeriesName(
- formattedValue,
- breakoutCol,
- hasMultipleCards,
- cardName,
- );
- seriesSettings[seriesName] = { color };
- }
- return { series_settings: seriesSettings };
-}
-
-interface ColorVizSettingsParams {
- displayType: VisualizationDisplay;
- seriesKey: string;
- color: string | undefined;
-}
-
-export function computeColorVizSettings({
- displayType,
- seriesKey,
- color,
-}: ColorVizSettingsParams): Partial<
- Pick<VisualizationSettings, "series_settings" | "map.colors">
-> {
- if (color == null) {
- return {};
- }
- if (displayType === "map") {
- return {
- "map.colors": getColorplethColorScale(color),
- };
- }
- return {
- series_settings: {
- [seriesKey]: {
- color,
- },
- },
- };
-}
-
function computeAvailableOptions(
entry: MetricsViewerDefinitionEntry,
modifiedDefinition: MetricDefinition | undefined,
diff --git a/frontend/src/metabase/metrics-viewer/utils/series.unit.spec.ts b/frontend/src/metabase/metrics-viewer/utils/series.unit.spec.ts
index 676fd9d046e..8c466a00cd4 100644
--- a/frontend/src/metabase/metrics-viewer/utils/series.unit.spec.ts
+++ b/frontend/src/metabase/metrics-viewer/utils/series.unit.spec.ts
@@ -1,10 +1,8 @@
import type {
MetricBreakoutValuesResponse,
RowValues,
- VisualizationSettings,
} from "metabase-types/api";
import { createMockColumn } from "metabase-types/api/mocks";
-import { createMockDatasetData } from "metabase-types/api/mocks/dataset";
import { ORDERS_ID } from "metabase-types/api/mocks/presets";
import { createMockSingleSeries } from "metabase-types/api/mocks/series";
@@ -26,10 +24,8 @@ import {
setupMeasureDefinition,
} from "./__tests__/test-helpers";
import {
- buildCartesianVizSettings,
+ type SplitByBreakoutParams,
buildDimensionItemsFromDefinitions,
- computeBreakoutColorSettings,
- computeColorVizSettings,
computeSourceBreakoutColors,
getSelectedMetricsInfo,
splitByBreakout,
@@ -54,7 +50,6 @@ const metricCol = createMockColumn({
});
const CARD_OPTS = { id: 1, name: "Revenue", display: "line" } as const;
-const EMPTY_VIZ: VisualizationSettings = {};
function makeColorMap(values: string[]): BreakoutColorMap {
const palette = [
@@ -68,6 +63,37 @@ function makeColorMap(values: string[]): BreakoutColorMap {
return new Map(values.map((v, i) => [v, palette[i % palette.length]]));
}
+const METRIC_ENTITY: MetricsViewerFormulaEntity = {
+ id: "metric:1" as MetricSourceId,
+ type: "metric",
+ definition: null,
+};
+
+type OptionalKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+
+function callSplitByBreakout({
+ entity = METRIC_ENTITY,
+ series,
+ breakoutColorMap,
+ isFirstSeries = true,
+ hasMultipleSeries = false,
+ display = "line",
+ definitions = {},
+}: OptionalKeys<
+ SplitByBreakoutParams,
+ "entity" | "isFirstSeries" | "hasMultipleSeries" | "display" | "definitions"
+>) {
+ return splitByBreakout({
+ entity,
+ series,
+ breakoutColorMap,
+ isFirstSeries,
+ hasMultipleSeries,
+ display,
+ definitions,
+ });
+}
+
describe("splitByBreakout", () => {
describe("3 columns: [dimension, breakout, metric]", () => {
it("splits rows by breakout value and strips breakout column", () => {
@@ -83,13 +109,10 @@ describe("splitByBreakout", () => {
},
});
- const { series: result } = splitByBreakout(
+ const { series: result } = callSplitByBreakout({
series,
- 1,
- true,
- makeColorMap(["Gadgets", "Widgets"]),
- EMPTY_VIZ,
- );
+ breakoutColorMap: makeColorMap(["Gadgets", "Widgets"]),
+ });
expect(result).toHaveLength(2);
@@ -98,37 +121,12 @@ describe("splitByBreakout", () => {
["2024-01", 10],
["2024-02", 30],
]);
- expect(result[0].card.name).toBe("Gadgets");
expect(result[1].data.cols).toEqual([dimensionCol, metricCol]);
expect(result[1].data.rows).toEqual([
["2024-01", 20],
["2024-02", 40],
]);
- expect(result[1].card.name).toBe("Widgets");
- });
-
- it("prefixes breakout value with card name when seriesCount > 1", () => {
- const series = createMockSingleSeries(CARD_OPTS, {
- data: {
- cols: [dimensionCol, breakoutCol, metricCol],
- rows: [
- ["2024-01", "Gadgets", 10],
- ["2024-01", "Widgets", 20],
- ],
- },
- });
-
- const { series: result } = splitByBreakout(
- series,
- 2,
- true,
- makeColorMap(["Gadgets", "Widgets"]),
- EMPTY_VIZ,
- );
-
- expect(result[0].card.name).toBe("Revenue: Gadgets");
- expect(result[1].card.name).toBe("Revenue: Widgets");
});
});
@@ -145,13 +143,10 @@ describe("splitByBreakout", () => {
},
});
- const { series: result } = splitByBreakout(
+ const { series: result } = callSplitByBreakout({
series,
- 1,
- true,
- makeColorMap(["Gadgets", "Widgets"]),
- EMPTY_VIZ,
- );
+ breakoutColorMap: makeColorMap(["Gadgets", "Widgets"]),
+ });
expect(result).toHaveLength(2);
@@ -160,11 +155,9 @@ describe("splitByBreakout", () => {
["Gadgets", 10],
["Gadgets", 30],
]);
- expect(result[0].card.name).toBe("Gadgets");
expect(result[1].data.cols).toEqual([breakoutCol, metricCol]);
expect(result[1].data.rows).toEqual([["Widgets", 20]]);
- expect(result[1].card.name).toBe("Widgets");
});
});
@@ -179,13 +172,10 @@ describe("splitByBreakout", () => {
},
});
- const { series: result } = splitByBreakout(
+ const { series: result } = callSplitByBreakout({
series,
- 1,
- true,
- makeColorMap(["Gadgets", "Widgets"]),
- EMPTY_VIZ,
- );
+ breakoutColorMap: makeColorMap(["Gadgets", "Widgets"]),
+ });
const ids = result.map((s) => s.card.id);
expect(new Set(ids).size).toBe(ids.length);
@@ -202,14 +192,10 @@ describe("splitByBreakout", () => {
},
});
- const colorMap = makeColorMap(["Gadgets", "Widgets"]);
- const { series: result } = splitByBreakout(
+ const { series: result } = callSplitByBreakout({
series,
- 1,
- true,
- colorMap,
- EMPTY_VIZ,
- );
+ breakoutColorMap: makeColorMap(["Gadgets", "Widgets"]),
+ });
expect(result[0].card.visualization_settings.series_settings).toBeDefined();
expect(result[1].card.visualization_settings.series_settings).toBeDefined();
@@ -222,13 +208,10 @@ describe("splitByBreakout", () => {
data: { cols: [dimensionCol, breakoutCol, metricCol], rows },
});
- const { series: result } = splitByBreakout(
+ const { series: result } = callSplitByBreakout({
series,
- 1,
- true,
- makeColorMap(values),
- EMPTY_VIZ,
- );
+ breakoutColorMap: makeColorMap(values),
+ });
expect(result).toHaveLength(1);
expect(result[0]).toBe(series);
@@ -245,13 +228,10 @@ describe("splitByBreakout", () => {
},
});
- const { series: result } = splitByBreakout(
+ const { series: result } = callSplitByBreakout({
series,
- 1,
- true,
- makeColorMap(["Gadgets", "Widgets"]),
- EMPTY_VIZ,
- );
+ breakoutColorMap: makeColorMap(["Gadgets", "Widgets"]),
+ });
expect(result[0].data.cols).toBe(result[1].data.cols);
});
@@ -273,16 +253,12 @@ describe("splitByBreakout", () => {
["Gizmos", "#A989C5"],
]);
- const { series: result, activeBreakoutColorMap } = splitByBreakout(
+ const { series: result, activeBreakoutColorMap } = callSplitByBreakout({
series,
- 1,
- true,
- colorMap,
- EMPTY_VIZ,
- );
+ breakoutColorMap: colorMap,
+ });
expect(result).toHaveLength(1);
- expect(result[0].card.name).toBe("Widgets");
expect(activeBreakoutColorMap).toEqual(new Map([["Widgets", "#88BF4D"]]));
});
@@ -297,23 +273,20 @@ describe("splitByBreakout", () => {
},
});
- const colorMap: BreakoutColorMap = new Map([
+ const breakoutColorMap: BreakoutColorMap = new Map([
["Gadgets", "#509EE3"],
["Widgets", "#88BF4D"],
]);
- const { series: result } = splitByBreakout(
+ const { series: result } = callSplitByBreakout({
series,
- 1,
- true,
- colorMap,
- EMPTY_VIZ,
- );
+ breakoutColorMap,
+ });
expect(result).toHaveLength(2);
// series order follows colorMap iteration order, not data order
- expect(result[0].card.name).toBe("Gadgets");
- expect(result[1].card.name).toBe("Widgets");
+ expect(result[0].data.rows[0][1]).toBe(10);
+ expect(result[1].data.rows[0][1]).toBe(20);
const gadgetColor =
result[0].card.visualization_settings.series_settings?.[
@@ -453,177 +426,6 @@ describe("computeSourceBreakoutColors", () => {
});
});
-describe("buildCartesianVizSettings", () => {
- describe("without breakout", () => {
- const data = createMockDatasetData({
- cols: [dimensionCol, metricCol],
- rows: [
- ["2024-01", 10],
- ["2024-02", 20],
- ],
- });
-
- it("sets single dimension and metric from data columns", () => {
- const result = buildCartesianVizSettings(data, false, false, "Revenue");
-
- expect(result["graph.dimensions"]).toEqual(["CREATED_AT"]);
- expect(result["graph.metrics"]).toEqual(["COUNT"]);
- });
-
- it("disables axis labels", () => {
- const result = buildCartesianVizSettings(data, false, false, "Revenue");
-
- expect(result["graph.x_axis.labels_enabled"]).toBe(false);
- expect(result["graph.y_axis.labels_enabled"]).toBe(false);
- });
- });
-
- describe("with breakout", () => {
- const data = createMockDatasetData({
- cols: [dimensionCol, breakoutCol, metricCol],
- rows: [
- ["2024-01", "Gadgets", 10],
- ["2024-01", "Widgets", 20],
- ["2024-02", "Gadgets", 30],
- ["2024-02", "Widgets", 40],
- ],
- });
-
- it("includes breakout column in graph.dimensions", () => {
- const result = buildCartesianVizSettings(data, true, false, "Revenue");
-
- expect(result["graph.dimensions"]).toEqual(["CREATED_AT", "CATEGORY"]);
- expect(result["graph.metrics"]).toEqual(["COUNT"]);
- });
-
- it("sets series_settings colors from breakout color map", () => {
- const result = buildCartesianVizSettings(
- data,
- true,
- false,
- "Revenue",
- makeColorMap(["Gadgets", "Widgets"]),
- );
-
- expect(result.series_settings).toEqual({
- Gadgets: { color: "#509EE3" },
- Widgets: { color: "#88BF4D" },
- });
- });
-
- it("prefixes color keys with card name when hasMultipleCards is true", () => {
- const result = buildCartesianVizSettings(
- data,
- true,
- true,
- "Revenue",
- makeColorMap(["Gadgets", "Widgets"]),
- );
-
- expect(result.series_settings).toEqual({
- "Revenue: Gadgets": { color: "#509EE3" },
- "Revenue: Widgets": { color: "#88BF4D" },
- });
- });
-
- it("preserves breakout colors regardless of data row order", () => {
- const reorderedData = createMockDatasetData({
- cols: [dimensionCol, breakoutCol, metricCol],
- rows: [
- ["2024-01", "Widgets", 20],
- ["2024-01", "Gadgets", 10],
- ],
- });
-
- const result = buildCartesianVizSettings(
- reorderedData,
- true,
- false,
- "Revenue",
- makeColorMap(["Gadgets", "Widgets"]),
- );
-
- expect(result.series_settings).toEqual({
- Gadgets: { color: "#509EE3" },
- Widgets: { color: "#88BF4D" },
- });
- });
- });
-});
-
-describe("computeBreakoutColorSettings", () => {
- it("maps breakout values to series_settings keyed by formatted name", () => {
- const colorMap = makeColorMap(["Gadgets", "Widgets"]);
- const result = computeBreakoutColorSettings(
- colorMap,
- breakoutCol,
- false,
- "Revenue",
- );
-
- expect(result).toEqual({
- series_settings: {
- Gadgets: { color: "#509EE3" },
- Widgets: { color: "#88BF4D" },
- },
- });
- });
-
- it("prefixes series names with card name when hasMultipleCards is true", () => {
- const colorMap = makeColorMap(["Gadgets", "Widgets"]);
- const result = computeBreakoutColorSettings(
- colorMap,
- breakoutCol,
- true,
- "Revenue",
- );
-
- expect(result).toEqual({
- series_settings: {
- "Revenue: Gadgets": { color: "#509EE3" },
- "Revenue: Widgets": { color: "#88BF4D" },
- },
- });
- });
-});
-
-describe("computeColorVizSettings", () => {
- it("returns empty object when color is undefined", () => {
- expect(
- computeColorVizSettings({
- displayType: "line",
- seriesKey: "COUNT",
- color: undefined,
- }),
- ).toEqual({});
- });
-
- it("returns series_settings for non-map display types", () => {
- expect(
- computeColorVizSettings({
- displayType: "line",
- seriesKey: "COUNT",
- color: "#509EE3",
- }),
- ).toEqual({
- series_settings: {
- COUNT: { color: "#509EE3" },
- },
- });
- });
-
- it("returns map.colors for map display type", () => {
- const result = computeColorVizSettings({
- displayType: "map",
- seriesKey: "COUNT",
- color: "#509EE3",
- });
-
- expect(result).toHaveProperty(["map.colors"]);
- expect(result).not.toHaveProperty("series_settings");
- });
-});
-
describe("getSelectedMetricsInfo", () => {
const metricMetadata = createMetricMetadata([REVENUE_METRIC]);
const metricDefinition = setupDefinition(metricMetadata, REVENUE_METRIC.id);
diff --git a/frontend/src/metabase/metrics-viewer/utils/tab-config.ts b/frontend/src/metabase/metrics-viewer/utils/tab-config.ts
index f84ca6a21c7..9ec30644c8f 100644
--- a/frontend/src/metabase/metrics-viewer/utils/tab-config.ts
+++ b/frontend/src/metabase/metrics-viewer/utils/tab-config.ts
@@ -3,17 +3,30 @@ import {
getGeoSubtype,
} from "metabase/metrics/common/utils/dimension-types";
import type { IconName } from "metabase/ui";
-import type { DimensionMetadata, MetricDefinition } from "metabase-lib/metric";
-import * as LibMetric from "metabase-lib/metric";
-import type { VisualizationSettings } from "metabase-types/api";
-
+import { getColorplethColorScale } from "metabase/visualizations/components/ChoroplethMap";
+import { getBreakoutSeriesName } from "metabase/visualizations/echarts/cartesian/model/series";
+import type { DimensionMetadata } from "metabase-lib/metric";
+import { isCountry, isState } from "metabase-lib/v1/types/utils/isa";
import type {
- MetricsViewerDisplayType,
- MetricsViewerTabType,
+ DatasetColumn,
+ SeriesSettings,
+ VisualizationSettings,
+} from "metabase-types/api";
+
+import {
+ type BreakoutColorMap,
+ type MetricSourceId,
+ type MetricsViewerDefinitionEntry,
+ type MetricsViewerDisplayType,
+ type MetricsViewerFormulaEntity,
+ type MetricsViewerTabType,
+ isExpressionEntry,
+ isMetricEntry,
} from "../types/viewer-state";
-import { getDefinitionColumnName } from "./definition-builder";
-import { getMapRegionForDimension } from "./geo-dimensions";
+import { getDefinitionName } from "./definition-builder";
+import { getEffectiveDefinitionEntry } from "./definition-entries";
+import { BREAKOUT_COLUMN_INDEX, DIMENSION_COLUMN_INDEX } from "./series";
// ── Types ──
@@ -22,28 +35,27 @@ export interface ChartTypeOption {
icon: IconName;
}
-type DisplayTypeDefinition =
- | {
- dimensionRequired: true;
- supportsMultipleSeries: boolean;
- supportsStacking: boolean;
- getSettings: (
- def: MetricDefinition,
- dimension: DimensionMetadata,
- ) => VisualizationSettings;
- combineSettings?: (
- settings: VisualizationSettings[],
- ) => VisualizationSettings;
- }
- | {
- dimensionRequired: false;
- supportsMultipleSeries: boolean;
- supportsStacking: boolean;
- getSettings: (def: MetricDefinition) => VisualizationSettings;
- combineSettings?: (
- settings: VisualizationSettings[],
- ) => VisualizationSettings;
- };
+interface GetSettingsParams {
+ entity: MetricsViewerFormulaEntity;
+ cols: DatasetColumn[];
+ color?: string;
+ breakoutValue?: string;
+ breakoutColors?: BreakoutColorMap;
+ isFirstSeries: boolean;
+ hasMultipleSeries: boolean;
+ cardName: string;
+ definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry>;
+}
+
+type DisplayTypeDefinition = {
+ dimensionRequired: boolean;
+ supportsMultipleSeries: boolean;
+ supportsStacking: boolean;
+ getSettings: (params: GetSettingsParams) => VisualizationSettings;
+ combineSettings?: (
+ settings: VisualizationSettings[],
+ ) => VisualizationSettings;
+};
interface BaseTabTypeDefinition {
type: MetricsViewerTabType;
@@ -159,75 +171,113 @@ export function getTabConfig(type: MetricsViewerTabType): TabTypeDefinition {
// ── Display type registry ──
-function getDimensionsAndMetrics(
- def: MetricDefinition,
- dimension: DimensionMetadata,
-): {
- dimensions: string[];
- metrics: string[];
-} {
- const dimensions: string[] = [];
- const name = LibMetric.displayInfo(def, dimension).name;
- if (name) {
- dimensions.push(name);
+function getCartesianSettings({
+ cols,
+ color,
+ breakoutColors,
+ isFirstSeries,
+ hasMultipleSeries,
+ cardName,
+}: GetSettingsParams): VisualizationSettings {
+ const dimensions = [cols[DIMENSION_COLUMN_INDEX].name];
+ if (breakoutColors) {
+ dimensions.push(cols[BREAKOUT_COLUMN_INDEX].name);
}
- const meta = LibMetric.sourceMetricOrMeasureMetadata(def);
- const metrics = meta ? [LibMetric.displayInfo(def, meta).displayName] : [];
-
- return { dimensions, metrics };
-}
+ const metricColName = cols[cols.length - 1].name;
-function getChartSettings(
- def: MetricDefinition,
- dimension: DimensionMetadata,
-): VisualizationSettings {
- const { dimensions, metrics } = getDimensionsAndMetrics(def, dimension);
+ const seriesSettings: Record<string, SeriesSettings> = {};
+ if (breakoutColors) {
+ for (const [formattedValue, color] of breakoutColors) {
+ const seriesName = getBreakoutSeriesName(
+ formattedValue,
+ cols[BREAKOUT_COLUMN_INDEX],
+ hasMultipleSeries,
+ cardName,
+ );
+ seriesSettings[seriesName] = { color };
+ }
+ } else if (color) {
+ const seriesKey = isFirstSeries ? metricColName : cardName;
+ seriesSettings[seriesKey] = {
+ color,
+ title: isFirstSeries ? cardName : undefined,
+ };
+ }
return {
"graph.x_axis.labels_enabled": false,
"graph.y_axis.labels_enabled": false,
"graph.dimensions": dimensions,
- "graph.metrics": metrics,
+ "graph.metrics": [metricColName],
+ series_settings: seriesSettings,
};
}
-function getScatterSettings(
- def: MetricDefinition,
- dimension: DimensionMetadata,
-): VisualizationSettings {
+function getScatterSettings(params: GetSettingsParams): VisualizationSettings {
return {
- ...getChartSettings(def, dimension),
+ ...getCartesianSettings(params),
"scatter.bubble": undefined,
};
}
-function getMapSettings(
- def: MetricDefinition,
- dimension: DimensionMetadata,
-): VisualizationSettings {
- const mapRegion = getMapRegionForDimension(dimension);
- if (!mapRegion) {
- return {};
+function getMapRegion(col: DatasetColumn): string | null {
+ if (isState(col)) {
+ return "us_states";
}
+ if (isCountry(col)) {
+ return "world_countries";
+ }
+ return null;
+}
- const { dimensions, metrics } = getDimensionsAndMetrics(def, dimension);
- if (dimensions.length === 0 || metrics.length === 0) {
+function getMapSettings({
+ cols,
+ color,
+}: GetSettingsParams): VisualizationSettings {
+ const dimensionCol = cols[DIMENSION_COLUMN_INDEX];
+ const mapRegion = getMapRegion(dimensionCol);
+ if (!mapRegion) {
return {};
}
return {
"map.type": "region",
"map.region": mapRegion,
- "map.dimension": dimensions[0],
- "map.metric": metrics[0],
+ "map.dimension": dimensionCol.name,
+ "map.metric": cols[cols.length - 1].name,
+ "map.colors": color ? getColorplethColorScale(color) : undefined,
};
}
-function getScalarSettings(def: MetricDefinition): VisualizationSettings {
- return {
- "scalar.field": getDefinitionColumnName(def) ?? undefined,
+function getScalarSettings({
+ entity,
+ cols,
+ breakoutValue,
+ definitions,
+}: Omit<GetSettingsParams, "dimension">): VisualizationSettings {
+ const settings: VisualizationSettings = {
+ "scalar.field": cols[cols.length - 1].name,
};
+ if (isExpressionEntry(entity)) {
+ settings["scalar.label"] = entity.name;
+ } else if (isMetricEntry(entity)) {
+ const definition = getEffectiveDefinitionEntry(entity, definitions);
+ if (!definition.definition) {
+ return settings;
+ }
+ const label = getDefinitionName(definition.definition);
+ if (!label) {
+ return settings;
+ }
+ settings["scalar.label"] = label;
+ if (breakoutValue) {
+ // scalars don't have a dimension, so the breakout column is the first column
+ const breakoutColumnName = cols[0].display_name;
+ settings["scalar.sublabel"] = `${breakoutColumnName}: ${breakoutValue}`;
+ }
+ }
+ return settings;
}
function combineColors(
@@ -253,21 +303,21 @@ export const DISPLAY_TYPE_REGISTRY: Record<
dimensionRequired: true,
supportsMultipleSeries: true,
supportsStacking: true,
- getSettings: getChartSettings,
+ getSettings: getCartesianSettings,
combineSettings: combineColors,
},
area: {
dimensionRequired: true,
supportsMultipleSeries: true,
supportsStacking: true,
- getSettings: getChartSettings,
+ getSettings: getCartesianSettings,
combineSettings: combineColors,
},
bar: {
dimensionRequired: true,
supportsMultipleSeries: true,
supportsStacking: true,
- getSettings: getChartSettings,
+ getSettings: getCartesianSettings,
combineSettings: combineColors,
},
scatter: {
@@ -280,13 +330,13 @@ export const DISPLAY_TYPE_REGISTRY: Record<
map: {
dimensionRequired: true,
supportsMultipleSeries: false,
- supportsStacking: true,
+ supportsStacking: false,
getSettings: getMapSettings,
},
scalar: {
dimensionRequired: false,
supportsMultipleSeries: false,
- supportsStacking: true,
+ supportsStacking: false,
getSettings: getScalarSettings,
},
};
diff --git a/frontend/src/metabase/metrics-viewer/utils/tab-config.unit.spec.ts b/frontend/src/metabase/metrics-viewer/utils/tab-config.unit.spec.ts
index 8130026a4df..1532e4a078e 100644
--- a/frontend/src/metabase/metrics-viewer/utils/tab-config.unit.spec.ts
+++ b/frontend/src/metabase/metrics-viewer/utils/tab-config.unit.spec.ts
@@ -1,4 +1,12 @@
import * as LibMetric from "metabase-lib/metric";
+import { createMockColumn } from "metabase-types/api/mocks";
+
+import type {
+ BreakoutColorMap,
+ MetricSourceId,
+ MetricsViewerDefinitionEntry,
+ MetricsViewerFormulaEntity,
+} from "../types/viewer-state";
import {
GEO_DIM_IDX,
@@ -7,7 +15,7 @@ import {
createMetricMetadata,
setupDefinition,
} from "./__tests__/test-helpers";
-import { getTabConfig } from "./tab-config";
+import { DISPLAY_TYPE_REGISTRY, getTabConfig } from "./tab-config";
const allMetadata = createMetricMetadata([REVENUE_METRIC, GEO_METRIC]);
const revenueDefinition = setupDefinition(allMetadata, REVENUE_METRIC.id);
@@ -22,6 +30,77 @@ const REV_DIM_IDX = {
BOOLEAN: 3,
};
+// ── Column fixtures ──
+
+const dimensionCol = createMockColumn({
+ name: "CREATED_AT",
+ display_name: "Created At",
+ base_type: "type/DateTime",
+});
+
+const breakoutCol = createMockColumn({
+ name: "CATEGORY",
+ display_name: "Category",
+ base_type: "type/Text",
+});
+
+const metricCol = createMockColumn({
+ name: "COUNT",
+ display_name: "Count",
+ base_type: "type/Integer",
+});
+
+const stateCol = createMockColumn({
+ name: "STATE",
+ display_name: "State",
+ base_type: "type/Text",
+ semantic_type: "type/State",
+});
+
+const countryCol = createMockColumn({
+ name: "COUNTRY",
+ display_name: "Country",
+ base_type: "type/Text",
+ semantic_type: "type/Country",
+});
+
+const cityCol = createMockColumn({
+ name: "CITY",
+ display_name: "City",
+ base_type: "type/Text",
+ semantic_type: "type/City",
+});
+
+const latitudeCol = createMockColumn({
+ name: "LATITUDE",
+ display_name: "Latitude",
+ base_type: "type/Float",
+ semantic_type: "type/Latitude",
+});
+
+// ── Shared helpers ──
+
+const METRIC_ENTITY: MetricsViewerFormulaEntity = {
+ id: "metric:1" as MetricSourceId,
+ type: "metric",
+ definition: null,
+};
+
+const DEFAULT_PARAMS = {
+ entity: METRIC_ENTITY,
+ isFirstSeries: true,
+ hasMultipleSeries: false,
+ cardName: "Revenue",
+ definitions: {},
+};
+
+function makeColorMap(values: string[]): BreakoutColorMap {
+ const palette = ["#509EE3", "#88BF4D", "#A989C5"];
+ return new Map(values.map((v, i) => [v, palette[i % palette.length]]));
+}
+
+// ── getTabConfig ──
+
describe("getTabConfig", () => {
it("returns config for time tab", () => {
expect(getTabConfig("time")).toEqual(
@@ -114,6 +193,8 @@ describe("getTabConfig", () => {
});
});
+// ── Dimension predicates ──
+
describe("TAB_TYPE_REGISTRY", () => {
describe("dimension predicates", () => {
const timeConfig = getTabConfig("time");
@@ -203,3 +284,256 @@ describe("TAB_TYPE_REGISTRY", () => {
});
});
});
+
+// ── Cartesian getSettings ──
+
+describe("DISPLAY_TYPE_REGISTRY", () => {
+ describe("line/area/bar getSettings", () => {
+ const getSettings = DISPLAY_TYPE_REGISTRY.line.getSettings;
+
+ it("sets graph.dimensions and graph.metrics from cols", () => {
+ const result = getSettings({
+ ...DEFAULT_PARAMS,
+ cols: [dimensionCol, metricCol],
+ });
+
+ expect(result["graph.dimensions"]).toEqual(["CREATED_AT"]);
+ expect(result["graph.metrics"]).toEqual(["COUNT"]);
+ });
+
+ it("disables axis labels", () => {
+ const result = getSettings({
+ ...DEFAULT_PARAMS,
+ cols: [dimensionCol, metricCol],
+ });
+
+ expect(result["graph.x_axis.labels_enabled"]).toBe(false);
+ expect(result["graph.y_axis.labels_enabled"]).toBe(false);
+ });
+
+ it("includes breakout column in dimensions when breakoutColors provided", () => {
+ const result = getSettings({
+ ...DEFAULT_PARAMS,
+ cols: [dimensionCol, breakoutCol, metricCol],
+ breakoutColors: makeColorMap(["Gadgets", "Widgets"]),
+ });
+
+ expect(result["graph.dimensions"]).toEqual(["CREATED_AT", "CATEGORY"]);
+ expect(result["graph.metrics"]).toEqual(["COUNT"]);
+ });
+
+ it("sets series_settings colors from breakoutColors", () => {
+ const result = getSettings({
+ ...DEFAULT_PARAMS,
+ cols: [dimensionCol, breakoutCol, metricCol],
+ breakoutColors: makeColorMap(["Gadgets", "Widgets"]),
+ });
+
+ expect(result.series_settings).toEqual({
+ Gadgets: { color: "#509EE3" },
+ Widgets: { color: "#88BF4D" },
+ });
+ });
+
+ it("prefixes series names with card name when hasMultipleSeries", () => {
+ const result = getSettings({
+ ...DEFAULT_PARAMS,
+ cols: [dimensionCol, breakoutCol, metricCol],
+ breakoutColors: makeColorMap(["Gadgets", "Widgets"]),
+ hasMultipleSeries: true,
+ });
+
+ expect(result.series_settings).toEqual({
+ "Revenue: Gadgets": { color: "#509EE3" },
+ "Revenue: Widgets": { color: "#88BF4D" },
+ });
+ });
+
+ it("sets series color from color prop when no breakout (first series)", () => {
+ const result = getSettings({
+ ...DEFAULT_PARAMS,
+ cols: [dimensionCol, metricCol],
+ color: "#509EE3",
+ isFirstSeries: true,
+ });
+
+ expect(result.series_settings).toEqual({
+ COUNT: expect.objectContaining({ color: "#509EE3" }),
+ });
+ });
+
+ it("uses cardName as series key when not first series", () => {
+ const result = getSettings({
+ ...DEFAULT_PARAMS,
+ cols: [dimensionCol, metricCol],
+ color: "#509EE3",
+ isFirstSeries: false,
+ });
+
+ expect(result.series_settings).toEqual({
+ Revenue: { color: "#509EE3" },
+ });
+ });
+ });
+
+ describe("scatter getSettings", () => {
+ it("includes scatter.bubble setting", () => {
+ const result = DISPLAY_TYPE_REGISTRY.scatter.getSettings({
+ ...DEFAULT_PARAMS,
+ cols: [dimensionCol, metricCol],
+ });
+
+ expect("scatter.bubble" in result).toBe(true);
+ expect(result["scatter.bubble"]).toBeUndefined();
+ expect(result["graph.dimensions"]).toEqual(["CREATED_AT"]);
+ });
+ });
+
+ // ── Map getSettings (migrated from geo-dimensions tests) ──
+
+ describe("map getSettings", () => {
+ const getSettings = DISPLAY_TYPE_REGISTRY.map.getSettings;
+
+ it("returns us_states region for state columns", () => {
+ const result = getSettings({
+ ...DEFAULT_PARAMS,
+ cols: [stateCol, metricCol],
+ });
+
+ expect(result["map.type"]).toBe("region");
+ expect(result["map.region"]).toBe("us_states");
+ expect(result["map.dimension"]).toBe("STATE");
+ expect(result["map.metric"]).toBe("COUNT");
+ });
+
+ it("returns world_countries region for country columns", () => {
+ const result = getSettings({
+ ...DEFAULT_PARAMS,
+ cols: [countryCol, metricCol],
+ });
+
+ expect(result["map.type"]).toBe("region");
+ expect(result["map.region"]).toBe("world_countries");
+ expect(result["map.dimension"]).toBe("COUNTRY");
+ expect(result["map.metric"]).toBe("COUNT");
+ });
+
+ it("returns empty settings for city columns (unsupported region)", () => {
+ const result = getSettings({
+ ...DEFAULT_PARAMS,
+ cols: [cityCol, metricCol],
+ });
+
+ expect(result).toEqual({});
+ });
+
+ it("returns empty settings for latitude columns", () => {
+ const result = getSettings({
+ ...DEFAULT_PARAMS,
+ cols: [latitudeCol, metricCol],
+ });
+
+ expect(result).toEqual({});
+ });
+
+ it("returns empty settings for datetime columns", () => {
+ const result = getSettings({
+ ...DEFAULT_PARAMS,
+ cols: [dimensionCol, metricCol],
+ });
+
+ expect(result).toEqual({});
+ });
+
+ it("applies map.colors color scale when color is provided", () => {
+ const result = getSettings({
+ ...DEFAULT_PARAMS,
+ cols: [stateCol, metricCol],
+ color: "#509EE3",
+ });
+
+ expect(result["map.colors"]).toBeDefined();
+ });
+ });
+
+ // ── Scalar getSettings ──
+
+ describe("scalar getSettings", () => {
+ const getSettings = DISPLAY_TYPE_REGISTRY.scalar.getSettings;
+
+ it("sets scalar.field from the last column name", () => {
+ const result = getSettings({
+ ...DEFAULT_PARAMS,
+ cols: [metricCol],
+ });
+
+ expect(result["scalar.field"]).toBe("COUNT");
+ });
+
+ it("sets scalar.label to entity name for expression entries", () => {
+ const expressionEntity: MetricsViewerFormulaEntity = {
+ id: "expr:1" as any,
+ type: "expression",
+ name: "Revenue Growth",
+ tokens: [],
+ };
+
+ const result = getSettings({
+ ...DEFAULT_PARAMS,
+ entity: expressionEntity,
+ cols: [metricCol],
+ });
+
+ expect(result["scalar.label"]).toBe("Revenue Growth");
+ expect(result["scalar.sublabel"]).toBeUndefined();
+ });
+
+ it("sets scalar.label from definition name for metric entries", () => {
+ const sourceId: MetricSourceId = `metric:${REVENUE_METRIC.id}`;
+ const metricEntity: MetricsViewerFormulaEntity = {
+ id: sourceId,
+ type: "metric",
+ definition: revenueDefinition,
+ };
+ const definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry> =
+ {
+ [sourceId]: { id: sourceId, definition: revenueDefinition },
+ };
+
+ const result = getSettings({
+ ...DEFAULT_PARAMS,
+ entity: metricEntity,
+ cols: [metricCol],
+ definitions,
+ });
+
+ expect(result["scalar.label"]).toBe("Revenue");
+ expect(result["scalar.sublabel"]).toBeUndefined();
+ });
+
+ it("adds sublabel when breakoutValue is provided", () => {
+ const sourceId: MetricSourceId = `metric:${REVENUE_METRIC.id}`;
+ const metricEntity: MetricsViewerFormulaEntity = {
+ id: sourceId,
+ type: "metric",
+ definition: revenueDefinition,
+ };
+ const definitions: Record<MetricSourceId, MetricsViewerDefinitionEntry> =
+ {
+ [sourceId]: { id: sourceId, definition: revenueDefinition },
+ };
+
+ const result = getSettings({
+ ...DEFAULT_PARAMS,
+ entity: metricEntity,
+ cols: [breakoutCol, metricCol],
+ breakoutValue: "Gadgets",
+ definitions,
+ });
+
+ expect(result["scalar.field"]).toBe("COUNT");
+ expect(result["scalar.label"]).toBe("Revenue");
+ expect(result["scalar.sublabel"]).toBe("Category: Gadgets");
+ });
+ });
+});
diff --git a/frontend/src/metabase/visualizations/components/ScalarValue/ScalarValue.styled.tsx b/frontend/src/metabase/visualizations/components/ScalarValue/ScalarValue.styled.tsx
index 2e8c2b87fe0..713bedaa276 100644
--- a/frontend/src/metabase/visualizations/components/ScalarValue/ScalarValue.styled.tsx
+++ b/frontend/src/metabase/visualizations/components/ScalarValue/ScalarValue.styled.tsx
@@ -23,7 +23,7 @@ export const ScalarValueWrapper = styled.h1<ScalarValueWrapperProps>`
display: inline;
font-size: ${(props) => props.fontSize};
line-height: ${(props) => props.lineHeight ?? "var(--mantine-line-height)"};
- cursor: pointer;
+ cursor: ${(props) => (props.disableHover ? "auto" : "pointer")};
color: ${({ color }) => color};
&:hover {
diff --git a/frontend/src/metabase/visualizations/visualizations/Scalar/Scalar.tsx b/frontend/src/metabase/visualizations/visualizations/Scalar/Scalar.tsx
index cb42ab550fe..737ca8c677f 100644
--- a/frontend/src/metabase/visualizations/visualizations/Scalar/Scalar.tsx
+++ b/frontend/src/metabase/visualizations/visualizations/Scalar/Scalar.tsx
@@ -3,7 +3,7 @@ import { t } from "ttag";
import _ from "underscore";
import DashboardS from "metabase/css/dashboard.module.css";
-import { Box, Tooltip } from "metabase/ui";
+import { Stack, Text, Tooltip } from "metabase/ui";
import {
ScalarValue,
ScalarWrapper,
@@ -87,11 +87,6 @@ export class Scalar extends Component<
},
]) => cols.length < 2,
}),
- // used by metrics viewer to set the color, overrides "scalar.segments"
- "scalar.color": {
- hidden: true,
- getDefault: () => undefined,
- },
"scalar.segments": {
get section() {
return t`Conditional colors`;
@@ -122,6 +117,16 @@ export class Scalar extends Component<
],
readDependencies: ["scalar.field"],
}),
+ // used by metrics viewer
+ "scalar.label": {
+ hidden: true,
+ getDefault: () => undefined,
+ },
+ // used by metrics viewer
+ "scalar.sublabel": {
+ hidden: true,
+ getDefault: () => undefined,
+ },
// LEGACY scalar settings, now handled by column level settings
"scalar.locale": {
// title: t`Separator style`,
@@ -210,9 +215,8 @@ export class Scalar extends Component<
segmentIsValid(segment, { allowOpenEnded: true }),
);
- const explicitColor = settings["scalar.color"];
- const color = explicitColor ?? getColor(value, segments);
- const tooltipContent = explicitColor ? null : getTooltipContent(segments);
+ const color = getColor(value, segments);
+ const tooltipContent = getTooltipContent(segments);
const { displayValue, fullScalarValue } = compactifyValue(
value,
@@ -220,7 +224,11 @@ export class Scalar extends Component<
formatOptions,
);
- const isClickable = onVisualizationClick != null;
+ const label = settings["scalar.label"];
+ const sublabel = settings["scalar.sublabel"];
+ const isMetricsViewer = label !== undefined;
+
+ const isClickable = onVisualizationClick != null && !isMetricsViewer;
const handleClick = () => {
if (this._scalar == null) {
@@ -259,13 +267,15 @@ export class Scalar extends Component<
py="xs"
disabled={!tooltipContent}
>
- <Box
+ <Stack
onClick={handleClick}
ref={(scalar) => (this._scalar = scalar)}
+ align="center"
+ gap={0}
>
<ScalarValue
color={color}
- disableHover={!!explicitColor}
+ disableHover={isMetricsViewer}
fontFamily={fontFamily}
gridSize={gridSize}
height={Math.max(height - PADDING * 2, 0)}
@@ -273,7 +283,23 @@ export class Scalar extends Component<
value={displayValue as string}
width={Math.max(width - PADDING, 0)}
/>
- </Box>
+ {label && (
+ <Text fz="14px" lh="16px" c="text-primary" mt="md" ta="center">
+ {label}
+ </Text>
+ )}
+ {sublabel && (
+ <Text
+ fz="12px"
+ lh="16px"
+ c="text-secondary"
+ mt="xs"
+ ta="center"
+ >
+ {sublabel}
+ </Text>
+ )}
+ </Stack>
</Tooltip>
</ScalarValueContainer>
</ScalarWrapper>