Class ChartSet

The ChartSet serves as a container around multiple individual Chart objects displaying data from the same timespan.

For example, a typical finance chart consists of one chart displaying stock quotes in the form of candlesticks, and and another chart displaying the traded volume. These two charts are linked via their x-axis - if the viewed span is changed in one chart, it also changes in the other.

The ChartSet is responsible for this synchronization by controlling the underlying Data object, basic event handling, the most general aspects of layout such as ordering charts. Visualization of the actual data and further event handling such as interaction with objects is then handled by the individual chart objects themselves.

By default, the chartset is drawn with an opaque background. This can be changed - e.g. to display a logo in the background of the chart via CSS - by clearing the style value 'background-color' or setting it to 'none'.

Hierarchy (View Summary)

ChartbreakerObject<ChartSet_Events>
- ChartSet

Constructors

constructor

new ChartSet(
    divId: string | HTMLDivElement,
    options: null | { [key: string]: any },
    data: Data,
    canvasConstructor?: (
        width: number,
        height: number,
        type?: "pdf" | "svg",
    ) => Canvas,
): ChartSet
Parameters
- divId: string | HTMLDivElement
  id of the parent div
- options: null | { [key: string]: any }
  backend specific options
- data: Data
- OptionalcanvasConstructor: (width: number, height: number, type?: "pdf" | "svg") => Canvas
  - (width: number, height: number, type?: "pdf" | "svg"): Canvas
    Creates a Canvas instance. This function works in both Node.js and Web browsers, where there is no Canvas constructor.
    
    Parameters
    width: number
    height: number
    Optionaltype: "pdf" | "svg"
    Optionally specify to create a PDF or SVG canvas. Defaults to an image canvas.
    
    Returns Canvas
Returns ChartSet
Overrides ChartbreakerObject.constructor

Properties

`Optional` `Readonly`events

events?: ChartSet_Events & Object_Events

Description

Phantom data for type inference

`Optional`optionGroups

optionGroups?: ObjectOptionGroup[]

`Protected`options

options: { [key: string]: any }

render

render: (meta?: ToolTCalculateParams) => void

`Static`options

options: {
    action: {
        type: string[];
        _get(
            this: ChartSet,
        ): "none" | "picker" | "place" | "edit" | "zoom" | "measure" | "resize";
    };
    buttonsRatio: { name: string; type: string; value: number };
    height: {
        type: string;
        _get(this: ChartSet): number;
        _set(this: ChartSet, v: number): void;
    };
    i18nLanguage: {
        type: string;
        _get(this: ChartSet): string;
        _set(this: ChartSet, v: string): void;
    };
    i18nLocale: {
        type: string;
        _get(this: ChartSet): string;
        _set(this: ChartSet, v: string): void;
    };
    i18nTimezone: {
        type: string;
        _get(this: ChartSet): string;
        _set(this: ChartSet, v: string): void;
    };
    interaction: {
        type: string;
        _get(this: ChartSet): boolean;
        _set(this: ChartSet, v: boolean): void;
    };
    interactionActive: { type: string; _get(this: ChartSet): boolean };
    interactionChartButtons: {
        type: string;
        _get(this: ChartSet): boolean;
        _set(this: ChartSet, v: boolean): void;
    };
    interactionLegendButtons: {
        type: string;
        _get(this: ChartSet): boolean;
        _set(this: ChartSet, v: boolean): void;
    };
    interactionModify: {
        type: string;
        _get(this: ChartSet): boolean;
        _set(this: ChartSet, v: boolean): void;
    };
    interactionReorder: { type: string; value: boolean };
    interactionResize: {
        type: string;
        _get(this: ChartSet): boolean;
        _set(this: ChartSet, v: boolean): void;
    };
    interactionScroll: {
        type: string;
        _get(this: ChartSet): boolean;
        _set(this: ChartSet, v: boolean): void;
    };
    interactionZoom: {
        type: string;
        _get(this: ChartSet): boolean;
        _set(this: ChartSet, v: boolean): void;
    };
    interpolation: { type: string; _get(this: ChartSet): boolean };
    legend: {
        type: string;
        _get(this: ChartSet): boolean;
        _set(this: ChartSet, v: boolean): void;
    };
    picker: {
        type: string;
        _get(this: ChartSet): boolean;
        _set(this: ChartSet, v: boolean): void;
    };
    plotWidth: {
        type: string;
        _get(this: ChartSet): number;
        _set(this: ChartSet, v: number): void;
    };
    primaryYAxisPosition: { type: string[]; _get(this: ChartSet): any };
    ratio: {
        type: string;
        _get(this: ChartSet): number;
        _set(this: ChartSet, v: number): void;
    };
    resize: {
        type: string[];
        value: string;
        _set(this: ChartSet, v: "fixed" | "dynamic"): void;
    };
    secondaryYAxisPlaceholder: { type: string[]; _get(this: ChartSet): any };
    snap: { type: string; value: boolean };
    snapRange: {
        type: string;
        _get(this: ChartSet): number;
        _set(this: ChartSet, v: number): void;
    };
    width: {
        type: string;
        _get(this: ChartSet): number;
        _set(this: ChartSet, v: number): void;
    };
    xAxisLayout: { type: string[]; _get(this: ChartSet): any };
    xAxisSpacing: { type: string; _get(this: ChartSet): any };
    yAxisLayout: { type: string[]; _get(this: ChartSet): any };
}

