highcharts 9.2.2 → 9.3.0

package/es-modules/Extensions/Sonification/TimelineEvent.js

@@ -0,0 +1,158 @@
+/* *
+ *
+ *  (c) 2009-2021 Øystein Moseng
+ *
+ *  TimelineEvent class definition.
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+import U from '../../Core/Utilities.js';
+var merge = U.merge, uniqueKey = U.uniqueKey;
+/* eslint-disable no-invalid-this, valid-jsdoc */
+/* *
+ *
+ *  Class
+ *
+ * */
+/**
+ * The TimelineEvent class. Represents a sound event on a timeline.
+ *
+ * @requires module:modules/sonification
+ *
+ * @private
+ * @class
+ * @name Highcharts.TimelineEvent
+ *
+ * @param {Highcharts.TimelineEventOptionsObject} options
+ * Options for the TimelineEvent.
+ */
+var TimelineEvent = /** @class */ (function () {
+    /* *
+     *
+     *  Constructor
+     *
+     * */
+    function TimelineEvent(options) {
+        /* *
+         *
+         *  Properties
+         *
+         * */
+        this.id = void 0;
+        this.options = void 0;
+        this.time = void 0;
+        this.init(options);
+    }
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    TimelineEvent.prototype.init = function (options) {
+        this.options = options;
+        this.time = options.time || 0;
+        this.id = this.options.id = options.id || uniqueKey();
+    };
+    /**
+     * Play the event. Does not take the TimelineEvent.time option into account,
+     * and plays the event immediately.
+     *
+     * @function Highcharts.TimelineEvent#play
+     *
+     * @param {Highcharts.TimelineEventOptionsObject} [options]
+     *        Options to pass in to the eventObject when playing it.
+     *
+     * @return {void}
+     */
+    TimelineEvent.prototype.play = function (options) {
+        var eventObject = this.options.eventObject, masterOnEnd = this.options.onEnd, playOnEnd = options && options.onEnd, playOptionsOnEnd = this.options.playOptions &&
+            this.options.playOptions.onEnd, playOptions = merge(this.options.playOptions, options);
+        if (eventObject && eventObject.sonify) {
+            // If we have multiple onEnds defined, use all
+            playOptions.onEnd = masterOnEnd || playOnEnd || playOptionsOnEnd ?
+                function () {
+                    var args = arguments;
+                    [masterOnEnd, playOnEnd, playOptionsOnEnd].forEach(function (onEnd) {
+                        if (onEnd) {
+                            onEnd.apply(this, args);
+                        }
+                    });
+                } : void 0;
+            eventObject.sonify(playOptions);
+        }
+        else {
+            if (playOnEnd) {
+                playOnEnd();
+            }
+            if (masterOnEnd) {
+                masterOnEnd();
+            }
+        }
+    };
+    /**
+     * Cancel the sonification of this event. Does nothing if the event is not
+     * currently sonifying.
+     *
+     * @function Highcharts.TimelineEvent#cancel
+     *
+     * @param {boolean} [fadeOut=false]
+     *        Whether or not to fade out as we stop. If false, the event is
+     *        cancelled synchronously.
+     */
+    TimelineEvent.prototype.cancel = function (fadeOut) {
+        var eventObject = this.options.eventObject;
+        if (eventObject) {
+            eventObject.cancelSonify(fadeOut);
+        }
+    };
+    return TimelineEvent;
+}());
+/* *
+ *
+ *  Default export
+ *
+ * */
+export default TimelineEvent;
+/* *
+ *
+ *  API Declarations
+ *
+ * */
+/**
+ * A set of options for the TimelineEvent class.
+ *
+ * @requires module:modules/sonification
+ *
+ * @private
+ * @interface Highcharts.TimelineEventOptionsObject
+ */ /**
+* The object we want to sonify when playing the TimelineEvent. Can be any
+* object that implements the `sonify` and `cancelSonify` functions. If this is
+* not supplied, the TimelineEvent is considered a silent event, and the onEnd
+* event is immediately called.
+* @name Highcharts.TimelineEventOptionsObject#eventObject
+* @type {*}
+*/ /**
+* Options to pass on to the eventObject when playing it.
+* @name Highcharts.TimelineEventOptionsObject#playOptions
+* @type {object|undefined}
+*/ /**
+* The time at which we want this event to play (in milliseconds offset). This
+* is not used for the TimelineEvent.play function, but rather intended as a
+* property to decide when to call TimelineEvent.play. Defaults to 0.
+* @name Highcharts.TimelineEventOptionsObject#time
+* @type {number|undefined}
+*/ /**
+* Unique ID for the event. Generated automatically if not supplied.
+* @name Highcharts.TimelineEventOptionsObject#id
+* @type {string|undefined}
+*/ /**
+* Callback called when the play has finished.
+* @name Highcharts.TimelineEventOptionsObject#onEnd
+* @type {Function|undefined}
+*/
+(''); // detach doclets above

