// ES Module - Works immediately with realistic demo data
    import TraceChart from 'trace-chart';

    // Basic setup with demo data
    const chart = new TraceChart('#chart-container', {
        theme: {
            backgroundColor: '#1a1a1a',
            bullishColor: '#26a69a', 
            bearishColor: '#ef5350'
        }
    });

    // Symbol selection (works with demo data too)
    chart.setSymbol('RELIANCE', 'NSE');
    chart.changeInterval('5min');
    chart.changeChartType('candlestick');

const chart = new TraceChart('#chart', {
    api: {
        baseURL: '/api/quotes',
        refreshInterval: 1000
    },
    demo: {
        enabled: false  // Use real data
    }
});

// Performance-optimized real-time updates
chart.setTick('RELIANCE', {
    lastPrice: 1500.75,
    volume: 1500000,
    timestamp: Date.now()
});

const chart = new TraceChart('#chart', {
    // Complete theme customization
    theme: {
        backgroundColor: '#ffffff',       // Light theme
        gridColor: '#e0e0e0',            // Subtle grid
        textColor: '#333333',            // Dark text
        bullishColor: '#00aa00',         // Green candles
        bearishColor: '#ff0000'          // Red candles
    },

    // Modular feature toggles
    features: {
        crosshairEnabled: true,
        tooltipEnabled: true,
        volumeEnabled: true,
        drawingEnabled: true,           // Disable to reduce bundle size
        indicatorsEnabled: true         // Disable if not needed
    }
});

// Streamlined setup for basic charts
const minimalChart = new TraceChart('#chart', {
    features: {
        drawingEnabled: false,          // Reduces bundle size
        indicatorsEnabled: false        // Further optimization
    },
    chartTypes: [
        { id: 'line', name: 'Line', default: true }  // Single chart type
    ],
    intervals: [
        { id: '1D', name: '1 Day', default: true }   // Single timeframe
    ]
});

// Optimized for high-frequency updates
const chart = new TraceChart('#chart', {
    api: {
        refreshInterval: 500,           // Balance between real-time and performance
        timeout: 10000,                 // Faster timeout
        retryAttempts: 1                // Quick failure recovery
    }
});

// Easy chart control
chart.setSymbol('INFY', 'NSE');
chart.changeInterval('5min');
chart.changeChartType('line');

// Simple indicator management
chart.addIndicator('sma', { period: 50 });
chart.removeIndicator('sma');

// Drawing tools
chart.setDrawingMode('rectangle');
chart.clearDrawings();

// Optimized real-time updates
chart.setTick('INFY', {
    lastPrice: 1500.50,
    volume: 1000000,
    timestamp: Date.now()
});

// Runtime customization
chart.updateConfig({ theme: { backgroundColor: '#fff' } });

// Clean resource management
chart.destroy();

import { BaseIndicator } from 'trace-chart';

class VWAPIndicator extends BaseIndicator {
    constructor(params = {}) {
        super('vwap', 'Volume Weighted Average Price', params, {
            color: '#ff9500',
            lineWidth: 2
        });
        
        // Efficient state tracking
        this.cumulativeVolumePrice = 0;
        this.cumulativeVolume = 0;
    }

    getDefaultParams() {
        return {
            period: 20,
            source: 'typical'
        };
    }

    // Full calculation for historical data
    calculate(ohlcvData) {
        const result = [];
        this.cumulativeVolumePrice = 0;
        this.cumulativeVolume = 0;
        
        for (let i = 0; i < ohlcvData.length; i++) {
            const candle = ohlcvData[i];
            const typicalPrice = (candle.high + candle.low + candle.close) / 3;
            const volume = candle.volume || 0;
            
            this.cumulativeVolumePrice += typicalPrice * volume;
            this.cumulativeVolume += volume;
            
            const vwap = this.cumulativeVolume > 0 ? 
                this.cumulativeVolumePrice / this.cumulativeVolume : typicalPrice;
            result.push(vwap);
        }
        
        return result;
    }

    // Performance-optimized single value calculation
    calculateSingleValue(ohlcvData, index) {
        const candle = ohlcvData[index];
        const typicalPrice = (candle.high + candle.low + candle.close) / 3;
        const volume = candle.volume || 0;
        
        // Incremental update
        this.cumulativeVolumePrice += typicalPrice * volume;
        this.cumulativeVolume += volume;
        
        return this.cumulativeVolume > 0 ? 
            this.cumulativeVolumePrice / this.cumulativeVolume : typicalPrice;
    }

    reset() {
        super.reset();
        this.cumulativeVolumePrice = 0;
        this.cumulativeVolume = 0;
    }
}

const chart = new TraceChart('#chart');
const indicatorFactory = chart.api.getChartEngine().indicatorFactory;

// Easy registration
indicatorFactory.register('vwap', VWAPIndicator);

// Use like built-in indicators
chart.addIndicator('vwap', { period: 0 });

class StochasticIndicator extends BaseIndicator {
    constructor(params = {}) {
        super('stochastic', 'Stochastic Oscillator', params);
        this.auxiliaryData.d = [];  // Additional data series
        this.kValues = [];          // Efficient value tracking
    }

    getDefaultParams() {
        return { kPeriod: 14, dPeriod: 3 };
    }

    // Automatic panel positioning
    getGridIndex(hasVolume = false) {
        return hasVolume ? 2 : 1;
    }

    // Optimized calculation
    calculate(ohlcvData) {
        const { kPeriod, dPeriod } = this.params;
        const kResult = [];
        const dResult = [];
        
        for (let i = 0; i < ohlcvData.length; i++) {
            if (i < kPeriod - 1) {
                kResult.push(null);
                dResult.push(null);
                continue;
            }
            
            // Efficient stochastic calculation
            const slice = ohlcvData.slice(i - kPeriod + 1, i + 1);
            const high = Math.max(...slice.map(d => d.high));
            const low = Math.min(...slice.map(d => d.low));
            const close = ohlcvData[i].close;
            
            const k = ((close - low) / (high - low)) * 100;
            kResult.push(k);
            this.kValues.push(k);
            
            // Simple moving average for %D
            if (this.kValues.length >= dPeriod) {
                const recentK = this.kValues.slice(-dPeriod);
                const d = recentK.reduce((sum, val) => sum + val, 0) / dPeriod;
                dResult.push(d);
            } else {
                dResult.push(null);
            }
        }
        
        this.auxiliaryData.d = dResult;
        return kResult;
    }

    // Multi-series rendering
    getSeries(xAxisIndex = 0, yAxisIndex = 0) {
        return [
            {
                type: 'line',
                name: 'Stochastic %K',
                data: this.data,
                xAxisIndex,
                yAxisIndex,
                lineStyle: { color: '#ff6b35', width: 2 },
                showSymbol: false
            },
            {
                type: 'line',
                name: 'Stochastic %D',
                data: this.auxiliaryData.d,
                xAxisIndex,
                yAxisIndex,
                lineStyle: { color: '#4ecdc4', width: 2 },
                showSymbol: false
            }
        ];
    }
}

import { TraceMarketHours } from 'trace-chart';

// Fully customizable market sessions
const marketHours = new TraceMarketHours({
    NSE: {
        name: 'NSE',
        timezone: 'Asia/Kolkata',
        rules: [
            { dayofweek: 1, open: '09:15', close: '15:30' },
            { dayofweek: 2, open: '09:15', close: '15:30' }
            // Easy to customize for any schedule
        ]
    }
});

// Simple market status checking
const isOpen = marketHours.isMarketOpen({
    tradingsymbol: 'INFY',
    segment: 'NSE'
});