@tradejs/core 1.0.9 → 1.0.11

package/dist/grid.js

@@ -0,0 +1,168 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/grid.ts
+var grid_exports = {};
+__export(grid_exports, {
+  createTestSuite: () => createTestSuite,
+  generateName: () => generateName,
+  generateParamGrid: () => generateParamGrid,
+  mergeConfigs: () => mergeConfigs
+});
+module.exports = __toCommonJS(grid_exports);
+
+// src/utils/grid.ts
+var import_lodash = __toESM(require("lodash"));
+
+// src/constants/index.ts
+var BACKTEST_EXECUTION_DELAY_MS = 5 * 6e4;
+var BACKTEST_DEFAULT_DAYS = 160;
+var DERIVATIVES_CONTEXT_BASE_REFERENCE_SYMBOLS = [
+  "BTCUSDT",
+  "ETHUSDT"
+];
+var DERIVATIVES_CONTEXT_DEFAULT_EXTRA_REFERENCE_SYMBOLS = [
+  "BNBUSDT",
+  "SOLUSDT",
+  "TRXUSDT",
+  "XRPUSDT"
+];
+var DERIVATIVES_CONTEXT_REFERENCE_SYMBOLS = [
+  ...DERIVATIVES_CONTEXT_BASE_REFERENCE_SYMBOLS,
+  ...DERIVATIVES_CONTEXT_DEFAULT_EXTRA_REFERENCE_SYMBOLS
+];
+
+// src/utils/timestamp.ts
+var import_date_fns = require("date-fns");
+var import_date_fns2 = require("date-fns");
+var RUNTIME_STORAGE_DAY_OFFSET_MS = 6 * 60 * 60 * 1e3;
+var getTimestamp = (days = 0) => {
+  if (days > 0) {
+    return (0, import_date_fns2.getUnixTime)((0, import_date_fns2.subDays)(/* @__PURE__ */ new Date(), days)) * 1e3;
+  }
+  return (0, import_date_fns2.getUnixTime)(/* @__PURE__ */ new Date()) * 1e3;
+};
+
+// src/utils/toJson.ts
+var toJson = (data, stringify = false) => {
+  return stringify ? JSON.stringify(data, null, 2) : JSON.stringify(data);
+};
+
+// src/utils/uuid.ts
+var import_node_crypto = require("crypto");
+var uuid = (len = 12) => {
+  const uuid2 = (0, import_node_crypto.randomUUID)();
+  return uuid2.slice(-len);
+};
+
+// src/utils/grid.ts
+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 toBase36Hash = (value) => {
+  let hash = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    hash = hash * 31 + value.charCodeAt(index) >>> 0;
+  }
+  return hash.toString(36).padStart(6, "0");
+};
+var buildConfigTestId = (config) => toBase36Hash(toJson(config)).slice(0, 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 ? import_lodash.default.cloneDeep(value) : value;
+      const isDuplicate = result[key].some(
+        (existing) => import_lodash.default.isEqual(existing, value)
+      );
+      if (!isDuplicate) {
+        result[key].push(clonedValue);
+      }
+    }
+  }
+  for (const key in result) {
+    if (result[key].every((v) => typeof v === "number")) {
+      result[key] = import_lodash.default.sortBy(result[key]);
+    }
+  }
+  return result;
+};
+var createTestSuite = (userName, tickers, strategyName, backtestConfig, connectorName, interval = "15") => {
+  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);
+      const configId = buildConfigTestId(params);
+      return {
+        userName,
+        name: `${symbol}_${testSuiteId}_${testId}`,
+        testId,
+        testSuiteId,
+        configId,
+        symbol,
+        interval,
+        options: { start, end },
+        strategyName,
+        strategyConfig: params,
+        connectorName
+      };
+    })
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTestSuite,
+  generateName,
+  generateParamGrid,
+  mergeConfigs
+});

package/dist/grid.mjs