package/es-modules/Extensions/Sonification/TimelinePath.js

@@ -0,0 +1,311 @@
+/* *
+ *
+ *  (c) 2009-2021 Øystein Moseng
+ *
+ *  TimelineEvent class definition.
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+import TimelineEvent from './TimelineEvent.js';
+import SU from './SonificationUtilities.js';
+import U from '../../Core/Utilities.js';
+var merge = U.merge, uniqueKey = U.uniqueKey;
+/* *
+ *
+ *  Class
+ *
+ * */
+/* eslint-disable no-invalid-this, valid-jsdoc */
+/**
+ * The TimelinePath class. Represents a track on a timeline with a list of
+ * sound events to play at certain times relative to each other.
+ *
+ * @requires module:modules/sonification
+ *
+ * @private
+ * @class
+ * @name Highcharts.TimelinePath
+ *
+ * @param {Highcharts.TimelinePathOptionsObject} options
+ *        Options for the TimelinePath.
+ */
+var TimelinePath = /** @class */ (function () {
+    /* *
+     *
+     *  Constructors
+     *
+     * */
+    function TimelinePath(options) {
+        /* *
+        *
+        *  Properties
+        *
+        * */
+        this.cursor = void 0;
+        this.events = void 0;
+        this.eventIdMap = void 0;
+        this.eventsPlaying = void 0;
+        this.id = void 0;
+        this.options = void 0;
+        this.signalHandler = void 0;
+        this.init(options);
+    }
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    TimelinePath.prototype.init = function (options) {
+        this.options = options;
+        this.id = this.options.id = options.id || uniqueKey();
+        this.cursor = 0;
+        this.eventsPlaying = {};
+        // Handle silent wait, otherwise use events from options
+        this.events = options.silentWait ?
+            [
+                new TimelineEvent({ time: 0 }),
+                new TimelineEvent({ time: options.silentWait })
+            ] :
+            this.options.events;
+        // Reference optionally provided by the user that indicates the intended
+        // duration of the path. Unused by TimelinePath itself.
+        this.targetDuration = options.targetDuration || options.silentWait;
+        // We need to sort our events by time
+        this.sortEvents();
+        // Get map from event ID to index
+        this.updateEventIdMap();
+        // Signal events to fire
+        this.signalHandler = new SU.SignalHandler(['playOnEnd', 'masterOnEnd', 'onStart', 'onEventStart', 'onEventEnd']);
+        this.signalHandler.registerSignalCallbacks(merge(options, { masterOnEnd: options.onEnd }));
+    };
+    /**
+     * Sort the internal event list by time.
+     * @private
+     */
+    TimelinePath.prototype.sortEvents = function () {
+        this.events = this.events.sort(function (a, b) {
+            return a.time - b.time;
+        });
+    };
+    /**
+     * Update the internal eventId to index map.
+     * @private
+     */
+    TimelinePath.prototype.updateEventIdMap = function () {
+        this.eventIdMap = this.events.reduce(function (acc, cur, i) {
+            acc[cur.id] = i;
+            return acc;
+        }, {});
+    };
+    /**
+     * Add events to the path. Should not be done while the path is playing.
+     * The new events are inserted according to their time property.
+     * @private
+     * @param {Array<Highcharts.TimelineEvent>} newEvents - The new timeline events
+     * to add.
+     */
+    TimelinePath.prototype.addTimelineEvents = function (newEvents) {
+        this.events = this.events.concat(newEvents);
+        this.sortEvents(); // Sort events by time
+        this.updateEventIdMap(); // Update the event ID to index map
+    };
+    /**
+     * Get the current TimelineEvent under the cursor.
+     * @private
+     * @return {Highcharts.TimelineEvent} The current timeline event.
+     */
+    TimelinePath.prototype.getCursor = function () {
+        return this.events[this.cursor];
+    };
+    /**
+     * Set the current TimelineEvent under the cursor.
+     * @private
+     * @param {string} eventId
+     * The ID of the timeline event to set as current.
+     * @return {boolean}
+     * True if there is an event with this ID in the path. False otherwise.
+     */
+    TimelinePath.prototype.setCursor = function (eventId) {
+        var ix = this.eventIdMap[eventId];
+        if (typeof ix !== 'undefined') {
+            this.cursor = ix;
+            return true;
+        }
+        return false;
+    };
+    /**
+     * Play the timeline from the current cursor.
+     * @private
+     * @param {Function} onEnd
+     * Callback to call when play finished. Does not override other onEnd
+     * callbacks.
+     * @return {void}
+     */
+    TimelinePath.prototype.play = function (onEnd) {
+        this.pause();
+        this.signalHandler.emitSignal('onStart');
+        this.signalHandler.clearSignalCallbacks(['playOnEnd']);
+        this.signalHandler.registerSignalCallbacks({ playOnEnd: onEnd });
+        this.playEvents(1);
+    };
+    /**
+     * Play the timeline backwards from the current cursor.
+     * @private
+     * @param {Function} onEnd
+     * Callback to call when play finished. Does not override other onEnd
+     * callbacks.
+     * @return {void}
+     */
+    TimelinePath.prototype.rewind = function (onEnd) {
+        this.pause();
+        this.signalHandler.emitSignal('onStart');
+        this.signalHandler.clearSignalCallbacks(['playOnEnd']);
+        this.signalHandler.registerSignalCallbacks({ playOnEnd: onEnd });
+        this.playEvents(-1);
+    };
+    /**
+     * Reset the cursor to the beginning.
+     * @private
+     */
+    TimelinePath.prototype.resetCursor = function () {
+        this.cursor = 0;
+    };
+    /**
+     * Reset the cursor to the end.
+     * @private
+     */
+    TimelinePath.prototype.resetCursorEnd = function () {
+        this.cursor = this.events.length - 1;
+    };
+    /**
+     * Cancel current playing. Leaves the cursor intact.
+     * @private
+     * @param {boolean} [fadeOut=false] - Whether or not to fade out as we stop. If
+     * false, the path is cancelled synchronously.
+     */
+    TimelinePath.prototype.pause = function (fadeOut) {
+        var timelinePath = this;
+        // Cancel next scheduled play
+        clearTimeout(timelinePath.nextScheduledPlay);
+        // Cancel currently playing events
+        Object.keys(timelinePath.eventsPlaying).forEach(function (id) {
+            if (timelinePath.eventsPlaying[id]) {
+                timelinePath.eventsPlaying[id].cancel(fadeOut);
+            }
+        });
+        timelinePath.eventsPlaying = {};
+    };
+    /**
+     * Play the events, starting from current cursor, and going in specified
+     * direction.
+     * @private
+     * @param {number} direction
+     * The direction to play, 1 for forwards and -1 for backwards.
+     * @return {void}
+     */
+    TimelinePath.prototype.playEvents = function (direction) {
+        var timelinePath = this, curEvent = timelinePath.events[this.cursor], nextEvent = timelinePath.events[this.cursor + direction], onEnd = function (signalData) {
+            timelinePath.signalHandler.emitSignal('masterOnEnd', signalData);
+            timelinePath.signalHandler.emitSignal('playOnEnd', signalData);
+        };
+        var timeDiff;
+        // Store reference to path on event
+        curEvent.timelinePath = timelinePath;
+        // Emit event, cancel if returns false
+        if (timelinePath.signalHandler.emitSignal('onEventStart', curEvent) === false) {
+            onEnd({
+                event: curEvent,
+                cancelled: true
+            });
+            return;
+        }
+        // Play the current event
+        timelinePath.eventsPlaying[curEvent.id] = curEvent;
+        curEvent.play({
+            onEnd: function (cancelled) {
+                var signalData = {
+                    event: curEvent,
+                    cancelled: !!cancelled
+                };
+                // Keep track of currently playing events for cancelling
+                delete timelinePath.eventsPlaying[curEvent.id];
+                // Handle onEventEnd
+                timelinePath.signalHandler.emitSignal('onEventEnd', signalData);
+                // Reached end of path?
+                if (!nextEvent) {
+                    onEnd(signalData);
+                }
+            }
+        });
+        // Schedule next
+        if (nextEvent) {
+            timeDiff = Math.abs(nextEvent.time - curEvent.time);
+            if (timeDiff < 1) {
+                // Play immediately
+                timelinePath.cursor += direction;
+                timelinePath.playEvents(direction);
+            }
+            else {
+                // Schedule after the difference in ms
+                this.nextScheduledPlay = setTimeout(function () {
+                    timelinePath.cursor += direction;
+                    timelinePath.playEvents(direction);
+                }, timeDiff);
+            }
+        }
+    };
+    return TimelinePath;
+}());
+/* *
+ *
+ *  Default export
+ *
+ * */
+export default TimelinePath;
+/* *
+ *
+ *  API Declarations
+ *
+ * */
+/**
+ * A set of options for the TimelinePath class.
+ *
+ * @requires module:modules/
+ *
+ * @private
+ * @interface Highcharts.TimelinePathOptionsObject
+ */ /**
+* List of TimelineEvents to play on this track.
+* @name Highcharts.TimelinePathOptionsObject#events
+* @type {Array<Highcharts.TimelineEvent>}
+*/ /**
+* If this option is supplied, this path ignores all events and just waits for
+* the specified number of milliseconds before calling onEnd.
+* @name Highcharts.TimelinePathOptionsObject#silentWait
+* @type {number|undefined}
+*/ /**
+* Unique ID for this timeline path. Automatically generated if not supplied.
+* @name Highcharts.TimelinePathOptionsObject#id
+* @type {string|undefined}
+*/ /**
+* Callback called before the path starts playing.
+* @name Highcharts.TimelinePathOptionsObject#onStart
+* @type {Function|undefined}
+*/ /**
+* Callback function to call before an event plays.
+* @name Highcharts.TimelinePathOptionsObject#onEventStart
+* @type {Function|undefined}
+*/ /**
+* Callback function to call after an event has stopped playing.
+* @name Highcharts.TimelinePathOptionsObject#onEventEnd
+* @type {Function|undefined}
+*/ /**
+* Callback called when the whole path is finished.
+* @name Highcharts.TimelinePathOptionsObject#onEnd
+* @type {Function|undefined}
+*/
+(''); // detach doclets above

