v0.1.3 - Enhancing Pine Script compatibility, Check CHANGELOG for details

Author: alaa-eddine

CHANGELOG.md

@@ -1,5 +1,18 @@
 # Change Log
 
+## [0.1.3] - 2025-02-10 -
+
+### Added
+
+-   Multiple transpiler fixes
+-   Fix Logical, Binary and unary expressions when passed as arguments to PineTS internal functions (e.g plot(close && open, ...))
+-   Support fo "na" as valid value (will be converted to NaN by the transpiler)
+-   Fix for Pine Script functions returning tupples
+-   Add partial support for color.rgb and color.new (these need to be completely rewritten)
+-   Experimenting a cache approach for TA functions (not yet ready, only tested with sma)
+-   Add Support for querying large time interval from MarketDataProvider by running multiple requests with a step, the requested market data is cached to prevent rate limiting and optimize performance
+-   Complete refactor of math.\* functions to ensure compatibility with time series for all functions using the same syntax as Pine Script
+
 ## [0.1.2] - 2025-02-05 - initial request.security() support
 
 ### Added

docs/api-coverage/color.md

@@ -10,7 +10,7 @@
 | `color.b()`             |        |
 | `color.from_gradient()` |        |
 | `color.g()`             |        |
-| `color.new()`           |        |
+| `color.new()`           | ⏳     |
 | `color.r()`             |        |
-| `color.rgb()`           |        |
+| `color.rgb()`           | ⏳     |
 | `color.t()`             |        |

docs/api-coverage/math.md

@@ -18,6 +18,7 @@
 | `math.log()`    | ✔️     |
 | `math.max()`    | ✅     |
 | `math.min()`    | ✅     |
+| `math.sum()`    | ✔️     |
 | `math.pow()`    | ✔️     |
 | `math.random()` | ✔️     |
 | `math.round()`  | ✔️     |

package.json

