FTO Indicators

https://fto-2.gitbook.io/fto-indicators-docs
Admin
A guide for developers and strategy testers to create, understand, and manage custom trading...
Tokens:37,040
Snippets:170
Trust Score:10
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install Project Dependencies with npm

Source: https://fto-2.gitbook.io/fto-indicators-docs/indicators-your-trading-super-vision/tutorial-open-and-upload-indicator

This command installs all the necessary packages and dependencies required for the indicator project to run. It reads the 'dependencies' section of the project's `package.json` file and downloads them from the npm registry. Ensure Node.js and npm are installed and the project is opened in the terminal.

```bash
npm install
```

--------------------------------

### Complete Indicator Buffer Setup Workflow in TypeScript

Source: https://fto-2.gitbook.io/fto-indicators-docs/configure_indicator/create-index-buffer

Illustrates the complete process of setting up indicator buffers, including declaration, creation, registration, assignment, style configuration, and usage within the Calculate() method. This example shows how to manage multiple buffers for a moving average indicator.

```typescript
export default class MovingAverageIndicator extends IndicatorImplementation {
    // Declare all buffers as class properties
    public maBuffer!: TIndexBuffer;
    public signalBuffer!: TIndexBuffer;

    public Init(): void {
        // 1. Register total number of buffers FIRST
        this.api.IndicatorBuffers(2);

        // 2. Create buffer instances
        this.maBuffer = this.api.CreateIndexBuffer();
        this.signalBuffer = this.api.CreateIndexBuffer();

        // 3. Assign buffers to indexes
        this.api.SetIndexBuffer(0, this.maBuffer);
        this.api.SetIndexBuffer(1, this.signalBuffer);

        // 4. Configure buffer appearance
        this.api.SetIndexStyle(0, TDrawStyle.LINE, TPenStyle.SOLID, 2, "#0000ff");
        this.api.SetIndexStyle(1, TDrawStyle.LINE, TPenStyle.DASH, 1, "#ff0000");

        // 5. Set buffer labels
        this.api.SetIndexLabel(0, "Moving Average");
        this.api.SetIndexLabel(1, "Signal Line");
    }

    public Calculate(index: number): void {
        // Use buffers to store and retrieve values
        const closePrice = this.api.Close(index);
        const maValue = this.calculateMA(index);

        // Set buffer values
        this.maBuffer.setValue(index, maValue);
        this.signalBuffer.setValue(index, maValue * 1.1);

        // Get buffer values (from previous bars)
        const previousMA = this.maBuffer.getValue(index + 1);
    }
}
```

--------------------------------

### Install Dependencies and Build Indicator - npm

Source: https://fto-2.gitbook.io/fto-indicators-docs/indicators-your-trading-super-vision/set-up-indicator

This snippet shows the commands to install project dependencies and then build the indicator project. It assumes a Node.js environment and uses npm as the package manager. The build process compiles the indicator into a .js file in the 'dist' folder.

```bash
npm install
```

```bash
npm run build
```

--------------------------------

### Full Indicator Buffer Example

Source: https://fto-2.gitbook.io/fto-indicators-docs/visible-buffers

A complete example demonstrating the declaration, creation, registration, binding, and configuration of an indicator buffer within the Forex Tester Online API.

```typescript
import { TIndexBuffer } from "forex-tester-custom-indicator-api";

export default class MovingAverage extends IndicatorImplementation {
  // Declare parameters as class fields
  public Period!: TOptValue_number;
  public Shift!: TOptValue_number;
  public SSMA!: TIndexBuffer;

  public Init(): void {
    // Create parameters
    this.Period = this.api.createTOptValue_number(8);
    this.Shift = this.api.createTOptValue_number(0);

    // Create and configure the buffer
    this.SSMA = this.api.CreateIndexBuffer();
    this.api.IndicatorBuffers(1);
    this.api.SetIndexBuffer(0, this.SSMA);
    this.api.SetIndexLabel(0, "SSMA");
    this.api.SetIndexStyle(0, TDrawStyle.LINE, TPenStyle.SOLID, 1, "#FF0000");
    this.api.SetIndexDrawBegin(0, this.Period.value - 1 + this.Shift.value);
  }
}
```

--------------------------------

### FTODate Class Example Usage in TypeScript

Source: https://fto-2.gitbook.io/fto-indicators-docs/fto-date

Demonstrates how to create an FTODate instance and utilize its methods to retrieve date components, convert to various formats, and get calendar information. It showcases usage with project-specific and UTC timezones.

```typescript
const date = this.api.createFTODate(1707739200); // 2024.02.12 12:00:00 UTC

// Get components in project timezone
console.log(`Year: ${date.yearOf()}`);
console.log(`Month: ${date.monthOf()}`);
console.log(`Day: ${date.dayOfMonth()}`);
console.log(`Hour: ${date.hour()}`);
console.log(`Minute: ${date.minute()}`);
console.log(`Second: ${date.second()}`);

// Get components in UTC
console.log(`UTC Year: ${date.yearOf(TimeZoneMode.UTC)}`);
console.log(`UTC Month: ${date.monthOf(TimeZoneMode.UTC)}`);

// Convert to different formats
console.log(`Milliseconds: ${date.toMilliseconds()}`);
console.log(`Seconds: ${date.toSeconds()}`);
console.log(`ISO String: ${date.toString()}`);
console.log(`JS Date: ${date.toJSDate()}`);

// Get calendar information
console.log(`Day of Week: ${date.dayOfWeek()}`); // 0=Sunday
console.log(`Day of Year: ${date.dayOfYear()}`);
console.log(`Week of Year: ${date.weekOf()}`);
```

--------------------------------

### Example: Get buffer values and calculate difference - TypeScript

Source: https://fto-2.gitbook.io/fto-indicators-docs/configure_indicator/get-buffer-value

