pinets 0.9.16 → 0.9.18

package/dist/types/Context.class.d.ts

@@ -4,6 +4,7 @@ import { Input } from './namespaces/input/input.index';
 import PineMath from './namespaces/math/math.index';
 import { PineRequest } from './namespaces/request/request.index';
 import TechnicalAnalysis from './namespaces/ta/ta.index';
+import { StrategyState } from './namespaces/strategy/strategy.index';
 import { Series } from './Series';
 import type { IndicatorOptions } from './types/PineTypes';
 export declare class Context {
@@ -11,6 +12,7 @@ export declare class Context {
     indicator: IndicatorOptions;
     cache: any;
     taState: any;
+    strategy?: StrategyState;
     isSecondaryContext: boolean;
     chartTimezone: string | null;
     dataVersion: number;

package/dist/types/PineTS.class.d.ts

@@ -144,10 +144,6 @@ export declare class PineTS {
         on: (event: 'data' | 'error' | 'warning' | 'alert', callback: Function) => void;
         stop: () => void;
     };
-    /**
-     * Run the script completely and return the final context (backward compatible behavior)
-     * @private
-     */
     /**
      * Run an already-transpiled PineTS function in this instance — no
      * additional transpile/parse pass. Used by `request.security_lower_tf`'s
@@ -158,6 +154,16 @@ export declare class PineTS {
      * arbitrary function is unsafe.
      */
     runPretranspiled(transpiledFn: Function, inputs?: Record<string, any>, periods?: number): Promise<Context>;
+    /**
+     * Run the script completely and return the final context.
+     *
+     * Execution is split: all bars except the last are processed first, then a
+     * var-state snapshot is taken, then the last bar is processed. This gives
+     * updateTail() a reliable snapshot-based restore point, matching the
+     * pattern used by _runPaginated and eliminates the pop-based drift that
+     * occurred when var variables were modified in-place during re-execution.
+     * @private
+     */
     private _runComplete;
     /**
      * Run the script with pagination, yielding results page by page
@@ -196,9 +202,16 @@ export declare class PineTS {
     private _appendCandle;
     /**
      * Update the secondary context's tail with fresh market data.
-     * Mirrors the streaming update logic in _runPaginated:
-     * fetches new/updated candles, rolls back the last result, and re-executes
-     * only the affected bars.
+     *
+     * Uses snapshot-restore for reliable var state rollback, matching the
+     * approach used by _runPaginated. The pop-based _removeLastResult is
+     * only used as a fallback for contexts that have no snapshot (e.g. those
+     * produced by runPretranspiled, which skips the split-execute pattern).
+     *
+     * After restoring state and re-executing, a fresh snapshot is taken before
+     * the last bar so that subsequent updateTail() calls also have a valid
+     * restore point.
+     *
      * @param context - The cached secondary context to update
      * @returns true if data was updated, false if no changes
      */

package/dist/types/namespaces/line/LineHelper.d.ts

@@ -15,6 +15,15 @@ export declare class LineHelper {
      * scalar value is used for line properties.
      */
     private _resolve;
+    /**
+     * Resolve a color value, PRESERVING na markers so renderers can
+     * detect "no color". Pine emits na as null (from `color(na)` —
+     * `color.any` returns null) or NaN (from raw `na` literal). Both
+     * must survive into the plot data — collapsing them to a default
+     * forces the renderer to paint a visible line where the script
+     * asked for none. Mirrors Box/Polyline `_resolveColor`.
+     */
+    private _resolveColor;
     private _createLine;
     private _enforceMaxCount;
     new(...args: any[]): LineObject;

package/dist/types/namespaces/linefill/LinefillHelper.d.ts

@@ -11,6 +11,17 @@ export declare class LinefillHelper {
      * Resolve a value that may be a Series, a bound function, or a plain scalar.
      */
     private _resolve;
+    /**
+     * Resolve a color value, PRESERVING na markers so renderers can
+     * detect "no color" instead of being forced to paint a default.
+     * Pine emits na either as null (from `color(na)` — `color.any`
+     * returns null) or as NaN (from raw `na` literals). The previous
+     * implementation collapsed both to '' via `_resolve(color) || ''`,
+     * which destroyed the signal and made `linefill.new(line1, line2,
+     * color(na))` render as a default-coloured fill instead of being
+     * invisible. Mirror Box/Polyline `_resolveColor`.
+     */
+    private _resolveColor;
     new(line1: LineObject, line2: LineObject, color: any): LinefillObject;
     any(...args: any[]): LinefillObject | null;
     set_color(id: LinefillObject, color: any): void;

package/dist/types/namespaces/polyline/PolylineObject.d.ts

@@ -6,15 +6,15 @@ export declare class PolylineObject {
     curved: boolean;
     closed: boolean;
     xloc: string;
-    line_color: string;
-    fill_color: string;
+    line_color: any;
+    fill_color: any;
     line_style: string;
     line_width: number;
     force_overlay: boolean;
     _deleted: boolean;
     /** Bar index at which this object was created (for streaming rollback) */
     _createdAtBar: number;
-    constructor(points: ChartPointObject[], curved?: boolean, closed?: boolean, xloc?: string, line_color?: string, fill_color?: string, line_style?: string, line_width?: number, force_overlay?: boolean);
+    constructor(points: ChartPointObject[], curved?: boolean, closed?: boolean, xloc?: string, line_color?: any, fill_color?: any, line_style?: string, line_width?: number, force_overlay?: boolean);
     delete(): void;
     toPlotData(): any;
 }

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

@@ -0,0 +1,5 @@
+/**
+ * Account currency configured in the strategy() declaration's `currency=`.
+ * Defaults to 'USD'. Matches Pine's strategy.account_currency.
+ */
+export declare function account_currency(context: any): () => any;

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

@@ -0,0 +1,5 @@
+/**
+ * Declares a strategy and initializes strategy state
+ * Usage: strategy(title, overlay=false, ...)
+ */
+export declare function any(context: any): (...args: any[]) => any;

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

@@ -0,0 +1,6 @@
+/**
+ * Average loss across losing closed trades, returned as a POSITIVE number
+ * (Pine convention: average loss is unsigned). NaN when no losers yet.
+ * Matches Pine's strategy.avg_losing_trade.
+ */
+export declare function avg_losing_trade(context: any): () => number;

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

@@ -0,0 +1,5 @@
+/**
+ * Average per-trade loss (as a positive percent) across losing closed trades.
+ * NaN when no losers yet. Matches Pine's strategy.avg_losing_trade_percent.
+ */
+export declare function avg_losing_trade_percent(context: any): () => number;

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

@@ -0,0 +1,5 @@
+/**
+ * Average profit/loss across all closed trades (post-commission).
+ * NaN when no trades have closed. Matches Pine's strategy.avg_trade.
+ */
+export declare function avg_trade(context: any): () => number;

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

@@ -0,0 +1,6 @@
+/**
+ * Average per-trade return as a percent. Computed as the mean of each
+ * closed trade's individual profit_percent = profit / (entry_price * |size|) * 100.
+ * NaN when no trades have closed. Matches Pine's strategy.avg_trade_percent.
+ */
+export declare function avg_trade_percent(context: any): () => number;

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

@@ -0,0 +1,5 @@
+/**
+ * Average profit across winning closed trades. NaN when no winners yet.
+ * Matches Pine's strategy.avg_winning_trade.
+ */
+export declare function avg_winning_trade(context: any): () => number;

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

@@ -0,0 +1,5 @@
+/**
+ * Average per-trade return (as a percent) across winning closed trades.
+ * NaN when no winners yet. Matches Pine's strategy.avg_winning_trade_percent.
+ */
+export declare function avg_winning_trade_percent(context: any): () => number;

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

@@ -0,0 +1 @@
+export declare function cancel(context: any): (...args: any[]) => void;

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

@@ -0,0 +1,6 @@
+/**
+ * Cancel all pending orders (entries only — exits attached to open trades
+ * are not affected since they ride on positions, not orders).
+ * Pine signature: strategy.cancel_all() → void
+ */
+export declare function cancel_all(context: any): () => void;

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

@@ -0,0 +1,5 @@
+/**
+ * Constant for order sizing type: cash
+ * Used in default_qty_type parameter
+ */
+export declare function cash(context: any): () => string;

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

@@ -0,0 +1 @@
+export declare function close(context: any): (...args: any[]) => void;

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

@@ -0,0 +1 @@
+export declare function close_all(context: any): (...args: any[]) => void;

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

@@ -0,0 +1,15 @@
+/**
+ * Pine's `strategy.closedtrades` serves a dual role:
+ *   - As a scalar: a series int count of closed trades.
+ *   - As a namespace: `strategy.closedtrades.profit(idx)` etc.
+ *
+ * Our transpiler renders the bare access as a CALL (`strategy.closedtrades()`),
+ * and the chained access as a CHAINED CALL (`strategy.closedtrades().profit(0)`).
+ * Both must work. The trick: the call returns a hybrid object that:
+ *   - has `valueOf()` returning the count (so it behaves like an int in
+ *     arithmetic/comparison contexts, e.g. `_ct > 0`),
+ *   - has the per-trade methods (`profit`, `size`, ...) attached.
+ *
+ * This pattern keeps the transpiler unchanged while supporting both shapes.
+ */
+export declare function closedtrades(context: any): () => any;

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

@@ -0,0 +1,9 @@
+/**
+ * Convert a value from the symbol's currency to the account currency.
+ *
+ * For the common same-currency case (e.g. BTCUSDC's quote currency USDC ≈ USD),
+ * this is an identity. Genuine cross-currency conversion would require an FX
+ * rate source which we don't model; returns the input unchanged in that case
+ * with a console warning on first call.
+ */
+export declare function convert_to_account(context: any): (value: number) => number;

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

@@ -0,0 +1,5 @@
+/**
+ * Inverse of convert_to_account: from account currency → symbol currency.
+ * Same identity passthrough for matching-currency case.
+ */
+export declare function convert_to_symbol(context: any): (value: number) => number;

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

@@ -0,0 +1,8 @@
+/**
+ * Returns the qty that would be used for an entry at the given fill price,
+ * given the strategy's `default_qty_type` and `default_qty_value`. Mirrors
+ * `calculateOrderQty()` without a specified qty (always uses the default).
+ *
+ * Pine signature: strategy.default_entry_qty(fill_price) → series float
+ */
+export declare function default_entry_qty(context: any): (fillPrice: number) => number;

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

@@ -0,0 +1 @@
+export declare function entry(context: any): (...args: any[]) => void;

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

@@ -0,0 +1,5 @@
+/**
+ * Returns the current equity (initial_capital + netprofit + openprofit).
+ * Matches Pine's strategy.equity.
+ */
+export declare function equity(context: any): () => any;

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

@@ -0,0 +1,2 @@
+/** Count of breakeven (profit === 0) closed trades. Matches Pine's strategy.eventrades. */
+export declare function eventrades(context: any): () => any;

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

@@ -0,0 +1 @@
+export declare function exit(context: any): (...args: any[]) => void;

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

@@ -0,0 +1,5 @@
+/**
+ * Constant for order sizing type: fixed
+ * Used in default_qty_type parameter
+ */
+export declare function fixed(context: any): () => string;

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

@@ -0,0 +1,5 @@
+/**
+ * Total currency value of all completed losing trades, as a POSITIVE number
+ * (the absolute sum of losses). Matches Pine's strategy.grossloss semantics.
+ */
+export declare function grossloss(context: any): () => any;

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

@@ -0,0 +1,4 @@
+/**
+ * strategy.grossloss as a percent of initial capital.
+ */
+export declare function grossloss_percent(context: any): () => number;

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

@@ -0,0 +1,5 @@
+/**
+ * Total currency value of all completed winning trades (post-commission).
+ * Matches Pine's strategy.grossprofit.
+ */
+export declare function grossprofit(context: any): () => any;

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

@@ -0,0 +1,4 @@
+/**
+ * strategy.grossprofit as a percent of initial capital.
+ */
+export declare function grossprofit_percent(context: any): () => number;

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

@@ -0,0 +1,2 @@
+/** The initial capital configured on the strategy() declaration. Matches Pine's strategy.initial_capital. */
+export declare function initial_capital(context: any): () => any;

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

@@ -0,0 +1,4 @@
+/**
+ * Constant representing long direction
+ */
+export declare function long(context: any): () => string;

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

@@ -0,0 +1,2 @@
+/** Count of closed trades with profit < 0. Matches Pine's strategy.losstrades. */
+export declare function losstrades(context: any): () => any;

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

@@ -0,0 +1,13 @@
+/**
+ * Price at which the current leveraged position would be force-liquidated.
+ * Returns NaN when flat or when the relevant margin% is 100 (no leverage).
+ *
+ * Formula (simplified):
+ *   long  → entry_avg_price * (1 - margin_long / 100)
+ *   short → entry_avg_price * (1 + margin_short / 100)
+ *
+ * This is the simple peak-loss-tolerable price; real broker liquidation
+ * depends on maintenance margin schedules which we don't model.
+ * Matches Pine's strategy.margin_liquidation_price in the common case.
+ */
+export declare function margin_liquidation_price(context: any): () => number;

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

@@ -0,0 +1,2 @@
+/** Peak |position_size| seen across the run. Matches Pine's strategy.max_contracts_held_all. */
+export declare function max_contracts_held_all(context: any): () => any;

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

@@ -0,0 +1,2 @@
+/** Peak long-side position_size seen. Matches Pine's strategy.max_contracts_held_long. */
+export declare function max_contracts_held_long(context: any): () => any;

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

@@ -0,0 +1,2 @@
+/** Peak |short-side position_size| seen. Matches Pine's strategy.max_contracts_held_short. */
+export declare function max_contracts_held_short(context: any): () => any;

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

@@ -0,0 +1,5 @@
+/**
+ * Maximum peak-to-trough equity drawdown over the whole run (currency).
+ * Matches Pine's strategy.max_drawdown.
+ */
+export declare function max_drawdown(context: any): () => any;

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

@@ -0,0 +1,5 @@
+/**
+ * Maximum drawdown as a percent of the equity high-water mark.
+ * Matches Pine's strategy.max_drawdown_percent.
+ */
+export declare function max_drawdown_percent(context: any): () => number;

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

@@ -0,0 +1,5 @@
+/**
+ * Maximum equity run-up over the whole run (currency).
+ * Matches Pine's strategy.max_runup.
+ */
+export declare function max_runup(context: any): () => any;

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

@@ -0,0 +1,5 @@
+/**
+ * Maximum equity run-up as a percent of initial capital.
+ * Matches Pine's strategy.max_runup_percent.
+ */
+export declare function max_runup_percent(context: any): () => number;

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

@@ -0,0 +1,5 @@
+/**
+ * Realized P&L summed across all closed trades.
+ * Matches Pine's strategy.netprofit.
+ */
+export declare function netprofit(context: any): () => any;

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

@@ -0,0 +1,5 @@
+/**
+ * Realized net profit expressed as a percent of initial capital.
+ * Matches Pine's strategy.netprofit_percent.
+ */
+export declare function netprofit_percent(context: any): () => number;

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

@@ -0,0 +1,5 @@
+/**
+ * Unrealized P&L across all currently-open trades.
+ * Matches Pine's strategy.openprofit. Updated each bar by updateUnrealizedPnL().
+ */
+export declare function openprofit(context: any): () => any;

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

@@ -0,0 +1,5 @@
+/**
+ * Unrealized P&L expressed as a percent of initial capital.
+ * Matches Pine's strategy.openprofit_percent.
+ */
+export declare function openprofit_percent(context: any): () => number;

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

@@ -0,0 +1,9 @@
+/**
+ * Pine's `strategy.opentrades` mirrors strategy.closedtrades' dual-role
+ * pattern — see that file's header for the rationale.
+ *
+ *   strategy.opentrades            → scalar count via valueOf
+ *   strategy.opentrades.profit(0)  → per-trade unrealized P&L
+ *   strategy.opentrades.capital_held → property (sum of held capital)
+ */
+export declare function opentrades(context: any): () => any;

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

@@ -0,0 +1,6 @@
+import { Order } from '../types';
+/**
+ * Place a basic order.
+ * Pine reference: https://www.tradingview.com/pine-script-reference/v5/#fun_strategy{dot}order
+ */
+export declare function order(context: any): (...args: any[]) => Order;

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

@@ -0,0 +1,5 @@
+/**
+ * Parameter wrapper for strategy namespace
+ * Type B - Simple Unwrapping (like input, array, map, matrix)
+ */
+export declare function param(context: any): (source: any, index?: number) => any;

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

@@ -0,0 +1,5 @@
+/**
+ * Constant for order sizing type: percent_of_equity
+ * Used in default_qty_type parameter
+ */
+export declare function percent_of_equity(context: any): () => string;

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

@@ -0,0 +1,5 @@
+/**
+ * Weighted-average entry price of the current open position.
+ * Returns NaN when flat — matches Pine's strategy.position_avg_price semantics.
+ */
+export declare function position_avg_price(context: any): () => any;

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

@@ -0,0 +1,5 @@
+/**
+ * Id string of the entry that initially opened the current position.
+ * Empty string when flat. Matches Pine's strategy.position_entry_name.
+ */
+export declare function position_entry_name(context: any): () => any;

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

@@ -0,0 +1,5 @@
+/**
+ * Signed position size — positive for long, negative for short, 0 for flat.
+ * Matches Pine's strategy.position_size.
+ */
+export declare function position_size(context: any): () => any;

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

@@ -0,0 +1,22 @@
+/**
+ * `strategy.risk` is a nested namespace with 6 setter functions that
+ * configure pre-trade risk rules. Each call mutates `context.strategy.risk_rules`;
+ * the actual blocking is performed by `checkRiskRules()` in utils.ts,
+ * invoked before each entry fills.
+ *
+ * Pine signatures:
+ *   strategy.risk.allow_entry_in(value)                         → void
+ *   strategy.risk.max_cons_loss_days(count, alert_message)      → void
+ *   strategy.risk.max_drawdown(value, type, alert_message)      → void
+ *   strategy.risk.max_intraday_filled_orders(count, alert_message) → void
+ *   strategy.risk.max_intraday_loss(value, type, alert_message) → void
+ *   strategy.risk.max_position_size(contracts)                  → void
+ */
+export declare function risk(context: any): {
+    allow_entry_in: (value: "long" | "short" | "all") => void;
+    max_cons_loss_days: (count: number, alert_message?: string) => void;
+    max_drawdown: (value: number, type: "cash" | "percent_of_equity", _alert_message?: string) => void;
+    max_intraday_filled_orders: (count: number, alert_message?: string) => void;
+    max_intraday_loss: (value: number, type: "cash" | "percent_of_equity", _alert_message?: string) => void;
+    max_position_size: (contracts: number) => void;
+};

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

@@ -0,0 +1,4 @@
+/**
+ * Constant representing short direction
+ */
+export declare function short(context: any): () => string;

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

@@ -0,0 +1,2 @@
+/** Count of closed trades with profit > 0. Matches Pine's strategy.wintrades. */
+export declare function wintrades(context: any): () => any;

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

@@ -0,0 +1,7 @@
+export type { StrategyConfig, StrategyState, Trade, Order } from './types';
+export declare class Strategy {
+    private context;
+    [key: string]: any;
+    constructor(context: any);
+}
+export default Strategy;