highcharts 9.2.0 → 9.3.1

package/es-modules/Accessibility/Components/SeriesComponent/ForcedMarkers.js

@@ -10,118 +10,140 @@
  *
  * */
 'use strict';
-import Series from '../../../Core/Series/Series.js';
 import U from '../../../Core/Utilities.js';
 var addEvent = U.addEvent, merge = U.merge;
-/* eslint-disable no-invalid-this, valid-jsdoc */
-/**
- * @private
- */
-function isWithinDescriptionThreshold(series) {
-    var a11yOptions = series.chart.options.accessibility;
-    return series.points.length <
-        a11yOptions.series.pointDescriptionEnabledThreshold ||
-        a11yOptions.series.pointDescriptionEnabledThreshold === false;
-}
-/**
- * @private
- */
-function shouldForceMarkers(series) {
-    var chart = series.chart, chartA11yEnabled = chart.options.accessibility.enabled, seriesA11yEnabled = (series.options.accessibility &&
-        series.options.accessibility.enabled) !== false;
-    return chartA11yEnabled && seriesA11yEnabled && isWithinDescriptionThreshold(series);
-}
-/**
- * @private
- */
-function hasIndividualPointMarkerOptions(series) {
-    return !!(series._hasPointMarkers && series.points && series.points.length);
-}
-/**
- * @private
- */
-function unforceSeriesMarkerOptions(series) {
-    var resetMarkerOptions = series.resetA11yMarkerOptions;
-    if (resetMarkerOptions) {
-        merge(true, series.options, {
+/* *
+ *
+ *  Composition
+ *
+ * */
+var ForcedMarkersComposition;
+(function (ForcedMarkersComposition) {
+    /* *
+     *
+     *  Declarations
+     *
+     * */
+    /* *
+     *
+     *  Compositions
+     *
+     * */
+    var composedClasses = [];
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /* eslint-disable valid-jsdoc */
+    /**
+     * @private
+     */
+    function compose(SeriesClass) {
+        if (composedClasses.indexOf(SeriesClass) === -1) {
+            composedClasses.push(SeriesClass);
+            addEvent(SeriesClass, 'afterSetOptions', seriesOnAfterSetOptions);
+            addEvent(SeriesClass, 'render', seriesOnRender);
+            addEvent(SeriesClass, 'afterRender', seriesOnAfterRender);
+        }
+    }
+    ForcedMarkersComposition.compose = compose;
+    /**
+     * @private
+     */
+    function forceZeroOpacityMarkerOptions(options) {
+        merge(true, options, {
             marker: {
-                enabled: resetMarkerOptions.enabled,
+                enabled: true,
                 states: {
                     normal: {
-                        opacity: resetMarkerOptions.states &&
-                            resetMarkerOptions.states.normal &&
-                            resetMarkerOptions.states.normal.opacity
+                        opacity: 0
                     }
                 }
             }
         });
     }
-}
-/**
- * @private
- */
-function forceZeroOpacityMarkerOptions(options) {
-    merge(true, options, {
-        marker: {
-            enabled: true,
-            states: {
-                normal: {
-                    opacity: 0
+    /**
+     * @private
+     */
+    function getPointMarkerOpacity(pointOptions) {
+        return pointOptions.marker.states &&
+            pointOptions.marker.states.normal &&
+            pointOptions.marker.states.normal.opacity;
+    }
+    /**
+     * @private
+     */
+    function handleForcePointMarkers(series) {
+        var i = series.points.length;
+        while (i--) {
+            var point = series.points[i];
+            var pointOptions = point.options;
+            var hadForcedMarker = point.hasForcedA11yMarker;
+            delete point.hasForcedA11yMarker;
+            if (pointOptions.marker) {
+                var isStillForcedMarker = hadForcedMarker && getPointMarkerOpacity(pointOptions) === 0;
+                if (pointOptions.marker.enabled && !isStillForcedMarker) {
+                    unforcePointMarkerOptions(pointOptions);
+                    point.hasForcedA11yMarker = false;
+                }
+                else if (pointOptions.marker.enabled === false) {
+                    forceZeroOpacityMarkerOptions(pointOptions);
+                    point.hasForcedA11yMarker = true;
                 }
             }
         }
-    });
-}
-/**
- * @private
- */
-function getPointMarkerOpacity(pointOptions) {
-    return pointOptions.marker.states &&
-        pointOptions.marker.states.normal &&
-        pointOptions.marker.states.normal.opacity || 1;
-}
-/**
- * @private
- */
-function unforcePointMarkerOptions(pointOptions) {
-    merge(true, pointOptions.marker, {
-        states: {
-            normal: {
-                opacity: getPointMarkerOpacity(pointOptions)
-            }
-        }
-    });
-}
-/**
- * @private
- */
-function handleForcePointMarkers(series) {
-    var i = series.points.length;
-    while (i--) {
-        var point = series.points[i];
-        var pointOptions = point.options;
-        delete point.hasForcedA11yMarker;
-        if (pointOptions.marker) {
-            if (pointOptions.marker.enabled) {
-                unforcePointMarkerOptions(pointOptions);
-                point.hasForcedA11yMarker = false;
+    }
+    /**
+     * @private
+     */
+    function hasIndividualPointMarkerOptions(series) {
+        return !!(series._hasPointMarkers && series.points && series.points.length);
+    }
+    /**
+     * @private
+     */
+    function isWithinDescriptionThreshold(series) {
+        var a11yOptions = series.chart.options.accessibility;
+        return series.points.length <
+            a11yOptions.series.pointDescriptionEnabledThreshold ||
+            a11yOptions.series.pointDescriptionEnabledThreshold === false;
+    }
+    /**
+     * Process marker graphics after render
+     * @private
+     */
+    function seriesOnAfterRender() {
+        var series = this;
+        // For styled mode the rendered graphic does not reflect the style
+        // options, and we need to add/remove classes to achieve the same.
+        if (series.chart.styledMode) {
+            if (series.markerGroup) {
+                series.markerGroup[series.a11yMarkersForced ? 'addClass' : 'removeClass']('highcharts-a11y-markers-hidden');
             }
-            else {
-                forceZeroOpacityMarkerOptions(pointOptions);
-                point.hasForcedA11yMarker = true;
+            // Do we need to handle individual points?
+            if (hasIndividualPointMarkerOptions(series)) {
+                series.points.forEach(function (point) {
+                    if (point.graphic) {
+                        point.graphic[point.hasForcedA11yMarker ? 'addClass' : 'removeClass']('highcharts-a11y-marker-hidden');
+                        point.graphic[point.hasForcedA11yMarker === false ? 'addClass' : 'removeClass']('highcharts-a11y-marker-visible');
+                    }
+                });
             }
         }
     }
-}
-/**
- * @private
- */
-function addForceMarkersEvents() {
+    /**
+     * Keep track of options to reset markers to if no longer forced.
+     * @private
+     */
+    function seriesOnAfterSetOptions(e) {
+        this.resetA11yMarkerOptions = merge(e.options.marker || {}, this.userOptions.marker || {});
+    }
     /**
      * Keep track of forcing markers.
      * @private
      */
-    addEvent(Series, 'render', function () {
+    function seriesOnRender() {
         var series = this, options = series.options;
         if (shouldForceMarkers(series)) {
             if (options.marker && options.marker.enabled === false) {
@@ -136,36 +158,51 @@ function addForceMarkersEvents() {
             delete series.a11yMarkersForced;
             unforceSeriesMarkerOptions(series);
         }
-    });
+    }
     /**
-     * Keep track of options to reset markers to if no longer forced.
      * @private
      */
-    addEvent(Series, 'afterSetOptions', function (e) {
-        this.resetA11yMarkerOptions = merge(e.options.marker || {}, this.userOptions.marker || {});
-    });
+    function shouldForceMarkers(series) {
+        var chart = series.chart, chartA11yEnabled = chart.options.accessibility.enabled, seriesA11yEnabled = (series.options.accessibility &&
+            series.options.accessibility.enabled) !== false;
+        return chartA11yEnabled && seriesA11yEnabled && isWithinDescriptionThreshold(series);
+    }
     /**
-     * Process marker graphics after render
      * @private
      */
-    addEvent(Series, 'afterRender', function () {
-        var series = this;
-        // For styled mode the rendered graphic does not reflect the style
-        // options, and we need to add/remove classes to achieve the same.
-        if (series.chart.styledMode) {
-            if (series.markerGroup) {
-                series.markerGroup[series.a11yMarkersForced ? 'addClass' : 'removeClass']('highcharts-a11y-markers-hidden');
+    function unforcePointMarkerOptions(pointOptions) {
+        merge(true, pointOptions.marker, {
+            states: {
+                normal: {
+                    opacity: getPointMarkerOpacity(pointOptions) || 1
+                }
             }
-            // Do we need to handle individual points?
-            if (hasIndividualPointMarkerOptions(series)) {
-                series.points.forEach(function (point) {
-                    if (point.graphic) {
-                        point.graphic[point.hasForcedA11yMarker ? 'addClass' : 'removeClass']('highcharts-a11y-marker-hidden');
-                        point.graphic[point.hasForcedA11yMarker === false ? 'addClass' : 'removeClass']('highcharts-a11y-marker-visible');
+        });
+    }
+    /**
+     * @private
+     */
+    function unforceSeriesMarkerOptions(series) {
+        var resetMarkerOptions = series.resetA11yMarkerOptions;
+        if (resetMarkerOptions) {
+            merge(true, series.options, {
+                marker: {
+                    enabled: resetMarkerOptions.enabled,
+                    states: {
+                        normal: {
+                            opacity: resetMarkerOptions.states &&
+                                resetMarkerOptions.states.normal &&
+                                resetMarkerOptions.states.normal.opacity
+                        }
                     }
-                });
-            }
+                }
+            });
         }
-    });
-}
-export default addForceMarkersEvents;
+    }
+})(ForcedMarkersComposition || (ForcedMarkersComposition = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default ForcedMarkersComposition;

package/es-modules/Accessibility/Components/SeriesComponent/NewDataAnnouncer.js

@@ -11,18 +11,20 @@
  * */
 'use strict';
 import H from '../../../Core/Globals.js';
-import Series from '../../../Core/Series/Series.js';
 import U from '../../../Core/Utilities.js';
-var extend = U.extend, defined = U.defined;
+var addEvent = U.addEvent, defined = U.defined;
+import Announcer from '../../Utils/Announcer.js';
 import ChartUtilities from '../../Utils/ChartUtilities.js';
 var getChartTitle = ChartUtilities.getChartTitle;
-import SeriesDescriber from './SeriesDescriber.js';
-var defaultPointDescriptionFormatter = SeriesDescriber
-    .defaultPointDescriptionFormatter, defaultSeriesDescriptionFormatter = SeriesDescriber
-    .defaultSeriesDescriptionFormatter;
-import Announcer from '../../Utils/Announcer.js';
 import EventProvider from '../../Utils/EventProvider.js';
-/* eslint-disable no-invalid-this, valid-jsdoc */
+import SeriesDescriber from './SeriesDescriber.js';
+var defaultPointDescriptionFormatter = SeriesDescriber.defaultPointDescriptionFormatter, defaultSeriesDescriptionFormatter = SeriesDescriber.defaultSeriesDescriptionFormatter;
+/* *
+ *
+ *  Functions
+ *
+ * */
+/* eslint-disable valid-jsdoc */
 /**
  * @private
  */
@@ -33,9 +35,7 @@ function chartHasAnnounceEnabled(chart) {
  * @private
  */
 function findPointInDataArray(point) {
-    var candidates = point.series.data.filter(function (candidate) {
-        return point.x === candidate.x && point.y === candidate.y;
-    });
+    var candidates = point.series.data.filter(function (candidate) { return (point.x === candidate.x && point.y === candidate.y); });
     return candidates.length === 1 ? candidates[0] : point;
 }
 /**
@@ -43,28 +43,54 @@ function findPointInDataArray(point) {
  * @private
  */
 function getUniqueSeries(arrayA, arrayB) {
-    var uniqueSeries = (arrayA || []).concat(arrayB || [])
-        .reduce(function (acc, cur) {
+    var uniqueSeries = (arrayA || []).concat(arrayB || []).reduce(function (acc, cur) {
         acc[cur.name + cur.index] = cur;
         return acc;
     }, {});
-    return Object.keys(uniqueSeries).map(function (ix) {
-        return uniqueSeries[ix];
-    });
+    return Object
+        .keys(uniqueSeries)
+        .map(function (ix) { return uniqueSeries[ix]; });
 }
+/* *
+ *
+ *  Class
+ *
+ * */
 /**
  * @private
  * @class
  */
-var NewDataAnnouncer = function (chart) {
-    this.chart = chart;
-};
-extend(NewDataAnnouncer.prototype, {
+var NewDataAnnouncer = /** @class */ (function () {
+    /* *
+     *
+     *  Constructor
+     *
+     * */
+    function NewDataAnnouncer(chart) {
+        /* *
+         *
+         *  Public
+         *
+         * */
+        this.announcer = void 0;
+        this.dirty = {
+            allSeries: {}
+        };
+        this.eventProvider = void 0;
+        this.lastAnnouncementTime = 0;
+        this.chart = chart;
+    }
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /* eslint-disable valid-jsdoc */
     /**
      * Initialize the new data announcer.
      * @private
      */
-    init: function () {
+    NewDataAnnouncer.prototype.init = function () {
         var chart = this.chart;
         var announceOptions = chart.options.accessibility.announceNewData;
         var announceType = announceOptions.interruptUser ? 'assertive' : 'polite';
@@ -75,55 +101,37 @@ extend(NewDataAnnouncer.prototype, {
         this.eventProvider = new EventProvider();
         this.announcer = new Announcer(chart, announceType);
         this.addEventListeners();
-    },
+    };
     /**
      * Remove traces of announcer.
      * @private
      */
-    destroy: function () {
+    NewDataAnnouncer.prototype.destroy = function () {
         this.eventProvider.removeAddedEvents();
         this.announcer.destroy();
-    },
+    };
     /**
      * Add event listeners for the announcer
      * @private
      */
-    addEventListeners: function () {
+    NewDataAnnouncer.prototype.addEventListeners = function () {
         var announcer = this, chart = this.chart, e = this.eventProvider;
         e.addEvent(chart, 'afterDrilldown', function () {
             announcer.lastAnnouncementTime = 0;
         });
-        e.addEvent(Series, 'updatedData', function () {
-            announcer.onSeriesUpdatedData(this);
-        });
         e.addEvent(chart, 'afterAddSeries', function (e) {
             announcer.onSeriesAdded(e.series);
         });
-        e.addEvent(Series, 'addPoint', function (e) {
-            announcer.onPointAdded(e.point);
-        });
         e.addEvent(chart, 'redraw', function () {
             announcer.announceDirtyData();
         });
-    },
-    /**
-     * On new data in the series, make sure we add it to the dirty list.
-     * @private
-     * @param {Highcharts.Series} series
-     */
-    onSeriesUpdatedData: function (series) {
-        var chart = this.chart;
-        if (series.chart === chart && chartHasAnnounceEnabled(chart)) {
-            this.dirty.hasDirty = true;
-            this.dirty.allSeries[series.name + series.index] = series;
-        }
-    },
+    };
     /**
      * On new data series added, update dirty list.
      * @private
      * @param {Highcharts.Series} series
      */
-    onSeriesAdded: function (series) {
+    NewDataAnnouncer.prototype.onSeriesAdded = function (series) {
         if (chartHasAnnounceEnabled(this.chart)) {
             this.dirty.hasDirty = true;
             this.dirty.allSeries[series.name + series.index] = series;
@@ -131,25 +139,12 @@ extend(NewDataAnnouncer.prototype, {
             this.dirty.newSeries = defined(this.dirty.newSeries) ?
                 void 0 : series;
         }
-    },
-    /**
-     * On new point added, update dirty list.
-     * @private
-     * @param {Highcharts.Point} point
-     */
-    onPointAdded: function (point) {
-        var chart = point.series.chart;
-        if (this.chart === chart && chartHasAnnounceEnabled(chart)) {
-            // Add it to newPoint storage unless we already have one
-            this.dirty.newPoint = defined(this.dirty.newPoint) ?
-                void 0 : point;
-        }
-    },
+    };
     /**
      * Gather what we know and announce the data to user.
      * @private
      */
-    announceDirtyData: function () {
+    NewDataAnnouncer.prototype.announceDirtyData = function () {
         var chart = this.chart, announcer = this;
         if (chart.options.accessibility.announceNewData &&
             this.dirty.hasDirty) {
@@ -160,15 +155,15 @@ extend(NewDataAnnouncer.prototype, {
             if (newPoint) {
                 newPoint = findPointInDataArray(newPoint);
             }
-            this.queueAnnouncement(Object.keys(this.dirty.allSeries).map(function (ix) {
-                return announcer.dirty.allSeries[ix];
-            }), this.dirty.newSeries, newPoint);
+            this.queueAnnouncement(Object
+                .keys(this.dirty.allSeries)
+                .map(function (ix) { return announcer.dirty.allSeries[ix]; }), this.dirty.newSeries, newPoint);
             // Reset
             this.dirty = {
                 allSeries: {}
             };
         }
-    },
+    };
     /**
      * Announce to user that there is new data.
      * @private
@@ -179,7 +174,7 @@ extend(NewDataAnnouncer.prototype, {
      * @param {Highcharts.Point} [newPoint]
      *          If a single point was added, a reference to this point.
      */
-    queueAnnouncement: function (dirtySeries, newSeries, newPoint) {
+    NewDataAnnouncer.prototype.queueAnnouncement = function (dirtySeries, newSeries, newPoint) {
         var _this = this;
         var chart = this.chart;
         var annOptions = chart.options.accessibility.announceNewData;
@@ -213,7 +208,7 @@ extend(NewDataAnnouncer.prototype, {
                 }, time);
             }
         }
-    },
+    };
     /**
      * Get announcement message for new data.
      * @private
@@ -227,7 +222,7 @@ extend(NewDataAnnouncer.prototype, {
      * @return {string|null}
      * The announcement message to give to user.
      */
-    buildAnnouncementMessage: function (dirtySeries, newSeries, newPoint) {
+    NewDataAnnouncer.prototype.buildAnnouncementMessage = function (dirtySeries, newSeries, newPoint) {
         var chart = this.chart, annOptions = chart.options.accessibility.announceNewData;
         // User supplied formatter?
         if (annOptions.announcementFormatter) {
@@ -250,6 +245,76 @@ extend(NewDataAnnouncer.prototype, {
             point: newPoint,
             series: newSeries
         });
+    };
+    return NewDataAnnouncer;
+}());
+/* *
+ *
+ *  Class Namespace
+ *
+ * */
+(function (NewDataAnnouncer) {
+    /* *
+     *
+     *  Declarations
+     *
+     * */
+    /* *
+     *
+     *  Static Properties
+     *
+     * */
+    NewDataAnnouncer.composedClasses = [];
+    /* *
+     *
+     *  Static Functions
+     *
+     * */
+    /**
+     * @private
+     */
+    function compose(SeriesClass) {
+        if (NewDataAnnouncer.composedClasses.indexOf(SeriesClass) === -1) {
+            NewDataAnnouncer.composedClasses.push(SeriesClass);
+            addEvent(SeriesClass, 'addPoint', seriesOnAddPoint);
+            addEvent(SeriesClass, 'updatedData', seriesOnUpdatedData);
+        }
+    }
+    NewDataAnnouncer.compose = compose;
+    /**
+     * On new point added, update dirty list.
+     * @private
+     * @param {Highcharts.Point} point
+     */
+    function seriesOnAddPoint(e) {
+        var chart = this.chart, newDataAnnouncer = this.newDataAnnouncer;
+        if (newDataAnnouncer &&
+            newDataAnnouncer.chart === chart &&
+            chartHasAnnounceEnabled(chart)) {
+            // Add it to newPoint storage unless we already have one
+            newDataAnnouncer.dirty.newPoint = (defined(newDataAnnouncer.dirty.newPoint) ?
+                void 0 :
+                e.point);
+        }
+    }
+    /**
+     * On new data in the series, make sure we add it to the dirty list.
+     * @private
+     * @param {Highcharts.Series} series
+     */
+    function seriesOnUpdatedData() {
+        var chart = this.chart, newDataAnnouncer = this.newDataAnnouncer;
+        if (newDataAnnouncer &&
+            newDataAnnouncer.chart === chart &&
+            chartHasAnnounceEnabled(chart)) {
+            newDataAnnouncer.dirty.hasDirty = true;
+            newDataAnnouncer.dirty.allSeries[this.name + this.index] = this;
+        }
     }
-});
+})(NewDataAnnouncer || (NewDataAnnouncer = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
 export default NewDataAnnouncer;