pinets 0.9.27 → 0.9.29

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

@@ -15,6 +15,7 @@ export declare class Context {
     strategy?: StrategyState;
     isSecondaryContext: boolean;
     chartTimezone: string | null;
+    chartStyle: string;
     dataVersion: number;
     __maxLoops: number;
     NA: any;

package/dist/types/index.d.ts

@@ -11,6 +11,7 @@ export type { IProvider, ISymbolInfo, BaseProviderConfig, ApiKeyProviderConfig }
 export type { Kline, PeriodType } from './marketData/types';
 export { computeNextPeriodStart, localTimeToUTC, computeSessionClose, TIMEFRAME_SECONDS, TIMEFRAME_PERIOD_INFO } from './marketData/types';
 export { aggregateCandles, selectSubTimeframe, getAggregationRatio } from './marketData/aggregation';
+export { splitTickerModifier, stripTickerModifier, withTickerModifier } from './tickerModifier';
 export { PineTS, Context, Provider, Indicator, PineRuntimeError };
 export type { IPineInput, IPineProp, PineInputType, PineInputDisplay, PinePropType, PreparedScript } from './Indicator';
 export { INDICATOR_PROPS, STRATEGY_PROPS, propsForDeclaration } from './Indicator';

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

@@ -4,11 +4,17 @@
  * The methods here construct "ticker ID" strings that are passed to
  * `request.security` / `request.security_lower_tf` to fetch data for a
  * specific symbol — potentially with extra modifiers (session,
- * adjustment, non-standard chart type). PineTS' data providers serve
- * standard candles only; chart-type modifiers (Heikin-Ashi, Renko,
- * Kagi, Line Break, Point & Figure) are silently dropped at the
- * `request.security` boundary, since we can't render alternative
- * bar-construction algorithms from the raw OHLCV feed.
+ * adjustment, non-standard chart type).
+ *
+ * CHART-TYPE modifiers travel as an EXTENDED-TICKER suffix
+ * (`"BINANCE:BTCUSDT;heikinashi"` — see `tickerModifier.ts`):
+ * `ticker.heikinashi()` appends it, `ticker.standard()` strips it, and
+ * `request.security` passes it through to the data source untouched. An
+ * embedding host that owns the transform honors it; PineTS' own bundled
+ * providers serve standard candles only and strip it at their boundary
+ * (documented no-op for standalone use). The other non-standard types
+ * (Renko, Kagi, Line Break, Point & Figure) remain plain-symbol stubs —
+ * no data source we route to can construct those bars.
  *
  * For the plain "no-modifier" cases — which cover virtually every
  * real-world Pine script — the returned tickerid strings match
