pinets 0.9.16 → 0.9.18

package/dist/types/namespaces/strategy/types.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Strategy configuration options.
+ *
+ * Field names mirror Pine's strategy() declaration parameters exactly
+ * (snake_case, single-word where Pine uses one word). See
+ * https://www.tradingview.com/pine-script-reference/v5/#fun_strategy
+ */
+export interface StrategyConfig {
+    title: string;
+    shorttitle?: string;
+    overlay: boolean;
+    format?: string;
+    precision?: number;
+    scale?: string;
+    pyramiding?: number;
+    calc_on_order_fills?: boolean;
+    calc_on_every_tick?: boolean;
+    max_bars_back?: number;
+    backtest_fill_limits_assumption?: number;
+    default_qty_type?: string;
+    default_qty_value?: number;
+    initial_capital?: number;
+    currency?: string;
+    slippage?: number;
+    commission_type?: string;
+    commission_value?: number;
+    process_orders_on_close?: boolean;
+    close_entries_rule?: string;
+    margin_long?: number;
+    margin_short?: number;
+    explicit_plot_zorder?: boolean;
+    max_lines_count?: number;
+    max_labels_count?: number;
+    max_boxes_count?: number;
+    max_polylines_count?: number;
+    calc_bars_count?: number;
+    risk_free_rate?: number;
+    use_bar_magnifier?: boolean;
+    fill_orders_on_standard_ohlc?: boolean;
+    dynamic_requests?: boolean;
+    behind_chart?: boolean;
+}
+/**
+ * A single trade — either currently open or already closed.
+ *
+ * Field names mirror Pine's per-trade getters from
+ * strategy.closedtrades.*(idx) / strategy.opentrades.*(idx).
+ *
+ * `size` is SIGNED to match Pine: positive = long, negative = short.
+ * The historical direction/qty pair has been collapsed into this single
+ * field, matching what `strategy.closedtrades.size(idx)` returns.
+ */
+export interface Trade {
+    id: string;
+    entry_id: string;
+    entry_price: number;
+    entry_bar_index: number;
+    entry_time: number;
+    entry_comment?: string;
+    exit_id?: string;
+    exit_price?: number;
+    exit_bar_index?: number;
+    exit_time?: number;
+    exit_comment?: string;
+    size: number;
+    profit?: number;
+    commission?: number;
+    max_drawdown?: number;
+    max_runup?: number;
+    status: 'open' | 'closed';
+}
+/**
+ * A pending or filled order tracked internally by the engine.
+ *
+ * No Pine API exposes pending orders directly. Field names follow Pine's
+ * `strategy.entry()` / `strategy.order()` parameter names where they map
+ * (`limit`, `stop`, `oca_name`, `oca_type`), and snake_case for the rest.
+ */
+export interface Order {
+    id: string;
+    direction: number;
+    qty: number;
+    type: 'market' | 'limit' | 'stop' | 'stop-limit';
+    limit?: number;
+    stop?: number;
+    bar: number;
+    time: number;
+    oca_name?: string;
+    oca_type?: 'cancel' | 'reduce' | 'none';
+    comment?: string;
+    fill_price?: number;
+    fill_bar?: number;
+    fill_time?: number;
+    status: 'pending' | 'filled' | 'cancelled';
+    category?: 'entry' | 'exit';
+    profit?: number;
+    loss?: number;
+    trail_price?: number;
+    trail_offset?: number;
+    trail_points?: number;
+    from_entry?: string;
+    qty_percent?: number;
+    comment_profit?: string;
+    comment_loss?: string;
+    comment_trailing?: string;
+    alert_message?: string;
+    alert_profit?: string;
+    alert_loss?: string;
+    alert_trailing?: string;
+    disable_alert?: boolean;
+    immediately?: boolean;
+    trail_peak?: number;
+    trail_armed?: boolean;
+}
+/**
+ * Strategy state stored on the Context after a backtest run.
+ *
+ * Top-level scalars mirror Pine's `strategy.*` properties 1:1 (snake_case,
+ * Pine's single-word concatenations like `netprofit` / `grossprofit` /
+ * `grossloss` / `openprofit` preserved). Position fields are FLATTENED
+ * — Pine exposes `strategy.position_size` / `position_avg_price` /
+ * `position_entry_name` as three separate scalars, not a nested object.
+ *
+ * The `opentrades` / `closedtrades` arrays use Pine's exact names with
+ * `.length` providing the count — same semantic as Pine's int count but
+ * also indexable for the per-trade getter equivalents.
+ */
+export interface StrategyState {
+    config: StrategyConfig;
+    opentrades: Trade[];
+    closedtrades: Trade[];
+    pending_orders: Order[];
+    position_size: number;
+    position_avg_price: number;
+    position_entry_name: string;
+    initial_capital: number;
+    account_currency: string;
+    equity: number;
+    netprofit: number;
+    grossprofit: number;
+    grossloss: number;
+    openprofit: number;
+    max_drawdown: number;
+    max_runup: number;
+    equity_peak: number;
+    equity_trough: number;
+    wintrades: number;
+    losstrades: number;
+    eventrades: number;
+    wintrades_total_profit: number;
+    losstrades_total_loss: number;
+    max_contracts_held_all: number;
+    max_contracts_held_long: number;
+    max_contracts_held_short: number;
+    risk_rules: {
+        allow_entry_in?: 'long' | 'short' | 'all';
+        max_cons_loss_days?: {
+            count: number;
+            alert_message?: string;
+        };
+        max_drawdown?: {
+            value: number;
+            type: 'cash' | 'percent_of_equity';
+        };
+        max_intraday_filled_orders?: {
+            count: number;
+            alert_message?: string;
+        };
+        max_intraday_loss?: {
+            value: number;
+            type: 'cash' | 'percent_of_equity';
+        };
+        max_position_size?: number;
+    };
+    risk_halted: boolean;
+}