Type Declaration

action: {
    type: string[];
    _get(
        this: ChartSet,
    ): "none" | "picker" | "place" | "edit" | "zoom" | "measure" | "resize";
}
currently active action (read only). Valid values:
- ** none **
- ** picker **
- ** place **
- ** edit **
- ** zoom **
- ** measure **
- ** resize **
Cfg
action
buttonsRatio: { name: string; type: string; value: number }
controls the size of buttons

Cfg
buttonsRatio
height: {
    type: string;
    _get(this: ChartSet): number;
    _set(this: ChartSet, v: number): void;
}
total height of the set

Cfg
height
i18nLanguage: {
    type: string;
    _get(this: ChartSet): string;
    _set(this: ChartSet, v: string): void;
}
i18n language

Cfg
i18nLanguage
i18nLocale: {
    type: string;
    _get(this: ChartSet): string;
    _set(this: ChartSet, v: string): void;
}
i18n locale

Cfg
i18nLocale
i18nTimezone: {
    type: string;
    _get(this: ChartSet): string;
    _set(this: ChartSet, v: string): void;
}
i18n timezone

Cfg
i18nTimezone
interaction: {
    type: string;
    _get(this: ChartSet): boolean;
    _set(this: ChartSet, v: boolean): void;
}
enable/disable mouse and keyboard interaction

Cfg
interaction
interactionActive: { type: string; _get(this: ChartSet): boolean }
check if user interaction (click or touch) is currently in progress

Cfg
interactionActive
interactionChartButtons: {
    type: string;
    _get(this: ChartSet): boolean;
    _set(this: ChartSet, v: boolean): void;
}
enable/disable buttons in charts

Cfg
interactionChartButtons
interactionLegendButtons: {
    type: string;
    _get(this: ChartSet): boolean;
    _set(this: ChartSet, v: boolean): void;
}
enable/disable buttons in legends

Cfg
interactionLegendButtons
interactionModify: {
    type: string;
    _get(this: ChartSet): boolean;
    _set(this: ChartSet, v: boolean): void;
}
enable/disable modification of the chartsets content through mouse/touch interaction

Cfg
interactionModify
interactionReorder: { type: string; value: boolean }
enable/disable manual interactive reordering of charts

Cfg
interactionReorder
interactionResize: {
    type: string;
    _get(this: ChartSet): boolean;
    _set(this: ChartSet, v: boolean): void;
}
enable/disable manual interactive resizing of charts

