# chart-financial

> Financial chart with switchable candlestick, Hilo series, and time range filtering.

**Framework:** javascript  **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/javascript/chart-financial.json
```

**Install Package(s)**

```bash
npm install @syncfusion/ej2-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/index.html

```html
<div class="stock-market-sample">
    <div class="stock-market-header">
        <h2>Acme Inc. Stock Market Analysis</h2>
        <p>Historical stock price and trading volume</p>
    </div>

    <div class="stock-market-toolbar">
        <select id="stock-market-series-select" class="stock-market-series-select" aria-label="Select series type">
            <option value="Candle" selected>Candle</option>
            <option value="Line">Line</option>
            <option value="Hilo">Hilo</option>
            <option value="HiloOpenClose">Hilo Open/Close</option>
            <option value="StepLine">StepLine</option>
        </select>

        <div id="stock-market-periods" class="stock-market-periods" role="group" aria-label="Select period range">
            <button type="button" class="stock-market-period-button" data-period="1M" aria-pressed="false">1M</button>
            <button type="button" class="stock-market-period-button" data-period="3M" aria-pressed="false">3M</button>
            <button type="button" class="stock-market-period-button" data-period="6M" aria-pressed="false">6M</button>
            <button type="button" class="stock-market-period-button" data-period="YTD" aria-pressed="false">YTD</button>
            <button type="button" class="stock-market-period-button" data-period="1Y" aria-pressed="false">1Y</button>
            <button type="button" class="stock-market-period-button active" data-period="All" aria-pressed="true">All</button>
        </div>
    </div>

    <div class="stock-market-chart">
        <div id="stock-market-analysis"></div>
    </div>
</div>

<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>

```

### src/components/chart-financial/index.ts

