# chart-financial

> Financial chart with candlestick and line series for a multi-day stock trend.

**Framework:** react  **Component:** Chart  **Variant:** financial

## Get this item

**If you are an agent, fetch the JSON.** Source is inlined, so one request is enough and no tooling is required:

```
GET https://ai.syncfusion.com/r/react/ts/chart-financial.json
```

**Install Package(s)**

```bash
npm install @syncfusion/ej2-react-charts
```

**Notes**

- Syncfusion release: 2026 Volume 3 (v35.1.37)
- The Syncfusion package is licensed. The composition in this file is source you own and edit. See https://ai.syncfusion.com/licensing.md

## Source files

### src/components/chart-financial/Chart.tsx

```tsx
import { useMemo, useState } from 'react';
import {
    ChartComponent,
    SeriesCollectionDirective,
    SeriesDirective,
    AxesDirective,
    AxisDirective,
    Inject,
    DateTime,
    CandleSeries,
    LineSeries,
    HiloSeries,
    HiloOpenCloseSeries,
    StepLineSeries,
    ColumnSeries,
    Tooltip,
    Crosshair,
    Legend
} from '@syncfusion/ej2-react-charts';

import type { AxisModel } from '@syncfusion/ej2-react-charts';
import { stockData1Completed } from '../datasource/chart-data';

type SeriesType =
    | 'Candle'
    | 'Line'
    | 'Hilo'
    | 'HiloOpenClose'
    | 'StepLine';

type RangeType = '1M' | '3M' | '6M' | 'YTD' | '1Y' | 'All';

interface StockData {
    date: Date;
    open: number;
    high: number;
    low: number;
    close: number;
    volume: number;
}

const periods: RangeType[] = ['1M', '3M', '6M', 'YTD', '1Y', 'All'];

const seriesOptions: SeriesType[] = [
    'Candle',
    'Line',
    'Hilo',
    'HiloOpenClose',
    'StepLine'
];

export default function App() {
    const [seriesType, setSeriesType] = useState<SeriesType>('Candle');
    const [selectedPeriod, setSelectedPeriod] = useState<RangeType>('All');

    const bullColor = '#43A047';
    const bearColor = '#E53935';

    const allData = useMemo<StockData[]>(() => {
        return stockData1Completed
            .map((item) => ({
                ...item,
                date: new Date(item.date)
            }))
            .sort((a, b) => a.date.getTime() - b.date.getTime());
    }, []);

    const minDate = allData[0]?.date ?? new Date();
    const maxDate = allData[allData.length - 1]?.date ?? new Date();

    const axisRange = useMemo(() => {
        const end = new Date(maxDate);
        const start = new Date(end);

        switch (selectedPeriod) {
            case '1M':
                start.setMonth(end.getMonth() - 1);
                break;
            case '3M':
                start.setMonth(end.getMonth() - 3);
                break;
            case '6M':
                start.setMonth(end.getMonth() - 6);
                break;
            case 'YTD':
                start.setMonth(0, 1);
                start.setHours(0, 0, 0, 0);
                break;
            case '1Y':
                start.setFullYear(end.getFullYear() - 1);
                break;
            case 'All':
                return { minimum: minDate, maximum: maxDate };
        }

        return { minimum: start, maximum: end };
    }, [selectedPeriod, minDate, maxDate]);

    const visibleData = useMemo(() => {
        return allData.filter(
            (item) =>
                item.date >= axisRange.minimum &&
                item.date <= axisRange.maximum
        );
    }, [allData, axisRange]);

    const priceRange = useMemo(() => {
        const lows = visibleData.map((item) => item.low);
        const highs = visibleData.map((item) => item.high);

        const minimum = Math.min(...lows);
        const maximum = Math.max(...highs);
        const padding = Math.max(1, (maximum - minimum) * 0.02);

        return {
            minimum: Math.floor((minimum - padding) / 20) * 20,
            maximum: Math.ceil((maximum + padding) / 20) * 20
        };
    }, [visibleData]);

    const volumeMaximum = useMemo(
        () => Math.max(...visibleData.map((item) => item.volume), 1),
        [visibleData]
    );

    const resistance = Math.max(...visibleData.map((item) => item.high));
    const support = Math.min(...visibleData.map((item) => item.low));

    const primaryXAxis: AxisModel = {
        valueType: 'DateTime',
        minimum: axisRange.minimum,
        maximum: axisRange.maximum,
        labelFormat: selectedPeriod === '1M' || selectedPeriod === '3M'
            ? 'd MMM'
            : 'MMM yyyy',
        intervalType: selectedPeriod === '1M' || selectedPeriod === '3M'
            ? 'Days'
            : 'Months',
        edgeLabelPlacement: 'Shift',
        majorGridLines: { width: 0 },
        crosshairTooltip: { enable: true }
    };

    const primaryYAxis: AxisModel = {
        minimum: priceRange.minimum,
        maximum: priceRange.maximum,
        opposedPosition: true,
        labelFormat: 'n2',
        majorGridLines: { width: 1, color: '#eeeeee' },
        crosshairTooltip: { enable: true },
        stripLines: selectedPeriod === 'All'
            ? [
                {
                    start: support,
                    end: support + 0.1,
                    text: 'Support',
                    color: '#43A047',
                    visible: true,
                    opacity: 0.8,
                    dashArray: '3,3'
                },
                {
                    start: resistance - 0.1,
                    end: resistance,
                    text: 'Resistance',
                    color: '#E53935',
                    visible: true,
                    opacity: 0.8,
                    dashArray: '3,3'
                }
            ]
            : []
    };

    const tooltip = {
        enable: true,
        shared: true,
        showMarker: false,
        format: '${series.name}: ${point.y}'
    };

   const crosshair = {
    enable: true,
    dashArray: '3,3',
    lineType: 'Both' as const
};
    return (
        <>
            <style>{`
                .stock-market-sample {
                    box-sizing: border-box;
                    width: 100%;
                    height: calc(100vh - 105px);
                    min-height: 520px;
                    padding: 20px 24px 24px;
                    overflow-y: auto;
                    overflow-x: hidden;
                    background: #f8fafc;
                    scrollbar-gutter: stable;
                }

                .stock-market-header {
                    text-align: center;
                    margin: 2px 0 20px;
                }

                .stock-market-header h2 {
                    margin: 0 0 6px;
                    color: #172554;
                    font-size: 25px;
                    line-height: 1.3;
                    font-weight: 650;
                }

                .stock-market-header p {
                    margin: 0;
                    color: #64748b;
                    font-size: 14px;
                }

                .stock-market-toolbar {
                    display: flex;
                    align-items: center;
                    justify-content: space-between;
                    flex-wrap: wrap;
                    gap: 12px 16px;
                    width: 100%;
                    min-width: 0;
                    margin: 0 0 14px;
                }

                .stock-market-series-select {
                    box-sizing: border-box;
                    min-width: 155px;
                    height: 38px;
                    padding: 0 12px;
                    border: 1px solid #cbd5e1;
                    border-radius: 7px;
                    background: #fff;
                    color: #334155;
                    font-size: 14px;
                    outline: none;
                }

                .stock-market-series-select:focus-visible,
                .stock-market-period-button:focus-visible {
                    outline: 2px solid #38bdf8;
                    outline-offset: 2px;
                }

                .stock-market-periods {
                    display: flex;
                    align-items: center;
                    justify-content: flex-end;
                    flex-wrap: wrap;
                    gap: 7px;
                    min-width: 0;
                    max-width: 100%;
                }

                .stock-market-period-button {
                    flex: 0 0 auto;
                    min-width: 49px;
                    height: 36px;
                    padding: 0 13px;
                    border: 1px solid #dbe2ea;
                    border-radius: 7px;
                    background: #fff;
                    color: #475569;
                    font-size: 13px;
                    font-weight: 500;
                    cursor: pointer;
                    transition: background-color .15s ease, color .15s ease,
                                border-color .15s ease, box-shadow .15s ease;
                }

                .stock-market-period-button:hover {
                    border-color: #7dd3fc;
                    background: #f0f9ff;
                }

                .stock-market-period-button.active {
                    border-color: #0284c7;
                    background: #0284c7;
                    color: #fff;
                    box-shadow: 0 1px 3px rgba(2, 132, 199, .2);
                }

                .stock-market-chart {
                    width: 100%;
                    min-width: 0;
                    height: 470px;
                    padding: 8px 10px 4px;
                    box-sizing: border-box;
                    border: 1px solid #e2e8f0;
                    border-radius: 10px;
                    background: #fff;
                    box-shadow: 0 2px 8px rgba(15, 23, 42, .04);
                }

                .stock-market-chart .e-chart {
                    width: 100% !important;
                }

                @media (max-width: 900px) {
                    .stock-market-sample {
                        padding: 16px;
                    }

                    .stock-market-toolbar {
                        align-items: flex-start;
                        flex-direction: column;
                    }

                    .stock-market-periods {
                        justify-content: flex-start;
                    }
                }

                @media (max-width: 600px) {
                    .stock-market-sample {
                        height: calc(100vh - 90px);
                        min-height: 480px;
                        padding: 12px;
                    }

                    .stock-market-header h2 {
                        font-size: 21px;
                    }

                    .stock-market-chart {
                        height: 400px;
                        padding: 4px;
                    }

                    .stock-market-periods {
                        width: 100%;
                        justify-content: flex-start;
                    }
                }
            `}</style>

            <div className="stock-market-sample">
                <div className="stock-market-header">
                    <h2>Acme Inc. Stock Market Analysis</h2>
                    <p>Historical stock price and trading volume</p>
                </div>

                <div className="stock-market-toolbar">
                    <select
                        className="stock-market-series-select"
                        value={seriesType}
                        onChange={(event) =>
                            setSeriesType(event.target.value as SeriesType)
                        }
                        aria-label="Select series type"
                    >
                        {seriesOptions.map((option) => (
                            <option key={option} value={option}>
                                {option === 'HiloOpenClose'
                                    ? 'Hilo Open/Close'
                                    : option}
                            </option>
                        ))}
                    </select>

                    <div className="stock-market-periods" role="group" aria-label="Select period range">
                        {periods.map((period) => (
                            <button
                                key={period}
                                type="button"
                                className={`stock-market-period-button ${selectedPeriod === period ? 'active' : ''}`}
                                aria-pressed={selectedPeriod === period}
                                onClick={() => setSelectedPeriod(period)}
                            >
                                {period}
                            </button>
                        ))}
                    </div>
                </div>

                <div className="stock-market-chart">
            <ChartComponent
                id="stock-market-analysis"
                height="450px"
                primaryXAxis={primaryXAxis}
                primaryYAxis={primaryYAxis}
                tooltip={tooltip}
                crosshair={crosshair}
                legendSettings={{ visible: false }}
                title=""
                background="transparent"
            >
                <Inject services={[
                    DateTime,
                    CandleSeries,
                    LineSeries,
                    HiloSeries,
                    HiloOpenCloseSeries,
                    StepLineSeries,
                    ColumnSeries,
                    Tooltip,
                    Crosshair,
                    Legend
                ]} />

                <AxesDirective>
                    <AxisDirective
                        name="volumeYAxis"
                        opposedPosition={false}
                        minimum={0}
                        maximum={volumeMaximum * 5}
                        majorGridLines={{ width: 0 }}
                        lineStyle={{ width: 0 }}
                        majorTickLines={{ width: 0 }}
                        labelStyle={{ color: 'transparent' }}
                    />
                </AxesDirective>

                <SeriesCollectionDirective>
                    <SeriesDirective
                        dataSource={visibleData}
                        xName="date"
                        name="Stock Price"
                        type={seriesType}
                        low="low"
                        high="high"
                        open="open"
                        close="close"
                        yName="close"
                        bullFillColor={bullColor}
                        bearFillColor={bearColor}
                        enableTooltip={true}
                        animation={{ enable: false }}
                        opacity={seriesType === 'Candle' ? 0.8 : 1}
                        width={2}
                    />

                    <SeriesDirective
                        dataSource={visibleData}
                        xName="date"
                        yName="volume"
                        name="Volume"
                        type="Column"
                        yAxisName="volumeYAxis"
                        fill="#90A4AE"
                        opacity={0.3}
                        enableTooltip={false}
                        animation={{ enable: false }}
                    />
                </SeriesCollectionDirective>
                </ChartComponent>
                </div>
            </div>
        </>
    );
}
```
