Class Chart

Hierarchy (View Summary)

ChartbreakerObject<Chart_Events>
- Chart

Constructors

constructor

new Chart(
chartSet: ChartSet,
legendEntryOrderFn: (a: LegendEntry, b: LegendEntry) => number,
): Chart
This class implements two dimensional chart with one X-Axis, and one or more Y-Axes (represented by Scale). Charts are always contained inside a ChartSet where they share the same X-Axis.

The chart object is mainly responsible for event handling, and managing a set of tools (Tool), layers (Layers), and legend entries (LegendEntry).

Depending on the type of displayed layers, the X-Axis can be synced/locked to one or more Y-Axis, meaning that manipulating the scale of either will also affect the other. For example, this is used in Point and Figure charts, to ensure a constant aspect ratio.
Parameters
- chartSet: ChartSet
- legendEntryOrderFn: (a: LegendEntry, b: LegendEntry) => number
Returns Chart
Overrides ChartbreakerObject.constructor

Properties

`Optional` `Readonly`events

events?: Chart_Events & Object_Events

Description

Phantom data for type inference

optionGroups

optionGroups: undefined | ObjectOptionGroup[]

`Protected`options

options: { [key: string]: any }

`Static`options

options: {
    axisTextSize: {
        flags: ObjectEOptionFlags;
        name: string;
        type: { default: string; large: string; veryLarge: string };
        _get(this: Chart): "default" | "large" | "veryLarge";
        _set(this: Chart, v: "default" | "large" | "veryLarge"): void;
    };
    crosshairColor: {
        flags: number;
        name: string;
        type: string;
        _get(this: Chart): any;
        _set(this: Chart, v: string): void;
    };
    crosshairLines: {
        flags: ObjectEOptionFlags;
        name: string;
        type: string;
        _get(this: Chart): boolean;
        _set(this: Chart, v: boolean): void;
    };
    crosshairStyle: {
        _get: (this: Chart) => ELineStyle;
        _set: (this: Chart, value: ELineStyle) => void;
        flags: ObjectEOptionFlags;
        name: string;
        type: Record<ELineStyle, string>;
    };
    crosshairWidth: {
        _get: (this: Chart) => LineWidth;
        _set: (this: Chart, value: LineWidth) => void;
        flags: ObjectEOptionFlags;
        name: string;
        type: Record<LineWidth, string>;
    };
    grid: {
        flags: ObjectEOptionFlags;
        name: string;
        type: string;
        _get(this: Chart): boolean;
        _set(this: Chart, v: boolean): void;
    };
    height: {
        type: string;
        _get(this: Chart): number;
        _set(this: Chart, v: number): void;
    };
    legendStyle: {
        flags: ObjectEOptionFlags;
        name: string;
        type: { horizontal: string; none: string; vertical: string };
        _get(this: Chart): any;
        _set(this: Chart, v: string): void;
    };
    legendValue: {
        flags: ObjectEOptionFlags;
        name: string;
        type: string;
        value: boolean;
    };
    markers: {
        flags: ObjectEOptionFlags;
        name: string;
        type: string;
        value: boolean;
        _get(this: Chart): any;
        _set(this: Chart, v: boolean): void;
    };
    messageEmpty: {
        type: string;
        _get(this: Chart): string;
        _set(this: Chart, v: string): void;
    };
    resetCrosshairStyle: {
        flags: number;
        name: string;
        type: string;
        _set(this: Chart): void;
    };
    sessionBreaks: {
        flags: ObjectEOptionFlags;
        name: string;
        type: string;
        _get(this: Chart): boolean;
        _set(this: Chart, v: boolean): void;
    };
    sessionBreaksColor: {
        flags: number;
        name: string;
        type: string;
        _get(this: Chart): any;
        _set(this: Chart, v: string): void;
    };
    sessionBreaksStyle: {
        _get: (this: Chart) => ELineStyle;
        _set: (this: Chart, value: ELineStyle) => void;
        flags: ObjectEOptionFlags;
        name: string;
        type: Record<ELineStyle, string>;
    };
    sessionBreaksWidth: {
        _get: (this: Chart) => LineWidth;
        _set: (this: Chart, value: LineWidth) => void;
        flags: ObjectEOptionFlags;
        name: string;
        type: Record<LineWidth, string>;
    };
    styleId: {
        type: string;
        _get(this: Chart): string;
        _set(this: Chart, v: string): void;
    };
    tapelineShowDeltaIndex: {
        flags: ObjectEOptionFlags;
        name: string;
        type: string;
        value: boolean;
        _get(this: Chart): any;
        _set(this: Chart, v: number): void;
    };
    tapelineShowDeltaValue: {
        flags: ObjectEOptionFlags;
        name: string;
        type: string;
        value: boolean;
        _get(this: Chart): any;
        _set(this: Chart, v: number): void;
    };
    tapelineShowPercentDiff: {
        flags: ObjectEOptionFlags;
        name: string;
        type: string;
        value: boolean;
        _get(this: Chart): any;
        _set(this: Chart, v: number): void;
    };
    tapelineShowSpeed: {
        flags: ObjectEOptionFlags;
        name: string;
        type: string;
        value: boolean;
        _get(this: Chart): any;
        _set(this: Chart, v: number): void;
    };
    xAxisBottomStyle: {
        type: { default: string; none: string; ticks: string };
        _get(this: Chart): any;
    };
    xAxisTopStyle: {
        type: { default: string; none: string; ticks: string };
        _get(this: Chart): any;
    };
}

Type Declaration

axisTextSize: {
    flags: ObjectEOptionFlags;
    name: string;
    type: { default: string; large: string; veryLarge: string };
    _get(this: Chart): "default" | "large" | "veryLarge";
    _set(this: Chart, v: "default" | "large" | "veryLarge"): void;
}
crosshairColor: {
    flags: number;
    name: string;
    type: string;
    _get(this: Chart): any;
    _set(this: Chart, v: string): void;
}
crosshair lines color

