chart-library-native 1.0.0

package/src/index.ts

@@ -0,0 +1,51 @@
+// ============================================================================
+// 📄 bindings/react-native/src/index.ts
+// Main export - Simplified API cho 90% use cases
+// ============================================================================
+
+// ========== TIER 1: SIMPLIFIED API (No configuration needed) ==========
+
+export { 
+  useQuickMA,
+  useQuickEMA,
+  useQuickMACD,
+  useQuickRSI,
+  useQuickKDJ,
+  useQuickBollinger,
+  useQuickDMI
+} from './api/tier1';
+
+export { 
+  QuickIndicatorDisplay
+} from './api/tier1/components';
+
+// ========== TIER 2: ADVANCED API (Full customization) ==========
+
+export {
+  useMA,
+  useEMA,
+  useWMA,
+  useMACD,
+  useRSI,
+  useKDJ,
+  useBollinger,
+  useDMI,
+  useMultipleIndicators
+} from './hooks/useIndicators';
+
+// ========== TYPES ==========
+
+export type { 
+  CandleData, 
+  MAResult, 
+  MACDResult, 
+  KDJResult, 
+  BOLLResult, 
+  DMIResult 
+} from './types';
+
+// ========== LOW-LEVEL API (Direct JSI access) ==========
+
+// Re-export the low-level ChartLibrary for advanced users
+export { default as ChartLibrary } from '../index';
+

package/src/jsi_bindings.cpp

