# YAxis

**📖 Live documentation:** https://cds.coinbase.com/components/charts/YAxis/

A vertical axis component for CartesianChart. Displays tick marks, labels, gridlines, and supports custom formatting, positioning, and data domains.

## Import

```tsx
import { YAxis } from '@coinbase/cds-web/visualizations/chart'
```

## Examples

### Basic Example

The YAxis component provides a vertical axis for charts with automatic tick generation and labeling.

```jsx live
<CartesianChart
  enableScrubbing
  height={250}
  series={[
    {
      id: 'prices',
      data: [10, 22, 29, 45, 98, 45, 22, 52, 21, 4, 68, 20, 21, 58],
    },
  ]}
>
  <YAxis showGrid />
  <Line seriesId="prices" showArea />
  <Scrubber />
</CartesianChart>
```

### Axis Config

Properties related to the scale of an axis are set on the Chart component. This includes `scaleType`, `domain`, `domainLimit`, `range`, `data`, and `categoryPadding`.

#### Scale Type

YAxis supports `linear` (default) and `log` scale types. Both `linear` and `log` are numeric scales.

```jsx live
<CartesianChart
  height={400}
  series={[
    {
      id: 'growthExponential',
      data: [
        1, 2, 4, 8, 15, 30, 65, 140, 280, 580, 1200, 2400, 4800, 9500, 19000, 38000, 75000, 150000,
      ],
      color: 'var(--color-fgPositive)',
    },
  ]}
  yAxis={{
    scaleType: 'log',
  }}
>
  <Line seriesId="growthExponential" showArea />
  <YAxis
    showGrid
    showLine
    showTickMarks
    requestedTickCount={6}
    width={70}
    tickLabelFormatter={(value) => value.toLocaleString()}
  />
</CartesianChart>
```

#### Domain

An axis's domain is the range of values that the axis will display.
You can pass in either an object (AxisBounds) with `min` and `max` properties (both optional), or a function that receives initial `AxisBounds` and returns an adjusted `AxisBounds`.

```jsx live
<CartesianChart
  height={250}
  series={[
    {
      id: 'prices',
      data: [10, 22, 29, 45, 98, 45, 22, 52, 21, 4, 68, 20, 21, 58],
    },
  ]}
  yAxis={{
    domain: ({ min, max }) => ({ min: min - 50, max: max + 50 }),
  }}
>
  <YAxis showGrid />
  <Line seriesId="prices" showArea />
</CartesianChart>
```

##### Domain Limit

