@coinbase/cds-mobile 8.66.2 → 9.0.0-rc.2

package/dts/visualizations/chart/text/ChartTextGroup.d.ts

@@ -0,0 +1,61 @@
+import { type ChartTextChildren, type ChartTextProps } from './ChartText';
+/**
+ * Configuration for a single text label in the display list
+ */
+export type TextLabelData = {
+  /**
+   * The text content to display
+   */
+  label: ChartTextChildren;
+  /**
+   * X coordinate where the text should be positioned
+   */
+  x: number;
+  /**
+   * Y coordinate where the text should be positioned
+   */
+  y: number;
+  /**
+   * Additional props to pass to the ChartText component for this specific label
+   */
+  chartTextProps?: Partial<ChartTextProps>;
+};
+export type TextLabelDataWithKey = TextLabelData & {
+  key: string;
+};
+export type ChartTextGroupBaseProps = {
+  /**
+   * Array of text labels to display
+   */
+  labels: TextLabelData[];
+  /**
+   * Minimum gap between labels
+   * @default 8
+   */
+  minGap?: number;
+  /**
+   * Whether to always show first and last labels
+   * @default true
+   */
+  prioritizeEndLabels?: boolean;
+  /**
+   * Common props to apply to all ChartText components
+   */
+  chartTextProps?: Partial<ChartTextProps>;
+  /**
+   * Custom component to render each label
+   * @default ChartText
+   */
+  LabelComponent?: React.FC<ChartTextProps>;
+};
+export type ChartTextGroupProps = ChartTextGroupBaseProps;
+/**
+ * A smart text display component that prevents label overlap through collision detection.
+ *
+ * This component renders a list of ChartText components and automatically hides overlapping elements
+ * to ensure readability.
+ *
+ * The component focuses solely on overlap prevention logic for better separation of concerns.
+ */
+export declare const ChartTextGroup: import('react').NamedExoticComponent<ChartTextGroupBaseProps>;
+//# sourceMappingURL=ChartTextGroup.d.ts.map

package/dts/visualizations/chart/text/ChartTextGroup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChartTextGroup.d.ts","sourceRoot":"","sources":["../../../../src/visualizations/chart/text/ChartTextGroup.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAa,KAAK,iBAAiB,EAAE,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAErF;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B;;OAEG;IACH,KAAK,EAAE,iBAAiB,CAAC;IACzB;;OAEG;IACH,CAAC,EAAE,MAAM,CAAC;IACV;;OAEG;IACH,CAAC,EAAE,MAAM,CAAC;IACV;;OAEG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;CAC1C,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG,aAAa,GAAG;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnE,MAAM,MAAM,uBAAuB,GAAG;IACpC;;OAEG;IACH,MAAM,EAAE,aAAa,EAAE,CAAC;IACxB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;OAEG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC;IACzC;;;OAGG;IACH,cAAc,CAAC,EAAE,KAAK,CAAC,EAAE,CAAC,cAAc,CAAC,CAAC;CAC3C,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,uBAAuB,CAAC;AAiB1D;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,+DA8L1B,CAAC"}

package/dts/visualizations/chart/text/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ChartText';
+export * from './ChartTextGroup';
+//# sourceMappingURL=index.d.ts.map

package/dts/visualizations/chart/text/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/visualizations/chart/text/index.ts"],"names":[],"mappings":"AACA,cAAc,aAAa,CAAC;AAC5B,cAAc,kBAAkB,CAAC"}

package/dts/visualizations/chart/utils/axis.d.ts