@@ -27,13 +33,14 @@ export declare class Ticker {
      */
     param(source: any, index?: number, _name?: string): any;
     /**
-     * ticker.inherit(from_tickerid, symbol) → simple string
+     * ticker.inherit(from_tickerid, symbol) → string
      *
-     * Returns a ticker ID that uses `symbol` and inherits modifier
-     * settings (session, currency, adjustment, chart type) from
-     * `from_tickerid`. For data-fetching purposes the result is
-     * effectively `symbol` — modifiers can't be honored without a TV
-     * datafeed, and `symbol` is what `request.security` needs.
+     * Returns a ticker ID that uses `symbol` and inherits modifier settings from
+     * `from_tickerid`. The CHART-TYPE modifier is honored: inheriting from a
+     * `";heikinashi"` ticker (e.g. `syminfo.tickerid` on a Heikin-Ashi chart)
+     * yields `"symbol;heikinashi"`, so the derived request keeps the chart type.
+     * The other modifier kinds (session, currency, adjustment) can't be honored
+     * without a TV datafeed and are dropped, as before.
      */
     inherit(_from_tickerid: any, symbol: any): string;
     /**
@@ -54,22 +61,22 @@ export declare class Ticker {
     /**
      * ticker.standard(symbol?) → simple string
      *
-     * Returns the symbol stripped of any non-standard chart-type
-     * modifiers. Since PineTS doesn't synthesise non-standard chart
-     * types in the first place, this is effectively a pass-through
-     * (the standard form IS what our providers serve). If `symbol` is
-     * undefined, falls back to `syminfo.tickerid`.
+     * Returns the symbol stripped of any chart-type modifier suffix —
+     * on a Heikin-Ashi chart, `ticker.standard(syminfo.tickerid)` turns
+     * `"BINANCE:BTCUSDT;heikinashi"` back into `"BINANCE:BTCUSDT"`, so a
+     * `request.security` call on the result fetches STANDARD candles.
+     * If `symbol` is undefined, falls back to `syminfo.tickerid`.
      */
     standard(symbol?: any): string;
     /**
-     * ticker.heikinashi(symbol) → simple string
+     * ticker.heikinashi(symbol) → extended-ticker string
      *
-     * In TV this returns an encoded tickerid that instructs the
-     * datafeed to deliver Heikin-Ashi bars. PineTS' providers don't
-     * synthesise HA candles, so we return the plain symbol — downstream
-     * `request.security` fetches standard candles, NOT HA-transformed
-     * ones. Behavior diverges from TV when the script depends on the
-     * HA values matching TV's HA computation. Documented limitation.
+     * Returns the symbol with the Heikin-Ashi chart-type modifier
+     * appended (`"BINANCE:BTCUSDT;heikinashi"`). `request.security`
+     * passes it through to the data source: an embedding host that owns
+     * the Heikin-Ashi transform serves derived bars; PineTS' own bundled
+     * providers strip the modifier and serve standard candles (documented
+     * standalone limitation). Idempotent on already-modified tickers.
      */
     heikinashi(symbol: any): string;
     /**

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

@@ -31,6 +31,7 @@ import { toradians } from './methods/toradians';
 import { __eq } from './methods/__eq';
 import { __ge } from './methods/__ge';
 import { __gt } from './methods/__gt';
+import { __idiv } from './methods/__idiv';
 import { __le } from './methods/__le';
 import { __lt } from './methods/__lt';
 import { __neq } from './methods/__neq';
@@ -68,6 +69,7 @@ declare const methods: {
     __eq: typeof __eq;
     __ge: typeof __ge;
     __gt: typeof __gt;
+    __idiv: typeof __idiv;
     __le: typeof __le;
     __lt: typeof __lt;
     __neq: typeof __neq;
@@ -108,6 +110,7 @@ export declare class PineMath {
     __eq: ReturnType<typeof methods.__eq>;
     __ge: ReturnType<typeof methods.__ge>;
     __gt: ReturnType<typeof methods.__gt>;
+    __idiv: ReturnType<typeof methods.__idiv>;
     __le: ReturnType<typeof methods.__le>;
     __lt: ReturnType<typeof methods.__lt>;
     __neq: ReturnType<typeof methods.__neq>;

package/dist/types/namespaces/math/methods/__idiv.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Pine integer division — the `/` (and `%`, via the transpiler) operator applied
+ * to two **integer** operands. In Pine, `int / int` yields an `int`: the result
+ * is truncated toward zero (`11 / 2 === 5`, `-11 / 2 === -5`), whereas JavaScript
+ * `/` is always float division (`5.5`).
+ *
+ * The transpiler rewrites a `/` BinaryExpression to this helper ONLY when BOTH
+ * operands are provably `int` at compile time (see TypeInferencePass). Any float
+ * operand keeps native `/`, so genuine float division (`4.0 / 2.0`, `close / 2`)
+ * is untouched.
+ *
+ * Semantics:
+ * - `na` (NaN) in either operand propagates → NaN.
+ * - Division by zero follows the same rule as native `/`: `Math.trunc` preserves
+ *   `1 / 0 → Infinity` and `0 / 0 → NaN`, matching PineTS's existing div-by-zero
+ *   behavior (truncation only changes finite results).
+ * - Non-numeric operands fall back to native `/` (defensive; should not occur
+ *   given the compile-time int guard).
+ */
+export declare function __idiv(context: any): (a: any, b: any) => number;

package/dist/types/namespaces/math/methods/__intDiv.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Pine Script integer division (`int / int → int`).
+ *
+ * TradingView truncates the quotient toward zero when BOTH operands are of
+ * type `int` (Java semantics: `11 / 2 == 5`, `-7 / 2 == -3`). Plain JS `/`
+ * always yields a float, which breaks idioms like `pivots(high, depth / 2)`
+ * where the result feeds a series history offset.
+ *
+ * The pine2js codegen emits this helper only when both operands are
+ * statically provable ints (declared `int` vars/params, int literals,
+ * `input.int`, int-result expressions). Anything unprovable keeps plain `/`.
+ *
+ * - `na` in either operand propagates (`NaN`).
+ * - Division by zero returns `na` (`NaN`) instead of JS `Infinity`.
+ */
+export declare function __intDiv(context: any): (a: any, b: any) => number;

package/dist/types/tickerModifier.d.ts

@@ -0,0 +1,9 @@
+/** Split `"SYM;modifier"` into its parts. Plain symbols yield `modifier: null`. */
+export declare function splitTickerModifier(tickerId: string): {
+    symbol: string;
+    modifier: string | null;
+};
+/** The plain symbol with any chart-type modifier removed. */
+export declare function stripTickerModifier(tickerId: string): string;
+/** Append a chart-type modifier (replacing any existing one; idempotent). */
+export declare function withTickerModifier(tickerId: string, modifier: string): string;

package/dist/types/transpiler/analysis/TypeInferencePass.d.ts

@@ -0,0 +1,2 @@
+import ScopeManager from './ScopeManager';
+export declare function runTypeInferencePass(ast: any, _scopeManager: ScopeManager): void;

package/dist/types/transpiler/pineToJS/lexer.d.ts

@@ -35,5 +35,5 @@ export declare class Lexer {
     isIdentifierStart(ch: any): boolean;
     isIdentifierChar(ch: any): boolean;
     getCurrentIndent(): number;
-    addToken(type: any, value: any, indent?: any): void;
+    addToken(type: any, value: any, indent?: any, raw?: any): void;
 }

package/dist/types/transpiler/pineToJS/tokens.d.ts

@@ -29,5 +29,6 @@ export declare class Token {
     line: number;
     column: number;
     indent: number;
-    constructor(type: string, value: any, line: number, column: number, indent?: number);
+    raw: string;
+    constructor(type: string, value: any, line: number, column: number, indent?: number, raw?: string);
 }

package/dist/types/transpiler/utils/ASTFactory.d.ts

@@ -21,6 +21,7 @@ export declare const ASTFactory: {
     createMathEqCall(left: any, right: any): any;
     createMathNeqCall(left: any, right: any): any;
     createMathCompareCall(method: string, left: any, right: any): any;
+    createMathIntDivCall(left: any, right: any): any;
     createWrapperFunction(body: any): any;
     createVariableDeclaration(name: string, init: any): any;
     createAwaitExpression(argument: any): any;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "pinets",
-    "version": "0.9.27",
+    "version": "0.9.29",
     "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",