@vulcan-js/strategies 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present enpitsulin <enpitsulin@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,142 @@
+# @vulcan-js/strategies
+
+Composable trading strategies for the [Vulcan](../../README.md) library. Combines multiple indicators into structured signal output with position management.
+
+## Installation
+
+```bash
+pnpm add @vulcan-js/strategies
+```
+
+## Usage
+
+### Built-in strategies
+
+Every strategy is a generator function (just like indicators). Pass OHLCV bars and iterate over signals:
+
+```ts
+import { collect } from '@vulcan-js/core'
+import { goldenCross } from '@vulcan-js/strategies'
+
+const bars = [
+  { o: 10, h: 12, l: 9, c: 11, v: 1000 },
+  { o: 11, h: 13, l: 10, c: 12, v: 1200 },
+  // ...
+]
+
+// Collect all signals
+const signals = collect(goldenCross(bars, { fastPeriod: 10, slowPeriod: 30 }))
+
+// Or iterate lazily
+for (const signal of goldenCross(bars)) {
+  console.log(signal.action) // 'long' | 'short' | 'close' | 'hold'
+  console.log(signal.reason) // human-readable explanation
+}
+```
+
+Use `.create()` for real-time / streaming scenarios:
+
+```ts
+import { goldenCross } from '@vulcan-js/strategies'
+
+const process = goldenCross.create({ fastPeriod: 10, slowPeriod: 30 })
+
+// Feed bars one by one
+const signal = process({ o: 10, h: 12, l: 9, c: 11, v: 1000 })
+```
+
+### Custom strategies
+
+Use `createStrategy` to build your own strategy. It mirrors `createSignal` from core, but adds a rolling window of historical bars and structured signal output:
+
+```ts
+import { ema } from '@vulcan-js/indicators'
+import { createStrategy } from '@vulcan-js/strategies'
+
+const myStrategy = createStrategy(
+  ({ emaPeriod, threshold }) => {
+    const emaProc = ema.create({ period: emaPeriod })
+
+    return (ctx) => {
+      const price = ctx.bar.c
+      const emaValue = emaProc(price)
+
+      // Access historical bars via ctx.bars (oldest first)
+      // Access current bar index via ctx.index
+
+      return { action: 'hold' }
+    }
+  },
+  { windowSize: 10, emaPeriod: 20, threshold: 0.05 },
+)
+```
+
+## API
+
+### `createStrategy(factory, defaultOptions)`
+
+Creates a generator-based strategy from a factory function.
+
+Returns a `StrategyGenerator` with:
+- **Generator iteration** — `strategy(source, options?)` yields `StrategySignal` for each bar
+- **`.create(options?)`** — returns a stateful `Processor<CandleData, StrategySignal>` for point-by-point feeding
+- **`.defaultOptions`** — the default options for the strategy
+
+The factory receives resolved options and returns a function `(ctx: StrategyContext) => StrategySignal`. The `StrategyContext` provides:
+
+| Property | Type | Description |
+| --- | --- | --- |
+| `bar` | `CandleData` | The current OHLCV bar |
+| `bars` | `readonly CandleData[]` | Rolling window of historical bars (oldest first, includes current bar) |
+| `index` | `number` | Zero-based index of the current bar since the strategy started |
+
+### `StrategySignal`
+
+| Property | Type | Description |
+| --- | --- | --- |
+| `action` | `'long' \| 'short' \| 'close' \| 'hold'` | The recommended action |
+| `size?` | `number` | Position size as a fraction (0–1) |
+| `stopLoss?` | `number` | Stop-loss price level |
+| `takeProfit?` | `number` | Take-profit price level |
+| `reason?` | `string` | Human-readable reason for the signal |
+
+### `BaseStrategyOptions`
+
+All strategy options must extend `BaseStrategyOptions`:
+
+| Property | Type | Description |
+| --- | --- | --- |
+| `windowSize` | `number` | Number of historical bars to keep in the rolling window |
+
+## Built-in Strategies
+
+| Strategy | Function | Alias | Description |
+| --- | --- | --- | --- |
+| Golden Cross / Death Cross | `goldenCross` | `goldenCrossStrategy` | Detects fast SMA crossing above/below slow SMA |
+| RSI Oversold/Overbought | `rsiOversoldOverbought` | `rsiOversoldOverboughtStrategy` | Detects RSI crossing oversold/overbought levels |
+
+### Golden Cross
+
+Detects when a fast SMA crosses above (golden cross) or below (death cross) a slow SMA. Includes stop-loss based on a configurable percentage.
+
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `fastPeriod` | `number` | `50` | Fast SMA period |
+| `slowPeriod` | `number` | `200` | Slow SMA period |
+| `stopLossPercent` | `number` | `0.02` | Stop-loss percentage (0–1) |
+| `windowSize` | `number` | `2` | Rolling window size |
+
+### RSI Oversold/Overbought
+
+Uses the Relative Strength Index to detect oversold and overbought reversal conditions.
+
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `period` | `number` | `14` | RSI calculation period |
+| `overboughtLevel` | `number` | `70` | RSI level considered overbought |
+| `oversoldLevel` | `number` | `30` | RSI level considered oversold |
+| `windowSize` | `number` | `2` | Rolling window size |
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,104 @@
+import { CandleData, SignalGenerator } from "@vulcan-js/core";
+
+//#region src/types.d.ts
+/**
+ * The action a strategy recommends.
+ */
+type StrategyAction = 'long' | 'short' | 'close' | 'hold';
+/**
+ * Structured signal output from a strategy.
+ */
+interface StrategySignal {
+  /** The recommended action */
+  action: StrategyAction;
+  /** Position size as a fraction (0–1), defaults to 1 */
+  size?: number;
+  /** Stop-loss price level */
+  stopLoss?: number;
+  /** Take-profit price level */
+  takeProfit?: number;
+  /** Human-readable reason for the signal */
+  reason?: string;
+}
+/**
+ * Base options that every strategy must include.
+ */
+interface BaseStrategyOptions {
+  /** Number of historical bars to keep in the rolling window */
+  windowSize: number;
+}
+/**
+ * Context passed to the strategy evaluation function on each bar.
+ */
+interface StrategyContext {
+  /** The current bar */
+  bar: CandleData;
+  /** Historical bars in the rolling window (oldest first, includes current bar) */
+  bars: readonly CandleData[];
+  /** Zero-based index of the current bar since the strategy started */
+  index: number;
+}
+/**
+ * A strategy generator — type alias for `SignalGenerator<CandleData, StrategySignal, Opts>`.
+ */
+type StrategyGenerator<Opts extends BaseStrategyOptions> = SignalGenerator<CandleData, StrategySignal, Opts>;
+type StrategyFactory<Opts extends BaseStrategyOptions> = (opts: Required<Opts>) => (ctx: StrategyContext) => StrategySignal;
+//#endregion
+//#region src/base.d.ts
+/**
+ * Create a generator-based strategy from a strategy factory.
+ *
+ * Mirrors `createSignal` from core, but manages a rolling window of bars
+ * and constructs a `StrategyContext` for each evaluation.
+ *
+ * The returned generator is fully compatible with `SignalGenerator<CandleData, StrategySignal, Opts>`.
+ */
+declare function createStrategy<Opts extends BaseStrategyOptions>(factory: StrategyFactory<Opts>, defaultOptions: Opts): StrategyGenerator<Opts>;
+//#endregion
+//#region src/builtin/goldenCross.d.ts
+interface GoldenCrossOptions extends BaseStrategyOptions {
+  /** Fast SMA period */
+  fastPeriod: number;
+  /** Slow SMA period */
+  slowPeriod: number;
+  /** Stop-loss percentage (0–1), e.g. 0.02 = 2% */
+  stopLossPercent: number;
+}
+declare const defaultGoldenCrossOptions: GoldenCrossOptions;
+/**
+ * Golden Cross / Death Cross Strategy
+ *
+ * Detects when a fast SMA crosses above (golden cross → long) or
+ * below (death cross → short) a slow SMA.
+ *
+ * - **Golden Cross**: fast SMA crosses above slow SMA → `long`
+ * - **Death Cross**: fast SMA crosses below slow SMA → `short`
+ * - Otherwise → `hold`
+ *
+ * Stop-loss is set as a percentage below/above the entry price.
+ */
+declare const goldenCross: StrategyGenerator<GoldenCrossOptions>;
+//#endregion
+//#region src/builtin/rsiOversoldOverbought.d.ts
+interface RsiOversoldOverboughtOptions extends BaseStrategyOptions {
+  /** RSI calculation period */
+  period: number;
+  /** RSI level above which the asset is considered overbought */
+  overboughtLevel: number;
+  /** RSI level below which the asset is considered oversold */
+  oversoldLevel: number;
+}
+declare const defaultRsiOversoldOverboughtOptions: RsiOversoldOverboughtOptions;
+/**
+ * RSI Oversold/Overbought Strategy
+ *
+ * Uses the Relative Strength Index to detect oversold and overbought conditions.
+ *
+ * - RSI crosses below `oversoldLevel` then back above → `long` (oversold reversal)
+ * - RSI crosses above `overboughtLevel` then back below → `short` (overbought reversal)
+ * - Otherwise → `hold`
+ */
+declare const rsiOversoldOverbought: StrategyGenerator<RsiOversoldOverboughtOptions>;
+//#endregion
+export { type BaseStrategyOptions, GoldenCrossOptions, RsiOversoldOverboughtOptions, type StrategyAction, type StrategyContext, type StrategyFactory, type StrategyGenerator, type StrategySignal, createStrategy, defaultGoldenCrossOptions, defaultRsiOversoldOverboughtOptions, goldenCross, goldenCross as goldenCrossStrategy, rsiOversoldOverbought, rsiOversoldOverbought as rsiOversoldOverboughtStrategy };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,157 @@
+import { assert } from "@vulcan-js/core";
+import { defu } from "defu";
+import { rsi, sma } from "@vulcan-js/indicators";
+import { from, gt, lt, toNumber } from "dnum";
+
+//#region src/base.ts
+/**
+* A fixed-capacity ring buffer with O(1) push and O(n) snapshot.
+*/
+function createRingBuffer(capacity) {
+	const buf = Array.from({ length: capacity });
+	let head = 0;
+	let size = 0;
+	return {
+		push(item) {
+			buf[head] = item;
+			head = (head + 1) % capacity;
+			if (size < capacity) size++;
+		},
+		toArray() {
+			if (size < capacity) return buf.slice(0, size);
+			return [...buf.slice(head), ...buf.slice(0, head)];
+		},
+		get size() {
+			return size;
+		}
+	};
+}
+/**
+* Create a generator-based strategy from a strategy factory.
+*
+* Mirrors `createSignal` from core, but manages a rolling window of bars
+* and constructs a `StrategyContext` for each evaluation.
+*
+* The returned generator is fully compatible with `SignalGenerator<CandleData, StrategySignal, Opts>`.
+*/
+function createStrategy(factory, defaultOptions) {
+	function buildProcessor(options) {
+		const opt = defu(options, defaultOptions);
+		assert(Number.isInteger(opt.windowSize) && opt.windowSize >= 1, /* @__PURE__ */ new RangeError(`Expected windowSize to be a positive integer, got ${opt.windowSize}`));
+		const ring = createRingBuffer(opt.windowSize);
+		const process = factory(opt);
+		let index = 0;
+		return (bar) => {
+			ring.push(bar);
+			const signal = process({
+				bar,
+				bars: ring.toArray(),
+				index
+			});
+			index++;
+			return signal;
+		};
+	}
+	function* generator(source, options) {
+		const process = buildProcessor(options);
+		for (const bar of source) yield process(bar);
+	}
+	generator.create = (options) => {
+		return buildProcessor(options);
+	};
+	Object.defineProperty(generator, "defaultOptions", { get() {
+		return JSON.parse(JSON.stringify(defaultOptions));
+	} });
+	return generator;
+}
+
+//#endregion
+//#region src/builtin/goldenCross.ts
+const defaultGoldenCrossOptions = {
+	windowSize: 2,
+	fastPeriod: 50,
+	slowPeriod: 200,
+	stopLossPercent: .02
+};
+/**
+* Golden Cross / Death Cross Strategy
+*
+* Detects when a fast SMA crosses above (golden cross → long) or
+* below (death cross → short) a slow SMA.
+*
+* - **Golden Cross**: fast SMA crosses above slow SMA → `long`
+* - **Death Cross**: fast SMA crosses below slow SMA → `short`
+* - Otherwise → `hold`
+*
+* Stop-loss is set as a percentage below/above the entry price.
+*/
+const goldenCross = createStrategy(({ fastPeriod, slowPeriod, stopLossPercent }) => {
+	const fastSma = sma.create({ period: fastPeriod });
+	const slowSma = sma.create({ period: slowPeriod });
+	let prevFastAbove;
+	return (ctx) => {
+		const close = ctx.bar.c;
+		const fastAbove = gt(fastSma(close), slowSma(close));
+		const price = toNumber(from(close, 18));
+		let signal = { action: "hold" };
+		if (prevFastAbove !== void 0) {
+			if (fastAbove && !prevFastAbove) signal = {
+				action: "long",
+				stopLoss: price * (1 - stopLossPercent),
+				reason: "Golden cross: fast SMA crossed above slow SMA"
+			};
+			else if (!fastAbove && prevFastAbove) signal = {
+				action: "short",
+				stopLoss: price * (1 + stopLossPercent),
+				reason: "Death cross: fast SMA crossed below slow SMA"
+			};
+		}
+		prevFastAbove = fastAbove;
+		return signal;
+	};
+}, defaultGoldenCrossOptions);
+
+//#endregion
+//#region src/builtin/rsiOversoldOverbought.ts
+const defaultRsiOversoldOverboughtOptions = {
+	windowSize: 2,
+	period: 14,
+	overboughtLevel: 70,
+	oversoldLevel: 30
+};
+/**
+* RSI Oversold/Overbought Strategy
+*
+* Uses the Relative Strength Index to detect oversold and overbought conditions.
+*
+* - RSI crosses below `oversoldLevel` then back above → `long` (oversold reversal)
+* - RSI crosses above `overboughtLevel` then back below → `short` (overbought reversal)
+* - Otherwise → `hold`
+*/
+const rsiOversoldOverbought = createStrategy(({ period, overboughtLevel, oversoldLevel }) => {
+	const rsiProc = rsi.create({ period });
+	let prevRsi;
+	const obLevel = from(overboughtLevel, 18);
+	const osLevel = from(oversoldLevel, 18);
+	return (ctx) => {
+		const close = ctx.bar.c;
+		const currentRsi = rsiProc(close);
+		let signal = { action: "hold" };
+		if (prevRsi !== void 0) {
+			if (lt(prevRsi, osLevel) && gt(currentRsi, osLevel)) signal = {
+				action: "long",
+				reason: `RSI crossed above oversold level (${oversoldLevel})`
+			};
+			else if (gt(prevRsi, obLevel) && lt(currentRsi, obLevel)) signal = {
+				action: "short",
+				reason: `RSI crossed below overbought level (${overboughtLevel})`
+			};
+		}
+		prevRsi = currentRsi;
+		return signal;
+	};
+}, defaultRsiOversoldOverboughtOptions);
+
+//#endregion
+export { createStrategy, defaultGoldenCrossOptions, defaultRsiOversoldOverboughtOptions, goldenCross, goldenCross as goldenCrossStrategy, rsiOversoldOverbought, rsiOversoldOverbought as rsiOversoldOverboughtStrategy };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/base.ts","../src/builtin/goldenCross.ts","../src/builtin/rsiOversoldOverbought.ts"],"sourcesContent":["import type { BaseStrategyOptions, CandleData, Processor, StrategyContext, StrategyFactory, StrategyGenerator, StrategySignal } from './types'\nimport { assert } from '@vulcan-js/core'\nimport { defu } from 'defu'\n\n/**\n * A fixed-capacity ring buffer with O(1) push and O(n) snapshot.\n */\nfunction createRingBuffer<T>(capacity: number) {\n  const buf: T[] = Array.from({ length: capacity })\n  let head = 0\n  let size = 0\n\n  return {\n    push(item: T) {\n      buf[head] = item\n      head = (head + 1) % capacity\n      if (size < capacity)\n        size++\n    },\n    toArray(): readonly T[] {\n      if (size < capacity) {\n        return buf.slice(0, size)\n      }\n      // head points to the oldest element when buffer is full\n      return [...buf.slice(head), ...buf.slice(0, head)]\n    },\n    get size() {\n      return size\n    },\n  }\n}\n\n/**\n * Create a generator-based strategy from a strategy factory.\n *\n * Mirrors `createSignal` from core, but manages a rolling window of bars\n * and constructs a `StrategyContext` for each evaluation.\n *\n * The returned generator is fully compatible with `SignalGenerator<CandleData, StrategySignal, Opts>`.\n */\nexport function createStrategy<Opts extends BaseStrategyOptions>(\n  factory: StrategyFactory<Opts>,\n  defaultOptions: Opts,\n): StrategyGenerator<Opts> {\n  function buildProcessor(options?: Partial<Opts>): Processor<CandleData, StrategySignal> {\n    const opt = defu(options, defaultOptions) as Required<Opts>\n    assert(Number.isInteger(opt.windowSize) && opt.windowSize >= 1, new RangeError(`Expected windowSize to be a positive integer, got ${opt.windowSize}`))\n    const ring = createRingBuffer<CandleData>(opt.windowSize)\n    const process = factory(opt)\n    let index = 0\n    return (bar: CandleData) => {\n      ring.push(bar)\n      const ctx: StrategyContext = { bar, bars: ring.toArray(), index }\n      const signal = process(ctx)\n      index++\n      return signal\n    }\n  }\n\n  function* generator(\n    source: Iterable<CandleData>,\n    options?: Partial<Opts>,\n  ): Generator<StrategySignal, void, unknown> {\n    const process = buildProcessor(options)\n    for (const bar of source) {\n      yield process(bar)\n    }\n  }\n\n  generator.create = (options?: Partial<Opts>): Processor<CandleData, StrategySignal> => {\n    return buildProcessor(options)\n  }\n\n  Object.defineProperty(generator, 'defaultOptions', {\n    get() {\n      return JSON.parse(JSON.stringify(defaultOptions))\n    },\n  })\n\n  return generator as StrategyGenerator<Opts>\n}\n","import type { Dnum, Numberish } from 'dnum'\nimport type { BaseStrategyOptions, StrategySignal } from '../types'\nimport { sma } from '@vulcan-js/indicators'\nimport { from, gt, toNumber } from 'dnum'\nimport { createStrategy } from '../base'\n\nexport interface GoldenCrossOptions extends BaseStrategyOptions {\n  /** Fast SMA period */\n  fastPeriod: number\n  /** Slow SMA period */\n  slowPeriod: number\n  /** Stop-loss percentage (0–1), e.g. 0.02 = 2% */\n  stopLossPercent: number\n}\n\nexport const defaultGoldenCrossOptions: GoldenCrossOptions = {\n  windowSize: 2,\n  fastPeriod: 50,\n  slowPeriod: 200,\n  stopLossPercent: 0.02,\n}\n\n/**\n * Golden Cross / Death Cross Strategy\n *\n * Detects when a fast SMA crosses above (golden cross → long) or\n * below (death cross → short) a slow SMA.\n *\n * - **Golden Cross**: fast SMA crosses above slow SMA → `long`\n * - **Death Cross**: fast SMA crosses below slow SMA → `short`\n * - Otherwise → `hold`\n *\n * Stop-loss is set as a percentage below/above the entry price.\n */\nexport const goldenCross = createStrategy(\n  ({ fastPeriod, slowPeriod, stopLossPercent }) => {\n    const fastSma = sma.create({ period: fastPeriod })\n    const slowSma = sma.create({ period: slowPeriod })\n    let prevFastAbove: boolean | undefined\n\n    return (ctx) => {\n      const close = ctx.bar.c as Numberish\n      const fast: Dnum = fastSma(close)\n      const slow: Dnum = slowSma(close)\n      const fastAbove = gt(fast, slow)\n      const price = toNumber(from(close, 18))\n\n      let signal: StrategySignal = { action: 'hold' }\n\n      if (prevFastAbove !== undefined) {\n        if (fastAbove && !prevFastAbove) {\n          signal = {\n            action: 'long',\n            stopLoss: price * (1 - stopLossPercent),\n            reason: 'Golden cross: fast SMA crossed above slow SMA',\n          }\n        }\n        else if (!fastAbove && prevFastAbove) {\n          signal = {\n            action: 'short',\n            stopLoss: price * (1 + stopLossPercent),\n            reason: 'Death cross: fast SMA crossed below slow SMA',\n          }\n        }\n      }\n\n      prevFastAbove = fastAbove\n\n      return signal\n    }\n  },\n  defaultGoldenCrossOptions,\n)\n\nexport { goldenCross as goldenCrossStrategy }\n","import type { Dnum, Numberish } from 'dnum'\nimport type { BaseStrategyOptions, StrategySignal } from '../types'\nimport { rsi } from '@vulcan-js/indicators'\nimport { from, gt, lt } from 'dnum'\nimport { createStrategy } from '../base'\n\nexport interface RsiOversoldOverboughtOptions extends BaseStrategyOptions {\n  /** RSI calculation period */\n  period: number\n  /** RSI level above which the asset is considered overbought */\n  overboughtLevel: number\n  /** RSI level below which the asset is considered oversold */\n  oversoldLevel: number\n}\n\nexport const defaultRsiOversoldOverboughtOptions: RsiOversoldOverboughtOptions = {\n  windowSize: 2,\n  period: 14,\n  overboughtLevel: 70,\n  oversoldLevel: 30,\n}\n\n/**\n * RSI Oversold/Overbought Strategy\n *\n * Uses the Relative Strength Index to detect oversold and overbought conditions.\n *\n * - RSI crosses below `oversoldLevel` then back above → `long` (oversold reversal)\n * - RSI crosses above `overboughtLevel` then back below → `short` (overbought reversal)\n * - Otherwise → `hold`\n */\nexport const rsiOversoldOverbought = createStrategy(\n  ({ period, overboughtLevel, oversoldLevel }) => {\n    const rsiProc = rsi.create({ period })\n    let prevRsi: Dnum | undefined\n    const obLevel = from(overboughtLevel, 18)\n    const osLevel = from(oversoldLevel, 18)\n\n    return (ctx) => {\n      const close = ctx.bar.c as Numberish\n      const currentRsi = rsiProc(close)\n\n      let signal: StrategySignal = { action: 'hold' }\n\n      if (prevRsi !== undefined) {\n        // Oversold reversal: RSI was below oversoldLevel, now crosses above\n        if (lt(prevRsi, osLevel) && gt(currentRsi, osLevel)) {\n          signal = {\n            action: 'long',\n            reason: `RSI crossed above oversold level (${oversoldLevel})`,\n          }\n        }\n        // Overbought reversal: RSI was above overboughtLevel, now crosses below\n        else if (gt(prevRsi, obLevel) && lt(currentRsi, obLevel)) {\n          signal = {\n            action: 'short',\n            reason: `RSI crossed below overbought level (${overboughtLevel})`,\n          }\n        }\n      }\n\n      prevRsi = currentRsi\n\n      return signal\n    }\n  },\n  defaultRsiOversoldOverboughtOptions,\n)\n\nexport { rsiOversoldOverbought as rsiOversoldOverboughtStrategy }\n"],"mappings":";;;;;;;;;AAOA,SAAS,iBAAoB,UAAkB;CAC7C,MAAM,MAAW,MAAM,KAAK,EAAE,QAAQ,UAAU,CAAC;CACjD,IAAI,OAAO;CACX,IAAI,OAAO;AAEX,QAAO;EACL,KAAK,MAAS;AACZ,OAAI,QAAQ;AACZ,WAAQ,OAAO,KAAK;AACpB,OAAI,OAAO,SACT;;EAEJ,UAAwB;AACtB,OAAI,OAAO,SACT,QAAO,IAAI,MAAM,GAAG,KAAK;AAG3B,UAAO,CAAC,GAAG,IAAI,MAAM,KAAK,EAAE,GAAG,IAAI,MAAM,GAAG,KAAK,CAAC;;EAEpD,IAAI,OAAO;AACT,UAAO;;EAEV;;;;;;;;;;AAWH,SAAgB,eACd,SACA,gBACyB;CACzB,SAAS,eAAe,SAAgE;EACtF,MAAM,MAAM,KAAK,SAAS,eAAe;AACzC,SAAO,OAAO,UAAU,IAAI,WAAW,IAAI,IAAI,cAAc,mBAAG,IAAI,WAAW,qDAAqD,IAAI,aAAa,CAAC;EACtJ,MAAM,OAAO,iBAA6B,IAAI,WAAW;EACzD,MAAM,UAAU,QAAQ,IAAI;EAC5B,IAAI,QAAQ;AACZ,UAAQ,QAAoB;AAC1B,QAAK,KAAK,IAAI;GAEd,MAAM,SAAS,QADc;IAAE;IAAK,MAAM,KAAK,SAAS;IAAE;IAAO,CACtC;AAC3B;AACA,UAAO;;;CAIX,UAAU,UACR,QACA,SAC0C;EAC1C,MAAM,UAAU,eAAe,QAAQ;AACvC,OAAK,MAAM,OAAO,OAChB,OAAM,QAAQ,IAAI;;AAItB,WAAU,UAAU,YAAmE;AACrF,SAAO,eAAe,QAAQ;;AAGhC,QAAO,eAAe,WAAW,kBAAkB,EACjD,MAAM;AACJ,SAAO,KAAK,MAAM,KAAK,UAAU,eAAe,CAAC;IAEpD,CAAC;AAEF,QAAO;;;;;AChET,MAAa,4BAAgD;CAC3D,YAAY;CACZ,YAAY;CACZ,YAAY;CACZ,iBAAiB;CAClB;;;;;;;;;;;;;AAcD,MAAa,cAAc,gBACxB,EAAE,YAAY,YAAY,sBAAsB;CAC/C,MAAM,UAAU,IAAI,OAAO,EAAE,QAAQ,YAAY,CAAC;CAClD,MAAM,UAAU,IAAI,OAAO,EAAE,QAAQ,YAAY,CAAC;CAClD,IAAI;AAEJ,SAAQ,QAAQ;EACd,MAAM,QAAQ,IAAI,IAAI;EAGtB,MAAM,YAAY,GAFC,QAAQ,MAAM,EACd,QAAQ,MAAM,CACD;EAChC,MAAM,QAAQ,SAAS,KAAK,OAAO,GAAG,CAAC;EAEvC,IAAI,SAAyB,EAAE,QAAQ,QAAQ;AAE/C,MAAI,kBAAkB,QACpB;OAAI,aAAa,CAAC,cAChB,UAAS;IACP,QAAQ;IACR,UAAU,SAAS,IAAI;IACvB,QAAQ;IACT;YAEM,CAAC,aAAa,cACrB,UAAS;IACP,QAAQ;IACR,UAAU,SAAS,IAAI;IACvB,QAAQ;IACT;;AAIL,kBAAgB;AAEhB,SAAO;;GAGX,0BACD;;;;ACzDD,MAAa,sCAAoE;CAC/E,YAAY;CACZ,QAAQ;CACR,iBAAiB;CACjB,eAAe;CAChB;;;;;;;;;;AAWD,MAAa,wBAAwB,gBAClC,EAAE,QAAQ,iBAAiB,oBAAoB;CAC9C,MAAM,UAAU,IAAI,OAAO,EAAE,QAAQ,CAAC;CACtC,IAAI;CACJ,MAAM,UAAU,KAAK,iBAAiB,GAAG;CACzC,MAAM,UAAU,KAAK,eAAe,GAAG;AAEvC,SAAQ,QAAQ;EACd,MAAM,QAAQ,IAAI,IAAI;EACtB,MAAM,aAAa,QAAQ,MAAM;EAEjC,IAAI,SAAyB,EAAE,QAAQ,QAAQ;AAE/C,MAAI,YAAY,QAEd;OAAI,GAAG,SAAS,QAAQ,IAAI,GAAG,YAAY,QAAQ,CACjD,UAAS;IACP,QAAQ;IACR,QAAQ,qCAAqC,cAAc;IAC5D;YAGM,GAAG,SAAS,QAAQ,IAAI,GAAG,YAAY,QAAQ,CACtD,UAAS;IACP,QAAQ;IACR,QAAQ,uCAAuC,gBAAgB;IAChE;;AAIL,YAAU;AAEV,SAAO;;GAGX,oCACD"}

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@vulcan-js/strategies",
+  "type": "module",
+  "version": "0.0.0",
+  "license": "MIT",
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "defu": "^6.1.4",
+    "dnum": "^2.17.0",
+    "@vulcan-js/core": "^0.0.0",
+    "@vulcan-js/indicators": "^0.0.0"
+  },
+  "devDependencies": {
+    "vite-tsconfig-paths": "^6.1.1",
+    "vitest": "^4.0.18"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run"
+  }
+}