This example demonstrates how to use the `getValue` method to retrieve current and previous values from a buffer and then calculate the difference between them. It highlights accessing data at different bar indices (0 for current, 1 for previous) and using these values in subsequent calculations.

```TypeScript
// Get the value from buffer 0 at the current bar
const currentValue = this.someBuffer.getValue(0);

// Get the value from buffer 0 at the previous bar
const previousValue = this.someBuffer.getValue(1);

// Get a value from another buffer
const signalValue = this.someBuffer.getValue(0);

// Use values in calculations
const difference = currentValue - signalValue;
```

--------------------------------

### GetBufferMin Function Syntax and Example

Source: https://fto-2.gitbook.io/fto-indicators-docs/configure_indicator/get-buffer-min

Demonstrates the TypeScript syntax for the GetBufferMin function and provides practical examples of its use. It includes buffer creation, setting buffer values, finding minimums over different ranges, and using the minimum for normalization.

```typescript
public someBuffer = this.api.CreateIndexBuffer();

// Assign the buffer to index 0
this.api.SetIndexBuffer(0, this.someBuffer)

// Find the minimum value in buffer 0 over the last 20 bars
const min = this.api.GetBufferMin(0, 0, 19)

// Find the minimum value in buffer 1 over a custom range
const startIndex = 10
const endIndex = 50
const minInRange = this.api.GetBufferMin(1, startIndex, endIndex)

// Use the minimum value for normalization
const range = this.api.GetBufferMax(0, 0, 19) - min
for (let i = 0; i < 20; i++) {
    const normalizedValue = (this.someBuffer.getValue(i) - min) / range
    this.someBuffer.setValue(i, normalizedValue)
}
```

--------------------------------

### Example Usage of SetIndexDrawBegin in TypeScript

Source: https://fto-2.gitbook.io/fto-indicators-docs/configure_indicator/set-index-draw-begin

These examples demonstrate how to use the SetIndexDrawBegin method in a TypeScript environment, likely within a TradingView indicator script. They illustrate setting the drawing start point for different buffers, considering the calculation periods of indicators like moving averages and MACD to ensure accurate visualization.

```typescript
// For a 14-period moving average, don't draw the first 13 bars
this.api.SetIndexDrawBegin(0, 13);

// For a 26-period EMA, don't draw until we have enough data
this.api.SetIndexDrawBegin(0, 25);

// For MACD with 12 and 26 periods, don't draw until we have enough data for both
this.api.SetIndexDrawBegin(0, 25); // MACD line
this.api.SetIndexDrawBegin(1, 33); // Signal line (26 + 9 - 1)
```

--------------------------------

### Indicator Initialization Syntax

Source: https://fto-2.gitbook.io/fto-indicators-docs/indicators/indicator-structure/init

The basic syntax for the Init method, which is called once when the indicator is created or loaded. This method is used for all initial setup tasks.

```typescript
public Init(): void {
    // initialization logic here
}
```

--------------------------------

### TypeScript: Dynamic Buffer Styling with OnParamsChange

Source: https://fto-2.gitbook.io/fto-indicators-docs/indicators/indicator-structure/on-params-change

A practical example in TypeScript demonstrating how to use `OnParamsChange` for dynamic buffer styling. This includes updating line color, controlling line visibility, and adjusting the drawing start based on indicator parameters.

```typescript
export default class CustomIndicator extends IndicatorImplementation {
  public period!: TOptValue_number;
  public lineColor!: TOptValue_str;
  public showLine!: TOptValue_bool;
  public mainBuffer!: TIndexBuffer;

  public OnParamsChange(): void {
    // Update line color when user changes it
    this.api.SetIndexStyle(
      0,
      TDrawStyle.LINE,
      TPenStyle.SOLID,
      1,
      this.lineColor.value
    );

    // Show/hide line based on boolean parameter
    this.api.SetIndexVisibility(0, this.showLine.value);

    // Adjust drawing start based on period
    this.api.SetIndexDrawBegin(0, this.period.value);
  }
}
```

--------------------------------

### GetBufferMax Function Syntax and Example

Source: https://fto-2.gitbook.io/fto-indicators-docs/configure_indicator/get-buffer-max

Demonstrates the TypeScript syntax for the GetBufferMax function and provides practical examples of its usage. This includes buffer creation, assignment, finding maximum values in different ranges, and applying the result for scaling indicator values.

```typescript
GetBufferMax(buffer: number, index1: number, index2: number): number
```

```typescript
// Create  buffer
public someBuffer = this.api.CreateIndexBuffer();

// Assign the buffer to index 0
this.api.SetIndexBuffer(0, this.someBuffer)

// Find the maximum value in buffer 0 over the last 20 bars
const max = this.api.GetBufferMax(0, 0, 19)

// Find the maximum value in buffer 1 over a custom range
const startIndex = 10
const endIndex = 50
const maxInRange = this.api.GetBufferMax(1, startIndex, endIndex)

// Use the maximum value for scaling
const scaleFactor = 100 / max
for (let i = 0; i < 20; i++) {
    const scaledValue = this.someBuffer(0, i) * scaleFactor
    this.someBuffer.setValue(i, scaledValue)
}
```

--------------------------------

### Set Output Window Example (TypeScript)

Source: https://fto-2.gitbook.io/fto-indicators-docs/types/output-window

Demonstrates how to set the output window for an indicator using the TOutputWindow enumeration in TypeScript. It shows examples for displaying indicators in the main chart window and in a separate window.

```typescript
this.api.SetOutputWindow(TOutputWindow.CHART_WINDOW);

this.api.SetOutputWindow(TOutputWindow.SEPARATE_WINDOW);
```

--------------------------------

### Example: State-Based Indicator Visibility

Source: https://fto-2.gitbook.io/fto-indicators-docs/configure_indicator/set-index-visibility

Demonstrates how to use SetIndexVisibility to switch between showing a trend buffer and a range buffer based on the detected market state. This example controls which of two buffers is visible.

