@kevinburke/flot 5.1.2 → 5.1.4

package/dist/jquery.flot.js

@@ -1,4 +1,4 @@
-/*! @kevinburke/flot v5.1.2 | MIT License | https://github.com/kevinburke/flot */
+/*! @kevinburke/flot v5.1.4 | MIT License | https://github.com/kevinburke/flot */
 (function ($) {
     'use strict';
 
@@ -168,8 +168,10 @@
     function removeData(el, key) {
         var store = dataStore.get(el);
         if (store) {
-            {
+            if (key) {
                 delete store[key];
+            } else {
+                dataStore.delete(el);
             }
         }
     }
@@ -192,7 +194,7 @@
         return triggerImpl(el, type, args);
     }
 
-    function setTrigger(fn) {
+    function setTrigger$1(fn) {
         triggerImpl = fn;
     }
 
@@ -235,6 +237,20 @@
         }
     }
 
+    var helpers = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        bind: bind,
+        css: css,
+        data: data,
+        extend: extend,
+        height: height,
+        removeData: removeData,
+        setTrigger: setTrigger$1,
+        trigger: trigger,
+        unbind: unbind,
+        width: width
+    });
+
     /** ## jquery.flot.canvaswrapper
 
     This plugin contains the function for creating and manipulating both the canvas
@@ -1739,6 +1755,120 @@
     */
 
 
