@ntlab/ntjs-assets 2.0.27 → 2.0.29

package/assets/js/highcharts/highcharts-more.src.js

@@ -1,5 +1,5 @@
 /**
- * @license Highcharts JS v11.4.3 (2024-05-22)
+ * @license Highcharts JS v11.4.5 (2024-07-04)
  *
  * (c) 2009-2024 Torstein Honsi
  *
@@ -26,7 +26,7 @@
             obj[path] = fn.apply(null, args);
 
             if (typeof CustomEvent === 'function') {
-                window.dispatchEvent(new CustomEvent(
+                Highcharts.win.dispatchEvent(new CustomEvent(
                     'HighchartsModuleLoaded',
                     { detail: { path: path, module: obj[path] } }
                 ));
@@ -261,7 +261,7 @@
                 ]
             },
             /** @ignore-option */
-            from: -Number.MAX_VALUE,
+            from: -Number.MAX_VALUE, // Corrected to axis min
             /**
              * The inner radius of the pane background. Can be either numeric
              * (pixels) or a percentage string.
@@ -272,7 +272,7 @@
              */
             innerRadius: 0,
             /** @ignore-option */
-            to: Number.MAX_VALUE,
+            to: Number.MAX_VALUE, // Corrected to axis max
             /**
              * The outer radius of the circular pane background. Can be either
              * numeric (pixels) or a percentage string.
@@ -287,6 +287,7 @@
          * The pane serves as a container for axes and backgrounds for circular
          * gauges and polar charts.
          *
+         * @type         {*|Array<*>}
          * @since        2.3.0
          * @product      highcharts
          * @requires     highcharts-more
@@ -2013,7 +2014,8 @@
                         }
                         let d;
                         // The stem
-                        const stemX = crisp(point.plotX || 0, point.stem.strokeWidth());
+                        const stemX = crisp((point.plotX || 0) + (series.pointXOffset || 0) +
+                            ((series.barW || 0) / 2), point.stem.strokeWidth());
                         d = [
                             // Stem up
                             ['M', stemX, q3Plot],
@@ -2283,19 +2285,19 @@
              * not specified, the `minSize` and the `maxSize` are calculated
              * from bubble series.
              */
-            maxSize: 60,
+            maxSize: 60, // Number
             /**
              * Minimum bubble legend range size. If values for ranges are
              * not specified, the `minSize` and the `maxSize` are calculated
              * from bubble series.
              */
-            minSize: 10,
+            minSize: 10, // Number
             /**
              * The position of the bubble legend in the legend.
              * @sample highcharts/bubble-legend/connectorandlabels/
              *         Bubble legend as last item in legend
              */
-            legendIndex: 0,
+            legendIndex: 0, // Number
             /**
              * Options for specific range. One range consists of bubble,
              * label and connector.
@@ -2896,11 +2898,8 @@
          *
          * @param {Highcharts.Legend} LegendClass
          * Core legend class to use with Bubble series.
-         *
-         * @param {Highcharts.Series} SeriesClass
-         * Core series class to use with Bubble series.
          */