```typescript
export default class TrendRangeIndicator extends IndicatorImplementation {
  public trendBuffer!: TIndexBuffer;
  public rangeBuffer!: TIndexBuffer;
  private isInTrend: boolean = false;

  public Calculate(index: number): void {
    // Determine market state
    this.isInTrend = this.calculateTrendState(index);

    if (this.isInTrend) {
      // Show trend buffer, hide range buffer
      this.api.SetIndexVisibility(0, true); // Trend buffer
      this.api.SetIndexVisibility(1, false); // Range buffer

      this.trendBuffer.setValue(index, this.calculateTrendValue(index));
    } else {
      // Show range buffer, hide trend buffer
      this.api.SetIndexVisibility(0, false); // Trend buffer
      this.api.SetIndexVisibility(1, true); // Range buffer

      this.rangeBuffer.setValue(index, this.calculateRangeValue(index));
    }
  }
}
```

--------------------------------

### GetBufferInfo - TypeScript Example

Source: https://fto-2.gitbook.io/fto-indicators-docs/configure_indicator/get-buffer-info

This example demonstrates how to retrieve buffer information using GetBufferInfo and conditionally modify buffer visibility. It takes a buffer index and returns a TVisibleBufferInfo object.

```typescript
const bufferInfo = this.api.GetBufferInfo(0);

console.log(`Buffer Name: ${bufferInfo.name}`);
console.log(`Paint From: ${bufferInfo.paintFrom}`);

if (bufferInfo.paintFrom > 0) {
  this.api.SetIndexVisibility(0, true);
} else {
  this.api.SetIndexVisibility(0, false);
}
```

--------------------------------

### TypeScript: Correct OnParamsChange Usage Example

Source: https://fto-2.gitbook.io/fto-indicators-docs/indicators/indicator-structure/on-params-change

An example showcasing the correct usage of the `OnParamsChange` method. It demonstrates lightweight parameter-dependent logic, updating buffer styling, and resetting internal state, which are appropriate operations within this method.

```typescript
public OnParamsChange(): void {
    // ✅ Correct - lightweight parameter-dependent logic
    this.internalMultiplier = this.period.value * 2;

    // ✅ Correct - update buffer styling based on parameters
    if (this.showLine.value) {
        this.api.SetIndexStyle(0, TDrawStyle.LINE, TPenStyle.SOLID, 1, this.lineColor.value);
    } else {
        this.api.SetIndexVisibility(0, false);
    }

    // ✅ Correct - reset internal state
    this.calculationCounter = 0;
}
```

--------------------------------

### Build Indicator Project with npm

Source: https://fto-2.gitbook.io/fto-indicators-docs/indicators-your-trading-super-vision/tutorial-open-and-upload-indicator

This command compiles and bundles the indicator project, preparing it for use by the FTO platform. It typically executes build scripts defined in the `package.json` file, such as transpiling TypeScript to JavaScript. This step should be run after all dependencies are installed and any code modifications are made.

```bash
npm run build
```

--------------------------------

### Get Lowest Price Values for Different Types (TypeScript)

Source: https://fto-2.gitbook.io/fto-indicators-docs/access-to-bar-arrays/ilowest

This example iterates through different price types (OPEN, HIGH, LOW, CLOSE) and uses iLowest to find the index of the lowest value for each type within the last 10 bars. It then retrieves the corresponding price, demonstrating versatility in analyzing various price components.

```typescript
// Get lowest price values for different types
const types = [0, 1, 2, 3]; // OPEN, HIGH, LOW, CLOSE
const lowestValues = types.map((type) => {
  const idx = this.api.iLowest("EURUSD", 60, type, 10, 0);
  return idx !== -1 ? this.api.iLow("EURUSD", 60, idx) : null;
});
```

--------------------------------

### Create OBV Indicator with FTO API (TypeScript)

Source: https://fto-2.gitbook.io/fto-indicators-docs/indicators-your-trading-super-vision/tutorial-create-indicator-with-cursor-ide/step-5-start-building

This code defines an On Balance Volume (OBV) indicator using the FTO Indicator API. It initializes indicator properties, sets up buffers for drawing, and implements the calculation logic based on price and volume data. Requires the 'forex-tester-custom-indicator-api' package.

```typescript
import { IndicatorImplementation, TDrawStyle, TPenStyle, TOutputWindow, TIndexBuffer } from "forex-tester-custom-indicator-api";

export default class OBVIndicator extends IndicatorImplementation {
    // Declare the buffer as a class property
    public obvBuffer!: TIndexBuffer;

    Init(): void {
        this.api.RecalculateMeAlways();
        
        // Set indicator name
        this.api.IndicatorShortName("On Balance Volume (OBV)");
        
        // Configure to display in separate window since OBV is an oscillator
        this.api.SetOutputWindow(TOutputWindow.SEPARATE_WINDOW);
        
        // Register the number of buffers we'll use
        this.api.IndicatorBuffers(1);
        
        // Create and initialize the OBV buffer
        this.obvBuffer = this.api.CreateIndexBuffer();
        
        // Bind buffer to index 0
        this.api.SetIndexBuffer(0, this.obvBuffer);
        
        // Configure buffer appearance
        this.api.SetIndexStyle(0, TDrawStyle.LINE, TPenStyle.SOLID, 1, "#0000FF"); // Blue line
        this.api.SetIndexLabel(0, "OBV");
    }

    Calculate(index: number): void {
        // If this is the first bar (rightmost/newest), initialize OBV
        if (index === this.api.Bars() - 1) {
            this.obvBuffer.setValue(index, this.api.Volume(index));
            return;
        }

        // Get current and previous close prices
        const currentClose = this.api.Close(index);
        const previousClose = this.api.Close(index + 1);
        
        // Get current volume
        const volume = this.api.Volume(index);
        
        // Get previous OBV value
        const previousOBV = this.obvBuffer.getValue(index + 1);
        
        let currentOBV;
        
        // Calculate OBV based on price movement
        if (currentClose > previousClose) {
            // If price increased, add volume
            currentOBV = previousOBV + volume;
        } else if (currentClose < previousClose) {
            // If price decreased, subtract volume
            currentOBV = previousOBV - volume;
        } else {
            // If price unchanged, OBV remains the same
            currentOBV = previousOBV;
        }
        
        // Set the calculated OBV value
        this.obvBuffer.setValue(index, currentOBV);
    }
}
```

