@tradejs/node 1.0.0 → 1.0.3

package/dist/backtest.mjs

@@ -1,17 +1,19 @@
 import {
   BUILTIN_CONNECTOR_NAMES,
   getConnectorCreatorByName
-} from "./chunk-E2QNOA5M.mjs";
+} from "./chunk-MGFEID6K.mjs";
 import {
   buildMlPayload
-} from "./chunk-PXJJPAQT.mjs";
+} from "./chunk-H4HXW3EZ.mjs";
 import {
   require_lodash
 } from "./chunk-GKDBAF3A.mjs";
 import {
   getStrategyCreator
-} from "./chunk-MHCXPD2B.mjs";
-import "./chunk-DE7ADBIR.mjs";
+} from "./chunk-CK2PW4L5.mjs";
+import {
+  getTradejsProjectCwd
+} from "./chunk-3C76HVLA.mjs";
 import {
   __toESM
 } from "./chunk-6DZX6EAA.mjs";
@@ -231,10 +233,25 @@ var createTestConnector = (connector, context) => {
 
 // src/testing.ts
 var preloadStart = getTimestamp(PRELOAD_DAYS);
-var coinKlineCache = /* @__PURE__ */ new Map();
-var btcKlineCache = /* @__PURE__ */ new Map();
-var btcBinanceKlineCache = /* @__PURE__ */ new Map();
-var btcCoinbaseKlineCache = /* @__PURE__ */ new Map();
+var createTestingKlineCacheState = () => ({
+  coinKlineCache: /* @__PURE__ */ new Map(),
+  btcKlineCache: /* @__PURE__ */ new Map(),
+  btcBinanceKlineCache: /* @__PURE__ */ new Map(),
+  btcCoinbaseKlineCache: /* @__PURE__ */ new Map()
+});
+var testingKlineCacheStateByProjectRoot = /* @__PURE__ */ new Map();
+var getTestingKlineCacheState = (cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  let state = testingKlineCacheStateByProjectRoot.get(projectRoot);
+  if (!state) {
+    state = createTestingKlineCacheState();
+    testingKlineCacheStateByProjectRoot.set(projectRoot, state);
+  }
+  return {
+    projectRoot,
+    state
+  };
+};
 var getKlineCacheKey = (params) => {
   const { userName, connectorName, symbol, end, interval, cacheOnly } = params;
   return [
@@ -247,11 +264,15 @@ var getKlineCacheKey = (params) => {
     cacheOnly ? 1 : 0
   ].join(":");
 };
-var resetTestingKlineCache = () => {
-  coinKlineCache.clear();
-  btcKlineCache.clear();
-  btcBinanceKlineCache.clear();
-  btcCoinbaseKlineCache.clear();
+var resetTestingKlineCache = (cwd) => {
+  const normalizedCwd = String(cwd ?? "").trim();
+  if (!normalizedCwd) {
+    testingKlineCacheStateByProjectRoot.clear();
+    return;
+  }
+  testingKlineCacheStateByProjectRoot.delete(
+    getTradejsProjectCwd(normalizedCwd)
+  );
 };
 var testing = async ({
   userName,
@@ -269,22 +290,28 @@ var testing = async ({
   if (!start) {
     throw new Error("no start");
   }
-  const connectorCreator = await getConnectorCreatorByName(connectorName);
+  const { projectRoot, state } = getTestingKlineCacheState();
+  const connectorCreator = await getConnectorCreatorByName(
+    connectorName,
+    projectRoot
+  );
   if (!connectorCreator) {
     throw new Error(`Unknown connector: ${connectorName}`);
   }
   const connector = await connectorCreator({
     userName
   });
-  const strategyCreator = await getStrategyCreator(strategyName);
+  const strategyCreator = await getStrategyCreator(strategyName, projectRoot);
   if (!strategyCreator) {
     throw new Error(`Unknown strategy: ${strategyName}`);
   }
   const binanceCreator = await getConnectorCreatorByName(
-    BUILTIN_CONNECTOR_NAMES.Binance
+    BUILTIN_CONNECTOR_NAMES.Binance,
+    projectRoot
   );
   const coinbaseCreator = await getConnectorCreatorByName(
-    BUILTIN_CONNECTOR_NAMES.Coinbase
+    BUILTIN_CONNECTOR_NAMES.Coinbase,
+    projectRoot
   );
   if (!binanceCreator || !coinbaseCreator) {
     logger.warn(
@@ -310,8 +337,8 @@ var testing = async ({
     interval,
     cacheOnly
   });
-  const cachedCoinData = coinKlineCache.get(coinCacheKey);
-  const cachedBtcData = btcKlineCache.get(btcCacheKey);
+  const cachedCoinData = state.coinKlineCache.get(coinCacheKey);
+  const cachedBtcData = state.btcKlineCache.get(btcCacheKey);
   const btcBinanceCacheKey = getKlineCacheKey({
     userName,
     connectorName: binanceCreator ? BUILTIN_CONNECTOR_NAMES.Binance : connectorName,
@@ -328,8 +355,8 @@ var testing = async ({
     interval,
     cacheOnly
   });
-  const cachedBtcBinanceData = btcBinanceKlineCache.get(btcBinanceCacheKey);
-  const cachedBtcCoinbaseData = btcCoinbaseKlineCache.get(btcCoinbaseCacheKey);
+  const cachedBtcBinanceData = state.btcBinanceKlineCache.get(btcBinanceCacheKey);
+  const cachedBtcCoinbaseData = state.btcCoinbaseKlineCache.get(btcCoinbaseCacheKey);
   const [data, btcData, btcBinanceData, btcCoinbaseData] = await Promise.all([
     cachedCoinData ? Promise.resolve(cachedCoinData) : connector.kline({
       symbol,
@@ -383,16 +410,16 @@ var testing = async ({
     })
   ]);
   if (!cachedCoinData) {
-    coinKlineCache.set(coinCacheKey, data);
+    state.coinKlineCache.set(coinCacheKey, data);
   }
   if (!cachedBtcData) {
-    btcKlineCache.set(btcCacheKey, btcData);
+    state.btcKlineCache.set(btcCacheKey, btcData);
   }
   if (!cachedBtcBinanceData) {
-    btcBinanceKlineCache.set(btcBinanceCacheKey, btcBinanceData);
+    state.btcBinanceKlineCache.set(btcBinanceCacheKey, btcBinanceData);
   }
   if (!cachedBtcCoinbaseData) {
-    btcCoinbaseKlineCache.set(btcCoinbaseCacheKey, btcCoinbaseData);
+    state.btcCoinbaseKlineCache.set(btcCoinbaseCacheKey, btcCoinbaseData);
   }
   const prevDataRaw = data.filter(
     (candle) => candle.timestamp >= preloadStart && candle.timestamp < start

package/dist/{chunk-DE7ADBIR.mjs → chunk-3C76HVLA.mjs}

@@ -198,6 +198,7 @@ var loadTradejsConfig = async (cwd = getTradejsProjectCwd()) => {
 };
 
 export {
+  getTradejsProjectCwd,
   importTradejsModule,
   resolvePluginModuleSpecifier,
   loadTradejsConfig

package/dist/{chunk-CVTV6S2V.mjs → chunk-7ICOZAKA.mjs}

@@ -5,7 +5,28 @@ import {
 // src/pine.ts
 import fs from "fs";
 import path from "path";
-export * from "@tradejs/core/pine";
+var getPinePlotSeries = (context, plotName) => {
+  const name = String(plotName || "").trim();
+  if (!name) return [];
+  const data = context?.plots?.[name]?.data;
+  return Array.isArray(data) ? data : [];
+};
+var getLatestPinePlotValue = (context, plotName) => {
+  const series = getPinePlotSeries(context, plotName);
+  if (!series.length) return void 0;
+  return series[series.length - 1]?.value;
+};
+var asFiniteNumber = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return void 0;
+  }
+  return value;
+};
+var asPineBoolean = (value) => {
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return Number.isFinite(value) && value !== 0;
+  return false;
+};
 var loadPinets = () => {
   const resolvedPath = __require.resolve("pinets");
   const cjsPath = resolvedPath.includes("pinets.min.browser") ? resolvedPath.replace(/pinets\.min\.browser(\.es)?\.js$/, "pinets.min.cjs") : resolvedPath;
@@ -88,6 +109,10 @@ var runPineScript = async ({
 };
 
 export {
+  getPinePlotSeries,
+  getLatestPinePlotValue,
+  asFiniteNumber,
+  asPineBoolean,
   loadPineScript,
   createLoadPineScript,
   runPineScript

package/dist/chunk-CK2PW4L5.mjs

@@ -0,0 +1,243 @@
+import {
+  getTradejsProjectCwd,
+  importTradejsModule,
+  loadTradejsConfig,
+  resolvePluginModuleSpecifier
+} from "./chunk-3C76HVLA.mjs";
+
+// src/strategy/manifests.ts
+import {
+  registerIndicatorEntries,
+  resetIndicatorRegistryCache
+} from "@tradejs/core/indicators";
+import { logger } from "@tradejs/infra/logger";
+var createStrategyRegistryState = () => ({
+  strategyCreators: /* @__PURE__ */ new Map(),
+  strategyManifestsMap: /* @__PURE__ */ new Map(),
+  pluginsLoadPromise: null
+});
+var registryStateByProjectRoot = /* @__PURE__ */ new Map();
+var getStrategyRegistryState = (cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  let state = registryStateByProjectRoot.get(projectRoot);
+  if (!state) {
+    state = createStrategyRegistryState();
+    registryStateByProjectRoot.set(projectRoot, state);
+  }
+  return {
+    projectRoot,
+    state
+  };
+};
+var toUniqueModules = (modules = []) => [
+  ...new Set(modules.map((moduleName) => moduleName.trim()).filter(Boolean))
+];
+var getConfiguredPluginModuleNames = async (cwd = getTradejsProjectCwd()) => {
+  const config = await loadTradejsConfig(cwd);
+  return {
+    strategyModules: toUniqueModules(config.strategies),
+    indicatorModules: toUniqueModules(config.indicators)
+  };
+};
+var extractModuleEntries = (moduleExport, key) => {
+  if (!moduleExport || typeof moduleExport !== "object") {
+    return null;
+  }
+  const candidate = moduleExport;
+  if (Array.isArray(candidate[key])) {
+    return candidate[key];
+  }
+  const defaultExport = candidate.default;
+  if (defaultExport && Array.isArray(defaultExport[key])) {
+    return defaultExport[key];
+  }
+  return null;
+};
+var extractStrategyPluginDefinition = (moduleExport) => {
+  const strategyEntries = extractModuleEntries(
+    moduleExport,
+    "strategyEntries"
+  );
+  return strategyEntries ? { strategyEntries } : null;
+};
+var extractIndicatorPluginDefinition = (moduleExport) => {
+  const indicatorEntries = extractModuleEntries(
+    moduleExport,
+    "indicatorEntries"
+  );
+  return indicatorEntries ? { indicatorEntries } : null;
+};
+var registerEntries = (entries, source, state) => {
+  for (const entry of entries) {
+    const strategyName = entry.manifest?.name;
+    if (!strategyName) {
+      logger.warn("Skip strategy entry without name from %s", source);
+      continue;
+    }
+    if (state.strategyCreators.has(strategyName)) {
+      logger.warn(
+        'Skip duplicate strategy "%s" from %s: already registered',
+        strategyName,
+        source
+      );
+      continue;
+    }
+    state.strategyCreators.set(strategyName, entry.creator);
+    state.strategyManifestsMap.set(strategyName, entry.manifest);
+  }
+};
+var importStrategyPluginModule = async (moduleName) => {
+  if (typeof importTradejsModule === "function") {
+    return importTradejsModule(moduleName);
+  }
+  return import(
+    /* webpackIgnore: true */
+    moduleName
+  );
+};
+var ensureStrategyPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
+  const { projectRoot, state } = getStrategyRegistryState(cwd);
+  if (!state.pluginsLoadPromise) {
+    resetIndicatorRegistryCache(projectRoot);
+    state.pluginsLoadPromise = (async () => {
+      const { strategyModules, indicatorModules } = await getConfiguredPluginModuleNames(projectRoot);
+      const strategySet = new Set(strategyModules);
+      const indicatorSet = new Set(indicatorModules);
+      const pluginModuleNames = [
+        .../* @__PURE__ */ new Set([...strategyModules, ...indicatorModules])
+      ];
+      if (!pluginModuleNames.length) {
+        return;
+      }
+      for (const moduleName of pluginModuleNames) {
+        try {
+          const resolvedModuleName = resolvePluginModuleSpecifier(
+            moduleName,
+            projectRoot
+          );
+          const moduleExport = await importStrategyPluginModule(resolvedModuleName);
+          if (strategySet.has(moduleName)) {
+            const pluginDefinition = extractStrategyPluginDefinition(moduleExport);
+            if (!pluginDefinition) {
+              logger.warn(
+                'Skip strategy plugin "%s": export { strategyEntries } is missing',
+                moduleName
+              );
+            } else {
+              registerEntries(
+                pluginDefinition.strategyEntries,
+                moduleName,
+                state
+              );
+            }
+          }
+          if (indicatorSet.has(moduleName)) {
+            const indicatorPluginDefinition = extractIndicatorPluginDefinition(moduleExport);
+            if (!indicatorPluginDefinition) {
+              logger.warn(
+                'Skip indicator plugin "%s": export { indicatorEntries } is missing',
+                moduleName
+              );
+            } else {
+              registerIndicatorEntries(
+                indicatorPluginDefinition.indicatorEntries,
+                moduleName,
+                projectRoot
+              );
+            }
+          }
+          if (!strategySet.has(moduleName) && !indicatorSet.has(moduleName)) {
+            logger.warn(
+              'Skip plugin "%s": no strategy/indicator sections requested in config',
+              moduleName
+            );
+          }
+        } catch (error) {
+          logger.warn(
+            'Failed to load plugin "%s": %s',
+            moduleName,
+            String(error)
+          );
+        }
+      }
+    })();
+  }
+  await state.pluginsLoadPromise;
+};
+var ensureIndicatorPluginsLoaded = async (cwd = getTradejsProjectCwd()) => ensureStrategyPluginsLoaded(cwd);
+var getStrategyCreator = async (name, cwd = getTradejsProjectCwd()) => {
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyCreators.get(name);
+};
+var getAvailableStrategyNames = async (cwd = getTradejsProjectCwd()) => {
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return [...state.strategyCreators.keys()].sort((a, b) => a.localeCompare(b));
+};
+var getRegisteredStrategies = (cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  return Object.fromEntries(state.strategyCreators.entries());
+};
+var getRegisteredManifests = (cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  return [...state.strategyManifestsMap.values()];
+};
+var getStrategyManifest = (name, cwd = getTradejsProjectCwd()) => {
+  if (!name) {
+    return void 0;
+  }
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyManifestsMap.get(name);
+};
+var isKnownStrategy = (name, cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyCreators.has(name);
+};
+var registerStrategyEntries = (entries, cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  registerEntries(entries, "runtime", state);
+};
+var resetStrategyRegistryCache = (cwd) => {
+  const normalizedCwd = String(cwd ?? "").trim();
+  if (!normalizedCwd) {
+    registryStateByProjectRoot.clear();
+    resetIndicatorRegistryCache();
+    return;
+  }
+  const projectRoot = getTradejsProjectCwd(normalizedCwd);
+  registryStateByProjectRoot.delete(projectRoot);
+  resetIndicatorRegistryCache(projectRoot);
+};
+var strategies = new Proxy(
+  {},
+  {
+    get: (_target, property) => {
+      if (typeof property !== "string") {
+        return void 0;
+      }
+      return getStrategyRegistryState().state.strategyCreators.get(property);
+    },
+    ownKeys: () => {
+      return [...getStrategyRegistryState().state.strategyCreators.keys()];
+    },
+    getOwnPropertyDescriptor: () => ({
+      enumerable: true,
+      configurable: true
+    })
+  }
+);
+
+export {
+  ensureStrategyPluginsLoaded,
+  ensureIndicatorPluginsLoaded,
+  getStrategyCreator,
+  getAvailableStrategyNames,
+  getRegisteredStrategies,
+  getRegisteredManifests,
+  getStrategyManifest,
+  isKnownStrategy,
+  registerStrategyEntries,
+  resetStrategyRegistryCache,
+  strategies
+};

package/dist/{chunk-PXJJPAQT.mjs → chunk-H4HXW3EZ.mjs}

@@ -1,6 +1,6 @@
 import {
   getStrategyManifest
-} from "./chunk-MHCXPD2B.mjs";
+} from "./chunk-CK2PW4L5.mjs";
 
 // src/strategyAdapters/ml.ts
 var defaultMlAdapter = {