@tradejs/node 2.0.17 → 2.0.19

package/dist/cli.mjs

@@ -3,25 +3,19 @@ import {
   KLINE_CONCURRENCY_LIMIT,
   SCREENSHOT_CONCURRENCY_LIMIT
 } from "./chunk-KMJQQ53K.mjs";
-import {
-  require_lodash
-} from "./chunk-GPR56UYQ.mjs";
 import {
   askAI
-} from "./chunk-WK5EUCX5.mjs";
-import "./chunk-QVSMINLG.mjs";
+} from "./chunk-4AVFJMQL.mjs";
 import {
   getTradejsProjectCwd,
   loadTradejsConfig
 } from "./chunk-WS5DYEVZ.mjs";
-import {
-  __toESM
-} from "./chunk-UV2HVMKZ.mjs";
+import "./chunk-Y6FXYEAI.mjs";
 
 // src/cli.ts
-var import_lodash = __toESM(require_lodash());
 import fs2 from "fs/promises";
 import path2 from "path";
+import _ from "lodash";
 import ProgressBar from "progress";
 import chalk from "chalk";
 import { runWithConcurrency } from "@tradejs/core/async";
@@ -38,7 +32,7 @@ import {
   redisKeys
 } from "@tradejs/infra/redis";
 import { logger as logger3 } from "@tradejs/infra/logger";
-import { getDataEdgesForSymbols } from "@tradejs/infra/timescale";
+import { getDataEdgesForSymbols } from "@tradejs/infra/timescale/candles";
 
 // src/screenshot.ts
 import fs from "fs/promises";
@@ -1230,7 +1224,7 @@ var getTickers = async (connector, include = "", exclude = "", limit, chunk, que
     const [currentChunk, chunksCount] = chunk.split("/").map((c) => parseInt(c));
     logger3.info("chunk: %d / %d", currentChunk, chunksCount);
     const chunkSize = Math.ceil(tickers.length / chunksCount);
-    const chunks = import_lodash.default.chunk(tickers, chunkSize);
+    const chunks = _.chunk(tickers, chunkSize);
     tickers = chunks[currentChunk - 1];
   }
   return tickers.filter((t) => !excludeTickers.includes(t));

package/dist/connectors.mjs

@@ -12,7 +12,7 @@ import {
   resolveConnectorName
 } from "./chunk-V3YMKE4I.mjs";
 import "./chunk-WS5DYEVZ.mjs";
