@tradejs/core 1.0.9 → 1.0.10

package/dist/backtest.mjs

@@ -1,6 +1,3 @@
-import {
-  uuid
-} from "./chunk-AJK4NS7Y.mjs";
 import {
   absReturns,
   equityPoints,
@@ -11,82 +8,11 @@ import {
 } from "./chunk-AYC2QVKI.mjs";
 import {
   compactOrderLog,
-  getTimeline,
-  getTimestamp
-} from "./chunk-FNLPYYML.mjs";
+  getTimeline
+} from "./chunk-PNBS6J3G.mjs";
 import {
-  BACKTEST_DEFAULT_DAYS,
   TestThresholdsConfig
-} from "./chunk-2ORZC66W.mjs";
-
-// src/utils/grid.ts
-import _ from "lodash";
-var generateParamGrid = (paramOptions) => {
-  const keys = Object.keys(paramOptions);
-  const combinations = [];
-  const helper = (index = 0, current = {}) => {
-    if (index === keys.length) {
-      combinations.push(current);
-      return;
-    }
-    const key = keys[index];
-    for (const value of paramOptions[key] || []) {
-      const copiedValue = typeof value === "object" && value !== null ? structuredClone(value) : value;
-      helper(index + 1, {
-        ...current,
-        [key]: copiedValue
-      });
-    }
-  };
-  helper();
-  return combinations;
-};
-var generateName = (prefix) => `${prefix}_${uuid(6)}`;
-var mergeConfigs = (configs) => {
-  const result = {};
-  for (const config of configs) {
-    for (const [key, value] of Object.entries(config)) {
-      if (!result[key]) {
-        result[key] = [];
-      }
-      const clonedValue = typeof value === "object" && value !== null ? _.cloneDeep(value) : value;
-      const isDuplicate = result[key].some(
-        (existing) => _.isEqual(existing, value)
-      );
-      if (!isDuplicate) {
-        result[key].push(clonedValue);
-      }
-    }
-  }
-  for (const key in result) {
-    if (result[key].every((v) => typeof v === "number")) {
-      result[key] = _.sortBy(result[key]);
-    }
-  }
-  return result;
-};
-var createTestSuite = (userName, tickers, strategyName, backtestConfig, connectorName) => {
-  const start = getTimestamp(BACKTEST_DEFAULT_DAYS);
-  const end = getTimestamp();
-  const testSuiteId = uuid(6);
-  const paramGrid = generateParamGrid(backtestConfig);
-  return tickers.flatMap(
-    (symbol) => paramGrid.map((params) => {
-      const testId = uuid(6);
-      return {
-        userName,
-        name: `${symbol}_${testSuiteId}_${testId}`,
-        testId,
-        testSuiteId,
-        symbol,
-        options: { start, end },
-        strategyName,
-        strategyConfig: params,
-        connectorName
-      };
-    })
-  );
-};
+} from "./chunk-DXJ4NCFJ.mjs";
 
 // src/utils/tests.ts
 var parseTestName = (testName) => {
@@ -133,6 +59,412 @@ var calculateMaxDrawdown = (amounts) => {
   }
   return maxDrawdown;
 };
