@highcharts/grid-pro 2.2.0 → 2.3.1

package/es-modules/Core/Defaults.js

@@ -14,8 +14,7 @@ import H from './Globals.js';
 const { isTouchDevice } = H;
 import Palettes from './Color/Palettes.js';
 import Time from './Time.js';
-import U from './Utilities.js';
-const { fireEvent, merge } = U;
+import { fireEvent, merge } from '../Shared/Utilities.js';
 /* *
  *
  *  API Options
@@ -990,6 +989,9 @@ const defaultOptions = {
          * columns. Setting this to `false` makes room for more items, but will
          * look more messy.
          *
+         * @sample highcharts/legend/aligncolumns
+         *         Align columns
+         *
          * @since 6.1.0
          */
         alignColumns: true,
@@ -1120,16 +1122,21 @@ const defaultOptions = {
          * for each legend label. Available variables relates to properties on
          * the series, or the point in case of pies.
          *
+         * @sample {highcharts} highcharts/legend/labelformat/
+         *         Add text
+         *
          * @type      {string}
          * @default   {name}
          * @since     1.3
          * @apioption legend.labelFormat
          */
-        /* eslint-disable valid-jsdoc */
         /**
          * Callback function to format each of the series' labels. The `this`
          * keyword refers to the series object, or the point object in case of
-         * pie charts. By default the series or point name is printed.
+         * pie charts. By default the series or point name is printed. Since
+         * v12.5.0, the callback also receives `ctx` as the first argument, so
+         * that arrow functions can access the same context as regular
+         * functions using `this`.
          *
          * @productdesc {highmaps}
          * In Highmaps the context can also be a data class in case of a
@@ -2025,13 +2032,18 @@ const defaultOptions = {
          * @sample {highmaps} maps/tooltip/formatter/
          *         String formatting
          *
+         * Since v12.5.0, the callback also receives `ctx` as the second
+         * argument, so that arrow functions can access the same context as
+         * regular functions using `this`.
+         *
          * @type      {Highcharts.TooltipFormatterCallbackFunction}
          * @apioption tooltip.formatter
          */
         /**
          * Callback function to format the text of the tooltip for
          * visible null points.
-         * Works analogously to [formatter](#tooltip.formatter).
+         * Works analogously to [formatter](#tooltip.formatter), including the
+         * `ctx` callback argument added in v12.5.0.
          *
          * @sample highcharts/plotoptions/series-nullformat
          *         Format data label and tooltip for null point.
@@ -2065,7 +2077,9 @@ const defaultOptions = {
         /**
          * A callback function for formatting the HTML output for a single point
          * in the tooltip. Like the `pointFormat` string, but with more
-         * flexibility.
+         * flexibility. Since v12.5.0, the callback also receives `ctx` as the
+         * first argument, so that arrow functions can access the same context
+         * as regular functions using `this`.
          *
          * @type      {Highcharts.FormatterCallbackFunction<Highcharts.Point>}
          * @since     4.1.0
@@ -2074,10 +2088,13 @@ const defaultOptions = {
          */
         /**
          * A callback function to place the tooltip in a custom position. The
-         * callback receives three parameters: `labelWidth`, `labelHeight` and
-         * `point`, where point contains values for `plotX` and `plotY` telling
-         * where the reference point is in the plot area. Add `chart.plotLeft`
-         * and `chart.plotTop` to get the full coordinates.
+         * callback receives four parameters: `labelWidth`, `labelHeight`,
+         * `point`, and `ctx`, where point contains values for `plotX` and
+         * `plotY` telling where the reference point is in the plot area, and
+         * `ctx` is the tooltip context (so that arrow-functions can access the
+         * same context as a normal function using `this`). Add
+         * `chart.plotLeft` and `chart.plotTop` to get the full coordinates.
+         * Since v12.5.0, the callback receives `ctx`.
          *
          * To find the actual hovered `Point` instance, use
          * `this.chart.hoverPoint`. For shared or split tooltips, all the hover
@@ -2301,6 +2318,15 @@ const defaultOptions = {
          * @since 3.0
          */
         hideDelay: 500,
+        /**
+         * The number of milliseconds to wait until the tooltip is shown when
+         * mouse over a point. Works on initial hover.
+         *
+         * @sample {highcharts|highstock} highcharts/tooltip/showdelay/
+         *
+         * @since next
+         */
+        showDelay: 0,
         /**
          * Padding inside the tooltip, in pixels.
          *

package/es-modules/Core/Delaunay.d.ts

@@ -0,0 +1 @@
+export default Delaunay;

package/es-modules/Core/Delaunay.js

@@ -0,0 +1,312 @@
+/* *
+ *
+ *  (c) 2009-2026 Highsoft AS
+ *
+ *  A commercial license may be required depending on use.
+ *  See www.highcharts.com/license
+ *
+ *
+ *  Authors:
+ *  - Dawid Dragula
+ *
+ * */
+'use strict';
+/* *
+ *
+ *  Class
+ *
+ * */
+/**
+ * Delaunay triangulation of a 2D point set.
+ *
+ * @internal
+ */
+class Delaunay {
+    /* *
+     *
+     *  Constructor
+     *
+     * */
+    /**
+     * Create a new Delaunay triangulation.
+     *
+     * @param {Float32Array|Float64Array} points
+     * A 1D array of points in the format [x0, y0, x1, y1, ...].
+     */
+    constructor(points) {
+        this.points = points;
+        const n = points.length >>> 1;
+        // Floating-point error multiplier used by geometric predicates.
+        this.epsilon = 4 * Number.EPSILON;
+        let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+        for (let i = 0; i < n; i++) {
+            const px = points[i << 1], py = points[(i << 1) + 1];
+            if (px < minX) {
+                minX = px;
+            }
+            if (px > maxX) {
+                maxX = px;
+            }
+            if (py < minY) {
+                minY = py;
+            }
+            if (py > maxY) {
+                maxY = py;
+            }
+        }
+        const rangeX = maxX - minX || 1, rangeY = maxY - minY || 1;
+        this.minX = minX;
+        this.minY = minY;
+        this.invScaleX = 1 / rangeX;
+        this.invScaleY = 1 / rangeY;
+        const ids = new Uint32Array(n), x = (i) => (points[i << 1] - minX) * this.invScaleX, y = (i) => (points[(i << 1) + 1] - minY) * this.invScaleY;
+        for (let i = 0; i < n; i++) {
+            ids[i] = i;
+        }
+        ids.sort((a, b) => (x(a) - x(b)) || (y(a) - y(b)));
+        let m = n ? 1 : 0, pa, pb;
+        for (let i = 1; i < n; ++i) {
+            pa = ids[m - 1],
+                pb = ids[i];
+            if (x(pa) !== x(pb) || y(pa) !== y(pb)) {
+                ids[m++] = pb;
+            }
+        }
+        this.ids = ids.subarray(0, m);
+        this.triangles = this.triangulate();
+    }
+    /* *
+     *
+     *  Methods
+     *
+     * */
+    /**
+     * Triangulate the points.
+     *
+     * @return {Uint32Array}
+     * A 1D array of triangle vertex indices.
+     */
+    triangulate() {
+        const count = this.ids.length;
+        if (count < 3) {
+            return new Uint32Array(0);
+        }
+        const points = this.points, { minX, minY, invScaleX, invScaleY } = this, x = (i) => (points[i << 1] - minX) * invScaleX, y = (i) => (points[(i << 1) + 1] - minY) * invScaleY;
+        // Determine if three points are in counter-clockwise order.
+        const orient = (a, b, c) => {
+            const ax = x(a), ay = y(a), bx = x(b) - ax, by = y(b) - ay, cx = x(c) - ax, cy = y(c) - ay, det = bx * cy - by * cx, err = (Math.abs(bx * cy) + Math.abs(by * cx)) * this.epsilon;
+            return det > err;
+        };
+        // Determine if a point (d) is inside the circumcircle of a triangle
+        // (a, b, c).
+        const inCircle = (a, b, c, d) => {
+            if (a === d || b === d || c === d) {
+                // Skip if d is one of the triangle vertices.
+                return false;
+            }
+            const ax = x(a) - x(d), ay = y(a) - y(d), bx = x(b) - x(d), by = y(b) - y(d), cx = x(c) - x(d), cy = y(c) - y(d), aa = ax * ax + ay * ay, bb = bx * bx + by * by, cc = cx * cx + cy * cy, term1 = by * cc - bb * cy, term2 = bx * cc - bb * cx, term3 = bx * cy - by * cx, det = ax * term1 - ay * term2 + aa * term3, err = (Math.abs(ax * term1) +
+                Math.abs(ay * term2) +
+                Math.abs(aa * term3)) * this.epsilon;
+            return det > err;
+        };
+        // Data structures for the quad-edge data structure.
+        let cap = Math.max(32, ((8 * count + 7) & ~3)), // Capacity (% 4 = 0)
+        on = new Int32Array(cap), // Next edge in same face
+        rt = new Int32Array(cap), // Rotation of edge (90 degrees)
+        vtx = new Uint32Array(cap), // Origin vertex of edge
+        seen = new Uint8Array(cap), // Visited flag for edge traversal
+        top = 0; // Next free edge id (% 4 = 0)
+        // Ensure the data structures have enough capacity for the required
+        // number of edges.
+        const ensure = (need) => {
+            // If the capacity is sufficient, return.
+            if (need <= cap) {
+                return;
+            }
+            // Double capacity until sufficient.
+            let ncap = cap << 1;
+            while (ncap < need) {
+                ncap <<= 1;
+            }
+            const on2 = new Int32Array(ncap), rt2 = new Int32Array(ncap), v2 = new Uint32Array(ncap), s2 = new Uint8Array(ncap);
+            on2.set(on);
+            rt2.set(rt);
+            v2.set(vtx);
+            s2.set(seen);
+            on = on2;
+            rt = rt2;
+            vtx = v2;
+            seen = s2;
+            cap = ncap;
+        };
+        const sym = (e) => rt[rt[e]], rotSym = (e) => sym(rt[e]), dest = (e) => vtx[sym(e)], lnext = (e) => rt[on[rotSym(e)]], oprev = (e) => rt[on[rt[e]]], rprev = (e) => on[sym(e)], leftOf = (p, e) => orient(p, vtx[e], dest(e)), rightOf = (p, e) => orient(p, dest(e), vtx[e]), admissible = (e, base) => rightOf(dest(e), base);
+        // Create a new edge between two vertices.
+        const makeEdge = (a, b) => {
+            ensure(top + 4);
+            const e0 = top, e1 = top + 1, e2 = top + 2, e3 = top + 3;
+            top += 4;
+            // Rot cycle
+            rt[e0] = e1;
+            rt[e1] = e2;
+            rt[e2] = e3;
+            rt[e3] = e0;
+            // Onext initial
+            on[e0] = e0;
+            on[e2] = e2;
+            on[e1] = e3;
+            on[e3] = e1;
+            // Origins
+            vtx[e0] = a;
+            vtx[e2] = b;
+            vtx[e1] = 0xffffffff;
+            vtx[e3] = 0xffffffff;
+            return e0;
+        };
+        // Splice two edges.
+        const splice = (a, b) => {
+            const alpha = rt[on[a]];
+            const beta = rt[on[b]];
+            const t2 = on[a];
+            const t3 = on[beta];
+            const t4 = on[alpha];
+            on[a] = on[b];
+            on[b] = t2;
+            on[alpha] = t3;
+            on[beta] = t4;
+        };
+        // Connect two edges.
+        const connect = (a, b) => {
+            const q = makeEdge(dest(a), vtx[b]);
+            splice(q, lnext(a));
+            splice(sym(q), b);
+            return q;
+        };
+        // Removes an edge from both sides.
+        const drop = (e) => {
+            splice(e, oprev(e));
+            const es = sym(e);
+            splice(es, oprev(es));
+        };
+        const A = this.ids;
+        // Recursively triangulate a range [lo, hi) of points. Returns the
+        // two endpoints [left, right] of the lower common tangent.
+        const solve = (lo, hi) => {
+            const len = hi - lo;
+            // If there are only two points, create a single edge.
+            if (len === 2) {
+                const a = makeEdge(A[lo], A[lo + 1]);
+                return [a, sym(a)];
+            }
+            // If there are three points, create two edges and connect them.
+            if (len === 3) {
+                const a = makeEdge(A[lo], A[lo + 1]), b = makeEdge(A[lo + 1], A[lo + 2]);
+                splice(sym(a), b);
+                const p0 = A[lo], p1 = A[lo + 1], p2 = A[lo + 2];
+                if (orient(p0, p1, p2)) {
+                    connect(b, a);
+                    return [a, sym(b)];
+                }
+                if (orient(p0, p2, p1)) {
+                    const c = connect(b, a);
+                    return [sym(c), c];
+                }
+                return [a, sym(b)];
+            }
+            // Find the midpoint of the range.
+            const mid = lo + ((len + 1) >>> 1);
+            const L = solve(lo, mid);
+            const R = solve(mid, hi);
+            let ldo = L[0], ldi = L[1], rdi = R[0], rdo = R[1];
+            // Lower common tangent
+            for (;;) {
+                if (leftOf(vtx[rdi], ldi)) {
+                    ldi = lnext(ldi);
+                }
+                else if (rightOf(vtx[ldi], rdi)) {
+                    rdi = rprev(rdi);
+                }
+                else {
+                    break;
+                }
+            }
+            let base = connect(sym(rdi), ldi);
+            if (vtx[ldi] === vtx[ldo]) {
+                ldo = sym(base);
+            }
+            if (vtx[rdi] === vtx[rdo]) {
+                rdo = base;
+            }
+            // Merge loop - removing bad edges (inCircle) and adding new edges.
+            for (;;) {
+                // Left candidate
+                let lc = on[sym(base)];
+                if (admissible(lc, base)) {
+                    while (inCircle(dest(base), vtx[base], dest(lc), dest(on[lc]))) {
+                        const t = on[lc];
+                        drop(lc);
+                        lc = t;
+                    }
+                }
+                // Right candidate
+                let rc = oprev(base);
+                if (admissible(rc, base)) {
+                    while (inCircle(dest(base), vtx[base], dest(rc), dest(oprev(rc)))) {
+                        const t = oprev(rc);
+                        drop(rc);
+                        rc = t;
+                    }
+                }
+                if (!admissible(lc, base) && !admissible(rc, base)) {
+                    break;
+                }
+                if (!admissible(lc, base) || (admissible(rc, base) &&
+                    inCircle(dest(lc), vtx[lc], vtx[rc], dest(rc)))) {
+                    base = connect(rc, sym(base));
+                }
+                else {
+                    base = connect(sym(base), sym(lc));
+                }
+            }
+            return [ldo, rdo];
+        };
+        let e0 = solve(0, count)[0];
+        while (leftOf(dest(on[e0]), e0)) {
+            e0 = on[e0];
+        }
+        const Q = [e0];
+        let qi = 0;
+        {
+            let c = e0;
+            do {
+                Q.push(sym(c));
+                seen[c] = 1;
+                c = lnext(c);
+            } while (c !== e0);
+        }
+        const faces = [];
+        let cur, t;
+        while (qi < Q.length) {
+            const e = Q[qi++];
+            if (seen[e]) {
+                continue;
+            }
+            cur = e;
+            do {
+                faces.push(vtx[cur]);
+                t = sym(cur);
+                if (!seen[t]) {
+                    Q.push(t);
+                }
+                seen[cur] = 1;
+                cur = lnext(cur);
+            } while (cur !== e);
+        }
+        return new Uint32Array(faces);
+    }
+}
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default Delaunay;

package/es-modules/Core/Foundation.js

@@ -9,8 +9,7 @@
  *
  * */
 'use strict';
-import U from './Utilities.js';
-const { addEvent, isFunction, objectEach, removeEvent } = U;
+import { addEvent, isFunction, objectEach, removeEvent } from '../Shared/Utilities.js';
 /* *
  *
  *  Class Namespace
@@ -24,7 +23,6 @@ var Foundation;
      *  Functions
      *
      * */
-    /* eslint-disable valid-jsdoc */
     /**
      * Register event options. If an event handler is set on the options, it
      * should be subject to Chart.update, Axis.update and Series.update. This is

package/es-modules/Core/Geometry/CircleUtilities.js

@@ -9,9 +9,8 @@
  * */
 'use strict';
 import Geometry from './GeometryUtilities.js';
-import Utilities from '../Utilities';
+import { correctFloat } from '../../Shared/Utilities.js';
 const { getAngleBetweenPoints, getCenterOfPoints, getDistanceBetweenPoints } = Geometry;
-const { correctFloat } = Utilities;
 /* *
  *
  *  Namespace

package/es-modules/Core/Globals.js

@@ -25,7 +25,7 @@ var Globals;
      *  Constants
      *
      * */
-    Globals.SVG_NS = 'http://www.w3.org/2000/svg', Globals.product = 'Highcharts', Globals.version = '2.2.0', Globals.win = (typeof window !== 'undefined' ?
+    Globals.SVG_NS = 'http://www.w3.org/2000/svg', Globals.product = 'Highcharts', Globals.version = '2.3.1', Globals.win = (typeof window !== 'undefined' ?
         window :
         {}), // eslint-disable-line node/no-unsupported-features/es-builtins
     Globals.doc = Globals.win.document, Globals.svg = !!Globals.doc?.createElementNS?.(Globals.SVG_NS, 'svg')?.createSVGRect, Globals.pageLang = Globals.doc?.documentElement?.closest('[lang]')?.lang, Globals.userAgent = Globals.win.navigator?.userAgent || '', Globals.isChrome = Globals.win.chrome, Globals.isFirefox = Globals.userAgent.indexOf('Firefox') !== -1, Globals.isMS = /(edge|msie|trident)/i.test(Globals.userAgent) && !Globals.win.opera, Globals.isSafari = !Globals.isChrome && Globals.userAgent.indexOf('Safari') !== -1, Globals.isTouchDevice = /(Mobile|Android|Windows Phone)/.test(Globals.userAgent), Globals.isWebKit = Globals.userAgent.indexOf('AppleWebKit') !== -1, Globals.deg2rad = Math.PI * 2 / 360, Globals.marginNames = [

package/es-modules/Core/HttpUtilities.js

@@ -11,8 +11,7 @@
 'use strict';
 import G from '../Core/Globals.js';
 const { win } = G;
-import U from '../Core/Utilities.js';
-const { discardElement, objectEach } = U;
+import { discardElement, objectEach } from '../Shared/Utilities.js';
 /* *
  *
  *  Functions

package/es-modules/Core/MSPointer.js

@@ -12,8 +12,7 @@
 import H from './Globals.js';
 const { charts, composed, doc, noop, win } = H;
 import Pointer from './Pointer.js';
-import U from './Utilities.js';
-const { addEvent, attr, css, defined, objectEach, pick, pushUnique, removeEvent } = U;
+import { addEvent, attr, css, defined, objectEach, pick, pushUnique, removeEvent } from '../Shared/Utilities.js';
 /* *
  *
  *  Constants
@@ -27,7 +26,6 @@ const hasPointerEvent = !!win.PointerEvent;
  *  Functions
  *
  * */
-/* eslint-disable valid-jsdoc */
 /** @internal */
 function getWebkitTouches() {
     const fake = [];

package/es-modules/Core/Math3D.js

@@ -10,9 +10,8 @@
  * */
 'use strict';
 import H from './Globals.js';
+import { pick } from '../Shared/Utilities.js';
 const { deg2rad } = H;
-import U from './Utilities.js';
-const { pick } = U;
 /* *
  *
  *  Functions

package/es-modules/Core/Options.d.ts

@@ -194,7 +194,7 @@ export interface LoadingOptions {
      * @sample highcharts/loading/hideduration/
      *         Fade in and out over a second
      *
-     * @default   100
+     * @default   0
      * @since     1.2.0
      */
     showDuration?: number;
@@ -233,11 +233,15 @@ export interface LoadingOptions {
  * The thousands separator, defaults to the one given in the lang options, or a
  * space character.
  *
+ * @param {Highcharts.Chart} [ctx]
+ * Since v12.5.0, the chart context passed as an extra argument for arrow
+ * functions.
+ *
  * @return {string}
  * The formatted number.
  */
 export interface NumberFormatterCallbackFunction {
-    (this: Chart | object | void, number: number, decimals: number, decimalPoint?: string, thousandsSep?: string): string;
+    (this: Chart | object | void, number: number, decimals: number, decimalPoint?: string, thousandsSep?: string, ctx?: Chart): string;
 }
 /**
  * Global options for all charts.

package/es-modules/Core/Pointer.js

@@ -13,8 +13,25 @@ import Color from './Color/Color.js';
 const { parse: color } = Color;
 import H from './Globals.js';
 const { charts, composed, isTouchDevice } = H;
-import U from './Utilities.js';
-const { addEvent, attr, css, extend, find, fireEvent, isNumber, isObject, objectEach, offset, pick, pushUnique, splat } = U;
+import { addEvent, attr, css, defined, extend, find, fireEvent, isNumber, isObject, objectEach, offset, pick, pushUnique, splat } from '../Shared/Utilities.js';
+/**
+ *
+ *  Functions
+ *
+ */
+/**
+ * Check whether the configured action key allows the interaction.
+ *
+ * @internal
+ * @param {Event} e
+ *        A mouse event.
+ * @param {string | undefined} key
+ *        Zoom or pan key.
+ * @return {boolean}
+ *         True if the key is undefined
+ *         or if the action key is pressed. False otherwise.
+ */
+const checkActionKey = (e, key) => !defined(key) || e[`${key}Key`];
 /* *
  *
  *  Class
@@ -212,7 +229,8 @@ class Pointer {
                 selectionMarker.attr(attrs);
             }
             // Panning
-            if (clickedInside && !selectionMarker && panningEnabled) {
+            if (clickedInside && !selectionMarker && panningEnabled &&
+                (checkActionKey(e, panKey))) {
                 chart.pan(e, panning);
             }
         }
@@ -1444,7 +1462,8 @@ class Pointer {
         this.zoomY = zoomY = /y/.test(zoomType);
         this.zoomHor = (zoomX && !inverted) || (zoomY && inverted);
         this.zoomVert = (zoomY && !inverted) || (zoomX && inverted);
-        this.hasZoom = zoomX || zoomY;
+        this.hasZoom = (zoomX || zoomY) &&
+            (checkActionKey(e, chart.zooming.key));
     }
 }
 /** @internal */

package/es-modules/Core/PointerEvent.d.ts

@@ -8,10 +8,12 @@ export interface PointerEvent extends globalThis.PointerEvent {
     accumulate?: boolean;
     chartX: number;
     chartY: number;
+    DOMType?: string;
     lat?: number;
     lon?: number;
     point?: Point;
     touches?: Array<Touch>;
+    trigger?: string;
     xAxis?: Array<Pointer.AxisCoordinateObject>;
     yAxis?: Array<Pointer.AxisCoordinateObject>;
 }

package/es-modules/Core/Renderer/HTML/AST.js

@@ -11,8 +11,8 @@
 'use strict';
 import H from '../../Globals.js';
 const { SVG_NS, win } = H;
-import U from '../../Utilities.js';
-const { attr, createElement, css, error, isFunction, isString, objectEach, splat } = U;
+import { attr, createElement, css, isFunction, isString, objectEach, splat } from '../../../Shared/Utilities.js';
+import { error } from '../../Utilities.js';
 const { trustedTypes } = win;
 /* *
  *

package/es-modules/Core/Renderer/HTML/HTMLAttributes.d.ts

@@ -13,6 +13,8 @@ export interface HTMLAttributes {
     href?: string;
     htmlFor?: string;
     id?: string;
+    min?: string;
+    max?: string;
     name?: string;
     onclick?: any;
     onload?: any;
@@ -24,6 +26,7 @@ export interface HTMLAttributes {
     rel?: string;
     role?: string;
     src?: string;
+    step?: string;
     rowspan?: number;
     summary?: string;
     tabindex?: number;

package/es-modules/Core/Renderer/HTML/HTMLElement.js

@@ -13,8 +13,7 @@ import AST from './AST.js';
 import H from '../../Globals.js';
 const { composed, isFirefox } = H;
 import SVGElement from '../SVG/SVGElement.js';
-import U from '../../Utilities.js';
-const { attr, css, createElement, defined, extend, getAlignFactor, isNumber, pInt, pushUnique } = U;
+import { attr, createElement, css, defined, extend, getAlignFactor, isNumber, pInt, pushUnique } from '../../../Shared/Utilities.js';
 /**
  * The opacity and visibility properties are set as attributes on the main
  * element and SVG groups, and as identical CSS properties on the HTML element