Cfg
crosshairColor
crosshairLines: {
    flags: ObjectEOptionFlags;
    name: string;
    type: string;
    _get(this: Chart): boolean;
    _set(this: Chart, v: boolean): void;
}
enable/disable the crosshair lines

Cfg
crosshairLines
crosshairStyle: {
    _get: (this: Chart) => ELineStyle;
    _set: (this: Chart, value: ELineStyle) => void;
    flags: ObjectEOptionFlags;
    name: string;
    type: Record<ELineStyle, string>;
}
line style. Valid values:
- ** 0 ** Normal
- ** 1 ** Dotted
- ** 2 ** Dashed
Cfg
crosshairStyle
crosshairWidth: {
    _get: (this: Chart) => LineWidth;
    _set: (this: Chart, value: LineWidth) => void;
    flags: ObjectEOptionFlags;
    name: string;
    type: Record<LineWidth, string>;
}
width of the crosshair lines in pixels. Valid values:
- ** 1 ** Thin
- ** 2 ** Normal
- ** 3 ** Thick
- ** 4 ** Thicker
Cfg
crosshairWidth
grid: {
    flags: ObjectEOptionFlags;
    name: string;
    type: string;
    _get(this: Chart): boolean;
    _set(this: Chart, v: boolean): void;
}
enable/disable the grid lines in the background

Cfg
grid
height: { type: string; _get(this: Chart): number; _set(this: Chart, v: number): void }
controls the height of the chart

Cfg
height
legendStyle: {
    flags: ObjectEOptionFlags;
    name: string;
    type: { horizontal: string; none: string; vertical: string };
    _get(this: Chart): any;
    _set(this: Chart, v: string): void;
}
enable/disable the legend
- ** 0 ** None
- ** 1 ** Horizontal
- ** 1 ** Vertical
Cfg
legendStyle
legendValue: { flags: ObjectEOptionFlags; name: string; type: string; value: boolean }
controls if the most recent value of a timeseries is displayed in its respective legend entry

Cfg
legendValue
markers: {
    flags: ObjectEOptionFlags;
    name: string;
    type: string;
    value: boolean;
    _get(this: Chart): any;
    _set(this: Chart, v: boolean): void;
}
messageEmpty: { type: string; _get(this: Chart): string; _set(this: Chart, v: string): void }
an error message that is displayed when no data is available

Cfg
messageEmpty
resetCrosshairStyle: { flags: number; name: string; type: string; _set(this: Chart): void }
sessionBreaks: {
    flags: ObjectEOptionFlags;
    name: string;
    type: string;
    _get(this: Chart): boolean;
    _set(this: Chart, v: boolean): void;
}
enable/disable the session break lines in the background

Cfg
sessionBreaks
sessionBreaksColor: {
    flags: number;
    name: string;
    type: string;
    _get(this: Chart): any;
    _set(this: Chart, v: string): void;
}
session break lines color

Cfg
sessionBreaksColor
sessionBreaksStyle: {
    _get: (this: Chart) => ELineStyle;
    _set: (this: Chart, value: ELineStyle) => void;
    flags: ObjectEOptionFlags;
    name: string;
    type: Record<ELineStyle, string>;
}
line style. Valid values:
- ** 0 ** Normal
- ** 1 ** Dotted
- ** 2 ** Dashed
Cfg
sessionBreaksStyle
sessionBreaksWidth: {
    _get: (this: Chart) => LineWidth;
    _set: (this: Chart, value: LineWidth) => void;
    flags: ObjectEOptionFlags;
    name: string;
    type: Record<LineWidth, string>;
}
width of the session break lines in pixels. Valid values:
- ** 1 ** Thin
- ** 2 ** Normal
- ** 3 ** Thick
- ** 4 ** Thicker
Cfg
sessionBreaksWidth
styleId: { type: string; _get(this: Chart): string; _set(this: Chart, v: string): void }
a style id

Cfg
styleId
tapelineShowDeltaIndex: {
    flags: ObjectEOptionFlags;
    name: string;
    type: string;
    value: boolean;
    _get(this: Chart): any;
    _set(this: Chart, v: number): void;
}
whether to display the difference between start and end indices when the tapeline is active
tapelineShowDeltaValue: {
    flags: ObjectEOptionFlags;
    name: string;
    type: string;
    value: boolean;
    _get(this: Chart): any;
    _set(this: Chart, v: number): void;
}
whether to display the difference between start and end values when the tapeline is active
tapelineShowPercentDiff: {
    flags: ObjectEOptionFlags;
    name: string;
    type: string;
    value: boolean;
    _get(this: Chart): any;
    _set(this: Chart, v: number): void;
}
whether to display the percentage difference between start and end points when the tapeline is active
tapelineShowSpeed: {
    flags: ObjectEOptionFlags;
    name: string;
    type: string;
    value: boolean;
    _get(this: Chart): any;
    _set(this: Chart, v: number): void;
}
whether to display the speed calculation when the tapeline is active
xAxisBottomStyle: {
type: { default: string; none: string; ticks: string };
_get(this: Chart): any;
}
controls the style of the bottom xAxis Valid values:
- ** none **
- ** ticks **
- ** default **
Cfg
xAxisBottomStyle
xAxisTopStyle: {
type: { default: string; none: string; ticks: string };
_get(this: Chart): any;
}
controls the style of the top xAxis Valid values:
- ** none **
- ** ticks **
- ** default **
Cfg
xAxisTopStyle

Methods

addListener

