@tradejs/core 1.0.0

package/dist/backtest.mjs

@@ -0,0 +1,355 @@
+import {
+  uuid
+} from "./chunk-NQ7D3T4E.mjs";
+import {
+  absReturns,
+  equityPoints,
+  mean,
+  relReturns,
+  round,
+  sum
+} from "./chunk-AYC2QVKI.mjs";
+import {
+  compactOrderLog,
+  getTimeline,
+  getTimestamp
+} from "./chunk-PXLXXXLA.mjs";
+import {
+  BACKTEST_PRELOAD_DAYS,
+  TestThresholdsConfig
+} from "./chunk-JG2QPVAV.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_PRELOAD_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
+      };
+    })
+  );
+};
+
+// src/utils/tests.ts
+var parseTestName = (testName) => {
+  const [symbol, testSuiteId, testId] = testName.split("_");
+  return { symbol, testSuiteId, testId };
+};
+
+// src/utils/stat.ts
+import {
+  startOfMonth,
+  endOfMonth,
+  addMonths,
+  differenceInMilliseconds
+} from "date-fns";
+var calcStreaks = (retsAbs) => {
+  let maxW = 0, maxL = 0, cw = 0, cl = 0;
+  for (const r of retsAbs) {
+    if (r > 0) {
+      cw++;
+      cl = 0;
+      if (cw > maxW) maxW = cw;
+    } else if (r < 0) {
+      cl++;
+      cw = 0;
+      if (cl > maxL) maxL = cl;
+    } else {
+      cw = 0;
+      cl = 0;
+    }
+  }
+  return { maxConsecutiveWins: maxW, maxConsecutiveLosses: maxL };
+};
+var calculateMaxDrawdown = (amounts) => {
+  let max = amounts[0];
+  let maxDrawdown = 0;
+  for (const amount of amounts) {
+    if (amount > max) {
+      max = amount;
+    }
+    const drawdown = (max - amount) / max * 100;
+    if (drawdown > maxDrawdown) {
+      maxDrawdown = drawdown;
+    }
+  }
+  return maxDrawdown;
+};
+var computeMonthlyEquityStats = (positionLogData, opts) => {
+  const MAR = opts?.mar ?? 0;
+  const useSample = !!opts?.sampleStd;
+  const tsMul = (opts?.tsUnit ?? "ms") === "s" ? 1e3 : 1;
+  if (!positionLogData.length) {
+    return {
+      eomSeries: [],
+      monthlyReturns: [],
+      monthlyMean: 0,
+      monthlyStd: 0,
+      monthlyDownsideStd: 0,
+      sharpeMonthly: null,
+      sharpeMonthlyAnnualized: null,
+      sortinoMonthly: null,
+      sortinoMonthlyAnnualized: null,
+      positiveMonths: 0,
+      maxMonthlyGain: 0,
+      maxMonthlyDrop: 0
+    };
+  }
+  const equityPoints2 = positionLogData.flatMap((p) => [
+    { ts: p.open.timestamp * tsMul, amount: p.open.amount },
+    { ts: p.close.timestamp * tsMul, amount: p.close.amount }
+  ]).sort((a, b) => a.ts - b.ts);
+  const startTs = equityPoints2[0].ts;
+  const endTs = equityPoints2[equityPoints2.length - 1].ts;
+  const eomSeries = [];
+  let monthCursor = startOfMonth(new Date(startTs));
+  const lastMonth = endOfMonth(new Date(endTs));
+  let i = 0;
+  let lastAmount = equityPoints2[0].amount;
+  while (monthCursor <= lastMonth) {
+    const eom = endOfMonth(monthCursor);
+    const eomTs = eom.getTime();
+    while (i < equityPoints2.length && equityPoints2[i].ts <= eomTs) {
+      lastAmount = equityPoints2[i].amount;
+      i += 1;
+    }
+    const key = `${eom.getFullYear()}-${String(eom.getMonth() + 1).padStart(2, "0")}`;
+    eomSeries.push({ month: key, ts: eomTs, amount: lastAmount });
+    monthCursor = addMonths(monthCursor, 1);
+  }
+  const monthlyReturns = [];
+  for (let k = 1; k < eomSeries.length; k++) {
+    const prev = eomSeries[k - 1].amount;
+    const curr = eomSeries[k].amount;
+    monthlyReturns.push(prev > 0 ? curr / prev - 1 : 0);
+  }
+  const n = monthlyReturns.length;
+  const monthlyMean = n ? monthlyReturns.reduce((a, b) => a + b, 0) / n : 0;
+  const variance = n ? monthlyReturns.reduce((a, v) => a + (v - monthlyMean) ** 2, 0) / (useSample && n > 1 ? n - 1 : n) : 0;
+  const monthlyStd = Math.sqrt(variance);
+  const downside = monthlyReturns.map((r) => Math.min(r - MAR, 0)).filter((v) => v < 0);
+  const nd = downside.length;
+  const downsideVar = nd ? downside.reduce((a, v) => a + v * v, 0) / (useSample && nd > 1 ? nd - 1 : nd) : 0;
+  const monthlyDownsideStd = Math.sqrt(downsideVar);
+  const sharpeMonthly = monthlyStd > 0 ? (monthlyMean - MAR) / monthlyStd : null;
+  const sortinoMonthly = monthlyDownsideStd > 0 ? (monthlyMean - MAR) / monthlyDownsideStd : null;
+  const sharpeMonthlyAnnualized = sharpeMonthly === null ? null : sharpeMonthly * Math.sqrt(12);
+  const sortinoMonthlyAnnualized = sortinoMonthly === null ? null : sortinoMonthly * Math.sqrt(12);
+  const positiveMonths = monthlyReturns.filter((r) => r > 0).length;
+  const maxMonthlyGain = n ? Math.max(...monthlyReturns) : 0;
+  const maxMonthlyDrop = n ? Math.min(...monthlyReturns) : 0;
+  return {
+    eomSeries,
+    monthlyReturns,
+    monthlyMean,
+    monthlyStd,
+    monthlyDownsideStd,
+    sharpeMonthly,
+    sharpeMonthlyAnnualized,
+    sortinoMonthly,
+    sortinoMonthlyAnnualized,
+    positiveMonths,
+    maxMonthlyGain,
+    maxMonthlyDrop
+  };
+};
+var calculateStatsFull = (positionLogData) => {
+  if (!positionLogData.length) return null;
+  const retsAbs = absReturns(positionLogData);
+  const retsRel = relReturns(positionLogData);
+  const points = equityPoints(positionLogData);
+  const startTs = points[0].ts;
+  const endTs = points[points.length - 1].ts;
+  const periodMs = differenceInMilliseconds(new Date(endTs), new Date(startTs));
+  const periodDays = periodMs / (1e3 * 60 * 60 * 24);
+  const periodMonths = periodDays / 30.4375;
+  const trades = positionLogData.length;
+  const tradesPerMonth = periodMonths > 0 ? trades / periodMonths : 0;
+  const durations = positionLogData.map(
+    (p) => p.close.timestamp - p.open.timestamp
+  );
+  const totalTime = endTs - startTs;
+  const exposure = totalTime > 0 ? sum(durations) / totalTime * 100 : 0;
+  const initialAmount = points[0].amount;
+  const finalAmount = points[points.length - 1].amount;
+  const netProfit = finalAmount - initialAmount;
+  const totalReturn = initialAmount > 0 ? (finalAmount / initialAmount - 1) * 100 : 0;
+  const cagr = periodMonths > 0 && initialAmount > 0 ? (Math.pow(finalAmount / initialAmount, 12 / periodMonths) - 1) * 100 : 0;
+  const allAmounts = points.map((p) => p.amount);
+  const maxDrawdown = calculateMaxDrawdown(allAmounts);
+  const calmar = maxDrawdown > 0 ? cagr / maxDrawdown : null;
+  const wins = retsAbs.filter((x) => x > 0).length;
+  const losses = retsAbs.filter((x) => x <= 0).length;
+  const winRate = trades ? wins / trades * 100 : 0;
+  const avgWinAbs = mean(retsAbs.filter((x) => x > 0));
+  const avgLossAbs = Math.abs(mean(retsAbs.filter((x) => x < 0)));
+  const payoff = avgLossAbs > 0 ? avgWinAbs / avgLossAbs : null;
+  const avgWinRel = mean(retsRel.filter((x) => x > 0));
+  const avgLossRel = Math.abs(mean(retsRel.filter((x) => x < 0)));
+  const pWin = trades ? wins / trades : 0;
+  const expectancyPerTrade = (pWin * avgWinRel - (1 - pWin) * avgLossRel) * 100;
+  const { maxConsecutiveWins, maxConsecutiveLosses } = calcStreaks(retsAbs);
+  const monthly = computeMonthlyEquityStats(positionLogData, {
+    mar: 0,
+    // MAR=0, при желании можно параметризовать
+    sampleStd: false,
+    // population std
+    tsUnit: "ms"
+    // timestamps в миллисекундах
+  });
+  const sharpe = (monthly.sharpeMonthly ?? null) !== null ? monthly.sharpeMonthly * Math.sqrt(12) : null;
+  const res = {
+    // Период и частота
+    periodDays: round(periodDays),
+    periodMonths: round(periodMonths),
+    orders: trades,
+    wins,
+    losses,
+    ordersPerMonth: round(tradesPerMonth),
+    exposure: round(exposure),
+    // Доходность
+    amount: round(finalAmount),
+    maxAmount: round(Math.max(...allAmounts)),
+    minAmount: round(Math.min(...allAmounts)),
+    netProfit: round(netProfit),
+    totalReturn: round(totalReturn),
+    cagr: round(cagr),
+    // Риск и Calmar
+    maxDrawdown: round(maxDrawdown),
+    calmar: calmar === null ? null : round(calmar),
+    // Качество сделок
+    winRate: round(winRate),
+    riskRewardRatio: payoff === null ? null : round(payoff),
+    expectancy: round(expectancyPerTrade),
+    maxConsecutiveWins,
+    maxConsecutiveLosses,
+    // Sharpe (годовой) по месячным ретёрнам equity
+    sharpeRatio: sharpe === null ? null : round(sharpe)
+  };
+  const score = getBacktestScore(res);
+  return {
+    ...res,
+    score
+  };
+};
+var classifyMetric = (name, value) => {
+  const { thresholds, direction } = TestThresholdsConfig[name];
+  if (direction === "higher") {
+    if (value >= thresholds[1]) return "success";
+    if (value >= thresholds[0]) return "warning";
+    return "error";
+  } else {
+    if (value <= thresholds[1]) return "success";
+    if (value <= thresholds[0]) return "warning";
+    return "error";
+  }
+};
+var getBacktestScore = (stat) => {
+  if (!stat) {
+    return 0;
+  }
+  const netProfit = Number(stat.netProfit ?? 0);
+  const winRate = Number(stat.winRate ?? 0);
+  if (!Number.isFinite(netProfit) || !Number.isFinite(winRate)) {
+    return 0;
+  }
+  return Math.round(netProfit * winRate);
+};
+var sortBestTests = (results, limit = 5) => {
+  return results.sort((a, b) => (b.stat.amount ?? 0) - (a.stat.amount ?? 0)).slice(0, limit);
+};
+var getFormatted = (stat, key) => {
+  if (!stat) {
+    return {
+      formatted: "0",
+      level: "error"
+    };
+  }
+  const raw = stat[key];
+  if (raw == null || typeof raw === "string") {
+    return {
+      formatted: String(raw ?? "-"),
+      level: "error"
+    };
+  }
+  const config = TestThresholdsConfig[key];
+  const level = config ? classifyMetric(key, raw) : "success";
+  const formatted = config ? `${raw.toFixed(config.precision)}${config.isPercent ? "%" : ""}${config.isAmount ? "$" : ""}` : String(raw);
+  return {
+    formatted,
+    level
+  };
+};
+export {
+  calculateMaxDrawdown,
+  calculateStatsFull,
+  classifyMetric,
+  compactOrderLog,
+  createTestSuite,
+  generateName,
+  generateParamGrid,
+  getBacktestScore,
+  getFormatted,
+  getTimeline,
+  mergeConfigs,
+  parseTestName,
+  sortBestTests
+};