@@ -0,0 +1,98 @@
+import {
+  uuid
+} from "./chunk-AJK4NS7Y.mjs";
+import {
+  getTimestamp
+} from "./chunk-BOETNABM.mjs";
+import {
+  BACKTEST_DEFAULT_DAYS
+} from "./chunk-MKCQSB4H.mjs";
+import {
+  toJson
+} from "./chunk-OJPHC3S2.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 toBase36Hash = (value) => {
+  let hash = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    hash = hash * 31 + value.charCodeAt(index) >>> 0;
+  }
+  return hash.toString(36).padStart(6, "0");
+};
+var buildConfigTestId = (config) => toBase36Hash(toJson(config)).slice(0, 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, interval = "15") => {
+  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);
+      const configId = buildConfigTestId(params);
+      return {
+        userName,
+        name: `${symbol}_${testSuiteId}_${testId}`,
+        testId,
+        testSuiteId,
+        configId,
+        symbol,
+        interval,
+        options: { start, end },
+        strategyName,
+        strategyConfig: params,
+        connectorName
+      };
+    })
+  );
+};
+export {
+  createTestSuite,
+  generateName,
+  generateParamGrid,
+  mergeConfigs
+};

package/dist/indicators-Da_i06-8.d.mts

@@ -0,0 +1,288 @@
+import { Candle, MlCandleIndicatorsSnapshot, DerivativesInterval, SpreadRow, IndicatorSnapshot, IndicatorsHistorySnapshot } from '@tradejs/types';
+
+type NumericHistoryBuffer = {
+    values: number[];
+    start: number;
+    size: number;
+};
+
+type CloseStreakRuntimeState = {
+    up: number;
+    down: number;
+};
+type BreakoutRuntimeState = {
+    side: 'high' | 'low' | null;
+    barsSinceBreakout: number | null;
+};
+
+declare const buildMlCandleIndicators: (candles: Candle[], btcCandles: Candle[]) => MlCandleIndicatorsSnapshot;
+type IndicatorValue = number | null | undefined;
+
+type RollingWindowState = {
+    period: number;
+    values: number[];
+    sum: number;
+};
+type SerializableSmaState = RollingWindowState;
+type SerializableEmaState = {
+    period: number;
+    exponent: number;
+    current: number | null;
+    seedSma: SerializableSmaState;
+};
+type SerializableObvState = {
+    current: number;
+    lastClose: number | null;
+};
+type SerializableAtrState = {
+    period: number;
+    prevClose: number | null;
+    wema: SerializableEmaState;
+};
+type SerializablePsarState = {
+    start: number;
+    increment: number;
+    maximum: number;
+    initialized: boolean;
+    isLong: boolean | null;
+    sar: number | null;
+    extremePoint: number | null;
+    acceleration: number;
+    previousHigh: number | null;
+    previousLow: number | null;
+    previousPreviousHigh: number | null;
+    previousPreviousLow: number | null;
+    previousClose: number | null;
+};
+type SerializableRsiState = {
+    period: number;
+    previousValue: number | null;
+    gains: number[];
+    losses: number[];
+    avgGain: number;
+    avgLoss: number;
+    initialized: boolean;
+};
+type SerializableAdxState = {
+    period: number;
+    smoothingPeriod: number;
+    previousHigh: number | null;
+    previousLow: number | null;
+    previousClose: number | null;
+    plusDMValues: number[];
+    minusDMValues: number[];
+    trValues: number[];
+    smoothedPlusDM: number | null;
+    smoothedMinusDM: number | null;
+    smoothedTR: number | null;
+    smaSum: number;
+    smaCount: number;
+    adxEMA: number | null;
+};
+type SerializableSdState = {
+    period: number;
+    values: number[];
+    sum: number;
+    sumSquares: number;
+};
+type SerializableBollingerState = {
+    period: number;
+    stdDev: number;
+    sma: SerializableSmaState;
+    sd: SerializableSdState;
+};
+type SerializableMacdState = {
+    fastPeriod: number;
+    slowPeriod: number;
+    signalPeriod: number;
+    fast: SerializableEmaState | SerializableSmaState;
+    slow: SerializableEmaState | SerializableSmaState;
+    signal: SerializableEmaState | SerializableSmaState;
+    simpleOscillator: boolean;
+    simpleSignal: boolean;
+    index: number;
+};
+
+type SpreadValue = number | null | undefined;
+type SpreadPointInput = {
+    timestamp: number;
+    spread?: SpreadValue;
+    binancePrice?: SpreadValue;
+    coinbasePrice?: SpreadValue;
+};
+declare const createSpreadSmoother: (window?: number) => {
+    next: (params: {
+        binancePrice?: SpreadValue;
+        coinbasePrice?: SpreadValue;
+        fallbackSpread?: SpreadValue;
+    }) => number | null;
+};
+type SpreadSmootherState = {
+    binanceWindow: number[];
+    coinbaseWindow: number[];
+    binanceSum: number;
+    coinbaseSum: number;
+};
+declare const createSerializableSpreadSmoother: (window?: number, state?: Partial<SpreadSmootherState>) => {
+    next: (params: {
+        binancePrice?: SpreadValue;
+        coinbasePrice?: SpreadValue;
+        fallbackSpread?: SpreadValue;
+    }) => number | null;
+    snapshot: () => SpreadSmootherState;
+};
+declare const smoothSpreadSeries: (points: SpreadPointInput[], window?: number) => Array<{
+    timestamp: number;
+    spread: number | null;
+}>;
+type PricePoint = {
+    ts: number;
+    close: number;
+};
+declare const intervalToMs: (interval: DerivativesInterval) => number;
+declare const coinbaseProductFromSymbol: (symbol: string) => string | null;
+declare const alignSpreadRows: (params: {
+    symbol: string;
+    interval: DerivativesInterval;
+    binance: PricePoint[];
+    coinbase: PricePoint[];
+    source: string;
+}) => SpreadRow[];
+declare const rollingMeanStd: (values: number[], endIndex: number, window: number) => {
+    mean: number;
+    std: number;
+};
+
+type TrendlineIndicatorHistoryPush = (key: string, value: number | null | undefined) => void;
+type IndicatorRuntimeState = {
+    maFast: SerializableSmaState;
+    maMedium: SerializableSmaState;
+    maSlow: SerializableSmaState;
+    atr: SerializableAtrState;
+    atrPctShort: SerializableSmaState;
+    atrPctLong: SerializableSmaState;
+    bb: SerializableBollingerState;
+    obv: SerializableObvState;
+    smaObv: SerializableSmaState;
+    macd: SerializableMacdState;
+    rsi: SerializableRsiState;
+    adx: SerializableAdxState;
+    baseContextHl2Ema: Record<string, SerializableEmaState>;
+    baseContextCloseEma34: SerializableEmaState;
+    baseContextTypicalSma20: SerializableSmaState;
+    baseContextAdaptivePreviousCenterline: number | null;
+    baseContextPsar: SerializablePsarState;
+    baseContextPsarEma50: SerializableEmaState;
+    baseContextPsarFilterBarsSinceSignal: number | null;
+    btcMaFast: SerializableSmaState;
+    btcMaSlow: SerializableSmaState;
+    spreadSmoother: SpreadSmootherState;
+};
+declare const getRequiredControllerSeedWindow: (periods?: Partial<IndicatorPeriods>) => number;
+type IndicatorsControllerRuntimeState = {
+    indicatorState: IndicatorRuntimeState;
+    indicatorHistory: Record<string, NumericHistoryBuffer>;
+    btcRuntimeHistory: Record<string, NumericHistoryBuffer>;
+    latestIndicatorValues: Record<string, number>;
+    rawCoinCandles: Candle[];
+    rawBtcCandles: Candle[];
+    rawEthCandles?: Candle[];
+    coinResampledCandles: {
+        h1: Candle[];
+        h4: Candle[];
+        d1: Candle[];
+    };
+    btcResampledCandles: {
+        h1: Candle[];
+        h4: Candle[];
+        d1: Candle[];
+    };
+    ethResampledCandles?: {
+        h1: Candle[];
+        h4: Candle[];
+        d1: Candle[];
+    };
+    closeStreaks: CloseStreakRuntimeState;
+    breakoutState: BreakoutRuntimeState;
+    btcCloses: number[];
+    btcBinanceCursor: number;
+    btcCoinbaseCursor: number;
+};
+type IndicatorsControllerCheckpointState = Pick<IndicatorsControllerRuntimeState, 'indicatorState' | 'rawCoinCandles' | 'rawBtcCandles' | 'rawEthCandles' | 'coinResampledCandles' | 'btcResampledCandles' | 'ethResampledCandles' | 'closeStreaks' | 'breakoutState' | 'btcCloses' | 'btcBinanceCursor' | 'btcCoinbaseCursor'> & Partial<Pick<IndicatorsControllerRuntimeState, 'indicatorHistory' | 'btcRuntimeHistory' | 'latestIndicatorValues'>>;
+type TrendlineIndicators = {
+    maFast: IndicatorValue;
+    maMedium: IndicatorValue;
+    maSlow: IndicatorValue;
+    atr: IndicatorValue;
+    atrPct: IndicatorValue;
+    bbUpper: IndicatorValue;
+    bbMiddle: IndicatorValue;
+    bbLower: IndicatorValue;
+    obv: IndicatorValue;
+    smaObv: IndicatorValue;
+    macd: IndicatorValue;
+    macdSignal: IndicatorValue;
+    macdHistogram: IndicatorValue;
+    price24hPcnt: IndicatorValue;
+    price1hPcnt: IndicatorValue;
+    highPrice1h: IndicatorValue;
+    lowPrice1h: IndicatorValue;
+    volume1h: IndicatorValue;
+    highPrice24h: IndicatorValue;
+    lowPrice24h: IndicatorValue;
+    volume24h: IndicatorValue;
+    highLevel: IndicatorValue;
+    lowLevel: IndicatorValue;
+    prevClose: IndicatorValue;
+    correlation: IndicatorValue;
+    spread: IndicatorValue;
+};
+type CreateIndicatorsOptions = {
+    includeMlPayload?: boolean;
+    runtimeOnly?: boolean;
+    ethData?: Candle[];
+    btcBinanceData?: Candle[];
+    btcCoinbaseData?: Candle[];
+    pluginRegistryScope?: string;
+    initialRuntimeState?: IndicatorsControllerRuntimeState | IndicatorsControllerCheckpointState;
+};
+declare const COMPACT_INDICATORS_SNAPSHOT_SYMBOL: unique symbol;
+declare const COMPACT_INDICATORS_SNAPSHOT_KEY = "__tradejsCompactIndicatorsSnapshot";
+interface IndicatorPeriods {
+    maFast: number;
+    maMedium: number;
+    maSlow: number;
+    obvSma: number;
+    atr: number;
+    atrPctShort: number;
+    atrPctLong: number;
+    bb: number;
+    bbStd: number;
+    macdFast: number;
+    macdSlow: number;
+    macdSignal: number;
+    levelLookback: number;
+    levelDelay: number;
+}
+declare const applyIndicatorsToHistory: (indicators: TrendlineIndicators, pushIndicator: TrendlineIndicatorHistoryPush) => void;
+declare const createIndicators: (data: Candle[], btcData?: Candle[], options?: CreateIndicatorsOptions & {
+    periods?: Partial<IndicatorPeriods>;
+}) => {
+    next: (candle: Candle, btcCandle?: Candle, ethCandle?: Candle) => IndicatorSnapshot | null;
+    updateReferenceData: ({ btcBinanceData, btcCoinbaseData, }: {
+        btcBinanceData?: Candle[];
+        btcCoinbaseData?: Candle[];
+    }) => void;
+    snapshot: (options?: {
+        compact?: boolean;
+        limit?: number;
+    }) => IndicatorsHistorySnapshot;
+    checkpointRuntimeState: () => IndicatorsControllerCheckpointState;
+    latestSnapshot: () => IndicatorSnapshot | null;
+    runtimeState: () => IndicatorsControllerRuntimeState;
+    latestNumber: (key: string) => number | undefined;
+    result: () => IndicatorsHistorySnapshot;
+};
+declare const buildMlTimeframeIndicators: (candles: Candle[], periods?: Partial<IndicatorPeriods>) => Record<string, number[]>;
+
+export { COMPACT_INDICATORS_SNAPSHOT_KEY as C, type IndicatorPeriods as I, type PricePoint as P, type SpreadSmootherState as S, type IndicatorsControllerRuntimeState as a, type IndicatorsControllerCheckpointState as b, COMPACT_INDICATORS_SNAPSHOT_SYMBOL as c, alignSpreadRows as d, applyIndicatorsToHistory as e, buildMlCandleIndicators as f, buildMlTimeframeIndicators as g, coinbaseProductFromSymbol as h, createIndicators as i, createSerializableSpreadSmoother as j, createSpreadSmoother as k, getRequiredControllerSeedWindow as l, intervalToMs as m, rollingMeanStd as r, smoothSpreadSeries as s };