addListener<
    Type extends (keyof Chart_Events)
    | (keyof Object_Events),
    Callback extends

            | (
                (
                    optionName: string,
                    attributeName: string,
                    oldValue: any,
                    newValue: any,
                ) => void
            )
            | ((optionName: string, oldValue?: any, newValue?: any) => void)
            | ((state: ObjectState, flags: ObjectStateEFlags) => void)
            | (() => void)
            | (
                (
                    object:
                        | null
                        | ChartbreakerObject<Record<string, (...args: any) => void>>,
                ) => void
            )
            | ((hovered: null | boolean | LegendEntry) => void)
            | (
                (
                    event: null | Event,
                    point: Point,
                    objects: ChartbreakerObject<Record<string, (...args: any) => void>>[],
                    chart: Chart,
                ) => void
            )
            | (
                (
                    event: null | Event,
                    point: Point,
                    object: ChartbreakerObject,
                ) => void
            )
            | ((tool: Tool) => void)
            | ((scale: Scale) => void)
            | ((scale: Scale) => void)
            | (() => void)
            | (
                (
                    objects:
                        | null
                        | ChartbreakerObject<Record<string, (...args: any) => void>>[],
                ) => void
            )
            | (() => void),
>(
    type: Type,
    listener: Callback,
): this
Type Parameters
- Type extends (keyof Chart_Events) | (keyof Object_Events)
- Callback extends
      | (
          (
              optionName: string,
              attributeName: string,
              oldValue: any,
              newValue: any,
          ) => void
      )
      | ((optionName: string, oldValue?: any, newValue?: any) => void)
      | ((state: ObjectState, flags: ObjectStateEFlags) => void)
      | (() => void)
      | (
          (
              object:
                  | null
                  | ChartbreakerObject<Record<string, (...args: any) => void>>,
          ) => void
      )
      | ((hovered: null | boolean | LegendEntry) => void)
      | (
          (
              event: null | Event,
              point: Point,
              objects: ChartbreakerObject<Record<string, (...args: any) => void>>[],
              chart: Chart,
          ) => void
      )
      | ((event: null | Event, point: Point, object: ChartbreakerObject) => void)
      | ((tool: Tool) => void)
      | ((scale: Scale) => void)
      | ((scale: Scale) => void)
      | (() => void)
      | (
          (
              objects:
                  | null
                  | ChartbreakerObject<Record<string, (...args: any) => void>>[],
          ) => void
      )
      | (() => void)
Parameters
- type: Type
- listener: Callback
Returns this
Description
adds a listener to the end of the listeners array for the specified event.

Inherited from ChartbreakerObject.addListener

attr

attr(this: ChartbreakerObject, s: string, a: string, v?: any): any
returns or sets the attribute of an option this function should be used with care - modifications of internal properties might break stuff!
Parameters
- this: ChartbreakerObject
- s: string
- a: string
- Optionalv: any
Returns any
Inherited from ChartbreakerObject.attr

didUpdateOptions

didUpdateOptions(this: ChartbreakerObject): void
must be called after willUpdateOptions once all actions that might potentially changed values of any options are done

IMPORTANT: methods must be called in balance; e.g. for each call to willUpdateOptions, you must call didUpdateOptions exactly once.
Parameters
- this: ChartbreakerObject
Returns void
Inherited from ChartbreakerObject.didUpdateOptions

drawHorizontalMarker

drawHorizontalMarker(
    index: number,
    color: string,
    order?: number,
    important?: boolean,
): void
draw a horizontal marker this method should only be called while the chart is redrawing (e.g. from a tools draw routine)

if the important parameter is set to true, marker is also drawn when xAxis is not visible
Parameters
- index: number
- color: string
- Optionalorder: number
- Optionalimportant: boolean
Returns void

drawTooltip

drawTooltip(x: number, y: number, w: number, h: number, text: string): void
draw a tooltip with originating from the supplied rectangle,
Parameters
- x: number
  upper left x coordinate
- y: number
  upper left y coordinate
- w: number
  width of rectangle
- h: number
  height of rectangle
- text: string
Returns void

drawVerticalMarker

drawVerticalMarker(marker: Omit<Scale_Marker, "textColor">): void
draw a vertical marker with the specified property this method should only be called while the chart is redrawing (e.g. from a tools draw routine)

if the important parameter is set to true, marker is also drawn when xAxis is not visible
Parameters
- marker: Omit<Scale_Marker, "textColor">
Returns void

emit

emit<
    Type extends (keyof Chart_Events)
    | (keyof Object_Events),
    Callback extends

            | (
                (
                    optionName: string,
                    attributeName: string,
                    oldValue: any,
                    newValue: any,
                ) => void
            )
            | ((optionName: string, oldValue?: any, newValue?: any) => void)
            | ((state: ObjectState, flags: ObjectStateEFlags) => void)
            | (() => void)
            | (
                (
                    object:
                        | null
                        | ChartbreakerObject<Record<string, (...args: any) => void>>,
                ) => void
            )
            | ((hovered: null | boolean | LegendEntry) => void)
            | (
                (
                    event: null | Event,
                    point: Point,
                    objects: ChartbreakerObject<Record<string, (...args: any) => void>>[],
                    chart: Chart,
                ) => void
            )
            | (
                (
                    event: null | Event,
                    point: Point,
                    object: ChartbreakerObject,
                ) => void
            )
            | ((tool: Tool) => void)
            | ((scale: Scale) => void)
            | ((scale: Scale) => void)
            | (() => void)
            | (
                (
                    objects:
                        | null
                        | ChartbreakerObject<Record<string, (...args: any) => void>>[],
                ) => void
            )
            | (() => void),
>(
    type: Type,
    ...params: Parameters<Callback>,
): boolean
Type Parameters
- Type extends (keyof Chart_Events) | (keyof Object_Events)
- Callback extends
      | (
          (
              optionName: string,
              attributeName: string,
              oldValue: any,
              newValue: any,
          ) => void
      )
      | ((optionName: string, oldValue?: any, newValue?: any) => void)
      | ((state: ObjectState, flags: ObjectStateEFlags) => void)
      | (() => void)
      | (
          (
              object:
                  | null
                  | ChartbreakerObject<Record<string, (...args: any) => void>>,
          ) => void
      )
      | ((hovered: null | boolean | LegendEntry) => void)
      | (
          (
              event: null | Event,
              point: Point,
              objects: ChartbreakerObject<Record<string, (...args: any) => void>>[],
              chart: Chart,
          ) => void
      )
      | ((event: null | Event, point: Point, object: ChartbreakerObject) => void)
      | ((tool: Tool) => void)
      | ((scale: Scale) => void)
      | ((scale: Scale) => void)
      | (() => void)
      | (
          (
              objects:
                  | null
                  | ChartbreakerObject<Record<string, (...args: any) => void>>[],
          ) => void
      )
      | (() => void)