--------------------------------

### Example: Timeframe-Dependent Buffer Visibility

Source: https://fto-2.gitbook.io/fto-indicators-docs/configure_indicator/set-index-visibility

Shows how to dynamically change buffer visibility based on the current chart timeframe using SetIndexVisibility. This example toggles between short-term and long-term analysis buffers.

```typescript
export default class MultiTimeframeIndicator extends IndicatorImplementation {
  public shortTermBuffer!: TIndexBuffer;
  public longTermBuffer!: TIndexBuffer;

  public OnParamsChange(): void {
    const currentTimeframe = this.api.Timeframe();

    if (currentTimeframe <= 60) {
      // 1 hour or less
      // Show short-term analysis
      this.api.SetIndexVisibility(0, true); // Short-term buffer
      this.api.SetIndexVisibility(1, false); // Long-term buffer
    } else {
      // Show long-term analysis
      this.api.SetIndexVisibility(0, false); // Short-term buffer
      this.api.SetIndexVisibility(1, true); // Long-term buffer
    }
  }
}
```

--------------------------------

### FTO Indicator Initialization and Calculation Structure (TypeScript)

Source: https://fto-2.gitbook.io/fto-indicators-docs/indicators/indicator-structure/init

Demonstrates the fundamental structure for FTO indicators using TypeScript. The `Init()` method is designated for setup and configuration, while the `Calculate()` method handles all data processing and calculations. This separation ensures a clean and efficient indicator implementation.

```TypeScript
public Init(): void {
    // ✅ Correct - only setup and configuration
    this.api.IndicatorShortName("My Indicator");
    this.api.IndicatorBuffers(1);
    this.mainBuffer = this.api.CreateIndexBuffer();
    // ... other setup code
}

public Calculate(index: number): void {
    // ✅ Correct - calculations go here
    let value = this.api.Close(index) * 2;
    this.mainBuffer.setValue(index, value);
}
```

```TypeScript
export default class MovingAverage extends IndicatorImplementation {
  // Parameters - declared as class-level fields
  public Period!: TOptValue_number;
  public ShowLine!: TOptValue_bool;

  // Buffers - declared as class-level fields
  public MA!: TIndexBuffer;

  public Init(): void {
    // 1. Create and register parameters
    this.Period = this.api.createTOptValue_number(14);
    this.ShowLine = this.api.createTOptValue_bool(true);

    this.api.RegOption("Period", TOptionType.INTEGER, this.Period);
    this.api.RegOption("Show Line", TOptionType.BOOLEAN, this.ShowLine);
    this.api.SetOptionRange("Period", 1, 9999);

    // 2. Set indicator properties
    this.api.IndicatorShortName("Moving Average");
    this.api.SetOutputWindow(TOutputWindow.CHART_WINDOW);
    this.api.RecalculateMeAlways(); // Recommended

    // 3. Create and configure buffers
    this.api.IndicatorBuffers(1);
    this.MA = this.api.CreateIndexBuffer();
    this.api.SetIndexBuffer(0, this.MA);
    this.api.SetIndexLabel(0, "Moving Average");
    this.api.SetIndexStyle(0, TDrawStyle.LINE, TPenStyle.SOLID, 1, "#FF0000");
  }

  public Calculate(index: number): void {
    // Actual calculations happen here, not in Init()
    const periodValue = this.Period.value; // Access parameter value
    // ... calculation logic
  }
}
```

--------------------------------

### Configure and Bind Indicator Buffers in TypeScript

Source: https://fto-2.gitbook.io/fto-indicators-docs/tutorial-moving-average

Sets the number of indicator buffers to be displayed and binds them by unique index starting from 0. This ensures the chart knows which buffers to render.

```typescript
this.api.IndicatorBuffers(1);
this.api.SetIndexBuffer(0, this.SSMA);
```

--------------------------------

### Style Indicator Buffers in TypeScript

Source: https://fto-2.gitbook.io/fto-indicators-docs/tutorial-moving-average

Configures the visual appearance of a specific indicator buffer, including its label, drawing style, line style, thickness, and color. It also sets the starting bar for drawing the indicator.

```typescript
this.api.SetIndexLabel(0, "MA");
this.api.SetIndexStyle(0, TDrawStyle.LINE, TPenStyle.SOLID, 1, "#FF0000");
this.api.SetIndexDrawBegin(0, this.Period.value - 1 + this.Shift.value);
```

--------------------------------

### Handle Parameter Changes in TypeScript

Source: https://fto-2.gitbook.io/fto-indicators-docs/tutorial-moving-average

Implements the `OnParamsChange` method to apply custom logic when indicator parameters are modified. This example demonstrates shifting the indicator buffer horizontally based on the `Shift` parameter.

```typescript
public OnParamsChange(): void {
    this.api.SetBufferShift(0, this.Shift.value)
}
```

--------------------------------

### Example: Moving Average Indicator Parameters (TypeScript)

Source: https://fto-2.gitbook.io/fto-indicators-docs/indicators/indicator-structure/toptvalue/toptvalue-number

This comprehensive example illustrates the practical application of TOptValue_number within a Moving Average indicator. It defines multiple numeric parameters such as Period, Shift, MAtype, ApplyToPrice, and VShift, showing their creation with specific default values and subsequent registration.