package/dist/chunk-AYC2QVKI.mjs

@@ -0,0 +1,35 @@
+// src/utils/math.ts
+import _ from "lodash";
+var diffRel = (a, b) => {
+  const min = _.min([a, b]) || 0;
+  const max = _.max([a, b]) || 0;
+  if (!min || !max) {
+    return 0;
+  }
+  return (max - min) / max;
+};
+var round = (value, precision = 2) => precision > 0 ? Math.round(value * 10 ** precision) / 10 ** precision : Math.round(value);
+var sum = (xs) => xs.reduce((a, b) => a + b, 0);
+var mean = (xs) => xs.length ? sum(xs) / xs.length : 0;
+var absReturns = (data) => data.map((p) => p.close.amount - p.open.amount);
+var relReturns = (data) => data.map((p) => (p.close.amount - p.open.amount) / p.open.amount);
+var equityPoints = (data) => data.flatMap((p) => [
+  { ts: p.open.timestamp, amount: p.open.amount },
+  { ts: p.close.timestamp, amount: p.close.amount }
+]).sort((a, b) => a.ts - b.ts);
+var formatNumber = (n, digits = 6) => {
+  if (n === null || n === void 0 || !Number.isFinite(n)) return null;
+  const useDigits = Math.abs(n) >= 1e3 ? 0 : digits;
+  return n.toFixed(useDigits);
+};
+
+export {
+  diffRel,
+  round,
+  sum,
+  mean,
+  absReturns,
+  relReturns,
+  equityPoints,
+  formatNumber
+};

