@tradejs/strategies 1.0.5 → 1.0.8

package/dist/strategy-HQIPCUOY.mjs

@@ -0,0 +1,399 @@
+import {
+  buildReverseTrendlineStructuralContext,
+  buildReverseTrendlineTimingContext,
+  config,
+  reverseTrendLineManifest,
+  toFiniteNumberOrNull
+} from "./chunk-UK4YHD2E.mjs";
+import "./chunk-HEBXNMVQ.mjs";
+
+// src/ReverseTrendLine/strategy.ts
+import { createStrategyRuntime } from "@tradejs/node/strategies";
+
+// src/ReverseTrendLine/core.ts
+import { round as round2 } from "@tradejs/core/math";
+import { createTrendlineEngine } from "@tradejs/core/indicators";
+
+// src/ReverseTrendLine/filters.ts
+import { diffRel } from "@tradejs/core/math";
+var MAX_CANDLE_VOLATILITY = 0.025;
+var filterByVeryVolatility = (data) => {
+  const lastCandle = data[data.length - 1];
+  const prevCandle = data[data.length - 2];
+  if (!lastCandle || !prevCandle) {
+    return false;
+  }
+  const isVeryVolatility = diffRel(lastCandle.low, lastCandle.high) > MAX_CANDLE_VOLATILITY || diffRel(prevCandle.low, prevCandle.high) > MAX_CANDLE_VOLATILITY;
+  return !isVeryVolatility;
+};
+
+// src/ReverseTrendLine/figures.ts
+var buildReverseTrendLineFigures = (bestLine) => ({
+  lines: [
+    {
+      id: bestLine.id,
+      kind: "trendline",
+      points: [...bestLine.points ?? []].sort(
+        (left, right) => left.timestamp - right.timestamp
+      ),
+      color: bestLine.mode === "lows" ? "#22c55e" : "#f97316",
+      width: 2,
+      style: "solid"
+    }
+  ],
+  points: [
+    {
+      id: `${bestLine.id}-points`,
+      kind: "trendline_points",
+      points: [...bestLine.points ?? [], ...bestLine.touches ?? []].sort(
+        (left, right) => left.timestamp - right.timestamp
+      ),
+      color: "#ef4444",
+      radius: 4
+    }
+  ]
+});
+
+// src/ReverseTrendLine/risk.ts
+import { round } from "@tradejs/core/math";
+var MIN_STOP_BUFFER_PCT = 0.1;
+var LINE_BUFFER_ATR_FACTOR = 0.25;
+var LINE_BUFFER_BASE_SL_FACTOR = 0.1;
+var ATR_STOP_FLOOR_FACTOR = 0.65;
+var MIN_STOP_LOSS_FACTOR = 0.8;
+var MAX_STOP_LOSS_FACTOR = 2;
+var clampNumber = (value, min, max) => Math.min(Math.max(value, min), max);
+var getTimingStopFactor = (entryTiming) => {
+  if (entryTiming === "ready_follow_through") {
+    return 0.95;
+  }
+  return 1;
+};
+var getTimingTargetRiskRatio = ({
+  direction,
+  entryTiming
+}) => {
+  if (direction === "LONG") {
+    return entryTiming === "ready_follow_through" ? 2.15 : 1.95;
+  }
+  return entryTiming === "ready_follow_through" ? 2.2 : 2;
+};
+var buildReverseTrendlineRiskPlan = ({
+  direction,
+  modeConfig,
+  structuralContext,
+  timingContext
+}) => {
+  const baseStopLossDelta = modeConfig.SL;
+  const atrPct = structuralContext.atrPct ?? baseStopLossDelta;
+  const priceVsLinePctAbs = structuralContext.priceVsLinePctAbs ?? 0;
+  const rejectionStrengthPct = structuralContext.rejectionStrengthPct ?? 0;
+  const touches = structuralContext.touches ?? 0;
+  const distance = structuralContext.distance ?? null;
+  const lineBufferPct = Math.max(
+    atrPct * LINE_BUFFER_ATR_FACTOR,
+    baseStopLossDelta * LINE_BUFFER_BASE_SL_FACTOR,
+    MIN_STOP_BUFFER_PCT
+  );
+  const lineInvalidationPct = priceVsLinePctAbs + lineBufferPct;
+  const volatilityFloorPct = Math.max(
+    atrPct * ATR_STOP_FLOOR_FACTOR,
+    baseStopLossDelta * MIN_STOP_LOSS_FACTOR
+  );
+  let stopLossDelta = Math.max(lineInvalidationPct, volatilityFloorPct);
+  if (touches >= 6) {
+    stopLossDelta *= 0.95;
+  } else if (touches > 0 && touches <= 4) {
+    stopLossDelta *= 1.03;
+  }
+  if (distance != null && distance >= 400) {
+    stopLossDelta *= 1.05;
+  } else if (distance != null && distance <= 120) {
+    stopLossDelta *= 0.95;
+  }
+  if (rejectionStrengthPct >= 0.2) {
+    stopLossDelta *= 0.95;
+  }
+  stopLossDelta *= getTimingStopFactor(timingContext.entryTiming);
+  stopLossDelta = clampNumber(
+    stopLossDelta,
+    baseStopLossDelta * MIN_STOP_LOSS_FACTOR,
+    baseStopLossDelta * MAX_STOP_LOSS_FACTOR
+  );
+  let targetRiskRatio = getTimingTargetRiskRatio({
+    direction,
+    entryTiming: timingContext.entryTiming
+  });
+  if (touches >= 6) {
+    targetRiskRatio += 0.1;
+  }
+  if (distance != null && distance >= 120 && distance <= 350) {
+    targetRiskRatio += 0.05;
+  }
+  if (direction === "SHORT" && distance != null && distance > 500) {
+    targetRiskRatio -= 0.15;
+  }
+  if (direction === "LONG" && distance != null && distance > 500) {
+    targetRiskRatio -= 0.1;
+  }
+  const minTargetRiskRatio = modeConfig.minRiskRatio + 0.05;
+  const maxTargetRiskRatio = Math.max(modeConfig.TP / modeConfig.SL, minTargetRiskRatio) + 0.3;
+  targetRiskRatio = clampNumber(
+    targetRiskRatio,
+    minTargetRiskRatio,
+    maxTargetRiskRatio
+  );
+  return {
+    stopLossDelta: round(stopLossDelta, 3),
+    targetRiskRatio: round(targetRiskRatio, 2),
+    takeProfitDelta: round(stopLossDelta * targetRiskRatio, 3)
+  };
+};
+
+// src/ReverseTrendLine/core.ts
+var buildReverseTrendlineSignalSeed = ({
+  direction,
+  currentPrice,
+  indicators,
+  bestLine,
+  currentCandle,
+  reverseTrendlineTiming
+}) => ({
+  direction,
+  prices: { currentPrice },
+  indicators,
+  additionalIndicators: {
+    touches: Array.isArray(bestLine.touches) ? bestLine.touches.length + 2 : 2,
+    distance: bestLine.distance,
+    trendLine: bestLine,
+    ...currentCandle ? { currentCandle } : {},
+    ...reverseTrendlineTiming ? { reverseTrendlineTiming } : {}
+  },
+  figures: {
+    trendLine: bestLine
+  }
+});
+var isOpenPosition = (position) => Boolean(
+  position && typeof position.price === "number" && Number.isFinite(position.price) && typeof position.qty === "number" && Number.isFinite(position.qty) && position.qty > 0 && (position.direction === "LONG" || position.direction === "SHORT")
+);
+var getLinePriceAtNow = (line, timestamp) => {
+  if (!line || !Array.isArray(line.points) || line.points.length === 0) {
+    return null;
+  }
+  const sortedPoints = [...line.points].sort(
+    (left, right) => left.timestamp - right.timestamp
+  );
+  const first = sortedPoints[0];
+  const last = sortedPoints[sortedPoints.length - 1];
+  if (first.timestamp === last.timestamp) {
+    return last.value;
+  }
+  const slope = (last.value - first.value) / (last.timestamp - first.timestamp);
+  return first.value + slope * (timestamp - first.timestamp);
+};
+var buildReverseTrendlineCandidateContext = ({
+  line,
+  candle,
+  direction
+}) => {
+  const currentLinePrice = getLinePriceAtNow(line, candle.timestamp);
+  const priceVsLinePct = currentLinePrice != null && currentLinePrice !== 0 ? (candle.close - currentLinePrice) / currentLinePrice * 100 : null;
+  const priceVsLinePctAbs = priceVsLinePct == null ? null : Math.abs(priceVsLinePct);
+  const lineTouchedNow = currentLinePrice != null && candle.low <= currentLinePrice && candle.high >= currentLinePrice;
+  const failedBounceBreak = direction === "LONG" ? priceVsLinePct != null && priceVsLinePct <= -0.35 : priceVsLinePct != null && priceVsLinePct >= 0.35;
+  return {
+    currentLinePrice,
+    priceVsLinePctAbs,
+    lineTouchedNow,
+    failedBounceBreak,
+    distance: toFiniteNumberOrNull(line.distance)
+  };
+};
+var pickBestCandidateLine = ({
+  candle,
+  lines
+}) => {
+  const ranked = lines.map(({ line, direction }) => {
+    const candidateContext = buildReverseTrendlineCandidateContext({
+      line,
+      candle,
+      direction
+    });
+    return { line, direction, candidateContext };
+  }).filter(({ candidateContext }) => candidateContext.currentLinePrice != null).sort((left, right) => {
+    const leftTouchRank = left.candidateContext.lineTouchedNow ? 0 : 1;
+    const rightTouchRank = right.candidateContext.lineTouchedNow ? 0 : 1;
+    if (leftTouchRank !== rightTouchRank) {
+      return leftTouchRank - rightTouchRank;
+    }
+    const leftDistance = left.candidateContext.priceVsLinePctAbs ?? Number.POSITIVE_INFINITY;
+    const rightDistance = right.candidateContext.priceVsLinePctAbs ?? Number.POSITIVE_INFINITY;
+    if (leftDistance !== rightDistance) {
+      return leftDistance - rightDistance;
+    }
+    return (left.candidateContext.distance ?? Number.POSITIVE_INFINITY) - (right.candidateContext.distance ?? Number.POSITIVE_INFINITY);
+  });
+  return ranked[0] ?? null;
+};
+var createReverseTrendLineCore = async ({ config: config2, data: cachedData, strategyApi, indicatorsState }) => {
+  const { TRENDLINE, FEE_PERCENT, MAX_LOSS_VALUE, HIGHS, LOWS } = config2;
+  const lastTradeController = strategyApi.createLastTradeController();
+  const trendlineOptions = {
+    bestLines: 1,
+    capture: true,
+    ...TRENDLINE
+  };
+  const getLowsTrendlines = createTrendlineEngine(cachedData, {
+    mode: "lows",
+    ...trendlineOptions
+  });
+  const getHighsTrendlines = createTrendlineEngine(cachedData, {
+    mode: "highs",
+    ...trendlineOptions
+  });
+  return async (candle) => {
+    const lowsTrendlines = getLowsTrendlines.next(candle);
+    const highsTrendlines = getHighsTrendlines.next(candle);
+    indicatorsState.onBar();
+    const currentPosition = await strategyApi.getCurrentPosition();
+    if (isOpenPosition(currentPosition)) {
+      const activeLine = currentPosition.direction === "LONG" ? lowsTrendlines[0] : highsTrendlines[0];
+      const activeLinePrice = getLinePriceAtNow(
+        activeLine ?? null,
+        candle.timestamp
+      );
+      const priceVsLinePct = activeLinePrice != null && activeLinePrice !== 0 ? (candle.close - activeLinePrice) / activeLinePrice * 100 : null;
+      const failedBounceBreak = currentPosition.direction === "LONG" ? priceVsLinePct != null && priceVsLinePct <= -0.35 : priceVsLinePct != null && priceVsLinePct >= 0.35;
+      if (failedBounceBreak) {
+        return strategyApi.exit({
+          code: "REVERSE_TRENDLINE_FAILED_BOUNCE_EXIT",
+          direction: currentPosition.direction
+        });
+      }
+      return strategyApi.skip("POSITION_EXISTS");
+    }
+    if (lastTradeController.isInCooldown(candle.timestamp)) {
+      return strategyApi.skip("DEV_TRADE_COOLDOWN");
+    }
+    const candidates = [];
+    if (LOWS.enable && lowsTrendlines.length > 0) {
+      candidates.push({ line: lowsTrendlines[0], direction: LOWS.direction });
+    }
+    if (HIGHS.enable && highsTrendlines.length > 0) {
+      candidates.push({ line: highsTrendlines[0], direction: HIGHS.direction });
+    }
+    if (candidates.length === 0) {
+      return strategyApi.skip("NO_TRENDLINE");
+    }
+    const bestCandidate = pickBestCandidateLine({
+      candle: {
+        timestamp: candle.timestamp,
+        open: candle.open,
+        close: candle.close,
+        high: candle.high,
+        low: candle.low
+      },
+      lines: candidates
+    });
+    if (!bestCandidate) {
+      return strategyApi.skip("NO_TRENDLINE");
+    }
+    const { line: bestLine, direction, candidateContext } = bestCandidate;
+    const modeConfig = direction === "LONG" ? LOWS : HIGHS;
+    const { minRiskRatio } = modeConfig;
+    if (candidateContext.failedBounceBreak) {
+      return strategyApi.skip(
+        "REVERSE_TRENDLINE_STRUCTURE:failed_bounce_break"
+      );
+    }
+    const { fullData, timestamp, currentPrice } = await strategyApi.getMarketData();
+    if (!filterByVeryVolatility(fullData)) {
+      return strategyApi.skip("VERY_VOLATILITY");
+    }
+    const indicators = indicatorsState.snapshot();
+    const signalSeed = buildReverseTrendlineSignalSeed({
+      direction,
+      currentPrice,
+      indicators,
+      bestLine,
+      currentCandle: {
+        timestamp: candle.timestamp,
+        open: candle.open,
+        close: candle.close,
+        high: candle.high,
+        low: candle.low
+      }
+    });
+    const structuralContext = buildReverseTrendlineStructuralContext(signalSeed);
+    const timingContext = buildReverseTrendlineTimingContext({
+      signal: signalSeed,
+      candles: fullData,
+      structuralContext
+    });
+    if (!timingContext.entryReadyNow) {
+      const timingCode = timingContext.entryTiming === "stale_reaction" ? "STALE_REACTION" : timingContext.entryTiming === "wait_reaction_confirmation" ? "WAIT_REACTION_CONFIRMATION" : "WAIT_TOUCH";
+      return strategyApi.skip(`REVERSE_TRENDLINE_TIMING:${timingCode}`);
+    }
+    const riskPlan = buildReverseTrendlineRiskPlan({
+      direction,
+      modeConfig,
+      structuralContext,
+      timingContext
+    });
+    const { stopLossPrice, takeProfitPrice, riskRatio, qty } = strategyApi.getDirectionalTpSlPrices({
+      price: currentPrice,
+      direction,
+      takeProfitDelta: riskPlan.takeProfitDelta,
+      stopLossDelta: riskPlan.stopLossDelta,
+      unit: "percent",
+      maxLossValue: MAX_LOSS_VALUE,
+      feePercent: Number(FEE_PERCENT ?? 0)
+    });
+    if (!qty || !Number.isFinite(qty) || qty <= 0) {
+      return strategyApi.skip("INVALID_QTY");
+    }
+    if (riskRatio <= minRiskRatio) {
+      return strategyApi.skip(`RISK_RATIO:${round2(riskRatio)}`);
+    }
+    lastTradeController.markTrade(timestamp);
+    return strategyApi.entry({
+      code: "REVERSE_TRENDLINE_SIGNAL",
+      figures: {
+        ...buildReverseTrendLineFigures(bestLine)
+      },
+      direction,
+      indicators,
+      additionalIndicators: buildReverseTrendlineSignalSeed({
+        direction,
+        currentPrice,
+        indicators,
+        bestLine,
+        currentCandle: {
+          timestamp: candle.timestamp,
+          open: candle.open,
+          close: candle.close,
+          high: candle.high,
+          low: candle.low
+        },
+        reverseTrendlineTiming: timingContext
+      }).additionalIndicators,
+      orderPlan: {
+        qty,
+        stopLossPrice,
+        takeProfits: [{ rate: 1, price: takeProfitPrice }]
+      }
+    });
+  };
+};
+
+// src/ReverseTrendLine/strategy.ts
+var ReverseTrendLineStrategyCreator = createStrategyRuntime({
+  strategyName: "ReverseTrendLine",
+  defaults: config,
+  createCore: createReverseTrendLineCore,
+  manifest: reverseTrendLineManifest,
+  strategyDirectory: __dirname
+});
+export {
+  ReverseTrendLineStrategyCreator
+};

