apexcharts 7.3.0 → 7.5.0

package/src/modules/weave/PluginAPI.js

@@ -1,4 +1,7 @@
 // @ts-check
+import { addClaim, normaliseEntries, releaseClaim } from './Claims'
+import { collectDrawn } from './Drawn'
+
 /**
  * The frozen facade handed to each Weave plugin. Plugins NEVER receive raw `w`,
  * internal module instances, or the `__apex_*` internals: only this stable,
@@ -25,12 +28,56 @@
  * tooltip and its `dataPoint*` events; before this a plugin either re-derived
  * it from raw pixels or did without.
  *
+ * v5 added `api.info.stroke`, the caller's own `stroke.dashArray`. That option
+ * is indexed by series position, so a plugin that wants its own derived series
+ * dashed must write the whole array; reporting the current value is what lets
+ * it put back what it found instead of flattening the caller's dashed lines.
+ *
+ * v6 also added `api.info.title` (the name the page already gave this chart, so
+ * a readout naming several charts has something better than a container id) and
+ * `modifiers` on the pointer payload (so a gesture can be shift-click).
+ *
+ * v6 added three larger pieces, each closing a class rather than one incident.
+ * `api.capabilities` / `api.can()` replace the typeof-sniffing below with
+ * something a plugin can ask. `api.claim()` generalises what v5 only reported,
+ * so a plugin sets a positional option for ITS OWN series and the host resolves
+ * it where the option is read, writing nothing. `api.drawn()` / `api.declare()`
+ * publish what is on the chart, including other features' output, which is the
+ * question a layers panel and an export summary both ask. See
+ * `plans/26-weave-capabilities.md`.
+ *
  * Feature-detect rather than bumping `apiVersion` unless the plugin genuinely
  * cannot work without the new surface: a plugin declaring v3 is SKIPPED
- * outright on a v2 host, so `apiVersion: 2` plus `typeof api.reserve ===
- * 'function'` keeps one build working on both.
+ * outright on a v2 host, so `apiVersion: 2` plus a capability check keeps one
+ * build working on both.
  */
