pinets 0.9.3 → 0.9.4

package/dist/types/NaProxy.d.ts

@@ -0,0 +1,19 @@
+/**
+ * NaProxy: A proxy object that represents `na` for UDT (User-Defined Type) values.
+ *
+ * In Pine Script, accessing a property on `na` returns `na`, and calling a method on
+ * `na` returns `na`. In JavaScript, NaN doesn't support property access, so we use
+ * this proxy as a stand-in.
+ *
+ * Behavior:
+ * - Any property access returns the proxy itself (chaining: proxy.bx.get_top → proxy)
+ * - Called as a function, returns proxy (proxy() → proxy, for chaining: proxy.method().field)
+ * - valueOf() returns NaN (arithmetic: proxy + 5 → NaN)
+ * - na.any(proxy) → true
+ */
+/** Symbol used to identify NaProxy objects */
+export declare const NA_MARKER: unique symbol;
+/** Singleton NaProxy instance */
+export declare const NA_PROXY: any;
+/** Check if a value is a NaProxy */
+export declare function isNaProxy(val: any): boolean;

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

@@ -13,29 +13,6 @@ export declare class NAHelper {
 }
 export declare class Core {
     private context;
-    color: {
-        param: (source: any, index?: number) => any;
-        rgb: (r: number, g: number, b: number, a?: number) => string;
-        new: (color: any, a?: number) => any;
-        from_gradient: (value: any, bottom_value: any, top_value: any, bottom_color: any, top_color: any) => string;
-        aqua: "#00BCD4";
-        black: "#363A45";
-        blue: "#2196F3";
-        fuchsia: "#E040FB";
-        gray: "#787B86";
-        green: "#4CAF50";
-        lime: "#00E676";
-        maroon: "#880E4F";
-        navy: "#311B92";
-        olive: "#808000";
-        orange: "#FF9800";
-        purple: "#9C27B0";
-        red: "#F23645";
-        silver: "#B2B5BE";
-        teal: "#089981";
-        white: "#FFFFFF";
-        yellow: "#FDD835";
-    };
     constructor(context: any);
     private extractPlotOptions;
     indicator(...args: any[]): any;
@@ -44,6 +21,9 @@ export declare class Core {
     nz(series: any, replacement?: number): any;
     fixnan(series: any): any;
     alertcondition(condition: any, title: any, message: any): void;
+    alert(...args: any[]): void;
+    error(...args: any[]): void;
+    max_bars_back(series?: any, length?: any): void;
     /**
      * Converts date/time components to a UNIX timestamp in milliseconds.
      * Supports multiple signatures:

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

@@ -1,4 +1,5 @@
 import { Context } from '..';
+import { PineArrayObject } from './array/PineArrayObject';
 export declare class Str {
     private context;
     constructor(context: Context);
@@ -17,7 +18,7 @@ export declare class Str {
     pos(source: string, target: string): number;
     length(source: string): number;
     match(source: string, pattern: string): RegExpMatchArray;
-    split(source: string, separator: string): string[][];
+    split(source: string, separator: string): PineArrayObject;
     substring(source: string, begin_pos: number, end_pos: number): string;
     format(message: string, ...args: any[]): string;
 }

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

@@ -1,9 +1,14 @@
 export declare class Timeframe {
     private context;
+    private _normalized;
     constructor(context: any);
     param(source: any, index?: number, name?: string): any;
-    get main_period(): any;
-    get period(): any;
+    /** Normalized canonical timeframe (cached) */
+    private get normalized();
+    /** Last character of the normalized timeframe (uppercase) */
+    private get unit();
+    get main_period(): string;
+    get period(): string;
     get multiplier(): number;
     get isdwm(): boolean;
     get isdaily(): boolean;
@@ -13,5 +18,5 @@ export declare class Timeframe {
     get isminutes(): boolean;
     get isintraday(): boolean;
     from_seconds(seconds: number): string | number;
-    in_seconds(timeframe: string): number;
+    in_seconds(timeframe?: string): number;
 }

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

@@ -151,11 +151,16 @@ export declare enum extend {
     none = "n"
 }
 export declare enum text {
+    align_bottom = "bottom",
+    align_top = "top",
     align_left = "left",
     align_center = "center",
     align_right = "right",
     wrap_auto = "auto",
-    wrap_none = "none"
+    wrap_none = "none",
+    format_bold = "bold",
+    format_italic = "italic",
+    format_none = "none"
 }
 export declare enum font {
     family_default = "default",
@@ -202,6 +207,16 @@ export declare enum position {
     bottom_center = "bottom_center",
     bottom_right = "bottom_right"
 }
+export declare enum scale {
+    left = "left",
+    none = "none",
+    right = "right"
+}
+export declare enum settlement_as_close {
+    inherit = "inherit",
+    off = "off",
+    on = "on"
+}
 declare const types: {
     order: typeof order;
     currency: typeof currency;
@@ -223,5 +238,7 @@ declare const types: {
     dividends: typeof dividends;
     splits: typeof splits;
     position: typeof position;
+    scale: typeof scale;
+    settlement_as_close: typeof settlement_as_close;
 };
 export default types;

package/dist/types/namespaces/array/methods/new_bool.d.ts

@@ -1,2 +1,2 @@
 import { PineArrayObject } from '../PineArrayObject';
-export declare function new_bool(context: any): (size: number, initial_value?: boolean) => PineArrayObject;
+export declare function new_bool(context: any): (size?: number, initial_value?: boolean) => PineArrayObject;

package/dist/types/namespaces/array/methods/new_float.d.ts

@@ -1,3 +1,3 @@
 import { PineArrayObject } from '../PineArrayObject';
 import { Context } from '../../../Context.class';
-export declare function new_float(context: Context): (size: number, initial_value?: number) => PineArrayObject;
+export declare function new_float(context: Context): (size?: number, initial_value?: number) => PineArrayObject;

package/dist/types/namespaces/array/methods/new_int.d.ts

@@ -1,3 +1,3 @@
 import { PineArrayObject } from '../PineArrayObject';
 import { Context } from '../../../Context.class';
-export declare function new_int(context: Context): (size: number, initial_value?: number) => PineArrayObject;
+export declare function new_int(context: Context): (size?: number, initial_value?: number) => PineArrayObject;

package/dist/types/namespaces/array/methods/new_string.d.ts

@@ -1,2 +1,2 @@
 import { PineArrayObject } from '../PineArrayObject';
-export declare function new_string(context: any): (size: number, initial_value?: string) => PineArrayObject;
+export declare function new_string(context: any): (size?: number, initial_value?: string) => PineArrayObject;

package/dist/types/namespaces/color/PineColor.d.ts

@@ -0,0 +1,45 @@
+/**
+ * PineColor implements the Pine Script `color` namespace.
+ *
+ * Supports:
+ * - color(na)                          → type-cast (via any())
+ * - color.new(color, alpha)            → apply transparency
+ * - color.rgb(r, g, b, a?)            → create from components
+ * - color.from_gradient(...)           → interpolate between two colors
+ * - color.r/g/b/t(color)              → extract individual components
+ * - color.red, color.blue, ...        → named constants
+ */
+export declare class PineColor {
+    private context;
+    constructor(context: any);
+    any(value: any): any;
+    param(source: any, index?: number): any;
+    new(color: any, a?: number): any;
+    rgb(r: number, g: number, b: number, a?: number): string;
+    from_gradient(value: any, bottom_value: any, top_value: any, bottom_color: any, top_color: any): any;
+    /** Extract red component (0-255) from a color string. Returns na if unparsable. */
+    r(color: any): number;
+    /** Extract green component (0-255) from a color string. Returns na if unparsable. */
+    g(color: any): number;
+    /** Extract blue component (0-255) from a color string. Returns na if unparsable. */
+    b(color: any): number;
+    /** Extract transparency (0-100, Pine scale) from a color string. Returns na if unparsable. */
+    t(color: any): number;
+    aqua(): "#00BCD4";
+    black(): "#363A45";
+    blue(): "#2196F3";
+    fuchsia(): "#E040FB";
+    gray(): "#787B86";
+    green(): "#4CAF50";
+    lime(): "#00E676";
+    maroon(): "#880E4F";
+    navy(): "#311B92";
+    olive(): "#808000";
+    orange(): "#FF9800";
+    purple(): "#9C27B0";
+    red(): "#F23645";
+    silver(): "#B2B5BE";
+    teal(): "#089981";
+    white(): "#FFFFFF";
+    yellow(): "#FDD835";
+}

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

@@ -9,5 +9,8 @@ export declare class LinefillObject {
     /** Bar index at which this object was created (for streaming rollback) */
     _createdAtBar: number;
     constructor(line1: LineObject, line2: LineObject, color: string);
+    get_line1(): LineObject;
+    get_line2(): LineObject;
+    set_color(color: any): void;
     delete(): void;
 }

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

@@ -29,6 +29,7 @@ import { tan } from './methods/tan';
 import { todegrees } from './methods/todegrees';
 import { toradians } from './methods/toradians';
 import { __eq } from './methods/__eq';
+import { __neq } from './methods/__neq';
 declare const methods: {
     abs: typeof abs;
     acos: typeof acos;
@@ -61,6 +62,7 @@ declare const methods: {
     todegrees: typeof todegrees;
     toradians: typeof toradians;
     __eq: typeof __eq;
+    __neq: typeof __neq;
 };
 export declare class PineMath {
     private context;
@@ -96,6 +98,7 @@ export declare class PineMath {
     todegrees: ReturnType<typeof methods.todegrees>;
     toradians: ReturnType<typeof methods.toradians>;
     __eq: ReturnType<typeof methods.__eq>;
+    __neq: ReturnType<typeof methods.__neq>;
     constructor(context: any);
 }
 export default PineMath;

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

@@ -0,0 +1,13 @@
+/**
+ * Pine Script na-aware inequality comparison.
+ *
+ * In Pine Script, any comparison involving `na` returns `false`:
+ *   na != na   → false
+ *   1  != na   → false
+ *   na != 1    → false
+ *
+ * This cannot be implemented as `!__eq(a, b)` because __eq(na, na) returns
+ * false, and !false = true — which is wrong. Both == and != must independently
+ * return false when either operand is na.
+ */
+export declare function __neq(context: any): (a: any, b: any) => boolean;

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

@@ -10,6 +10,11 @@ export declare class PolylineHelper {
      * Resolve a value that may be a Series, a bound function, or a plain scalar.
      */
     private _resolve;
+    /**
+     * Resolve a color value, preserving NaN (na = no color) instead of
+     * letting it fall through to a default via the || operator.
+     */
+    private _resolveColor;
     /**
      * Extract raw ChartPointObject array from a PineArrayObject, Series, or plain array.
      */

package/dist/types/namespaces/request/methods/security_lower_tf.d.ts

@@ -1,3 +1,4 @@
+import { PineArrayObject } from '../../array/PineArrayObject';
 /**
  * Requests the results of an expression from a specified symbol on a timeframe lower than or equal to the chart's timeframe.
  * It returns an array containing one element for each lower-timeframe bar within the chart bar.
@@ -6,4 +7,4 @@
  * @param context
  * @returns
  */
-export declare function security_lower_tf(context: any): (symbol: any, timeframe: any, expression: any, ignore_invalid_symbol?: boolean | any[], currency?: any, ignore_invalid_timeframe?: boolean | any[], calc_bars_count?: number | any[]) => Promise<any>;
+export declare function security_lower_tf(context: any): (symbol: any, timeframe: any, expression: any, ignore_invalid_symbol?: boolean | any[], currency?: any, ignore_invalid_timeframe?: boolean | any[], calc_bars_count?: number | any[]) => Promise<number | PineArrayObject | any[][]>;

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

@@ -16,4 +16,4 @@ export declare function extractCallsiteId(args: any[]): string | undefined;
  * @param types - The types to parse, each type is a string representing the type of the argument.
  * @returns The parsed arguments, the arguments are parsed according to the signatures and types.
  */
-export declare function parseArgsForPineParams<T>(args: any[], signatures: any[], types: Record<string, string>, override?: Record<string, any>): Partial<T> & T & Record<string, any>;
+export declare function parseArgsForPineParams<T>(args: any[], signatures: any[], types: Record<string, string>, override?: Record<string, any>): T & Partial<T> & Record<string, any>;

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

@@ -19,6 +19,7 @@ export declare class ScopeManager {
     private suppressHoisting;
     private reservedNames;
     private userFunctions;
+    private userMethods;
     get nextParamIdArg(): any;
     get nextCacheIdArg(): any;
     getNextTACallId(): any;
@@ -45,8 +46,18 @@ export declare class ScopeManager {
     addReservedName(name: string): void;
     addUserFunction(name: string): void;
     isUserFunction(name: string): boolean;
+    addUserMethod(name: string): void;
+    isUserMethod(name: string): boolean;
     addVariable(name: string, kind: string): string;
     getVariable(name: string): [string, string];
+    /**
+     * Check if a variable (by original name) lives inside a function scope.
+     * Walks the scope stack to find which scope owns the variable, then checks
+     * whether any scope from the root up to (and including) that level is a
+     * function scope ('fn').  This allows nested scopes (if, else, for, while)
+     * inside functions to be correctly treated as function-local.
+     */
+    isVariableInFunctionScope(name: string): boolean;
     generateTempVar(): string;
     enterHoistingScope(): void;
     exitHoistingScope(): any[];

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

@@ -6,12 +6,16 @@ export declare class CodeGenerator {
     private sourceLines;
     private lastCommentedLine;
     private includeSourceComments;
+    private paramRenameCounter;
+    private functionParams;
     constructor(options?: {
         indentStr?: string;
         sourceCode?: string;
         includeSourceComments?: boolean;
     });
     generate(ast: any): string;
+    private preProcessAST;
+    private collectFunctionParams;
     writeSourceComment(startLine: any, endLine?: any): void;
     write(str: any): void;
     writeLine(str?: string): void;
@@ -20,6 +24,7 @@ export declare class CodeGenerator {
     generateProgram(node: any): void;
     generateStatement(node: any): void;
     generateTypeDefinition(node: any): void;
+    private renameIdentifiersInAST;
     generateFunctionDeclaration(node: any): void;
     generateVariableDeclaration(node: any): void;
     generateExpressionStatement(node: any): void;

package/dist/types/transpiler/transformers/MainTransformer.d.ts

@@ -1,4 +1,16 @@
 import ScopeManager from '../analysis/ScopeManager';
+/**
+ * Post-pass: propagate async/await through user-defined function call chains.
+ *
+ * When request.security() is used inside a user-defined function, the transpiler
+ * injects `await` but doesn't mark the function as `async` or propagate await
+ * to callers via $.call(). This pass:
+ * 1. Finds all FunctionDeclarations containing AwaitExpression (directly, not in nested functions)
+ * 2. Marks them as async
+ * 3. Wraps $.call(fn, ...) invocations of those functions in AwaitExpression
+ * 4. Repeats until stable (handles transitive async infection: A calls B calls request.security)
+ */
+export declare function propagateAsyncAwait(ast: any): void;
 export declare function transformEqualityChecks(ast: any): void;
 export declare function runTransformationPass(ast: any, scopeManager: ScopeManager, originalParamName: string, options?: {
     debug: boolean;

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

@@ -19,6 +19,7 @@ export declare const ASTFactory: {
     createGetCall(source: any, index: any): any;
     createSetCall(target: any, value: any): any;
     createMathEqCall(left: any, right: any): any;
+    createMathNeqCall(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.3",
+    "version": "0.9.4",
     "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",