@@ -0,0 +1,387 @@
+import type React from 'react';
+import type { Rect } from '@coinbase/cds-common/types';
+import { type AxisBounds, type Series } from './chart';
+import type { CartesianChartLayout } from './context';
+import { type ChartAxisScaleType, type ChartScaleFunction, type PointAnchor } from './scale';
+export declare const defaultAxisId = 'DEFAULT_AXIS_ID';
+export declare const defaultAxisScaleType = 'linear';
+/**
+ * Position options for band scale axis elements (grid lines, tick marks, labels).
+ *
+ * - `'start'` - At the start of each step (before bar padding)
+ * - `'middle'` - At the center of each band
+ * - `'end'` - At the end of each step (after bar padding)
+ * - `'edges'` - At start of each tick, plus end for the last tick (encloses the chart)
+ *
+ * @note These properties only apply when using a band scale (`scaleType: 'band'`).
+ */
+export type AxisBandPlacement = 'start' | 'middle' | 'end' | 'edges';
+/**
+ * Converts an AxisBandPlacement to the corresponding PointAnchor for use with getPointOnScale.
+ *
+ * @param placement - The axis placement value
+ * @returns The corresponding PointAnchor for scale calculations
+ */
+export declare const toPointAnchor: (placement: AxisBandPlacement) => PointAnchor;
+/**
+ * Axis configuration with computed bounds
+ */
+export type AxisConfig = {
+  /** The type of scale to use */
+  scaleType: ChartAxisScaleType;
+  /**
+   * Domain bounds for the axis (data space)
+   */
+  domain: AxisBounds;
+  /**
+   * Range bounds for the axis (visual space in pixels)
+   */
+  range: AxisBounds;
+  /**
+   * Data for the axis.
+   * @note only used by the category axis.
+   */
+  data?: string[] | number[];
+  /**
+   * Padding between categories for band scales (0-1, where 0.1 = 10% spacing)
+   * Only used when scaleType is 'band'
+   * @default 0.1
+   */
+  categoryPadding?: number;
+  /**
+   * Domain limit type for numeric scales
+   * - 'nice': Rounds the domain to human-friendly values
+   * - 'strict': Uses the exact min/max values from the data
+   */
+  domainLimit: 'nice' | 'strict';
+};
+export type CartesianAxisConfig = AxisConfig & {
+  /**
+   * Baseline value used as the origin for numeric series on this axis.
+   * Only applies when this axis is the value axis for the current chart layout.
+   * - Non-stacked numeric series render from `[baseline, value]`.
+   * - Multi-series stacks are normalized around this baseline before stacking.
+   *
+   * @default 0 for value axes, undefined for category axes
+   */
+  baseline?: number;
+};
+/**
+ * Axis configuration without computed bounds (used for input)
+ */
+export type CartesianAxisConfigProps = Omit<CartesianAxisConfig, 'domain' | 'range'> & {
+  /**
+   * Unique identifier for this axis.
+   */
+  id: string;
+  /**
+   * Domain configuration for the axis (data space).
+   *
+   * The domainLimit parameter (inherited from AxisConfig) controls how initial domain bounds are calculated:
+   * - 'nice' (default for y axes): Rounds the domain to human-friendly values (e.g., 0-100 instead of 1.2-97.8)
+   * - 'strict' (default for x axes): Uses the exact min/max values from the data
+   *
+   * The domain can be:
+   * - A partial bounds object to override specific min/max values
+   * - A function that receives the limit-processed bounds and allows further customization
+   *
+   * This allows you to first apply nice/strict processing, then optionally transform the result.
+   */
+  domain?: Partial<AxisBounds> | ((bounds: AxisBounds) => AxisBounds);
+  /**
+   * Range configuration for the axis (visual space in pixels).
+   * Can be a partial bounds object to override specific values, or a function that transforms the calculated range.
+   *
+   * When using a function, it receives the initial calculated range bounds and allows you to adjust them.
+   * This replaces the previous rangeOffset approach and provides more flexibility for range customization.
+   */
+  range?: Partial<AxisBounds> | ((bounds: AxisBounds) => AxisBounds);
+};
+export declare const withBaselineDomain: (
+  domain: CartesianAxisConfigProps['domain'],
+  baseline?: number,
+) => CartesianAxisConfigProps['domain'];
+/**
+ * Gets a D3 scale based on the cartesian axis configuration.
+ * Handles both numeric (linear/log) and categorical (band) scales.
+ *
+ * For numeric scales, the domain limit controls whether bounds are "nice" (human-friendly)
+ * or "strict" (exact min/max). Range can be customized using function-based configuration.
+ *
+ * @param params - Scale parameters
+ * @returns The D3 scale function
+ * @throws An Error if bounds are invalid
+ */
+export declare const getCartesianAxisScale: ({
+  config,
+  type,
+  range,
+  dataDomain,
+  layout,
+}: {
+  config?: CartesianAxisConfig;
+  type: 'x' | 'y';
+  range: AxisBounds;
+  dataDomain: AxisBounds;
+  layout?: CartesianChartLayout;
+}) => ChartScaleFunction;
+/**
+ * Formats the array of user-provided axis configs with default values and validates axis ids.
+ * Ensures at least one axis config exists if no input is provided.
+ * Requires specific axis ids when there are more than 1 axes.
+ * Defaults the axis id for a single axis config if there is no id.
+ * @param type - the type of axis, 'x' or 'y'
+ * @param axes - array of axis configs or single axis config
+ * @param defaultId - the default id to use for the axis
+ * @param defaultScaleType - the default scale type to use for the axis
+ * @returns array of axis configs with IDs
+ */
+export declare const getAxisConfig: (
+  type: 'x' | 'y',
+  axes: Partial<CartesianAxisConfigProps> | Partial<CartesianAxisConfigProps>[] | undefined,
+  defaultId?: string,
+  defaultScaleType?: ChartAxisScaleType,
+) => CartesianAxisConfigProps[];
+/**
+ * Calculates the data domain for an axis based on its configuration and series data.
+ * Handles both x and y axes, categorical data, custom domain configurations, and stacking.
+ *
+ * @param axisParam - The axis configuration
+ * @param series - Array of series objects (for stacking support)
+ * @param axisType - Whether this is an 'x' or 'y' axis
+ * @param layout - The chart layout orientation
+ * @returns The calculated axis bounds
+ */
+export declare const getCartesianAxisDomain: (
+  axisParam: CartesianAxisConfigProps,
+  series: Series[],
+  axisType: 'x' | 'y',
+  layout?: CartesianChartLayout,
+) => AxisBounds;
+/**
+ * Calculates the visual range for an axis based on the chart rectangle and configuration.
+ * Handles custom range configurations including functions and partial bounds.
+ *
+ * @param axisParam - The axis configuration
+ * @param chartRect - The chart drawing area rectangle
+ * @param axisType - Whether this is an 'x' or 'y' axis
+ * @returns The calculated axis range bounds
+ */
+export declare const getAxisRange: (
+  axisParam: CartesianAxisConfigProps,
+  chartRect: Rect,
+  axisType: 'x' | 'y',
+) => AxisBounds;
+/**
+ * Options for tick generation behavior
+ */
+type TickGenerationOptions = {
+  /**
+   * Minimum step size allowed for ticks.
+   * Prevents the step from being smaller than this value.
+   * @example 1 // Prevents fractional steps like 0.5
+   */
+  minStep?: number;
+  /**
+   * Maximum step size allowed for ticks.
+   * Prevents the step from being larger than this value.
+   * @example 100 // Prevents steps larger than 100
+   */
+  maxStep?: number;
+  /**
+   * Minimum number of ticks to generate when using tickInterval.
+   * @default 4
+   */
+  minTickCount?: number;
+  /**
+   * Anchor position for band/categorical scales.
+   * Controls where tick labels are positioned within each band.
+   * @default 'middle'
+   */
+  anchor?: PointAnchor;
+};
+export type GetAxisTicksDataProps = {
+  /**
+   * Custom tick configuration for the axis.
+   * - **Array**: Uses these exact values for tick positioning and labels.
+   *   - For numeric scales: exact values to display
+   *   - For band scales: category indices to display
+   * - **Function**: Filters based on the predicate function.
+   *   - For numeric scales: filters generated tick values
+   *   - For band scales: filters category indices
+   */
+  ticks?: number[] | ((value: number) => boolean);
+  /**
+   * The scale function to use for positioning and tick generation.
+   * Can be either a numeric scale or a band scale.
+   */
+  scaleFunction: ChartScaleFunction;
+  /**
+   * Requested number of ticks to display (only used for numeric scales).
+   * For band/categorical scales, use the `ticks` parameter to control which categories are shown.
+   */
+  requestedTickCount?: number;
+  /**
+   * Categories for band scales
+   */
+  categories?: string[];
+  /**
+   * Possible tick values to filter from when using function-based ticks.
+   * Used for discrete data (such as 'band' scale indices).
+   */
+  possibleTickValues?: number[];
+  /**
+   * Interval at which to show ticks in pixels.
+   * When provided, calculates tick count based on available space and generates
+   * evenly distributed ticks that always include first and last domain values.
+   * Only applies to numeric scales and overrides requestedTickCount.
+   *
+   * @example
+   * // For a chart with 400px width, tickInterval: 64 would generate ~6 ticks
+   * // evenly distributed across the data range, always including first and last values
+   * getAxisTicksData({
+   *   scaleFunction: numericScale,
+   *   tickInterval: 32,
+   *   possibleTickValues: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+   * });
+   * // Result: ticks at indices [0, 2, 4, 6, 8, 10] with their corresponding positions
+   */
+  tickInterval?: number;
+  /**
+   * Options for tick generation behavior
+   */
+  options?: TickGenerationOptions;
+};
+/**
+ * Formats a tick value for display on an axis.
+ * Consolidates the identical formatting logic shared between XAxis and YAxis.
+ *
+ * @param value - The raw tick value to format
+ * @param tickFormatter - Optional custom formatter function
+ * @returns The formatted tick value as a React node
+ */
+export declare const formatAxisTick: (
+  value: any,
+  tickFormatter?: (value: any) => React.ReactNode,
+) => React.ReactNode;
+/**
+ * Processes tick configuration and returns tick data with positions.
+ *
+ * **Parameter Precedence by Scale Type:**
+ *
+ * **For Numeric Scales (linear/log):**
+ * 1. `ticks` (array) - Explicit tick values override all other options
+ * 2. `ticks` (function) - Filter function for tick selection
+ * 3. `ticks` (boolean) - Show/hide all possible ticks
+ * 4. `requestedTickCount` - D3 automatic tick generation (overrides tickInterval)
+ * 5. `tickInterval` - Pixel-based spacing (fallback)
+ *
+ * **For Categorical Scales (band):**
+ * 1. `ticks` (array) - Explicit category indices to display
+ * 2. `ticks` (function) - Filter function for category selection
+ * 3. `ticks` (boolean) - Show/hide all categories
+ * 4. Default - Show all categories (requestedTickCount and tickInterval are ignored)
+ *
+ * @param params - Tick processing parameters
+ * @param params.ticks - Custom tick configuration with multiple formats:
+ *   - **Array**: For numeric scales: exact tick values; For band scales: category indices
+ *   - **Function**: Predicate to filter tick values or category indices
+ *   - **Boolean**: Show all (true) or no ticks (false) for both scale types
+ * @param params.scaleFunction - D3 scale function (numeric or band scale)
+ * @param params.requestedTickCount - Number of ticks for D3 generation (**numeric scales only**, overrides tickInterval)
+ * @param params.categories - Category labels (**band scales only**)
+ * @param params.possibleTickValues - Available tick values for filtering/selection (**numeric scales only**)
+ * @param params.tickInterval - Pixel spacing between ticks (**numeric scales only**, fallback option)
+ * @returns Array of tick data with values and positions
+ *
+ * @example
+ * // Basic usage with tickInterval for pixel-based spacing
+ * import { scaleLinear } from 'd3-scale';
+ *
+ * const numericScale = scaleLinear().domain([0, 10]).range([0, 400]);
+ * const result = getAxisTicksData({
+ *   scaleFunction: numericScale,
+ *   tickInterval: 80, // 80 pixels between ticks
+ *   possibleTickValues: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+ * });
+ * // Returns: [
+ * //   { tick: 0, position: 0 },    // Always includes first
+ * //   { tick: 2, position: 80 },
+ * //   { tick: 5, position: 200 },
+ * //   { tick: 7, position: 280 },
+ * //   { tick: 10, position: 400 }  // Always includes last
+ * // ]
+ *
+ * @example
+ * // Using requestedTickCount for D3-generated ticks
+ * const result = getAxisTicksData({
+ *   scaleFunction: numericScale,
+ *   requestedTickCount: 5
+ * });
+ * // Uses D3's tick generation algorithm
+ *
+ * @example
+ * // Using explicit tick values
+ * const result = getAxisTicksData({
+ *   scaleFunction: numericScale,
+ *   ticks: [0, 2.5, 5, 7.5, 10]
+ * });
+ * // Returns exact positions for specified values
+ *
+ * @example
+ * // Using tick filter function
+ * const result = getAxisTicksData({
+ *   scaleFunction: numericScale,
+ *   ticks: (value) => value % 2 === 0, // Only even numbers
+ *   possibleTickValues: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+ * });
+ * // Returns: [0, 2, 4, 6, 8, 10] with their positions
+ *
+ * @example
+ * // Band scale with categories (requestedTickCount and tickInterval are ignored)
+ * import { scaleBand } from 'd3-scale';
+ *
+ * const bandScale = scaleBand().domain([0, 1, 2, 3, 4]).range([0, 400]).padding(0.1);
+ * const result = getAxisTicksData({
+ *   scaleFunction: bandScale,
+ *   categories: ['Jan', 'Feb', 'Mar', 'Apr', 'May'],
+ *   ticks: [0, 2, 4], // Show only Jan (index 0), Mar (index 2), May (index 4)
+ *   requestedTickCount: 10, // IGNORED for band scales
+ *   tickInterval: 50 // IGNORED for band scales
+ * });
+ * // Returns tick positions centered in each selected band
+ */
+export declare const getAxisTicksData: ({
+  ticks,
+  scaleFunction,
+  requestedTickCount,
+  categories,
+  possibleTickValues,
+  tickInterval,
+  options,
+}: GetAxisTicksDataProps) => Array<{
+  tick: number;
+  position: number;
+}>;
+export type RegisteredAxis = {
+  id: string;
+  position: 'top' | 'bottom' | 'left' | 'right';
+  size: number;
+};
+/**
+ * Calculates the total amount of padding needed to render a set of axes on the main drawing area of the chart.
+ * Returns the registed axes, an API for adding/removing axes as well as the total calculated padding that must be reserved in the drawing area.
+ */
+export declare const useTotalAxisPadding: () => {
+  renderedAxes: Map<string, RegisteredAxis>;
+  axisPadding: {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+  };
+  registerAxis: (id: string, position: 'top' | 'bottom' | 'left' | 'right', size: number) => void;
+  unregisterAxis: (id: string) => void;
+};
+export {};
+//# sourceMappingURL=axis.d.ts.map

