funhi-chart 1.2.0 → 1.3.1

package/dist/dts/adapters/CandleStorageAdapter.d.ts

@@ -0,0 +1,14 @@
+/**
+ * CandleStorageAdapter - Handles loading/saving candles (wrapper around existing service)
+ */
+import { CandleData } from '../core/types';
+export declare class CandleStorageAdapter {
+    /**
+     * Loads candles from storage
+     */
+    loadCandles(mint: string, timeframeSeconds: number, limit?: number): Promise<CandleData[]>;
+    /**
+     * Saves candles to storage (if needed in future)
+     */
+    saveCandles(mint: string, timeframeSeconds: number, candles: CandleData[]): Promise<void>;
+}

package/dist/dts/components/FunhiChartOOP.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import type { ChartProps } from './FunhiChart';
+/**
+ * FunhiChartOOP - OOP-based implementation using FunhiChartController
+ * This version eliminates code duplication and uses clean OOP architecture
+ */
+declare const FunhiChartOOP: React.FC<ChartProps>;
+export default FunhiChartOOP;

package/dist/dts/core/CandleManager.d.ts

@@ -0,0 +1,73 @@
+/**
+ * CandleManager - Manages candle creation, updates, and validation for a single timeframe
+ * This class eliminates code duplication by handling all timeframe logic generically
+ */
+import { CandleData, CandleUpdateResult } from './types';
+export declare class CandleManager {
+    private timeframeSeconds;
+    private candles;
+    private currentCandle;
+    private lastCandleTime;
+    private lastProcessedTimestamp;
+    private readonly debounceMs;
+    constructor(timeframeSeconds: number);
+    /**
+     * Main method: Creates a new candle or updates the current one
+     */
+    createOrUpdate(price: number, timestamp: number): CandleUpdateResult | null;
+    /**
+     * Creates a new candle at bucket boundary
+     */
+    private createNewCandle;
+    /**
+     * Updates the current candle with new price data
+     */
+    private updateCurrentCandle;
+    /**
+     * Updates candle price while preserving minimum body size
+     */
+    private updateCandlePrice;
+    /**
+     * Builds a new candle with minimum body size enforcement
+     */
+    private buildNewCandle;
+    /**
+     * Gets the previous candle's close price
+     */
+    private getPreviousCandleClose;
+    /**
+     * Gets the previous candle's direction (1 for bullish, -1 for bearish)
+     */
+    private getPreviousCandleDirection;
+    /**
+     * Calculates bucket start time for a given timestamp
+     */
+    private calculateBucketStart;
+    /**
+     * Checks if a candle has valid data
+     */
+    private isValidCandle;
+    /**
+     * Adds a candle to history
+     */
+    private addCandleToHistory;
+    /**
+     * Updates a candle in history (only if it matches current bucket)
+     */
+    private updateCandleInHistory;
+    getCandles(): CandleData[];
+    getCurrentCandle(): CandleData | null;
+    getLastCandleTime(): number;
+    /**
+     * Loads candles from storage
+     */
+    loadCandles(candles: CandleData[]): void;
+    /**
+     * Directly updates candle from external source (e.g., WebSocket)
+     */
+    updateFromExternal(candle: CandleData, currentBucket: number): void;
+    /**
+     * Resets the manager (useful for cleanup)
+     */
+    reset(): void;
+}

package/dist/dts/core/ChartRenderer.d.ts

@@ -0,0 +1,46 @@
+/**
+ * ChartRenderer - Manages the lightweight-charts instance and rendering
+ */
+import { IChartApi, ISeriesApi } from 'lightweight-charts';
+import { CandleData, TimeFrame } from './types';
+export interface ChartOptions {
+    ticker?: string;
+    mint: string;
+    formatPrice: (value: number) => string;
+    height?: number;
+}
+export declare class ChartRenderer {
+    private chart;
+    private series;
+    private container;
+    private options;
+    constructor(container: HTMLDivElement, options: ChartOptions);
+    /**
+     * Initializes the chart
+     */
+    initialize(): void;
+    /**
+     * Updates chart data
+     */
+    updateData(candles: CandleData[]): void;
+    /**
+     * Sets the current timeframe (for future use if needed)
+     */
+    setTimeframe(timeframe: TimeFrame): void;
+    /**
+     * Resizes the chart
+     */
+    resize(): void;
+    /**
+     * Destroys the chart instance
+     */
+    destroy(): void;
+    /**
+     * Gets the chart instance (for advanced operations)
+     */
+    getChart(): IChartApi | null;
+    /**
+     * Gets the series instance (for advanced operations)
+     */
+    getSeries(): ISeriesApi<"Candlestick"> | null;
+}

