@visactor/vrender-components 0.12.1 → 0.12.2

package/dist/index.js

@@ -436,143 +436,28 @@
         return '#' + vutils.ColorUtil.rgbToHex(r, g, b);
     }
 
-    /**
-     * Common utilities
-     * @module glMatrix
-     */
-    var ARRAY_TYPE = typeof Float32Array !== 'undefined' ? Float32Array : Array;
-    if (!Math.hypot) Math.hypot = function () {
-      var y = 0,
-        i = arguments.length;
-      while (i--) {
-        y += arguments[i] * arguments[i];
-      }
-      return Math.sqrt(y);
-    };
-
-    /**
-     * 2 Dimensional Vector
-     * @module vec2
-     */
-
-    /**
-     * Creates a new, empty vec2
-     *
-     * @returns {vec2} a new 2D vector
-     */
-
-    function create() {
-      var out = new ARRAY_TYPE(2);
-      if (ARRAY_TYPE != Float32Array) {
-        out[0] = 0;
-        out[1] = 0;
-      }
-      return out;
+    function scale(vector, scale) {
+        return [vector[0] * scale, vector[1] * scale];
     }
-    /**
-     * Scales a vec2 by a scalar number
-     *
-     * @param {vec2} out the receiving vector
-     * @param {ReadonlyVec2} a the vector to scale
-     * @param {Number} b amount to scale the vector by
-     * @returns {vec2} out
-     */
-
-    function scale(out, a, b) {
-      out[0] = a[0] * b;
-      out[1] = a[1] * b;
-      return out;
-    }
-    /**
-     * Calculates the length of a vec2
-     *
-     * @param {ReadonlyVec2} a vector to calculate length of
-     * @returns {Number} length of a
-     */
-
-    function length(a) {
-      var x = a[0],
-        y = a[1];
-      return Math.hypot(x, y);
+    function length(vector) {
+        const [x, y] = vector;
+        return Math.sqrt(x * x + y * y);
     }
-    /**
-     * Normalize a vec2
-     *
-     * @param {vec2} out the receiving vector
-     * @param {ReadonlyVec2} a vector to normalize
-     * @returns {vec2} out
-     */
-
-    function normalize(out, a) {
-      var x = a[0],
-        y = a[1];
-      var len = x * x + y * y;
-      if (len > 0) {
-        //TODO: evaluate use of glm_invsqrt here?
-        len = 1 / Math.sqrt(len);
-      }
-      out[0] = a[0] * len;
-      out[1] = a[1] * len;
-      return out;
+    function normalize(vector) {
+        const [x, y] = vector;
+        let len = x * x + y * y;
+        if (len > 0) {
+            len = 1 / Math.sqrt(len);
+        }
+        return [vector[0] * len, vector[1] * len];
     }
-    /**
-     * Get the angle between two 2D vectors
-     * @param {ReadonlyVec2} a The first operand
-     * @param {ReadonlyVec2} b The second operand
-     * @returns {Number} The angle in radians
-     */
-
-    function angle(a, b) {
-      var x1 = a[0],
-        y1 = a[1],
-        x2 = b[0],
-        y2 = b[1],
-        // mag is the product of the magnitudes of a and b
-        mag = Math.sqrt(x1 * x1 + y1 * y1) * Math.sqrt(x2 * x2 + y2 * y2),
-        // mag &&.. short circuits if mag == 0
-        cosine = mag && (x1 * x2 + y1 * y2) / mag; // Math.min(Math.max(cosine, -1), 1) clamps the cosine between -1 and 1
-
-      return Math.acos(Math.min(Math.max(cosine, -1), 1));
+    function angle(vector1, vector2) {
+        const [x1, y1] = vector1;
+        const [x2, y2] = vector2;
+        const mag = Math.sqrt((x1 * x1 + y1 * y1) * (x2 * x2 + y2 * y2));
+        const cosine = mag && (x1 * x2 + y1 * y2) / mag;
+        return Math.acos(Math.min(Math.max(cosine, -1), 1));
     }
-    /**
-     * Perform some operation over an array of vec2s.
-     *
-     * @param {Array} a the array of vectors to iterate over
-     * @param {Number} stride Number of elements between the start of each vec2. If 0 assumes tightly packed
-     * @param {Number} offset Number of elements to skip at the beginning of the array
-     * @param {Number} count Number of vec2s to iterate over. If 0 iterates over entire array
-     * @param {Function} fn Function to call for each vector in the array
-     * @param {Object} [arg] additional argument to pass to fn
-     * @returns {Array} a
-     * @function
-     */
-
-    (function () {
-      var vec = create();
-      return function (a, stride, offset, count, fn, arg) {
-        var i, l;
-        if (!stride) {
-          stride = 2;
-        }
-        if (!offset) {
-          offset = 0;
-        }
-        if (count) {
-          l = Math.min(count * stride + offset, a.length);
-        } else {
-          l = a.length;
-        }
-        for (i = offset; i < l; i += stride) {
-          vec[0] = a[i];
-          vec[1] = a[i + 1];
-          fn(vec, vec, arg);
-          a[i] = vec[0];
-          a[i + 1] = vec[1];
-        }
-        return a;
-      };
-    })();
-
     function direction(v1, v2) {
         return v1[0] * v2[1] - v2[0] * v1[1];
     }
@@ -2525,11 +2410,11 @@
             container.add(axisTitle);
         }
         renderGrid(container) {
-            this._renderGridByType('grid', container);
             const { visible } = this.attribute.subGrid || {};
             if (visible) {
                 this._renderGridByType('subGrid', container);
             }
+            this._renderGridByType('grid', container);
         }
         getVerticalCoord(point, offset, inside) {
             const vector = this.getVerticalVector(offset, inside, point);
@@ -2773,9 +2658,9 @@
         getVerticalVector(offset, inside = false) {
             const { verticalFactor = 1 } = this.attribute;
             const axisVector = this.getRelativeVector();
-            const normalize$1 = normalize([0, 0], axisVector);
-            const verticalVector = [normalize$1[1], normalize$1[0] * -1];
-            return scale([0, 0], verticalVector, offset * (inside ? 1 : -1) * verticalFactor);
+            const normalizedAxisVector = normalize(axisVector);
+            const verticalVector = [normalizedAxisVector[1], normalizedAxisVector[0] * -1];
+            return scale(verticalVector, offset * (inside ? 1 : -1) * verticalFactor);
         }
         getTitleAttribute() {
             const { position = 'middle', space = 4, textStyle = {}, autoRotate = true, shape, background, state, ...restAttrs } = this.attribute.title;
@@ -3072,8 +2957,7 @@
             const { inside: axisInside = false } = this.attribute;
             const { center } = this.attribute;
             const vector = [point.x - center.x, point.y - center.y];
-            scale(vector, vector, ((inside ? -1 : 1) * (axisInside ? -1 : 1) * offset) / length(vector));
-            return vector;
+            return scale(vector, ((inside ? -1 : 1) * (axisInside ? -1 : 1) * offset) / length(vector));
         }
         getRelativeVector(point) {
             const { center } = this.attribute;
@@ -4930,6 +4814,7 @@
             }
             const preHandler = vrender.createSymbol({
                 strokeBoundsBuffer: 0,
+                pickMode: 'imprecise',
                 ...handlerStyle,
                 x: 0,
                 y: 0,
@@ -4960,6 +4845,7 @@
             container.add(text);
             const nextHandler = vrender.createSymbol({
                 strokeBoundsBuffer: 0,
+                pickMode: 'imprecise',
                 ...handlerStyle,
                 x: isHorizontal ? handlerSizeX + handlerSpace * 2 + maxTextWidth : 0,
                 y: isHorizontal ? 0 : handlerSizeY + handlerSpace * 2 + maxTextHeight,
@@ -5343,11 +5229,21 @@
                 this._itemMaxWidth = Math.max(itemWidth, this._itemMaxWidth);
                 if (isHorizontal) {
                     maxPages = maxRow;
-                    if (vutils.isValid(maxWidth) && maxWidth < startX + itemWidth) {
-                        doWrap = true;
-                        startX = 0;
-                        startY += itemHeight + spaceRow;
-                        pages += 1;
+                    if (vutils.isValid(maxWidth)) {
+                        if (itemWidth >= maxWidth) {
+                            doWrap = true;
+                            if (index > 0) {
+                                startX = 0;
+                                startY += itemHeight + spaceRow;
+                                pages += 1;
+                            }
+                        }
+                        else if (maxWidth < startX + itemWidth) {
+                            doWrap = true;
+                            startX = 0;
+                            startY += itemHeight + spaceRow;
+                            pages += 1;
+                        }
                     }
                     if (index > 0) {
                         itemGroup.setAttributes({
@@ -5376,10 +5272,11 @@
                 }
                 itemsContainer.add(itemGroup);
             });
+            let pagerRendered = false;
             if (doWrap && autoPage && pages > maxPages) {
-                this._renderPager(isHorizontal);
+                pagerRendered = this._renderPager(isHorizontal);
             }
-            else {
+            if (!pagerRendered) {
                 itemsContainer.setAttribute('y', this._title ? this._title.AABBBounds.height() + vutils.get(this.attribute, 'title.space', 8) : 0);
                 this._innerView.add(itemsContainer);
             }
@@ -5555,6 +5452,10 @@
                 this._innerView.add(pagerComp);
                 pageHeight = (maxRow - 1) * spaceRow + this._itemHeight * maxRow;
                 pageWidth = maxWidth - pagerComp.AABBBounds.width() - pagerSpace;
+                if (pageWidth <= 0) {
+                    this._innerView.removeChild(pagerComp);
+                    return false;
+                }
                 itemsContainer.getChildren().forEach((item, index) => {
                     const { width, height } = item.attribute;
                     if (pageWidth < startX + width) {
@@ -5586,6 +5487,10 @@
                 this._innerView.add(pagerComp);
                 pageWidth = this._itemMaxWidth * maxCol + (maxCol - 1) * spaceCol;
                 pageHeight = maxHeight - pagerComp.AABBBounds.height() - pagerSpace - renderStartY;
+                if (pageHeight <= 0) {
+                    this._innerView.removeChild(pagerComp);
+                    return false;
+                }
                 itemsContainer.getChildren().forEach((item, index) => {
                     const { height } = item.attribute;
                     if (pageHeight < startY + height) {
@@ -5645,6 +5550,7 @@
             };
             this._pager.addEventListener('toPrev', onPaging);
             this._pager.addEventListener('toNext', onPaging);
+            return true;
         }
         _onHover = (e) => {
             const target = e.target;
@@ -8718,7 +8624,7 @@
         }
     }
 
-    const version = "0.12.1";
+    const version = "0.12.2";
 
     exports.AbstractComponent = AbstractComponent;
     exports.BasePlayer = BasePlayer;