Parameters
- type: Type
- ...params: Parameters<Callback>
Returns boolean
Description
execute each of the listeners in order with the supplied parameters.

Inherited from ChartbreakerObject.emit

flat

flat(
    readWriteOnly?: boolean,
    modifiedOnly?: boolean,
    nonEphemeralOnly?: boolean,
): { [key: string]: any }
returns a flat representation of all available config options in the form of a key-value-object optionally only values that are not read-only can be returned

IMPORTANT: this method will always convert I18NStrings to strings, so for displaying strings in a UI use individual calls to Object:get instead
Parameters
- OptionalreadWriteOnly: boolean
  default: true
- OptionalmodifiedOnly: boolean
  default: true
- OptionalnonEphemeralOnly: boolean
  default: true
Returns { [key: string]: any }
Inherited from ChartbreakerObject.flat

focusTool

focusTool(
    tool:
        | null
        | Tool<Record<string, unknown>, Record<string, (...args: any) => void>>,
): void
focus the specified tool; on the next input event, the tools handleEvent function will be called
Parameters
- tool: null | Tool<Record<string, unknown>, Record<string, (...args: any) => void>>
Returns void

get

get(s?: string, flags?: number): any
returns the value of the requested option, or a list of all available config options if no parameter is specified.
Parameters
- Optionals: string
- Optionalflags: number
Returns any
Inherited from ChartbreakerObject.get

getBounds

getBounds(scale?: number): undefined | null | Bounds
returns the bounds of the values currently displayed by this chart
Parameters
- Optionalscale: number
Returns undefined | null | Bounds

getChartSet

getChartSet(): ChartSet
returns the parent ChartSet object

Returns ChartSet

getGroups

getGroups(): ObjectOptionGroup[]
returns the categorization of the objects options can be used for displaying a more structured user interface

Returns ObjectOptionGroup[]
Inherited from ChartbreakerObject.getGroups

getIdentifierByIndex

getIdentifierByIndex(index: number): number
returns the identifier for the specified index
Parameters
- index: number
  a valid index
Returns number
the identifier

getIndex

getIndex(x: number): number
returns the index for the specified x coordinate
Parameters
- x: number
  the x coordinate in pixels
Returns number
the index

getIndexByIdentifier

getIndexByIdentifier(identifier: number): number
returns the identifier for the specified index
Parameters
- identifier: number
  a valid identifier
Returns number
the index

getOffsetByIndex

getOffsetByIndex(index: number): number
returns the numeric offset for the specified index will only be non-zero if the timestamp at the specified index is not distinct

offset should be used in combination with the return value of getIdentifierByIndex
Parameters
- index: number
  an index
Returns number
numeric offset

getPlotArea

getPlotArea(): Bounds
returns the bounds of the charts plot area

Returns Bounds

getPlotAreaInsets

getPlotAreaInsets(): EdgeInsets
returns the inset values for all plot area edges plugins or tools should not draw any interactive elements within these areas

Returns EdgeInsets

getReferenceOHLCInput

getReferenceOHLCInput(): null | DataTOHLCSet
returns the reference ohlc input or null if not available

Returns null | DataTOHLCSet

getScale

getScale(id?: number): null | Scale
retrieve custom y scale identified by specified id
Parameters
- Optionalid: number
Returns null | Scale

getState

getState(): ObjectState
returns the objects current state

Returns ObjectState
Inherited from ChartbreakerObject.getState

getStyle

getStyle(): ObjectStyle
return the style object

Returns ObjectStyle

getTickWidth

getTickWidth(): number
returns the tick width of this chart

Returns number

getValue

getValue(y: number, scale?: number): number
returns the value for the specified y coordinate
Parameters
- y: number
  the y coordinate in pixels
- Optionalscale: number
Returns number
the value in chart units

getX

getX(index: number): number
returns the x coordinate for the specified index
Parameters
- index: number
  the index
Returns number
x coordinate in pixels

getY

getY(value: number, scale?: number): number
returns the y coordinate for the specified value
Parameters
- value: number
  the value in chart units
- Optionalscale: number
Returns number
y coordinate in pixels

handleOptionDependencyVisibility

handleOptionDependencyVisibility(
optionDependencies: OptionExposureRelations,
): void
Automatically toggles the EXPOSED flag on dependent options when a 'parent' option changes value.

For each entry in optionDependencies, whenever the parent option emits an optionChanged event, its dependents (listed in dependentNames) will be exposed (flag added) if the new value === exposeWhen, or hidden (flag removed) otherwise.
Parameters
- optionDependencies: OptionExposureRelations
  Map where:
  
  key = name of the 'parent' option to watch
  
  value = an object with:
  
  exposeWhen: the boolean that triggers exposing the dependents or a function with the newValue for custom validation
  
  dependentNames: array of dependent option names whose EXPOSED flag will be toggled
Returns void
Example
```
class Test extends ChartbreakerObject {
  constructor() {
    super();
    this.registerOptionDependencyVisibility(new Map([
      ['showLine', { exposeWhen: true,   dependentNames: ['lineColor', 'lineStyle'] }],
      ['advancedMode', { exposeWhen: false, dependentNames: ['simpleModeOnlyOption'] }],
          ['description'], { exposeWhen: (text) => !!text.length, ['fontSize', 'fontColor']}
    ]));
  }
}
```
Inherited from ChartbreakerObject.handleOptionDependencyVisibility

isHighlighted

isHighlighted(object: ChartbreakerObject): boolean
Parameters
- object: ChartbreakerObject
Returns boolean

