openpinescript 0.0.0-stage → 0.1.0

package/dist/types/transpiler/v6/ToJsVisitor.d.ts

@@ -0,0 +1,237 @@
+/**
+ * Pine Script v6 → JavaScript emitter.
+ *
+ * v6 inherits every line of emit logic from v5 (and so from v1 through v4).
+ * This file contains only what TradingView's v6 migration guide and release
+ * notes document as different.
+ *
+ * ── Why so much of v6 lands here ───────────────────────────────────────────
+ *
+ * "Breaking changes" is TradingView's term for USER SCRIPTS moving v5 to v6.
+ * Sorted by where each of the 25 actually lands in this engine, 11 are emit
+ * decisions — a different JavaScript expression, or a new compile error over a
+ * tree that parses fine. 9 are registry or profile DATA. 5 are run-time, and
+ * all 5 are a flag or a broker override rather than a second runtime.
+ *
+ * So this file is where v6 mostly lives, exactly as transpiler/v5 is where v5
+ * mostly lives. Nothing in v1–v5 is touched to add any of it: a v5 script
+ * reaches V5ToJsVisitor and emits what it always did.
+ */
+import type { PineVersion } from "../common/version.js";
+import { V5ToJsVisitor, V5Options } from "../v5/ToJsVisitor.js";
+import type { StdlibEntry } from "../../runtime/v1/stdlib/metadata.js";
+import { Once_exprContext } from "../../parser/v6/generated/PineV6Parser.js";
+export interface V6Options extends V5Options {
+}
+/** Anything carrying a source position (see the v1 base for why it is structural). */
+interface SourceLocated {
+    start?: {
+        line: number;
+        column: number;
+    } | null;
+}
+/**
+ * A triple-quoted literal's text, as a JavaScript string literal.
+ *
+ * Quoted, from the release notes (April 2026):
+ *
+ *   "All code between the """ or ''' delimiters in a multiline string
+ *    definition represents literal text."
+ *   "Each code line between the delimiters defines a separate text line"
+ *   "multiline strings automatically include all spaces used for indentation"
+ *
+ * So newlines are KEPT, and so is every leading space — unlike the inherited
+ * `unwrapString`, which collapses a wrapped ordinary string onto one line.
+ * Stripping a common indent, the way some languages do, would be the wrong
+ * guess: the notes' own example says "any indentation in the definition is
+ * still included literally in the string".
+ *
+ * Escapes keep their ordinary meaning (`\t`, `\\`, `\"`), which is why a
+ * backslash and the character after it are copied as a pair. Everything else
+ * is re-escaped for JavaScript: a raw newline becomes `\n`, and a bare `"`
+ * — legal inside `'''…'''` — becomes `\"`.
+ */
+export declare function unwrapMultilineString(text: string): string;
+export declare class V6ToJsVisitor extends V5ToJsVisitor {
+    protected readonly version: PineVersion;
+    constructor(options?: V6Options);
+    /**
+     * MG §"Fractional division of constants": "Non-even int division always
+     * returns a fraction (5/2 = 2.5) for all qualifiers." v5 truncated two
+     * constant ints; v6 does not.
+     */
+    protected truncatesConstIntDivision(): boolean;
+    /** v6's view of the stdlib. See V6_VIEW for what differs from v5's. */
+    protected get registry(): Record<string, StdlibEntry>;
+    /**
+     * A library is read by the grammar of the version IT declares.
+     *
+     * A v6 script may import a v5 library, and the two grammars disagree: v5
+     * lets a library bind a variable called `once`, v6 does not. Parsing every
+     * library as v6 would reject published v5 libraries for using a word that
+     * was legal when they were written.
+     */
+    protected parseLibrary(source: string): {
+        parsed: ReturnType<typeof import("../../parser/v5/index.js").parse>;
+        version: PineVersion;
+    };
+    protected createLibraryVisitor(version: PineVersion, options: V5Options): V5ToJsVisitor;
+    /** The types a library constant may have. Release notes, June 2025. */
+    private static readonly CONSTANT_TYPES;
+    /** Names this library exports as constants. */
+    protected exportedConstants: Set<string>;
+    /** alias → the constants that library exports, so `alias.NAME` resolves. */
+    protected libraryConstants: Map<string, Set<string>>;
+    /** The visitor of the library compiled most recently — see compileLibrary. */
+    private lastLibraryVisitor;
+    /**
+     * `export const <type> <NAME> = <value>` — the only form the release notes
+     * allow: the `const` qualifier, and one of five types. Anything else is a
+     * variable a library cannot export, and is refused here by name.
+     */
+    visitExport_stmt(ctx: any): string;
+    protected exportedMemberJs(name: string, types: ReadonlyMap<string, unknown>, enums: ReadonlyMap<string, unknown>): string;
+    protected compileLibrary(path: string, alias: string, source: string, ctx: SourceLocated): {
+        js: string;
+        exports: Set<string>;
+        types: Map<string, string[]>;
+        methods: Set<string>;
+        members: string[];
+        enums: Map<string, string[]>;
+    };
+    /** `alias.NAME` — a constant an imported library exports. */
+    protected emitFieldChain(text: string): string | null;
+    visitOther_literal(ctx: any): string;
+    protected visitContent(ctx: any): string;
+    /**
+     * `once [<condition>]` — run the block the first time the condition holds,
+     * and never again.
+     *
+     * Lowered onto `var`, because that is precisely the state the manual
+     * describes. From the Conditional structures page:
+     *
+     *   - on historical bars the block runs once, the first time the condition
+     *     is true, and never again;
+     *   - on the realtime bar the structure's state is ROLLED BACK between ticks,
+     *     so the block can run on several ticks of one bar, and the structure
+     *     only goes inactive when the block runs on the bar's closing tick.
+     *
+     * A `var` flag is committed on a confirmed bar and rolled back on an
+     * unconfirmed tick — which is that behaviour exactly, with no new runtime
+     * mechanism. `varip` would be wrong: it survives rollback, and would stop
+     * the block after the first realtime tick.
+     *
+     * The flag is keyed by the structure's SOURCE LOCATION through
+     * `seriesKey`, so two `once` blocks never share it, and one inside a user
+     * function gets the same per-call-site storage a `var` there gets. The
+     * manual does not say whether a `once` in a function fires once per call
+     * site or once overall; following `var` is the reading consistent with the
+     * rest of the language, and it is stated here because it is an assumption.
+     *
+     * Emitted as a plain `if`, never an IIFE: `once` is a statement with no
+     * value (the manual makes assigning one a compile error), and a plain block
+     * is what lets `break` and `continue` inside it reach an enclosing loop.
+     */
+    visitOnce_expr(ctx: Once_exprContext): string;
+    /** The value of a block's last statement, or null. */
+    protected blockTail(block: any): any | null;
+    /** The value an arm of a switch ends with, or null. */
+    protected caseTail(arm: any): any | null;
+    /**
+     * MG §"Explicit bool casting": "int and float values are no longer
+     * implicitly cast to bool". A numeric value where a condition is required
+     * is a compile error; the fix the guide gives is `bool(x)`.
+     */
+    protected enforceBoolCondition(node: any, where?: SourceLocated): void;
+    visitIf_expr(ctx: any): string;
+    visitTernary_expr(ctx: any): string;
+    visitUnary_expr(ctx: any): string;
+    visitWhile_expr(ctx: any): string;
+    /**
+     * MG §"Lazy evaluation of conditions": "evaluation stops once the result is
+     * determined". v5 evaluated every operand (see the long note on
+     * `visitOr_expr` in the v1 base for why, and the golden export that proved
+     * it); v6 short-circuits, so a `ta.*` call on the right of an `and` really
+     * is skipped on bars where the left is false — the guide's own warning, and
+     * TradingView's behaviour, which this engine must reproduce surprise and all.
+     *
+     * The guide also names the payoff: `arr.size() != 0 and arr.first()` no
+     * longer reads an empty array.
+     */
+    visitOr_expr(ctx: any): string;
+    visitAnd_expr(ctx: any): string;
+    /**
+     * MG §"Boolean values cannot be na": "In if/switch expressions returning
+     * bool, a missing branch yields false instead of na."
+     *
+     * Decided from the FIRST branch's value, which is the type the structure
+     * has: Pine requires every branch to agree, and disagreeing is a separate
+     * compile error on TradingView.
+     */
+    protected ifFallthrough(ctx: any): string;
+    protected switchFallthrough(ctx: any): string;
+    /**
+     * MG §"Unique parameters cannot be na": "switch needs a default branch, and
+     * if needs an else branch, when the result is a unique type" — because the
+     * missing branch would be `na`, which a unique type can no longer hold.
+     *
+     * Only in VALUE position. A statement-`if` produces nothing, so its missing
+     * branch produces no `na` either.
+     */
+    protected enforceUniqueIfHasElse(ctx: any): void;
+    visitSwitch_expr(ctx: any): string;
+    /** Is this switch a statement whose value is discarded? */
+    protected isStatementSwitch(ctx: any): boolean;
+    /**
+     * MG §"Boolean values cannot be na": "Declaring a bool with na as its
+     * default is invalid."
+     */
+    visitVar_def(ctx: any): string;
+    /**
+     * MG §"History-referencing operator":
+     *
+     *   - "[] on a literal or constant is a compile error"
+     *   - "obj.field[10] is invalid. Use (obj[10]).field"
+     */
+    visitSqbr_expr(ctx: any): string;
+    /**
+     * MG §"Dynamic for loop boundaries": "The to_num expression ... is
+     * re-evaluated before every iteration." v5 read it once.
+     *
+     * The same loop as the v1 base in every other respect — start value, step
+     * magnitude and DIRECTION are still fixed when the loop starts — with the
+     * bound moved into a thunk that is called once before the first iteration
+     * and again after each one. Calling it in the loop CONDITION instead would
+     * evaluate it twice before the first pass, and a bound with a side effect —
+     * the guide's own example appends to an array — would see that.
+     */
+    visitFor_expr(ctx: any): string;
+    /**
+     * True when the declaration says `dynamic_requests = false`.
+     *
+     * MG §"Dynamic requests": v6 defaults it to true, so `request.*()` may run
+     * in loops and conditional blocks. Turned off EXPLICITLY, "calling
+     * request.*() inside loop or conditional scopes, even through a wrapper
+     * function, is a compile error". This engine never restricted request scope
+     * at v5 either, so the default case needs nothing; only the opt-out does.
+     */
+    protected dynamicRequestsOff: boolean;
+    /**
+     * User functions that issue a request, directly or through another user
+     * function — the "wrapper function" of the rule.
+     */
+    protected requestingFunctions: Set<string>;
+    visitPine_script(ctx: any): string;
+    protected enforceStaticRequestScope(ctx: any, callee: string): void;
+    visitFun_call(ctx: any): string;
+    /** The keyword arguments of a call, in order. */
+    protected kwArgs(ctx: any): Array<{
+        name: string;
+        value: any;
+        node: any;
+    }>;
+    /** The positional arguments of a call, in order. */
+    protected posArgs(ctx: any): any[];
+    protected enforceV6CallRules(ctx: any): void;
+}
+export {};