+    /**
+     * @typedef {{ [key: string]: any }} PluginOptions
+     */
+
+    /**
+     * @typedef {PluginOptions & {
+     *   points: PluginOptions,
+     *   lines: PluginOptions,
+     *   bars: PluginOptions,
+     *   shadowSize: number,
+     *   highlightColor: string | null
+     * }} InternalSeriesOptions
+     */
+
+    /**
+     * @typedef {PluginOptions & {
+     *   position?: string,
+     *   color?: string | number | null,
+     *   tickColor?: string | number | null,
+     *   font?: PluginOptions | null,
+     *   autoScale?: string,
+     *   offset?: PluginOptions,
+     *   boxPosition?: AxisBoxPosition
+     * }} InternalAxisOptions
+     */
+
+    /**
+     * @typedef {{ top: number, right: number, bottom: number, left: number }} BorderWidth
+     */
+
+    /**
+     * @typedef {{ top: string, right: string, bottom: string, left: string }} BorderColor
+     */
+
+    /**
+     * @typedef {{ left: number, top: number, width: number, height: number, padding: number }} AxisBox
+     */
+
+    /**
+     * @typedef {{ centerX: number, centerY: number }} AxisBoxPosition
+     */
+
+    /**
+     * @typedef {PluginOptions & {
+     *   n: number,
+     *   direction: "x" | "y",
+     *   options: InternalAxisOptions,
+     *   used: boolean,
+     *   show: boolean,
+     *   reserveSpace: boolean,
+     *   labelWidth: number,
+     *   labelHeight: number,
+     *   box: AxisBox,
+     *   boxPosition: AxisBoxPosition,
+     *   min: number,
+     *   max: number,
+     *   datamin: number | null,
+     *   datamax: number | null,
+     *   scale: number,
+     *   tickSize: number,
+     *   tickDecimals: number,
+     *   ticks: Array<PluginOptions>,
+     *   p2c: function(string | number): number,
+     *   c2p: function(string | number): number
+     * }} InternalAxis
+     */
+
+    /**
+     * @typedef {PluginOptions & {
+     *   show: boolean,
+     *   aboveData: boolean,
+     *   color: string,
+     *   backgroundColor: string | PluginOptions | null,
+     *   borderColor: string | BorderColor | null,
+     *   tickColor: string | null,
+     *   margin: number | PluginOptions,
+     *   borderWidth: number | BorderWidth,
+     *   minBorderMargin: number | null,
+     *   markings: any,
+     *   markingsColor: string,
+     *   markingsLineWidth: number,
+     *   clickable: boolean,
+     *   hoverable: boolean,
+     *   autoHighlight: boolean,
+     *   mouseActiveRadius: number
+     * }} InternalGridOptions
+     */
+
+    /**
+     * @typedef {PluginOptions & {
+     *   colors: string[],
+     *   xaxis: InternalAxisOptions,
+     *   yaxis: InternalAxisOptions,
+     *   xaxes: InternalAxisOptions[],
+     *   yaxes: InternalAxisOptions[],
+     *   series: InternalSeriesOptions,
+     *   grid: InternalGridOptions,
+     *   interaction: PluginOptions,
+     *   hooks: PluginOptions
+     * }} InternalOptions
+     */
+
+    /**
+     * @typedef {{ [key: string]: Array<function(...any): any> }} HookRegistry
+     */
+
+    /**
+     * @typedef {PluginOptions} InternalPlot
+     */
+
+    /**
+     * @typedef {{ from?: number, to?: number, axis: InternalAxis }} ExtractedRange
+     */
+
         function defaultTickGenerator(axis) {
             var ticks = [],
                 start = saturated.saturate(saturated.floorInBase(axis.min, axis.tickSize)),
@@ -1827,6 +1957,7 @@
             // or { data: [ [x1, y1], [x2, y2], ... ], label: "some label", ... }
 
             var series = [],
+                /** @type {InternalOptions} */
                 options = {
                     // the color theme used for graphs
                     colors: ["#edc240", "#afd8f8", "#cb4b4b", "#4da74d", "#9440ed"],
@@ -1939,7 +2070,9 @@
                 eventHolder = null, // DOM element that events should be bound to
                 ctx = null,
                 octx = null,
+                /** @type {InternalAxis[]} */
                 xaxes = [],
+                /** @type {InternalAxis[]} */
                 yaxes = [],
                 plotOffset = {
                     left: 0,
@@ -1949,6 +2082,7 @@
                 },
                 plotWidth = 0,
                 plotHeight = 0,
+                /** @type {HookRegistry} */
                 hooks = {
                     processOptions: [],
                     processRawData: [],
@@ -1968,6 +2102,7 @@
                     resize: [],
                     shutdown: []
                 },
+                /** @type {InternalPlot} */
                 plot = this;
 
             var eventManager = {};
@@ -2034,8 +2169,8 @@
             plot.triggerRedrawOverlay = triggerRedrawOverlay;
             plot.pointOffset = function(point) {
                 return {
-                    left: parseInt(xaxes[axisNumber(point, "x") - 1].p2c(+point.x) + plotOffset.left, 10),
-                    top: parseInt(yaxes[axisNumber(point, "y") - 1].p2c(+point.y) + plotOffset.top, 10)
+                    left: parseInt(String(xaxes[axisNumber(point, "x") - 1].p2c(+point.x) + plotOffset.left), 10),
+                    top: parseInt(String(yaxes[axisNumber(point, "y") - 1].p2c(+point.y) + plotOffset.top), 10)
                 };
             };
             plot.shutdown = shutdown;
@@ -2045,6 +2180,7 @@
                 placeholder.innerHTML = '';
 
                 series = [];
+                // @ts-expect-error destroy clears closure references after shutdown.
                 options = null;
                 surface = null;
                 overlay = null;
@@ -2053,7 +2189,9 @@
                 octx = null;
                 xaxes = [];
                 yaxes = [];
+                // @ts-expect-error destroy clears closure references after shutdown.
                 hooks = null;
+                // @ts-expect-error destroy clears closure references after shutdown.
                 plot = null;
             };
 
@@ -2282,6 +2420,9 @@
                 return a;
             }
 