@@ -0,0 +1,532 @@
+// ============================================================================
+// 📄 bindings/react-native/src/jsi_bindings.cpp
+// Mục đích: React Native JSI bridge
+// Kết nối JavaScript → C API
+// ============================================================================
+
+#include <jsi/jsi.h>
+#include "../../core/c_api/chart_api.h"
+#include <cmath>
+#include <vector>
+
+using namespace facebook::jsi;
+
+// Helper: Convert JSI Array → C++ vector<double>
+static std::vector<double> jsArrayToVector(Runtime& rt, const Array& arr) {
+  std::vector<double> result;
+  size_t len = arr.size(rt);
+  for (size_t i = 0; i < len; ++i) {
+    Value v = arr.getValueAtIndex(rt, i);
+    if (v.isNumber()) {
+      result.push_back(v.asNumber());
+    } else if (v.isNull() || v.isUndefined()) {
+      result.push_back(std::nan(""));
+    } else {
+      result.push_back(std::nan(""));
+    }
+  }
+  return result;
+}
+
+// ============================================================================
+// JSI FUNCTION: calculateMA
+// ============================================================================
+void installCalculateMA(Runtime& rt, Object& module) {
+  module.setProperty(
+    rt,
+    "calculateMA",
+    Function::createFromHostFunction(
+      rt,
+      PropNameID::forAscii(rt, "calculateMA"),
+      2,  // closes[], period
+      [](Runtime& rt, const Value& thisVal, const Value* args, size_t count) -> Value {
+        if (count < 2) {
+          throw JSError(rt, "calculateMA requires 2 arguments: closes[], period");
+        }
+
+        Array closesArr = args[0].asObject(rt).asArray(rt);
+        int32_t period = (int32_t)args[1].asNumber();
+
+        auto closes_vec = jsArrayToVector(rt, closesArr);
+        
+        DoubleArrayResult cres = chart_calculate_ma(
+          closes_vec.data(),
+          closes_vec.size(),
+          period
+        );
+
+        if (cres.error != CHART_OK) {
+          chart_free_double_array_result(&cres);
+          throw JSError(rt, cres.message ? cres.message : "Unknown error");
+        }
+
+        Array jsResult(rt, cres.length);
+        for (size_t i = 0; i < cres.length; ++i) {
+          double val = cres.data[i];
+          if (std::isnan(val)) {
+            jsResult.setValueAtIndex(rt, i, Value::null());
+          } else {
+            jsResult.setValueAtIndex(rt, i, Value(val));
+          }
+        }
+        
+        chart_free_double_array_result(&cres);
+        return jsResult;
+      }
+    )
+  );
+}
+
+// ============================================================================
+// JSI FUNCTION: calculateEMA
+// ============================================================================
+void installCalculateEMA(Runtime& rt, Object& module) {
+  module.setProperty(
+    rt,
+    "calculateEMA",
+    Function::createFromHostFunction(
+      rt,
+      PropNameID::forAscii(rt, "calculateEMA"),
+      2,
+      [](Runtime& rt, const Value& thisVal, const Value* args, size_t count) -> Value {
+        if (count < 2) {
+          throw JSError(rt, "calculateEMA requires 2 arguments: closes[], period");
+        }
+
+        Array closesArr = args[0].asObject(rt).asArray(rt);
+        int32_t period = (int32_t)args[1].asNumber();
+
+        auto closes_vec = jsArrayToVector(rt, closesArr);
+        
+        DoubleArrayResult cres = chart_calculate_ema(
+          closes_vec.data(),
+          closes_vec.size(),
+          period
+        );
+
+        if (cres.error != CHART_OK) {
+          chart_free_double_array_result(&cres);
+          throw JSError(rt, cres.message ? cres.message : "Unknown error");
+        }
+
+        Array jsResult(rt, cres.length);
+        for (size_t i = 0; i < cres.length; ++i) {
+          double val = cres.data[i];
+          if (std::isnan(val)) {
+            jsResult.setValueAtIndex(rt, i, Value::null());
+          } else {
+            jsResult.setValueAtIndex(rt, i, Value(val));
+          }
+        }
+        
+        chart_free_double_array_result(&cres);
+        return jsResult;
+      }
+    )
+  );
+}
+
+// ============================================================================
+// JSI FUNCTION: calculateMACD
+// ============================================================================
+void installCalculateMACD(Runtime& rt, Object& module) {
+  module.setProperty(
+    rt,
+    "calculateMACD",
+    Function::createFromHostFunction(
+      rt,
+      PropNameID::forAscii(rt, "calculateMACD"),
+      4,  // closes[], fast, slow, signal
+      [](Runtime& rt, const Value& thisVal, const Value* args, size_t count) -> Value {
+        if (count < 4) {
+          throw JSError(rt, "calculateMACD requires 4 arguments");
+        }
+
+        Array closesArr = args[0].asObject(rt).asArray(rt);
+        int32_t fast = (int32_t)args[1].asNumber();
+        int32_t slow = (int32_t)args[2].asNumber();
+        int32_t signal = (int32_t)args[3].asNumber();
+
+        auto closes_vec = jsArrayToVector(rt, closesArr);
+        
+        MACDResult cres = chart_calculate_macd(
+          closes_vec.data(),
+          closes_vec.size(),
+          fast, slow, signal
+        );
+
+        if (cres.error != CHART_OK) {
+          chart_free_macd_result(&cres);
+          throw JSError(rt, cres.message ? cres.message : "Unknown error");
+        }
+
+        // Return object: { macd: [...], signal: [...], histogram: [...] }
+        Object jsResult(rt);
+        
+        Array macdArr(rt, cres.length);
+        for (size_t i = 0; i < cres.length; ++i) {
+          double val = cres.macd[i];
+          if (std::isnan(val)) {
+            macdArr.setValueAtIndex(rt, i, Value::null());
+          } else {
+            macdArr.setValueAtIndex(rt, i, Value(val));
+          }
+        }
+        jsResult.setProperty(rt, "macd", macdArr);
+
+        Array signalArr(rt, cres.length);
+        for (size_t i = 0; i < cres.length; ++i) {
+          double val = cres.signal[i];
+          if (std::isnan(val)) {
+            signalArr.setValueAtIndex(rt, i, Value::null());
+          } else {
+            signalArr.setValueAtIndex(rt, i, Value(val));
+          }
+        }
+        jsResult.setProperty(rt, "signal", signalArr);
+
+        Array histArr(rt, cres.length);
+        for (size_t i = 0; i < cres.length; ++i) {
+          double val = cres.histogram[i];
+          if (std::isnan(val)) {
+            histArr.setValueAtIndex(rt, i, Value::null());
+          } else {
+            histArr.setValueAtIndex(rt, i, Value(val));
+          }
+        }
+        jsResult.setProperty(rt, "histogram", histArr);
+
+        chart_free_macd_result(&cres);
+        return jsResult;
+      }
+    )
+  );
+}
+
+// ============================================================================
+// JSI FUNCTION: calculateRSI
+// ============================================================================
+void installCalculateRSI(Runtime& rt, Object& module) {
+  module.setProperty(
+    rt,
+    "calculateRSI",
+    Function::createFromHostFunction(
+      rt,
+      PropNameID::forAscii(rt, "calculateRSI"),
+      2,
+      [](Runtime& rt, const Value& thisVal, const Value* args, size_t count) -> Value {
+        if (count < 2) {
+          throw JSError(rt, "calculateRSI requires 2 arguments: closes[], period");
+        }
+
+        Array closesArr = args[0].asObject(rt).asArray(rt);
+        int32_t period = (int32_t)args[1].asNumber();
+
+        auto closes_vec = jsArrayToVector(rt, closesArr);
+        
+        DoubleArrayResult cres = chart_calculate_rsi(
+          closes_vec.data(),
+          closes_vec.size(),
+          period
+        );
+
+        if (cres.error != CHART_OK) {
+          chart_free_double_array_result(&cres);
+          throw JSError(rt, cres.message ? cres.message : "Unknown error");
+        }
+
+        Array jsResult(rt, cres.length);
+        for (size_t i = 0; i < cres.length; ++i) {
+          double val = cres.data[i];
+          if (std::isnan(val)) {
+            jsResult.setValueAtIndex(rt, i, Value::null());
+          } else {
+            jsResult.setValueAtIndex(rt, i, Value(val));
+          }
+        }
+        
+        chart_free_double_array_result(&cres);
+        return jsResult;
+      }
+    )
+  );
+}
+
+// ============================================================================
+// JSI FUNCTION: calculateKDJ
+// ============================================================================
+void installCalculateKDJ(Runtime& rt, Object& module) {
+  module.setProperty(
+    rt,
+    "calculateKDJ",
+    Function::createFromHostFunction(
+      rt,
+      PropNameID::forAscii(rt, "calculateKDJ"),
+      6,  // highs[], lows[], closes[], n, m1, m2
+      [](Runtime& rt, const Value& thisVal, const Value* args, size_t count) -> Value {
+        if (count < 6) {
+          throw JSError(rt, "calculateKDJ requires 6 arguments");
+        }
+
+        Array highsArr = args[0].asObject(rt).asArray(rt);
+        Array lowsArr = args[1].asObject(rt).asArray(rt);
+        Array closesArr = args[2].asObject(rt).asArray(rt);
+        int32_t n = (int32_t)args[3].asNumber();
+        int32_t m1 = (int32_t)args[4].asNumber();
+        int32_t m2 = (int32_t)args[5].asNumber();
+
+        auto highs_vec = jsArrayToVector(rt, highsArr);
+        auto lows_vec = jsArrayToVector(rt, lowsArr);
+        auto closes_vec = jsArrayToVector(rt, closesArr);
+        
+        KDJResult cres = chart_calculate_kdj(
+          highs_vec.data(),
+          lows_vec.data(),
+          closes_vec.data(),
+          closes_vec.size(),
+          n, m1, m2
+        );
+
+        if (cres.error != CHART_OK) {
+          chart_free_kdj_result(&cres);
+          throw JSError(rt, cres.message ? cres.message : "Unknown error");
+        }
+
+        Object jsResult(rt);
+        
+        Array kArr(rt, cres.length);
+        for (size_t i = 0; i < cres.length; ++i) {
+          double val = cres.k[i];
+          if (std::isnan(val)) {
+            kArr.setValueAtIndex(rt, i, Value::null());
+          } else {
+            kArr.setValueAtIndex(rt, i, Value(val));
+          }
+        }
+        jsResult.setProperty(rt, "k", kArr);
+
+        Array dArr(rt, cres.length);
+        for (size_t i = 0; i < cres.length; ++i) {
+          double val = cres.d[i];
+          if (std::isnan(val)) {
+            dArr.setValueAtIndex(rt, i, Value::null());
+          } else {
+            dArr.setValueAtIndex(rt, i, Value(val));
+          }
+        }
+        jsResult.setProperty(rt, "d", dArr);
+
+        Array jArr(rt, cres.length);
+        for (size_t i = 0; i < cres.length; ++i) {
+          double val = cres.j[i];
+          if (std::isnan(val)) {
+            jArr.setValueAtIndex(rt, i, Value::null());
+          } else {
+            jArr.setValueAtIndex(rt, i, Value(val));
+          }
+        }
+        jsResult.setProperty(rt, "j", jArr);
+
+        chart_free_kdj_result(&cres);
+        return jsResult;
+      }
+    )
+  );
+}
+
+// ============================================================================
+// JSI FUNCTION: calculateBOLL
+// ============================================================================
+void installCalculateBOLL(Runtime& rt, Object& module) {
+  module.setProperty(
+    rt,
+    "calculateBOLL",
+    Function::createFromHostFunction(
+      rt,
+      PropNameID::forAscii(rt, "calculateBOLL"),
+      3,  // closes[], period, k
+      [](Runtime& rt, const Value& thisVal, const Value* args, size_t count) -> Value {
+        if (count < 3) {
+          throw JSError(rt, "calculateBOLL requires 3 arguments: closes[], period, k");
+        }
+
+        Array closesArr = args[0].asObject(rt).asArray(rt);
+        int32_t period = (int32_t)args[1].asNumber();
+        double k = args[2].asNumber();
+
+        auto closes_vec = jsArrayToVector(rt, closesArr);
+        
+        BOLLResult cres = chart_calculate_boll(
+          closes_vec.data(),
+          closes_vec.size(),
+          period,
+          k
+        );
+
+        if (cres.error != CHART_OK) {
+          chart_free_boll_result(&cres);
+          throw JSError(rt, cres.message ? cres.message : "Unknown error");
+        }
+
+        Object jsResult(rt);
+        
+        Array upperArr(rt, cres.length);
+        for (size_t i = 0; i < cres.length; ++i) {
+          double val = cres.upper[i];
+          if (std::isnan(val)) {
+            upperArr.setValueAtIndex(rt, i, Value::null());
+          } else {
+            upperArr.setValueAtIndex(rt, i, Value(val));
+          }
+        }
+        jsResult.setProperty(rt, "upper", upperArr);
+
+        Array midArr(rt, cres.length);
+        for (size_t i = 0; i < cres.length; ++i) {
+          double val = cres.middle[i];
+          if (std::isnan(val)) {
+            midArr.setValueAtIndex(rt, i, Value::null());
+          } else {
+            midArr.setValueAtIndex(rt, i, Value(val));
+          }
+        }
+        jsResult.setProperty(rt, "middle", midArr);
+
+        Array lowerArr(rt, cres.length);
+        for (size_t i = 0; i < cres.length; ++i) {
+          double val = cres.lower[i];
+          if (std::isnan(val)) {
+            lowerArr.setValueAtIndex(rt, i, Value::null());
+          } else {
+            lowerArr.setValueAtIndex(rt, i, Value(val));
+          }
+        }
+        jsResult.setProperty(rt, "lower", lowerArr);
+
+        chart_free_boll_result(&cres);
+        return jsResult;
+      }
+    )
+  );
+}
+
+// ============================================================================
+// JSI FUNCTION: calculateDMI
+// ============================================================================
+void installCalculateDMI(Runtime& rt, Object& module) {
+  module.setProperty(
+    rt,
+    "calculateDMI",
+    Function::createFromHostFunction(
+      rt,
+      PropNameID::forAscii(rt, "calculateDMI"),
+      5,  // opens[], highs[], lows[], closes[], period
+      [](Runtime& rt, const Value& thisVal, const Value* args, size_t count) -> Value {
+        if (count < 5) {
+          throw JSError(rt, "calculateDMI requires 5 arguments");
+        }
+
+        Array opensArr = args[0].asObject(rt).asArray(rt);
+        Array highsArr = args[1].asObject(rt).asArray(rt);
+        Array lowsArr = args[2].asObject(rt).asArray(rt);
+        Array closesArr = args[3].asObject(rt).asArray(rt);
+        int32_t period = (int32_t)args[4].asNumber();
+
+        auto opens_vec = jsArrayToVector(rt, opensArr);
+        auto highs_vec = jsArrayToVector(rt, highsArr);
+        auto lows_vec = jsArrayToVector(rt, lowsArr);
+        auto closes_vec = jsArrayToVector(rt, closesArr);
+
+        // Build Candle array
+        std::vector<Candle> candles_c;
+        for (size_t i = 0; i < opens_vec.size(); ++i) {
+          Candle c;
+          c.open = opens_vec[i];
+          c.high = highs_vec[i];
+          c.low = lows_vec[i];
+          c.close = closes_vec[i];
+          candles_c.push_back(c);
+        }
+        
+        DMIResult cres = chart_calculate_dmi(
+          candles_c.data(),
+          candles_c.size(),
+          period
+        );
+
+        if (cres.error != CHART_OK) {
+          chart_free_dmi_result(&cres);
+          throw JSError(rt, cres.message ? cres.message : "Unknown error");
+        }
+
+        Object jsResult(rt);
+        
+        Array pdiArr(rt, cres.length);
+        for (size_t i = 0; i < cres.length; ++i) {
+          double val = cres.pdi[i];
+          if (std::isnan(val)) {
+            pdiArr.setValueAtIndex(rt, i, Value::null());
+          } else {
+            pdiArr.setValueAtIndex(rt, i, Value(val));
+          }
+        }
+        jsResult.setProperty(rt, "pdi", pdiArr);
+
+        Array mdiArr(rt, cres.length);
+        for (size_t i = 0; i < cres.length; ++i) {
+          double val = cres.mdi[i];
+          if (std::isnan(val)) {
+            mdiArr.setValueAtIndex(rt, i, Value::null());
+          } else {
+            mdiArr.setValueAtIndex(rt, i, Value(val));
+          }
+        }
+        jsResult.setProperty(rt, "mdi", mdiArr);
+
+        Array adxArr(rt, cres.length);
+        for (size_t i = 0; i < cres.length; ++i) {
+          double val = cres.adx[i];
+          if (std::isnan(val)) {
+            adxArr.setValueAtIndex(rt, i, Value::null());
+          } else {
+            adxArr.setValueAtIndex(rt, i, Value(val));
+          }
+        }
+        jsResult.setProperty(rt, "adx", adxArr);
+
+        Array adxrArr(rt, cres.length);
+        for (size_t i = 0; i < cres.length; ++i) {
+          double val = cres.adxr[i];
+          if (std::isnan(val)) {
+            adxrArr.setValueAtIndex(rt, i, Value::null());
+          } else {
+            adxrArr.setValueAtIndex(rt, i, Value(val));
+          }
+        }
+        jsResult.setProperty(rt, "adxr", adxrArr);
+
+        chart_free_dmi_result(&cres);
+        return jsResult;
+      }
+    )
+  );
+}
+
+// ============================================================================
+// MAIN INSTALLATION FUNCTION
+// ============================================================================
+
+extern "C" void installChartLibrary(jsi::Runtime& rt) {
+  auto module = Object(rt);
+
+  installCalculateMA(rt, module);
+  installCalculateEMA(rt, module);
+  installCalculateMACD(rt, module);
+  installCalculateRSI(rt, module);
+  installCalculateKDJ(rt, module);
+  installCalculateBOLL(rt, module);
+  installCalculateDMI(rt, module);
+
+  rt.global().setProperty(rt, "ChartLibrary", module);
+}
+

