@primeui/chart-core 0.0.1-alpha.1

package/dist/chunk-SDBPQ5CF.mjs

@@ -0,0 +1,624 @@
+import { buildHeatmapFingerprint } from './chunk-SANZPAJ4.mjs';
+import { renderCanvasHeatmapContent } from './chunk-TQ6S34QZ.mjs';
+import { calculateHeatmapLayout, hitTestHeatmap } from './chunk-3Z62EUJN.mjs';
+import { triggerCompositorRepaint } from './chunk-Q6PPVIHU.mjs';
+import { renderAxisCanvas, calculateAxisLayout, calculateAxisSpace } from './chunk-ZTL2FQEW.mjs';
+import { AnimatedScene, resolveAnimatedProps, HEATMAP_ANIMATABLE_PROPS } from './chunk-VN7CKCSE.mjs';
+import { reconcileSvgChildren } from './chunk-KP2TWD4Z.mjs';
+import { parseAnimationConfig } from './chunk-3WEMHXZI.mjs';
+import { getResponsiveTier, getAdaptiveDefaults, getAdaptiveTickCount } from './chunk-YBJ56XJS.mjs';
+import { raf, cancelRaf } from './chunk-EDAKJLNA.mjs';
+import { buildAccessibilityRenderContext, generateSeriesDescription } from './chunk-OGJ6IIBW.mjs';
+import { collectItems } from './chunk-FFMT6OCO.mjs';
+import { DEFAULT_HOVER_BRIGHTNESS } from './chunk-NKUYIWAP.mjs';
+import { FIELD_DEFAULTS, batchResolveRequired } from './chunk-O2X6FF45.mjs';
+import { materializeSvgNode, setAttr } from './chunk-SSLTFJ3U.mjs';
+import { createBandScale } from './chunk-RQ3CKQOX.mjs';
+
+// src/series/heatmap/controller/index.ts
+function uniqueValues(values) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const v of values) {
+    const s = String(v);
+    if (!seen.has(s)) {
+      seen.add(s);
+      result.push(s);
+    }
+  }
+  return result;
+}
+function buildHeatmapSvgChildren(params) {
+  const children = [];
+  for (const [dsId, hmLayout] of params.frameLayouts) {
+    const hmProps = params.frameRenderProps.get(dsId);
+    if (!hmProps) continue;
+    const node = params.paint.renderSvg(hmProps, hmLayout, params.context);
+    setAttr(node, "data-dataset", dsId);
+    if (params.context.accessibility?.enabled && params.context.accessibility.landmarkVerbosity === "all") {
+      setAttr(node, "role", "region");
+      setAttr(node, "aria-label", generateSeriesDescription(hmProps.name ?? dsId, "heatmap", hmLayout.cells.length));
+    }
+    children.push(node);
+  }
+  return children;
+}
+var HEATMAP_CELL_REGISTRY = {
+  number: ["x", "y", "width", "height", "opacity"],
+  color: ["color"]
+};
+var HeatmapRendererController = class {
+  constructor(paint) {
+    // Animation lifecycle — local raf clock + fingerprint for phase detection.
+    this._animRafId = null;
+    // Single source of truth for the current hover. Written ONLY by applyHover, read by
+    // renderFrame (the scene-loop + full-render path). Must NOT live on the `input` object:
+    // the scene-loop tick captures a stale `input` while update() swaps `this.lastInput`, so
+    // an input-mutated hover is invisible to the running loop (caused "hover twice to show").
+    // Mirrors radar/polar's `this.hoverState`.
+    this._hover = { datasetId: null, index: null };
+    this._lastFingerprint = "";
+    this.layoutCache = /* @__PURE__ */ new Map();
+    this.lastRenderedLayout = null;
+    this.heatmapDatasets = [];
+    this.lastInput = null;
+    this.svgGroup = null;
+    this.canvasEl = null;
+    // Per-dataset property-animation overrides resolved from AnimatedPropertyStore.
+    // Set by `applyPropertyAnimations()` each property-animation tick and merged
+    // into render props uniformly across all cells of the dataset at every
+    // cache-write site (renderFrame + applyHover). Cleared by `destroy()`.
+    //
+    // Step 10 keeps this per-dataset only. Per-cell granularity is Step 14;
+    // the scene elements are already keyed per-cell from the Step 1 migration,
+    // but the override map is intentionally coarse for this phase.
+    this._propertyOverrides = /* @__PURE__ */ new Map();
+    // Computed results exposed via getters
+    this._scaleResult = null;
+    this._axisLayouts = /* @__PURE__ */ new Map();
+    this._adjustedArea = null;
+    this._layoutResult = null;
+    this.onFrame = null;
+    this._paint = paint;
+    this._scene = new AnimatedScene({
+      // ENTER: cell fades in from transparent at its final position.
+      emptyState: (target) => ({ ...target, opacity: 0 }),
+      // EXIT: cell fades to transparent at its current position.
+      exitEmptyState: (target) => ({ ...target, opacity: 0 }),
+      registry: HEATMAP_CELL_REGISTRY
+    });
+  }
+  // ================================================================
+  // PUBLIC API
+  // ================================================================
+  update(input) {
+    this.lastInput = input;
+    this.svgGroup = input.svgGroup ?? null;
+    this.canvasEl = input.canvasEl ?? null;
+    const { datasets, datasetVisibility, chartArea, width, height, axes, features, compositor, globalFont, locale } = input;
+    const sortedDatasets = Array.from(datasets.entries()).sort(([, a], [, b]) => a.order - b.order);
+    this.heatmapDatasets = collectItems(sortedDatasets, datasetVisibility).heatmap;
+    if (this.heatmapDatasets.length === 0) {
+      this._cancelRaf();
+      this._scene.reset();
+      this._lastFingerprint = "";
+      this._scaleResult = null;
+      this._axisLayouts = /* @__PURE__ */ new Map();
+      this._layoutResult = null;
+      this.layoutCache.clear();
+      return;
+    }
+    const hd0 = this.heatmapDatasets[0];
+    const xField = hd0.props.columnField ?? FIELD_DEFAULTS.columnField;
+    const yField = hd0.props.rowField ?? FIELD_DEFAULTS.rowField;
+    const xCategories = uniqueValues(batchResolveRequired(xField, hd0.props.data, "columnField"));
+    const yCategories = uniqueValues(batchResolveRequired(yField, hd0.props.data, "rowField"));
+    const { xScale, yScale, layouts: axLayouts, adjustedArea } = this.computeAxes(axes, xCategories, yCategories, chartArea, width, globalFont, locale);
+    this._scaleResult = { xScale, yScale, xCategories, yCategories };
+    this._axisLayouts = axLayouts;
+    this._adjustedArea = adjustedArea;
+    const visibleDatasets = this.heatmapDatasets.filter((d) => d.visible);
+    if (visibleDatasets.length === 0) {
+      this._layoutResult = null;
+      this.layoutCache.clear();
+      return;
+    }
+    const cellLayouts = /* @__PURE__ */ new Map();
+    const renderPropsMap = /* @__PURE__ */ new Map();
+    for (const hd of visibleDatasets) {
+      cellLayouts.set(hd.id, calculateHeatmapLayout(hd.props, adjustedArea, { xScale, yScale }, input.theme));
+      renderPropsMap.set(hd.id, hd.props);
+    }
+    this._layoutResult = { layouts: cellLayouts, renderPropsMap };
+    this.layoutCache = cellLayouts;
+    const context = { chartId: input.chartId, width, height, renderer: input.renderer, chartArea, font: globalFont, locale, theme: input.theme, accessibility: buildAccessibilityRenderContext(input.features) };
+    if (input.renderer === "canvas" && compositor) {
+      compositor.setBackground((ctx) => {
+        for (const [, axisInfo] of axLayouts) {
+          if (axisInfo.layout.gridLines.length > 0) {
+            renderAxisCanvas(ctx, axisInfo.layout, { gridOnly: true }, input.theme);
+          }
+        }
+      });
+      compositor.setForeground((ctx) => {
+        for (const [, axisInfo] of axLayouts) {
+          const axisProps = axisInfo.props;
+          renderAxisCanvas(ctx, axisInfo.layout, { skipGrid: true, skipAxisLine: axisProps.showLine === false, skipTicks: axisProps.showTicks === false }, input.theme);
+        }
+      });
+      for (const [dsId] of cellLayouts) {
+        const dsOrder = datasets.get(dsId)?.order ?? 0;
+        compositor.registerLayer({
+          id: `heatmap:${dsId}`,
+          order: dsOrder,
+          paint: (ctx) => {
+            const cached = this.lastRenderedLayout;
+            const hmLayout = cached?.layouts.get(dsId);
+            const hmProps = cached?.renderPropsMap.get(dsId);
+            if (!hmLayout || !hmProps) return;
+            this._paint.renderCanvas(hmProps, hmLayout, ctx, context);
+            if (input.resolveDatasetProps) {
+              renderCanvasHeatmapContent(ctx, /* @__PURE__ */ new Map([[dsId, hmLayout]]), input.resolveDatasetProps, () => {
+                const c = this.canvasEl?.getContext("2d");
+                if (c && compositor) compositor.repaint(c);
+              });
+            }
+          }
+        });
+      }
+    }
+    const animConfig = features.get("animation")?.props;
+    const { enabled: animEnabled, duration, easing } = parseAnimationConfig(animConfig);
+    const limit = animConfig?.limit ?? 5e3;
+    const fingerprint = buildHeatmapFingerprint(cellLayouts);
+    const phase = this._lastFingerprint === "" ? "entrance" : fingerprint !== "" && fingerprint !== this._lastFingerprint ? "update" : "static";
+    let totalCells = 0;
+    for (const layout of cellLayouts.values()) {
+      totalCells += layout.cells.filter((c) => !c.isEmpty).length;
+    }
+    const shouldAnimate = animEnabled && duration > 0 && totalCells <= limit && totalCells > 0 && phase !== "static";
+    if (phase === "static" && this._animRafId !== null) {
+      this._commit(fingerprint);
+      return;
+    }
+    this._cancelRaf();
+    const opts = {
+      numbers: { duration: shouldAnimate ? duration : 0, easing },
+      colors: { duration: shouldAnimate ? duration : 0, easing }
+    };
+    const sceneTargets = this._buildSceneTargets(cellLayouts);
+    this._scene.diff(sceneTargets, opts);
+    if (shouldAnimate) {
+      this._renderSceneFrame(cellLayouts, renderPropsMap, context, input);
+      const tick = (now) => {
+        this._animRafId = null;
+        const { allIdle } = this._scene.tick(now);
+        this._renderSceneFrame(cellLayouts, renderPropsMap, context, input);
+        if (!allIdle) {
+          this._animRafId = raf(tick);
+        }
+      };
+      this._animRafId = raf(tick);
+    } else {
+      this._scene.tick(performance.now());
+      this._renderSceneFrame(cellLayouts, renderPropsMap, context, input);
+    }
+    this._commit(fingerprint);
+  }
+  applyHover(hover) {
+    if (!this.lastRenderedLayout || !this.lastInput) return;
+    this._hover = hover;
+    const input = this.lastInput;
+    const context = {
+      chartId: input.chartId,
+      width: input.width,
+      height: input.height,
+      renderer: input.renderer,
+      chartArea: input.chartArea,
+      font: input.globalFont,
+      locale: input.locale,
+      theme: input.theme,
+      accessibility: buildAccessibilityRenderContext(input.features)
+    };
+    if (input.renderer === "canvas" && input.compositor) {
+      const cached = this.lastRenderedLayout;
+      const updatedProps = this.buildFrameRenderProps(cached.renderPropsMap, this._hover, input.hoverConfig);
+      this.lastRenderedLayout = { ...cached, renderPropsMap: updatedProps };
+      const ctx = this.canvasEl?.getContext("2d");
+      if (ctx) input.compositor.repaint(ctx);
+    } else if (input.renderer === "svg" && this.svgGroup && this._layoutResult) {
+      if (this._animRafId !== null) return;
+      const frameLayouts = this.lastRenderedLayout.layouts;
+      const frameRenderProps = this.buildFrameRenderProps(this._layoutResult.renderPropsMap, this._hover, input.hoverConfig);
+      const children = buildHeatmapSvgChildren({ paint: this._paint, frameLayouts, frameRenderProps, context });
+      reconcileSvgChildren(this.svgGroup, children);
+    }
+  }
+  hitTest(x, y) {
+    for (const [datasetId, heatmapLayout] of this.layoutCache) {
+      const cell = hitTestHeatmap(heatmapLayout, x, y);
+      if (cell) {
+        return { datasetId, index: cell.index, col: cell.col, value: cell.value, xLabel: cell.xLabel, yLabel: cell.yLabel, x: cell.x, y: cell.y, width: cell.width, height: cell.height, color: cell.color };
+      }
+    }
+    return null;
+  }
+  getColorScaleInfo() {
+    if (!this._layoutResult) return null;
+    const firstLayout = this._layoutResult.layouts.values().next().value;
+    if (!firstLayout || firstLayout.resolvedColorScale.length === 0) return null;
+    return { colorScale: firstLayout.resolvedColorScale, colorRange: firstLayout.resolvedColorRange, min: firstLayout.valueRange[0], max: firstLayout.valueRange[1] };
+  }
+  get hasData() {
+    return this.heatmapDatasets.length > 0;
+  }
+  get scaleResult() {
+    return this._scaleResult;
+  }
+  get axisLayouts() {
+    return this._axisLayouts;
+  }
+  get adjustedArea() {
+    return this._adjustedArea;
+  }
+  get layoutResult() {
+    return this._layoutResult;
+  }
+  get layouts() {
+    return this.layoutCache;
+  }
+  destroy() {
+    this._cancelRaf();
+    this._scene.reset();
+    this._lastFingerprint = "";
+    this._propertyOverrides.clear();
+    this.lastInput?.compositor?.removeLayersByPrefix("heatmap:");
+  }
+  /**
+   * Apply animated property values without triggering a full layout cycle.
+   * Called from the property-animation framework wrapper each animation tick.
+   *
+   * Per-dataset: writes overrides into `_propertyOverrides` (or deletes the
+   * entry when the store has no live values for it), then patches the active
+   * `lastRenderedLayout.renderPropsMap` and triggers a repaint. The overrides
+   * apply uniformly to all cells of the dataset — per-cell granularity is
+   * Step 14.
+   *
+   * SVG: heatmap renders cells imperatively each frame from
+   * `lastRenderedLayout.renderPropsMap`, so a `renderFrameCycle()` call replays
+   * the merged props onto the DOM. Canvas: refreshes the cache then triggers
+   * compositor repaint so the layer paint callback reads the merged props.
+   */
+  applyPropertyAnimations(store) {
+    const input = this.lastInput;
+    const cached = this.lastRenderedLayout;
+    if (!input || !cached) return;
+    let appliedAny = false;
+    for (const [dsId, baseProps] of cached.renderPropsMap) {
+      const overrides = resolveAnimatedProps(store, "heatmap", dsId, HEATMAP_ANIMATABLE_PROPS);
+      if (Object.keys(overrides).length === 0) {
+        if (this._propertyOverrides.delete(dsId)) appliedAny = true;
+        continue;
+      }
+      appliedAny = true;
+      this._propertyOverrides.set(dsId, overrides);
+      cached.renderPropsMap.set(dsId, { ...baseProps, ...overrides });
+    }
+    if (!appliedAny) return;
+    if (triggerCompositorRepaint(input.renderer, this.canvasEl, input.compositor)) return;
+    if (input.renderer === "svg" && this._layoutResult) {
+      const context = {
+        chartId: input.chartId,
+        width: input.width,
+        height: input.height,
+        renderer: input.renderer,
+        chartArea: input.chartArea,
+        font: input.globalFont,
+        locale: input.locale,
+        theme: input.theme,
+        accessibility: buildAccessibilityRenderContext(input.features)
+      };
+      this.renderFrame(cached.layouts, this._layoutResult.renderPropsMap, context, input);
+    }
+  }
+  /**
+   * Full re-render of the current scene state.
+   *
+   * Used by the property-animation framework wrapper: when a property
+   * animation completes and its override is released from the store, the
+   * next call to `_renderSceneFrame()` (via `renderFrame` here) rebuilds
+   * `lastRenderedLayout.renderPropsMap` from the now-empty overrides map,
+   * so SVG attributes / canvas paints snap back to base values.
+   */
+  renderFrameCycle() {
+    const input = this.lastInput;
+    const layoutResult = this._layoutResult;
+    const cached = this.lastRenderedLayout;
+    if (!input || !layoutResult || !cached) return;
+    const context = {
+      chartId: input.chartId,
+      width: input.width,
+      height: input.height,
+      renderer: input.renderer,
+      chartArea: input.chartArea,
+      font: input.globalFont,
+      locale: input.locale,
+      theme: input.theme,
+      accessibility: buildAccessibilityRenderContext(input.features)
+    };
+    this.renderFrame(cached.layouts, layoutResult.renderPropsMap, context, input);
+  }
+  // ================================================================
+  // PRIVATE
+  // ================================================================
+  /**
+   * Build the per-cell scene-target map from the computed cell layouts.
+   * Element id format: `${datasetId}::${dataKey ?? xLabel|yLabel}`. The
+   * `${datasetId}::` prefix scopes the id across datasets; within a dataset
+   * the suffix matches the legacy cellKey identity from animations/heatmap.ts.
+   */
+  _buildSceneTargets(cellLayouts) {
+    const targets = /* @__PURE__ */ new Map();
+    for (const [datasetId, layout] of cellLayouts) {
+      for (const cell of layout.cells) {
+        if (cell.isEmpty) continue;
+        const cellKey = cell.dataKey != null ? String(cell.dataKey) : `${cell.xLabel}|${cell.yLabel}`;
+        const id = `${datasetId}::${cellKey}`;
+        targets.set(id, {
+          x: cell.x,
+          y: cell.y,
+          width: cell.width,
+          height: cell.height,
+          opacity: 1,
+          color: cell.color,
+          value: cell.value,
+          row: cell.row,
+          col: cell.col,
+          xLabel: cell.xLabel,
+          yLabel: cell.yLabel,
+          datasetId,
+          dataKey: cell.dataKey,
+          isEmpty: false
+        });
+      }
+    }
+    return targets;
+  }
+  /**
+   * Walk the scene and rebuild per-dataset HeatmapRenderData reflecting the
+   * current visual state. Used by the raf tick loop to feed the existing
+   * render path without modifying the renderer.
+   *
+   * Layout structure (xCategories, yCategories, color scale, etc.) comes from
+   * the target layout in `cellLayouts`; per-cell visual state (x, y, width,
+   * height, opacity, color) comes from the scene's current frame.
+   */
+  _renderSceneFrame(cellLayouts, renderPropsMap, context, input) {
+    const cellIndexByDataset = /* @__PURE__ */ new Map();
+    for (const [datasetId, layout] of cellLayouts) {
+      const idx = /* @__PURE__ */ new Map();
+      for (const c of layout.cells) {
+        idx.set(`${c.row}|${c.col}`, c);
+      }
+      cellIndexByDataset.set(datasetId, idx);
+    }
+    const cellsByDataset = /* @__PURE__ */ new Map();
+    for (const el of this._scene.getElements()) {
+      const s = el.current;
+      const targetCell = cellIndexByDataset.get(s.datasetId)?.get(`${s.row}|${s.col}`);
+      if (!targetCell) continue;
+      const cell = {
+        ...targetCell,
+        x: s.x,
+        y: s.y,
+        width: s.width,
+        height: s.height,
+        opacity: s.opacity,
+        color: s.color,
+        value: s.value,
+        row: s.row,
+        col: s.col,
+        xLabel: s.xLabel,
+        yLabel: s.yLabel,
+        dataKey: s.dataKey,
+        isEmpty: false
+      };
+      let arr = cellsByDataset.get(s.datasetId);
+      if (!arr) {
+        arr = [];
+        cellsByDataset.set(s.datasetId, arr);
+      }
+      arr.push(cell);
+    }
+    const frameLayouts = /* @__PURE__ */ new Map();
+    for (const [datasetId, targetLayout] of cellLayouts) {
+      const liveCells = cellsByDataset.get(datasetId) ?? [];
+      const emptyCells = targetLayout.cells.filter((c) => c.isEmpty);
+      frameLayouts.set(datasetId, { ...targetLayout, cells: [...liveCells, ...emptyCells] });
+    }
+    this.renderFrame(frameLayouts, renderPropsMap, context, input);
+  }
+  /** Cancel any in-flight raf. */
+  _cancelRaf() {
+    if (this._animRafId !== null) {
+      cancelRaf(this._animRafId);
+      this._animRafId = null;
+    }
+  }
+  /** Commit fingerprint for next-frame phase detection. */
+  _commit(fingerprint) {
+    this._lastFingerprint = fingerprint;
+  }
+  /**
+   * Merge each base prop set with its property-animation override + the current
+   * hover/effects state into the per-dataset render props consumed by both the
+   * full render (renderFrame) and the in-place hover reconcile (applyHover).
+   * Single source of truth — the three call sites differ only in which base map
+   * and hover snapshot they feed in.
+   */
+  buildFrameRenderProps(baseMap, hover, hoverConfig) {
+    const result = /* @__PURE__ */ new Map();
+    for (const [dsId, baseProps] of baseMap) {
+      const overrides = this._propertyOverrides.get(dsId);
+      result.set(dsId, {
+        ...baseProps,
+        ...overrides ?? {},
+        interaction: { hoveredIndex: hover.datasetId === dsId ? hover.index : null },
+        // Heatmap hover diverges from other chart types: it does NOT dim the other cells by
+        // default. Dimming creates a visible flicker when the pointer crosses the gap between
+        // cells (the whole grid un-dims, then re-dims on the next cell). Instead heatmap
+        // brightens just the hovered cell. Callers can still opt back into dimming by passing
+        // an explicit `dimOpacity` on <Chart.Hover>.
+        effects: hoverConfig ? { dimOpacity: hoverConfig.dimOpacity ?? 1, hoverBrightness: hoverConfig.brightness ?? DEFAULT_HOVER_BRIGHTNESS } : void 0
+      });
+    }
+    return result;
+  }
+  renderFrame(frameLayouts, renderPropsMap, context, input) {
+    const frameRenderProps = this.buildFrameRenderProps(renderPropsMap, this._hover, input.hoverConfig);
+    this.lastRenderedLayout = { layouts: frameLayouts, renderPropsMap: frameRenderProps };
+    if (input.renderer === "svg" && this.svgGroup) {
+      const children = buildHeatmapSvgChildren({ paint: this._paint, frameLayouts, frameRenderProps, context });
+      this.svgGroup.replaceChildren(...children.map(materializeSvgNode));
+    }
+    if (input.renderer === "canvas" && input.compositor) {
+      const ctx = this.canvasEl?.getContext("2d");
+      if (ctx) input.compositor.repaint(ctx);
+    } else if (input.renderer === "canvas") {
+      const ctx = this.canvasEl?.getContext("2d");
+      if (!ctx) return;
+      for (const [dsId, hmLayout] of frameLayouts) {
+        const hmProps = frameRenderProps.get(dsId);
+        if (!hmProps) continue;
+        this._paint.renderCanvas(hmProps, hmLayout, ctx, context);
+      }
+      if (input.resolveDatasetProps) {
+        renderCanvasHeatmapContent(ctx, frameLayouts, input.resolveDatasetProps, () => {
+          const c = this.canvasEl?.getContext("2d");
+          if (c && input.compositor) input.compositor.repaint(c);
+        });
+      }
+    }
+    this.onFrame?.();
+  }
+  computeAxes(axes, xCategories, yCategories, chartArea, width, globalFont, locale) {
+    const tier = getResponsiveTier(width);
+    const adaptive = getAdaptiveDefaults(tier, globalFont);
+    const tempXScale = createBandScale(xCategories, [chartArea.x, chartArea.x + chartArea.width]);
+    const tempYScale = createBandScale(yCategories, [chartArea.y, chartArea.y + chartArea.height]);
+    let leftSpace = 0, rightSpace = 0, topSpace = 0, bottomSpace = 0;
+    const sidePrimarySet = /* @__PURE__ */ new Set();
+    const yAxesPrepped = [];
+    const xAxesPrepped = [];
+    for (const [yAxisId, yAxisConfig] of axes.y) {
+      const yPos = yAxisConfig.props.position ?? "left";
+      const isPrimary = !sidePrimarySet.has(yPos);
+      if (isPrimary) sidePrimarySet.add(yPos);
+      let yProps = yAxisConfig.props;
+      if (yProps.gridLines === void 0) yProps = { ...yProps, gridLines: isPrimary };
+      if (yProps.tickCount === void 0) yProps = { ...yProps, tickCount: getAdaptiveTickCount(chartArea.height) };
+      const existingTickStyle = yProps?.tickStyle;
+      if (typeof existingTickStyle !== "function" && !existingTickStyle?.fontSize) {
+        yProps = { ...yProps, tickStyle: { ...existingTickStyle, fontSize: adaptive.tickFontSize } };
+      }
+      const tempLayout = calculateAxisLayout(tempYScale, yPos, chartArea, yProps, void 0, globalFont, locale);
+      const space = calculateAxisSpace(
+        yPos,
+        !!yProps?.label,
+        {
+          tickLabels: tempLayout.ticks.map((t) => t.label ?? ""),
+          tickRotation: 0,
+          titleGap: yProps?.titleGap,
+          showTicks: yProps?.showTicks,
+          tickStyle: typeof existingTickStyle === "function" ? void 0 : existingTickStyle
+        },
+        void 0,
+        globalFont
+      );
+      if (yPos === "left") leftSpace += space;
+      else rightSpace += space;
+      yAxesPrepped.push({ id: yAxisId, pos: yPos, isPrimary, props: yProps });
+    }
+    for (const [xAxisId, xAxisConfig] of axes.x) {
+      const xPos = xAxisConfig.props.position ?? "bottom";
+      const isPrimary = !sidePrimarySet.has(xPos);
+      if (isPrimary) sidePrimarySet.add(xPos);
+      let xProps = xAxisConfig.props;
+      if (xProps.tickCount === void 0) xProps = { ...xProps, tickCount: getAdaptiveTickCount(chartArea.width) };
+      const existingTickStyle = xProps?.tickStyle;
+      if (typeof existingTickStyle !== "function" && !existingTickStyle?.fontSize) {
+        xProps = { ...xProps, tickStyle: { ...existingTickStyle, fontSize: adaptive.tickFontSize } };
+      }
+      const tempLayout = calculateAxisLayout(tempXScale, xPos, chartArea, xProps, void 0, globalFont, locale);
+      const space = calculateAxisSpace(
+        xPos,
+        !!xProps?.label,
+        {
+          tickLabels: tempLayout.ticks.map((t) => t.label ?? ""),
+          tickRotation: tempLayout.ticks.find((t) => t.label)?.rotation ?? 0,
+          titleGap: xProps?.titleGap,
+          showTicks: xProps?.showTicks,
+          tickStyle: typeof existingTickStyle === "function" ? void 0 : existingTickStyle
+        },
+        void 0,
+        globalFont
+      );
+      if (xPos === "top") topSpace += space;
+      else bottomSpace += space;
+      xAxesPrepped.push({ id: xAxisId, pos: xPos, isPrimary, props: xProps });
+    }
+    const adjusted = {
+      x: chartArea.x + leftSpace,
+      y: chartArea.y + topSpace,
+      width: Math.max(0, chartArea.width - leftSpace - rightSpace),
+      height: Math.max(0, chartArea.height - topSpace - bottomSpace)
+    };
+    const xScale = createBandScale(xCategories, [adjusted.x, adjusted.x + adjusted.width]);
+    const yScale = createBandScale(yCategories, [adjusted.y, adjusted.y + adjusted.height]);
+    const layouts = /* @__PURE__ */ new Map();
+    const sideOffsets = { left: 0, right: 0, top: 0, bottom: 0 };
+    for (const { id, pos, isPrimary, props } of yAxesPrepped) {
+      const offset = sideOffsets[pos];
+      const layout = calculateAxisLayout(yScale, pos, adjusted, props, void 0, globalFont, locale);
+      const existingTickStyle = props?.tickStyle;
+      const space = calculateAxisSpace(
+        pos,
+        !!props?.label,
+        {
+          tickLabels: layout.ticks.map((t) => t.label ?? ""),
+          tickRotation: 0,
+          titleGap: props?.titleGap,
+          showTicks: props?.showTicks,
+          tickStyle: typeof existingTickStyle === "function" ? void 0 : existingTickStyle
+        },
+        void 0,
+        globalFont
+      );
+      sideOffsets[pos] += space;
+      layouts.set(`y:${id}`, { id, axis: "y", position: pos, layout, visibleLayout: layout, scale: yScale, props, isPrimary, offset, space, isHidden: false });
+    }
+    for (const { id, pos, isPrimary, props } of xAxesPrepped) {
+      const offset = sideOffsets[pos];
+      const layout = calculateAxisLayout(xScale, pos, adjusted, props, void 0, globalFont, locale);
+      const existingTickStyle = props?.tickStyle;
+      const space = calculateAxisSpace(
+        pos,
+        !!props?.label,
+        {
+          tickLabels: layout.ticks.map((t) => t.label ?? ""),
+          tickRotation: layout.ticks.find((t) => t.label)?.rotation ?? 0,
+          titleGap: props?.titleGap,
+          showTicks: props?.showTicks,
+          tickStyle: typeof existingTickStyle === "function" ? void 0 : existingTickStyle
+        },
+        void 0,
+        globalFont
+      );
+      sideOffsets[pos] += space;
+      layouts.set(`x:${id}`, { id, axis: "x", position: pos, layout, visibleLayout: layout, scale: xScale, props, isPrimary, offset, space, isHidden: false });
+    }
+    return { xScale, yScale, layouts, adjustedArea: adjusted };
+  }
+};
+
+export { HeatmapRendererController };