package/dist/{strategy-Y4SOK6FF.mjs → strategy-JQIJILHQ.mjs}

@@ -1,6 +1,7 @@
 import {
-  breakoutManifest
-} from "./chunk-3PN7ZSJJ.mjs";
+  breakoutManifest,
+  config
+} from "./chunk-37ZWRG3W.mjs";
 import {
   __commonJS,
   __toESM
@@ -12,9 +13,9 @@ var require_lodash = __commonJS({
     "use strict";
     (function() {
       var undefined;
-      var VERSION = "4.17.21";
+      var VERSION = "4.18.1";
       var LARGE_ARRAY_SIZE = 200;
-      var CORE_ERROR_TEXT = "Unsupported core-js use. Try https://npms.io/search?q=ponyfill.", FUNC_ERROR_TEXT = "Expected a function", INVALID_TEMPL_VAR_ERROR_TEXT = "Invalid `variable` option passed into `_.template`";
+      var CORE_ERROR_TEXT = "Unsupported core-js use. Try https://npms.io/search?q=ponyfill.", FUNC_ERROR_TEXT = "Expected a function", INVALID_TEMPL_VAR_ERROR_TEXT = "Invalid `variable` option passed into `_.template`", INVALID_TEMPL_IMPORTS_ERROR_TEXT = "Invalid `imports` option passed into `_.template`";
       var HASH_UNDEFINED = "__lodash_hash_undefined__";
       var MAX_MEMOIZE_SIZE = 500;
       var PLACEHOLDER = "__lodash_placeholder__";
@@ -1940,8 +1941,21 @@ var require_lodash = __commonJS({
         }
         function baseUnset(object, path) {
           path = castPath(path, object);
-          object = parent(object, path);
-          return object == null || delete object[toKey(last(path))];
+          var index = -1, length = path.length;
+          if (!length) {
+            return true;
+          }
+          while (++index < length) {
+            var key = toKey(path[index]);
+            if (key === "__proto__" && !hasOwnProperty.call(object, "__proto__")) {
+              return false;
+            }
+            if ((key === "constructor" || key === "prototype") && index < length - 1) {
+              return false;
+            }
+          }
+          var obj = parent(object, path);
+          return obj == null || delete obj[toKey(last(path))];
         }
         function baseUpdate(object, path, updater, customizer) {
           return baseSet(object, path, updater(baseGet(object, path)), customizer);
@@ -3268,7 +3282,7 @@ var require_lodash = __commonJS({
           var index = -1, length = pairs == null ? 0 : pairs.length, result2 = {};
           while (++index < length) {
             var pair = pairs[index];
-            result2[pair[0]] = pair[1];
+            baseAssignValue(result2, pair[0], pair[1]);
           }
           return result2;
         }
@@ -4652,8 +4666,13 @@ var require_lodash = __commonJS({
             options = undefined;
           }
           string = toString(string);
-          options = assignInWith({}, options, settings, customDefaultsAssignIn);
-          var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn), importsKeys = keys(imports), importsValues = baseValues(imports, importsKeys);
+          options = assignWith({}, options, settings, customDefaultsAssignIn);
+          var imports = assignWith({}, options.imports, settings.imports, customDefaultsAssignIn), importsKeys = keys(imports), importsValues = baseValues(imports, importsKeys);
+          arrayEach(importsKeys, function(key) {
+            if (reForbiddenIdentifierChars.test(key)) {
+              throw new Error(INVALID_TEMPL_IMPORTS_ERROR_TEXT);
+            }
+          });
           var isEscaping, isEvaluating, index = 0, interpolate = options.interpolate || reNoMatch, source = "__p += '";
           var reDelimiters = RegExp2(
             (options.escape || reNoMatch).source + "|" + interpolate.source + "|" + (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + "|" + (options.evaluate || reNoMatch).source + "|$",
@@ -5490,106 +5509,6 @@ var require_lodash = __commonJS({
 // src/Breakout/strategy.ts
 import { createStrategyRuntime } from "@tradejs/node/strategies";
 
-// src/Breakout/config.ts
-var config = {
-  ML_ENABLED: false,
-  MA_FAST: 49,
-  MA_MEDIUM: 49,
-  MA_SLOW: 99,
-  OBV_SMA: 10,
-  ATR: 14,
-  ATR_PCT_SHORT: 7,
-  ATR_PCT_LONG: 30,
-  BB: 20,
-  BB_STD: 2,
-  MACD_FAST: 12,
-  MACD_SLOW: 26,
-  MACD_SIGNAL: 9,
-  LEVEL_LOOKBACK: 20,
-  LEVEL_DELAY: 2,
-  ATR_PERIOD: 14,
-  BB_PERIOD: 20,
-  BB_STDDEV: 2,
-  LIMIT: 100,
-  ATR_OPEN: 0.5,
-  ATR_CLOSE: 1.5,
-  OBV_SMA_PERIOD: 10,
-  BREAKOUT_LOOKBACK_DELAY: 2,
-  BREAKOUT_LOOKBACK: 20,
-  REQUIRED_SCORE_LONG: 7,
-  REQUIRED_SCORE_SHORT: 7,
-  SIGNALS_LONG: {
-    VOLATILE: {
-      weight: 1,
-      required: true
-    },
-    SMA_UPTREND: {
-      weight: 1,
-      required: true
-    },
-    OBV_ABOVE_SMA: {
-      weight: 1,
-      required: true
-    },
-    PREV_HIGH_BREAKOUT: {
-      weight: 1,
-      required: false
-    },
-    CLOSE_ABOVE_UPPER_BB: {
-      weight: 1,
-      required: false
-    },
-    CLOSE_ABOVE_HIGH_LEVEL: {
-      weight: 1,
-      required: false
-    },
-    CLOSE_ABOVE_PREV_CLOSE: {
-      weight: 1,
-      required: false
-    }
-  },
-  SIGNALS_SHORT: {
-    VOLATILE: {
-      weight: 1,
-      required: true
-    },
-    SMA_DOWNTREND: {
-      weight: 1,
-      required: true
-    },
-    OBV_BELOW_SMA: {
-      weight: 1,
-      required: true
-    },
-    PREV_LOW_BREAKDOWN: {
-      weight: 1,
-      required: false
-    },
-    CLOSE_BELOW_LOWER_BB: {
-      weight: 1,
-      required: false
-    },
-    CLOSE_BELOW_LOW_LEVEL: {
-      weight: 1,
-      required: false
-    },
-    CLOSE_BELOW_PREV_CLOSE: {
-      weight: 1,
-      required: false
-    }
-  },
-  TP_LONG: [
-    { profit: 0.1, rate: 0.25 },
-    { profit: 0.15, rate: 0.5 }
-  ],
-  TP_SHORT: [
-    { profit: 0.05, rate: 0.25 },
-    { profit: 0.1, rate: 0.5 }
-  ],
-  SL_LONG: 0.06,
-  SL_SHORT: 0.03
-};
-
 // src/Breakout/core.ts
 var import_lodash = __toESM(require_lodash());