package/dist/types/transpiler/v6/rules.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Static facts the v6 emitter needs about an expression, and the tables of
+ * names the migration guide's rules apply to.
+ *
+ * ── The rule every predicate here follows ──────────────────────────────────
+ *
+ * Each answers "PROVABLY", never "probably". These feed compile errors, and
+ * the two ways to be wrong are not symmetric: a missed case compiles a script
+ * TradingView would have rejected — the status quo at v5 — while a false
+ * positive rejects a correct script outright. So a predicate that cannot prove
+ * its answer says no. This is the same contract `isStaticallyBool` in
+ * ../common/passes/ScopeAnalysis.ts states, and the two are meant to be read
+ * together.
+ *
+ * Source for every table: the v6 migration guide,
+ * https://www.tradingview.com/pine-script-docs/migration-guides/to-pine-version-6/
+ */
+import type { ScopeInfo } from "../common/passes/ScopeAnalysis.js";
+/** Duck-typed node access — the generated contexts share no usable base type. */
+export declare function kids(node: any): any[];
+export declare function ruleName(node: any): string;
+export declare function unwrap(node: any): any;
+/** Is `node` provably an int or float value? */
+export declare function isStaticallyNumeric(node: any, scopes: ScopeInfo): boolean;
+/** The type name to put in a diagnostic for a numeric node: int, or float. */
+export declare function numericTypeName(node: any, scopes: ScopeInfo): "int" | "float";
+/** Is `node` a literal value — `6`, `"text"`, `true`, `#FF0000`? */
+export declare function isLiteral(node: any): boolean;
+/** Is `node` the bare identifier `na`? */
+export declare function isNaLiteral(node: any): boolean;
+/**
+ * MG §"Removal of `when` parameter": removed from these seven functions.
+ */
+export declare const WHEN_REMOVED: Set<string>;
+/**
+ * MG §"The `transp` parameter is removed": from these six functions.
+ */
+export declare const TRANSP_REMOVED: Set<string>;
+/** Does `callee`'s parameter `name` take a unique type? Built-ins only. */
+export declare function isUniqueParam(callee: string, name: string): boolean;
+/** Is `node` a bare read of a unique-type constant, like `plot.style_line`? */
+export declare function isUniqueConstant(node: any): boolean;
+/**
+ * Parameters of built-ins that take a "simple" length, where v6 makes passing
+ * a mutable variable a compile error (MG §"Mutable variables are always
+ * series"). The guide's own example is `ta.ema`; each entry below is a
+ * parameter the reference manual types as "simple int". Indices are the
+ * POSITIONAL slot, names the keyword.
+ */
+export declare const SIMPLE_LENGTH_PARAMS: ReadonlyMap<string, ReadonlyArray<[number, string]>>;
+/**
+ * Is `node` provably a "series" value?
+ *
+ * True when it reads a bar-varying built-in, calls a `ta.*` or `request.*`
+ * function, or reads a variable that is reassigned with `:=` — which v6 makes
+ * series unconditionally (MG §"Mutable variables are always series").
+ */
+export declare function isStaticallySeries(node: any, scopes: ScopeInfo): boolean;
+/**
+ * Does `node` read a numeric literal below 1 — `0`, `-5`, `0.5`?
+ *
+ * MG §"Minimum linewidth is 1". Only literals are decided here: a computed
+ * width is a run-time value on TradingView too.
+ */
+export declare function isLiteralBelowOne(node: any): boolean;
+/** Does the declaration pass `dynamic_requests = false`? */
+export declare function declaresStaticRequests(root: any): boolean;
+/**
+ * User functions that reach a `request.*()` call, directly or by calling
+ * another such function. A fixed point over the call graph, because the
+ * wrapper may itself be wrapped.
+ */
+export declare function findRequestingFunctions(root: any): Set<string>;
+/**
+ * Is `node` inside the body of a loop or conditional? Stops at a function
+ * definition: a function's body is its own scope, and whether IT runs
+ * conditionally is decided where it is called.
+ *
+ * "Body", not condition: `if request.security(…) > 0` evaluates the request in
+ * the enclosing scope, so only a request below a block counts.
+ */
+export declare function insideConditionalOrLoop(node: any): boolean;
+/** `dynamic_requests` as the declaration states it: "true", "false", or absent. */
+export declare function dynamicRequestsSetting(root: any): string | null;
+/** The name of the script's declaration call: indicator, strategy or library. */
+export declare function declarationName(root: any): string | null;
+/** Every call name in the script. */
+export declare function allCallNames(root: any): Set<string>;
+export declare function hasIndicatorOutput(root: any): boolean;
+/**
+ * Is `node` PROVABLY a colour: a `color.*` constant, a `color.new/rgb/
+ * from_gradient` result, or a `#hex` literal.
+ */
+export declare function isColorExpression(node: any): boolean;