```typescript
export default class MovingAverage extends IndicatorImplementation {
  public Period!: TOptValue_number;
  public Shift!: TOptValue_number;
  public MAtype!: TOptValue_number;
  public ApplyToPrice!: TOptValue_number;
  public VShift!: TOptValue_number;

  public Init(): void {
    // Create parameters with default values
    this.Period = this.api.createTOptValue_number(8);
    this.Shift = this.api.createTOptValue_number(0);
    this.MAtype = this.api.createTOptValue_number(E_MAType.SMA);
    this.ApplyToPrice = this.api.createTOptValue_number(TPriceType.CLOSE);
    this.VShift = this.api.createTOptValue_number(0);

    // Register parameters
    this.api.RegOption("Period", TOptionType.INTEGER, this.Period);
    this.api.RegOption("Shift", TOptionType.INTEGER, this.Shift);
    this.api.RegOption("MAtype", TOptionType.INTEGER, this.MAtype);
    this.api.RegOption("ApplyToPrice", TOptionType.INTEGER, this.ApplyToPrice);
    this.api.RegOption("VShift", TOPTIONType.INTEGER, this.VShift);
  }
}
```

--------------------------------

### Example: Conditional Signal Display Visibility

Source: https://fto-2.gitbook.io/fto-indicators-docs/configure_indicator/set-index-visibility

Illustrates using SetIndexVisibility to conditionally display warning and signal buffers. The warning buffer is shown during high volatility, and the signal buffer is shown only when conditions are optimal.

```typescript
export default class SmartSignalIndicator extends IndicatorImplementation {
  public mainBuffer!: TIndexBuffer;
  public warningBuffer!: TIndexBuffer;
  public signalBuffer!: TIndexBuffer;

  public Calculate(index: number): void {
    const mainValue = this.calculateMainValue(index);
    this.mainBuffer.setValue(index, mainValue);

    // Only show warning when market is volatile
    const volatility = this.calculateVolatility(index);
    if (volatility > 2.0) {
      this.api.SetIndexVisibility(1, true); // Show warning
      this.warningBuffer.setValue(index, mainValue);
    } else {
      this.api.SetIndexVisibility(1, false); // Hide warning
    }

    // Only show signals when conditions are optimal
    const signalStrength = this.calculateSignalStrength(index);
    if (signalStrength > 0.8 && volatility < 1.5) {
      this.api.SetIndexVisibility(2, true); // Show signal
      this.signalBuffer.setValue(index, this.generateSignal(index));
    } else {
      this.api.SetIndexVisibility(2, false); // Hide signal
    }
  }
}
```

--------------------------------

### Example: Using DoesChartObjectExist for Safe Chart Object Operations - TypeScript

Source: https://fto-2.gitbook.io/fto-indicators-docs/access_to_objects/does-chart-object-exist

Demonstrates practical usage of DoesChartObjectExist to conditionally perform operations like setting properties, checking static objects, creating objects if they don't exist, and removing objects.

```typescript
// Check if object exists before using it
if (this.api.DoesChartObjectExist("MyTrendLine")) {
  // Object exists, safe to use
  this.api.SetObjectProperty("MyTrendLine", ObjProp.OBJPROP_COLOR, 0xff0000);
} else {
  console.log("Object not found");
}

// Check static object
const staticExists = this.api.DoesChartObjectExist("MyStaticLabel", true);
console.log(`Static object exists: ${staticExists}`);

// Create object only if it doesn't exist
const objectName = "UniqueObject";
if (!this.api.DoesChartObjectExist(objectName)) {
  this.api.СreateChartObject(
    objectName,
    TObjectType.TEXT,
    0,
    this.api.createFTODate(Date.now()),
    1.2345
  );
}

// Remove object if it exists
if (this.api.DoesChartObjectExist("OldObject")) {
  this.api.RemoveChartObject("OldObject");
}
```

--------------------------------

### Calculate Price Channel Height (TypeScript)

Source: https://fto-2.gitbook.io/fto-indicators-docs/access-to-bar-arrays/ilowest

This example calculates the height of a price channel by finding the highest high and lowest low over the last 20 bars. It utilizes both iHighest and iLowest functions, showcasing how they can be combined to define price boundaries for trading strategies.

```typescript
// Find price channel
const highestHigh = this.api.iHigh(
  "EURUSD",
  60,
  this.api.iHighest("EURUSD", 60, 1, 20, 0)
);
const lowestLow = this.api.iLow(
  "EURUSD",
  60,
  this.api.iLowest("EURUSD", 60, 2, 20, 0)
);
const channelHeight = highestHigh - lowestLow;
```

--------------------------------

### SetOptionDigits - TypeScript Example

Source: https://fto-2.gitbook.io/fto-indicators-docs/external_parameters_definition/set-option-digits

Demonstrates how to use the SetOptionDigits method in TypeScript to configure the decimal precision for registered numeric options. This involves first registering an option using RegOption and then calling SetOptionDigits to specify the display format.

```typescript
this.api.RegOption("Overbought Level", TOptionType.DOUBLE, 70.0);
this.api.SetOptionDigits("Overbought Level", 1);
this.api.RegOption("Multiplier", TOptionType.DOUBLE, 2.618);
this.api.SetOptionDigits("Multiplier", 3);
```

--------------------------------

### Get Price Based on Selected Type

Source: https://fto-2.gitbook.io/fto-indicators-docs/tutorial-create-indicator-with-cursor

A helper method to retrieve the price for a given index based on the user-selected 'Price Type'. It handles different price types including Close, Open, High, Low, Median, and Typical prices, with a fallback to Close price.

```typescript
private getPrice(index: number): number {
        switch (this.priceType.value) {
            case 0: // Close
                return this.api.Close(index);
            case 1: // Open
                return this.api.Open(index);
            case 2: // High
                return this.api.High(index);
            case 3: // Low
                return this.api.Low(index);
            case 4: // Median
                return (this.api.High(index) + this.api.Low(index)) / 2;
            case 5: // Typical
                return (this.api.High(index) + this.api.Low(index) + this.api.Close(index)) / 3;
            default:
                return this.api.Close(index); // Fallback to Close
        }
    }
```