-export const WEAVE_API_VERSION = 4
+export const WEAVE_API_VERSION = 6
+
+/**
+ * What this host can do, for plugins that must run against older ones too.
+ *
+ * The version integer cannot answer this. A plugin declaring a version newer
+ * than the host is skipped outright, so a plugin supporting several hosts
+ * declares the LOWEST version it can run on and then has to discover anything
+ * above that. Until now it did so by sniffing the facade for function members.
+ *
+ * Named for the capability rather than the version that introduced it, and
+ * permanent once published: removing a name is a breaking change on the same
+ * terms as removing a member.
+ *
+ * `scales` is deliberately absent. It is null for non-axis charts, which is a
+ * property of the chart rather than of the host, and advertising it here would
+ * tell a plugin on a pie chart that projection is available.
+ */
+export const WEAVE_CAPABILITIES = Object.freeze([
+  'layer',
+  'derived',
+  'reserve',
+  'pointer',
+  'stroke-info',
+  'claim',
+  'drawn',
+])
 
 /**
  * Public chart methods safe to expose to plugins (each bound to ctx). Excludes
@@ -307,6 +354,31 @@ export function buildPluginAPI(host, record) {
             ? w.config.dataLabels.enabledOnSeries.slice()
             : null,
         }),
+        // The caller's own dashing, reported for the same reason and against
+        // the same trap (v5). `stroke.dashArray` is indexed by series position
+        // with no per-series escape hatch, so a plugin that wants ITS OWN
+        // computed series dashed has to write the whole array, and writing one
+        // without knowing what was there discards the caller's dashed lines
+        // with nothing to restore them from.
+        //
+        // A scalar applies to every series and an array is per series. There is
+        // no "unset" to report: the option defaults to 0, and 0 already means
+        // no dashing, so restoring it restores exactly what was there.
+        stroke: Object.freeze({
+          dashArray: Array.isArray(w.config.stroke && w.config.stroke.dashArray)
+            ? w.config.stroke.dashArray.slice()
+            : (w.config.stroke && w.config.stroke.dashArray) || 0,
+        }),
+        // What the chart calls itself, where the caller titled it (v6).
+        //
+        // For a plugin that has to NAME this chart to somebody: a page-level
+        // readout listing several charts otherwise has only the container's id
+        // to head each row with, which is a string written for a stylesheet.
+        // The title is the name the page already chose and put on screen.
+        //
+        // Empty string rather than undefined for an untitled chart, so a
+        // caller can use it directly in a template; falsy either way.
+        title: String((w.config.title && w.config.title.text) || ''),
       })
     },
 
@@ -377,6 +449,88 @@ export function buildPluginAPI(host, record) {
       return api
     },
 
+    /**
+     * Set a positional option for your own series, without writing the
+     * caller's config.
+     *
+     * Some options are indexed by series position with no per-series escape
+     * hatch, so setting one for a single series has always meant writing the
+     * array that covers all of them, then putting the caller's value back. A
+     * claim says what this plugin wants instead, and the host answers with it
+     * where the option is READ. Nothing is written, so releasing is a deletion
+     * rather than a restore, and a caller's own `updateOptions` composes with
+     * the claim instead of being reverted by it.
+     *
+     *     const claim = api.claim('stroke.dashArray', [
+     *       { series: 'Revenue (forecast)', value: 6 },
+     *     ])
+     *     claim.release()
+     *
+     * Name the series rather than its position where you can: a name is
+     * resolved each time the option is read, so the claim follows the series
+     * through the caller adding, removing or reordering others.
+     *
+     * Claimable options are an allowlist (see `CLAIMABLE`). An option that is
+     * not on it returns null rather than throwing, so a plugin written against
+     * a newer host degrades. Every claim is released on teardown, on destroy,
+     * and if the host disables this plugin after repeated failures.
+     *
+     * @param {string} option
+     * @param {Array<{series: string|number, value: any}>} entries
+     * @returns {{release: () => void, update: (entries: Array<{series: string|number, value: any}>) => void}|null}
+     * @since Weave v6
+     */
+    claim(option, entries) {
+      const claim = addClaim(w, record.def.name, option, entries)
+      if (!claim) return null
+      return Object.freeze({
+        release() {
+          releaseClaim(w, claim)
+        },
+        update(next) {
+          claim.entries = normaliseEntries(option, next)
+        },
+      })
+    },
+
+    /**
+     * Everything drawn on this chart, including what other features drew.
+     *
+     * The chart's series, the caller's annotations (ink strokes among them,
+     * since an ink stroke is an annotation), and whatever plugins have
+     * declared. Each entry names its `owner`, because the list is only as
+     * complete as the features that opted into it: a reader can say what it
+     * covers instead of assuming it is everything.
+     *
+     * Read only. Removing or hiding another feature's output is a much larger
+     * promise than this platform makes, and is deliberately not here.
+     *
+     * Rebuilt per call: it is a projection of live state, and a remembered
+     * inventory is a list of what WAS drawn.
+     *
+     * @returns {ReadonlyArray<{id: string, kind: 'series'|'annotation'|'overlay', label: string, owner: string, visible: boolean}>}
+     * @since Weave v6
+     */
+    drawn() {
+      return Object.freeze(collectDrawn(w, host).map((i) => Object.freeze(i)))
+    },
+
+    /**
+     * Say what this plugin has drawn, so it appears in `api.drawn()`.
+     *
+     * Declare from your draw handler, on the same terms as the drawing itself:
+     * declarations are cleared with the layers at the start of every draw, so
+     * an inventory cannot outlive what it describes. Declaring the same id
+     * twice replaces it rather than adding a second row.
+     *
+     * @param {{id: string, label?: string, visible?: boolean}} item
+     * @since Weave v6
+     */
+    declare(item) {
+      host._declare(record.def.name, item)
+      return api
+    },
+
     /**
      * Subscribe to the data point a viewer is pointing at.
      *
@@ -400,7 +554,12 @@ export function buildPluginAPI(host, record) {
      * and a handler that throws is contained rather than allowed to break the
      * interaction it was watching.
      *
-     * @param {(e: {type: 'enter'|'leave'|'select', seriesIndex: number, dataPointIndex: number, category: string|undefined, seriesName: string|undefined, selected: boolean|undefined}) => void} fn
+     * `modifiers` (v6) reports the keys held during the interaction, for the
+     * gestures that need them: shift-click to add to a selection is the one
+     * page-level coordination wants. All four are false when the interaction
+     * came from somewhere with no DOM event, such as the keyboard.
+     *
+     * @param {(e: {type: 'enter'|'leave'|'select', seriesIndex: number, dataPointIndex: number, category: string|undefined, seriesName: string|undefined, selected: boolean|undefined, modifiers: {shift: boolean, ctrl: boolean, alt: boolean, meta: boolean}}) => void} fn
      * @returns {() => void} unsubscribe
      * @since Weave v4
      */
