@highcharts/grid-pro 2.0.0

package/es-modules/Core/HttpUtilities.js

@@ -0,0 +1,214 @@
+/* *
+ *
+ *  (c) 2010-2025 Christer Vasseng, Torstein Honsi
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+import G from '../Core/Globals.js';
+const { win } = G;
+import U from '../Core/Utilities.js';
+const { discardElement, objectEach } = U;
+/* *
+ *
+ *  Functions
+ *
+ * */
+/**
+ * Perform an Ajax call.
+ *
+ * @function Highcharts.ajax
+ *
+ * @param {Highcharts.AjaxSettingsObject} settings
+ * The Ajax settings to use.
+ *
+ * @return {false | undefined}
+ * Returns false, if error occurred.
+ */
+function ajax(settings) {
+    const headers = {
+        json: 'application/json',
+        xml: 'application/xml',
+        text: 'text/plain',
+        octet: 'application/octet-stream'
+    }, r = new XMLHttpRequest();
+    /**
+     * Private error handler.
+     *
+     * @private
+     *
+     * @param {XMLHttpRequest} xhr
+     * Internal request object.
+     * @param {string | Error} err
+     * Occurred error.
+     */
+    function handleError(xhr, err) {
+        if (settings.error) {
+            settings.error(xhr, err);
+        }
+        else {
+            // @todo Maybe emit a highcharts error event here
+        }
+    }
+    if (!settings.url) {
+        return false;
+    }
+    r.open((settings.type || 'get').toUpperCase(), settings.url, true);
+    if (!settings.headers?.['Content-Type']) {
+        r.setRequestHeader('Content-Type', headers[settings.dataType || 'json'] || headers.text);
+    }
+    objectEach(settings.headers, function (val, key) {
+        r.setRequestHeader(key, val);
+    });
+    if (settings.responseType) {
+        r.responseType = settings.responseType;
+    }
+    // @todo lacking timeout handling
+    r.onreadystatechange = function () {
+        let res;
+        if (r.readyState === 4) {
+            if (r.status === 200) {
+                if (settings.responseType !== 'blob') {
+                    res = r.responseText;
+                    if (settings.dataType === 'json') {
+                        try {
+                            res = JSON.parse(res);
+                        }
+                        catch (e) {
+                            if (e instanceof Error) {
+                                return handleError(r, e);
+                            }
+                        }
+                    }
+                }
+                return settings.success?.(res, r);
+            }
+            handleError(r, r.responseText);
+        }
+    };
+    if (settings.data && typeof settings.data !== 'string') {
+        settings.data = JSON.stringify(settings.data);
+    }
+    r.send(settings.data);
+}
+/**
+ * Get a JSON resource over XHR, also supporting CORS without preflight.
+ *
+ * @function Highcharts.getJSON
+ *
+ * @param {string} url
+ * The URL to load.
+ * @param {Function} success
+ * The success callback. For error handling, use the `Highcharts.ajax` function
+ * instead.
+ */
+function getJSON(url, success) {
+    HttpUtilities.ajax({
+        url: url,
+        success: success,
+        dataType: 'json',
+        headers: {
+            // Override the Content-Type to avoid preflight problems with CORS
+            // in the Highcharts demos
+            'Content-Type': 'text/plain'
+        }
+    });
+}
+/**
+ * The post utility.
+ *
+ * @private
+ * @function Highcharts.post
+ *
+ * @param {string} url
+ * Post URL.
+ * @param {Object} data
+ * Post data.
+ * @param {RequestInit} [fetchOptions]
+ * Additional attributes for the post request.
+ */
+async function post(url, data, fetchOptions) {
+    // Prepare a form to send the data
+    const formData = new win.FormData();
+    // Add the data to the form
+    objectEach(data, function (value, name) {
+        formData.append(name, value);
+    });
+    formData.append('b64', 'true');
+    // Send the POST
+    const response = await win.fetch(url, {
+        method: 'POST',
+        body: formData,
+        ...fetchOptions
+    });
+    // Check the response
+    if (response.ok) {
+        // Get the text from the response
+        const text = await response.text();
+        // Prepare self-click link with the Base64 representation
+        const link = document.createElement('a');
+        link.href = `data:${data.type};base64,${text}`;
+        link.download = data.filename;
+        link.click();
+        // Remove the link
+        discardElement(link);
+    }
+}
+/* *
+ *
+ *  Default Export
+ *
+ * */
+const HttpUtilities = {
+    ajax,
+    getJSON,
+    post
+};
+export default HttpUtilities;
+/* *
+ *
+ *  API Declarations
+ *
+ * */
+/**
+ * @interface Highcharts.AjaxSettingsObject
+ */ /**
+* The payload to send.
+*
+* @name Highcharts.AjaxSettingsObject#data
+* @type {string | Highcharts.Dictionary<any> | undefined}
+*/ /**
+* The data type expected.
+*
+* @name Highcharts.AjaxSettingsObject#dataType
+* @type {"json" | "xml" | "text" | "octet" | undefined}
+*/ /**
+* Function to call on error.
+*
+* @name Highcharts.AjaxSettingsObject#error
+* @type {Function | undefined}
+*/ /**
+* The headers; keyed on header name.
+*
+* @name Highcharts.AjaxSettingsObject#headers
+* @type {Highcharts.Dictionary<string> | undefined}
+*/ /**
+* Function to call on success.
+*
+* @name Highcharts.AjaxSettingsObject#success
+* @type {Function | undefined}
+*/ /**
+* The HTTP method to use. For example GET or POST.
+*
+* @name Highcharts.AjaxSettingsObject#type
+* @type {string | undefined}
+*/ /**
+* The URL to call.
+*
+* @name Highcharts.AjaxSettingsObject#url
+* @type {string}
+*/
+(''); // Keeps doclets above in JS file

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