--------------------------------

### Get Open Price using iOpen (TypeScript)

Source: https://fto-2.gitbook.io/fto-indicators-docs/access-to-bar-arrays/iopen

The iOpen function retrieves the opening price of a bar from the price history of a given symbol and timeframe. The index parameter specifies which bar to retrieve (0 for the current bar).

```typescript
const currentOpen = this.api.iOpen("EURUSD", 60, 0);
const pastOpen = this.api.iOpen("EURUSD", 60, 5);
const openDiff =
  this.api.iOpen("EURUSD", 60, 0) - this.api.iOpen("EURUSD", 60, 1);

if (this.api.iOpen("EURUSD", 60, 0) > this.api.iOpen("EURUSD", 60, 1)) {
  console.log("Current bar opened higher");
}
```

--------------------------------

### Registering Indicator Options with TOptionType (TypeScript)

Source: https://fto-2.gitbook.io/fto-indicators-docs/types/option-type

This example demonstrates how to use the TOptionType enumeration in TypeScript to register various types of options for indicators and strategies using the `RegOption` and `AddSeparator` API methods. It shows the usage for integer, color, boolean, enum types, and adding visual separators.

```typescript
this.api.RegOption("Period", TOptionType.INTEGER, 14);

this.api.RegOption("Line Color", TOptionType.COLOR, "#0000FF");

this.api.RegOption("Show Labels", TOptionType.BOOLEAN, true);

this.api.RegOption("MA Type", TOptionType.ENUM_TYPE, 0);

this.api.AddSeparator("Visual Settings");
```

--------------------------------

### Example Usage of TPenStyle Enumeration in TypeScript

Source: https://fto-2.gitbook.io/fto-indicators-docs/types/pen-style

Demonstrates how to use the TPenStyle enumeration to define line styles for chart levels. This involves calling the AddLevel method with different TPenStyle values to create solid, dashed, and dotted lines with specified colors and transparency.

```typescript
this.api.AddLevel(70, TPenStyle.SOLID, 1, "#FF0000", 1);

this.api.AddLevel(30, TPenStyle.DASH, 1, "#00FF00", 1);

this.api.AddLevel(50, TPenStyle.DOT, 1, "#808080", 0.7);
```

--------------------------------

### Get Chart Timeframe (TypeScript)

Source: https://fto-2.gitbook.io/fto-indicators-docs/other/timeframe

Retrieves the current chart's timeframe in seconds. Special values represent longer periods. Example demonstrates checking for specific timeframes like H1 or Daily.

```typescript
Timeframe(): number
```

```typescript
// Get the current timeframe
const timeframe = this.api.Timeframe();
console.log(`Current timeframe: ${timeframe}`);

// Check for specific timeframes
if (this.api.Timeframe() === 60) {
  // H1 specific logic
} else if (this.api.Timeframe() === 1440) {
  // Daily chart logic
}
```

--------------------------------

### Find Lowest Price Index in Last 10 Bars (TypeScript)

Source: https://fto-2.gitbook.io/fto-indicators-docs/access-to-bar-arrays/ilowest

This example demonstrates how to use the iLowest function to find the index of the bar with the lowest low price within the last 10 bars. It also shows how to retrieve the actual price using the found index. Handles cases where no valid bar is found.

```typescript
const lowestIndex = this.api.iLowest("EURUSD", 60, 2, 10, 0);
if (lowestIndex !== -1) {
  const lowestPrice = this.api.iLow("EURUSD", 60, lowestIndex);
  console.log(`Lowest price: ${lowestPrice} at index ${lowestIndex}`);
}
```

--------------------------------

### Creating and Configuring Buffers

Source: https://fto-2.gitbook.io/fto-indicators-docs/indicators/indicator-structure/init

Illustrates the process of setting up indicator buffers, including registering the total number of buffers, creating a buffer instance, binding it to an index, and configuring its visual appearance and drawing behavior.

```typescript
// Declare as class-level field
public mainBuffer!: TIndexBuffer;

public Init(): void {
    // 1. Register total number of buffers (MUST be called first)
    this.api.IndicatorBuffers(1);

    // 2. Create the buffer
    this.mainBuffer = this.api.CreateIndexBuffer();

    // 3. Bind buffer to index
    this.api.SetIndexBuffer(0, this.mainBuffer);

    // 4. Configure buffer appearance
    this.api.SetIndexLabel(0, "Main Line");
    this.api.SetIndexStyle(0, TDrawStyle.LINE, TPenStyle.SOLID, 1, '#FF0000');

    // 5. Optional: Set drawing start point
    this.api.SetIndexDrawBegin(0, 10);
}
```

--------------------------------

### Building and Deploying Indicators with npm and Bash

Source: https://context7.com/context7/fto-2_gitbook_io_fto-indicators-docs/llms.txt

This snippet outlines the command-line steps for building and deploying custom indicators for Forex Tester Online. It includes installing dependencies, compiling TypeScript to JavaScript, and instructions for uploading the compiled `.js` file to the FTO platform. It also addresses potential PowerShell execution policy issues on Windows. Dependencies include Node.js, npm, and the FTO platform.

```bash
# Install dependencies (first time only)
npm install

# Build the indicator (compiles TypeScript to JavaScript)
npm run build

# Output file location
# dist/my-indicator-project.js

# Fix PowerShell execution policy error (Windows)
Set-ExecutionPolicy RemoteSigned -Scope CurrentUser
```

--------------------------------

### Get Index of Highest Value Bar - TypeScript

Source: https://fto-2.gitbook.io/fto-indicators-docs/access-to-bar-arrays/ihighest

