# chart-financial

> Financial chart with switchable candlestick, Hilo, and line series; time range filtering and trading volume.

**Framework:** angular  **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/angular/chart-financial.json
```

**Install Package(s)**

```bash
npm install @syncfusion/ej2-angular-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.component.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 class="stock-market-series-select" [value]="seriesType" (change)="onSeriesTypeChange($event)"
            aria-label="Select series type">
            @for (option of seriesOptions; track option) {
                <option [value]="option" [selected]="option === seriesType">{{ getOptionText(option) }}</option>
            }
        </select>

        <div class="stock-market-periods" role="group" aria-label="Select period range">
            @for (period of periods; track period) {
                <button type="button" class="stock-market-period-button"
                    [class.active]="selectedPeriod === period"
                    [attr.aria-pressed]="selectedPeriod === period"
                    (click)="onPeriodChange(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]="chartSeriesType"
                    low="low" high="high" open="open" close="close" yName="close"
                    [bullFillColor]="bullColor" [bearFillColor]="bearColor" [enableTooltip]="true"
                    [animation]="animation" [opacity]="seriesOpacity" [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>

```

### src/components/chart-financial/financial.component.ts

```typescript
import { Component, ViewEncapsulation } from '@angular/core';
import {
    ChartModule,
    DateTimeService,
    CandleSeriesService,
    LineSeriesService,
    HiloSeriesService,
    HiloOpenCloseSeriesService,
    StepLineSeriesService,
    ColumnSeriesService,
    TooltipService,
    CrosshairService,
    LegendService,
    StripLineService,
    type AxisModel,
    type StripLineSettingsModel,
    type TooltipSettingsModel,
    type CrosshairSettingsModel,
    type LegendSettingsModel,
    type AnimationModel,
    type ChartSeriesType
} from '@syncfusion/ej2-angular-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;
}

interface DateRange {
    minimum: Date;
    maximum: Date;
}

@Component({
    selector: 'app-financial',
    standalone: true,
    imports: [ChartModule],
    providers: [
        DateTimeService, CandleSeriesService, LineSeriesService, HiloSeriesService,
        HiloOpenCloseSeriesService, StepLineSeriesService, ColumnSeriesService,
        TooltipService, CrosshairService, LegendService, StripLineService
    ],
    templateUrl: './financial.component.html',
    styleUrls: ['../styles/financial.component.css'],
    encapsulation: ViewEncapsulation.None
})
export class FinancialComponent {
    public periods: RangeType[] = ['1M', '3M', '6M', 'YTD', '1Y', 'All'];

    public seriesOptions: SeriesType[] = ['Candle', 'Line', 'Hilo', 'HiloOpenClose', 'StepLine'];

    public seriesType: SeriesType = 'Candle';
    public selectedPeriod: RangeType = 'All';

    public bullColor: string = '#43A047';
    public bearColor: string = '#E53935';

    private allData: StockData[] = stockData1Completed
        .map((item: StockData) => ({ ...item, date: new Date(item.date) }))
        .sort((a: StockData, b: StockData) => a.date.getTime() - b.date.getTime());

    private minDate: Date = this.allData.length ? this.allData[0].date : new Date();
    private maxDate: Date = this.allData.length ? this.allData[this.allData.length - 1].date : new Date();

    // Values recomputed whenever the series type or period changes.
    public visibleData: StockData[] = [];
    public primaryXAxis: AxisModel = {};
    public primaryYAxis: AxisModel = {};
    public volumeMaximum: number = 1;
    public seriesOpacity: number = 0.8;

    public tooltip: TooltipSettingsModel = {
        enable: true,
        shared: true,
        enableMarker: false, // React sample used 'showMarker', which is not a TooltipSettings property
        format: '${series.name}: ${point.y}'
    };

    public crosshair: CrosshairSettingsModel = { enable: true, dashArray: '3,3', lineType: 'Both' };

    public legendSettings: LegendSettingsModel = { visible: false };

    public animation: AnimationModel = { enable: false };

    public zeroLine: { width: number } = { width: 0 };

    public transparentLabel: { color: string } = { color: 'transparent' };

    constructor() {
        this.updateChart();
    }

    public getOptionText(option: SeriesType): string {
        return option === 'HiloOpenClose' ? 'Hilo Open/Close' : option;
    }

    public get chartSeriesType(): ChartSeriesType {
        return this.seriesType as ChartSeriesType;
    }

    public onSeriesTypeChange(event: Event): void {
        this.seriesType = (event.target as HTMLSelectElement).value as SeriesType;
        this.updateChart();
    }

    public onPeriodChange(period: RangeType): void {
        this.selectedPeriod = period;
        this.updateChart();
    }

    private getAxisRange(): DateRange {
        const end: Date = new Date(this.maxDate.getTime());
        const start: Date = new Date(end.getTime());

        switch (this.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: this.minDate, maximum: this.maxDate };
        }

        return { minimum: start, maximum: end };
    }

    private updateChart(): void {
        const axisRange: DateRange = this.getAxisRange();
        const visibleData: StockData[] = this.allData.filter(
            (item: StockData) => item.date >= axisRange.minimum && item.date <= axisRange.maximum
        );

        const lows: number[] = visibleData.map((item: StockData) => item.low);
        const highs: number[] = visibleData.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);

        const resistance: number = maximum;
        const support: number = minimum;
        const isShortPeriod: boolean = this.selectedPeriod === '1M' || this.selectedPeriod === '3M';

        const stripLines: StripLineSettingsModel[] = this.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' }
            ]
            : [];

        this.visibleData = visibleData;
        this.volumeMaximum = Math.max(...visibleData.map((item: StockData) => item.volume), 1);
        this.seriesOpacity = this.seriesType === 'Candle' ? 0.8 : 1;

        this.primaryXAxis = {
            valueType: 'DateTime',
            minimum: axisRange.minimum,
            maximum: axisRange.maximum,
            labelFormat: isShortPeriod ? 'd MMM' : 'MMM yyyy',
            intervalType: isShortPeriod ? 'Days' : 'Months',
            edgeLabelPlacement: 'Shift',
            majorGridLines: { width: 0 },
            crosshairTooltip: { enable: true }
        };

        this.primaryYAxis = {
            minimum: Math.floor((minimum - padding) / 20) * 20,
            maximum: Math.ceil((maximum + padding) / 20) * 20,
            opposedPosition: true,
            labelFormat: 'n2',
            majorGridLines: { width: 1, color: '#eeeeee' },
            crosshairTooltip: { enable: true },
            stripLines: stripLines
        };
    }
}

```