listeners

listeners<
    Type extends (keyof Chart_Events)
    | (keyof Object_Events),
    Callback extends

            | (
                (
                    optionName: string,
                    attributeName: string,
                    oldValue: any,
                    newValue: any,
                ) => void
            )
            | ((optionName: string, oldValue?: any, newValue?: any) => void)
            | ((state: ObjectState, flags: ObjectStateEFlags) => void)
            | (() => void)
            | (
                (
                    object:
                        | null
                        | ChartbreakerObject<Record<string, (...args: any) => void>>,
                ) => void
            )
            | ((hovered: null | boolean | LegendEntry) => void)
            | (
                (
                    event: null | Event,
                    point: Point,
                    objects: ChartbreakerObject<Record<string, (...args: any) => void>>[],
                    chart: Chart,
                ) => void
            )
            | (
                (
                    event: null | Event,
                    point: Point,
                    object: ChartbreakerObject,
                ) => void
            )
            | ((tool: Tool) => void)
            | ((scale: Scale) => void)
            | ((scale: Scale) => void)
            | (() => void)
            | (
                (
                    objects:
                        | null
                        | ChartbreakerObject<Record<string, (...args: any) => void>>[],
                ) => void
            )
            | (() => void),
>(
    type: Type,
): Callback[]
Type Parameters
- Type extends (keyof Chart_Events) | (keyof Object_Events)
- Callback extends
      | (
          (
              optionName: string,
              attributeName: string,
              oldValue: any,
              newValue: any,
          ) => void
      )
      | ((optionName: string, oldValue?: any, newValue?: any) => void)
      | ((state: ObjectState, flags: ObjectStateEFlags) => void)
      | (() => void)
      | (
          (
              object:
                  | null
                  | ChartbreakerObject<Record<string, (...args: any) => void>>,
          ) => void
      )
      | ((hovered: null | boolean | LegendEntry) => void)
      | (
          (
              event: null | Event,
              point: Point,
              objects: ChartbreakerObject<Record<string, (...args: any) => void>>[],
              chart: Chart,
          ) => void
      )
      | ((event: null | Event, point: Point, object: ChartbreakerObject) => void)
      | ((tool: Tool) => void)
      | ((scale: Scale) => void)
      | ((scale: Scale) => void)
      | (() => void)
      | (
          (
              objects:
                  | null
                  | ChartbreakerObject<Record<string, (...args: any) => void>>[],
          ) => void
      )
      | (() => void)
Parameters
- type: Type
Returns Callback[]
Description
returns an array of listeners for the specified event.

Inherited from ChartbreakerObject.listeners

on

on<
    Type extends (keyof Chart_Events)
    | (keyof Object_Events),
    Callback extends

            | (
                (
                    optionName: string,
                    attributeName: string,
                    oldValue: any,
                    newValue: any,
                ) => void
            )
            | ((optionName: string, oldValue?: any, newValue?: any) => void)
            | ((state: ObjectState, flags: ObjectStateEFlags) => void)
            | (() => void)
            | (
                (
                    object:
                        | null
                        | ChartbreakerObject<Record<string, (...args: any) => void>>,
                ) => void
            )
            | ((hovered: null | boolean | LegendEntry) => void)
            | (
                (
                    event: null | Event,
                    point: Point,
                    objects: ChartbreakerObject<Record<string, (...args: any) => void>>[],
                    chart: Chart,
                ) => void
            )
            | (
                (
                    event: null | Event,
                    point: Point,
                    object: ChartbreakerObject,
                ) => void
            )
            | ((tool: Tool) => void)
            | ((scale: Scale) => void)
            | ((scale: Scale) => void)
            | (() => void)
            | (
                (
                    objects:
                        | null
                        | ChartbreakerObject<Record<string, (...args: any) => void>>[],
                ) => void
            )
            | (() => void),
>(
    type: Type,
    listener: Callback,
): this
Type Parameters
- Type extends (keyof Chart_Events) | (keyof Object_Events)
- Callback extends
      | (
          (
              optionName: string,
              attributeName: string,
              oldValue: any,
              newValue: any,
          ) => void
      )
      | ((optionName: string, oldValue?: any, newValue?: any) => void)
      | ((state: ObjectState, flags: ObjectStateEFlags) => void)
      | (() => void)
      | (
          (
              object:
                  | null
                  | ChartbreakerObject<Record<string, (...args: any) => void>>,
          ) => void
      )
      | ((hovered: null | boolean | LegendEntry) => void)
      | (
          (
              event: null | Event,
              point: Point,
              objects: ChartbreakerObject<Record<string, (...args: any) => void>>[],
              chart: Chart,
          ) => void
      )
      | ((event: null | Event, point: Point, object: ChartbreakerObject) => void)
      | ((tool: Tool) => void)
      | ((scale: Scale) => void)
      | ((scale: Scale) => void)
      | (() => void)
      | (
          (
              objects:
                  | null
                  | ChartbreakerObject<Record<string, (...args: any) => void>>[],
          ) => void
      )
      | (() => void)
Parameters
- type: Type
- listener: Callback
Returns this
Description
alias for addListener

Inherited from ChartbreakerObject.on

once

once<
    Type extends (keyof Chart_Events)
    | (keyof Object_Events),
    Callback extends

            | (
                (
                    optionName: string,
                    attributeName: string,
                    oldValue: any,
                    newValue: any,
                ) => void
            )
            | ((optionName: string, oldValue?: any, newValue?: any) => void)
            | ((state: ObjectState, flags: ObjectStateEFlags) => void)
            | (() => void)
            | (
                (
                    object:
                        | null
                        | ChartbreakerObject<Record<string, (...args: any) => void>>,
                ) => void
            )
            | ((hovered: null | boolean | LegendEntry) => void)
            | (
                (
                    event: null | Event,
                    point: Point,
                    objects: ChartbreakerObject<Record<string, (...args: any) => void>>[],
                    chart: Chart,
                ) => void
            )
            | (
                (
                    event: null | Event,
                    point: Point,
                    object: ChartbreakerObject,
                ) => void
            )
            | ((tool: Tool) => void)
            | ((scale: Scale) => void)
            | ((scale: Scale) => void)
            | (() => void)
            | (
                (
                    objects:
                        | null
                        | ChartbreakerObject<Record<string, (...args: any) => void>>[],
                ) => void
            )
            | (() => void),