package/dist/types/utils/v2/common.d.ts

@@ -0,0 +1,4 @@
+export declare const PREFIX = "opsv2_";
+export declare function removePrefix(str: string): string;
+export declare function extractFunctionName(id: string): string;
+export declare function val(x: any): any;

package/package.json

@@ -1,6 +1,94 @@
 {
   "name": "openpinescript",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Run TradingView Pine Script locally and offline. Compiles Pine Script v1-v6 to JavaScript and executes it against your own OHLCV data, with indicator, plotting and strategy backtesting output verified against TradingView itself.",
+  "keywords": [
+    "pine-script",
+    "pinescript",
+    "tradingview",
+    "pine-script-v5",
+    "pine-script-v6",
+    "trading",
+    "backtesting",
+    "backtest",
+    "technical-analysis",
+    "indicators",
+    "transpiler",
+    "compiler",
+    "charting",
+    "algorithmic-trading",
+    "ohlcv",
+    "antlr"
+  ],
+  "homepage": "https://github.com/be-thomas/OpenPineScript#readme",
+  "bugs": {
+    "url": "https://github.com/be-thomas/OpenPineScript/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/be-thomas/OpenPineScript.git"
+  },
+  "license": "GPL-3.0-or-later",
+  "author": "be-thomas",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "bin": {
+    "openpinescript": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "generate:parser": "node scripts/common/build-grammars.mjs && node scripts/common/patch-visitor.cjs",
+    "generate:parser:v1": "node scripts/common/build-grammars.mjs v1",
+    "generate:parser:v2": "node scripts/common/build-grammars.mjs v2",
+    "generate:parser:v3": "node scripts/common/build-grammars.mjs v3",
+    "generate:parser:v4": "node scripts/common/build-grammars.mjs v4",
+    "generate:parser:v5": "node scripts/common/build-grammars.mjs v5",
+    "generate:parser:v6": "node scripts/common/build-grammars.mjs v6",
+    "prebuild": "ts-node scripts/common/generate-metadata.ts",
+    "build": "npm run generate:parser && node scripts/common/build-dist.mjs",
+    "parse": "tsx parser/v2/run_antlr.ts",
+    "replv2": "tsx repl/v2/index.ts",
+    "opsv2": "tsx mock_run/v2/run.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:cov": "vitest run --coverage",
+    "prepare": "npm run generate:parser",
+    "build:dist": "node scripts/common/build-dist.mjs",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "dependencies": {
+    "antlr4ng": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "antlr-ng": "^1.0.0",
+    "esbuild": "^0.27.0",
+    "ts-morph": "^27.0.2",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.21.0",
+    "typescript": "^5.6.0",
+    "vitest": "^4.0.18"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}