package/es-modules/Maps/MapNavigation.js

@@ -223,9 +223,11 @@ extend(Chart.prototype, /** @lends Chart.prototype */ {
         return inner;
     },
     /**
-     * Highmaps only. Zoom in or out of the map. See also {@link Point#zoomTo}.
-     * See {@link Chart#fromLatLonToPoint} for how to get the `centerX` and
-     * `centerY` parameters for a geographic location.
+     * Highcharts Maps only. Zoom in or out of the map. See also
+     * {@link Point#zoomTo}. See {@link Chart#fromLatLonToPoint} for how to get
+     * the `centerX` and `centerY` parameters for a geographic location.
+     *
+     * Deprecated as of v9.3 in favor of [MapView.zoomBy](https://api.highcharts.com/class-reference/Highcharts.MapView#zoomBy).
      *
      * @function Highcharts.Chart#mapZoom
      *
@@ -234,76 +236,37 @@ extend(Chart.prototype, /** @lends Chart.prototype */ {
      *        in to half the current view. 2 zooms to twice the current view. If
      *        omitted, the zoom is reset.
      *
-     * @param {number} [centerX]
-     *        The X axis position to center around if available space.
+     * @param {number} [xProjected]
+     *        The projected x position to keep stationary when zooming, if
+     *        available space.
      *
-     * @param {number} [centerY]
-     *        The Y axis position to center around if available space.
+     * @param {number} [yProjected]
+     *        The projected y position to keep stationary when zooming, if
+     *        available space.
      *
-     * @param {number} [mouseX]
-     *        Fix the zoom to this position if possible. This is used for
+     * @param {number} [chartX]
+     *        Keep this chart position stationary if possible. This is used for
      *        example in mousewheel events, where the area under the mouse
      *        should be fixed as we zoom in.
      *
-     * @param {number} [mouseY]
-     *        Fix the zoom to this position if possible.
+     * @param {number} [chartY]
+     *        Keep this chart position stationary if possible.
      *
+     * @deprecated
      * @return {void}
      */
-    mapZoom: function (howMuch, centerXArg, centerYArg, mouseX, mouseY, animation) {
-        var chart = this, xAxis = chart.xAxis[0], xRange = xAxis.max - xAxis.min, centerX = pick(centerXArg, xAxis.min + xRange / 2), newXRange = xRange * howMuch, yAxis = chart.yAxis[0], yRange = yAxis.max - yAxis.min, centerY = pick(centerYArg, yAxis.min + yRange / 2), newYRange = yRange * howMuch, fixToX = mouseX ? ((mouseX - xAxis.pos) / xAxis.len) : 0.5, fixToY = mouseY ? ((mouseY - yAxis.pos) / yAxis.len) : 0.5, newXMin = centerX - newXRange * fixToX, newYMin = centerY - newYRange * fixToY, newExt = chart.fitToBox({
-            x: newXMin,
-            y: newYMin,
-            width: newXRange,
-            height: newYRange
-        }, {
-            x: xAxis.dataMin,
-            y: yAxis.dataMin,
-            width: xAxis.dataMax - xAxis.dataMin,
-            height: yAxis.dataMax - yAxis.dataMin
-        }), zoomOut = (newExt.x <= xAxis.dataMin &&
-            newExt.width >=
-                xAxis.dataMax - xAxis.dataMin &&
-            newExt.y <= yAxis.dataMin &&
-            newExt.height >= yAxis.dataMax - yAxis.dataMin);
-        // When mousewheel zooming, fix the point under the mouse
-        if (mouseX && xAxis.mapAxis) {
-            xAxis.mapAxis.fixTo = [mouseX - xAxis.pos, centerXArg];
-        }
-        if (mouseY && yAxis.mapAxis) {
-            yAxis.mapAxis.fixTo = [mouseY - yAxis.pos, centerYArg];
-        }
-        // Zoom
-        if (typeof howMuch !== 'undefined' && !zoomOut) {
-            xAxis.setExtremes(newExt.x, newExt.x + newExt.width, false);
-            yAxis.setExtremes(newExt.y, newExt.y + newExt.height, false);
-            // Reset zoom
-        }
-        else {
-            xAxis.setExtremes(void 0, void 0, false);
-            yAxis.setExtremes(void 0, void 0, false);
-        }
-        // Prevent zooming until this one is finished animating
-        /*
-        chart.holdMapZoom = true;
-        setTimeout(function () {
-            chart.holdMapZoom = false;
-        }, 200);
-        */
-        /*
-        delay = animation ? animation.duration || 500 : 0;
-        if (delay) {
-            chart.isMapZooming = true;
-            setTimeout(function () {
-                chart.isMapZooming = false;
-                if (chart.mapZoomQueue) {
-                    chart.mapZoom.apply(chart, chart.mapZoomQueue);
-                }
-                chart.mapZoomQueue = null;
-            }, delay);
+    mapZoom: function (howMuch, xProjected, yProjected, chartX, chartY) {
+        if (this.mapView) {
+            if (typeof howMuch === 'number') {
+                // Compliance, mapView.zoomBy uses different values
+                howMuch = Math.log(howMuch) / Math.log(0.5);
+            }
+            this.mapView.zoomBy(howMuch, typeof xProjected === 'number' && typeof yProjected === 'number' ?
+                this.mapView.projection.inverse([xProjected, yProjected]) :
+                void 0, typeof chartX === 'number' && typeof chartY === 'number' ?
+                [chartX, chartY] :
+                void 0);
         }
-        */
-        chart.redraw(animation);
     }
 });
 // Extend the Chart.render method to add zooming and panning

