@dynatrace/strato-components 3.13.2 → 3.14.0

package/charts/xy-chart/utils/get-ticks-formatted-by-config.js

@@ -21,10 +21,24 @@ __export(get_ticks_formatted_by_config_exports, {
   getTicksFormattedByConfig: () => getTicksFormattedByConfig
 });
 module.exports = __toCommonJS(get_ticks_formatted_by_config_exports);
+var import_d3_scale = require("d3-scale");
 var import_adaptively_reduce_horizontal_ticks = require("../../core/utils/adaptively-reduce-horizontal-ticks.js");
 var import_formatter_by_ticks = require("../../core/utils/formatter-by-ticks.js");
 var import_guards = require("../types/guards.js");
 const MIN_TICK_COUNT = 2;
+function createLogLinearFallbackGetter(scale, formatter) {
+  const domain = scale.domain();
+  const fmt = formatter;
+  const getter = (count) => {
+    const vals = (0, import_d3_scale.scaleLinear)().domain(domain).ticks(count);
+    return {
+      ticks: vals,
+      formattedTicks: vals.map((v) => fmt ? fmt(v) : String(v)),
+      numericTicks: vals
+    };
+  };
+  return getter(1).ticks.length > 0 ? getter : void 0;
+}
 function getTicksFormattedByConfig(config, numTicks, scale, formatter, availableWidth) {
   const axisType = config?.type || "";
   if ((0, import_guards.isCategorical)(axisType)) {
@@ -56,11 +70,23 @@ function getTicksFormattedByConfig(config, numTicks, scale, formatter, available
   if (availableWidth === void 0 || scale === void 0) {
     return result;
   }
+  const visibleCount = result.formattedTicks.filter((t) => t !== "").length;
+  let linearGetTicksForCount;
   let initialResult = result;
-  if (result.formattedTicks.length < MIN_TICK_COUNT) {
+  if (visibleCount < MIN_TICK_COUNT) {
     const boosted = getTicksForCount(MIN_TICK_COUNT);
-    if (boosted.formattedTicks.length >= MIN_TICK_COUNT) {
+    const boostedVisible = boosted.formattedTicks.filter(
+      (t) => t !== ""
+    ).length;
+    if (boostedVisible >= MIN_TICK_COUNT) {
       initialResult = boosted;
+    } else if ((0, import_guards.isLogarithmic)(axisType)) {
+      linearGetTicksForCount = createLogLinearFallbackGetter(scale, formatter);
+      if (linearGetTicksForCount !== void 0) {
+        initialResult = linearGetTicksForCount(numTicks);
+      } else {
+        return result;
+      }
     } else {
       return result;
     }
@@ -68,12 +94,27 @@ function getTicksFormattedByConfig(config, numTicks, scale, formatter, available
   const continuousScale = scale;
   const rawDomain = typeof scale.domain === "function" ? scale.domain() : null;
   const domainBounds = rawDomain !== null && rawDomain.length >= 2 ? [+rawDomain[0], +rawDomain[rawDomain.length - 1]] : void 0;
-  const reduced = (0, import_adaptively_reduce_horizontal_ticks.adaptivelyReduceHorizontalTicks)(
-    (0, import_guards.isLogarithmic)(axisType) ? createLogMajorTickThinningBuilder(initialResult, MIN_TICK_COUNT) : createHalvingHintCandidateBuilder(
+  let buildCandidate;
+  if (linearGetTicksForCount !== void 0) {
+    buildCandidate = createHalvingHintCandidateBuilder(
+      initialResult,
+      linearGetTicksForCount,
+      MIN_TICK_COUNT
+    );
+  } else if ((0, import_guards.isLogarithmic)(axisType)) {
+    buildCandidate = createLogMajorTickThinningBuilder(
+      initialResult,
+      MIN_TICK_COUNT
+    );
+  } else {
+    buildCandidate = createHalvingHintCandidateBuilder(
       initialResult,
       getTicksForCount,
       MIN_TICK_COUNT
-    ),
+    );
+  }
+  const reduced = (0, import_adaptively_reduce_horizontal_ticks.adaptivelyReduceHorizontalTicks)(
+    buildCandidate,
     continuousScale,
     { domainBounds }
   );

package/charts/xy-chart/utils/is-pan-allowed.d.ts

@@ -0,0 +1,3 @@
+import type { AxisIdToScaleDomain, XYChartAxisInternal } from '../types/xy-chart-internals.js';
+export declare function isPanAllowed(axes: XYChartAxisInternal[], axisIdToScaleDomain: AxisIdToScaleDomain): boolean;
+//# sourceMappingURL=is-pan-allowed.d.ts.map

package/charts/xy-chart/utils/is-pan-allowed.js

@@ -0,0 +1,44 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var is_pan_allowed_exports = {};
+__export(is_pan_allowed_exports, {
+  isPanAllowed: () => isPanAllowed
+});
+module.exports = __toCommonJS(is_pan_allowed_exports);
+var import_axis_interactions = require("./axis-interactions.js");
+var import_get_initial_zoom_out = require("../../core/components/zoom/utils/get-initial-zoom-out.js");
+var import_safe_get = require("../../core/utils/safe-get.js");
+function getMinMax(axisIdToScaleDomain, axisId) {
+  const aux = (0, import_safe_get.safeGet)(axisIdToScaleDomain, axisId);
+  return [aux.min, aux.max];
+}
+function isPanAllowed(axes, axisIdToScaleDomain) {
+  const pannableAxes = axes.filter(import_axis_interactions.isPanEnabledFor);
+  if (pannableAxes.length === 0) {
+    return false;
+  }
+  return pannableAxes.some((axis) => {
+    if (axis.interactions.infinite) {
+      return true;
+    }
+    return (0, import_get_initial_zoom_out.getInitialZoomOut)(
+      axis.interactions.current,
+      axis.interactions.initial ?? getMinMax(axisIdToScaleDomain, axis.id)
+    );
+  });
+}

package/charts/xy-chart-adoption/categorical-bar/CategoricalBarToXY.js

@@ -73,9 +73,12 @@ const CategoricalBarToXY = (0, import_react.forwardRef)((props, forwardedRef) =>
   const [behaviorTrackingProps] = (0, import_useBehavioralTrackingProps.useBehavioralTrackingProps)(props);
   const {
     variant,
+    isMultiDimensional,
+    hasMixedValueShapes,
+    hasExplicitDataColors,
     data: xyData,
     seriesByDimension,
-    unitPerSeries
+    seriesMeta
   } = (0, import_transformer_data_to_xy.transformCategoricalBarDataToXY)(data, groupMode);
   const {
     colorRules: userColorRules,
@@ -90,14 +93,16 @@ const CategoricalBarToXY = (0, import_react.forwardRef)((props, forwardedRef) =>
     thresholds
   } = (0, import_iterate_slots.iterateSlots)(children);
   const resolvedTooltipVariant = tooltip?.variant === "single" ? "single" : "shared";
-  const resolvedColorRules = (0, import_resolve_categorical_color_support.resolveCategoricalColorSupport)(
-    data,
-    xyData,
+  const { colorRules: resolvedColorRules, seriesColors } = (0, import_resolve_categorical_color_support.resolveCategoricalColors)({
+    seriesMeta,
+    isMultiDimensional,
+    hasMixedValueShapes,
+    hasExplicitDataColors,
     colorPalette,
     colorPaletteMode,
     userColorRules,
     groupMode
-  );
+  });
   const resolvedCategoryAxis = (0, import_lodash_es.merge)(
     {},
     import_defaults.defaultConfig.categoryAxis,
@@ -131,7 +136,7 @@ const CategoricalBarToXY = (0, import_react.forwardRef)((props, forwardedRef) =>
   const numericalAxisGroups = /* @__PURE__ */ new Map();
   if (seriesByDimension !== null) {
     for (const [dim] of seriesByDimension) {
-      const unit = unitPerSeries.get(dim);
+      const unit = seriesMeta.get(dim)?.unit;
       const axisId = unit !== void 0 ? toNumericalAxisId(unit) : import_constants.Y_NUMERICAL_AXIS_ID;
       dimToAxisId.set(dim, axisId);
       if (!numericalAxisGroups.has(axisId)) {
@@ -140,7 +145,7 @@ const CategoricalBarToXY = (0, import_react.forwardRef)((props, forwardedRef) =>
     }
   } else {
     for (const dataPoint of xyData) {
-      const unit = unitPerSeries.get(String(dataPoint.seriesId));
+      const unit = seriesMeta.get(String(dataPoint.seriesId))?.unit;
       const axisId = unit !== void 0 ? toNumericalAxisId(unit) : import_constants.Y_NUMERICAL_AXIS_ID;
       let group = numericalAxisGroups.get(axisId);
       if (group === void 0) {
@@ -181,6 +186,7 @@ const CategoricalBarToXY = (0, import_react.forwardRef)((props, forwardedRef) =>
             {
               variant,
               data: dimData,
+              color: seriesColors?.get(dim),
               xAxisId: isHorizontal ? axisId : CATEGORY_AXIS_ID,
               yAxisId: isHorizontal ? CATEGORY_AXIS_ID : axisId,
               ...barSeriesAccessors,

package/charts/xy-chart-adoption/categorical-bar/resolve-categorical-color-support.d.ts

@@ -1,7 +1,45 @@
-import type { CategoricalBarChartData, GroupMode } from '../../categorical-bar/types/categorical-bar-chart.js';
+import type { CategoricalSeriesMeta } from './transformer-data-to-xy.js';
+import type { GroupMode } from '../../categorical-bar/types/categorical-bar-chart.js';
 import type { ColorPalette, ColorPaletteMode, CustomColorPalette } from '../../core/types/color-palette.js';
 import type { ColorRuleProps } from '../../core/types/color-rule.js';
-import type { XYChartData } from '../../xy-chart/types/xy-chart.js';
+interface ResolveCategoricalColorsOptions {
+    /** Series metadata collected by the data transformer. */
+    seriesMeta: Map<string, CategoricalSeriesMeta>;
+    isMultiDimensional: boolean;
+    hasMixedValueShapes: boolean;
+    hasExplicitDataColors: boolean;
+    colorPalette?: ColorPalette | CustomColorPalette;
+    colorPaletteMode?: ColorPaletteMode;
+    userColorRules: ColorRuleProps[];
+    groupMode?: GroupMode;
+}
+export interface ResolveCategoricalColorsResult {
+    /** Rules to forward to XYChart, consumer rules last. */
+    colorRules: ColorRuleProps[];
+    /**
+     * Color per series id, to apply directly to the matching BarSeries. Undefined
+     * whenever the colors have to travel as rules instead.
+     */
+    seriesColors: Map<string, string> | undefined;
+}
+/**
+ * Single entry point for the adoption layer's coloring.
+ *
+ * Mixed data needs palette positions the legacy chart assigns per entry, which
+ * XYChart's series order cannot reproduce, so those positions are resolved here
+ * and then travel one of two ways:
+ *
+ * 1. `seriesColors` — applied straight to the matching BarSeries. Cheaper than
+ *    evaluating a rule per datapoint, and the default.
+ * 2. `colorRules` — one rule per series id. Needed as soon as the consumer
+ *    supplies ColorRules of their own, because `useColorRule` skips any series
+ *    carrying an explicit `color`: applying one would silently disable the
+ *    consumer's rules for that series.
+ *
+ * The deprecated per-entry `color` follows the same split — it rides along in
+ * `seriesColors` where those exist, and becomes a rule otherwise.
+ */
+export declare function resolveCategoricalColors({ seriesMeta, isMultiDimensional, hasMixedValueShapes, hasExplicitDataColors, colorPalette, colorPaletteMode, userColorRules, groupMode, }: ResolveCategoricalColorsOptions): ResolveCategoricalColorsResult;
 /**
  * Resolves colorPalette + colorPaletteMode into XYChart-compatible ColorRuleProps[].
  *
@@ -20,10 +58,14 @@ import type { XYChartData } from '../../xy-chart/types/xy-chart.js';
  * - Rules with `colorPalette` are expanded into one per-seriesId `equals` rule
  *   with a resolved color, incrementing the palette index per matching series.
  *   This ensures multi-dim charts assign distinct palette colors to each matching
- *   series rather than all resolving to index 0 (AC6).
+ *   series rather than all resolving to index 0.
  *
- * Synthetic single-color rules come first; user rules come last so they take
+ * Synthetic single-color rules come first; user rules come next so they take
  * priority (useColorRule reverses the rule list before applying).
+ *
+ * `mixedSeriesColors` carries the explicitly resolved colors for mixed data.
+ * See {@link resolveCategoricalColors} for when they arrive as rules.
  */
-export declare function resolveCategoricalColorSupport(data: CategoricalBarChartData[], xyData: XYChartData[], colorPalette: (ColorPalette | CustomColorPalette) | undefined, colorPaletteMode: ColorPaletteMode | undefined, userColorRules: ColorRuleProps[], groupMode?: GroupMode): ColorRuleProps[];
+export declare function resolveCategoricalColorSupport(isMultiDimensional: boolean, uniqueSeriesIds: string[], colorPalette: (ColorPalette | CustomColorPalette) | undefined, colorPaletteMode: ColorPaletteMode | undefined, userColorRules: ColorRuleProps[], groupMode?: GroupMode, mixedSeriesColors?: Map<string, string>): ColorRuleProps[];
+export {};
 //# sourceMappingURL=resolve-categorical-color-support.d.ts.map

package/charts/xy-chart-adoption/categorical-bar/resolve-categorical-color-support.js

@@ -17,20 +17,82 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var resolve_categorical_color_support_exports = {};
 __export(resolve_categorical_color_support_exports, {
-  resolveCategoricalColorSupport: () => resolveCategoricalColorSupport
+  resolveCategoricalColorSupport: () => resolveCategoricalColorSupport,
+  resolveCategoricalColors: () => resolveCategoricalColors
 });
 module.exports = __toCommonJS(resolve_categorical_color_support_exports);
-var import_transformer_data_to_xy = require("./transformer-data-to-xy.js");
+var import_resolve_mixed_series_colors = require("./resolve-mixed-series-colors.js");
 var import_get_color_palette = require("../../core/utils/get-color-palette.js");
 var import_validators = require("../../core/utils/validators.js");
 const CATEGORICAL_DEFAULT_VALUE_ACCESSOR = "seriesName";
-function resolveCategoricalColorSupport(data, xyData, colorPalette = "categorical", colorPaletteMode = "single-color", userColorRules, groupMode) {
-  const effectiveColorPaletteMode = groupMode !== void 0 || (0, import_transformer_data_to_xy.isMultiDimensional)(data) ? "multi-color" : colorPaletteMode;
+function resolveCategoricalColors({
+  seriesMeta,
+  isMultiDimensional,
+  hasMixedValueShapes,
+  hasExplicitDataColors,
+  colorPalette,
+  colorPaletteMode,
+  userColorRules,
+  groupMode
+}) {
+  const mixedSeriesColors = hasMixedValueShapes ? (0, import_resolve_mixed_series_colors.resolveMixedSeriesColors)(
+    seriesMeta,
+    colorPalette,
+    colorPaletteMode,
+    groupMode
+  ) : void 0;
+  const mustTravelAsRules = userColorRules.length > 0;
+  const seriesColors = mustTravelAsRules ? void 0 : mixedSeriesColors;
+  const ruleSeriesColors = mustTravelAsRules ? omitDataColorSeries(mixedSeriesColors, seriesMeta) : void 0;
+  const explicitDataColorRules = hasExplicitDataColors && seriesColors === void 0 ? buildExplicitDataColorRules(seriesMeta) : [];
+  return {
+    seriesColors,
+    colorRules: [
+      ...resolveCategoricalColorSupport(
+        isMultiDimensional,
+        [...seriesMeta.keys()],
+        colorPalette,
+        colorPaletteMode,
+        userColorRules,
+        groupMode,
+        ruleSeriesColors
+      ),
+      ...explicitDataColorRules
+    ]
+  };
+}
+function omitDataColorSeries(mixedSeriesColors, seriesMeta) {
+  if (!mixedSeriesColors) {
+    return mixedSeriesColors;
+  }
+  const filtered = new Map(mixedSeriesColors);
+  for (const [seriesId, { dataColor }] of seriesMeta) {
+    if (dataColor !== void 0) {
+      filtered.delete(seriesId);
+    }
+  }
+  return filtered;
+}
+function buildExplicitDataColorRules(seriesMeta) {
+  const rules = [];
+  for (const [seriesId, { dataColor }] of seriesMeta) {
+    if (dataColor !== void 0) {
+      rules.push({
+        comparator: "equals",
+        matchValue: seriesId,
+        valueAccessor: CATEGORICAL_DEFAULT_VALUE_ACCESSOR,
+        color: dataColor
+      });
+    }
+  }
+  return rules;
+}
+function resolveCategoricalColorSupport(isMultiDimensional, uniqueSeriesIds, colorPalette = "categorical", colorPaletteMode = "single-color", userColorRules, groupMode, mixedSeriesColors) {
+  const effectiveColorPaletteMode = groupMode !== void 0 || isMultiDimensional ? "multi-color" : colorPaletteMode;
   if (effectiveColorPaletteMode !== "single-color" && userColorRules.length === 0) {
     return [];
   }
-  const uniqueSeriesIds = [...new Set(xyData.map((d) => String(d.seriesId)))];
-  const syntheticRules = buildSingleColorRules(
+  const syntheticRules = mixedSeriesColors ? buildSeriesColorRules(uniqueSeriesIds, mixedSeriesColors) : buildSingleColorRules(
     uniqueSeriesIds,
     colorPalette,
     effectiveColorPaletteMode
@@ -60,6 +122,21 @@ function buildSingleColorRules(uniqueSeriesIds, colorPalette, colorPaletteMode)
     color: firstColor
   }));
 }
+function buildSeriesColorRules(uniqueSeriesIds, colorBySeriesId) {
+  const rules = [];
+  for (const seriesId of uniqueSeriesIds) {
+    const color = colorBySeriesId.get(seriesId);
+    if (color !== void 0) {
+      rules.push({
+        comparator: "equals",
+        matchValue: seriesId,
+        valueAccessor: CATEGORICAL_DEFAULT_VALUE_ACCESSOR,
+        color
+      });
+    }
+  }
+  return rules;
+}
 function resolveUserColorRules(uniqueSeriesIds, colorRules) {
   const isValid = (0, import_validators.buildValidator)(import_validators.VALUE_MATCHERS);
   const resolved = [];

package/charts/xy-chart-adoption/categorical-bar/resolve-mixed-series-colors.d.ts

@@ -0,0 +1,20 @@
+import type { CategoricalSeriesMeta } from './transformer-data-to-xy.js';
+import type { GroupMode } from '../../categorical-bar/types/categorical-bar-chart.js';
+import type { ColorPalette, ColorPaletteMode, CustomColorPalette } from '../../core/types/color-palette.js';
+/**
+ * Resolves the palette color of every series id for data that mixes scalar and
+ * object `value` entries.
+ *
+ * XYChart derives a series' palette position from the order in which series ids
+ * first appear, while the legacy chart derives it per entry: a dimension key
+ * takes its position inside its own `value` object, and a scalar entry takes its
+ * position in the data array (or 0 when a single color is applied). For mixed
+ * data the two schemes drift apart — each scalar entry consumes a position the
+ * legacy chart never assigns — so the positions the data transformer collected
+ * are resolved explicitly here to keep both renderings in sync.
+ *
+ * Series whose palette cannot be resolved are omitted so that XYChart falls back
+ * to its own coloring.
+ */
+export declare function resolveMixedSeriesColors(seriesMeta: Map<string, CategoricalSeriesMeta>, colorPalette?: ColorPalette | CustomColorPalette, colorPaletteMode?: ColorPaletteMode, groupMode?: GroupMode): Map<string, string>;
+//# sourceMappingURL=resolve-mixed-series-colors.d.ts.map

package/charts/xy-chart-adoption/categorical-bar/resolve-mixed-series-colors.js

@@ -0,0 +1,57 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var resolve_mixed_series_colors_exports = {};
+__export(resolve_mixed_series_colors_exports, {
+  resolveMixedSeriesColors: () => resolveMixedSeriesColors
+});
+module.exports = __toCommonJS(resolve_mixed_series_colors_exports);
+var import_layout = require("../../categorical-bar/utils/layout.js");
+var import_get_color_palette = require("../../core/utils/get-color-palette.js");
+function resolveMixedSeriesColors(seriesMeta, colorPalette = "categorical", colorPaletteMode = "single-color", groupMode) {
+  const colorBySeriesId = /* @__PURE__ */ new Map();
+  const scalarUsesPalettePosition = colorPaletteMode === "multi-color" || groupMode !== void 0 && (0, import_layout.isGrouped)(groupMode);
+  for (const [seriesId, meta] of seriesMeta) {
+    if (meta.dataColor !== void 0) {
+      colorBySeriesId.set(seriesId, meta.dataColor);
+      continue;
+    }
+    const color = resolveColor(
+      seriesId,
+      meta.isScalar && !scalarUsesPalettePosition ? 0 : meta.palettePosition,
+      colorPalette,
+      // Only the legacy single-dimension path forwards the palette mode.
+      meta.isScalar ? colorPaletteMode : void 0
+    );
+    if (color !== void 0) {
+      colorBySeriesId.set(seriesId, color);
+    }
+  }
+  return colorBySeriesId;
+}
+function resolveColor(seriesId, paletteIndex, colorPalette, colorPaletteMode) {
+  try {
+    return (0, import_get_color_palette.getColorPalette)(
+      seriesId,
+      paletteIndex,
+      colorPalette,
+      colorPaletteMode
+    ).Default;
+  } catch {
+    return void 0;
+  }
+}

package/charts/xy-chart-adoption/categorical-bar/transformer-data-to-xy.d.ts

@@ -1,23 +1,54 @@
 import type { GroupMode, CategoricalBarChartData } from '../../categorical-bar/types/categorical-bar-chart.js';
 import type { ChartUnit } from '../../core/types/chart-unit.js';
 import type { XYChartData } from '../../xy-chart/types/xy-chart.js';
+/**
+ * Everything the downstream layers need to know about a series, collected while
+ * the data is walked. The first occurrence of a series id wins, mirroring the
+ * legacy chart's color cache.
+ */
+export interface CategoricalSeriesMeta {
+    unit: ChartUnit | undefined;
+    /**
+     * Palette position the legacy chart assigns: the index inside its own `value`
+     * object for a dimension, the index in the data array for a scalar entry.
+     */
+    palettePosition: number;
+    /** True when the series comes from a scalar `value` — one bar per category. */
+    isScalar: boolean;
+    dataColor?: string;
+}
 export interface TransformCategoricalBarDataResult {
     variant: 'single' | 'stack' | 'group';
-    /** Flat array of all data rows — used for color rule resolution. */
+    /**
+     * True when any entry has an object `value` (multi-dimension data). The
+     * legacy chart uses this signal to force multi-color palette rendering
+     * regardless of `colorPaletteMode`.
+     */
+    isMultiDimensional: boolean;
+    /**
+     * True when the data mixes scalar and object `value` entries. Series order
+     * alone does not reproduce the legacy chart's palette positions for such
+     * data — see `resolveMixedSeriesColors`.
+     */
+    hasMixedValueShapes: boolean;
+    /**
+     * True when any scalar-value entry carries the deprecated per-entry `color`.
+     * Gates the extra work that supporting it needs — see
+     * `buildExplicitDataColorRules`.
+     */
+    hasExplicitDataColors: boolean;
+    /** Flat array of all data rows. */
     data: XYChartData[];
     /**
      * Data grouped by dimension key. Non-null only for multi-dimension data;
      * null for single-dimension data where a single BarSeries covers everything.
      */
     seriesByDimension: Map<string, XYChartData[]> | null;
-    /** Unit per series ID (dimension key for multi-dim, category for scalar). */
-    unitPerSeries: Map<string, ChartUnit | undefined>;
+    /**
+     * Metadata per series id — the dimension key for multi-dimension data, the
+     * category for scalar data — in the order the series first appear.
+     */
+    seriesMeta: Map<string, CategoricalSeriesMeta>;
 }
-/**
- * True when any entry in the data has an object `value`, meaning the chart has
- * more than one dimension per category. The legacy chart uses this signal to
- * force multi-color palette rendering regardless of `colorPaletteMode`.
- */
-export declare function isMultiDimensional(data: CategoricalBarChartData[]): boolean;
 export declare function transformCategoricalBarDataToXY(data: CategoricalBarChartData[], groupMode?: GroupMode): TransformCategoricalBarDataResult;
 //# sourceMappingURL=transformer-data-to-xy.d.ts.map

package/charts/xy-chart-adoption/categorical-bar/transformer-data-to-xy.js

@@ -17,57 +17,70 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var transformer_data_to_xy_exports = {};
 __export(transformer_data_to_xy_exports, {
-  isMultiDimensional: () => isMultiDimensional,
   transformCategoricalBarDataToXY: () => transformCategoricalBarDataToXY
 });
 module.exports = __toCommonJS(transformer_data_to_xy_exports);
-function isMultiDimensional(data) {
-  for (const entry of data) {
-    if (typeof entry.value === "object" && entry.value !== null) {
-      return true;
-    }
-  }
-  return false;
-}
 function transformCategoricalBarDataToXY(data, groupMode) {
-  const unitPerSeries = /* @__PURE__ */ new Map();
+  const seriesMeta = /* @__PURE__ */ new Map();
   const flat = [];
-  const isMultiDim = isMultiDimensional(data);
-  for (const entry of data) {
+  let isMultiDim = false;
+  let hasScalarEntry = false;
+  let hasExplicitDataColors = false;
+  for (const [entryIndex, entry] of data.entries()) {
     const { category, value, unit: entryUnit, ...extraProps } = entry;
     const chartUnit = entryUnit;
     if (typeof value === "object" && value !== null) {
-      for (const [dimensionKey, dimensionValue] of Object.entries(value)) {
-        if (!unitPerSeries.has(dimensionKey)) {
-          unitPerSeries.set(dimensionKey, chartUnit);
+      isMultiDim = true;
+      Object.entries(value).forEach(
+        ([dimensionKey, dimensionValue], dimensionIndex) => {
+          if (!seriesMeta.has(dimensionKey)) {
+            seriesMeta.set(dimensionKey, {
+              unit: chartUnit,
+              palettePosition: dimensionIndex,
+              isScalar: false
+            });
+          }
+          flat.push({
+            ...extraProps,
+            category,
+            value: dimensionValue,
+            seriesId: dimensionKey,
+            seriesName: dimensionKey
+          });
         }
-        flat.push({
-          ...extraProps,
-          category,
-          value: dimensionValue,
-          seriesId: dimensionKey,
-          seriesName: dimensionKey
-        });
-      }
-    } else {
-      if (!unitPerSeries.has(category)) {
-        unitPerSeries.set(category, chartUnit);
-      }
-      flat.push({
-        ...extraProps,
-        category,
-        value,
-        seriesId: category,
-        seriesName: category
+      );
+      continue;
+    }
+    hasScalarEntry = true;
+    if (entry.color !== void 0) {
+      hasExplicitDataColors = true;
+    }
+    if (!seriesMeta.has(category)) {
+      seriesMeta.set(category, {
+        unit: chartUnit,
+        palettePosition: entryIndex,
+        isScalar: true,
+        // DEPRECATION: [APPDEV-18274] BREAKING-CHANGE: Remove deprecated CategoricalBarChartData.color prop.
+        dataColor: entry.color
       });
     }
+    flat.push({
+      ...extraProps,
+      category,
+      value,
+      seriesId: category,
+      seriesName: category
+    });
   }
   if (!isMultiDim) {
     return {
       variant: "single",
+      isMultiDimensional: false,
+      hasMixedValueShapes: false,
+      hasExplicitDataColors,
       data: flat,
       seriesByDimension: null,
-      unitPerSeries
+      seriesMeta
     };
   }
   const variant = groupMode === "grouped" ? "group" : "stack";
@@ -81,5 +94,13 @@ function transformCategoricalBarDataToXY(data, groupMode) {
       seriesByDimension.set(dim, [row]);
     }
   }
-  return { variant, data: flat, seriesByDimension, unitPerSeries };
+  return {
+    variant,
+    isMultiDimensional: true,
+    hasMixedValueShapes: hasScalarEntry,
+    hasExplicitDataColors,
+    data: flat,
+    seriesByDimension,
+    seriesMeta
+  };
 }

package/charts/xy-chart-adoption/timeseries/utils/chart-configuration.d.ts

@@ -26,7 +26,7 @@ export declare function getToolbar(contextToolbar: TimeseriesChartToolbarConfig
 export declare function getGapPolicyConfiguration(contextGapPolicy?: TimeGapPolicy, propsGapPolicy?: TimeGapPolicy): TimeGapPolicy;
 export declare function getPointsDisplayConfiguration(contextPointsDisplay?: PointsDisplay, propsPointsDisplay?: PointsDisplay): "always" | "auto" | "never";
 export declare function getValueRepresentationConfiguration(contextValueRepresentation?: ValueRepresentation, propsValueRepresentation?: ValueRepresentation): "absolute" | "relative";
-export declare function getColorPaletteConfiguration(contextColorPalette?: ColorPalette | CustomColorPalette, propsColorPalette?: ColorPalette | CustomColorPalette): "apdex" | "apdex-inverted" | "blue" | "blue-inverted" | "blue-moss" | "blue-moss-inverted" | "blue-steel" | "blue-steel-inverted" | "blue-turquoise" | "blue-turquoise-inverted" | "brown" | "brown-inverted" | "categorical" | "categorical-inverted" | "fireplace" | "fireplace-inverted" | "grey" | "grey-inverted" | "log-level" | "log-level-inverted" | "log-status" | "log-status-inverted" | "magenta" | "magenta-inverted" | "moss" | "moss-inverted" | "orange" | "orange-blue" | "orange-blue-inverted" | "orange-inverted" | "orange-petrol" | "orange-petrol-inverted" | "pear" | "pear-inverted" | "petrol" | "petrol-inverted" | "pink" | "pink-green" | "pink-green-inverted" | "pink-inverted" | "pink-purple" | "pink-purple-inverted" | "purple" | "purple-inverted" | "purple-rain" | "purple-rain-inverted" | "purple-yellow" | "purple-yellow-inverted" | "rainbow" | "rainbow-inverted" | "red" | "red-blue" | "red-blue-inverted" | "red-green" | "red-green-inverted" | "red-inverted" | "red-purple" | "red-purple-inverted" | "security-risk-level" | "security-risk-level-inverted" | "status" | "status-inverted" | "swamps" | "swamps-inverted" | "threshold" | "threshold-inverted" | "turquoise" | "turquoise-inverted" | "vulnerability-status" | "vulnerability-status-inverted" | "yellow" | "yellow-inverted" | CustomColorPalette;
+export declare function getColorPaletteConfiguration(contextColorPalette?: ColorPalette | CustomColorPalette, propsColorPalette?: ColorPalette | CustomColorPalette): "apdex" | "apdex-inverted" | "aurora" | "aurora-inverted" | "blue" | "blue-inverted" | "blue-moss" | "blue-moss-inverted" | "blue-steel" | "blue-steel-inverted" | "blue-turquoise" | "blue-turquoise-inverted" | "brown" | "brown-inverted" | "categorical" | "categorical-inverted" | "categorical-vivid" | "categorical-vivid-inverted" | "fireplace" | "fireplace-inverted" | "grey" | "grey-inverted" | "log-level" | "log-level-inverted" | "log-status" | "log-status-inverted" | "magenta" | "magenta-inverted" | "moss" | "moss-inverted" | "neon" | "neon-inverted" | "orange" | "orange-blue" | "orange-blue-inverted" | "orange-inverted" | "orange-petrol" | "orange-petrol-inverted" | "overdrive" | "overdrive-inverted" | "pear" | "pear-inverted" | "petrol" | "petrol-inverted" | "pink" | "pink-green" | "pink-green-inverted" | "pink-inverted" | "pink-purple" | "pink-purple-inverted" | "purple" | "purple-inverted" | "purple-rain" | "purple-rain-inverted" | "purple-yellow" | "purple-yellow-inverted" | "rainbow" | "rainbow-inverted" | "red" | "red-blue" | "red-blue-inverted" | "red-green" | "red-green-inverted" | "red-inverted" | "red-purple" | "red-purple-inverted" | "security-risk-level" | "security-risk-level-inverted" | "status" | "status-inverted" | "swamps" | "swamps-inverted" | "threshold" | "threshold-inverted" | "tide" | "tide-inverted" | "turquoise" | "turquoise-inverted" | "vulnerability-status" | "vulnerability-status-inverted" | "yellow" | "yellow-inverted" | CustomColorPalette;
 export declare function getSeriesCurveConfiguration(contextConfig?: SeriesCurve, propsConfig?: SeriesCurve): SeriesCurve;
 export declare function getInfiniteZoomConfiguration(contextConfig?: boolean, propsConfig?: boolean): boolean;
 export declare function getInitialZoomConfiguration(contextConfig?: TimeseriesZoomDomain, propsConfig?: TimeseriesZoomDomain): TimeseriesZoomDomain | undefined;