>(
    type: Type,
    listener: Callback,
): this
Type Parameters
- Type extends (keyof Chart_Events) | (keyof Object_Events)
- Callback extends
      | (
          (
              optionName: string,
              attributeName: string,
              oldValue: any,
              newValue: any,
          ) => void
      )
      | ((optionName: string, oldValue?: any, newValue?: any) => void)
      | ((state: ObjectState, flags: ObjectStateEFlags) => void)
      | (() => void)
      | (
          (
              object:
                  | null
                  | ChartbreakerObject<Record<string, (...args: any) => void>>,
          ) => void
      )
      | ((hovered: null | boolean | LegendEntry) => void)
      | (
          (
              event: null | Event,
              point: Point,
              objects: ChartbreakerObject<Record<string, (...args: any) => void>>[],
              chart: Chart,
          ) => void
      )
      | ((event: null | Event, point: Point, object: ChartbreakerObject) => void)
      | ((tool: Tool) => void)
      | ((scale: Scale) => void)
      | ((scale: Scale) => void)
      | (() => void)
      | (
          (
              objects:
                  | null
                  | ChartbreakerObject<Record<string, (...args: any) => void>>[],
          ) => void
      )
      | (() => void)
Parameters
- type: Type
- listener: Callback
Returns this
Description
adds a one time listener for the event. This listener is invoked only the next time the event is fired, after which it is removed.

Inherited from ChartbreakerObject.once

onDestroy

onDestroy(): void
called when an object will be permanently discarded no other methods will be called on it ever again after this point

IMPORTANT: this method should ONLY be called directly on the Controller all other objects will be destroyed automatically by the implementation

Returns void
Overridable
Inherited from ChartbreakerObject.onDestroy

onRecover

onRecover(): void
life cycle method; called when the object should recover from an error and resume normal operation

this will only be called if the object encountered a RecoverableChartbreakerError, and is always triggered by a manual user interaction

always called between start and stop

Returns void
Overridable
Inherited from ChartbreakerObject.onRecover

onStart

onStart(context: TContext): void
life cycle method; called when the object should start normal operation at this point is is already completely initialized
Parameters
- context: TContext
Returns void
Overridable
Overrides ChartbreakerObject.onStart

onStop

onStop(): void
life cycle method; called when the object should stop normal operation if objects have any pending subscriptions/requests, they should all be stopped here

the object is also responsible for clearing the loading flag from it's state if it is currently active failing to do so will trigger a fatal error

object might be started again afterwards (start) or destroyed (destroy) this is not known yet at this point

called after start or restart

Returns void
Overridable
Inherited from ChartbreakerObject.onStop

recover

recover(): boolean
can be called to tell the object that it should recover from an error and resume will have no effect if no retryable error is currently associated with the object

Returns boolean
Inherited from ChartbreakerObject.recover

removeAllListeners

removeAllListeners<Type extends (keyof Chart_Events) | (keyof Object_Events)>(
type?: Type,
): this
Type Parameters
- Type extends (keyof Chart_Events) | (keyof Object_Events)
Parameters
- Optionaltype: Type
Returns this
Description
removes all listeners, or those of the specified event.

Inherited from ChartbreakerObject.removeAllListeners

removeListener

removeListener<
    Type extends (keyof Chart_Events)
    | (keyof Object_Events),
    Callback extends

            | (
                (
                    optionName: string,
                    attributeName: string,
                    oldValue: any,
                    newValue: any,
                ) => void
            )
            | ((optionName: string, oldValue?: any, newValue?: any) => void)
            | ((state: ObjectState, flags: ObjectStateEFlags) => void)
            | (() => void)
            | (
                (
                    object:
                        | null
                        | ChartbreakerObject<Record<string, (...args: any) => void>>,
                ) => void
            )
            | ((hovered: null | boolean | LegendEntry) => void)
            | (
                (
                    event: null | Event,
                    point: Point,
                    objects: ChartbreakerObject<Record<string, (...args: any) => void>>[],
                    chart: Chart,
                ) => void
            )
            | (
                (
                    event: null | Event,
                    point: Point,
                    object: ChartbreakerObject,
                ) => void
            )
            | ((tool: Tool) => void)
            | ((scale: Scale) => void)
            | ((scale: Scale) => void)
            | (() => void)
            | (
                (
                    objects:
                        | null
                        | ChartbreakerObject<Record<string, (...args: any) => void>>[],
                ) => void
            )
            | (() => void),
>(
    type: Type,
    listener: Callback,
): this
Type Parameters
- Type extends (keyof Chart_Events) | (keyof Object_Events)
- Callback extends
      | (
          (
              optionName: string,
              attributeName: string,
              oldValue: any,
              newValue: any,
          ) => void
      )
      | ((optionName: string, oldValue?: any, newValue?: any) => void)
      | ((state: ObjectState, flags: ObjectStateEFlags) => void)
      | (() => void)
      | (
          (
              object:
                  | null
                  | ChartbreakerObject<Record<string, (...args: any) => void>>,
          ) => void
      )
      | ((hovered: null | boolean | LegendEntry) => void)
      | (
          (
              event: null | Event,
              point: Point,
              objects: ChartbreakerObject<Record<string, (...args: any) => void>>[],
              chart: Chart,
          ) => void
      )
      | ((event: null | Event, point: Point, object: ChartbreakerObject) => void)
      | ((tool: Tool) => void)
      | ((scale: Scale) => void)
      | ((scale: Scale) => void)
      | (() => void)
      | (
          (
              objects:
                  | null
                  | ChartbreakerObject<Record<string, (...args: any) => void>>[],
          ) => void
      )
      | (() => void)