package/dist/types/namespaces/strategy/utils.d.ts

@@ -0,0 +1,84 @@
+import { Order, StrategyState } from './types';
+/**
+ * Parse strategy() function arguments
+ */
+export declare function parseStrategyOptions(args: any[]): any;
+/**
+ * Calculate order quantity based on strategy configuration
+ */
+export declare function calculateOrderQty(context: any, specifiedQty: number | undefined, direction: number, fillPrice: number): number;
+/**
+ * Process pending orders and execute them
+ */
+export declare function processStrategyOrders(context: any): void;
+/**
+ * Parse direction string/number to numeric value
+ */
+export declare function parseDirection(direction: number | string): number;
+/**
+ * Returns true if adding a same-direction entry would exceed the strategy's
+ * pyramiding cap. Counts existing open trades in the requested direction.
+ *
+ * `strategy.entry()` (when implemented) consults this; `strategy.order()` does
+ * NOT — Pine treats strategy.order as a low-level primitive that ignores the
+ * pyramiding limit.
+ */
+export declare function wouldExceedPyramiding(strategy: StrategyState, direction: number): boolean;
+/**
+ * Pre-fill risk-rule check. Returns true if the order should be BLOCKED.
+ *
+ * Consulted rules (independent; first violation wins):
+ *   - risk_halted (latched by any catastrophic rule)
+ *   - allow_entry_in: 'long' blocks short orders; 'short' blocks long
+ *   - max_position_size: post-fill |position_size| would exceed N
+ */
+export declare function isOrderBlockedByRisk(strategy: StrategyState, order: Order): boolean;
+/**
+ * Latches `risk_halted` when any catastrophic rule trips (max_drawdown,
+ * max_intraday_loss, max_cons_loss_days). Once halted, all entries are
+ * blocked for the rest of the run.
+ *
+ * Called after each close. The intraday rules use simple cumulative
+ * approximations — true day-rollover detection would require bar timestamp
+ * + timezone logic that's deferred.
+ */
+export declare function evaluateCatastrophicRiskHalt(strategy: StrategyState): void;
+/**
+ * Open a new trade.
+ *
+ * @param direction +1 long, -1 short
+ * @param qty       unsigned contract count
+ * @param price     fill price
+ * @param time      fill time (ms)
+ */
+export declare function openTrade(context: any, entryId: string, direction: number, qty: number, price: number, time: number): void;
+/**
+ * Close partial or full position.
+ *
+ * FIFO accounting: closes oldest open trades first. Splits a trade if the
+ * close qty is smaller than the trade's remaining qty.
+ */
+export declare function closePartialPosition(context: any, qtyToClose: number, exitPrice: number, exitTime: number): void;
+/**
+ * FIFO close of `qtyToClose` contracts from open trades, optionally filtered
+ * by `fromEntry` — when set, only trades whose `entry_id === fromEntry` are
+ * eligible. Falls back to closing across all open trades when empty/undefined.
+ *
+ * Wraps `closePartialPosition` by temporarily reorganizing `opentrades` so
+ * the matching trades sit at the head of the FIFO queue.
+ */
+export declare function closeMatching(context: any, fromEntry: string | undefined, qtyToClose: number, exitPrice: number, exitTime: number): void;
+/**
+ * Process exit-category orders each bar (after entry-order fills, before the
+ * user script runs). Handles:
+ *   - Market exits from strategy.close() / strategy.close_all() (fill at
+ *     current bar's open if placed previously).
+ *   - Conditional exits from strategy.exit() — TP / SL / trailing-stop
+ *     triggers evaluated against current bar's high/low. Trailing-stop
+ *     peak (trade.trail_peak) is updated each bar even when not triggered.
+ */
+export declare function processExitOrders(context: any): void;
+/**
+ * Initialize strategy state
+ */
+export declare function initializeStrategy(context: any, config: any): void;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pinets",
-    "version": "0.9.16",
+    "version": "0.9.18",
     "description": "Run Pine Script anywhere. PineTS is an open-source transpiler and runtime that brings Pine Script logic to Node.js and the browser with 1:1 syntax compatibility. Reliably write, port, and run indicators or strategies on your own infrastructure.",
     "keywords": [
         "Pine Script",
@@ -105,7 +105,7 @@
     },
     "repository": {
         "type": "git",
-        "url": "git+https://github.com/QuantForgeOrg/PineTS.git"
+        "url": "git+https://github.com/LuxAlgo/PineTS.git"
     },
-    "homepage": "https://quantforge.org/pinets/"
+    "homepage": "https://luxalgo.com/"
 }