@tradejs/node 1.0.2 → 1.0.3

package/dist/chunk-MHCXPD2B.mjs

@@ -1,201 +0,0 @@
-import {
-  importTradejsModule,
-  loadTradejsConfig,
-  resolvePluginModuleSpecifier
-} from "./chunk-DE7ADBIR.mjs";
-
-// src/strategy/manifests.ts
-import {
-  registerIndicatorEntries,
-  resetIndicatorRegistryCache
-} from "@tradejs/core/indicators";
-import { logger } from "@tradejs/infra/logger";
-var strategyCreators = /* @__PURE__ */ new Map();
-var strategyManifestsMap = /* @__PURE__ */ new Map();
-var pluginsLoadPromise = null;
-var toUniqueModules = (modules = []) => [
-  ...new Set(modules.map((moduleName) => moduleName.trim()).filter(Boolean))
-];
-var getConfiguredPluginModuleNames = async () => {
-  const config = await loadTradejsConfig();
-  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) => {
-  for (const entry of entries) {
-    const strategyName = entry.manifest?.name;
-    if (!strategyName) {
-      logger.warn("Skip strategy entry without name from %s", source);
-      continue;
-    }
-    if (strategyCreators.has(strategyName)) {
-      logger.warn(
-        'Skip duplicate strategy "%s" from %s: already registered',
-        strategyName,
-        source
-      );
-      continue;
-    }
-    strategyCreators.set(strategyName, entry.creator);
-    strategyManifestsMap.set(strategyName, entry.manifest);
-  }
-};
-var importStrategyPluginModule = async (moduleName) => {
-  if (typeof importTradejsModule === "function") {
-    return importTradejsModule(moduleName);
-  }
-  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) {
-            logger.warn(
-              'Skip strategy plugin "%s": export { strategyEntries } is missing',
-              moduleName
-            );
-          } else {
-            registerEntries(pluginDefinition.strategyEntries, moduleName);
-          }
-        }
-        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
-            );
-          }
-        }
-        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)
-        );
-      }
-    }
-  })();
-  return pluginsLoadPromise;
-};
-var ensureIndicatorPluginsLoaded = ensureStrategyPluginsLoaded;
-var getStrategyCreator = async (name) => {
-  await ensureStrategyPluginsLoaded();
-  return strategyCreators.get(name);
-};
-var getAvailableStrategyNames = async () => {
-  await ensureStrategyPluginsLoaded();
-  return [...strategyCreators.keys()].sort((a, b) => a.localeCompare(b));
-};
-var getRegisteredStrategies = () => {
-  return Object.fromEntries(strategyCreators.entries());
-};
-var getRegisteredManifests = () => {
-  return [...strategyManifestsMap.values()];
-};
-var getStrategyManifest = (name) => {
-  return name ? strategyManifestsMap.get(name) : void 0;
-};
-var isKnownStrategy = (name) => {
-  return strategyCreators.has(name);
-};
-var registerStrategyEntries = (entries) => {
-  registerEntries(entries, "runtime");
-};
-var resetStrategyRegistryCache = () => {
-  strategyCreators.clear();
-  strategyManifestsMap.clear();
-  resetIndicatorRegistryCache();
-  pluginsLoadPromise = null;
-};
-var strategies = new Proxy(
-  {},
-  {
-    get: (_target, property) => {
-      if (typeof property !== "string") {
-        return void 0;
-      }
-      return strategyCreators.get(property);
-    },
-    ownKeys: () => {
-      return [...strategyCreators.keys()];
-    },
-    getOwnPropertyDescriptor: () => ({
-      enumerable: true,
-      configurable: true
-    })
-  }
-);
-
-export {
-  ensureStrategyPluginsLoaded,
-  ensureIndicatorPluginsLoaded,
-  getStrategyCreator,
-  getAvailableStrategyNames,
-  getRegisteredStrategies,
-  getRegisteredManifests,
-  getStrategyManifest,
-  isKnownStrategy,
-  registerStrategyEntries,
-  resetStrategyRegistryCache,
-  strategies
-};