Parameters
- type: Type
- listener: Callback
Returns this
Description
remove a listener from the listener array for the specified event.

Inherited from ChartbreakerObject.removeListener

set

set(
    this: ChartbreakerObject,
    s: null | string | { [key: string]: any },
    v?: any,
    flags?: ObjectEFlags,
): boolean
will set validate and then set the specified option(s) to the provided value(s) after validation

NOTE: if multiple options are used, will return false if at least one value is not valid values are applied individually however, so one option might be set even if the value for another is invalid
Parameters
- this: ChartbreakerObject
- s: null | string | { [key: string]: any }
- Optionalv: any
- Optionalflags: ObjectEFlags
Returns boolean
Inherited from ChartbreakerObject.set

setHighlightButtons

setHighlightButtons(buttons: string[]): void
highlight the specified buttons
Parameters
- buttons: string[]
Returns void

setMaxListeners

setMaxListeners(maxListeners: number): this
Parameters
- maxListeners: number
Returns this
Description
by default EventEmitters will print a warning if more than 10 listeners are added for a particular event. This is a useful default which helps finding memory leaks. Obviously not all Emitters should be limited to 10. This function allows that limit to be increased. Set to zero for unlimited.

Inherited from ChartbreakerObject.setMaxListeners

setTypeAndName

setTypeAndName(objType?: string, objName?: string): void
Sets the objName and objType of the Object reverts to the default ones if no arguments are given
Parameters
- OptionalobjType: string
- OptionalobjName: string
Returns void
Inherited from ChartbreakerObject.setTypeAndName

snap

snap(point: Point, range: number): false | Point
snap point to the nearest value of interest
Parameters
- point: Point
  the point to be snapped
- range: number
  the maximum allowed distance from the nearest value
Returns false | Point
false if the point was not snappoed, otherwise the snapped Point

toString

toString(): string
Returns a string representation of an object.

Returns string
Inherited from ChartbreakerObject.toString

validate

validate(
    this: ChartbreakerObject,
    s: string | { [key: string]: any },
    v?: any,
    flags?: ObjectEFlags,
): boolean
will set validate value(s) for the specified option(s)

NOTE: if multiple options are used, will return false if at least one value is not valid
Parameters
- this: ChartbreakerObject
- s: string | { [key: string]: any }
- Optionalv: any
- Optionalflags: ObjectEFlags
Returns boolean
Inherited from ChartbreakerObject.validate

willUpdateOptions

willUpdateOptions(options?: string | string[]): void
when using custom getters/setters (via _get/_set) in options, the values of options can change without .set being called - or there might not even be a setter for readonly options; for example, if the getter simply returns the value of a member variable this variable could be modified directly. In this case, events such as optionChanged would not be fired, and listeners would not be informed about the change.

To account for such cases, the methods willUpdateOptions and didUpdateOptions should be called directly BEFORE and AFTER actions that might potentially change values of options. the correct events will then automatically be triggered when calling didUpdateOptions.

if the options that could change are known, they can be supplied via the optional parameter. This provides a small performance gain in most situations.

IMPORTANT: methods must be called in balance; e.g. for each call to willUpdateOptions, you must call didUpdateOptions exactly once.
Parameters
- Optionaloptions: string | string[]
Returns void
Inherited from ChartbreakerObject.willUpdateOptions

`Static`guard

guard(cb: GuardCb): void
Parameters
- cb: GuardCb
Returns void
Description
set custom error handler for event listeners

Inherited from ChartbreakerObject.guard

`Static`listenerCount

listenerCount<EvType extends Events, Type extends string>(
emitter: chartbreaker.EventEmitter<EvType>,
type: Type,
): number
Type Parameters
- EvType extends Events
- Type extends string
Parameters
- emitter: chartbreaker.EventEmitter<EvType>
- type: Type
Returns number
Description
returns number of listeners on specified emitter for specified type

Inherited from ChartbreakerObject.listenerCount

`Static`setDefaultMaxListeners

setDefaultMaxListeners(maxListeners: number): void
Parameters
- maxListeners: number
Returns void
Description
set default amount for limit warning

Inherited from ChartbreakerObject.setDefaultMaxListeners

Class Chart

Hierarchy (View Summary)

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Returns Chart

Properties

Optional Readonlyevents

Description

optionGroups

Protectedoptions

Staticoptions

Type Declaration

axisTextSize: { flags: ObjectEOptionFlags; name: string; type: { default: string; large: string; veryLarge: string }; _get(this: Chart): "default" | "large" | "veryLarge"; _set(this: Chart, v: "default" | "large" | "veryLarge"): void;}

crosshairColor: { flags: number; name: string; type: string; _get(this: Chart): any; _set(this: Chart, v: string): void;}

Cfg

crosshairLines: { flags: ObjectEOptionFlags; name: string; type: string; _get(this: Chart): boolean; _set(this: Chart, v: boolean): void;}

Cfg

crosshairStyle: { _get: (this: Chart) => ELineStyle; _set: (this: Chart, value: ELineStyle) => void; flags: ObjectEOptionFlags; name: string; type: Record<ELineStyle, string>;}

Cfg

crosshairWidth: { _get: (this: Chart) => LineWidth; _set: (this: Chart, value: LineWidth) => void; flags: ObjectEOptionFlags; name: string; type: Record<LineWidth, string>;}

Cfg

grid: { flags: ObjectEOptionFlags; name: string; type: string; _get(this: Chart): boolean; _set(this: Chart, v: boolean): void;}

Cfg

height: { type: string; _get(this: Chart): number; _set(this: Chart, v: number): void }

Cfg

legendStyle: { flags: ObjectEOptionFlags; name: string; type: { horizontal: string; none: string; vertical: string }; _get(this: Chart): any; _set(this: Chart, v: string): void;}

Cfg

legendValue: { flags: ObjectEOptionFlags; name: string; type: string; value: boolean }