package/src/types/index.ts

@@ -0,0 +1,58 @@
+// ============================================================================
+// 📄 bindings/react-native/src/types/index.ts
+// Type definitions for Chart Library React Native API
+// ============================================================================
+
+export interface CandleData {
+  open: number;
+  high: number;
+  low: number;
+  close: number;
+  volume?: number;
+  timestamp?: number;
+}
+
+export interface MAResult {
+  data: (number | null)[];
+  loading: boolean;
+  error?: string;
+  status: 'success' | 'error';
+}
+
+export interface MACDResult {
+  macd: (number | null)[];
+  signal: (number | null)[];
+  histogram: (number | null)[];
+  loading: boolean;
+  error?: string;
+  status: 'success' | 'error';
+}
+
+export interface KDJResult {
+  k: (number | null)[];
+  d: (number | null)[];
+  j: (number | null)[];
+  loading: boolean;
+  error?: string;
+  status: 'success' | 'error';
+}
+
+export interface BOLLResult {
+  upper: (number | null)[];
+  middle: (number | null)[];
+  lower: (number | null)[];
+  loading: boolean;
+  error?: string;
+  status: 'success' | 'error';
+}
+
+export interface DMIResult {
+  pdi: (number | null)[];
+  mdi: (number | null)[];
+  adx: (number | null)[];
+  adxr: (number | null)[];
+  loading: boolean;
+  error?: string;
+  status: 'success' | 'error';
+}
+