@@ -0,0 +1,74 @@
+import type Chart from './Chart/Chart';
+import type Options from './Options';
+import type PointerEvent from './PointerEvent';
+import Pointer from './Pointer.js';
+import DOMElementType from './Renderer/DOMElementType';
+declare global {
+    /** @deprecated */
+    interface MSPointerEvent extends Partial<PointerEvent> {
+        /** @deprecated */
+        readonly MSPOINTER_TYPE_TOUCH: string;
+        readonly currentTarget?: EventTarget;
+        readonly pointerId: number;
+        readonly pointerType?: undefined;
+        /** @deprecated */
+        readonly toElement: Element;
+    }
+    interface Window {
+        /** @deprecated */
+        MSPointerEvent?: Class<MSPointerEvent>;
+    }
+}
+/** @private */
+declare class MSPointer extends Pointer {
+    static isRequired(): boolean;
+    /**
+     * Add or remove the MS Pointer specific events
+     * @private
+     * @function Highcharts.Pointer#batchMSEvents
+     */
+    private batchMSEvents;
+    destroy(): void;
+    constructor(chart: Chart, options: Options);
+    /**
+     * Utility to detect whether an element has, or has a parent with, a
+     * specific class name. Used on detection of tracker objects and on deciding
+     * whether hovering the tooltip should cause the active series to mouse out.
+     *
+     * @function Highcharts.Pointer#inClass
+     *
+     * @param {Highcharts.SVGDOMElement|Highcharts.HTMLDOMElement} element
+     * The element to investigate.
+     *
+     * @param {string} className
+     * The class name to look for.
+     *
+     * @return {boolean|undefined}
+     * True if either the element or one of its parents has the given class
+     * name.
+     */
+    inClass(element: DOMElementType, className: string): (boolean | undefined);
+    /**
+     * @private
+     * @function Highcharts.Pointer#onContainerPointerDown
+     */
+    private onContainerPointerDown;
+    /**
+     * @private
+     * @function Highcharts.Pointer#onContainerPointerMove
+     */
+    private onContainerPointerMove;
+    /**
+     * @private
+     * @function Highcharts.Pointer#onDocumentPointerUp
+     */
+    private onDocumentPointerUp;
+    setDOMEvents(): void;
+}
+declare namespace MSPointer {
+    /**
+     * @private
+     */
+    function compose(ChartClass: typeof Chart): void;
+}
+export default MSPointer;

package/es-modules/Core/MSPointer.js