package/es-modules/Maps/MapNavigationOptionsDefault.js

@@ -17,6 +17,9 @@ var extend = U.extend;
  *
  * */
 /**
+ * The `mapNavigation` option handles buttons for navigation in addition to
+ * mousewheel and doubleclick handlers for map zooming.
+ *
  * @product      highmaps
  * @optionparent mapNavigation
  */

package/es-modules/Maps/MapPointer.js

@@ -10,7 +10,7 @@
 'use strict';
 import Pointer from '../Core/Pointer.js';
 import U from '../Core/Utilities.js';
-var extend = U.extend, pick = U.pick, wrap = U.wrap;
+var defined = U.defined, extend = U.extend, pick = U.pick, wrap = U.wrap;
 /* eslint-disable no-invalid-this */
 var totalWheelDelta = 0;
 var totalWheelDeltaTimer;
@@ -27,7 +27,7 @@ extend(Pointer.prototype, {
             }
         }
         else if (chart.isInsidePlot(e.chartX - chart.plotLeft, e.chartY - chart.plotTop)) {
-            chart.mapZoom(0.5, chart.xAxis[0].toValue(e.chartX), chart.yAxis[0].toValue(e.chartY), e.chartX, e.chartY);
+            chart.mapZoom(0.5, void 0, void 0, e.chartX, e.chartY);
         }
     },
     // The event handler for the mouse scroll event
