lightweight-charts-indicators

The INDICATOR_INVENTORY_COMMUNITY.md file provides a status report of community-contributed indicators for the OakScriptJS ecosystem. It tracks which indicators are currently Implemented, Implementable (planned), Blocked (due to technical limitations), or Duplicate (already available in the standard library).

Status Definitions

• Implemented: The indicator is available and ready for use.
• Implementable: The indicator is planned and can be built, often categorized by difficulty (Easy, Medium, Hard).
• Blocked: The indicator cannot be implemented currently due to specific technical blockers.
• Duplicate: The indicator is already covered by an existing standard or community indicator.

Common Blockers

If an indicator is marked as Blocked, it is typically due to one of the following requirements that the current engine may not support:

• MTF: Multi-Timeframe support.
• Drawing: Requires drawing shapes or lines on the chart.
• Table: Requires rendering data tables.
• Strategy: Requires a backtesting or trading strategy engine.
• Session: Requires specific session-based logic.
• Screener: Requires a screener interface.

The INDICATOR_INVENTORY_COMMUNITY.md document tracks the feasibility of porting TradingView PineScript indicators to OakScriptJS. It categorizes indicators based on whether they can be implemented and what technical limitations (blockers) prevent certain features from being replicated.

Implementation Feasibility

• Implementable (Easy/Medium/Hard): Indicators that can be ported. 'Hard' indicators typically involve complex logic (>200 lines) and may require skipping non-essential features like tables or drawings.
• Blocked: Indicators that cannot be fully replicated due to missing engine capabilities. While the core calculation logic might be portable, the full feature set is unavailable.
• Duplicate: Indicators that provide functionality already covered by existing standard or community indicators.
• N/A: Indicators that are fundamentally incompatible or have missing data requirements.

The timeframe.main_period variable is a simple string representing the script's main timeframe.

Behavioral Nuances:

• Indicator Declaration: If an indicator specifies a timeframe value in its declaration statement, timeframe.main_period holds that specific value. Otherwise, it defaults to the chart's current timeframe.
• Request Functions: Unlike timeframe.period, the value of timeframe.main_period remains constant when used inside the expression argument of a request.*() function call.

String Format: The format follows "<quantity>[<unit>]".

Supported Units:

• T: Ticks
• S: Seconds
• D: Days
• W: Weeks
• M: Months
• (No unit): Minutes
• Note on Hours: There is no specific unit for hours; hourly timeframes must be expressed in minutes (e.g., 4 hours is "240").

"10S" // 10 seconds
"30"   // 30 minutes
"240"  // 4 hours (expressed in minutes)
"1D"   // 1 day
"2W"   // 2 weeks
"3M"   // 3 months

The var keyword is used for assigning and one-time initializing a variable.

Unlike standard variable assignment (which overwrites the value with every data update), variables initialized with var "keep their state" across updates. The value remains unchanged unless it is explicitly modified using the reassignment operator (:=) within conditional blocks (like if expressions).

Syntax

var variable_name = expression

• variable_name: Any valid name (Latin characters, numbers, and underscores; cannot start with a number).
• expression: An arithmetic expression that is calculated and assigned to the variable exactly once during the first execution.

//@version=6  
indicator("Var keyword example")  
var a = close  
var b = 0.0  
var c = 0.0  
var green_bars_count = 0  

if close > open  
    var x = close  
    b := x  
    green_bars_count := green_bars_count + 1  
    if green_bars_count >= 10  
        var y = close  
        c := y  

plot(a)
plot(b)
plot(c)

The OakScriptJS Indicator Inventory tracks the implementation status of PineScript indicators (from TradingView's standard library) within the OakScriptJS environment. It categorizes indicators by their implementation status (Implemented vs Pending) and assigns a complexity score based on the technical features they require.

Implementation Status

• Implemented: The indicator is available for use in OakScriptJS. Many implemented indicators have passed regression testing (marked with ✅ Pass).
• Pending: The indicator is planned but not yet fully implemented.

Complexity Scoring

Complexity is used to prioritize development and is calculated using the following weights:

• Strategy functions: +20 points
• Drawing functions: +10 points
• request.security usage: +5 points
• Table operations: +5 points
• Array/Matrix operations: +5 points
• Number of unique TA functions used: (Base score)

The series keyword is a type qualifier used to declare variables or function parameters that can change throughout a script's execution. In the type qualifier hierarchy, series is the strongest qualifier:

const < input < simple < series

Key Behaviors

• Automatic Inference: The compiler usually detects if a parameter is compatible with series or simple automatically. For exported library functions, parameters are treated as series by default whenever possible.
• Variable Declarations: The compiler can typically infer the qualifier based on the assigned value and can automatically upgrade a variable to a stronger qualifier (e.g., from simple to series) if needed.
• Restriction: Explicitly declaring a variable as series restricts it. A series variable cannot be passed to any function or assigned to any variable that requires a weaker qualifier (such as const, input, or simple).
• Requirement: When using series as a qualifier, you must also provide a type keyword (e.g., float, int, bool).

//@version=6  
//@description A library with custom functions.  
library("CustomFunctions", overlay = true)  
  
//@function Finds the highest `source` value over `length` bars, filtered by the `cond` condition.  
export conditionalHighest(series float source, series bool cond, series int length) =>  
    //@variable The highest `source` value from when the `cond` was `true` over `length` bars.  
    series float result = na  
    // Loop to find the highest value.  
    for i = 0 to length - 1  
        if cond[i]  
            value   = source[i]  
            result := math.max(nz(result, value), value)  
    // Return the `result`.  
    result  
  
//@variable Is `true` once every five bars.  
series bool condition = bar_index % 5 == 0  
  
//@variable The highest `close` value from every fifth bar over the last 100 bars.  
series float hiValue = conditionalHighest(close, condition, 100)  

plot(hiValue)  
bgcolor(condition ? color.new(color.teal, 80) : na)