Retrieves the index of the bar with the highest value for a specified price type within a given range. Useful for technical analysis to find local maxima. Requires symbol, timeframe, price type, count of bars, and starting index.

```typescript
// Find highest high price in last 10 bars
const highestIndex = this.api.iHighest("EURUSD", 60, 1, 10, 0);
if (highestIndex !== -1) {
  const highestPrice = this.api.iHigh("EURUSD", 60, highestIndex);
  console.log(`Highest price: ${highestPrice} at index ${highestIndex}`);
}

// Find highest close in last 20 bars
const highestCloseIndex = this.api.iHighest("EURUSD", 60, 3, 20, 0);

// Find highest volume in last 5 bars
const highestVolumeIndex = this.api.iHighest("EURUSD", 60, 4, 5, 0);

// Check if current bar is highest in last 50 bars
const isNewHigh = this.api.iHighest("EURUSD", 60, 1, 50, 0) === 0;

// Find highest high starting from a specific bar
const startIndex = 10;
const lookback = 5;
const highIndex = this.api.iHighest("EURUSD", 60, 1, lookback, startIndex);

// Get highest price values for different types
const types = [0, 1, 2, 3]; // OPEN, HIGH, LOW, CLOSE
const highestValues = types.map((type) => {
  const idx = this.api.iHighest("EURUSD", 60, type, 10, 0);
  return idx !== -1 ? this.api.iHigh("EURUSD", 60, idx) : null;
});
```

--------------------------------

### Creating and Registering Parameters

Source: https://fto-2.gitbook.io/fto-indicators-docs/indicators/indicator-structure/init

Demonstrates how to declare, create using factory methods, and register user-configurable parameters for an indicator. Registration with RegOption is crucial for UI visibility.

```typescript
// Declare as class-level field
public period!: TOptValue_number;
public showLine!: TOptValue_bool;
public mode!: TOptValue_str;

public Init(): void {
    // Create parameters with factory methods
    this.period = this.api.createTOptValue_number(14);
    this.showLine = this.api.createTOptValue_bool(true);
    this.mode = this.api.createTOptValue_str("Simple");

    // Register parameters (required for UI visibility)
    this.api.RegOption("Period", TOptionType.INTEGER, this.period);
    this.api.RegOption("Show Line", TOptionType.BOOLEAN, this.showLine);
    this.api.RegOption("Mode", TOptionType.STRING, this.mode);

    // Optional: Set parameter constraints
    this.api.SetOptionRange("Period", 1, 200);
    this.api.SetOptionDigits("Period", 0);
}
```

--------------------------------

### Registering Indicator Parameters (TypeScript)

Source: https://fto-2.gitbook.io/fto-indicators-docs/tutorial-moving-average

Illustrates the process of registering indicator parameters within the Init function using methods provided by the forex-tester-custom-indicator-api. This makes the parameters visible and configurable in the indicator settings.

```typescript
public Init(): void {
  ...existing code...
  // Register parameter this.Period so it's shown in the indicator settings
  this.api.RegOption(
    'Period',
    TOptionType.INTEGER,
    this.Period
  );
  // Setting the maximum avalable range that can be used for Period value
  this.api.SetOptionRange(
    'Period',
    1,
    Number.MAX_SAFE_INTEGER
  );
  // Register parameter this.Shift so it's shown in the indicator settings
  this.api.RegOption(
    'Shift',
    TOptionType.INTEGER,
    this.Shift
  );
  // Register parameter this.VShift so it's its shown in the indicator settings
  this.api.RegOption(
    'VShift',
    TOptionType.INTEGER,
    this.VShift
  );
  // Register the MA type so it has a drowdown in the indicator settings
  this.api.RegMATypeOption(
    this.MAtype,
    'MAtype'
  );
  // Register the price type so it has a dropdown in the indicator settings.
  this.api.RegApplyToPriceOption(
    this.ApplyToPrice,
    'ApplyToPrice'
  );
...existing code...
}
```

--------------------------------

### TypeScript: Incorrect OnParamsChange Usage Example

Source: https://fto-2.gitbook.io/fto-indicators-docs/indicators/indicator-structure/on-params-change

An example demonstrating incorrect usage of the `OnParamsChange` method. It includes heavy calculations and attempts to create new parameters, both of which are forbidden operations and should be avoided.

```typescript
public OnParamsChange(): void {
    // DON'T DO THIS - heavy calculations
    for (let i = 0; i < 1000; i++) {
        let value = this.api.Close(i) * this.period.value; // ❌ Wrong!
        this.mainBuffer.setValue(i, value); // ❌ Wrong!
    }

    // DON'T DO THIS - creating new parameters
    this.newParam = this.api.createTOptValue_number(10); // ❌ Wrong!
    this.api.RegOption("New Param", TOptionType.INTEGER, this.newParam); // ❌ Wrong!
}
```

--------------------------------

### Create and Manage Bollinger Bands Buffers (TypeScript)

Source: https://context7.com/context7/fto-2_gitbook_io_fto-indicators-docs/llms.txt

This TypeScript code demonstrates how to initialize, configure, and calculate values for Bollinger Bands using the FTO Indicators library. It covers registering buffer counts, creating buffer instances, assigning them to indexes, setting styles and labels, and performing calculations for the upper, middle, and lower bands, as well as a fill buffer. It also shows how to access buffer information and individual values.

