ferro-ta-wasm 1.0.0

package/README.md

@@ -0,0 +1,158 @@
+# ferro-ta WASM
+
+WebAssembly bindings for the [ferro-ta](https://github.com/pratikbhadane24/ferro-ta) technical analysis library.
+
+## Install from npm
+
+Once published, install the Node.js build from npm:
+
+```bash
+npm install ferro-ta-wasm
+```
+
+```javascript
+const { sma, ema, rsi, bbands, atr, obv, macd } = require('ferro-ta-wasm');
+
+const close = new Float64Array([44.34, 44.09, 44.15, 43.61, 44.33, 44.83, 45.10]);
+const smaOut = sma(close, 3);
+console.log('SMA:', Array.from(smaOut));
+```
+
+> **Decision**: We chose WebAssembly (wasm-bindgen / wasm-pack) as the second binding because it runs in
+> browsers *and* Node.js without any native addons, and shares zero unsafe FFI surface with the Python
+> build.  Node.js users get a pure-JS entry point; browser users get the same `.wasm` file.
+
+## Available Indicators
+
+| Category   | Function      | Parameters                                         | Returns |
+|------------|---------------|----------------------------------------------------|---------|
+| Overlap    | `sma`         | `close: Float64Array, timeperiod: number`          | `Float64Array` |
+| Overlap    | `ema`         | `close: Float64Array, timeperiod: number`          | `Float64Array` |
+| Overlap    | `bbands`      | `close, timeperiod, nbdevup, nbdevdn`              | `Array[upper, middle, lower]` |
+| Momentum   | `rsi`         | `close: Float64Array, timeperiod: number`          | `Float64Array` |
+| Momentum   | `macd`        | `close, fastperiod, slowperiod, signalperiod`      | `Array[macd, signal, hist]` |
+| Momentum   | `mom`         | `close: Float64Array, timeperiod: number`          | `Float64Array` |
+| Momentum   | `stochf`      | `high, low, close, fastk_period, fastd_period`     | `Array[fastk, fastd]` |
+| Volatility | `atr`         | `high, low, close: Float64Array, timeperiod`       | `Float64Array` |
+| Volume     | `obv`         | `close: Float64Array, volume: Float64Array`        | `Float64Array` |
+
+### Adding more indicators
+
+All implementations are self-contained in `src/lib.rs` — no external crate dependency needed.
+To add a new indicator:
+
+1. Implement the algorithm in a `#[wasm_bindgen]` function in `src/lib.rs`.
+2. Add at least two `#[wasm_bindgen_test]` tests covering output length and a known value.
+3. Update this README table.
+4. Run `wasm-pack test --node` to verify.
+
+## Prerequisites
+
+```bash
+# Install Rust (if not already present)
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+
+# Install wasm-pack
+curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
+# OR via cargo:
+cargo install wasm-pack
+```
+
+## Build
+
+```bash
+cd wasm/
+wasm-pack build --target nodejs --out-dir pkg
+```
+
+This produces a `pkg/` directory containing:
+- `ferro_ta_wasm.js` — JavaScript glue code
+- `ferro_ta_wasm_bg.wasm` — compiled WebAssembly binary
+- `ferro_ta_wasm.d.ts` — TypeScript declarations
+
+For a browser build:
+
+```bash
+wasm-pack build --target web --out-dir pkg-web
+```
+
+## Usage (Node.js)
+
+```javascript
+const { sma, ema, rsi, bbands, atr, obv, macd } = require('./pkg/ferro_ta_wasm.js');
+
+const close = new Float64Array([44.34, 44.09, 44.15, 43.61, 44.33, 44.83, 45.10]);
+
+// Simple Moving Average (period 3)
+const smaOut = sma(close, 3);
+console.log('SMA:', Array.from(smaOut));  // [ NaN, NaN, 44.193, ... ]
+
+// RSI (period 5)
+const rsiOut = rsi(close, 5);
+console.log('RSI:', Array.from(rsiOut));
+
+// Bollinger Bands (period 5, ±2σ) — returns [upper, middle, lower]
+const [upper, middle, lower] = bbands(close, 5, 2.0, 2.0);
+console.log('BBANDS upper:', Array.from(upper));
+
+// MACD (fast=3, slow=5, signal=2) — returns [macd_line, signal_line, histogram]
+const [macdLine, signalLine, histogram] = macd(close, 3, 5, 2);
+console.log('MACD:', Array.from(macdLine));
+console.log('Signal:', Array.from(signalLine));
+console.log('Histogram:', Array.from(histogram));
+
+// ATR (period 3)
+const high   = new Float64Array([45.0, 46.0, 47.0, 46.0, 45.0, 44.0, 45.0]);
+const low    = new Float64Array([43.0, 44.0, 45.0, 44.0, 43.0, 42.0, 43.0]);
+const atrOut = atr(high, low, close, 3);
+console.log('ATR:', Array.from(atrOut));
+
+// OBV
+const volume  = new Float64Array([1000, 1200, 900, 1500, 800, 600, 700]);
+const obvOut  = obv(close, volume);
+console.log('OBV:', Array.from(obvOut));
+```
+
+## Usage (Browser)
+
+```html
+<script type="module">
+  import init, { sma, macd } from './pkg-web/ferro_ta_wasm.js';
+  await init();  // loads the .wasm binary
+
+  const close = new Float64Array([44.34, 44.09, 44.15, 43.61, 44.33]);
+  const smaOut = sma(close, 3);
+  console.log('SMA:', Array.from(smaOut));
+
+  // MACD
+  const [macdLine, signal, hist] = macd(close, 3, 5, 2);
+  console.log('MACD line:', Array.from(macdLine));
+</script>
+```
+
+## Run Tests
+
+```bash
+cd wasm/
+wasm-pack test --node
+```
+
+## CI Artifact
+
+Every CI run on `main` builds the WASM package and uploads it as a GitHub Actions
+artifact named `wasm-pkg`.  To download the latest pre-built package without building
+from source:
+
+1. Go to the [Actions tab](https://github.com/pratikbhadane24/ferro-ta/actions).
+2. Open the latest successful CI run.
+3. Download the `wasm-pkg` artifact from the **Artifacts** section.
+4. Unzip and use `pkg/ferro_ta_wasm.js` directly in your project.
+
+## Limitations
+
+- Only 9 indicators are currently exposed (SMA, EMA, BBANDS, RSI, MACD, MOM, STOCHF, ATR, OBV).
+  Additional indicators will be added following the same pattern in `src/lib.rs`.
+- Large arrays (> 10M bars) may be slow due to JS↔WASM memory copies.  For high-throughput
+  use cases prefer the Python (PyO3) binding.
+- WASM does not support multi-threading natively in browsers (SharedArrayBuffer requires
+  COOP/COEP headers).

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "ferro-ta-wasm",
+  "version": "1.0.0",
+  "description": "WebAssembly bindings for ferro-ta technical analysis indicators",
+  "main": "pkg/ferro_ta_wasm.js",
+  "types": "pkg/ferro_ta_wasm.d.ts",
+  "files": ["pkg"],
+  "scripts": {
+    "build": "wasm-pack build --target nodejs --out-dir pkg",
+    "prepack": "npm run build && node -e \"require('fs').rmSync('pkg/.gitignore', { force: true })\"",
+    "test": "wasm-pack test --node"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pratikbhadane24/ferro-ta.git",
+    "directory": "wasm"
+  },
+  "homepage": "https://github.com/pratikbhadane24/ferro-ta#readme",
+  "bugs": "https://github.com/pratikbhadane24/ferro-ta/issues",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {}
+}

package/pkg/README.md

@@ -0,0 +1,158 @@
+# ferro-ta WASM
+
+WebAssembly bindings for the [ferro-ta](https://github.com/pratikbhadane24/ferro-ta) technical analysis library.
+
+## Install from npm
+
+Once published, install the Node.js build from npm:
+
+```bash
+npm install ferro-ta-wasm
+```
+
+```javascript
+const { sma, ema, rsi, bbands, atr, obv, macd } = require('ferro-ta-wasm');
+
+const close = new Float64Array([44.34, 44.09, 44.15, 43.61, 44.33, 44.83, 45.10]);
+const smaOut = sma(close, 3);
+console.log('SMA:', Array.from(smaOut));
+```
+
+> **Decision**: We chose WebAssembly (wasm-bindgen / wasm-pack) as the second binding because it runs in
+> browsers *and* Node.js without any native addons, and shares zero unsafe FFI surface with the Python
+> build.  Node.js users get a pure-JS entry point; browser users get the same `.wasm` file.
+
+## Available Indicators
+
+| Category   | Function      | Parameters                                         | Returns |
+|------------|---------------|----------------------------------------------------|---------|
+| Overlap    | `sma`         | `close: Float64Array, timeperiod: number`          | `Float64Array` |
+| Overlap    | `ema`         | `close: Float64Array, timeperiod: number`          | `Float64Array` |
+| Overlap    | `bbands`      | `close, timeperiod, nbdevup, nbdevdn`              | `Array[upper, middle, lower]` |
+| Momentum   | `rsi`         | `close: Float64Array, timeperiod: number`          | `Float64Array` |
+| Momentum   | `macd`        | `close, fastperiod, slowperiod, signalperiod`      | `Array[macd, signal, hist]` |
+| Momentum   | `mom`         | `close: Float64Array, timeperiod: number`          | `Float64Array` |
+| Momentum   | `stochf`      | `high, low, close, fastk_period, fastd_period`     | `Array[fastk, fastd]` |
+| Volatility | `atr`         | `high, low, close: Float64Array, timeperiod`       | `Float64Array` |
+| Volume     | `obv`         | `close: Float64Array, volume: Float64Array`        | `Float64Array` |
+
+### Adding more indicators
+
+All implementations are self-contained in `src/lib.rs` — no external crate dependency needed.
+To add a new indicator:
+
+1. Implement the algorithm in a `#[wasm_bindgen]` function in `src/lib.rs`.
+2. Add at least two `#[wasm_bindgen_test]` tests covering output length and a known value.
+3. Update this README table.
+4. Run `wasm-pack test --node` to verify.
+
+## Prerequisites
+
+```bash
+# Install Rust (if not already present)
+curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
+
+# Install wasm-pack
+curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
+# OR via cargo:
+cargo install wasm-pack
+```
+
+## Build
+
+```bash
+cd wasm/
+wasm-pack build --target nodejs --out-dir pkg
+```
+
+This produces a `pkg/` directory containing:
+- `ferro_ta_wasm.js` — JavaScript glue code
+- `ferro_ta_wasm_bg.wasm` — compiled WebAssembly binary
+- `ferro_ta_wasm.d.ts` — TypeScript declarations
+
+For a browser build:
+
+```bash
+wasm-pack build --target web --out-dir pkg-web
+```
+
+## Usage (Node.js)
+
+```javascript
+const { sma, ema, rsi, bbands, atr, obv, macd } = require('./pkg/ferro_ta_wasm.js');
+
+const close = new Float64Array([44.34, 44.09, 44.15, 43.61, 44.33, 44.83, 45.10]);
+
+// Simple Moving Average (period 3)
+const smaOut = sma(close, 3);
+console.log('SMA:', Array.from(smaOut));  // [ NaN, NaN, 44.193, ... ]
+
+// RSI (period 5)
+const rsiOut = rsi(close, 5);
+console.log('RSI:', Array.from(rsiOut));
+
+// Bollinger Bands (period 5, ±2σ) — returns [upper, middle, lower]
+const [upper, middle, lower] = bbands(close, 5, 2.0, 2.0);
+console.log('BBANDS upper:', Array.from(upper));
+
+// MACD (fast=3, slow=5, signal=2) — returns [macd_line, signal_line, histogram]
+const [macdLine, signalLine, histogram] = macd(close, 3, 5, 2);
+console.log('MACD:', Array.from(macdLine));
+console.log('Signal:', Array.from(signalLine));
+console.log('Histogram:', Array.from(histogram));
+
+// ATR (period 3)
+const high   = new Float64Array([45.0, 46.0, 47.0, 46.0, 45.0, 44.0, 45.0]);
+const low    = new Float64Array([43.0, 44.0, 45.0, 44.0, 43.0, 42.0, 43.0]);
+const atrOut = atr(high, low, close, 3);
+console.log('ATR:', Array.from(atrOut));
+
+// OBV
+const volume  = new Float64Array([1000, 1200, 900, 1500, 800, 600, 700]);
+const obvOut  = obv(close, volume);
+console.log('OBV:', Array.from(obvOut));
+```
+
+## Usage (Browser)
+
+```html
+<script type="module">
+  import init, { sma, macd } from './pkg-web/ferro_ta_wasm.js';
+  await init();  // loads the .wasm binary
+
+  const close = new Float64Array([44.34, 44.09, 44.15, 43.61, 44.33]);
+  const smaOut = sma(close, 3);
+  console.log('SMA:', Array.from(smaOut));
+
+  // MACD
+  const [macdLine, signal, hist] = macd(close, 3, 5, 2);
+  console.log('MACD line:', Array.from(macdLine));
+</script>
+```
+
+## Run Tests
+
+```bash
+cd wasm/
+wasm-pack test --node
+```
+
+## CI Artifact
+
+Every CI run on `main` builds the WASM package and uploads it as a GitHub Actions
+artifact named `wasm-pkg`.  To download the latest pre-built package without building
+from source:
+
+1. Go to the [Actions tab](https://github.com/pratikbhadane24/ferro-ta/actions).
+2. Open the latest successful CI run.
+3. Download the `wasm-pkg` artifact from the **Artifacts** section.
+4. Unzip and use `pkg/ferro_ta_wasm.js` directly in your project.
+
+## Limitations
+
+- Only 9 indicators are currently exposed (SMA, EMA, BBANDS, RSI, MACD, MOM, STOCHF, ATR, OBV).
+  Additional indicators will be added following the same pattern in `src/lib.rs`.
+- Large arrays (> 10M bars) may be slow due to JS↔WASM memory copies.  For high-throughput
+  use cases prefer the Python (PyO3) binding.
+- WASM does not support multi-threading natively in browsers (SharedArrayBuffer requires
+  COOP/COEP headers).

package/pkg/ferro_ta_wasm.d.ts

@@ -0,0 +1,121 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Average True Range (Wilder smoothing, TA-Lib compatible).
+ *
+ * # Arguments
+ * - `high`  – `Float64Array` of high prices.
+ * - `low`   – `Float64Array` of low prices.
+ * - `close` – `Float64Array` of close prices.
+ * - `timeperiod` – look-back period (default 14, minimum 1).
+ *
+ * # Returns
+ * `Float64Array`; first `timeperiod` values are `NaN`.
+ */
+export function atr(high: Float64Array, low: Float64Array, close: Float64Array, timeperiod: number): Float64Array;
+
+/**
+ * Bollinger Bands (SMA ± k × rolling standard deviation).
+ *
+ * # Arguments
+ * - `close` – `Float64Array` of close prices.
+ * - `timeperiod` – look-back window (default 5, minimum 1).
+ * - `nbdevup` – multiplier for the upper band (default 2.0).
+ * - `nbdevdn` – multiplier for the lower band (default 2.0).
+ *
+ * # Returns
+ * A `js_sys::Array` containing three `Float64Array` elements:
+ * `[upperband, middleband, lowerband]`.
+ */
+export function bbands(close: Float64Array, timeperiod: number, nbdevup: number, nbdevdn: number): Array<any>;
+
+/**
+ * Exponential Moving Average (SMA-seeded).
+ *
+ * # Arguments
+ * - `close` – `Float64Array` of close prices.
+ * - `timeperiod` – look-back period (default 30, minimum 1).
+ *
+ * # Returns
+ * `Float64Array` with the first `timeperiod - 1` values set to `NaN`.
+ */
+export function ema(close: Float64Array, timeperiod: number): Float64Array;
+
+/**
+ * Moving Average Convergence/Divergence.
+ *
+ * # Arguments
+ * - `close`        – `Float64Array` of close prices.
+ * - `fastperiod`   – fast EMA period (default 12).
+ * - `slowperiod`   – slow EMA period (default 26).
+ * - `signalperiod` – signal EMA period (default 9).
+ *
+ * # Returns
+ * A `js_sys::Array` containing three `Float64Array` elements:
+ * `[macd_line, signal_line, histogram]`.
+ */
+export function macd(close: Float64Array, fastperiod: number, slowperiod: number, signalperiod: number): Array<any>;
+
+/**
+ * Momentum — difference between current close and close *timeperiod* bars ago.
+ *
+ * # Arguments
+ * - `close`      – `Float64Array` of close prices.
+ * - `timeperiod` – look-back window (default 10, minimum 1).
+ *
+ * # Returns
+ * `Float64Array`; first `timeperiod` values are `NaN`.
+ */
+export function mom(close: Float64Array, timeperiod: number): Float64Array;
+
+/**
+ * On-Balance Volume.
+ *
+ * # Arguments
+ * - `close`  – `Float64Array` of close prices.
+ * - `volume` – `Float64Array` of volume values.
+ *
+ * # Returns
+ * `Float64Array` — cumulative OBV.
+ */
+export function obv(close: Float64Array, volume: Float64Array): Float64Array;
+
+/**
+ * Relative Strength Index (Wilder smoothing).
+ *
+ * # Arguments
+ * - `close` – `Float64Array` of close prices.
+ * - `timeperiod` – look-back period (default 14, minimum 1).
+ *
+ * # Returns
+ * `Float64Array` — values in `[0, 100]`; first `timeperiod` values are `NaN`.
+ */
+export function rsi(close: Float64Array, timeperiod: number): Float64Array;
+
+/**
+ * Simple Moving Average.
+ *
+ * # Arguments
+ * - `close` – `Float64Array` of close prices.
+ * - `timeperiod` – look-back window (default 30, minimum 1).
+ *
+ * # Returns
+ * `Float64Array` with the first `timeperiod - 1` values set to `NaN`.
+ */
+export function sma(close: Float64Array, timeperiod: number): Float64Array;
+
+/**
+ * Fast Stochastic Oscillator.
+ *
+ * # Arguments
+ * - `high`        – `Float64Array` of high prices.
+ * - `low`         – `Float64Array` of low prices.
+ * - `close`       – `Float64Array` of close prices.
+ * - `fastk_period` – fast-%K look-back window (default 5, minimum 1).
+ * - `fastd_period` – fast-%D SMA smoothing period (default 3, minimum 1).
+ *
+ * # Returns
+ * A `js_sys::Array` containing two `Float64Array` elements: `[fastk, fastd]`.
+ */
+export function stochf(high: Float64Array, low: Float64Array, close: Float64Array, fastk_period: number, fastd_period: number): Array<any>;

package/pkg/ferro_ta_wasm.js

@@ -0,0 +1,274 @@
+/* @ts-self-types="./ferro_ta_wasm.d.ts" */
+
+/**
+ * Average True Range (Wilder smoothing, TA-Lib compatible).
+ *
+ * # Arguments
+ * - `high`  – `Float64Array` of high prices.
+ * - `low`   – `Float64Array` of low prices.
+ * - `close` – `Float64Array` of close prices.
+ * - `timeperiod` – look-back period (default 14, minimum 1).
+ *
+ * # Returns
+ * `Float64Array`; first `timeperiod` values are `NaN`.
+ * @param {Float64Array} high
+ * @param {Float64Array} low
+ * @param {Float64Array} close
+ * @param {number} timeperiod
+ * @returns {Float64Array}
+ */
+function atr(high, low, close, timeperiod) {
+    const ret = wasm.atr(high, low, close, timeperiod);
+    return ret;
+}
+exports.atr = atr;
+
+/**
+ * Bollinger Bands (SMA ± k × rolling standard deviation).
+ *
+ * # Arguments
+ * - `close` – `Float64Array` of close prices.
+ * - `timeperiod` – look-back window (default 5, minimum 1).
+ * - `nbdevup` – multiplier for the upper band (default 2.0).
+ * - `nbdevdn` – multiplier for the lower band (default 2.0).
+ *
+ * # Returns
+ * A `js_sys::Array` containing three `Float64Array` elements:
+ * `[upperband, middleband, lowerband]`.
+ * @param {Float64Array} close
+ * @param {number} timeperiod
+ * @param {number} nbdevup
+ * @param {number} nbdevdn
+ * @returns {Array<any>}
+ */
+function bbands(close, timeperiod, nbdevup, nbdevdn) {
+    const ret = wasm.bbands(close, timeperiod, nbdevup, nbdevdn);
+    return ret;
+}
+exports.bbands = bbands;
+
+/**
+ * Exponential Moving Average (SMA-seeded).
+ *
+ * # Arguments
+ * - `close` – `Float64Array` of close prices.
+ * - `timeperiod` – look-back period (default 30, minimum 1).
+ *
+ * # Returns
+ * `Float64Array` with the first `timeperiod - 1` values set to `NaN`.
+ * @param {Float64Array} close
+ * @param {number} timeperiod
+ * @returns {Float64Array}
+ */
+function ema(close, timeperiod) {
+    const ret = wasm.ema(close, timeperiod);
+    return ret;
+}
+exports.ema = ema;
+
+/**
+ * Moving Average Convergence/Divergence.
+ *
+ * # Arguments
+ * - `close`        – `Float64Array` of close prices.
+ * - `fastperiod`   – fast EMA period (default 12).
+ * - `slowperiod`   – slow EMA period (default 26).
+ * - `signalperiod` – signal EMA period (default 9).
+ *
+ * # Returns
+ * A `js_sys::Array` containing three `Float64Array` elements:
+ * `[macd_line, signal_line, histogram]`.
+ * @param {Float64Array} close
+ * @param {number} fastperiod
+ * @param {number} slowperiod
+ * @param {number} signalperiod
+ * @returns {Array<any>}
+ */
+function macd(close, fastperiod, slowperiod, signalperiod) {
+    const ret = wasm.macd(close, fastperiod, slowperiod, signalperiod);
+    return ret;
+}
+exports.macd = macd;
+
+/**
+ * Momentum — difference between current close and close *timeperiod* bars ago.
+ *
+ * # Arguments
+ * - `close`      – `Float64Array` of close prices.
+ * - `timeperiod` – look-back window (default 10, minimum 1).
+ *
+ * # Returns
+ * `Float64Array`; first `timeperiod` values are `NaN`.
+ * @param {Float64Array} close
+ * @param {number} timeperiod
+ * @returns {Float64Array}
+ */
+function mom(close, timeperiod) {
+    const ret = wasm.mom(close, timeperiod);
+    return ret;
+}
+exports.mom = mom;
+
+/**
+ * On-Balance Volume.
+ *
+ * # Arguments
+ * - `close`  – `Float64Array` of close prices.
+ * - `volume` – `Float64Array` of volume values.
+ *
+ * # Returns
+ * `Float64Array` — cumulative OBV.
+ * @param {Float64Array} close
+ * @param {Float64Array} volume
+ * @returns {Float64Array}
+ */
+function obv(close, volume) {
+    const ret = wasm.obv(close, volume);
+    return ret;
+}
+exports.obv = obv;
+
+/**
+ * Relative Strength Index (Wilder smoothing).
+ *
+ * # Arguments
+ * - `close` – `Float64Array` of close prices.
+ * - `timeperiod` – look-back period (default 14, minimum 1).
+ *
+ * # Returns
+ * `Float64Array` — values in `[0, 100]`; first `timeperiod` values are `NaN`.
+ * @param {Float64Array} close
+ * @param {number} timeperiod
+ * @returns {Float64Array}
+ */
+function rsi(close, timeperiod) {
+    const ret = wasm.rsi(close, timeperiod);
+    return ret;
+}
+exports.rsi = rsi;
+
+/**
+ * Simple Moving Average.
+ *
+ * # Arguments
+ * - `close` – `Float64Array` of close prices.
+ * - `timeperiod` – look-back window (default 30, minimum 1).
+ *
+ * # Returns
+ * `Float64Array` with the first `timeperiod - 1` values set to `NaN`.
+ * @param {Float64Array} close
+ * @param {number} timeperiod
+ * @returns {Float64Array}
+ */
+function sma(close, timeperiod) {
+    const ret = wasm.sma(close, timeperiod);
+    return ret;
+}
+exports.sma = sma;
+
+/**
+ * Fast Stochastic Oscillator.
+ *
+ * # Arguments
+ * - `high`        – `Float64Array` of high prices.
+ * - `low`         – `Float64Array` of low prices.
+ * - `close`       – `Float64Array` of close prices.
+ * - `fastk_period` – fast-%K look-back window (default 5, minimum 1).
+ * - `fastd_period` – fast-%D SMA smoothing period (default 3, minimum 1).
+ *
+ * # Returns
+ * A `js_sys::Array` containing two `Float64Array` elements: `[fastk, fastd]`.
+ * @param {Float64Array} high
+ * @param {Float64Array} low
+ * @param {Float64Array} close
+ * @param {number} fastk_period
+ * @param {number} fastd_period
+ * @returns {Array<any>}
+ */
+function stochf(high, low, close, fastk_period, fastd_period) {
+    const ret = wasm.stochf(high, low, close, fastk_period, fastd_period);
+    return ret;
+}
+exports.stochf = stochf;
+
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_throw_6ddd609b62940d55: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_length_550d8a396009cd38: function(arg0) {
+            const ret = arg0.length;
+            return ret;
+        },
+        __wbg_new_a70fbab9066b301f: function() {
+            const ret = new Array();
+            return ret;
+        },
+        __wbg_new_with_length_eae667475c36c4e4: function(arg0) {
+            const ret = new Float64Array(arg0 >>> 0);
+            return ret;
+        },
+        __wbg_prototypesetcall_79daf97fb14c7a19: function(arg0, arg1, arg2) {
+            Float64Array.prototype.set.call(getArrayF64FromWasm0(arg0, arg1), arg2);
+        },
+        __wbg_push_e87b0e732085a946: function(arg0, arg1) {
+            const ret = arg0.push(arg1);
+            return ret;
+        },
+        __wbg_set_636d1e3e4286e068: function(arg0, arg1, arg2) {
+            arg0.set(getArrayF64FromWasm0(arg1, arg2));
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./ferro_ta_wasm_bg.js": import0,
+    };
+}
+
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const wasmPath = `${__dirname}/ferro_ta_wasm_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+let wasm = new WebAssembly.Instance(wasmModule, __wbg_get_imports()).exports;
+wasm.__wbindgen_start();

package/pkg/ferro_ta_wasm_bg.wasm.d.ts

@@ -0,0 +1,14 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const atr: (a: any, b: any, c: any, d: number) => any;
+export const bbands: (a: any, b: number, c: number, d: number) => any;
+export const ema: (a: any, b: number) => any;
+export const macd: (a: any, b: number, c: number, d: number) => any;
+export const mom: (a: any, b: number) => any;
+export const obv: (a: any, b: any) => any;
+export const rsi: (a: any, b: number) => any;
+export const sma: (a: any, b: number) => any;
+export const stochf: (a: any, b: any, c: any, d: number, e: number) => any;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __wbindgen_start: () => void;

package/pkg/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "ferro_ta_wasm",
+  "description": "WebAssembly bindings for ferro-ta technical analysis indicators",
+  "version": "1.0.0",
+  "license": "MIT",
+  "files": [
+    "ferro_ta_wasm_bg.wasm",
+    "ferro_ta_wasm.js",
+    "ferro_ta_wasm.d.ts"
+  ],
+  "main": "ferro_ta_wasm.js",
+  "types": "ferro_ta_wasm.d.ts"
+}