@@ -428,5 +587,37 @@ export function buildPluginAPI(host, record) {
     },
   }
 
+  // Probed off the facade that was actually built rather than copied from the
+  // constant, so a member that is ever made conditional drops out instead of
+  // being advertised and then missing.
+  //
+  // An ARRAY rather than a Set, because a frozen Set is not actually read-only:
+  // Object.freeze does not touch internal slots, so `add()` and `delete()` keep
+  // working and one plugin could edit what every later one is told. The Set
+  // stays in the closure and `can()` is the lookup.
+  const probes = /** @type {Record<string, (a: any) => boolean>} */ (WIRED)
+  const granted = WEAVE_CAPABILITIES.filter((name) => probes[name](api))
+  const grantedSet = new Set(granted)
+  const extras = /** @type {any} */ (api)
+  extras.capabilities = Object.freeze(granted)
+  /** Whether this host supports a named capability. @since Weave v6 */
+  extras.can = (/** @type {string} */ name) => grantedSet.has(name)
+
   return Object.freeze(api)
 }
+
+/**
+ * How each capability name is confirmed present. One entry per member of
+ * {@link WEAVE_CAPABILITIES}; a name with no probe would always be advertised,
+ * which is the failure this table exists to prevent.
+ */
+const WIRED = {
+  layer: (/** @type {any} */ a) => typeof a.layer === 'function',
+  derived: (/** @type {any} */ a) => typeof a.markDerived === 'function',
+  reserve: (/** @type {any} */ a) => typeof a.reserve === 'function',
+  pointer: (/** @type {any} */ a) => typeof a.pointer === 'function',
+  'stroke-info': (/** @type {any} */ a) => !!(a.info && a.info.stroke),
+  claim: (/** @type {any} */ a) => typeof a.claim === 'function',
+  drawn: (/** @type {any} */ a) =>
+    typeof a.drawn === 'function' && typeof a.declare === 'function',
+}

package/src/modules/weave/WeaveHost.js

@@ -1,6 +1,7 @@
 // @ts-check
 import { getPlugin } from './PluginRegistry'
 import { buildPluginAPI, makeLayerHandle, WEAVE_API_VERSION } from './PluginAPI'
+import { releaseOwner } from './Claims'
 
 export { WEAVE_API_VERSION }
 