-import "./chunk-UV2HVMKZ.mjs";
+import "./chunk-Y6FXYEAI.mjs";
 export {
   BUILTIN_CONNECTOR_NAMES,
   DEFAULT_CONNECTOR_NAME,

package/dist/constants.mjs

@@ -4,7 +4,7 @@ import {
   SCREENSHOT_CONCURRENCY_LIMIT,
   TG_CONCURRENCY_LIMIT
 } from "./chunk-KMJQQ53K.mjs";
-import "./chunk-UV2HVMKZ.mjs";
+import "./chunk-Y6FXYEAI.mjs";
 export {
   AI_CONCURRENCY_LIMIT,
   KLINE_CONCURRENCY_LIMIT,

package/dist/pine.mjs

@@ -1,17 +1,126 @@
 import {
-  createPineScriptLoader,
-  getLatestPineBooleanPlotValue,
-  getLatestPineBooleanPlotValues,
-  getLatestPineNumberPlotValue,
-  getLatestPineNumberPlotValues,
-  getLatestPineRawPlotValue,
-  getPinePlotSeries,
-  loadPineScriptFile,
-  runPineScript,
-  toFiniteNumber,
-  toPineBoolean
-} from "./chunk-IQKMII6L.mjs";
-import "./chunk-UV2HVMKZ.mjs";
+  __require
+} from "./chunk-Y6FXYEAI.mjs";
+
+// src/pine.ts
+import fs from "fs";
+import path from "path";
+var getPinePlotSeries = (context, plotName) => {
+  const name = String(plotName || "").trim();
+  if (!name) return [];
+  const data = context?.plots?.[name]?.data;
+  return Array.isArray(data) ? data : [];
+};
+var getLatestPineRawPlotValue = (context, plotName) => {
+  const series = getPinePlotSeries(context, plotName);
+  if (!series.length) return void 0;
+  return series[series.length - 1]?.value;
+};
+var getLatestPineNumberPlotValue = (context, plotName) => toFiniteNumber(getLatestPineRawPlotValue(context, plotName)) ?? null;
+var getLatestPineBooleanPlotValue = (context, plotName) => toPineBoolean(getLatestPineRawPlotValue(context, plotName));
+var getLatestPineNumberPlotValues = (context, plotNames) => Object.fromEntries(
+  plotNames.map((plotName) => [
+    plotName,
+    getLatestPineNumberPlotValue(context, plotName)
+  ])
+);
+var getLatestPineBooleanPlotValues = (context, plotNames) => Object.fromEntries(
+  plotNames.map((plotName) => [
+    plotName,
+    getLatestPineBooleanPlotValue(context, plotName)
+  ])
+);
+var toFiniteNumber = (value) => {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return void 0;
+  }
+  return value;
+};
+var toPineBoolean = (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;
+  return __require(cjsPath);
+};
+var loadPineScriptFile = (filePath, fallback = "") => {
+  const resolvedPath = String(filePath || "").trim();
+  if (!resolvedPath) {
+    return fallback;
+  }
+  try {
+    return fs.readFileSync(resolvedPath, "utf8").trim();
+  } catch {
+    return fallback;
+  }
+};
+var createPineScriptLoader = (baseDir) => {
+  const resolvedBaseDir = path.resolve(baseDir);
+  return (fileNameOrPath, fallback = "") => {
+    const rawPath = String(fileNameOrPath || "").trim();
+    if (!rawPath) {
+      return fallback;
+    }
+    const resolvedPath = path.isAbsolute(rawPath) ? rawPath : path.resolve(resolvedBaseDir, rawPath);
+    return loadPineScriptFile(resolvedPath, fallback);
+  };
+};
+var MINUTE_MS = 6e4;
+var normalizeTimestampMs = (timestamp) => timestamp < 1e12 ? timestamp * 1e3 : timestamp;
+var resolveCandleDuration = (candles) => {
+  if (candles.length < 2) {
+    return MINUTE_MS;
+  }
+  const first = normalizeTimestampMs(candles[0].timestamp);
+  const second = normalizeTimestampMs(candles[1].timestamp);
+  const duration = Math.max(second - first, MINUTE_MS);
+  return Number.isFinite(duration) && duration > 0 ? duration : MINUTE_MS;
+};
+var toPineRuntimeCandles = (candles) => {
+  const candleDuration = resolveCandleDuration(candles);
+  return candles.map((candle) => {
+    const openTime = normalizeTimestampMs(candle.timestamp);
+    return {
+      open: Number(candle.open),
+      high: Number(candle.high),
+      low: Number(candle.low),
+      close: Number(candle.close),
+      volume: Number(candle.volume ?? 0),
+      openTime,
+      closeTime: openTime + candleDuration
+    };
+  });
+};
+var runPineScript = async ({
+  candles,
+  script,
+  symbol = "SYMBOL",
+  timeframe = "15",
+  inputs = {},
+  limit
+}) => {
+  const { PineTS, Indicator } = loadPinets();
+  const trimmedScript = String(script || "").trim();
+  if (!trimmedScript) {
+    throw new Error("Pine script is empty");
+  }
+  if (!Array.isArray(candles) || candles.length === 0) {
+    throw new Error("No candles provided for Pine script execution");
+  }
+  const pineCandles = toPineRuntimeCandles(candles);
+  const pine = new PineTS(
+    pineCandles,
+    symbol,
+    timeframe,
+    Math.max(1, limit ?? pineCandles.length)
+  );
+  const indicator = new Indicator(trimmedScript, inputs);
+  const context = await pine.run(indicator);
+  return context;
+};
 export {
   createPineScriptLoader,
   getLatestPineBooleanPlotValue,