+            /**
+             * @returns {InternalAxis[]}
+             */
             function allAxes() {
                 // return flat array without annoying null entries
                 return xaxes.concat(yaxes).filter(function(a) {
@@ -2360,16 +2501,23 @@
 
             function getOrCreateAxis(axes, number) {
                 if (!axes[number - 1]) {
-                    axes[number - 1] = {
+                    axes[number - 1] = /** @type {InternalAxis} */ (/** @type {unknown} */ ({
                         n: number, // save the number for future reference
                         direction: axes === xaxes ? "x" : "y",
                         options: extend(true, {}, axes === xaxes ? options.xaxis : options.yaxis)
-                    };
+                    }));
                 }
 
                 return axes[number - 1];
             }
 
+            function firstAxis(axes) {
+                if (!axes[0]) {
+                    throw new Error("missing first axis");
+                }
+                return axes[0];
+            }
+
             function fillInSeriesOptions() {
                 var neededColors = series.length,
                     maxIndex = -1,
@@ -2792,8 +2940,13 @@
             function measureTickLabels(axis) {
                 var opts = axis.options,
                     ticks = opts.showTickLabels !== 'none' && axis.ticks ? axis.ticks : [],
-                    showMajorTickLabels = opts.showTickLabels === 'major' || opts.showTickLabels === 'all',
-                    showEndpointsTickLabels = opts.showTickLabels === 'endpoints' || opts.showTickLabels === 'all',
+                    // Mirror drawAxisLabels: 'major' and 'all' draw every tick;
+                    // only 'endpoints' skips middle ticks. Measurement must cover
+                    // every label that will be drawn, otherwise labelWidth can be
+                    // too small for the widest one — e.g. a top tick of 100 next
+                    // to 70/80/90 gets clipped to "00" because the axis box was
+                    // sized for 2-char labels. See flot/flot#1729, flot/flot#1788.
+                    endpointsOnly = opts.showTickLabels === 'endpoints',
                     labelWidth = opts.labelWidth || 0,
                     labelHeight = opts.labelHeight || 0,
                     legacyStyles = axis.direction + "Axis " + axis.direction + axis.n + "Axis",
@@ -2804,9 +2957,7 @@
                     var t = ticks[i];
                     var label = t.label;
 
-                    if (!t.label ||
-                        (showMajorTickLabels === false && i > 0 && i < ticks.length - 1) ||
-                        (showEndpointsTickLabels === false && (i === 0 || i === ticks.length - 1))) {
+                    if (!t.label || (endpointsOnly && i > 0 && i < ticks.length - 1)) {
                         continue;
                     }
 
@@ -3130,9 +3281,11 @@
                 if (delta === 0.0) {
                     // degenerate case
                     var widen = max === 0 ? 1 : 0.01;
-                    var wmin = null;
+                    var wmin = 0;
+                    var wminSet = false;
                     if (min == null) {
-                        wmin -= widen;
+                        wmin = -widen;
+                        wminSet = true;
                     }
 
                     // always widen max if we couldn't widen min to ensure we
@@ -3141,7 +3294,7 @@
                         max += widen;
                     }
 
-                    if (wmin != null) {
+                    if (wminSet) {
                         min = wmin;
                     }
                 }
@@ -3537,8 +3690,13 @@
                 triggerRedrawOverlay();
             }
 
+            /**
+             * @returns {ExtractedRange}
+             */
             function extractRange(ranges, coord) {
-                var axis, from, to, key, axes = allAxes();
+                var axis, from, to, axes = allAxes();
+                var key = "";
+                var keyFound = false;
 
                 for (var i = 0; i < axes.length; ++i) {
                     axis = axes[i];
@@ -3550,6 +3708,7 @@
                         }
 
                         if (ranges[key]) {
+                            keyFound = true;
                             from = ranges[key].from;
                             to = ranges[key].to;
                             break;
@@ -3558,8 +3717,8 @@
                 }
 
                 // backwards-compat stuff - to be removed in future
-                if (!ranges[key]) {
-                    axis = coord === "x" ? xaxes[0] : yaxes[0];
+                if (!keyFound) {
+                    axis = firstAxis(coord === "x" ? xaxes : yaxes);
                     from = ranges[coord + "1"];
                     to = ranges[coord + "2"];
                 }
@@ -3574,7 +3733,7 @@
                 return {
                     from: from,
                     to: to,
-                    axis: axis
+                    axis: /** @type {InternalAxis} */ (axis)
                 };
             }
 
@@ -3824,7 +3983,8 @@
                 // check if the line will be overlapped with a border
                 var overlappedWithBorder = function (value) {
                     var bw = options.grid.borderWidth;
-                    return (((typeof bw === "object" && bw[axis.position] > 0) || bw > 0) && (value === axis.min || value === axis.max));
+                    var overlapsBorder = typeof bw === "object" ? bw[axis.position] > 0 : bw > 0;
+                    return overlapsBorder && (value === axis.min || value === axis.max);
                 };
 
                 ctx.strokeStyle = options.grid.tickColor;
@@ -3870,6 +4030,10 @@
                 var bw = options.grid.borderWidth,
                     bc = options.grid.borderColor;
 
+                if (bc == null) {
+                    bc = options.grid.color;
+                }
+
                 if (typeof bw === "object" || typeof bc === "object") {
                     if (typeof bw !== "object") {
                         bw = {
@@ -4247,10 +4411,14 @@
                     smallestDistance = radius * radius + 1;
 
                 for (i = series.length - 1; i >= 0; --i) {
-                    if (!seriesFilter(i)) continue;
+                    if (!seriesFilter(i)) {
+                        continue;
+                    }
 
                     var s = series[i];
-                    if (!s.datapoints) return;
+                    if (!s.datapoints) {
+                        continue;
+                    }
 
                     var foundPoint = false;
                     if (s.lines.show || s.points.show) {
@@ -4537,7 +4705,7 @@
         // Plugin registry. Plugins push to this array to register themselves.
         var plugins = [];
 
-        var version = "5.1.2";
+        var version = "5.1.4";
 
         // The main plot function.
         function plot(placeholder, data, options) {
@@ -9921,6 +10089,7 @@
     //   import '@kevinburke/flot/jquery';
     //   $.plot("#placeholder", data, options);
 
+    var setTrigger = setTrigger$1;
 
     // Route flot's internal trigger() through jQuery so plugin handlers bound
     // via $(el).on(type, fn) see the same data shape as upstream flot/flot.
@@ -9940,13 +10109,15 @@
         $(el).trigger(event);
     });
 
-    // Register $.plot and $.color on the jQuery object.
-    $.plot = function(placeholder, data, options) {
+    function jqueryPlot(placeholder, data, options) {
         var el = typeof placeholder === 'string'
             ? document.querySelector(placeholder)
             : (placeholder instanceof $ ? placeholder[0] : placeholder);
         return plot(el, data, options);
-    };
+    }
+
+    // Register $.plot and $.color on the jQuery object.
+    $.plot = /** @type {typeof $.plot} */ (/** @type {unknown} */ (jqueryPlot));
 
     $.plot.plugins = plugins;
     $.plot.version = version;
@@ -9968,7 +10139,9 @@
     var origExtract = color.extract;
     $.color = Object.create(color);
     $.color.extract = function(elem, cssProp) {
-        if (elem instanceof $ && elem.length) elem = elem[0];
+        if (elem instanceof $) {
+            elem = elem[0];
+        }
         return origExtract(elem, cssProp);
     };
 
@@ -9984,6 +10157,11 @@
             window.Flot = {};
         }
         window.Flot.Canvas = Canvas;
+        // Exposed so standalone plugin bundles (dist/plugins/*.js) can resolve
+        // their `import { plugins } from './jquery.flot.js'` and
+        // `import { ... } from './helpers.js'` to live objects on this global.
+        window.Flot.plugins = plugins;
+        window.Flot.helpers = helpers;
     }
 
 })(jQuery);