Cfg

markers: { flags: ObjectEOptionFlags; name: string; type: string; value: boolean; _get(this: Chart): any; _set(this: Chart, v: boolean): void;}

messageEmpty: { type: string; _get(this: Chart): string; _set(this: Chart, v: string): void }

Cfg

resetCrosshairStyle: { flags: number; name: string; type: string; _set(this: Chart): void }

sessionBreaks: { flags: ObjectEOptionFlags; name: string; type: string; _get(this: Chart): boolean; _set(this: Chart, v: boolean): void;}

Cfg

sessionBreaksColor: { flags: number; name: string; type: string; _get(this: Chart): any; _set(this: Chart, v: string): void;}

Cfg

sessionBreaksStyle: { _get: (this: Chart) => ELineStyle; _set: (this: Chart, value: ELineStyle) => void; flags: ObjectEOptionFlags; name: string; type: Record<ELineStyle, string>;}

Cfg

sessionBreaksWidth: { _get: (this: Chart) => LineWidth; _set: (this: Chart, value: LineWidth) => void; flags: ObjectEOptionFlags; name: string; type: Record<LineWidth, string>;}

Cfg

styleId: { type: string; _get(this: Chart): string; _set(this: Chart, v: string): void }

Cfg

tapelineShowDeltaIndex: { flags: ObjectEOptionFlags; name: string; type: string; value: boolean; _get(this: Chart): any; _set(this: Chart, v: number): void;}

tapelineShowDeltaValue: { flags: ObjectEOptionFlags; name: string; type: string; value: boolean; _get(this: Chart): any; _set(this: Chart, v: number): void;}

tapelineShowPercentDiff: { flags: ObjectEOptionFlags; name: string; type: string; value: boolean; _get(this: Chart): any; _set(this: Chart, v: number): void;}

tapelineShowSpeed: { flags: ObjectEOptionFlags; name: string; type: string; value: boolean; _get(this: Chart): any; _set(this: Chart, v: number): void;}

xAxisBottomStyle: { type: { default: string; none: string; ticks: string }; _get(this: Chart): any;}

Cfg

xAxisTopStyle: { type: { default: string; none: string; ticks: string }; _get(this: Chart): any;}

Cfg

Methods

addListener

Type Parameters

Parameters

Returns this

Description

attr

Parameters

Returns any

didUpdateOptions

Parameters

Returns void

drawHorizontalMarker

Parameters

Returns void

drawTooltip

Parameters

Returns void

drawVerticalMarker

Parameters

Returns void

emit

Type Parameters

Parameters

`Optional` `Readonly`events

`Protected`options

`Static`options

axisTextSize: {
flags: ObjectEOptionFlags;
name: string;
type: { default: string; large: string; veryLarge: string };
_get(this: Chart): "default" | "large" | "veryLarge";
_set(this: Chart, v: "default" | "large" | "veryLarge"): void;
}

crosshairColor: {
flags: number;
name: string;
type: string;
_get(this: Chart): any;
_set(this: Chart, v: string): void;
}

crosshairLines: {
flags: ObjectEOptionFlags;
name: string;
type: string;
_get(this: Chart): boolean;
_set(this: Chart, v: boolean): void;
}

crosshairStyle: {
_get: (this: Chart) => ELineStyle;
_set: (this: Chart, value: ELineStyle) => void;
flags: ObjectEOptionFlags;
name: string;
type: Record<ELineStyle, string>;
}

crosshairWidth: {
_get: (this: Chart) => LineWidth;
_set: (this: Chart, value: LineWidth) => void;
flags: ObjectEOptionFlags;
name: string;
type: Record<LineWidth, string>;
}

grid: {
flags: ObjectEOptionFlags;
name: string;
type: string;
_get(this: Chart): boolean;
_set(this: Chart, v: boolean): void;
}

legendStyle: {
flags: ObjectEOptionFlags;
name: string;
type: { horizontal: string; none: string; vertical: string };
_get(this: Chart): any;
_set(this: Chart, v: string): void;
}

markers: {
flags: ObjectEOptionFlags;
name: string;
type: string;
value: boolean;
_get(this: Chart): any;
_set(this: Chart, v: boolean): void;
}

sessionBreaks: {
flags: ObjectEOptionFlags;
name: string;
type: string;
_get(this: Chart): boolean;
_set(this: Chart, v: boolean): void;
}

sessionBreaksColor: {
flags: number;
name: string;
type: string;
_get(this: Chart): any;
_set(this: Chart, v: string): void;
}

sessionBreaksStyle: {
_get: (this: Chart) => ELineStyle;
_set: (this: Chart, value: ELineStyle) => void;
flags: ObjectEOptionFlags;
name: string;
type: Record<ELineStyle, string>;
}

sessionBreaksWidth: {
_get: (this: Chart) => LineWidth;
_set: (this: Chart, value: LineWidth) => void;
flags: ObjectEOptionFlags;
name: string;
type: Record<LineWidth, string>;
}

tapelineShowDeltaIndex: {
flags: ObjectEOptionFlags;
name: string;
type: string;
value: boolean;
_get(this: Chart): any;
_set(this: Chart, v: number): void;
}

tapelineShowDeltaValue: {
flags: ObjectEOptionFlags;
name: string;
type: string;
value: boolean;
_get(this: Chart): any;
_set(this: Chart, v: number): void;
}

tapelineShowPercentDiff: {
flags: ObjectEOptionFlags;
name: string;
type: string;
value: boolean;
_get(this: Chart): any;
_set(this: Chart, v: number): void;
}

tapelineShowSpeed: {
flags: ObjectEOptionFlags;
name: string;
type: string;
value: boolean;
_get(this: Chart): any;
_set(this: Chart, v: number): void;
}

xAxisBottomStyle: {
type: { default: string; none: string; ticks: string };
_get(this: Chart): any;
}

xAxisTopStyle: {
type: { default: string; none: string; ticks: string };
_get(this: Chart): any;
}