openpinescript 0.0.0-stage → 0.1.1

package/dist/types/runtime/v1/stdlib/request.d.ts

@@ -0,0 +1,207 @@
+/**
+ * Non-price data requests — `request.financial`, `.dividends`, `.splits`,
+ * `.earnings`, `.quandl`. v5.
+ *
+ * `request.security` is NOT here: it is v5's spelling of `security()`, aliased
+ * to the same implementation in ./renames5.ts, because the two are one function
+ * under two names.
+ *
+ * ── Where the data comes from ───────────────────────────────────────────────
+ *
+ * Nowhere this engine can reach. Every function below asks TradingView for a
+ * series it does not compute — a company's quarterly revenue, a dividend
+ * record, a Nasdaq Data Link table — and there is no such source here.
+ *
+ * So the HOST supplies it, exactly as it supplies higher-timeframe candles for
+ * `security()`: `Context.provideRequestData(kind, key, samples)`. An
+ * unsupplied request is REFUSED rather than answered with `na`.
+ *
+ * That refusal is the whole point of this file. These names were absent
+ * before, and `request` is a namespace that DOES exist (it has `security` in
+ * it), so `request.financial(…)` read as `undefined` and the script ran to
+ * completion with a silently empty series. The emitter's namespace check
+ * deliberately does not assert registry completeness — failing an incomplete
+ * stdlib as a user error would be worse — so nothing else could catch it.
+ *
+ * ── Why the values are sparse ───────────────────────────────────────────────
+ *
+ * None of these is a per-bar series. A dividend happens on one day and the
+ * value stands until the next one; a quarterly figure is published once and
+ * stands for the quarter. So a request is stored as timestamped SAMPLES and
+ * read as a step function: the most recent sample at or before the current bar,
+ * and `na` before the first one.
+ */
+import { Context } from "../context.js";
+/**
+ * The key a request is stored under.
+ *
+ * Built from every argument that selects a different SERIES, so two requests
+ * that differ in any of them cannot read each other's data.
+ */
+export declare function requestKey(parts: readonly any[]): string;
+/**
+ * `request.financial(symbol, financial_id, period, gaps)`.
+ * @returns {series float} The reported figure, held until the next report.
+ */
+export declare const request: {
+    financial: (ctx: Context, symbol: any, financial_id: any, period: any, gaps?: any, ignore_invalid_symbol?: any, currency?: any) => number;
+    /** `request.dividends(ticker, field, …)` — field defaults to gross dividends. */
+    dividends: (ctx: Context, ticker: any, field?: any, ..._rest: any[]) => number;
+    splits: (ctx: Context, ticker: any, field?: any, ..._rest: any[]) => number;
+    earnings: (ctx: Context, ticker: any, field?: any, ..._rest: any[]) => number;
+    /**
+     * `request.security_lower_tf(symbol, timeframe, expression,
+     * ignore_invalid_symbol, currency, ignore_invalid_timeframe,
+     * calc_bars_count)` — Sept 2023.
+     *
+     * Evaluates `expression` on EVERY intrabar of the chart bar and returns them
+     * all, as an array — or, when the expression is a tuple, as a tuple of arrays.
+     * That is what makes it different from `request.security`, which returns one
+     * value: a chart bar contains many lower-timeframe bars, and this hands back
+     * all of them so a script can sum, count or measure within the bar.
+     *
+     * The intrabars of a chart bar are the lower-timeframe bars that open
+     * inside it, from its open to its close. The expression is evaluated on
+     * every lower-timeframe bar in order, in one sub-context per call site, so
+     * a `ta.*` call inside it warms up on the lower timeframe's own history.
+     *
+     * ── With no intrabar data, the answer is EMPTY, not approximate ─────────────
+     *
+     * This engine is fed one series of OHLCV bars. It has no finer data and cannot
+     * fetch any, so unless a host supplies the lower timeframe there are no
+     * intrabars to report — and an empty array says exactly that. The alternative,
+     * returning the chart bar as its own single intrabar, would make
+     * `array.size(...)` report 1 where TradingView reports 12, and every average
+     * computed from it would be quietly wrong rather than visibly absent.
+     *
+     * `security` answers `na` in the same situation for the same reason, and asks
+     * the session layer for the data the same way.
+     *
+     * ── The three arguments ─────────────────────────────────────────────────────
+     *
+     * ignore_invalid_timeframe: "Determines the behavior of the function when
+     *   the chart's timeframe is smaller than the timeframe used in the function
+     *   call. If false, the script will halt and throw a runtime error. If true,
+     *   the function will return na and execution will continue."
+     *
+     * ignore_invalid_symbol: "If false, the script will halt and throw a runtime
+     *   error [when the symbol is not found]. If true, the function will return
+     *   na and execution will continue." This engine cannot tell a symbol that
+     *   does not exist from data the host has not supplied, and the second is
+     *   not an error: the request is recorded for the host and the answer is the
+     *   empty one above, whichever way the argument is set. It is accepted so it
+     *   is not reported as dropped.
+     *
+     * calc_bars_count: accepted, with no observable effect: TradingView's log
+     *   (conformance/v5/parity/harness_security_cbc) shows a call with
+     *   calc_bars_count = 200 equal to the call without it on every bar.
+     */
+    security_lower_tf: (ctx: Context, symbol: any, timeframe: any, expression: () => any, ignore_invalid_symbol?: any, currency?: any, ignore_invalid_timeframe?: any, calc_bars_count?: any) => any;
+    /**
+     * `request.quandl(ticker, gaps, index)` — Nasdaq Data Link.
+     *
+     * TradingView removed this in 2023 and it remains in the v5 reference as
+     * deprecated. Kept so a published script still compiles, and refused at run
+     * time like the rest unless the host supplies the table.
+     */
+    quandl: (ctx: Context, ticker: any, _gaps: any, index?: any) => number;
+    /**
+     * `request.currency_rate(from, to)` — the daily conversion rate.
+     *
+     * "Provides a daily rate that can be used to convert a value expressed in
+     *  the `from` currency to another in the `to` currency."
+     *
+     * Identical currencies convert at 1 without needing any data, which is not
+     * a special case so much as the definition — and it is the common one, since
+     * `request.currency_rate(syminfo.currency, strategy.account_currency)` is
+     * how a strategy asks whether conversion is needed at all.
+     *
+     * Anything else is host-supplied like the rest of this namespace: an
+     * exchange rate is a fact about the world on a date, and guessing one would
+     * misstate every position size computed from it.
+     */
+    currency_rate: (ctx: Context, from: any, to: any) => number;
+    /**
+     * `request.economic(country_code, field, gaps)` — a macroeconomic series.
+     *
+     * "GDPQQ", "UNRATE", "CPIYY" and the rest, keyed by country. Host-supplied
+     * like every other member of this namespace: there is no data here to fetch
+     * it from, and inventing a plausible unemployment rate would be worse than
+     * refusing to.
+     */
+    economic: (ctx: Context, country_code: any, field: any, _gaps?: any) => number;
+    /**
+     * `request.seed(source, symbol, expression, …)` — September 2023.
+     *
+     * "Requests data from a user-maintained GitHub repository and returns it as
+     *  a series."
+     *
+     * The repository is `source` and the file is `symbol`. Nothing about it is
+     * reachable from here, so it resolves through the same host-supplied table
+     * as the rest — which is the honest shape for a function whose entire job
+     * is to fetch something this engine cannot reach.
+     */
+    seed: (ctx: Context, source: any, symbol: any, _expression?: any, ..._rest: any[]) => number;
+};
+/** Which dividend figure `request.dividends` returns. */
+export declare const dividends: {
+    gross: string;
+    net: string;
+    /**
+     * The NEXT dividend: "na if the data is not available". This engine has
+     * no corporate calendar, so it always is.
+     * @getter
+     */
+    future_amount: (_ctx: Context) => number;
+    /** @getter */
+    future_ex_date: (_ctx: Context) => number;
+    /** @getter */
+    future_pay_date: (_ctx: Context) => number;
+};
+/** Which half of the split ratio `request.splits` returns. */
+export declare const splits: {
+    numerator: string;
+    denominator: string;
+};
+/** Which earnings figure `request.earnings` returns. */
+export declare const earnings: {
+    actual: string;
+    estimate: string;
+    standardized: string;
+    /** The NEXT report, `na` without a corporate calendar. @getter */
+    future_time: (_ctx: Context) => number;
+    /** @getter */
+    future_eps: (_ctx: Context) => number;
+    /** @getter */
+    future_revenue: (_ctx: Context) => number;
+    /** @getter */
+    future_period_end_time: (_ctx: Context) => number;
+};
+/**
+ * Whether a futures ticker id's history is back-adjusted, and whether its
+ * daily close is the settlement price — `ticker.new` / `ticker.modify`
+ * arguments (v5, 2024). Carried like `adjustment`: one price series runs here.
+ */
+export declare const backadjustment: {
+    inherit: string;
+    on: string;
+    off: string;
+};
+export declare const settlement_as_close: {
+    inherit: string;
+    on: string;
+    off: string;
+};
+/**
+ * Which corporate actions a ticker id's prices are adjusted for.
+ *
+ * Passed to `ticker.new` / `ticker.modify`. This engine runs one price series —
+ * the bars it was handed — so the adjustment cannot change any number here; it
+ * is carried so that a script naming it compiles and runs, and so a host that
+ * does keep adjusted and unadjusted feeds can read it off the ticker id.
+ */
+export declare const adjustment: {
+    none: string;
+    splits: string;
+    dividends: string;
+};