package/dist/dts/core/FunhiChartController.d.ts

@@ -0,0 +1,61 @@
+import { CandleData, TimeFrame } from './types';
+export interface ControllerConfig {
+    mint: string;
+    ticker?: string;
+    tokenName?: string;
+    timeframes: TimeFrame[];
+    container: HTMLDivElement;
+    formatPrice: (value: number) => string;
+}
+export declare class FunhiChartController {
+    private chartRenderer;
+    private timeframeManager;
+    private storageAdapter;
+    private updateHandler;
+    private currentTimeframe;
+    private config;
+    constructor(config: ControllerConfig);
+    /**
+     * Initializes the chart and loads initial data
+     */
+    initialize(): Promise<void>;
+    /**
+     * Loads candles for a specific timeframe
+     */
+    loadTimeframeData(timeframeSeconds: number): Promise<void>;
+    /**
+     * Updates price for all timeframes
+     */
+    updatePrice(price: number): void;
+    /**
+     * Handles WebSocket update
+     */
+    handleSocketUpdate(data: {
+        mint: string;
+        candles: Record<string, any>;
+    }): void;
+    /**
+     * Switches to a different timeframe
+     */
+    switchTimeframe(seconds: number): Promise<void>;
+    /**
+     * Gets candles for current timeframe
+     */
+    getCurrentCandles(): CandleData[];
+    /**
+     * Gets current timeframe
+     */
+    getCurrentTimeframe(): TimeFrame;
+    /**
+     * Gets current candle for a specific timeframe
+     */
+    getCurrentCandle(seconds: number): CandleData | null;
+    /**
+     * Resizes the chart
+     */
+    resize(): void;
+    /**
+     * Destroys the controller and cleans up resources
+     */
+    destroy(): void;
+}

package/dist/dts/core/TimeframeManager.d.ts

@@ -0,0 +1,42 @@
+/**
+ * TimeframeManager - Orchestrates multiple timeframes and coordinates updates
+ */
+import { CandleManager } from './CandleManager';
+import { CandleData, TimeFrame } from './types';
+export declare class TimeframeManager {
+    private managers;
+    private timeframes;
+    constructor(timeframes: TimeFrame[]);
+    /**
+     * Gets the manager for a specific timeframe
+     */
+    getManager(seconds: number): CandleManager | undefined;
+    /**
+     * Updates all timeframes with new price data
+     */
+    updateAll(price: number, timestamp: number): void;
+    /**
+     * Gets candles for a specific timeframe
+     */
+    getCandles(seconds: number): CandleData[];
+    /**
+     * Gets current candle for a specific timeframe
+     */
+    getCurrentCandle(seconds: number): CandleData | null;
+    /**
+     * Loads candles for a specific timeframe
+     */
+    loadCandles(seconds: number, candles: CandleData[]): void;
+    /**
+     * Updates candle from external source (e.g., WebSocket)
+     */
+    updateFromExternal(seconds: number, candle: CandleData, currentBucket: number): void;
+    /**
+     * Gets all available timeframes
+     */
+    getTimeframes(): TimeFrame[];
+    /**
+     * Resets all managers
+     */
+    reset(): void;
+}

package/dist/dts/core/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Core exports for FunhiChart OOP architecture
+ */
+export * from './types';
+export * from './CandleManager';
+export * from './TimeframeManager';
+export * from './ChartRenderer';
+export * from './FunhiChartController';