@@ -0,0 +1,218 @@
+/* *
+ *
+ *  (c) 2010-2025 Torstein Honsi
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+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;
+/* *
+ *
+ *  Constants
+ *
+ * */
+// The touches object keeps track of the points being touched at all times
+const touches = {};
+const hasPointerEvent = !!win.PointerEvent;
+/* *
+ *
+ *  Functions
+ *
+ * */
+/* eslint-disable valid-jsdoc */
+/** @private */
+function getWebkitTouches() {
+    const fake = [];
+    fake.item = function (i) {
+        return this[i];
+    };
+    objectEach(touches, function (touch) {
+        fake.push({
+            pageX: touch.pageX,
+            pageY: touch.pageY,
+            target: touch.target
+        });
+    });
+    return fake;
+}
+/** @private */
+function translateMSPointer(e, method, wktype, func) {
+    const pointer = charts[Pointer.hoverChartIndex ?? -1]?.pointer;
+    if (pointer &&
+        (e.pointerType === 'touch' ||
+            e.pointerType === e.MSPOINTER_TYPE_TOUCH)) {
+        func(e);
+        pointer[method]({
+            type: wktype,
+            target: e.currentTarget,
+            preventDefault: noop,
+            touches: getWebkitTouches()
+        });
+    }
+}
+/* *
+ *
+ *  Class
+ *
+ * */
+/** @private */
+class MSPointer extends Pointer {
+    /* *
+     *
+     *  Static Functions
+     *
+     * */
+    static isRequired() {
+        return !!(!win.TouchEvent && (win.PointerEvent || win.MSPointerEvent));
+    }
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Add or remove the MS Pointer specific events
+     * @private
+     * @function Highcharts.Pointer#batchMSEvents
+     */
+    batchMSEvents(fn) {
+        fn(this.chart.container, hasPointerEvent ? 'pointerdown' : 'MSPointerDown', this.onContainerPointerDown);
+        fn(this.chart.container, hasPointerEvent ? 'pointermove' : 'MSPointerMove', this.onContainerPointerMove);
+        fn(doc, hasPointerEvent ? 'pointerup' : 'MSPointerUp', this.onDocumentPointerUp);
+    }
+    // Destroy MS events also
+    destroy() {
+        this.batchMSEvents(removeEvent);
+        super.destroy();
+    }
+    // Disable default IE actions for pinch and such on chart element
+    constructor(chart, options) {
+        super(chart, options);
+        if (this.hasZoom) { // #4014
+            css(chart.container, {
+                '-ms-touch-action': 'none',
+                'touch-action': 'none'
+            });
+        }
+    }
+    /**
+     * Utility to detect whether an element has, or has a parent with, a
+     * specific class name. Used on detection of tracker objects and on deciding
+     * whether hovering the tooltip should cause the active series to mouse out.
+     *
+     * @function Highcharts.Pointer#inClass
+     *
+     * @param {Highcharts.SVGDOMElement|Highcharts.HTMLDOMElement} element
+     * The element to investigate.
+     *
+     * @param {string} className
+     * The class name to look for.
+     *
+     * @return {boolean|undefined}
+     * True if either the element or one of its parents has the given class
+     * name.
+     */
+    inClass(element, className) {
+        let elem = element, elemClassName;
+        while (elem) {
+            elemClassName = attr(elem, 'class');
+            if (elemClassName) {
+                if (elemClassName.indexOf(className) !== -1) {
+                    return true;
+                }
+                if (elemClassName.indexOf('highcharts-container') !== -1) {
+                    return false;
+                }
+            }
+            // #21098 IE11 compatibility
+            elem = elem.parentNode;
+            if (elem && (
+            // HTMLElement
+            elem === document.documentElement ||
+                // Document
+                defined(elem.nodeType) &&
+                    elem.nodeType === document.nodeType)) {
+                elem = null;
+            }
+        }
+    }
+    /**
+     * @private
+     * @function Highcharts.Pointer#onContainerPointerDown
+     */
+    onContainerPointerDown(e) {
+        translateMSPointer(e, 'onContainerTouchStart', 'touchstart', function (e) {
+            touches[e.pointerId] = {
+                pageX: e.pageX,
+                pageY: e.pageY,
+                target: e.currentTarget
+            };
+        });
+    }
+    /**
+     * @private
+     * @function Highcharts.Pointer#onContainerPointerMove
+     */
+    onContainerPointerMove(e) {
+        translateMSPointer(e, 'onContainerTouchMove', 'touchmove', function (e) {
+            touches[e.pointerId] = ({ pageX: e.pageX, pageY: e.pageY });
+            if (!touches[e.pointerId].target) {
+                touches[e.pointerId].target = e.currentTarget;
+            }
+        });
+    }
+    /**
+     * @private
+     * @function Highcharts.Pointer#onDocumentPointerUp
+     */
+    onDocumentPointerUp(e) {
+        translateMSPointer(e, 'onDocumentTouchEnd', 'touchend', function (e) {
+            delete touches[e.pointerId];
+        });
+    }
+    // Add IE specific touch events to chart
+    setDOMEvents() {
+        const tooltip = this.chart.tooltip;
+        super.setDOMEvents();
+        if (this.hasZoom ||
+            pick((tooltip?.options.followTouchMove), true)) {
+            this.batchMSEvents(addEvent);
+        }
+    }
+}
+/* *
+ *
+ *  Class Namespace
+ *
+ * */
+(function (MSPointer) {
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * @private
+     */
+    function compose(ChartClass) {
+        if (pushUnique(composed, 'Core.MSPointer')) {
+            addEvent(ChartClass, 'beforeRender', function () {
+                this.pointer = new MSPointer(this, this.options);
+            });
+        }
+    }
+    MSPointer.compose = compose;
+})(MSPointer || (MSPointer = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default MSPointer;

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

@@ -0,0 +1,117 @@
+import type Chart from './Chart/Chart';
+import type Position3DObject from './Renderer/Position3DObject';
+import type PositionObject from './Renderer/PositionObject';
+declare module './Chart/ChartBase' {
+    interface ChartBase {
+        scale3d?: number;
+    }
+}
+/**
+ * Transforms a given array of points according to the angles in chart.options.
+ *
+ * @private
+ * @function Highcharts.perspective
+ *
+ * @param {Array<Highcharts.Position3DObject>} points
+ * The array of points
+ *
+ * @param {Highcharts.Chart} chart
+ * The chart
+ *
+ * @param {boolean} [insidePlotArea]
+ * Whether to verify that the points are inside the plotArea
+ *
+ * @param {boolean} [useInvertedPersp]
+ * Whether to use inverted perspective in calculations
+ *
+ * @return {Array<Highcharts.Position3DObject>}
+ * An array of transformed points
+ *
+ * @requires highcharts-3d
+ */
+declare function perspective(points: Array<Position3DObject>, chart: Chart, insidePlotArea?: boolean, useInvertedPersp?: boolean): Array<Position3DObject>;
+/**
+ * Perspective3D function is available in global Highcharts scope because is
+ * needed also outside of perspective() function (#8042).
+ * @private
+ * @function Highcharts.perspective3D
+ *
+ * @param {Highcharts.Position3DObject} coordinate
+ * 3D position
+ *
+ * @param {Highcharts.Position3DObject} origin
+ * 3D root position
+ *
+ * @param {number} distance
+ * Perspective distance
+ *
+ * @return {Highcharts.PositionObject}
+ * Perspective 3D Position
+ *
+ * @requires highcharts-3d
+ */
+declare function perspective3D(coordinate: Position3DObject, origin: Position3DObject, distance: number): PositionObject;
+/**
+ * Calculate a distance from camera to points - made for calculating zIndex of
+ * scatter points.
+ *
+ * @private
+ * @function Highcharts.pointCameraDistance
+ *
+ * @param {Highcharts.Dictionary<number>} coordinates
+ * Coordinates of the specific point
+ *
+ * @param {Highcharts.Chart} chart
+ * Related chart
+ *
+ * @return {number}
+ * Distance from camera to point
+ *
+ * @requires highcharts-3d
+ */
+declare function pointCameraDistance(coordinates: Record<string, number>, chart: Chart): number;
+/**
+ * Calculate area of a 2D polygon using Shoelace algorithm
+ * https://en.wikipedia.org/wiki/Shoelace_formula
+ *
+ * @private
+ * @function Highcharts.shapeArea
+ *
+ * @param {Array<Highcharts.PositionObject>} vertexes
+ * 2D Polygon
+ *
+ * @return {number}
+ * Calculated area
+ *
+ * @requires highcharts-3d
+ */
+declare function shapeArea(vertexes: Array<PositionObject>): number;
+/**
+ * Calculate area of a 3D polygon after perspective projection
+ *
+ * @private
+ * @function Highcharts.shapeArea3d
+ *
+ * @param {Array<Highcharts.Position3DObject>} vertexes
+ * 3D Polygon
+ *
+ * @param {Highcharts.Chart} chart
+ * Related chart
+ *
+ * @param {boolean} [insidePlotArea]
+ * Whether to verify that the points are inside the plotArea
+ *
+ * @return {number}
+ * Calculated area
+ *
+ * @requires highcharts-3d
+ */
+declare function shapeArea3D(vertexes: Array<Position3DObject>, chart: Chart, insidePlotArea?: boolean): number;
+declare const Math3D: {
+    perspective: typeof perspective;
+    perspective3D: typeof perspective3D;
+    pointCameraDistance: typeof pointCameraDistance;
+    shapeArea: typeof shapeArea;
+    shapeArea3D: typeof shapeArea3D;
+};
+export default Math3D;