package/dist/types/runtime/v1/stdlib/scale.d.ts

@@ -0,0 +1,19 @@
+/**
+ * scale.* — which price scale a study/strategy is drawn against.
+ *
+ * Passed to the `scale` argument of study()/strategy():
+ *
+ *     strategy("Pre Meditated", scale=scale.right, overlay=true)
+ *
+ * Purely declarative: it affects chart presentation, not any computed series.
+ * The values are carried through to the script's declared metadata so a host
+ * renderer can honour them; the engine itself only needs them to EXIST, because
+ * a missing constant is a hard "opsv2_scale is not defined" at runtime.
+ */
+export declare const __IS_NAMESPACE__ = true;
+/** Draw against the right-hand price scale (the default for overlays). */
+export declare const right = "scale.right";
+/** Draw against the left-hand price scale. */
+export declare const left = "scale.left";
+/** Do not attach to a price scale — the script provides its own range. */
+export declare const none = "scale.none";

package/dist/types/runtime/v1/stdlib/session.d.ts

@@ -0,0 +1,113 @@
+/**
+ * `session.*` — which trading session a bar belongs to, and where in it.
+ *
+ * Two constants and six per-bar booleans, quoted from the manual's Sessions
+ * page:
+ *
+ *   session.regular   "Represents the regular trading session."
+ *   session.extended  "Represents the extended trading session."
+ *
+ *   session.ismarket        "Is true when the bar belongs to regular trading
+ *                            hours. On '1D' and above timeframes, this variable
+ *                            is always true."
+ *   session.ispremarket     "Is true when the bar belongs to the extended
+ *                            session preceding regular trading hours."
+ *   session.ispostmarket    "Is true when the bar belongs to the extended
+ *                            session following regular trading hours."
+ *   session.isfirstbar      "Is true if the current bar is the first bar of the
+ *                            day's session, and false otherwise."
+ *   session.islastbar       "Is true if the current bar is the last bar of the
+ *                            day's session, and false otherwise."
+ *   session.isfirstbar_regular  "Is true on the first regular session bar of
+ *                            the day, false otherwise."
+ *   session.islastbar_regular   "Is true on the last regular session bar of the
+ *                            day, false otherwise."
+ *
+ * ── What this engine can and cannot know ────────────────────────────────────
+ *
+ * A session is a property of the EXCHANGE, and this engine is handed bars and
+ * nothing else — no symbol metadata, no session hours, no holiday calendar. So
+ * the extended-hours questions cannot be answered from the data, and the answer
+ * given is the one that matches the data actually supplied:
+ *
+ *   ismarket      always true
+ *   ispremarket   always false
+ *   ispostmarket  always false
+ *
+ * which is EXACTLY right for a regular-hours dataset — the ordinary OHLCV feed
+ * — and wrong for one that includes extended bars. It is stated here rather
+ * than hidden because a script gating entries on `not session.ispremarket`
+ * would take every bar under this engine and skip some on TradingView.
+ *
+ * Because of that, `isfirstbar_regular` and `islastbar_regular` are the same
+ * facts as `isfirstbar` and `islastbar`: with no extended bars in the dataset,
+ * the first bar of the day IS the first regular bar. They are separate entries
+ * anyway, so the day a host supplies extended bars there is one place to fix.
+ *
+ * ── Day boundaries ──────────────────────────────────────────────────────────
+ *
+ * `opensDay` in ../sessions.ts owns where a day starts, and its header states
+ * the convention. It is shared with `ta.vwap`, which restarts its accumulation
+ * on the same boundary — the two must not drift apart.
+ *
+ * v5-only: the registry split in ./index.ts keeps the namespace out of the
+ * v1–v4 views.
+ */
+import { Context } from "../context.js";
+export declare const session: {
+    /** The regular trading session. */
+    regular: string;
+    /** The extended trading session. */
+    extended: string;
+    /**
+     * True when the bar belongs to regular trading hours.
+     * @getter
+     */
+    ismarket: (_ctx: Context) => boolean;
+    /**
+     * True when the bar belongs to the extended session BEFORE regular hours.
+     * @getter
+     */
+    ispremarket: (_ctx: Context) => boolean;
+    /**
+     * True when the bar belongs to the extended session AFTER regular hours.
+     * @getter
+     */
+    ispostmarket: (_ctx: Context) => boolean;
+    /**
+     * True on the first bar of the day's session.
+     * @getter
+     */
+    isfirstbar: (ctx: Context) => boolean;
+    /**
+     * True on the first REGULAR-session bar of the day.
+     * @getter
+     */
+    isfirstbar_regular: (ctx: Context) => boolean;
+    /**
+     * True on the last bar of the day's session.
+     *
+     * ── Answerable on daily and above; not answerable intraday ──────────────
+     *
+     * On "1D" and higher, one bar IS one session, so every bar is its session's
+     * last — that is a fact about the timeframe, not a guess, and it is what
+     * this returns.
+     *
+     * Intraday it is unanswerable here. The last bar of a day is the bar whose
+     * SUCCESSOR opens a new one, and the successor has not arrived: this engine
+     * is fed one bar at a time, and looking ahead is exactly the thing it must
+     * not do. So intraday gets `false`, always.
+     *
+     * That is a stated gap rather than an approximation. A script closing
+     * positions on `session.islastbar` will simply never fire intraday under
+     * this engine, which is visible, instead of firing on the wrong bar, which
+     * is not.
+     * @getter
+     */
+    islastbar: (ctx: Context) => boolean;
+    /**
+     * True on the last REGULAR-session bar of the day. See `islastbar`.
+     * @getter
+     */
+    islastbar_regular: (ctx: Context) => boolean;
+};