package/dist/dts/core/types.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Core types for FunhiChart OOP architecture
+ */
+export interface CandleData {
+    time: number;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    volume: number;
+}
+export interface TimeFrame {
+    label: string;
+    value: string;
+    seconds: number;
+}
+export type { TimeFrame as TimeFrameType };
+export interface ChartConfig {
+    mint: string;
+    ticker?: string;
+    tokenName?: string;
+    timeframes: TimeFrame[];
+    container: HTMLDivElement;
+}
+export interface CandleManagerConfig {
+    timeframeSeconds: number;
+    mint: string;
+}
+export interface CandleUpdateResult {
+    candle: CandleData | null;
+    isNewCandle: boolean;
+    wasUpdated: boolean;
+}

package/dist/dts/handlers/RealTimeUpdateHandler.d.ts

@@ -0,0 +1,29 @@
+/**
+ * RealTimeUpdateHandler - Handles real-time price updates and WebSocket events
+ */
+import { TimeframeManager } from '../core/TimeframeManager';
+export declare class RealTimeUpdateHandler {
+    private timeframeManager;
+    private debounceMs;
+    private lastUpdate;
+    constructor(timeframeManager: TimeframeManager);
+    /**
+     * Handles price update from real-time data
+     */
+    handlePriceUpdate(price: number, timestamp: number): void;
+    /**
+     * Handles WebSocket update with pre-calculated candles
+     */
+    handleSocketUpdate(data: {
+        mint: string;
+        candles: Record<string, any>;
+    }, mint: string): void;
+    /**
+     * Debounce check
+     */
+    private debounce;
+    /**
+     * Converts timeframe key to seconds
+     */
+    private getTimeframeSeconds;
+}

package/dist/dts/index.d.ts

@@ -7,6 +7,7 @@
  * @packageDocumentation
  */
 export { default as FunhiChart } from './components/FunhiChart';
+export { default as FunhiChartOOP } from './components/FunhiChartOOP';
 export type { ChartProps } from './components/FunhiChart';
 export { useSocket } from './hooks/useSocket';
 export { useOptimizedTokenAnalytics } from './hooks/useOptimizedTokenAnalytics';

package/dist/dts/validators/CandleValidator.d.ts

@@ -0,0 +1,38 @@
+/**
+ * CandleValidator - Validates and enforces candle data integrity
+ */
+import { CandleData } from '../core/types';
+export declare class CandleValidator {
+    /**
+     * Minimum body size as percentage of price (0.01%)
+     */
+    private static readonly MIN_BODY_PERCENTAGE;
+    /**
+     * Absolute minimum body size in price units
+     */
+    private static readonly MIN_BODY_ABSOLUTE;
+    /**
+     * Validates if a candle has valid OHLC data
+     */
+    static validate(candle: CandleData): boolean;
+    /**
+     * Ensures candle has minimum body size for visibility
+     */
+    static ensureMinimumBodySize(candle: CandleData, minBodySize?: number): CandleData;
+    /**
+     * Validates and corrects OHLC data integrity
+     */
+    static validateOHLC(candle: CandleData): CandleData;
+    /**
+     * Checks if a candle belongs to the current time bucket
+     */
+    static isCurrentBucket(candle: CandleData, timeframeSeconds: number, timestamp: number): boolean;
+    /**
+     * Validates price data
+     */
+    static validatePrice(price: number): boolean;
+    /**
+     * Calculates minimum body size for a given price
+     */
+    static calculateMinBodySize(price: number): number;
+}

package/dist/index.d.ts

@@ -14,6 +14,12 @@ interface ChartProps {
 }
 declare const FunhiChart: React.FC<ChartProps>;
 
+/**
+ * FunhiChartOOP - OOP-based implementation using FunhiChartController
+ * This version eliminates code duplication and uses clean OOP architecture
+ */
+declare const FunhiChartOOP: React.FC<ChartProps>;
+
 interface OHLCVCandle {
     time: number;
     open: number;
@@ -291,5 +297,5 @@ declare const API_CONFIG: {
     readonly RETRY_DELAY: 1000;
 };
 
-export { API_CONFIG, FunhiChart, candleAggregation, candleStorageService, useOptimizedTokenAnalytics, useSocket };
+export { API_CONFIG, FunhiChart, FunhiChartOOP, candleAggregation, candleStorageService, useOptimizedTokenAnalytics, useSocket };
 export type { CandleData$1 as CandleData, ChartProps, GetCandlesRequest, SaveCandleRequest, SaveCandlesRequest, TimeFrame };