Cfg
interactionResize
interactionScroll: {
    type: string;
    _get(this: ChartSet): boolean;
    _set(this: ChartSet, v: boolean): void;
}
enable/disable manual interactive scrolling of the xAxis

Cfg
interactionScroll
interactionZoom: {
    type: string;
    _get(this: ChartSet): boolean;
    _set(this: ChartSet, v: boolean): void;
}
enable/disable manual interactive scrolling of the xAxis

Cfg
interactionZoom
interpolation: { type: string; _get(this: ChartSet): boolean }
controls wether layers such as line and mountain use linear interpolation between data points disabling interpolation can make sense for some kinds of data such as measurements

(can only be configured via stylesheet)

Cfg
interpolation
legend: {
    type: string;
    _get(this: ChartSet): boolean;
    _set(this: ChartSet, v: boolean): void;
}
enables/disables legend completely, regardless of the legendStyle configured for individual charts

Cfg
legendButtons
picker: {
    type: string;
    _get(this: ChartSet): boolean;
    _set(this: ChartSet, v: boolean): void;
}
enable/disable picker (value cursor)

Cfg
picker
plotWidth: {
    type: string;
    _get(this: ChartSet): number;
    _set(this: ChartSet, v: number): void;
}
width of the set usable for plotting (width excluding y axes on the outside)

Cfg
plotWidth
primaryYAxisPosition: { type: string[]; _get(this: ChartSet): any }
(can only be configured via stylesheet)

Cfg
[primaryYAxisPosition=right]
ratio: {
    type: string;
    _get(this: ChartSet): number;
    _set(this: ChartSet, v: number): void;
}
scale factor affecting the size of the set (0.0 - 1.0)

Cfg
ratio
resize: {
    type: string[];
    value: string;
    _set(this: ChartSet, v: "fixed" | "dynamic"): void;
}
controls the ChartSets resizing behaviour Valid values:
- ** fixed ** the height of the chartset is fixed
- ** dynamic ** the height of the chartset can be changed
Cfg
[resize=dynamic]
secondaryYAxisPlaceholder: { type: string[]; _get(this: ChartSet): any }
retrieves current y-axis placeholder mode When y-axes are placed on the outside, this option controls if the primary axis is rendered twice if a chart has no secondary y-axis.

Valid values:
- ** never ** Placeholder is never shown
- ** always ** Placeholder is always shown
- ** ondemand ** Placeholder is only shown when at least one chart has a secondary axis
(can only be configured via stylesheet)
Cfg
[secondaryYAxisPlaceholder=never]
snap: { type: string; value: boolean }
enable/disable automatic snapping to OHLC values or tool handles

Cfg
snap
snapRange: {
    type: string;
    _get(this: ChartSet): number;
    _set(this: ChartSet, v: number): void;
}
range in pixels for automatic snapping

Cfg
snapRange
width: {
    type: string;
    _get(this: ChartSet): number;
    _set(this: ChartSet, v: number): void;
}
width of the set

Cfg
width
xAxisLayout: { type: string[]; _get(this: ChartSet): any }
retrieves current x-axis layout

(can only be configured via stylesheet)

Cfg
xAxisLayout
xAxisSpacing: { type: string; _get(this: ChartSet): any }
retrieves the initial amount of blank space between the last value and the yAxis.

(can only be configured via stylesheet)

this value is not used by the ChartSet implementation itself; it is just a hint for anyone who creates a layout for this ChartSet. ranges between 0% (no space) and 50% (50% empty space on the right).

NOTE: displayed spacing might be slightly larger than the requested value due to layout constraints.

Cfg
xAxis
yAxisLayout: { type: string[]; _get(this: ChartSet): any }
retrieves current y-axis layout

(can only be configured via stylesheet)

Cfg
yAxisLayout

Methods

addListener