You can set the domain limit to `nice` (default for YAxis) or `strict`. `nice` will round the domain to human-friendly values, while `strict` will use the exact min/max values from the data. See [d3-scale](https://d3js.org/d3-scale/linear#linear_nice) for more details.

#### Range

An axis's range is the range of values that the axis will display in pixels. This is most useful for adjusting the sizing of the data inside of the chart's drawing area.

You can pass in either an object (AxisBounds) with `min` and `max` properties (both optional), or a function that receives initial `AxisBounds` and returns an adjusted `AxisBounds`.

```jsx live
<CartesianChart
  height={250}
  series={[
    {
      id: 'prices',
      data: [10, 22, 29, 45, 98, 45, 22, 52, 21, 4, 68, 20, 21, 58],
    },
  ]}
  yAxis={{
    range: ({ min, max }) => ({ min: min + 96, max: max - 96 }),
  }}
>
  <Line seriesId="prices" showArea />
</CartesianChart>
```

### Axis Props

Properties related to the visual appearance of the YAxis are set on the component itself. This includes `position`, `showGrid`, `showLine`, `showTickMarks`, `size`, `tickInterval`, `ticks`, `tickLabelFormatter`, and `tickMarkSize`.

#### Position

You can set the position of an axis to `left` or `right` (default).

```jsx live
<CartesianChart
  enableScrubbing
  height={512}
  series={[
    {
      id: 'linear',
      yAxisId: 'linearAxis',
      data: [1, 10, 30, 50, 70, 90, 100],
      label: 'linear',
    },
    { id: 'log', yAxisId: 'logAxis', data: [1, 10, 30, 50, 70, 90, 100], label: 'log' },
  ]}
  xAxis={[{ data: [1, 10, 30, 50, 70, 90, 100] }]}
  yAxis={[
    { id: 'linearAxis', scaleType: 'linear' },
    { id: 'logAxis', scaleType: 'log' },
  ]}
>
  <YAxis showLine showTickMarks axisId="logAxis" position="left" />
  <YAxis showLine showTickMarks axisId="linearAxis" />
  <Line curve="natural" seriesId="linear" />
  <Line curve="natural" seriesId="log" />
  <Scrubber />
</CartesianChart>
```

When `layout="horizontal"`, CartesianChart supports only one y-axis configuration.

#### Grid

You can show grid lines at each tick position using the `showGrid` prop.

```jsx live
function YAxisGridExample() {
  const [showGrid, setShowGrid] = useState(true);
  return (
    <VStack gap={2}>
      <HStack gap={2} style={{ flexWrap: 'wrap' }}>
        <Switch checked={showGrid} onChange={() => setShowGrid(!showGrid)}>
          Show Grid
        </Switch>
      </HStack>
      <CartesianChart
        enableScrubbing
        height={250}
        series={[
          {
            id: 'prices',
            data: [10, 22, 29, 45, 98, 45, 22, 52, 21, 4, 68, 20, 21, 58],
          },
        ]}
      >
        <YAxis showGrid={showGrid} />
        <Line seriesId="prices" showArea />
        <Scrubber />
      </CartesianChart>
    </VStack>
  );
}
```

You can also customize the grid lines using the `GridLineComponent` prop.

```jsx live
function CustomGridLineExample() {
  const ThinSolidLine = memo((props) => <SolidLine {...props} strokeWidth={1} />);

  const categories = Array.from({ length: 31 }, (_, i) => `3/${i + 1}`);
  const gains = [
    5, 0, 6, 18, 0, 5, 12, 0, 12, 22, 28, 18, 0, 12, 6, 0, 0, 24, 0, 0, 4, 0, 18, 0, 0, 14, 10, 16,
    0, 0, 0,
  ];
  const losses = [
    -4, 0, -8, -12, -6, 0, 0, 0, -18, 0, -12, 0, -9, -6, 0, 0, 0, 0, -22, -8, 0, 0, -10, -14, 0, 0,
    0, 0, 0, -12, -10,
  ];
  const series = [
    { id: 'gains', data: gains, color: 'var(--color-fgPositive)', stackId: 'bars' },
    { id: 'losses', data: losses, color: 'var(--color-fgNegative)', stackId: 'bars' },
  ];

  return (
    <CartesianChart
      height={420}
      padding={4}
      series={series}
      xAxis={{ data: categories, scaleType: 'band' }}
    >
      <XAxis />
      <YAxis
        showGrid
        GridLineComponent={ThinSolidLine}
        tickLabelFormatter={(value) => `$${value}M`}
      />
      <BarPlot />
      <ReferenceLine LineComponent={SolidLine} dataY={0} />
    </CartesianChart>
  );
}
```

#### Line

You can show the axis line using the `showLine` prop.

```jsx live
function YAxisLineExample() {
  const [showLine, setShowLine] = useState(true);
  return (
    <VStack gap={2}>
      <HStack gap={2} style={{ flexWrap: 'wrap' }}>
        <Switch checked={showLine} onChange={() => setShowLine(!showLine)}>
          Show Line
        </Switch>
      </HStack>
      <CartesianChart
        enableScrubbing
        height={250}
        series={[
          {
            id: 'prices',
            data: [10, 22, 29, 45, 98, 45, 22, 52, 21, 4, 68, 20, 21, 58],
          },
        ]}
      >
        <YAxis showLine={showLine} />
        <Line seriesId="prices" showArea />
        <Scrubber />
      </CartesianChart>
    </VStack>
  );
}
```

You can also customize the axis line using the `classNames` and `styles` props.

```jsx live
function YAxisLineStylesExample() {
  const [showLine, setShowLine] = useState(true);
  return (
    <VStack gap={2}>
      <HStack gap={2} style={{ flexWrap: 'wrap' }}>
        <Switch checked={showLine} onChange={() => setShowLine(!showLine)}>
          Show Line
        </Switch>
      </HStack>
      <CartesianChart
        enableScrubbing
        height={250}
        series={[
          {
            id: 'prices',
            data: [10, 22, 29, 45, 98, 45, 22, 52, 21, 4, 68, 20, 21, 58],
          },
        ]}
      >
        <YAxis
          showLine={showLine}
          showGrid
          styles={{ line: { stroke: 'var(--color-accentBoldGreen)', strokeWidth: 4 } }}
        />
        <Line seriesId="prices" showArea />
        <Scrubber />
      </CartesianChart>
    </VStack>
  );
}
```

#### Size

The `size` prop sets the size of the axis in pixels. The default is 44 for YAxis, but can be adjusted to fit the size of your data.

```jsx live
<CartesianChart
  height={400}
  series={[
    {
      id: 'growthExponential',
      data: [
        1, 2, 4, 8, 15, 30, 65, 140, 280, 580, 1200, 2400, 4800, 9500, 19000, 38000, 75000, 150000,
      ],
      color: 'var(--color-fgPositive)',
    },
  ]}
>
  <Line curve="natural" showArea seriesId="growthExponential" />
  <YAxis
    showGrid
    showLine
    showTickMarks
    requestedTickCount={6}
    width={70}
    tickLabelFormatter={(value) => value.toLocaleString()}
  />
</CartesianChart>
```

#### Ticks

You can use the `ticks`, `requestedTickCount` (default for YAxis), and `tickInterval` props to control the number and placement of ticks on the YAxis.

`ticks` accepts an array of numbers, which corresponds to the values of that axis that you would like to display ticks for.

```jsx live
<CartesianChart
  enableScrubbing
  height={250}
  series={[
    {
      id: 'prices',
      data: [10, 22, 29, 45, 98, 45, 22, 52, 21, 4, 68, 20, 21, 58],
    },
  ]}
>
  <YAxis showLine showTickMarks showGrid ticks={[34, 56, 80]} />
  <Line seriesId="prices" showArea />
  <Scrubber />
</CartesianChart>
```

Using `requestedTickCount` will use [D3's ticks function](https://d3js.org/d3-array/ticks#ticks) to determine the number and placement of ticks. Note that this count is not guaranteed to be respected.

This is the default behavior for YAxis, and defaults to `5`.

```jsx live
<CartesianChart
  enableScrubbing
  height={250}
  series={[
    {
      id: 'prices',
      data: [10, 22, 29, 45, 98, 45, 22, 52, 21, 4, 68, 20, 21, 58],
    },
  ]}
>
  <YAxis showLine showTickMarks showGrid requestedTickCount={5} />
  <Line seriesId="prices" showArea />
  <Scrubber />
</CartesianChart>
```

`tickInterval`, which accepts a number for the gap between ticks in pixels, will measure the available space and try to create evenly spaced ticks. It will always include the first and last values of the domain.

```jsx live
<CartesianChart
  enableScrubbing
  height={250}
  series={[
    {
      id: 'prices',
      data: [10, 22, 29, 45, 98, 45, 22, 52, 21, 4, 68, 20, 21, 58],
    },
  ]}
>
  <YAxis showLine showTickMarks showGrid tickInterval={8} />
  <Line seriesId="prices" showArea />
  <Scrubber />
</CartesianChart>
```

#### Tick Marks

You can show tick marks on the axis using the `showTickMarks` prop.
You can also customize the tick mark size using the `tickMarkSize` prop.

```jsx live
function YAxisTickMarksExample() {
  const [showTickMarks, setShowTickMarks] = useState(true);
  return (
    <VStack gap={2}>
      <HStack gap={2} style={{ flexWrap: 'wrap' }}>
        <Switch checked={showTickMarks} onChange={() => setShowTickMarks(!showTickMarks)}>
          Show Tick Marks
        </Switch>
      </HStack>
      <CartesianChart
        enableScrubbing
        height={250}
        series={[
          {
            id: 'prices',
            data: [10, 22, 29, 45, 98, 45, 22, 52, 21, 4, 68, 20, 21, 58],
          },
        ]}
      >
        <YAxis showLine showTickMarks={showTickMarks} tickMarkSize={16} showGrid />
        <Line seriesId="prices" showArea />
        <Scrubber />
      </CartesianChart>
    </VStack>
  );
}
```

#### Tick Labels

You can customize the tick labels using the `tickLabelFormatter` prop.

```jsx live
<CartesianChart
  enableScrubbing
  height={250}
  series={[
    {
      id: 'prices',
      data: [10, 22, 29, 45, 98, 45, 22, 52, 21, 4, 68, 20, 21, 58],
    },
  ]}
>
  <YAxis showGrid tickLabelFormatter={(value) => `$${value}`} />
  <Line seriesId="prices" showArea />
  <Scrubber />
</CartesianChart>
```

#### Label

You can add a label to the axis using the `label` prop.

```jsx live
<CartesianChart
  enableScrubbing
  height={250}
  series={[
    {
      id: 'prices',
      data: [10, 22, 29, 45, 98, 45, 22, 52, 21, 4, 68, 20, 21, 58],
    },
  ]}
>
  <YAxis showGrid label="Price ($)" tickLabelFormatter={(value) => `$${value}`} />
  <Line seriesId="prices" showArea />
  <Scrubber />
</CartesianChart>
```

##### Custom Tick Labels

You can create custom tick label components using the `TickLabelComponent` prop for advanced styling and positioning that works cross-platform.

```jsx live
function CustomTickLabelExample() {
  const CustomYAxisTickLabel = useCallback(
    (props) => <DefaultAxisTickLabel {...props} dx={4} dy={-12} horizontalAlignment="left" />,
    [],
  );

  return (
    <CartesianChart
      enableScrubbing
      height={250}
      series={[
        {
          id: 'prices',
          data: [10, 22, 29, 45, 98, 45, 22, 52, 21, 4, 68, 20, 21, 58],
        },
      ]}
    >
      <YAxis
        showGrid
        position="left"
        width={0}
        tickLabelFormatter={(value) => `$${value}`}
        TickLabelComponent={CustomYAxisTickLabel}
      />
      <Line seriesId="prices" showArea />
      <Scrubber />
    </CartesianChart>
  );
}
```

### Customization

#### Multiple Y Axes

```jsx live
<CartesianChart
  height={400}
  series={[
    {
      id: 'revenue',
      data: [455, 520, 380, 455, 285, 235],
      yAxisId: 'revenue',
      color: 'var(--color-accentBoldYellow)',
    },
    {
      id: 'profitMargin',
      data: [23, 20, 16, 38, 12, 9],
      yAxisId: 'profitMargin',
      color: 'var(--color-fgPositive)',
    },
  ]}
  xAxis={{
    data: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun'],
    scaleType: 'band',
  }}
  yAxis={[
    {
      id: 'revenue',
      domain: { min: 0 },
    },
    {
      id: 'profitMargin',
      domain: { min: 0, max: 100 },
    },
  ]}
  inset={{ left: 0, right: 0 }}
>
  <XAxis showLine showTickMarks label="Month" />
  <YAxis
    showGrid
    showLine
    showTickMarks
    axisId="revenue"
    position="left"
    label="Revenue"
    width={80}
    requestedTickCount={5}
    tickLabelFormatter={(value) => `$${value}k`}
  />
  <YAxis
    showLine
    showTickMarks
    axisId="profitMargin"
    label="Profit Margin"
    width={70}
    requestedTickCount={5}
    tickLabelFormatter={(value) => `${value}%`}
  />
  <BarPlot />
</CartesianChart>
```

## Props

| Prop | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| `GridLineComponent` | `LineComponent` | No | `DottedLine` | Component to render the grid lines. |
| `LineComponent` | `LineComponent` | No | `SolidLine` | Component to render the axis line. |
| `TickLabelComponent` | `AxisTickLabelComponent` | No | `DefaultAxisTickLabel` | Component to render tick labels. Allows for custom styling and formatting that works cross-platform. |
| `TickMarkLineComponent` | `LineComponent` | No | `SolidLine` | Component to render the tick marks. |
| `axisId` | `string` | No | `-` | The ID of the axis to render. Defaults to defaultAxisId if not specified. |
| `bandGridLinePlacement` | `end \| start \| middle \| edges` | No | `'edges'` | Placement of grid lines relative to each band. Options: start, middle, end, edges |
| `bandTickMarkPlacement` | `end \| start \| middle \| edges` | No | `'middle'` | Placement of tick marks relative to each band. Options: start, middle, end, edges |
| `className` | `string` | No | `-` | Custom className for the axis. |
| `classNames` | `{ root?: string; label?: string \| undefined; tickLabel?: string \| undefined; gridLine?: string \| undefined; line?: string \| undefined; tickMark?: string \| undefined; } \| undefined` | No | `-` | Custom classNames for the axis. |
| `label` | `string` | No | `-` | Label text to display for the axis. |
| `labelGap` | `number` | No | `4` | Gap between the tick labels and the axis label. |
| `minTickLabelGap` | `number` | No | `4` | Minimum gap between tick labels. Labels will be hidden if they are closer than this gap. |
| `position` | `left \| right` | No | `'right'` | The position of the axis relative to the charts drawing area. |
| `requestedTickCount` | `number` | No | `5 for value axes by layout: - X axis when chart layout is horizontal - Y axis when chart layout is vertical` | Requested number of ticks to display. This value is passed into d3 and may not be respected. |
| `showGrid` | `boolean` | No | `-` | Whether to show grid lines at each tick position. |
| `showLine` | `boolean` | No | `-` | Whether to show the axis line. |
| `showTickMarks` | `boolean` | No | `-` | Whether to show tick marks on the axis. |
| `style` | `CSSProperties` | No | `-` | Custom style for the axis. |
| `styles` | `{ root?: CSSProperties; label?: CSSProperties \| undefined; tickLabel?: CSSProperties \| undefined; gridLine?: CSSProperties \| undefined; line?: CSSProperties \| undefined; tickMark?: CSSProperties \| undefined; } \| undefined` | No | `-` | Custom styles for the axis. |
| `testID` | `string` | No | `-` | Used to locate this element in unit and end-to-end tests. Under the hood, testID translates to data-testid on Web. On Mobile, testID stays the same - testID |
| `tickInterval` | `number` | No | `32 (for x-axis)` | Interval at which to show ticks. When provided, calculates tick count based on available space. |
| `tickLabelFormatter` | `((value: number) => ChartTextChildren)` | No | `-` | Formatter function for axis tick values. Tick values will be wrapped in ChartText component.  For band scales with string data, the value will be the string label (e.g., Jan, Feb). For numeric scales, the value will be the number. |
| `tickMarkLabelGap` | `number` | No | `2 for x-axis, 8 for y-axis` | Space between the axis tick mark and labels. If tick marks are not shown, this is the gap between the axis and the chart. |
| `tickMarkSize` | `number` | No | `4` | Size of the tick marks. |
| `tickMaxStep` | `number` | No | `-` | Maximum step size for tick generation. Prevents the step from being larger than this value. |
| `tickMinStep` | `number` | No | `1` | Minimum step size for tick generation. Prevents the step from being smaller than this value. |
| `ticks` | `number[] \| ((value: number) => boolean)` | No | `-` | Custom tick configuration for the axis. When provided, this overrides the requestedTickCount property.  - **Array**: Uses these exact values for tick positioning and labels. - **Function**: Filters based on the predicate function.   - For **x-axis**: Checks every data index (0, 1, 2, ..., dataLength-1)   - For **y-axis**: Filters d3-generated tick values |
| `width` | `number` | No | `44 when no label is provided, 64 when a label is provided` | Width of the axis. This value is inclusive of the padding. |


