# chart-financial

> Financial chart with switchable candlestick, Hilo series, and time range filtering.

**Framework:** vue  **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/vue/chart-financial.json
```

**Install Package(s)**

```bash
npm install @syncfusion/ej2-vue-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/Financial.vue

```vue
<template>
    <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 class="stock-market-series-select" v-model="seriesType" aria-label="Select series type">
                <option v-for="option in seriesOptions" :key="option" :value="option">
                    {{ option === 'HiloOpenClose' ? 'Hilo Open/Close' : option }}
                </option>
            </select>

            <div class="stock-market-periods" role="group" aria-label="Select period range">
                <button v-for="period in periods" :key="period" type="button"
                    :class="['stock-market-period-button', { active: selectedPeriod === period }]"
                    :aria-pressed="selectedPeriod === period"
                    @click="selectedPeriod = period">
                    {{ period }}
                </button>
            </div>
        </div>

        <div class="stock-market-chart">
            <ejs-chart id="stock-market-analysis" height="450px" title="" background="transparent"
                :primaryXAxis="primaryXAxis" :primaryYAxis="primaryYAxis"
                :tooltip="tooltip" :crosshair="crosshair" :legendSettings="legendSettings">
                <e-axes>
                    <e-axis name="volumeYAxis" :opposedPosition="false" :minimum="0" :maximum="volumeMaximum * 5"
                        :majorGridLines="zeroLine" :lineStyle="zeroLine" :majorTickLines="zeroLine"
                        :labelStyle="transparentLabel"></e-axis>
                </e-axes>

                <e-series-collection>
                    <e-series :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="animation" :opacity="seriesType === 'Candle' ? 0.8 : 1" :width="2"></e-series>

                    <e-series :dataSource="visibleData" xName="date" yName="volume" name="Volume" type="Column"
                        yAxisName="volumeYAxis" fill="#90A4AE" :opacity="0.3" :enableTooltip="false"
                        :animation="animation"></e-series>
                </e-series-collection>
            </ejs-chart>
        </div>
    </div>
</template>

<script setup lang="ts">
import { computed, provide, ref } from 'vue';
import {
    ChartComponent as EjsChart,
    SeriesCollectionDirective as ESeriesCollection,
    SeriesDirective as ESeries,
    AxesDirective as EAxes,
    AxisDirective as EAxis,
    DateTime,
    CandleSeries,
    LineSeries,
    HiloSeries,
    HiloOpenCloseSeries,
    StepLineSeries,
    ColumnSeries,
    Tooltip,
    Crosshair,
    Legend,
    StripLine,
    type AxisModel,
    type StripLineSettingsModel,
    type TooltipSettingsModel,
    type CrosshairSettingsModel,
    type LegendSettingsModel,
    type AnimationModel
} from '@syncfusion/ej2-vue-charts';
import { stockData1Completed } from '../datasource/chart-data';

provide('chart', [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 periods: RangeType[] = ['1M', '3M', '6M', 'YTD', '1Y', 'All'];

const seriesOptions: SeriesType[] = ['Candle', 'Line', 'Hilo', 'HiloOpenClose', 'StepLine'];

const seriesType = ref<SeriesType>('Candle');
const selectedPeriod = ref<RangeType>('All');

const bullColor: string = '#43A047';
const bearColor: string = '#E53935';

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 axisRange = computed<DateRange>(() => {
    const end: Date = new Date(maxDate.getTime());
    const start: Date = new Date(end.getTime());

    switch (selectedPeriod.value) {
        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 visibleData = computed<StockData[]>(() =>
    allData.filter(
        (item: StockData) => item.date >= axisRange.value.minimum && item.date <= axisRange.value.maximum
    )
);

const priceRange = computed<{ minimum: number; maximum: number }>(() => {
    const lows: number[] = visibleData.value.map((item: StockData) => item.low);
    const highs: number[] = visibleData.value.map((item: StockData) => item.high);

    const minimum: number = Math.min(...lows);
    const maximum: number = Math.max(...highs);
    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 volumeMaximum = computed<number>(() =>
    Math.max(...visibleData.value.map((item: StockData) => item.volume), 1)
);

const primaryXAxis = computed<AxisModel>(() => {
    const isShortPeriod: boolean = selectedPeriod.value === '1M' || selectedPeriod.value === '3M';

    return {
        valueType: 'DateTime',
        minimum: axisRange.value.minimum,
        maximum: axisRange.value.maximum,
        labelFormat: isShortPeriod ? 'd MMM' : 'MMM yyyy',
        intervalType: isShortPeriod ? 'Days' : 'Months',
        edgeLabelPlacement: 'Shift',
        majorGridLines: { width: 0 },
        crosshairTooltip: { enable: true }
    };
});

const primaryYAxis = computed<AxisModel>(() => {
    const resistance: number = Math.max(...visibleData.value.map((item: StockData) => item.high));
    const support: number = Math.min(...visibleData.value.map((item: StockData) => item.low));

    const stripLines: StripLineSettingsModel[] = selectedPeriod.value === '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' }
        ]
        : [];

    return {
        minimum: priceRange.value.minimum,
        maximum: priceRange.value.maximum,
        opposedPosition: true,
        labelFormat: 'n2',
        majorGridLines: { width: 1, color: '#eeeeee' },
        crosshairTooltip: { enable: true },
        stripLines: stripLines
    };
});

const tooltip: TooltipSettingsModel = {
    enable: true,
    shared: true,
    enableMarker: false, // React sample used 'showMarker', which is not a TooltipSettings property
    format: '${series.name}: ${point.y}'
};

const crosshair: CrosshairSettingsModel = { enable: true, dashArray: '3,3', lineType: 'Both' };

const legendSettings: LegendSettingsModel = { visible: false };

const animation: AnimationModel = { enable: false };

const zeroLine: { width: number } = { width: 0 };

const transparentLabel: { color: string } = { color: 'transparent' };
</script>

<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>

```