-        function compose(ChartClass, LegendClass, SeriesClass) {
+        function compose(ChartClass, LegendClass) {
             if (pushUnique(composed, 'Series.BubbleLegend')) {
                 setOptions({
                     // Set default bubble legend options
@@ -2910,7 +2909,7 @@
                 });
                 wrap(ChartClass.prototype, 'drawChartBox', chartDrawChartBox);
                 addEvent(LegendClass, 'afterGetAllItems', onLegendAfterGetAllItems);
-                addEvent(SeriesClass, 'legendItemClick', onSeriesLegendItemClick);
+                addEvent(LegendClass, 'itemClick', onLegendItemClick);
             }
         }
         /**
@@ -3002,12 +3001,12 @@
         /**
          * Toggle bubble legend depending on the visible status of bubble series.
          */
-        function onSeriesLegendItemClick(e) {
+        function onLegendItemClick(e) {
             // #14080 don't fire this code if click function is prevented
             if (e.defaultPrevented) {
                 return false;
             }
-            const series = this, chart = series.chart, visible = series.visible, legend = series.chart.legend;
+            const legend = this, series = e.legendItem, chart = legend.chart, visible = series.visible;
             let status;
             if (legend && legend.bubbleLegend) {
                 // Temporary correct 'visible' property
@@ -3208,8 +3207,8 @@
              *  Static Functions
              *
              * */
-            static compose(AxisClass, ChartClass, LegendClass, SeriesClass) {
-                BubbleLegendComposition.compose(ChartClass, LegendClass, SeriesClass);
+            static compose(AxisClass, ChartClass, LegendClass) {
+                BubbleLegendComposition.compose(ChartClass, LegendClass);
                 if (pushUnique(composed, 'Series.Bubble')) {
                     addEvent(AxisClass, 'foundExtremes', onAxisFoundExtremes);
                 }
@@ -3484,7 +3483,7 @@
              * @excluding enabled, enabledThreshold, height, radius, width
              */
             marker: {
-                lineColor: null,
+                lineColor: null, // Inherit from series.color
                 lineWidth: 1,
                 /**
                  * The fill opacity of the bubble markers.
@@ -3676,7 +3675,7 @@
             pointClass: BubblePoint,
             parallelArrays: ['x', 'y', 'z'],
             trackerGroups: ['group', 'dataLabelsGroup'],
-            specialGroup: 'group',
+            specialGroup: 'group', // To allow clipping (#6296)
             zoneAxis: 'z'
         });
         // On updated data in any series, delete the chart-level Z extremes cache
@@ -4652,8 +4651,8 @@
             }
         }, { order: 0 });
         extend(ErrorBarSeries.prototype, {
-            pointArrayMap: ['low', 'high'],
-            pointValKey: 'high',
+            pointArrayMap: ['low', 'high'], // Array point configs are mapped to this
+            pointValKey: 'high', // Defines the top of the tracker
             doQuartiles: false
         });
         SeriesRegistry.registerSeriesType('errorbar', ErrorBarSeries);
@@ -5182,7 +5181,7 @@
             // `chart.angular` will be set to true when a gauge series is present, and
             // this will be used on the axes
             angular: true,
-            directTouch: true,
+            directTouch: true, // #5063
             drawGraph: noop,
             drawTracker: ColumnSeries.prototype.drawTracker,
             fixedBox: true,
@@ -5578,7 +5577,7 @@
              * @private
              */
             destroy() {
-                if (this.series.layout) {
+                if (this.series?.layout) {
                     this.series.layout.removeElementFromCollection(this, this.series.layout.nodes);
                 }
                 return Point.prototype.destroy.apply(this, arguments);
@@ -7644,7 +7643,234 @@
 
         return DataLabelsDeferUtils;
     });
-    _registerModule(_modules, 'Series/PackedBubble/PackedBubbleSeries.js', [_modules['Core/Color/Color.js'], _modules['Series/DragNodesComposition.js'], _modules['Series/GraphLayoutComposition.js'], _modules['Core/Globals.js'], _modules['Series/PackedBubble/PackedBubblePoint.js'], _modules['Series/PackedBubble/PackedBubbleSeriesDefaults.js'], _modules['Series/PackedBubble/PackedBubbleLayout.js'], _modules['Core/Series/SeriesRegistry.js'], _modules['Series/SimulationSeriesUtilities.js'], _modules['Core/Utilities.js']], function (Color, DragNodesComposition, GraphLayout, H, PackedBubblePoint, PackedBubbleSeriesDefaults, PackedBubbleLayout, SeriesRegistry, D, U) {
+    _registerModule(_modules, 'Extensions/TextPath.js', [_modules['Core/Globals.js'], _modules['Core/Utilities.js']], function (H, U) {
+        /* *
+         *
+         *  Highcharts module with textPath functionality.
+         *
+         *  (c) 2009-2024 Torstein Honsi
+         *
+         *  License: www.highcharts.com/license
+         *
+         *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+         *
+         * */
+        const { deg2rad } = H;
+        const { addEvent, merge, uniqueKey, defined, extend } = U;
+        /**
+         * Set a text path for a `text` or `label` element, allowing the text to
+         * flow along a path.
+         *
+         * In order to unset the path for an existing element, call `setTextPath`
+         * with `{ enabled: false }` as the second argument.
+         *
+         * Text path support is not bundled into `highcharts.js`, and requires the
+         * `modules/textpath.js` file. However, it is included in the script files of
+         * those series types that use it by default
+         *
+         * @sample highcharts/members/renderer-textpath/ Text path demonstrated
+         *
+         * @function Highcharts.SVGElement#setTextPath
+         *
+         * @param {Highcharts.SVGElement|undefined} path
+         *        Path to follow. If undefined, it allows changing options for the
+         *        existing path.
+         *
+         * @param {Highcharts.DataLabelsTextPathOptionsObject} textPathOptions
+         *        Options.
+         *
+         * @return {Highcharts.SVGElement} Returns the SVGElement for chaining.
+         */
+        function setTextPath(path, textPathOptions) {
+            // Defaults
+            textPathOptions = merge(true, {
+                enabled: true,
+                attributes: {
+                    dy: -5,
+                    startOffset: '50%',
+                    textAnchor: 'middle'
+                }
+            }, textPathOptions);
+            const url = this.renderer.url, textWrapper = this.text || this, textPath = textWrapper.textPath, { attributes, enabled } = textPathOptions;
+            path = path || (textPath && textPath.path);
+            // Remove previously added event
+            if (textPath) {
+                textPath.undo();
+            }
+            if (path && enabled) {
+                const undo = addEvent(textWrapper, 'afterModifyTree', (e) => {
+                    if (path && enabled) {
+                        // Set ID for the path
+                        let textPathId = path.attr('id');
+                        if (!textPathId) {
+                            path.attr('id', textPathId = uniqueKey());
+                        }
+                        // Set attributes for the <text>
+                        const textAttribs = {
+                            // `dx`/`dy` options must by set on <text> (parent), the
+                            // rest should be set on <textPath>
+                            x: 0,
+                            y: 0
+                        };
+                        if (defined(attributes.dx)) {
+                            textAttribs.dx = attributes.dx;
+                            delete attributes.dx;
+                        }
+                        if (defined(attributes.dy)) {
+                            textAttribs.dy = attributes.dy;
+                            delete attributes.dy;
+                        }
+                        textWrapper.attr(textAttribs);
+                        // Handle label properties
+                        this.attr({ transform: '' });
+                        if (this.box) {
+                            this.box = this.box.destroy();
+                        }
+                        // Wrap the nodes in a textPath
+                        const children = e.nodes.slice(0);
+                        e.nodes.length = 0;
+                        e.nodes[0] = {
+                            tagName: 'textPath',
+                            attributes: extend(attributes, {
+                                'text-anchor': attributes.textAnchor,
+                                href: `${url}#${textPathId}`
+                            }),
+                            children
+                        };
+                    }
+                });
+                // Set the reference
+                textWrapper.textPath = { path, undo };
+            }
+            else {
+                textWrapper.attr({ dx: 0, dy: 0 });
+                delete textWrapper.textPath;
+            }
+            if (this.added) {
+                // Rebuild text after added
+                textWrapper.textCache = '';
+                this.renderer.buildText(textWrapper);
+            }
+            return this;
+        }
+        /**
+         * Attach a polygon to a bounding box if the element contains a textPath.
+         *
+         * @function Highcharts.SVGElement#setPolygon
+         *
+         * @param {any} event
+         *        An event containing a bounding box object
+         *
+         * @return {Highcharts.BBoxObject} Returns the bounding box object.
+         */
+        function setPolygon(event) {
+            const bBox = event.bBox, tp = this.element?.querySelector('textPath');
+            if (tp) {
+                const polygon = [], { b, h } = this.renderer.fontMetrics(this.element), descender = h - b, lineCleanerRegex = new RegExp('(<tspan>|' +
+                    '<tspan(?!\\sclass="highcharts-br")[^>]*>|' +
+                    '<\\/tspan>)', 'g'), lines = tp
+                    .innerHTML
+                    .replace(lineCleanerRegex, '')
+                    .split(/<tspan class="highcharts-br"[^>]*>/), numOfLines = lines.length;
+                // Calculate top and bottom coordinates for
+                // either the start or the end of a single
+                // character, and append it to the polygon.
+                const appendTopAndBottom = (charIndex, positionOfChar) => {
+                    const { x, y } = positionOfChar, rotation = (tp.getRotationOfChar(charIndex) - 90) * deg2rad, cosRot = Math.cos(rotation), sinRot = Math.sin(rotation);
+                    return [
+                        [
+                            x - descender * cosRot,
+                            y - descender * sinRot
+                        ],
+                        [
+                            x + b * cosRot,
+                            y + b * sinRot
+                        ]
+                    ];
+                };
+                for (let i = 0, lineIndex = 0; lineIndex < numOfLines; lineIndex++) {
+                    const line = lines[lineIndex], lineLen = line.length;
+                    for (let lineCharIndex = 0; lineCharIndex < lineLen; lineCharIndex += 5) {
+                        try {
+                            const srcCharIndex = (i +
+                                lineCharIndex +
+                                lineIndex), [lower, upper] = appendTopAndBottom(srcCharIndex, tp.getStartPositionOfChar(srcCharIndex));
+                            if (lineCharIndex === 0) {
+                                polygon.push(upper);
+                                polygon.push(lower);
+                            }
+                            else {
+                                if (lineIndex === 0) {
+                                    polygon.unshift(upper);
+                                }
+                                if (lineIndex === numOfLines - 1) {
+                                    polygon.push(lower);
+                                }
+                            }
+                        }
+                        catch (e) {
+                            // Safari fails on getStartPositionOfChar even if the
+                            // character is within the `textContent.length`
+                            break;
+                        }
+                    }
+                    i += lineLen - 1;
+                    try {
+                        const srcCharIndex = i + lineIndex, charPos = tp.getEndPositionOfChar(srcCharIndex), [lower, upper] = appendTopAndBottom(srcCharIndex, charPos);
+                        polygon.unshift(upper);
+                        polygon.unshift(lower);
+                    }
+                    catch (e) {
+                        // Safari fails on getStartPositionOfChar even if the character
+                        // is within the `textContent.length`
+                        break;
+                    }
+                }
+                // Close it
+                if (polygon.length) {
+                    polygon.push(polygon[0].slice());
+                }
+                bBox.polygon = polygon;
+            }
+            return bBox;
+        }
+        /**
+         * Draw text along a textPath for a dataLabel.
+         *
+         * @function Highcharts.SVGElement#setTextPath
+         *
+         * @param {any} event
+         *        An event containing label options
+         *
+         * @return {void}
+         */
+        function drawTextPath(event) {
+            const labelOptions = event.labelOptions, point = event.point, textPathOptions = (labelOptions[point.formatPrefix + 'TextPath'] ||
+                labelOptions.textPath);
+            if (textPathOptions && !labelOptions.useHTML) {
+                this.setTextPath(point.getDataLabelPath?.(this) || point.graphic, textPathOptions);
+                if (point.dataLabelPath &&
+                    !textPathOptions.enabled) {
+                    // Clean the DOM
+                    point.dataLabelPath = (point.dataLabelPath.destroy());
+                }
+            }
+        }
+        function compose(SVGElementClass) {
+            addEvent(SVGElementClass, 'afterGetBBox', setPolygon);
+            addEvent(SVGElementClass, 'beforeAddingDataLabel', drawTextPath);
+            const svgElementProto = SVGElementClass.prototype;
+            if (!svgElementProto.setTextPath) {
+                svgElementProto.setTextPath = setTextPath;
+            }
+        }
+        const TextPath = {
+            compose
+        };
+
+        return TextPath;
+    });
+    _registerModule(_modules, 'Series/PackedBubble/PackedBubbleSeries.js', [_modules['Core/Color/Color.js'], _modules['Series/DragNodesComposition.js'], _modules['Series/GraphLayoutComposition.js'], _modules['Core/Globals.js'], _modules['Series/PackedBubble/PackedBubblePoint.js'], _modules['Series/PackedBubble/PackedBubbleSeriesDefaults.js'], _modules['Series/PackedBubble/PackedBubbleLayout.js'], _modules['Core/Series/SeriesRegistry.js'], _modules['Series/SimulationSeriesUtilities.js'], _modules['Core/Utilities.js'], _modules['Core/Renderer/SVG/SVGElement.js'], _modules['Extensions/TextPath.js']], function (Color, DragNodesComposition, GraphLayout, H, PackedBubblePoint, PackedBubbleSeriesDefaults, PackedBubbleLayout, SeriesRegistry, D, U, SVGElement, TextPath) {
         /* *
          *
          *  (c) 2010-2024 Grzegorz Blachlinski, Sebastian Bochan
@@ -7659,6 +7885,7 @@
         const { series: { prototype: seriesProto }, seriesTypes: { bubble: BubbleSeries } } = SeriesRegistry;
         const { initDataLabels, initDataLabelsDefer } = D;
         const { addEvent, clamp, defined, extend, fireEvent, isArray, isNumber, merge, pick } = U;
+        TextPath.compose(SVGElement);
         /* *
          *
          *  Class
@@ -7688,8 +7915,8 @@
              *  Static Functions
              *
              * */
-            static compose(AxisClass, ChartClass, LegendClass, SeriesClass) {
-                BubbleSeries.compose(AxisClass, ChartClass, LegendClass, SeriesClass);
+            static compose(AxisClass, ChartClass, LegendClass) {
+                BubbleSeries.compose(AxisClass, ChartClass, LegendClass);
                 DragNodesComposition.compose(ChartClass);
                 PackedBubbleLayout.compose(ChartClass);
             }
@@ -8116,10 +8343,10 @@
                     // Create first bubble in the middle of the chart
                     bubblePos.push([
                         [
+                            0, // Starting in 0,0 coordinates
                             0,
-                            0,
-                            sortedArr[0][2],
-                            sortedArr[0][3],
+                            sortedArr[0][2], // Radius
+                            sortedArr[0][3], // Series index
                             sortedArr[0][4]
                         ] // Point index
                     ]); // 0 level bubble
@@ -8717,11 +8944,11 @@
              * @private
              */
         const defaultCircularOptions = {
-            gridLineWidth: 1,
+            gridLineWidth: 1, // Spokes
             labels: {
-                align: void 0,
+                align: void 0, // Auto
                 x: 0,
-                y: void 0,
+                y: void 0, // Auto
                 style: {
                     textOverflow: 'none' // Wrap lines by default (#7248)
                 }
@@ -11669,12 +11896,12 @@
 
         const G = Highcharts;
         G.RadialAxis = RadialAxis;
-        BubbleSeries.compose(G.Axis, G.Chart, G.Legend, G.Series);
-        PackedBubbleSeries.compose(G.Axis, G.Chart, G.Legend, G.Series);
+        BubbleSeries.compose(G.Axis, G.Chart, G.Legend);
+        PackedBubbleSeries.compose(G.Axis, G.Chart, G.Legend);
         Pane.compose(G.Chart, G.Pointer);
         PolarAdditions.compose(G.Axis, G.Chart, G.Pointer, G.Series, G.Tick, G.Point, SeriesRegistry.seriesTypes.areasplinerange, SeriesRegistry.seriesTypes.column, SeriesRegistry.seriesTypes.line, SeriesRegistry.seriesTypes.spline);
         WaterfallSeries.compose(G.Axis, G.Chart);
 
         return G;
     });
-}));
+}));