package/dts/visualizations/chart/utils/axis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"axis.d.ts","sourceRoot":"","sources":["../../../../src/visualizations/chart/utils/axis.ts"],"names":[],"mappings":"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"}

package/dts/visualizations/chart/utils/bar.d.ts

@@ -0,0 +1,225 @@
+import type { Rect } from '@coinbase/cds-common/types';
+import type { BarComponent } from '../bar/Bar';
+import type { BarSeries } from '../bar/BarStack';
+import type { CartesianChartLayout } from './context';
+import type { GradientDefinition, GradientStop } from './gradient';
+import type { ChartScaleFunction, SerializableScale } from './scale';
+import { type Transition } from './transition';
+/**
+ * A bar-specific transition that extends Transition with stagger support.
+ * When `staggerDelay` is provided, bars will animate with increasing delays
+ * based on their position along the category axis (vertical: left-to-right,
+ * horizontal: top-to-bottom).
+ *
+ * @example
+ * // Bars stagger in from left to right over 250ms, each animating for 750ms
+ * { type: 'timing', duration: 750, staggerDelay: 250 }
+ */
+export type BarTransition = Transition & {
+  /**
+   * Maximum stagger delay (ms) distributed across bars by x position.
+   * Leftmost bar starts immediately, rightmost starts after this delay.
+   */
+  staggerDelay?: number;
+};
+/**
+ * Computes a bar's normalized [0, 1] position along the category axis, used for
+ * stagger-delay calculations.
+ *
+ * Vertical charts stagger left-to-right (x axis); horizontal charts stagger
+ * top-to-bottom (y axis). Returns 0 when the drawing area has no extent.
+ *
+ * @param layout - The layout of the chart
+ * @param x - Bar's left edge in pixels
+ * @param y - Bar's top edge in pixels
+ */
+export declare const getNormalizedStagger: (
+  layout: CartesianChartLayout,
+  x: number,
+  y: number,
+  drawingArea: Rect,
+) => number;
+/**
+ * Strips `staggerDelay` from a transition and computes a positional delay.
+ *
+ * @param transition - The transition config (may include staggerDelay)
+ * @param normalizedPosition - The bar's normalized position along the category axis (0–1)
+ * @returns A standard Transition with computed delay
+ */
+export declare const withStaggerDelayTransition: (
+  transition: BarTransition | null,
+  normalizedPosition: number,
+) => Transition | null;
+/**
+ * Default bar enter transition. Uses the default spring with a stagger delay
+ * so bars spring into place from left to right.
+ * `{ type: 'spring', stiffness: 900, damping: 120, staggerDelay: 250 }`
+ */
+export declare const defaultBarEnterTransition: BarTransition;
+/**
+ * Default bar enter opacity transition.
+ * `{ type: 'timing', duration: 200 }`
+ */
+export declare const defaultBarEnterOpacityTransition: BarTransition;
+/**
+ * Calculates the size adjustment needed for bars when accounting for gaps between them.
+ * This function helps determine how much to reduce each bar's width to accommodate
+ * the specified gap size between multiple bars in a group.
+ *
+ * @param barCount - The number of bars in the group
+ * @param gapSize - The desired gap size between bars
+ * @returns The amount to reduce each bar's size by, or 0 if there's only one bar
+ *
+ * @example
+ * ```typescript
+ * // For 3 bars with 12px gaps, each bar should be reduced by 8px
+ * const adjustment = getBarSizeAdjustment(3, 12);
+ *
+ * // Single bar needs no adjustment
+ * const singleBarAdjustment = getBarSizeAdjustment(1, 10);
+ * ```
+ */
+export declare function getBarSizeAdjustment(barCount: number, gapSize: number): number;
+type StackGroup = {
+  stackId: string;
+  series: BarSeries[];
+  xAxisId?: string;
+  yAxisId?: string;
+};
+/**
+ * Groups bar series into stack groups scoped by stackId + axis IDs.
+ *
+ * Series with no `stackId` are treated as independent stacks keyed by series id.
+ * Axis IDs are included in the group key so series on different axes never stack together.
+ */
+export declare function getStackGroups(series: BarSeries[], defaultAxisId?: string): StackGroup[];
+/**
+ * Computes stack clip origin [start, end] that covers the bounding box
+ * of all bars at their stacked starting positions (as computed by `getBarOrigins`).
+ *
+ * This is passed to `DefaultBarStack` so the clip animation starts in sync with the
+ * individual bar animations — no bars leak outside the clip on frame 0.
+ *
+ * @param barOrigins - Per-bar initial origins from `getBarOrigins`
+ * @param barMinSizes - Per-bar minimum sizes in pixels (or a uniform value)
+ * @returns [originStart, originEnd] or undefined when barMinSize is 0 / no bars
+ */
+export declare function getStackOrigin(
+  barOrigins: number[],
+  barMinSizes: number[] | number,
+): [number, number] | undefined;
+/**
+ * Computes the initial clip rect used for stack enter animations.
+ */
+export declare function getStackInitialClipRect(
+  stackRect: Rect,
+  layout: CartesianChartLayout,
+  origin?: number | [number, number],
+): Rect;
+/**
+ * Threshold for treating a position as touching the baseline.
+ * Positions within this distance are considered at the baseline for rounding purposes.
+ */
+export declare const EPSILON = 0.0001;
+/**
+ * Computes and clamps the value-axis baseline position in pixels.
+ *
+ * When `baseline` (data space) is omitted, the baseline is chosen heuristically from the scale domain:
+ * - If the full domain is positive, use domain min.
+ * - If the full domain is negative, use domain max.
+ * - If the domain crosses zero, use `0`.
+ * When `baseline` is set, that value is used as the data-space baseline instead.
+ *
+ * @param valueScale - Scale for the value axis
+ * @param stackRect - Bounding rect of the stack in pixels
+ * @param layout - Chart layout
+ * @param baseline - Optional value-axis baseline in data space
+ */
+export declare function getBaselinePx(
+  valueScale: ChartScaleFunction,
+  stackRect: Rect,
+  layout: CartesianChartLayout,
+  baseline?: number,
+): number;
+type SeriesGradientEntry =
+  | {
+      seriesId: string;
+      gradient: GradientDefinition;
+      scale: SerializableScale | ChartScaleFunction;
+      stops: GradientStop[];
+    }
+  | undefined;
+/**
+ * Computes the positioned bar entries and bounding rect for a single stack at one category index.
+ *
+ * This is the pure computation extracted from `BarStack`'s `useMemo` so it can be tested
+ * independently and reused across contexts.
+ *
+ * @param params.series - Series configs for this stack
+ * @param params.seriesData - Stacked data for each series, keyed by series id
+ * @param params.categoryIndex - Index of the category being rendered
+ * @param params.indexPos - Pixel position along the categorical axis
+ * @param params.thickness - Bar thickness in pixels
+ * @param params.valueScale - Scale function for the value axis
+ * @param params.seriesGradients - Precomputed gradient configs per series (undefined entries are skipped)
+ * @param params.roundBaseline - Whether to round the face touching the baseline
+ * @param params.layout - The layout of the chart
+ * @param params.baseline - Value-axis baseline in data space
+ * @param params.baselinePx - Pixel position of the value-axis baseline on the value axis
+ * @param params.stackGap - Gap between adjacent bars in pixels
+ * @param params.barMinSize - Minimum individual bar size in pixels
+ * @param params.stackMinSize - Minimum total stack size in pixels
+ * @param params.defaultFill - Fallback fill color when a series has no color or gradient
+ * @returns Positioned bar entries and the stack's bounding rect
+ */
+export declare function getBars(params: {
+  series: BarSeries[];
+  seriesData: Record<string, ([number, number] | null)[]>;
+  categoryIndex: number;
+  categoryValue: number;
+  indexPos: number;
+  thickness: number;
+  valueScale: ChartScaleFunction;
+  seriesGradients: SeriesGradientEntry[];
+  roundBaseline?: boolean;
+  layout: CartesianChartLayout;
+  baseline?: number;
+  baselinePx: number;
+  stackGap?: number;
+  barMinSize?: number;
+  stackMinSize?: number;
+  defaultFill: string;
+  borderRadius?: number;
+  defaultFillOpacity?: number;
+  defaultStroke?: string;
+  defaultStrokeWidth?: number;
+  defaultBarComponent?: BarComponent;
+}): {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  dataX: number | [number, number];
+  dataY: number | [number, number];
+  origin: number;
+  borderRadius: number | undefined;
+  fillOpacity: number | undefined;
+  stroke: string | undefined;
+  strokeWidth: number | undefined;
+  minSize: number;
+  BarComponent: BarComponent | undefined;
+  roundTop?: boolean;
+  roundBottom?: boolean;
+  seriesId: string;
+  fill?: string;
+  /** Position along the value axis in pixels (axis-agnostic, used by layout helpers). */
+  valuePos: number;
+  /** Size along the value axis in pixels (axis-agnostic, used by layout helpers). */
+  length: number;
+  /** The raw data value as [baseline, value], used by layout helpers for gap/rounding logic. */
+  dataValue: [number, number];
+  /** Whether gap distribution should be applied to this bar in a stack. */
+  shouldApplyGap?: boolean;
+}[];
+export {};
+//# sourceMappingURL=bar.d.ts.map