addListener<
    Type extends (keyof Object_Events)
    | (keyof ChartSet_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)
            | (() => void)
            | ((oldIndex: number, newIndex: number) => void)
            | ((chart: null | Chart) => void)
            | (() => void),
>(
    type: Type,
    listener: Callback,
): this
Type Parameters
- Type extends (keyof Object_Events) | (keyof ChartSet_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)
      | (() => void)
      | ((oldIndex: number, newIndex: number) => void)
      | ((chart: null | Chart) => 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

doRedraw

doRedraw(meta?: ToolTCalculateParams): void
redraw the contents
Parameters
- Optionalmeta: ToolTCalculateParams
Returns void

emit

emit<
    Type extends (keyof Object_Events)
    | (keyof ChartSet_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)
            | (() => void)
            | ((oldIndex: number, newIndex: number) => void)
            | ((chart: null | Chart) => void)
            | (() => void),
>(
    type: Type,
    ...params: Parameters<Callback>,
): boolean
Type Parameters
- Type extends (keyof Object_Events) | (keyof ChartSet_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)
      | (() => void)
      | ((oldIndex: number, newIndex: number) => void)
      | ((chart: null | Chart) => 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

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

getCanvas

getCanvas(): HTMLCanvasElement
returns the sets underlying canvas element

Returns HTMLCanvasElement

getData

getData(): Data
returns the sets data object

Returns Data

getFormatter

getFormatter(
    type: NUMBER | QUOTE,
): (
    arg0: number,
    arg1?: number | ChartbreakerObject<Record<string, (...args: any) => void>>,
) => string
returns the requested formatter

available types are:
- ChartSetEFormatter.NUMBER: generic number formatting. second argument is the precision.
- ChartSetEFormatter.QUOTE: special quote formatting. second argument is the precision. when using precision 0 numbers like 1,000,000 are formatted as 1.00M etc
- ChartSetEFormatter.TIME: timestamp formatter; second argument is the format string
Parameters
- type: NUMBER | QUOTE
Returns (
arg0: number,
arg1?: number | ChartbreakerObject<Record<string, (...args: any) => void>>,
) => string
getFormatter(
    type: TIME,
): (
    arg0: number,
    arg1?: string | ChartbreakerObject<Record<string, (...args: any) => void>>,
) => null | string | number
returns the requested formatter

available types are:
- ChartSetEFormatter.NUMBER: generic number formatting. second argument is the precision.
- ChartSetEFormatter.QUOTE: special quote formatting. second argument is the precision. when using precision 0 numbers like 1,000,000 are formatted as 1.00M etc
- ChartSetEFormatter.TIME: timestamp formatter; second argument is the format string
Parameters
- type: TIME
Returns (
arg0: number,
arg1?: string | ChartbreakerObject<Record<string, (...args: any) => void>>,
) => null | string | number

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

getState

getState(): ObjectState
returns the objects current state

Returns ObjectState
Inherited from ChartbreakerObject.getState

getStyle

getStyle(): null | Style
return the sets current style object

Returns null | Style

getTranslator

getTranslator(): Translator
returns the translator instance used by this chart must not be cached/stored externally because it can change at any time

Returns Translator

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

listeners

listeners<
    Type extends (keyof Object_Events)
    | (keyof ChartSet_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)
            | (() => void)
            | ((oldIndex: number, newIndex: number) => void)
            | ((chart: null | Chart) => void)
            | (() => void),
>(
    type: Type,
): Callback[]
Type Parameters
- Type extends (keyof Object_Events) | (keyof ChartSet_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)
      | (() => void)
      | ((oldIndex: number, newIndex: number) => void)
      | ((chart: null | Chart) => 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 Object_Events)
    | (keyof ChartSet_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)
            | (() => void)
            | ((oldIndex: number, newIndex: number) => void)
            | ((chart: null | Chart) => void)
            | (() => void),
>(
    type: Type,
    listener: Callback,
): this
Type Parameters
- Type extends (keyof Object_Events) | (keyof ChartSet_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)
      | (() => void)
      | ((oldIndex: number, newIndex: number) => void)
      | ((chart: null | Chart) => void)
      | (() => void)
Parameters
- type: Type
- listener: Callback
Returns this
Description
alias for addListener

Inherited from ChartbreakerObject.on

once

once<
    Type extends (keyof Object_Events)
    | (keyof ChartSet_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)
            | (() => void)
            | ((oldIndex: number, newIndex: number) => void)
            | ((chart: null | Chart) => void)
            | (() => void),
>(
    type: Type,
    listener: Callback,
): this
Type Parameters
- Type extends (keyof Object_Events) | (keyof ChartSet_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)
      | (() => void)
      | ((oldIndex: number, newIndex: number) => void)
      | ((chart: null | Chart) => 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
Inherited from 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

redraw

redraw(
    delay?: number,
    redrawMode?: ERedrawReason,
    indices?: { from: number; to: number },
): void
request redrawing of all charts
Parameters
- Optionaldelay: number
  an optional delay in milliseconds
- OptionalredrawMode: ERedrawReason
- Optionalindices: { from: number; to: number }
Returns void

removeAllListeners

removeAllListeners<Type extends (keyof Object_Events) | (keyof ChartSet_Events)>(
type?: Type,
): this
Type Parameters
- Type extends (keyof Object_Events) | (keyof ChartSet_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 Object_Events)
    | (keyof ChartSet_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)
            | (() => void)
            | ((oldIndex: number, newIndex: number) => void)
            | ((chart: null | Chart) => void)
            | (() => void),
>(
    type: Type,
    listener: Callback,
): this
Type Parameters
- Type extends (keyof Object_Events) | (keyof ChartSet_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)
      | (() => void)
      | ((oldIndex: number, newIndex: number) => void)
      | ((chart: null | Chart) => 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

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

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 ChartSet

Hierarchy (View Summary)

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Parameters

Returns Canvas

Returns ChartSet

Properties

Optional Readonlyevents

Description

OptionaloptionGroups

Protectedoptions

render

Staticoptions

Type Declaration

action: { type: string[]; _get( this: ChartSet, ): "none" | "picker" | "place" | "edit" | "zoom" | "measure" | "resize";}

Cfg

buttonsRatio: { name: string; type: string; value: number }

Cfg

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

Cfg

i18nLanguage: { type: string; _get(this: ChartSet): string; _set(this: ChartSet, v: string): void;}

Cfg

i18nLocale: { type: string; _get(this: ChartSet): string; _set(this: ChartSet, v: string): void;}

Cfg

i18nTimezone: { type: string; _get(this: ChartSet): string; _set(this: ChartSet, v: string): void;}

Cfg

interaction: { type: string; _get(this: ChartSet): boolean; _set(this: ChartSet, v: boolean): void;}

Cfg

interactionActive: { type: string; _get(this: ChartSet): boolean }

Cfg

interactionChartButtons: { type: string; _get(this: ChartSet): boolean; _set(this: ChartSet, v: boolean): void;}

Cfg

interactionLegendButtons: { type: string; _get(this: ChartSet): boolean; _set(this: ChartSet, v: boolean): void;}

Cfg

interactionModify: { type: string; _get(this: ChartSet): boolean; _set(this: ChartSet, v: boolean): void;}

Cfg

interactionReorder: { type: string; value: boolean }

Cfg

interactionResize: { type: string; _get(this: ChartSet): boolean; _set(this: ChartSet, v: boolean): void;}

Cfg

interactionScroll: { type: string; _get(this: ChartSet): boolean; _set(this: ChartSet, v: boolean): void;}

Cfg

interactionZoom: { type: string; _get(this: ChartSet): boolean; _set(this: ChartSet, v: boolean): void;}

Cfg

interpolation: { type: string; _get(this: ChartSet): boolean }

Cfg

legend: { type: string; _get(this: ChartSet): boolean; _set(this: ChartSet, v: boolean): void;}

Cfg

picker: { type: string; _get(this: ChartSet): boolean; _set(this: ChartSet, v: boolean): void;}

Cfg

plotWidth: { type: string; _get(this: ChartSet): number; _set(this: ChartSet, v: number): void;}

Cfg

primaryYAxisPosition: { type: string[]; _get(this: ChartSet): any }

Cfg

ratio: { type: string; _get(this: ChartSet): number; _set(this: ChartSet, v: number): void;}

Cfg

resize: { type: string[]; value: string; _set(this: ChartSet, v: "fixed" | "dynamic"): void;}

Cfg

secondaryYAxisPlaceholder: { type: string[]; _get(this: ChartSet): any }

Cfg

snap: { type: string; value: boolean }

Cfg

snapRange: { type: string; _get(this: ChartSet): number; _set(this: ChartSet, v: number): void;}

Cfg

width: { type: string; _get(this: ChartSet): number; _set(this: ChartSet, v: number): void;}

Cfg

xAxisLayout: { type: string[]; _get(this: ChartSet): any }

Cfg

xAxisSpacing: { type: string; _get(this: ChartSet): any }

Cfg

yAxisLayout: { type: string[]; _get(this: ChartSet): any }

Cfg

Methods

addListener

`Optional` `Readonly`events

`Optional`optionGroups

`Protected`options

`Static`options

action: {
type: string[];
_get(
this: ChartSet,
): "none" | "picker" | "place" | "edit" | "zoom" | "measure" | "resize";
}

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

i18nLanguage: {
type: string;
_get(this: ChartSet): string;
_set(this: ChartSet, v: string): void;
}

i18nLocale: {
type: string;
_get(this: ChartSet): string;
_set(this: ChartSet, v: string): void;
}

i18nTimezone: {
type: string;
_get(this: ChartSet): string;
_set(this: ChartSet, v: string): void;
}

interaction: {
type: string;
_get(this: ChartSet): boolean;
_set(this: ChartSet, v: boolean): void;
}

interactionChartButtons: {
type: string;
_get(this: ChartSet): boolean;
_set(this: ChartSet, v: boolean): void;
}

interactionLegendButtons: {
type: string;
_get(this: ChartSet): boolean;
_set(this: ChartSet, v: boolean): void;
}

interactionModify: {
type: string;
_get(this: ChartSet): boolean;
_set(this: ChartSet, v: boolean): void;
}

interactionResize: {
type: string;
_get(this: ChartSet): boolean;
_set(this: ChartSet, v: boolean): void;
}

interactionScroll: {
type: string;
_get(this: ChartSet): boolean;
_set(this: ChartSet, v: boolean): void;
}

interactionZoom: {
type: string;
_get(this: ChartSet): boolean;
_set(this: ChartSet, v: boolean): void;
}

legend: {
type: string;
_get(this: ChartSet): boolean;
_set(this: ChartSet, v: boolean): void;
}

picker: {
type: string;
_get(this: ChartSet): boolean;
_set(this: ChartSet, v: boolean): void;
}

plotWidth: {
type: string;
_get(this: ChartSet): number;
_set(this: ChartSet, v: number): void;
}

ratio: {
type: string;
_get(this: ChartSet): number;
_set(this: ChartSet, v: number): void;
}

resize: {
type: string[];
value: string;
_set(this: ChartSet, v: "fixed" | "dynamic"): void;
}

snapRange: {
type: string;
_get(this: ChartSet): number;
_set(this: ChartSet, v: number): void;
}

width: {
type: string;
_get(this: ChartSet): number;
_set(this: ChartSet, v: number): void;
}

Returns (
arg0: number,
arg1?: number | ChartbreakerObject<Record<string, (...args: any) => void>>,
) => string

Returns (
arg0: number,
arg1?: string | ChartbreakerObject<Record<string, (...args: any) => void>>,
) => null | string | number