package/dist/types/runtime/v1/stdlib/sort_field.d.ts

@@ -0,0 +1,12 @@
+import type { Context } from "../context.js";
+/** Is `x` an instance of a user-defined type? Such objects carry `__type`. */
+export declare function isObject(x: any): boolean;
+/** The value a UDT element sorts by, or the element itself when it is not one. */
+export declare function sortKey(item: any, sortField: any): any;
+/** Ascending comparison of two keys: strings by code point, numbers numerically. */
+export declare function compareKeys(a: any, b: any): number;
+/**
+ * Whether this call sorts by field. Only at v6 — at v5 a UDT array was never
+ * sortable here, and turning it into one would change what v5 does.
+ */
+export declare function byField(ctx: Context | undefined, items: any[]): boolean;

package/dist/types/runtime/v1/stdlib/sources.d.ts

@@ -0,0 +1,24 @@
+import { Context } from "../context.js";
+/**
+ * Derived price sources. Pine spells these as bare globals that recompute each
+ * bar, so they are getters rather than values.
+ */
+/** (high + low) / 2 @getter */
+export declare function hl2(ctx: Context): number;
+/** (high + low + close) / 3 @getter */
+export declare function hlc3(ctx: Context): number;
+/** (open + high + low + close) / 4 @getter */
+export declare function ohlc4(ctx: Context): number;
+/**
+ * `hlcc4` — (high + low + close + close) / 4.
+ *
+ * Added alongside `last_bar_index` and `last_bar_time` in the same v5 release:
+ * "New built-in source variable: hlcc4 - A shortcut for (high + low + close +
+ * close)/4. It averages the high and low values with the double-weighted
+ * close." Gated to v5 with the rest of that batch.
+ *
+ * Source: https://www.tradingview.com/pine-script-docs/v5/release-notes/
+ * @getter
+ * @returns {series float} The double-weighted close average.
+ */
+export declare function hlcc4(ctx: Context): number;