```typescript
export default class BollingerBands extends IndicatorImplementation {
  // Declare all buffers as class fields
  public upperBand!: TIndexBuffer;
  public middleBand!: TIndexBuffer;
  public lowerBand!: TIndexBuffer;
  public fillBuffer!: TIndexBuffer;

  public Init(): void {
    // Register total buffer count FIRST
    this.api.IndicatorBuffers(4);

    // Create buffer instances
    this.upperBand = this.api.CreateIndexBuffer();
    this.middleBand = this.api.CreateIndexBuffer();
    this.lowerBand = this.api.CreateIndexBuffer();
    this.fillBuffer = this.api.CreateIndexBuffer();

    // Assign buffers to indexes (must be unique, zero-based)
    this.api.SetIndexBuffer(0, this.upperBand);
    this.api.SetIndexBuffer(1, this.middleBand);
    this.api.SetIndexBuffer(2, this.lowerBand);
    this.api.SetIndexBuffer(3, this.fillBuffer);

    // Configure buffer styles
    this.api.SetIndexStyle(0, TDrawStyle.LINE, TPenStyle.SOLID, 1, "#FF0000");
    this.api.SetIndexStyle(1, TDrawStyle.LINE, TPenStyle.SOLID, 2, "#0000FF");
    this.api.SetIndexStyle(2, TDrawStyle.LINE, TPenStyle.SOLID, 1, "#FF0000");
    this.api.SetIndexStyle(3, TDrawStyle.FILL, TPenStyle.SOLID, 1, "#80C0FF");

    // Set buffer labels for legend
    this.api.SetIndexLabel(0, "Upper Band");
    this.api.SetIndexLabel(1, "Middle Band");
    this.api.SetIndexLabel(2, "Lower Band");

    // Set starting bar for drawing
    this.api.SetIndexDrawBegin(0, 20);
    this.api.SetIndexDrawBegin(1, 20);
    this.api.SetIndexDrawBegin(2, 20);
    this.api.SetIndexDrawBegin(3, 20);

    // Set buffer shift (horizontal offset)
    this.api.SetBufferShift(0, 2);
  }

  public Calculate(index: number): void {
    if (index + 20 >= this.api.Bars()) return;

    // Calculate and store values
    const middle = this.calculateSMA(index, 20);
    const stdDev = this.calculateStdDev(index, 20, middle);

    this.middleBand.setValue(index, middle);
    this.upperBand.setValue(index, middle + 2 * stdDev);
    this.lowerBand.setValue(index, middle - 2 * stdDev);
    this.fillBuffer.setValue(index, middle - 2 * stdDev); // Fill between buffer 2 and 3

    // Get buffer information
    const bufferInfo = this.api.GetBufferInfo(0);
    const bufferMin = this.api.GetBufferMin(0, 0, 100);
    const bufferMax = this.api.GetBufferMax(0, 0, 100);
    const bufferCount = this.api.GetBufferCount(0);

    // Alternative buffer value access
    const middleValue = this.api.GetBufferValue(1, index);
  }

  private calculateSMA(index: number, period: number): number {
    let sum = 0;
    for (let i = 0; i < period; i++) {
      sum += this.api.Close(index + i);
    }
    return sum / period;
  }

  private calculateStdDev(index: number, period: number, mean: number): number {
    let sum = 0;
    for (let i = 0; i < period; i++) {
      const diff = this.api.Close(index + i) - mean;
      sum += diff * diff;
    }
    return Math.sqrt(sum / period);
  }
}
```

--------------------------------

### Initialize Indicator Parameters and Buffers (TypeScript)

Source: https://context7.com/context7/fto-2_gitbook_io_fto-indicators-docs/llms.txt

The Init() method is called once when an indicator is loaded. It sets up configurable parameters, registers them for the UI, defines indicator properties like name and output window, and configures data buffers for calculations. Dependencies include the API object for creating and managing options, buffers, and indicator settings. It returns void.

```typescript
public Init(): void {
  // 1. Create and register parameters
  this.fastPeriod = this.api.createTOptValue_number(12);
  this.slowPeriod = this.api.createTOptValue_number(26);
  this.showLine = this.api.createTOptValue_bool(true);
  this.lineColor = this.api.createTOptValue_str("#0000FF");

  // Register parameters (makes them appear in indicator settings UI)
  this.api.RegOption("Fast Period", TOptionType.INTEGER, this.fastPeriod);
  this.api.SetOptionRange("Fast Period", 1, 200);

  this.api.RegOption("Slow Period", TOptionType.INTEGER, this.slowPeriod);
  this.api.SetOptionRange("Slow Period", 1, 200);

  this.api.RegOption("Show Line", TOptionType.BOOLEAN, this.showLine);

  // Register dropdown parameter with values
  this.api.RegOption("Line Color", TOptionType.ENUM_TYPE, this.lineColor);
  this.api.AddOptionValue("Line Color", "Red");
  this.api.AddOptionValue("Line Color", "Blue");
  this.api.AddOptionValue("Line Color", "Green");

  // 2. Set indicator properties
  this.api.IndicatorShortName("Dual MA Oscillator");
  this.api.SetOutputWindow(TOutputWindow.SEPARATE_WINDOW);
  this.api.RecalculateMeAlways();
  this.api.SetEmptyValue(0);
  this.api.IndicatorDigits(5);

  // 3. Create and configure buffers (must call IndicatorBuffers first)
  this.api.IndicatorBuffers(2);

  this.fastBuffer = this.api.CreateIndexBuffer();
  this.slowBuffer = this.api.CreateIndexBuffer();

  this.api.SetIndexBuffer(0, this.fastBuffer);
  this.api.SetIndexBuffer(1, this.slowBuffer);

  this.api.SetIndexLabel(0, "Fast MA");
  this.api.SetIndexLabel(1, "Slow MA");

  this.api.SetIndexStyle(0, TDrawStyle.LINE, TPenStyle.SOLID, 1, "#FF0000");
  this.api.SetIndexStyle(1, TDrawStyle.LINE, TPenStyle.DASH, 1, "#0000FF");

  this.api.SetIndexDrawBegin(0, this.fastPeriod.value);
  this.api.SetIndexDrawBegin(1, this.slowPeriod.value);

  // 4. Add reference levels for oscillator
  this.api.AddLevel(0);
  this.api.SetLevelValue(0, 0);
}
```
Tokens:
Raw