@@ -52,6 +53,8 @@ export default class WeaveHost {
     this._reserveTimer = null
     /** @type {Map<string, Function[]>|null} plugin name -> pointer handlers */
     this._pointerSubs = null
+    /** @type {Map<string, any[]>|null} plugin name -> what it says it drew */
+    this._declared = null
     /** @type {Array<[string, Function]>|null} chart listeners to remove on teardown */
     this._pointerWired = null
 
@@ -185,6 +188,11 @@ export default class WeaveHost {
       record.failures = (record.failures || 0) + 1
       if (record.failures >= 3) {
         record.disabled = true
+        // Its claims go with it. A disabled plugin has stopped running, so a
+        // claim it left behind would go on answering for an option nobody is
+        // maintaining, which is the permanent-leak case claims exist to rule
+        // out (see weave/Claims).
+        releaseOwner(this.w, record.def.name)
         console.error(
           `[apexcharts] plugin "${record.def.name}" disabled after repeated errors.`,
         )
@@ -431,8 +439,11 @@ export default class WeaveHost {
     ]
     this._pointerWired = []
     for (const [type, name] of map) {
-      const handler = (/** @type {any} */ _e, /** @type {any} */ _ctx, /** @type {any} */ opts) => {
-        this._emitPointer(type, opts)
+      // The DOM event is carried through rather than dropped: it is the only
+      // place the modifier keys exist, and a gesture like shift-click to add to
+      // a selection cannot be expressed without them. See `_emitPointer`.
+      const handler = (/** @type {any} */ e, /** @type {any} */ _ctx, /** @type {any} */ opts) => {
+        this._emitPointer(type, opts, e)
       }
       this.ctx.addEventListener(name, handler)
       this._pointerWired.push([name, handler])
@@ -449,8 +460,9 @@ export default class WeaveHost {
    *
    * @param {'enter'|'leave'|'select'} type
    * @param {any} opts
+   * @param {any} [e] the DOM event, where the interaction came from one
    */
-  _emitPointer(type, opts) {
+  _emitPointer(type, opts, e) {
     if (!this._pointerSubs || !this._pointerSubs.size) return
     const seriesIndex = opts && typeof opts.seriesIndex === 'number' ? opts.seriesIndex : -1
     const dataPointIndex =
@@ -475,6 +487,14 @@ export default class WeaveHost {
       // set, and what a plugin wants to know is whether THIS point is now in
       // it, so a second click reads as a deselect rather than another select.
       selected: type === 'select' ? WeaveHost._isSelected(opts, seriesIndex, dataPointIndex) : undefined,
+      // The modifier keys held during the interaction (v6), for the gestures
+      // that need them: shift-click to add to a selection is the one page mode
+      // wants, and a plugin cannot invent it from anything else here.
+      //
+      // All false when the interaction came from somewhere with no DOM event
+      // (the keyboard, a programmatic selection), which is the honest answer:
+      // no key was held.
+      modifiers: WeaveHost._modifiers(e),
     }
     for (const [name, handlers] of this._pointerSubs) {
       for (const fn of handlers.slice()) {
@@ -526,6 +546,24 @@ export default class WeaveHost {
     return mine.indexOf(dataPointIndex) > -1
   }
 
+  /**
+   * Which modifier keys were held, read off the DOM event.
+   *
+   * Always the same four booleans, never undefined and never a partial object:
+   * a plugin writes `if (e.modifiers.shift)` without a guard, and a shape that
+   * sometimes lacks a key is how that becomes a crash inside a viewer's click.
+   *
+   * @param {any} e
+   */
+  static _modifiers(e) {
+    return Object.freeze({
+      shift: !!(e && e.shiftKey),
+      ctrl: !!(e && e.ctrlKey),
+      alt: !!(e && e.altKey),
+      meta: !!(e && e.metaKey),
+    })
+  }
+
   /**
    * Record a plugin's container reservation and re-render if it changed.
    *
@@ -730,6 +768,39 @@ export default class WeaveHost {
       Array.prototype.forEach.call(groups, (/** @type {any} */ n) => n.remove())
     }
     this._layers.clear()
+    // Declarations go with the drawing they describe. A plugin repaints its
+    // overlays from state on every draw, and it declares them the same way, so
+    // an inventory can never outlive what it is an inventory OF.
+    this._declared = null
+  }
+
+  /**
+   * Record one thing a plugin has drawn, for `api.drawn()`.
+   *
+   * Replaced by id rather than appended, so a plugin declaring the same overlay
+   * on every draw (which is the pattern this expects) produces one entry.
+   *
+   * @param {string} name plugin
+   * @param {{id: string, label?: string, visible?: boolean}} item
+   */
+  _declare(name, item) {
+    if (!item || typeof item.id !== 'string' || !item.id) {
+      console.warn(
+        `[apexcharts] plugin "${name}" declared something with no id; ignored.`,
+      )
+      return
+    }
+    if (!this._declared) this._declared = new Map()
+    const mine = this._declared.get(name) || []
+    const entry = {
+      id: item.id,
+      label: item.label ? String(item.label) : item.id,
+      visible: item.visible !== false,
+    }
+    const at = mine.findIndex((/** @type {any} */ d) => d.id === entry.id)
+    if (at > -1) mine[at] = entry
+    else mine.push(entry)
+    this._declared.set(name, mine)
   }
 
   // ─── Config-change reconciliation ───────────────────────────────────────
@@ -795,10 +866,12 @@ export default class WeaveHost {
       for (const record of this.active) {
         this._guard(record, 'destroy', () => record.def.destroy && record.def.destroy(record.api))
       }
+      for (const record of this.active) releaseOwner(this.w, record.def.name)
       this.active = []
       this._derived = null
       this._reserved = null
       this._pointerSubs = null
+      this._declared = null
       if (this._pointerWired) {
         for (const [name, handler] of this._pointerWired) {
           this.ctx.removeEventListener && this.ctx.removeEventListener(name, handler)

package/src/ssr/DOMShim.js

@@ -4,6 +4,14 @@
  * Provides just enough SVG element emulation to create chart structure without full DOM
  */
 
+// Approximate sans-serif metrics, in em, used to estimate SVG text bounds when
+// no font engine is available to measure the glyphs.
+const CHAR_WIDTH_EM = 0.55
+const ASCENT_EM = 0.917
+const DESCENT_EM = 0.25
+const LINE_HEIGHT_EM = 1.1
+const DEFAULT_FONT_SIZE = 11
+
 /**
  * Mock SVG element for SSR environment
  */
@@ -148,6 +156,48 @@ class SSRElement {
     }
   }
 
+  getBBox() {
+    if (this.nodeName !== 'text' && this.nodeName !== 'tspan') {
+      return { x: 0, y: 0, width: 0, height: 0 }
+    }
+
+    const lines = this._textLines()
+    const longest = lines.reduce((acc, line) => Math.max(acc, line.length), 0)
+    if (!longest) {
+      return { x: 0, y: 0, width: 0, height: 0 }
+    }
+
+    const fontSize =
+      parseFloat(this.attributes.get('font-size')) || DEFAULT_FONT_SIZE
+    const width = longest * fontSize * CHAR_WIDTH_EM
+    const height =
+      fontSize * (ASCENT_EM + DESCENT_EM) +
+      (lines.length - 1) * fontSize * LINE_HEIGHT_EM
+
+    const anchor = this.attributes.get('text-anchor')
+    const x = parseFloat(this.attributes.get('x')) || 0
+    const y = parseFloat(this.attributes.get('y')) || 0
+
+    return {
+      x: anchor === 'middle' ? x - width / 2 : anchor === 'end' ? x - width : x,
+      y: y - fontSize * ASCENT_EM,
+      width,
+      height,
+    }
+  }
+
+  /**
+   * Text of this element, one entry per rendered line
+   * @returns {string[]}
+   */
+  _textLines() {
+    const tspans = this.children.filter((child) => child.nodeName === 'tspan')
+    if (tspans.length) {
+      return tspans.map((tspan) => String(tspan.textContent ?? ''))
+    }
+    return [String(this.textContent ?? '')]
+  }
+
   getRootNode() {
     /** @type {SSRElement} */
     let root = this

package/src/types/internal.d.ts

@@ -802,7 +802,7 @@ export interface ChartContext {
   eventList: string[]
 
   // Public methods on the ApexCharts instance
-  update(options?: any): Promise<any>
+  update(options?: any, overwriteInitialSeries?: boolean): Promise<any>
   getSyncedCharts(): any[]
   getGroupedCharts(): any[]
   fastUpdate(animate?: boolean, prevAxisScaleSig?: string): Promise<any>

package/src/utils/Utils.js

@@ -75,15 +75,12 @@ class Utils {
   }
 
   // A per-series shallow copy: the series OBJECTS are copied, their data arrays
-  // are shared. Almost every internal "mutation" of a series' data is a
-  // property REPLACEMENT (`series[i].data = []` on legend collapse,
-  // `series[i] = 0` for non-axis charts), and those cannot reach a copy made
-  // this way because the series object was copied at capture time. The
-  // exception is appendData(), whose push loop grows the shared data array in
-  // place, so a copy taken before it does see the appended points; see the
-  // note above defineLazyInitialSeries(). This is the same cheap shape
-  // `globals.initialSeries` captures, so snapshotting a config stays O(n)
-  // instead of deep-cloning every point.
+  // are shared. Every internal "mutation" of a series' data is a property
+  // REPLACEMENT (`series[i].data = []` on legend collapse, `series[i] = 0` for
+  // non-axis charts, appendData's concat), and those cannot reach a copy made
+  // this way because the series object was copied at capture time. This is the
+  // same cheap shape `globals.initialSeries` captures, so snapshotting a config
+  // stays O(n) instead of deep-cloning every point.
   /**
    * @param {any} series
    */

package/types/apexcharts.d.ts

@@ -850,6 +850,81 @@ interface ApexPluginAPI {
    */
   emit(name: string, detail?: any): void
   readonly el: Element
+  /**
+   * What this host supports, for a plugin that has to run against older ones
+   * too. A plugin targeting several hosts declares the lowest `apiVersion` it
+   * can run on (a newer one is skipped outright) and asks this for the rest.
+   *
+   * @since Weave v6
+   */
+  can(name: string): boolean
+  /** The same list, for logging and support. Frozen. @since Weave v6 */
+  readonly capabilities: readonly string[]
+  /**
+   * Set a positional option for your own series without writing the caller's
+   * config.
+   *
+   * Options like `stroke.dashArray` are indexed by series position with no
+   * per-series alternative, so setting one for a single series has meant
+   * writing the whole array and restoring the caller's afterwards. A claim is
+   * resolved where the option is READ instead: nothing is written, releasing is
+   * a deletion rather than a restore, and a caller's own `updateOptions`
+   * composes with the claim instead of being reverted by it.
+   *
+   * Name the series rather than its position where you can: the name is
+   * resolved each time the option is read, so the claim follows that series
+   * when others are added, removed or reordered.
+   *
+   * Returns null for an option that is not claimable, so a plugin written
+   * against a newer host degrades instead of throwing. Every claim is released
+   * on teardown, on destroy, and if the host disables the plugin.
+   *
+   * @since Weave v6
+   */
+  claim(
+    option: 'stroke.dashArray' | 'dataLabels.enabledOnSeries' | (string & {}),
+    entries: Array<{ series: string | number; value: any }>
+  ): ApexPluginClaim | null
+  /**
+   * Everything drawn on this chart, including other features' output: the
+   * series, the caller's annotations (ink strokes among them), and whatever
+   * plugins have declared.
+   *
+   * Read only. Every entry names its `owner`, because the list is only as
+   * complete as the features that opted in, and a reader should be able to say
+   * what it covers rather than assume it is exhaustive.
+   *
+   * @since Weave v6
+   */
+  drawn(): ReadonlyArray<ApexDrawnItem>
+  /**
+   * Say what this plugin has drawn, so it appears in `drawn()`. Declare from
+   * your draw handler: declarations are cleared with the layers at the start of
+   * every draw, so an inventory cannot outlive what it describes.
+   *
+   * @since Weave v6
+   */
+  declare(item: { id: string; label?: string; visible?: boolean }): ApexPluginAPI
+}
+
+/** One thing drawn on a chart. @since Weave v6 */
+interface ApexDrawnItem {
+  /** Stable within this chart, opaque to readers. */
+  readonly id: string
+  readonly kind: 'series' | 'annotation' | 'overlay'
+  /** A human name where one exists. */
+  readonly label: string
+  /** 'core', or the plugin that put it there. */
+  readonly owner: string
+  readonly visible: boolean
+}
+
+/** A live claim over one positional option. @since Weave v6 */
+interface ApexPluginClaim {
+  /** Drop the claim. Idempotent. */
+  release(): void
+  /** Replace this claim's entries, keeping its place in the resolution order. */
+  update(entries: Array<{ series: string | number; value: any }>): void
 }
 
 interface ApexPlugin {
@@ -1878,6 +1953,17 @@ type ApexChart = {
      * @default 'auto'
      */
     pinch?: boolean | 'auto'
+    /**
+     * The way back out of a zoom on a chart whose toolbar is hidden. While the
+     * chart is zoomed and nothing else on screen can reset it, one reset
+     * control is drawn where the toolbar would have been, and it goes when the
+     * range does; `Escape` resets the zoom as well. `'auto'` supplies both only
+     * where there is no reset button already, `true` also forces the control on
+     * where `toolbar.tools.reset` is off, and `false` turns both off for a page
+     * that supplies its own reset. Requires `enabled: true`.
+     * @default 'auto'
+     */
+    resetControl?: boolean | 'auto'
     zoomedArea?: {
       fill?: {
         color?: string
@@ -2656,6 +2742,12 @@ type ApexPlotOptions = {
     distributed?: boolean
     borderRadius?: number;
     borderRadiusApplication?: 'around' | 'end';
+    /**
+     * Which segments of a stack round. 'all' (default) caps both ends of the
+     * stack, the baseline and the far end; 'last' caps only the far end so
+     * the stack sits square on the baseline. Stacked bar/column only.
+     */
+    borderRadiusWhenStacked?: 'all' | 'last';
     hideZeroBarsWhenGrouped?: boolean
     rangeBarOverlap?: boolean
     rangeBarGroupRows?: boolean