package/dist/chunk-JG2QPVAV.mjs

@@ -0,0 +1,190 @@
+// src/constants/index.ts
+var FEE_PERCENT = 5e-3;
+var CORRELATION_WINDOW = 50;
+var SPREAD_WINDOW = 50;
+var PRELOAD_DAYS = 200;
+var SIGNALS_PRELOAD_DAYS = 60;
+var BACKTEST_PRELOAD_DAYS = 160;
+var DASHBOARD_PRELOAD_DAYS = 160;
+var BOT_PRELOAD_DAYS = 160;
+var PRELOAD_FALLBACK_DAYS = 160;
+var TTL_1H = 3600;
+var TTL_3H = 10800;
+var TTL_12H = 43300;
+var TTL_1D = 86400;
+var TTL_1M = 26e5;
+var TTL_3M = 78e5;
+var TESTS_TOP_LIMIT = 50;
+var TESTS_LIMIT = 1e5;
+var TESTS_ORDERS_MIN_LIMIT = 3;
+var MARKET_CATEGORY = "linear";
+var ML_CANDLE_FEATURE_WINDOW = 50;
+var ML_BASE_CANDLES_WINDOW = 50;
+var TRENDLINE_DEFAULTS = {
+  maxLines: 20,
+  range: 15,
+  firstRange: 80,
+  epsilon: 3e-3,
+  epsilonOffset: 5e-3,
+  minTouches: 4,
+  minDistance: 50,
+  minTouchGap: 15,
+  maxTouchGap: 60,
+  offset: 1e3,
+  capture: false,
+  bestLines: 4,
+  maxDistance: 2e3
+};
+var TestThresholdsConfig = {
+  // Период и частота — используем как требования к качеству теста, в скоринг не влияют
+  periodDays: {
+    thresholds: [30, 120],
+    direction: "higher",
+    precision: 0
+  },
+  periodMonths: {
+    thresholds: [1, 6],
+    direction: "higher",
+    precision: 2
+  },
+  orders: {
+    thresholds: [30, 200],
+    direction: "higher",
+    precision: 0
+  },
+  wins: {
+    thresholds: [30, 100],
+    direction: "higher",
+    precision: 0
+  },
+  losses: {
+    thresholds: [20, 50],
+    direction: "lower",
+    precision: 0
+  },
+  ordersPerMonth: {
+    thresholds: [4, 20],
+    direction: "higher",
+    precision: 2
+  },
+  exposure: {
+    thresholds: [20, 60],
+    direction: "higher",
+    isPercent: true,
+    precision: 1
+  },
+  // Доходность
+  amount: {
+    thresholds: [105, 120],
+    direction: "higher",
+    isAmount: true,
+    precision: 2
+  },
+  maxAmount: {
+    thresholds: [140, 180],
+    direction: "higher",
+    isAmount: true,
+    precision: 2
+  },
+  minAmount: {
+    thresholds: [80, 90],
+    direction: "higher",
+    isAmount: true,
+    precision: 2
+  },
+  netProfit: {
+    thresholds: [5, 20],
+    direction: "higher",
+    isAmount: true,
+    precision: 2
+  },
+  totalReturn: {
+    thresholds: [10, 50],
+    direction: "higher",
+    isPercent: true,
+    precision: 1
+  },
+  cagr: {
+    thresholds: [15, 40],
+    direction: "higher",
+    isPercent: true,
+    precision: 1
+  },
+  // Риск и риск/доходность
+  maxDrawdown: {
+    thresholds: [25, 12],
+    direction: "lower",
+    isPercent: true,
+    precision: 1
+  },
+  calmar: {
+    thresholds: [0.5, 2],
+    direction: "higher",
+    precision: 2
+  },
+  // Качество сделок
+  winRate: {
+    thresholds: [40, 60],
+    direction: "higher",
+    isPercent: true,
+    precision: 1
+  },
+  riskRewardRatio: {
+    thresholds: [1.5, 2.5],
+    direction: "higher",
+    precision: 2
+  },
+  expectancy: {
+    thresholds: [0.3, 1],
+    direction: "higher",
+    isPercent: true,
+    precision: 2
+  },
+  maxConsecutiveWins: {
+    thresholds: [2, 6],
+    direction: "higher",
+    precision: 0
+  },
+  maxConsecutiveLosses: {
+    thresholds: [5, 2],
+    direction: "lower",
+    precision: 0
+  },
+  // Sharpe (годовой, по месячным ретернам equity)
+  sharpeRatio: {
+    thresholds: [0.5, 1.5],
+    direction: "higher",
+    precision: 2
+  },
+  score: {
+    thresholds: [10, 100],
+    direction: "higher",
+    precision: 0
+  }
+};
+
+export {
+  FEE_PERCENT,
+  CORRELATION_WINDOW,
+  SPREAD_WINDOW,
+  PRELOAD_DAYS,
+  SIGNALS_PRELOAD_DAYS,
+  BACKTEST_PRELOAD_DAYS,
+  DASHBOARD_PRELOAD_DAYS,
+  BOT_PRELOAD_DAYS,
+  PRELOAD_FALLBACK_DAYS,
+  TTL_1H,
+  TTL_3H,
+  TTL_12H,
+  TTL_1D,
+  TTL_1M,
+  TTL_3M,
+  TESTS_TOP_LIMIT,
+  TESTS_LIMIT,
+  TESTS_ORDERS_MIN_LIMIT,
+  MARKET_CATEGORY,
+  ML_CANDLE_FEATURE_WINDOW,
+  ML_BASE_CANDLES_WINDOW,
+  TRENDLINE_DEFAULTS,
+  TestThresholdsConfig
+};