@@ -1,6 +1,6 @@
 {
     "name": "pinets",
-    "version": "0.1.2",
+    "version": "0.1.3",
     "description": "",
     "main": "dist/pinets.dev.es.js",
     "types": "dist/types/index.d.ts",

src/Context.class.ts

@@ -21,6 +21,7 @@ export class Context {
         ohlc4: [],
     };
     public cache: any = {};
+    public useTACache = false;
 
     public NA: any = NaN;
 
@@ -129,6 +130,7 @@ export class Context {
      * by default it is set to 10 decimals which is the same as pine script
      * @param n - the number to be precision
      * @param decimals - the number of decimals to precision to
+
      * @returns the precision number
      */
     precision(n: number, decimals: number = 10) {
@@ -151,6 +153,7 @@ export class Context {
         if (Array.isArray(source)) {
             if (index) {
                 this.params[name] = source.slice(index);
+                this.params[name].length = source.length; //ensure length is correct
                 return this.params[name];
             }
             this.params[name] = source.slice(0);

src/PineTS.class.ts

@@ -94,7 +94,7 @@ export class PineTS {
         return this._readyPromise;
     }
 
-    public async run(pineTSCode: Function | String, n?: number): Promise<Context> {
+    public async run(pineTSCode: Function | String, n?: number, useTACache?: boolean): Promise<Context> {
         await this.ready();
         if (!n) n = this._periods;
 
@@ -109,7 +109,7 @@ export class PineTS {
         });
 
         context.pineTSCode = pineTSCode;
-
+        context.useTACache = useTACache;
         const transformer = transpile.bind(this);
         let transpiledFn = transformer(pineTSCode);
 

src/marketData/Binance/BinanceProvider.class.ts

@@ -22,17 +22,153 @@ const timeframe_to_binance = {
 
 import { IProvider } from '@pinets/marketData/IProvider';
 
+interface CacheEntry<T> {
+    data: T;
+    timestamp: number;
+}
+
+class CacheManager<T> {
+    private cache: Map<string, CacheEntry<T>>;
+    private readonly cacheDuration: number;
+
+    constructor(cacheDuration: number = 5 * 60 * 1000) {
+        // Default 5 minutes
+        this.cache = new Map();
+        this.cacheDuration = cacheDuration;
+    }
+
+    private generateKey(params: Record<string, any>): string {
+        return Object.entries(params)
+            .filter(([_, value]) => value !== undefined)
+            .map(([key, value]) => `${key}:${value}`)
+            .join('|');
+    }
+
+    get(params: Record<string, any>): T | null {
+        const key = this.generateKey(params);
+        const cached = this.cache.get(key);
+
+        if (!cached) return null;
+
+        if (Date.now() - cached.timestamp > this.cacheDuration) {
+            this.cache.delete(key);
+            return null;
+        }
+
+        return cached.data;
+    }
+
+    set(params: Record<string, any>, data: T): void {
+        const key = this.generateKey(params);
+        this.cache.set(key, {
+            data,
+            timestamp: Date.now(),
+        });
+    }
+
+    clear(): void {
+        this.cache.clear();
+    }
+
+    // Optional: method to remove expired entries
+    cleanup(): void {
+        const now = Date.now();
+        for (const [key, entry] of this.cache.entries()) {
+            if (now - entry.timestamp > this.cacheDuration) {
+                this.cache.delete(key);
+            }
+        }
+    }
+}
+
 export class BinanceProvider implements IProvider {
+    private cacheManager: CacheManager<any[]>;
+
+    constructor() {
+        this.cacheManager = new CacheManager(5 * 60 * 1000); // 5 minutes cache duration
+    }
+
+    async getMarketDataInterval(tickerId: string, timeframe: string, sDate: number, eDate: number): Promise<any> {
+        try {
+            const interval = timeframe_to_binance[timeframe.toUpperCase()];
+            if (!interval) {
+                console.error(`Unsupported timeframe: ${timeframe}`);
+                return [];
+            }
+
+            const timeframeDurations = {
+                '1m': 60 * 1000,
+                '3m': 3 * 60 * 1000,
+                '5m': 5 * 60 * 1000,
+                '15m': 15 * 60 * 1000,
+                '30m': 30 * 60 * 1000,
+                '1h': 60 * 60 * 1000,
+                '2h': 2 * 60 * 60 * 1000,
+                '4h': 4 * 60 * 60 * 1000,
+                '1d': 24 * 60 * 60 * 1000,
+                '1w': 7 * 24 * 60 * 60 * 1000,
+                '1M': 30 * 24 * 60 * 60 * 1000,
+            };
+
+            let allData = [];
+            let currentStart = sDate;
+            const endTime = eDate;
+            const intervalDuration = timeframeDurations[interval];
+
+            if (!intervalDuration) {
+                console.error(`Duration not defined for interval: ${interval}`);
+                return [];
+            }
+
+            while (currentStart < endTime) {
+                const chunkEnd = Math.min(currentStart + 1000 * intervalDuration, endTime);
+
+                const data = await this.getMarketData(
+                    tickerId,
+                    timeframe,
+                    1000, // Max allowed by Binance
+                    currentStart,
+                    chunkEnd
+                );
+
+                if (data.length === 0) break;
+
+                allData = allData.concat(data);
+
+                // CORRECTED LINE: Remove *1000 since closeTime is already in milliseconds
+                currentStart = data[data.length - 1].closeTime + 1;
+
+                // Keep this safety check to exit when we get less than full page
+                if (data.length < 1000) break;
+            }
+
+            return allData;
+        } catch (error) {
+            console.error('Error in getMarketDataInterval:', error);
+            return [];
+        }
+    }
     //TODO : allow querying more than 1000 klines
     //TODO : immplement cache
     async getMarketData(tickerId: string, timeframe: string, limit?: number, sDate?: number, eDate?: number): Promise<any> {
         try {
+            // Check cache first
+            const cacheParams = { tickerId, timeframe, limit, sDate, eDate };
+            const cachedData = this.cacheManager.get(cacheParams);
+            if (cachedData) {
+                console.log('cache hit', tickerId, timeframe, limit, sDate, eDate);
+                return cachedData;
+            }
+
             const interval = timeframe_to_binance[timeframe.toUpperCase()];
             if (!interval) {
                 console.error(`Unsupported timeframe: ${timeframe}`);
                 return [];
             }
             let url = `${BINANCE_API_URL}/klines?symbol=${tickerId}&interval=${interval}`;
+            if (!limit && sDate && eDate) {
+                return this.getMarketDataInterval(tickerId, timeframe, sDate, eDate);
+            }
 
             //example https://api.binance.com/api/v3/klines?symbol=BTCUSDT&interval=1m&limit=1000
             if (limit) {
@@ -53,20 +189,24 @@ export class BinanceProvider implements IProvider {
             const result = await response.json();
             const data = result.map((item) => {
                 return {
-                    openTime: parseInt(item[0]) / 1000,
+                    openTime: parseInt(item[0]),
                     open: parseFloat(item[1]),
                     high: parseFloat(item[2]),
                     low: parseFloat(item[3]),
                     close: parseFloat(item[4]),
                     volume: parseFloat(item[5]),
-                    closeTime: parseInt(item[6]) / 1000,
+                    closeTime: parseInt(item[6]),
                     quoteAssetVolume: parseFloat(item[7]),
                     numberOfTrades: parseInt(item[8]),
                     takerBuyBaseAssetVolume: parseFloat(item[9]),
                     takerBuyQuoteAssetVolume: parseFloat(item[10]),
                     ignore: item[11],
                 };
             });
+
+            // Cache the results
+            this.cacheManager.set(cacheParams, data);
+
             return data;
         } catch (error) {
             console.error('Error in binance.klines:', error);

src/namespaces/Core.ts

@@ -2,12 +2,35 @@
 
 export class Core {
     public color = {
+        param: (source, index = 0) => {
+            if (Array.isArray(source)) {
+                return source[index];
+            }
+            return source;
+        },
+        rgb: (r: number, g: number, b: number, a?: number) => (a ? `rgba(${r}, ${g}, ${b}, ${a})` : `rgb(${r}, ${g}, ${b})`),
+        new: (color: string, a?: number) => {
+            // Handle hexadecimal colors
+            if (color && color.startsWith('#')) {
+                // Remove # and convert to RGB
+                const hex = color.slice(1);
+                const r = parseInt(hex.slice(0, 2), 16);
+                const g = parseInt(hex.slice(2, 4), 16);
+                const b = parseInt(hex.slice(4, 6), 16);
+
+                return a ? `rgba(${r}, ${g}, ${b}, ${a})` : `rgb(${r}, ${g}, ${b})`;
+            }
+            // Handle existing RGB format
+            return a ? `rgba(${color}, ${a})` : color;
+        },
         white: 'white',
         lime: 'lime',
         green: 'green',
         red: 'red',
         maroon: 'maroon',
+
         black: 'black',
+
         gray: 'gray',
         blue: 'blue',
     };
@@ -36,7 +59,7 @@ export class Core {
         this.context.plots[title].data.push({
             time: this.context.marketData[this.context.marketData.length - this.context.idx - 1].openTime,
             value: series[0],
-            options: this.extractPlotOptions(options),
+            options: { ...this.extractPlotOptions(options), style: 'char' },
         });
     }
 
@@ -56,10 +79,8 @@ export class Core {
         return Array.isArray(series) ? isNaN(series[0]) : isNaN(series);
     }
     nz(series: any, replacement: number = 0) {
-        if (Array.isArray(series)) {
-            return isNaN(series[0]) ? replacement : series[0];
-        } else {
-            return isNaN(series) ? replacement : series;
-        }
+        const val = Array.isArray(series) ? series[0] : series;
+        const rep = Array.isArray(series) ? replacement[0] : replacement;
+        return isNaN(val) ? rep : val;
     }
 }