@tradejs/node 1.0.2 → 1.0.4

package/dist/registry.js

@@ -65,6 +65,7 @@ var TS_MODULE_RE = /\.(cts|mts|ts)$/i;
 var cachedByCwd = /* @__PURE__ */ new Map();
 var announcedConfigFile = /* @__PURE__ */ new Set();
 var tsNodeRegistered = false;
+var tsconfigPathsRegisteredByCwd = /* @__PURE__ */ new Set();
 var getTradejsProjectCwd = (cwd) => {
   const explicit = String(cwd ?? "").trim();
   if (explicit) {
@@ -106,6 +107,28 @@ var ensureTsNodeRegistered = async () => {
   });
   tsNodeRegistered = true;
 };
+var ensureTsconfigPathsRegistered = async (cwd = getTradejsProjectCwd()) => {
+  const projectRoot = getTradejsProjectCwd(cwd);
+  if (tsconfigPathsRegisteredByCwd.has(projectRoot)) {
+    return;
+  }
+  const tsconfigPathsModule = await import("tsconfig-paths");
+  const loadConfig = tsconfigPathsModule.loadConfig;
+  const register = tsconfigPathsModule.register;
+  if (typeof loadConfig !== "function" || typeof register !== "function") {
+    return;
+  }
+  const loadedConfig = loadConfig(projectRoot);
+  if (loadedConfig.resultType !== "success") {
+    return;
+  }
+  register({
+    baseUrl: loadedConfig.absoluteBaseUrl,
+    paths: loadedConfig.paths,
+    addMatchAll: false
+  });
+  tsconfigPathsRegisteredByCwd.add(projectRoot);
+};
 var toImportSpecifier = (moduleName) => {
   if (moduleName.startsWith("file://")) {
     return moduleName;
@@ -133,6 +156,7 @@ var importConfigFile = async (configFilePath) => {
   if (ext === ".ts" || ext === ".mts") {
     const requireFn = getRequireFn(import_path.default.dirname(configFilePath));
     await ensureTsNodeRegistered();
+    await ensureTsconfigPathsRegistered(import_path.default.dirname(configFilePath));
     return requireFn(configFilePath);
   }
   return import(
@@ -140,7 +164,7 @@ var importConfigFile = async (configFilePath) => {
     configFileUrl
   );
 };
-var importTradejsModule = async (moduleName) => {
+var importTradejsModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
   const normalized = String(moduleName ?? "").trim();
   if (!normalized) {
     return {};
@@ -154,13 +178,15 @@ var importTradejsModule = async (moduleName) => {
     }
   }
   const requireFn = getRequireFn(
-    import_path.default.isAbsolute(modulePath) ? import_path.default.dirname(modulePath) : getTradejsProjectCwd()
+    import_path.default.isAbsolute(modulePath) ? import_path.default.dirname(modulePath) : cwd
   );
   if (isTsModulePath(modulePath)) {
     await ensureTsNodeRegistered();
+    await ensureTsconfigPathsRegistered(cwd);
     return requireFn(modulePath);
   }
   if (isBareModuleSpecifier(normalized)) {
+    await ensureTsconfigPathsRegistered(cwd);
     return requireFn(normalized);
   }
   try {
@@ -171,6 +197,7 @@ var importTradejsModule = async (moduleName) => {
   } catch (error) {
     if (isTsModulePath(modulePath)) {
       await ensureTsNodeRegistered();
+      await ensureTsconfigPathsRegistered(cwd);
       return requireFn(modulePath);
     }
     throw error;
@@ -248,14 +275,29 @@ var loadTradejsConfig = async (cwd = getTradejsProjectCwd()) => {
 };
 
 // src/strategy/manifests.ts
-var strategyCreators = /* @__PURE__ */ new Map();
-var strategyManifestsMap = /* @__PURE__ */ new Map();
-var pluginsLoadPromise = null;
+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 () => {
-  const config = await loadTradejsConfig();
+var getConfiguredPluginModuleNames = async (cwd = getTradejsProjectCwd()) => {
+  const config = await loadTradejsConfig(cwd);
   return {
     strategyModules: toUniqueModules(config.strategies),
     indicatorModules: toUniqueModules(config.indicators)
@@ -289,14 +331,14 @@ var extractIndicatorPluginDefinition = (moduleExport) => {
   );
   return indicatorEntries ? { indicatorEntries } : null;
 };
-var registerEntries = (entries, source) => {
+var registerEntries = (entries, source, state) => {
   for (const entry of entries) {
     const strategyName = entry.manifest?.name;
     if (!strategyName) {
       import_logger2.logger.warn("Skip strategy entry without name from %s", source);
       continue;
     }
-    if (strategyCreators.has(strategyName)) {
+    if (state.strategyCreators.has(strategyName)) {
       import_logger2.logger.warn(
         'Skip duplicate strategy "%s" from %s: already registered',
         strategyName,
@@ -304,106 +346,135 @@ var registerEntries = (entries, source) => {
       );
       continue;
     }
-    strategyCreators.set(strategyName, entry.creator);
-    strategyManifestsMap.set(strategyName, entry.manifest);
+    state.strategyCreators.set(strategyName, entry.creator);
+    state.strategyManifestsMap.set(strategyName, entry.manifest);
   }
 };
-var importStrategyPluginModule = async (moduleName) => {
+var importStrategyPluginModule = async (moduleName, cwd = getTradejsProjectCwd()) => {
   if (typeof importTradejsModule === "function") {
-    return importTradejsModule(moduleName);
+    return importTradejsModule(moduleName, cwd);
   }
   return import(
     /* webpackIgnore: true */
     moduleName
   );
 };
-var ensureStrategyPluginsLoaded = async () => {
-  if (pluginsLoadPromise) {
-    return pluginsLoadPromise;
-  }
-  pluginsLoadPromise = (async () => {
-    const { strategyModules, indicatorModules } = await getConfiguredPluginModuleNames();
-    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);
-        const moduleExport = await importStrategyPluginModule(resolvedModuleName);
-        if (strategySet.has(moduleName)) {
-          const pluginDefinition = extractStrategyPluginDefinition(moduleExport);
-          if (!pluginDefinition) {
-            import_logger2.logger.warn(
-              'Skip strategy plugin "%s": export { strategyEntries } is missing',
-              moduleName
-            );
-          } else {
-            registerEntries(pluginDefinition.strategyEntries, moduleName);
+var ensureStrategyPluginsLoaded = async (cwd = getTradejsProjectCwd()) => {
+  const { projectRoot, state } = getStrategyRegistryState(cwd);
+  if (!state.pluginsLoadPromise) {
+    (0, import_indicators.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,
+            projectRoot
+          );
+          if (strategySet.has(moduleName)) {
+            const pluginDefinition = extractStrategyPluginDefinition(moduleExport);
+            if (!pluginDefinition) {
+              import_logger2.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) {
+          if (indicatorSet.has(moduleName)) {
+            const indicatorPluginDefinition = extractIndicatorPluginDefinition(moduleExport);
+            if (!indicatorPluginDefinition) {
+              import_logger2.logger.warn(
+                'Skip indicator plugin "%s": export { indicatorEntries } is missing',
+                moduleName
+              );
+            } else {
+              (0, import_indicators.registerIndicatorEntries)(
+                indicatorPluginDefinition.indicatorEntries,
+                moduleName,
+                projectRoot
+              );
+            }
+          }
+          if (!strategySet.has(moduleName) && !indicatorSet.has(moduleName)) {
             import_logger2.logger.warn(
-              'Skip indicator plugin "%s": export { indicatorEntries } is missing',
-              moduleName
-            );
-          } else {
-            (0, import_indicators.registerIndicatorEntries)(
-              indicatorPluginDefinition.indicatorEntries,
+              'Skip plugin "%s": no strategy/indicator sections requested in config',
               moduleName
             );
           }
-        }
-        if (!strategySet.has(moduleName) && !indicatorSet.has(moduleName)) {
+        } catch (error) {
           import_logger2.logger.warn(
-            'Skip plugin "%s": no strategy/indicator sections requested in config',
-            moduleName
+            'Failed to load plugin "%s": %s',
+            moduleName,
+            String(error)
           );
         }
-      } catch (error) {
-        import_logger2.logger.warn(
-          'Failed to load plugin "%s": %s',
-          moduleName,
-          String(error)
-        );
       }
-    }
-  })();
-  return pluginsLoadPromise;
+    })();
+  }
+  await state.pluginsLoadPromise;
 };
-var ensureIndicatorPluginsLoaded = ensureStrategyPluginsLoaded;
-var getStrategyCreator = async (name) => {
-  await ensureStrategyPluginsLoaded();
-  return strategyCreators.get(name);
+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 () => {
-  await ensureStrategyPluginsLoaded();
-  return [...strategyCreators.keys()].sort((a, b) => a.localeCompare(b));
+var getAvailableStrategyNames = async (cwd = getTradejsProjectCwd()) => {
+  await ensureStrategyPluginsLoaded(cwd);
+  const { state } = getStrategyRegistryState(cwd);
+  return [...state.strategyCreators.keys()].sort((a, b) => a.localeCompare(b));
 };
-var getRegisteredStrategies = () => {
-  return Object.fromEntries(strategyCreators.entries());
+var getRegisteredStrategies = (cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  return Object.fromEntries(state.strategyCreators.entries());
 };
-var getRegisteredManifests = () => {
-  return [...strategyManifestsMap.values()];
+var getRegisteredManifests = (cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  return [...state.strategyManifestsMap.values()];
 };
-var getStrategyManifest = (name) => {
-  return name ? strategyManifestsMap.get(name) : void 0;
+var getStrategyManifest = (name, cwd = getTradejsProjectCwd()) => {
+  if (!name) {
+    return void 0;
+  }
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyManifestsMap.get(name);
 };
-var isKnownStrategy = (name) => {
-  return strategyCreators.has(name);
+var isKnownStrategy = (name, cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  return state.strategyCreators.has(name);
 };
-var registerStrategyEntries = (entries) => {
-  registerEntries(entries, "runtime");
+var registerStrategyEntries = (entries, cwd = getTradejsProjectCwd()) => {
+  const { state } = getStrategyRegistryState(cwd);
+  registerEntries(entries, "runtime", state);
 };
-var resetStrategyRegistryCache = () => {
-  strategyCreators.clear();
-  strategyManifestsMap.clear();
-  (0, import_indicators.resetIndicatorRegistryCache)();
-  pluginsLoadPromise = null;
+var resetStrategyRegistryCache = (cwd) => {
+  const normalizedCwd = String(cwd ?? "").trim();
+  if (!normalizedCwd) {
+    registryStateByProjectRoot.clear();
+    (0, import_indicators.resetIndicatorRegistryCache)();
+    return;
+  }
+  const projectRoot = getTradejsProjectCwd(normalizedCwd);
+  registryStateByProjectRoot.delete(projectRoot);
+  (0, import_indicators.resetIndicatorRegistryCache)(projectRoot);
 };
 var strategies = new Proxy(
   {},
@@ -412,10 +483,10 @@ var strategies = new Proxy(
       if (typeof property !== "string") {
         return void 0;
       }
-      return strategyCreators.get(property);
+      return getStrategyRegistryState().state.strategyCreators.get(property);
     },
     ownKeys: () => {
-      return [...strategyCreators.keys()];
+      return [...getStrategyRegistryState().state.strategyCreators.keys()];
     },
     getOwnPropertyDescriptor: () => ({
       enumerable: true,

package/dist/registry.mjs

@@ -11,8 +11,8 @@ import {
   registerStrategyEntries,
   resetStrategyRegistryCache,
   strategies
-} from "./chunk-MHCXPD2B.mjs";
-import "./chunk-DE7ADBIR.mjs";
+} from "./chunk-ZY6ULOWK.mjs";
+import "./chunk-P2ZUWONT.mjs";
 import "./chunk-6DZX6EAA.mjs";
 export {
   ensureIndicatorPluginsLoaded,