+var MS_IN_DAY = 24 * 60 * 60 * 1e3;
+var DAYS_IN_YEAR = 365;
+var isFiniteMetric = (value) => typeof value === "number" && Number.isFinite(value);
+var safeRatio = (numerator, denominator) => {
+  if (!isFiniteMetric(numerator) || !isFiniteMetric(denominator)) {
+    return null;
+  }
+  if (Math.abs(denominator) <= Number.EPSILON) {
+    return null;
+  }
+  return numerator / denominator;
+};
+var percentile = (values, p) => {
+  if (!values.length) {
+    return null;
+  }
+  const sorted = [...values].sort((a, b) => a - b);
+  const index = (sorted.length - 1) * p;
+  const lower = Math.floor(index);
+  const upper = Math.ceil(index);
+  if (lower === upper) {
+    return sorted[lower];
+  }
+  const weight = index - lower;
+  return sorted[lower] * (1 - weight) + sorted[upper] * weight;
+};
+var medianValue = (values) => percentile(values, 0.5);
+var getMonthKey = (timestamp) => {
+  const date = new Date(timestamp);
+  return `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, "0")}`;
+};
+var getQuarterKey = (timestamp) => {
+  const date = new Date(timestamp);
+  return `${date.getUTCFullYear()} Q${Math.floor(date.getUTCMonth() / 3) + 1}`;
+};
+var resolveTradeSession = (timestamp) => {
+  const hour = new Date(timestamp).getUTCHours();
+  if (hour < 8) {
+    return "Asia";
+  }
+  if (hour < 16) {
+    return "Europe";
+  }
+  return "US";
+};
+var getDateKey = (timestamp) => {
+  const date = new Date(timestamp);
+  return `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, "0")}-${String(date.getUTCDate()).padStart(2, "0")}`;
+};
+var calculateDrawdownStats = (trades, orderLog) => {
+  const explicitPoints = (orderLog ?? []).map((point) => ({ timestamp: point[0], amount: point[1] })).filter(
+    (point) => isFiniteMetric(point.timestamp) && isFiniteMetric(point.amount)
+  ).sort((a, b) => a.timestamp - b.timestamp);
+  const points = explicitPoints.length ? explicitPoints : trades.slice().sort((a, b) => a.timestamp - b.timestamp).reduce(
+    (acc, trade) => {
+      const previous = acc[acc.length - 1]?.amount ?? 0;
+      acc.push({
+        timestamp: trade.timestamp,
+        amount: previous + trade.pnl
+      });
+      return acc;
+    },
+    [{ timestamp: trades[0]?.timestamp ?? 0, amount: 0 }]
+  );
+  if (!points.length) {
+    return { absolute: null, percent: null };
+  }
+  let peak = points[0].amount;
+  let maxAbsolute = 0;
+  let maxPercent = 0;
+  for (const point of points) {
+    if (point.amount > peak) {
+      peak = point.amount;
+    }
+    const absolute = peak - point.amount;
+    maxAbsolute = Math.max(maxAbsolute, absolute);
+    if (peak > 0) {
+      maxPercent = Math.max(maxPercent, absolute / peak * 100);
+    }
+  }
+  return { absolute: maxAbsolute, percent: maxPercent };
+};
+var calculateWorstRollingPnl = (trades, days) => {
+  if (!trades.length) {
+    return null;
+  }
+  const sorted = trades.slice().sort((a, b) => a.timestamp - b.timestamp);
+  const windowMs = days * MS_IN_DAY;
+  let start = 0;
+  let rollingPnl = 0;
+  let worstPnl = 0;
+  for (let end = 0; end < sorted.length; end += 1) {
+    rollingPnl += sorted[end].pnl;
+    while (start <= end && sorted[end].timestamp - sorted[start].timestamp > windowMs) {
+      rollingPnl -= sorted[start].pnl;
+      start += 1;
+    }
+    worstPnl = Math.min(worstPnl, rollingPnl);
+  }
+  return worstPnl;
+};
+var calculateLossStreak = (trades) => {
+  let current = 0;
+  let max = 0;
+  for (const trade of trades.slice().sort((a, b) => a.timestamp - b.timestamp)) {
+    if (trade.pnl < 0) {
+      current += 1;
+      max = Math.max(max, current);
+      continue;
+    }
+    current = 0;
+  }
+  return max;
+};
+var normalizeExitReason = (reason) => {
+  const normalized = String(reason ?? "").trim().toLowerCase();
+  if (normalized === "tp" || normalized === "take_profit") {
+    return "takeProfit";
+  }
+  if (normalized === "sl" || normalized === "stop_loss") {
+    return "stopLoss";
+  }
+  if (normalized === "exit" || normalized === "close" || normalized === "closed") {
+    return "exit";
+  }
+  return "unknown";
+};
+var calculateExitBreakdown = (trades) => {
+  const counts = {
+    takeProfit: 0,
+    stopLoss: 0,
+    exit: 0,
+    unknown: 0
+  };
+  for (const trade of trades) {
+    counts[normalizeExitReason(trade.exitReason)] += 1;
+  }
+  const total = trades.length;
+  const bucket = (count) => ({
+    count,
+    share: total ? count / total * 100 : null
+  });
+  return {
+    takeProfit: bucket(counts.takeProfit),
+    stopLoss: bucket(counts.stopLoss),
+    exit: bucket(counts.exit),
+    unknown: bucket(counts.unknown)
+  };
+};
+var calculateDailyPnlSeries = (trades, startTimestamp, endTimestamp) => {
+  const approvedTrades = trades.filter((trade) => trade.approved !== false);
+  if (!approvedTrades.length) {
+    return [];
+  }
+  const firstTimestamp = startTimestamp ?? Math.min(...approvedTrades.map((trade) => trade.timestamp));
+  const lastTimestamp = endTimestamp ?? Math.max(...approvedTrades.map((trade) => trade.timestamp));
+  if (!isFiniteMetric(firstTimestamp) || !isFiniteMetric(lastTimestamp) || lastTimestamp < firstTimestamp) {
+    return [];
+  }
+  const startDate = Date.UTC(
+    new Date(firstTimestamp).getUTCFullYear(),
+    new Date(firstTimestamp).getUTCMonth(),
+    new Date(firstTimestamp).getUTCDate()
+  );
+  const endDate = Date.UTC(
+    new Date(lastTimestamp).getUTCFullYear(),
+    new Date(lastTimestamp).getUTCMonth(),
+    new Date(lastTimestamp).getUTCDate()
+  );
+  const daily = /* @__PURE__ */ new Map();
+  for (let ts = startDate; ts <= endDate; ts += MS_IN_DAY) {
+    daily.set(getDateKey(ts), 0);
+  }
+  for (const trade of approvedTrades) {
+    const key = getDateKey(trade.timestamp);
+    daily.set(key, (daily.get(key) ?? 0) + trade.pnl);
+  }
+  return [...daily.values()];
+};
+var calculateStd = (values, valueMean) => {
+  if (!values.length) {
+    return 0;
+  }
+  return Math.sqrt(
+    values.reduce((acc, value) => acc + (value - valueMean) ** 2, 0) / values.length
+  );
+};
+var calculateSkewness = (values) => {
+  if (values.length < 3) {
+    return null;
+  }
+  const valueMean = mean(values);
+  const std = calculateStd(values, valueMean);
+  if (std <= Number.EPSILON) {
+    return null;
+  }
+  return values.reduce((acc, value) => acc + ((value - valueMean) / std) ** 3, 0) / values.length;
+};
+var sumTopPositiveProfitShare = (pnls, count) => {
+  const grossProfit = pnls.filter((pnl) => pnl > 0).reduce((acc, pnl) => acc + pnl, 0);
+  if (grossProfit <= 0) {
+    return null;
+  }
+  const topProfit = pnls.filter((pnl) => pnl > 0).sort((a, b) => b - a).slice(0, count).reduce((acc, pnl) => acc + pnl, 0);
+  return topProfit / grossProfit * 100;
+};
+var concentrationPercent = (items, limit) => {
+  const totals = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    totals.set(item.key, (totals.get(item.key) ?? 0) + Math.abs(item.pnl));
+  }
+  const totalAbsPnl = [...totals.values()].reduce(
+    (acc, value) => acc + value,
+    0
+  );
+  if (totalAbsPnl <= 0) {
+    return null;
+  }
+  const topAbsPnl = [...totals.values()].sort((a, b) => b - a).slice(0, limit).reduce((acc, value) => acc + value, 0);
+  return topAbsPnl / totalAbsPnl * 100;
+};
+var calculateAdvancedTradeMetrics = ({
+  trades,
+  orderLog,
+  startTimestamp,
+  endTimestamp
+}) => {
+  const normalizedTrades = trades.filter(
+    (trade) => isFiniteMetric(trade.timestamp) && isFiniteMetric(trade.pnl) && trade.timestamp > 0
+  ).sort((a, b) => a.timestamp - b.timestamp);
+  const pnls = normalizedTrades.map((trade) => trade.pnl);
+  const wins = pnls.filter((pnl) => pnl > 0).length;
+  const losses = pnls.filter((pnl) => pnl < 0).length;
+  const totalPnl = sum(pnls);
+  const grossProfit = pnls.filter((pnl) => pnl > 0).reduce((acc, pnl) => acc + pnl, 0);
+  const grossLoss = Math.abs(
+    pnls.filter((pnl) => pnl < 0).reduce((acc, pnl) => acc + pnl, 0)
+  );
+  const avgWin = wins ? grossProfit / wins : null;
+  const avgLoss = losses ? grossLoss / losses : null;
+  const firstTimestamp = startTimestamp ?? normalizedTrades[0]?.timestamp ?? null;
+  const lastTimestamp = endTimestamp ?? normalizedTrades[normalizedTrades.length - 1]?.timestamp ?? null;
+  const periodDays = isFiniteMetric(firstTimestamp) && isFiniteMetric(lastTimestamp) && lastTimestamp > firstTimestamp ? (lastTimestamp - firstTimestamp) / MS_IN_DAY : null;
+  const drawdown = calculateDrawdownStats(normalizedTrades, orderLog);
+  const monthly = /* @__PURE__ */ new Map();
+  const quarterly = /* @__PURE__ */ new Map();
+  for (const trade of normalizedTrades) {
+    const monthKey = getMonthKey(trade.timestamp);
+    const quarterKey = getQuarterKey(trade.timestamp);
+    const month = monthly.get(monthKey) ?? {
+      pnl: 0,
+      orders: 0,
+      wins: 0,
+      timestamp: trade.timestamp
+    };
+    month.pnl += trade.pnl;
+    month.orders += 1;
+    month.wins += trade.pnl > 0 ? 1 : 0;
+    month.timestamp = Math.min(month.timestamp, trade.timestamp);
+    monthly.set(monthKey, month);
+    quarterly.set(quarterKey, (quarterly.get(quarterKey) ?? 0) + trade.pnl);
+  }
+  const monthlyStats = [...monthly.entries()].sort(
+    ([a], [b]) => a.localeCompare(b)
+  );
+  const monthlyPnls = monthlyStats.map(([, stat]) => stat.pnl);
+  const monthlyWinRates = monthlyStats.map(
+    ([, stat]) => stat.orders ? stat.wins / stat.orders * 100 : 0
+  );
+  const positiveMonths = monthlyStats.filter(([, stat]) => stat.pnl > 0).length;
+  const p25Monthly = percentile(monthlyPnls, 0.25);
+  const p75Monthly = percentile(monthlyPnls, 0.75);
+  const dailyPnls = calculateDailyPnlSeries(
+    normalizedTrades,
+    startTimestamp,
+    endTimestamp
+  );
+  const dailyMean = dailyPnls.length ? mean(dailyPnls) : null;
+  const dailyStd = dailyMean === null ? null : calculateStd(dailyPnls, dailyMean);
+  const downsideDailyPnls = dailyPnls.map((pnl) => Math.min(pnl, 0));
+  const downsideStd = downsideDailyPnls.some((pnl) => pnl < 0) ? Math.sqrt(
+    downsideDailyPnls.reduce((acc, pnl) => acc + pnl ** 2, 0) / downsideDailyPnls.length
+  ) : null;
+  const annualizedPnl = dailyMean === null ? null : dailyMean * DAYS_IN_YEAR;
+  const approvedFlags = normalizedTrades.filter(
+    (trade) => typeof trade.approved === "boolean"
+  );
+  const slippageCosts = normalizedTrades.map((trade) => trade.slippageCost).filter(isFiniteMetric);
+  const pnlBeforeSlippage = normalizedTrades.reduce((acc, trade) => {
+    if (isFiniteMetric(trade.grossPnl)) {
+      return acc + trade.grossPnl;
+    }
+    if (isFiniteMetric(trade.slippageCost)) {
+      return acc + trade.pnl + trade.slippageCost;
+    }
+    return acc + trade.pnl;
+  }, 0);
+  const directionStats = normalizedTrades.reduce(
+    (acc, trade) => {
+      const direction = String(trade.direction ?? "").toUpperCase();
+      if (direction === "LONG") {
+        acc.longTrades += 1;
+        acc.longPnl += trade.pnl;
+      }
+      if (direction === "SHORT") {
+        acc.shortTrades += 1;
+        acc.shortPnl += trade.pnl;
+      }
+      return acc;
+    },
+    { longTrades: 0, shortTrades: 0, longPnl: 0, shortPnl: 0 }
+  );
+  return {
+    core: {
+      trades: normalizedTrades.length,
+      wins,
+      losses,
+      winRate: normalizedTrades.length ? wins / normalizedTrades.length * 100 : null,
+      totalPnl,
+      avgTrade: normalizedTrades.length ? totalPnl / normalizedTrades.length : null,
+      grossProfit,
+      grossLoss,
+      profitFactor: safeRatio(grossProfit, grossLoss),
+      payoffRatio: safeRatio(avgWin, avgLoss),
+      expectancy: normalizedTrades.length ? totalPnl / normalizedTrades.length : null,
+      tradesPerDay: periodDays && periodDays > 0 ? normalizedTrades.length / periodDays : null,
+      tradesPerWeek: periodDays && periodDays > 0 ? normalizedTrades.length / periodDays * 7 : null
+    },
+    risk: {
+      maxDrawdown: drawdown.absolute,
+      maxDrawdownPercent: drawdown.percent,
+      maxDrawdownToTotalProfit: totalPnl > 0 ? safeRatio(drawdown.absolute, totalPnl) : null,
+      maxDrawdownToGrossProfit: grossProfit > 0 ? safeRatio(drawdown.absolute, grossProfit) : null,
+      recoveryFactor: safeRatio(totalPnl, drawdown.absolute),
+      maxLossStreak: calculateLossStreak(normalizedTrades),
+      losingMonthsCount: monthlyStats.filter(([, stat]) => stat.pnl < 0).length,
+      worstMonthPnl: monthlyPnls.length ? Math.min(...monthlyPnls) : null,
+      worstRolling30dPnl: calculateWorstRollingPnl(normalizedTrades, 30),
+      worstRolling90dPnl: calculateWorstRollingPnl(normalizedTrades, 90)
+    },
+    stability: {
+      monthlyWinRate: monthlyWinRates.length ? mean(monthlyWinRates) : null,
+      positiveMonthsPercent: monthlyStats.length ? positiveMonths / monthlyStats.length * 100 : null,
+      quarterlyPnl: [...quarterly.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([quarter, pnl]) => ({ quarter, pnl })),
+      rolling365Pnl: normalizedTrades.length && isFiniteMetric(lastTimestamp) ? normalizedTrades.filter(
+        (trade) => lastTimestamp - trade.timestamp <= 365 * MS_IN_DAY
+      ).reduce((acc, trade) => acc + trade.pnl, 0) : null,
+      medianMonthlyPnl: medianValue(monthlyPnls),
+      iqrMonthlyPnl: p25Monthly === null || p75Monthly === null ? null : p75Monthly - p25Monthly,
+      top5ProfitShare: sumTopPositiveProfitShare(pnls, 5),
+      top10ProfitShare: sumTopPositiveProfitShare(pnls, 10)
+    },
+    distribution: {
+      medianTrade: medianValue(pnls),
+      p10Trade: percentile(pnls, 0.1),
+      p25Trade: percentile(pnls, 0.25),
+      p75Trade: percentile(pnls, 0.75),
+      p90Trade: percentile(pnls, 0.9),
+      largestWin: wins ? Math.max(...pnls.filter((pnl) => pnl > 0)) : null,
+      largestLoss: losses ? Math.min(...pnls.filter((pnl) => pnl < 0)) : null,
+      tailRatio: safeRatio(
+        percentile(pnls, 0.95),
+        Math.abs(percentile(pnls, 0.05) ?? 0)
+      ),
+      skewness: calculateSkewness(pnls)
+    },
+    riskAdjusted: {
+      sharpeDaily: dailyMean !== null && dailyStd !== null && dailyStd > 0 ? dailyMean / dailyStd * Math.sqrt(DAYS_IN_YEAR) : null,
+      sortinoDaily: dailyMean !== null && downsideStd !== null && downsideStd > 0 ? dailyMean / downsideStd * Math.sqrt(DAYS_IN_YEAR) : null,
+      calmar: safeRatio(annualizedPnl, drawdown.absolute),
+      mar: safeRatio(annualizedPnl, drawdown.absolute)
+    },
+    operational: {
+      avgSlippageCost: slippageCosts.length ? mean(slippageCosts) : null,
+      pnlBeforeSlippage: normalizedTrades.length ? pnlBeforeSlippage : null,
+      pnlAfterSlippage: totalPnl,
+      approvalRate: approvedFlags.length ? approvedFlags.filter((trade) => trade.approved).length / approvedFlags.length * 100 : null,
+      blockedProfitableTrades: normalizedTrades.filter(
+        (trade) => trade.blocked && trade.pnl > 0
+      ).length,
+      approvedLosingTrades: normalizedTrades.filter(
+        (trade) => trade.approved && trade.pnl < 0
+      ).length,
+      symbolConcentrationTop1: concentrationPercent(
+        normalizedTrades.filter((trade) => trade.symbol).map((trade) => ({ key: String(trade.symbol), pnl: trade.pnl })),
+        1
+      ),
+      symbolConcentrationTop5: concentrationPercent(
+        normalizedTrades.filter((trade) => trade.symbol).map((trade) => ({ key: String(trade.symbol), pnl: trade.pnl })),
+        5
+      ),
+      sessionConcentrationTop1: concentrationPercent(
+        normalizedTrades.map((trade) => ({
+          key: trade.session ?? resolveTradeSession(trade.timestamp),
+          pnl: trade.pnl
+        })),
+        1
+      ),
+      longTrades: directionStats.longTrades,
+      shortTrades: directionStats.shortTrades,
+      longPnl: directionStats.longPnl,
+      shortPnl: directionStats.shortPnl,
+      exitBreakdown: calculateExitBreakdown(normalizedTrades)
+    }
+  };
+};
 var computeMonthlyEquityStats = (positionLogData, opts) => {
   const MAR = opts?.mar ?? 0;
   const useSample = !!opts?.sampleStd;
@@ -291,7 +623,10 @@ var calculateStatsFull = (positionLogData) => {
   };
 };
 var classifyMetric = (name, value) => {
-  const { thresholds, direction } = TestThresholdsConfig[name];
+  const { thresholds, direction, neutralValue } = TestThresholdsConfig[name];
+  if (neutralValue !== void 0 && value === neutralValue) {
+    return "neutral";
+  }
   if (direction === "higher") {
     if (value >= thresholds[1]) return "success";
     if (value >= thresholds[0]) return "warning";
@@ -339,17 +674,14 @@ var getFormatted = (stat, key) => {
   };
 };
 export {
+  calculateAdvancedTradeMetrics,
   calculateMaxDrawdown,
   calculateStatsFull,
   classifyMetric,
   compactOrderLog,
-  createTestSuite,
-  generateName,
-  generateParamGrid,
   getBacktestScore,
   getFormatted,
   getTimeline,
-  mergeConfigs,
   parseTestName,
   sortBestTests
 };