package/dist/types/runtime/v1/stdlib/str.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Pine Script strings — the `str.*` namespace.
+ *
+ * v5 moved string handling into its own namespace: `tostring(x)` became
+ * `str.tostring(value, format)` and `tonumber(x)` became `str.tonumber(string)`
+ * (docs/common/VERSIONS.md §4a). The rest of the namespace —
+ * `str.format`, `str.length`, `str.split` and friends — has no v1–v4 spelling
+ * at all and exists only here.
+ *
+ * v5-only, which this file does NOT enforce: the registry split in ./index.ts
+ * keeps the whole namespace out of the v1–v4 views, so a v4 script naming
+ * `str.length` is refused there rather than by a check in every function.
+ *
+ * ── The number FORMAT is the load-bearing part ──────────────────────────────
+ *
+ * `str.tostring(value, format)` is how the golden-data harnesses get numbers
+ * out of TradingView (see scripts/common/make-log-harness.ts): every column is emitted
+ * as `str.tostring(v, "#.##########")`. If this formatter disagrees with
+ * TradingView's, every golden comparison is measuring the formatter rather than
+ * the indicator — so the digit rules below are implemented literally from
+ * Pine's format-string grammar rather than approximated with toFixed.
+ *
+ *   '#'  an OPTIONAL digit — printed only when non-zero material remains
+ *   '0'  a REQUIRED digit  — always printed, padded if necessary
+ *
+ * so "#.##" is up to two decimals with trailing zeros trimmed, "0.00" is
+ * exactly two, and "#" is an integer. That trimming is why the harnesses can
+ * ask for ten decimals without every row carrying ten characters of padding.
+ */
+import { Context } from "../context.js";
+export declare const str: {
+    /**
+     * `str.tostring(value, format)` — v5's spelling of v1–v4's `tostring(x)`.
+     *
+     * The second argument is new in this spelling. The v1–v4 flat `tostring`
+     * keeps its own one-argument implementation in ./core.ts — `str.tostring`
+     * is a rename for DIAGNOSTIC purposes only, and ./index.ts is careful not
+     * to let the rename table overwrite this entry with it.
+     *
+     * ── The format is EITHER a format string or a `format.*` constant ────────
+     *
+     * "use str.tostring(myValue, format.mintick) to first round the number to
+     *  tick precision and then return its string representation."
+     *
+     * `format.mintick` needs the instrument's tick size, which is why this is
+     * the one `str.*` member that takes a Context. The other `format.*`
+     * constants describe how a value appears on the PRICE AXIS and in the Data
+     * Window — neither of which exists here — so they are recognised and then
+     * render the value plainly, rather than being fed to the number-format
+     * parser, where "format.volume" would be read as a mask with no digit
+     * placeholders and produce an empty string.
+     */
+    tostring: (ctx: Context, value: any, format?: any) => string;
+    /** `str.tonumber(string)` — na (NaN) when the string is not a number. */
+    tonumber: (string: any) => number;
+    /** `str.format(formatString, arg0, arg1, …)`. */
+    format: (formatString: any, ...args: any[]) => string;
+    length: (string: any) => number;
+    contains: (source: any, str: any) => boolean;
+    startswith: (source: any, str: any) => boolean;
+    endswith: (source: any, str: any) => boolean;
+    /** Index of the first occurrence, or na — Pine returns na, not -1. */
+    pos: (source: any, str: any) => number;
+    /**
+     * `str.substring(source, begin_pos, end_pos)`.
+     *
+     * `end_pos` is EXCLUSIVE and optional; omitting it runs to the end.
+     */
+    substring: (source: any, begin_pos: any, end_pos?: any) => string;
+    replace_all: (source: any, target: any, replacement: any) => string;
+    /**
+     * `str.replace(source, target, replacement, occurrence)` — ONE occurrence.
+     *
+     * The sibling of `replace_all`, and the difference is the fourth argument:
+     * `occurrence` is a zero-based index selecting WHICH match to replace, and
+     * defaults to 0 — the first. An index past the last match leaves the string
+     * alone, which is the same answer as "there was nothing to replace".
+     */
+    replace: (source: any, target: any, replacement: any, occurrence?: any) => string;
+    /** `str.trim(string)` — leading and trailing whitespace removed. */
+    trim: (string: any) => string;
+    /**
+     * `str.format_time(time, format, timezone)` — October 2022.
+     *
+     * "Converts a timestamp to a formatted string using the specified format
+     *  and time zone."
+     *
+     * The format is a Java `SimpleDateFormat` pattern, which is what
+     * TradingView's own examples pass — "yyyy-MM-dd", "HH:mm:ss",
+     * "yyyy-MM-dd'T'HH:mm:ss". The subset implemented is the one those patterns
+     * use, and an unrecognised letter run is left as written rather than
+     * silently dropped: a pattern this engine does not understand should be
+     * visible in the output, not invisible.
+     *
+     * Quoted runs are literal — `'T'` is the letter T and not a year field —
+     * because a date-time pattern without that rule cannot express ISO 8601,
+     * which is the commonest thing anyone formats.
+     */
+    format_time: (ctx: Context, time: any, format?: any, timezone?: any) => string;
+    upper: (source: any) => string;
+    lower: (source: any) => string;
+    /** `str.split(string, separator)` — returns a Pine array of strings. */
+    split: (string: any, separator: any) => string[];
+    /** `str.repeat(string, repeat, separator)`. */
+    repeat: (string: any, repeat: any, separator?: any) => string;
+    /**
+     * `str.match(source, regex)` — the first match, or an empty string.
+     *
+     * Pine documents this as a RE2 regular expression. JavaScript's engine is
+     * not RE2, and the two disagree on backreferences and lookaround, which RE2
+     * does not support at all. Patterns that stay inside the common subset
+     * behave identically; anything relying on a JavaScript-only construct will
+     * work here and fail on TradingView, which is the safe direction for a
+     * feature no harness exercises.
+     */
+    match: (source: any, regex: any) => string;
+};