```typescript
import {
    Chart,
    DateTime,
    CandleSeries,
    LineSeries,
    HiloSeries,
    HiloOpenCloseSeries,
    StepLineSeries,
    ColumnSeries,
    Tooltip,
    Crosshair,
    Legend,
    StripLine,
    type AxisModel,
    type StripLineSettingsModel,
    type ChartSeriesType
} from '@syncfusion/ej2-charts';
import { stockData1Completed } from '../datasource/chart-data';

Chart.Inject(DateTime, CandleSeries, LineSeries, HiloSeries, HiloOpenCloseSeries, StepLineSeries, ColumnSeries, Tooltip, Crosshair, Legend, StripLine);

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;
}

interface DateRange {
    minimum: Date;
    maximum: Date;
}

const bullColor: string = '#43A047';
const bearColor: string = '#E53935';

let seriesType: SeriesType = 'Candle';
let selectedPeriod: RangeType = 'All';

const allData: StockData[] = stockData1Completed
    .map((item: StockData) => ({ ...item, date: new Date(item.date) }))
    .sort((a: StockData, b: StockData) => a.date.getTime() - b.date.getTime());

const minDate: Date = allData.length ? allData[0].date : new Date();
const maxDate: Date = allData.length ? allData[allData.length - 1].date : new Date();

const getAxisRange = (): DateRange => {
    const end: Date = new Date(maxDate.getTime());
    const start: Date = new Date(end.getTime());

    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 };
};

const getVisibleData = (range: DateRange): StockData[] =>
    allData.filter((item: StockData) => item.date >= range.minimum && item.date <= range.maximum);

const getPriceRange = (visibleData: StockData[]): { minimum: number; maximum: number } => {
    const minimum: number = Math.min(...visibleData.map((item: StockData) => item.low));
    const maximum: number = Math.max(...visibleData.map((item: StockData) => item.high));
    const padding: number = Math.max(1, (maximum - minimum) * 0.02);

    return {
        minimum: Math.floor((minimum - padding) / 20) * 20,
        maximum: Math.ceil((maximum + padding) / 20) * 20
    };
};

const getVolumeMaximum = (visibleData: StockData[]): number =>
    Math.max(...visibleData.map((item: StockData) => item.volume), 1);

const getStripLines = (visibleData: StockData[]): StripLineSettingsModel[] => {
    if (selectedPeriod !== 'All') {
        return [];
    }

    const resistance: number = Math.max(...visibleData.map((item: StockData) => item.high));
    const support: number = Math.min(...visibleData.map((item: StockData) => item.low));

    return [
        { 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 isShortPeriod = (): boolean => selectedPeriod === '1M' || selectedPeriod === '3M';

const initialRange: DateRange = getAxisRange();
const initialData: StockData[] = getVisibleData(initialRange);
const initialPrice: { minimum: number; maximum: number } = getPriceRange(initialData);

const primaryXAxis: AxisModel = {
    valueType: 'DateTime',
    minimum: initialRange.minimum,
    maximum: initialRange.maximum,
    labelFormat: isShortPeriod() ? 'd MMM' : 'MMM yyyy',
    intervalType: isShortPeriod() ? 'Days' : 'Months',
    edgeLabelPlacement: 'Shift',
    majorGridLines: { width: 0 },
    crosshairTooltip: { enable: true }
};

const primaryYAxis: AxisModel = {
    minimum: initialPrice.minimum,
    maximum: initialPrice.maximum,
    opposedPosition: true,
    labelFormat: 'n2',
    majorGridLines: { width: 1, color: '#eeeeee' },
    crosshairTooltip: { enable: true },
    stripLines: getStripLines(initialData)
};

const chart: Chart = new Chart({
    height: '450px',
    primaryXAxis: primaryXAxis,
    primaryYAxis: primaryYAxis,
    axes: [
        {
            name: 'volumeYAxis',
            opposedPosition: false,
            minimum: 0,
            maximum: getVolumeMaximum(initialData) * 5,
            majorGridLines: { width: 0 },
            lineStyle: { width: 0 },
            majorTickLines: { width: 0 },
            labelStyle: { color: 'transparent' }
        }
    ],
    tooltip: {
        enable: true,
        shared: true,
        enableMarker: false, // React sample used 'showMarker', which is not a TooltipSettings property
        format: '${series.name}: ${point.y}'
    },
    crosshair: { enable: true, dashArray: '3,3', lineType: 'Both' },
    legendSettings: { visible: false },
    title: '',
    background: 'transparent',
    series: [
        {
            dataSource: initialData,
            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
        },
        {
            dataSource: initialData,
            xName: 'date',
            yName: 'volume',
            name: 'Volume',
            type: 'Column',
            yAxisName: 'volumeYAxis',
            fill: '#90A4AE',
            opacity: 0.3,
            enableTooltip: false,
            animation: { enable: false }
        }
    ]
});
chart.appendTo('#stock-market-analysis');

// Re-applies the current series type / period selection to the chart.
const updateChart = (): void => {
    const range: DateRange = getAxisRange();
    const visibleData: StockData[] = getVisibleData(range);
    const priceRange: { minimum: number; maximum: number } = getPriceRange(visibleData);

    chart.primaryXAxis.minimum = range.minimum;
    chart.primaryXAxis.maximum = range.maximum;
    chart.primaryXAxis.labelFormat = isShortPeriod() ? 'd MMM' : 'MMM yyyy';
    chart.primaryXAxis.intervalType = isShortPeriod() ? 'Days' : 'Months';

    chart.primaryYAxis.minimum = priceRange.minimum;
    chart.primaryYAxis.maximum = priceRange.maximum;
    chart.primaryYAxis.stripLines = getStripLines(visibleData);

    chart.axes[0].maximum = getVolumeMaximum(visibleData) * 5;

    chart.series[0].type = seriesType as ChartSeriesType;
    chart.series[0].opacity = seriesType === 'Candle' ? 0.8 : 1;
    chart.series[0].dataSource = visibleData;
    chart.series[1].dataSource = visibleData;

    chart.refresh();
};

// Series type dropdown.
const seriesSelect: HTMLSelectElement = document.getElementById('stock-market-series-select') as HTMLSelectElement;
seriesSelect.addEventListener('change', (): void => {
    seriesType = seriesSelect.value as SeriesType;
    updateChart();
});

// Period range buttons.
const periodButtons: NodeListOf<HTMLButtonElement> =
    document.querySelectorAll('#stock-market-periods .stock-market-period-button');
periodButtons.forEach((button: HTMLButtonElement) => {
    button.addEventListener('click', (): void => {
        selectedPeriod = button.getAttribute('data-period') as RangeType;
        periodButtons.forEach((item: HTMLButtonElement) => {
            const isActive: boolean = item === button;
            item.classList.toggle('active', isActive);
            item.setAttribute('aria-pressed', String(isActive));
        });
        updateChart();
    });
});

```
