@tradejs/node 1.0.2 → 1.0.4

package/dist/chunk-E2QNOA5M.mjs

@@ -1,227 +0,0 @@
-import {
-  importTradejsModule,
-  loadTradejsConfig,
-  resolvePluginModuleSpecifier
-} from "./chunk-DE7ADBIR.mjs";
-
-// src/connectorsRegistry.ts
-import { logger } from "@tradejs/infra/logger";
-var connectorCreators = /* @__PURE__ */ new Map();
-var providerToConnectorName = /* @__PURE__ */ new Map();
-var pluginsLoadPromise = null;
-var BUILTIN_CONNECTOR_NAMES = {
-  ByBit: "ByBit",
-  Binance: "Binance",
-  Coinbase: "Coinbase",
-  Test: "Test"
-};
-var normalizeProvider = (value) => String(value ?? "").trim().toLowerCase();
-var toUniqueModules = (modules = []) => [
-  ...new Set(modules.map((moduleName) => moduleName.trim()).filter(Boolean))
-];
-var findConnectorNameInsensitive = (name) => {
-  const normalized = name.trim().toLowerCase();
-  if (!normalized) {
-    return null;
-  }
-  for (const existingName of connectorCreators.keys()) {
-    if (existingName.toLowerCase() === normalized) {
-      return existingName;
-    }
-  }
-  return null;
-};
-var normalizeProviders = (providers, connectorName) => {
-  const list = Array.isArray(providers) ? providers.map((item) => normalizeProvider(item)).filter(Boolean) : [];
-  const deduped = [...new Set(list)];
-  if (deduped.length) {
-    return deduped;
-  }
-  return [normalizeProvider(connectorName)];
-};
-var registerProvider = (provider, connectorName, source) => {
-  const existing = providerToConnectorName.get(provider);
-  if (existing && existing !== connectorName) {
-    logger.warn(
-      'Skip duplicate connector provider "%s" from %s: already mapped to %s',
-      provider,
-      source,
-      existing
-    );
-    return;
-  }
-  providerToConnectorName.set(provider, connectorName);
-};
-var registerEntry = (entry, source) => {
-  const connectorName = String(entry?.name ?? "").trim();
-  if (!connectorName) {
-    logger.warn("Skip connector entry without name from %s", source);
-    return;
-  }
-  if (typeof entry.creator !== "function") {
-    logger.warn(
-      'Skip connector entry "%s" from %s: creator must be a function',
-      connectorName,
-      source
-    );
-    return;
-  }
-  const existingByName = findConnectorNameInsensitive(connectorName);
-  if (existingByName) {
-    logger.warn(
-      'Skip duplicate connector "%s" from %s: already registered as %s',
-      connectorName,
-      source,
-      existingByName
-    );
-    return;
-  }
-  connectorCreators.set(connectorName, entry.creator);
-  const providers = normalizeProviders(entry.providers, connectorName);
-  for (const provider of providers) {
-    registerProvider(provider, connectorName, source);
-  }
-};
-var registerEntries = (entries, source) => {
-  for (const entry of entries) {
-    registerEntry(entry, source);
-  }
-};
-var extractConnectorPluginDefinition = (moduleExport) => {
-  if (!moduleExport || typeof moduleExport !== "object") {
-    return null;
-  }
-  const candidate = moduleExport;
-  if (Array.isArray(candidate.connectorEntries)) {
-    return {
-      connectorEntries: candidate.connectorEntries
-    };
-  }
-  const defaultExport = candidate.default;
-  if (defaultExport && Array.isArray(defaultExport.connectorEntries)) {
-    return {
-      connectorEntries: defaultExport.connectorEntries
-    };
-  }
-  return null;
-};
-var importConnectorPluginModule = async (moduleName) => {
-  if (typeof importTradejsModule === "function") {
-    return importTradejsModule(moduleName);
-  }
-  return import(
-    /* webpackIgnore: true */
-    moduleName
-  );
-};
-var ensureConnectorPluginsLoaded = async () => {
-  if (pluginsLoadPromise) {
-    return pluginsLoadPromise;
-  }
-  pluginsLoadPromise = (async () => {
-    const config = await loadTradejsConfig();
-    const connectorModules = toUniqueModules(config.connectors);
-    if (!connectorModules.length) {
-      return;
-    }
-    for (const moduleName of connectorModules) {
-      try {
-        const resolvedModuleName = resolvePluginModuleSpecifier(moduleName);
-        const moduleExport = await importConnectorPluginModule(resolvedModuleName);
-        const pluginDefinition = extractConnectorPluginDefinition(moduleExport);
-        if (!pluginDefinition) {
-          logger.warn(
-            'Skip connector plugin "%s": export { connectorEntries } is missing',
-            moduleName
-          );
-          continue;
-        }
-        registerEntries(pluginDefinition.connectorEntries, moduleName);
-      } catch (error) {
-        logger.warn(
-          'Failed to load connector plugin "%s": %s',
-          moduleName,
-          String(error)
-        );
-      }
-    }
-  })();
-  return pluginsLoadPromise;
-};
-var getConnectorCreatorByName = async (connectorName) => {
-  await ensureConnectorPluginsLoaded();
-  const raw = String(connectorName ?? "").trim();
-  if (!raw) {
-    return void 0;
-  }
-  const direct = connectorCreators.get(raw);
-  if (direct) {
-    return direct;
-  }
-  const existing = findConnectorNameInsensitive(raw);
-  if (!existing) {
-    return void 0;
-  }
-  return connectorCreators.get(existing);
-};
-var getConnectorNameByProvider = async (provider) => {
-  await ensureConnectorPluginsLoaded();
-  const normalized = normalizeProvider(provider);
-  if (!normalized) {
-    return void 0;
-  }
-  return providerToConnectorName.get(normalized);
-};
-var getConnectorCreatorByProvider = async (provider) => {
-  const connectorName = await getConnectorNameByProvider(provider);
-  if (!connectorName) {
-    return void 0;
-  }
-  return connectorCreators.get(connectorName);
-};
-var resolveConnectorName = async (providerOrName) => {
-  const raw = String(providerOrName ?? "").trim();
-  if (!raw) {
-    return void 0;
-  }
-  const byProvider = await getConnectorNameByProvider(raw);
-  if (byProvider) {
-    return byProvider;
-  }
-  const byName = await getConnectorCreatorByName(raw);
-  if (!byName) {
-    return void 0;
-  }
-  return findConnectorNameInsensitive(raw) ?? void 0;
-};
-var getAvailableConnectorNames = async () => {
-  await ensureConnectorPluginsLoaded();
-  return [...connectorCreators.keys()].sort((a, b) => a.localeCompare(b));
-};
-var getAvailableConnectorProviders = async () => {
-  await ensureConnectorPluginsLoaded();
-  return [...providerToConnectorName.keys()].sort((a, b) => a.localeCompare(b));
-};
-var registerConnectorEntries = (entries) => {
-  registerEntries(entries, "runtime");
-};
-var resetConnectorRegistryCache = () => {
-  connectorCreators.clear();
-  providerToConnectorName.clear();
-  pluginsLoadPromise = null;
-};
-var DEFAULT_CONNECTOR_NAME = BUILTIN_CONNECTOR_NAMES.ByBit;
-
-export {
-  BUILTIN_CONNECTOR_NAMES,
-  ensureConnectorPluginsLoaded,
-  getConnectorCreatorByName,
-  getConnectorNameByProvider,
-  getConnectorCreatorByProvider,
-  resolveConnectorName,
-  getAvailableConnectorNames,
-  getAvailableConnectorProviders,
-  registerConnectorEntries,
-  resetConnectorRegistryCache,
-  DEFAULT_CONNECTOR_NAME
-};

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
-};