@@ -35,7 +35,9 @@ extend(Pointer.prototype, {
         var chart = this.chart;
         e = this.normalize(e);
         // Firefox uses e.deltaY or e.detail, WebKit and IE uses wheelDelta
-        var delta = e.deltaY || e.detail || -(e.wheelDelta / 120);
+        // try wheelDelta first #15656
+        var delta = (defined(e.wheelDelta) && -e.wheelDelta / 120) ||
+            e.deltaY || e.detail;
         // Wheel zooming on trackpads have different behaviours in Firefox vs
         // WebKit. In Firefox the delta increments in steps by 1, so it is not
         // distinguishable from true mouse wheel. Therefore we use this timer
@@ -51,8 +53,8 @@ extend(Pointer.prototype, {
                 totalWheelDelta = 0;
             }, 50);
         }
-        if (totalWheelDelta < 10 && chart.isInsidePlot(e.chartX - chart.plotLeft, e.chartY - chart.plotTop)) {
-            chart.mapZoom(Math.pow(chart.options.mapNavigation.mouseWheelSensitivity, delta), chart.xAxis[0].toValue(e.chartX), chart.yAxis[0].toValue(e.chartY), e.chartX, e.chartY, 
+        if (totalWheelDelta < 10 && chart.isInsidePlot(e.chartX - chart.plotLeft, e.chartY - chart.plotTop) && chart.mapView) {
+            chart.mapView.zoomBy((chart.options.mapNavigation.mouseWheelSensitivity - 1) * -delta, void 0, [e.chartX, e.chartY], 
             // Delta less than 1 indicates stepless/trackpad zooming, avoid
             // animation delaying the zoom
             Math.abs(delta) < 1 ? false : void 0);