gridviz 3.0.17 → 3.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "gridviz",
-    "version": "3.0.17",
+    "version": "3.0.18",
     "description": "Visualization tool for gridded statistics",
     "keywords": [
         "statistics",

package/src/button/Button.js

@@ -46,7 +46,7 @@ export class Button {
         this.style('display', 'flex')
         this.style('justify-content', 'center')
         this.style('align-items', 'center')
-        this.style('width', '30px')
+        this.style('width', '35px')
         this.style('height', '30px')
         // this.style(padding , '4px'
 

package/src/core/GeoCanvas.js

@@ -87,24 +87,29 @@ export class GeoCanvas {
                 .on('zoom', (e) => {
                     const t = e.transform
                     const f = tP.k / t.k
-                    if (f == 1) {
-                        //pan
+
+                    // Get container's bounding rect to adjust for offsets
+                    const containerRect = this.canvas.getBoundingClientRect()
+
+                    // Adjust for container's offset and zoom center
+                    const offsetX = e.sourceEvent.offsetX - containerRect.left
+                    const offsetY = e.sourceEvent.offsetY - containerRect.top
+
+                    if (f === 1) {
+                        // Pan logic
                         const dx = tP.x - t.x
                         const dy = tP.y - t.y
                         this.pan(dx * this.view.z, -dy * this.view.z)
                     } else {
                         const se = e.sourceEvent
+
                         if (se instanceof WheelEvent) {
-                            //zoom at the mouse position
-                            this.zoom(
-                                f,
-                                this.pixToGeoX(e.sourceEvent.offsetX),
-                                this.pixToGeoY(e.sourceEvent.offsetY)
-                            )
+                            // Zoom at mouse position, adjusted by container offset
+                            this.zoom(f, this.pixToGeoX(offsetX), this.pixToGeoY(offsetY))
                         } else if (se instanceof TouchEvent) {
                             if (!se.targetTouches.length) return
-                            //pinch zoom
-                            //compute average position of the touches
+
+                            // Compute average position of the touches
                             let tx = 0,
                                 ty = 0
                             for (let tt of se.targetTouches) {
@@ -113,7 +118,12 @@ export class GeoCanvas {
                             }
                             tx /= se.targetTouches.length
                             ty /= se.targetTouches.length
-                            //zoom at this average position
+
+                            // Adjust for container's offset
+                            tx -= containerRect.left
+                            ty -= containerRect.top
+
+                            // Zoom at the average touch position
                             this.zoom(f, this.pixToGeoX(tx), this.pixToGeoY(ty))
                         }
                     }

package/src/core/Map.js

@@ -60,9 +60,10 @@ export class Map {
         }
 
         // legend div
-        this.legendDivId = opts.legendDivId || 'gvizLegend'
-        this.legend = select('#' + this.legendDivId)
-        if (this.legend.empty()) this.initialiseLegend()
+        this.legend = opts.legendContainer
+            ? select(opts.legendContainer) // Wrap the provided HTML node in a D3 selection
+            : null
+        if (!this.legend) this.initialiseLegend()
 
         //tooltip
 
@@ -122,9 +123,9 @@ export class Map {
     }
 
     initialiseLegend() {
-        this.legend = select(this.container.id && this.container.id != '' ? '#' + this.container.id : 'body')
-            .append('div')
-            .attr('id', this.legendDivId)
+        this.legend = select(this.container)
+            .append('div') // Create a new container
+            .attr('id', 'gridviz-legend')
             .style('position', 'absolute')
             .style('width', 'auto')
             .style('height', 'auto')
@@ -432,35 +433,43 @@ export class Map {
      * @memberof App
      */
     defineResizeObserver() {
-        // listen to resize events
+        // Track whether the observer is currently processing a resize event
+        let resizePending = false
+
         const resizeObserver = new ResizeObserver((entries) => {
+            if (!Array.isArray(entries) || !entries.length) return
+
             let container = this.container
-            // make sure canvas has been built
+
+            // Ensure the container has valid dimensions
             if (container.clientWidth > 0 && container.clientHeight > 0) {
-                // make sure we dont exceed loop limit first
-                // see: https://stackoverflow.com/questions/49384120/resizeobserver-loop-limit-exceeded
-                window.requestAnimationFrame(() => {
-                    if (!Array.isArray(entries) || !entries.length) {
-                        return
-                    }
-                    // update the map and canvas size
-                    if (this.h !== container.clientHeight || this.w !== container.clientWidth) {
-                        this.h = container.clientHeight
-                        this.w = container.clientWidth
-                        this.geoCanvas.h = container.clientHeight
-                        this.geoCanvas.w = container.clientWidth
-                        this.geoCanvas.canvas.setAttribute('width', '' + this.w)
-                        this.geoCanvas.canvas.setAttribute('height', '' + this.h)
-                        // offscreen canvas
-                        this.geoCanvas.offscreenCanvas.setAttribute('width', '' + this.w)
-                        this.geoCanvas.offscreenCanvas.setAttribute('height', '' + this.h)
-                        this.redraw()
-
-                        //update button positions
-                        // if (this.zoomButtons) this.zoomButtons.node.style.left = this.w - 50 + 'px'
-                        // if (this.fullscreenButton) this.fullscreenButton.node.style.left = this.w - 50 + 'px'
-                    }
-                })
+                if (!resizePending) {
+                    resizePending = true // Prevent overlapping resize triggers
+
+                    window.requestAnimationFrame(() => {
+                        resizePending = false // Reset the flag after processing
+
+                        // Check for size changes
+                        if (this.h !== container.clientHeight || this.w !== container.clientWidth) {
+                            this.h = container.clientHeight
+                            this.w = container.clientWidth
+
+                            // Update geoCanvas sizes
+                            this.geoCanvas.h = this.h
+                            this.geoCanvas.w = this.w
+                            this.geoCanvas.canvas.setAttribute('width', String(this.w))
+                            this.geoCanvas.canvas.setAttribute('height', String(this.h))
+                            this.geoCanvas.offscreenCanvas.setAttribute('width', String(this.w))
+                            this.geoCanvas.offscreenCanvas.setAttribute('height', String(this.h))
+
+                            this.redraw()
+
+                            // Optionally reposition UI elements
+                            // if (this.zoomButtons) this.zoomButtons.node.style.left = this.w - 50 + 'px';
+                            // if (this.fullscreenButton) this.fullscreenButton.node.style.left = this.w - 50 + 'px';
+                        }
+                    })
+                }
             }
         })
 

package/src/core/Tooltip.js

@@ -16,8 +16,6 @@ export class Tooltip {
     constructor(opts) {
         opts = opts || {}
 
-        /** @type {string} */
-        this.div = opts.div || 'tooltip_eurostat'
         /** @type {string} */
         this.maxWidth = opts.maxWidth || '20em'
         /** @type {string} */
@@ -47,21 +45,15 @@ export class Tooltip {
         this.xMouseOffset = opts.xMouseOffset || 0
         /** @type {HTMLElement} */
         this.parentElement = opts.parentElement || document.body
+        /** @type {HTMLElement} */
+        this.tooltipElement = opts.tooltipElement || null
 
         /**
          * @public
          * @type {import("d3-selection").Selection} */
-        this.tooltip = select('#' + this.div)
-
-        if (this.tooltip.empty()) {
-            //create tooltip DOM node
-            // this.tooltip = select(
-            //     '#' + this.parentElement.id && this.parentElement.id != ''
-            //         ? '#' + this.parentElement.id
-            //         : 'body'
-            // )
-            this.tooltip = select('body').append('div').attr('id', this.div)
-        }
+        this.tooltip = opts.tooltipElement
+            ? select(opts.tooltipElement) // Wrap the provided HTML node in a D3 selection
+            : select(this.parentElement).append('div').attr('id', 'gridviz-tooltip').attr('class', 'gridviz-tooltip') // create default element
 
         //initialise
         this.tooltip.style('max-width', this.maxWidth)
@@ -78,6 +70,10 @@ export class Tooltip {
         this.tooltip.style('opacity', '0')
         this.tooltip.style('text-wrap', 'nowrap')
 
+        // these placeholders are needed to prevent an infinite DOM resizeObserver loop:
+        this.tooltip.style('left', '0')
+        this.tooltip.style('top', '0')
+
         // aria-labels (thanks to wahlatlas)
         this.tooltip.attr('role', 'tooltip').attr('aria-live', 'polite')
     }
@@ -107,14 +103,51 @@ export class Tooltip {
      * @param {MouseEvent} event
      */
     setPosition(event) {
+        // Get the bounding rect of the parent container (map2)
         let parentRect = this.parentElement.getBoundingClientRect()
 
-        let x = event.pageX + this.xOffset
-        let y = event.pageY - this.yOffset
+        // Get the mouse position (relative to the parent container)
+        let x = event.clientX - parentRect.left + this.xOffset // Relative to parent
+        let y = event.clientY - parentRect.top - this.yOffset // Relative to parent
 
+        // Now, apply the position to the tooltip
         this.tooltip.style('left', x + 'px').style('top', y + 'px')
 
-        this.ensureTooltipInsideContainer(event, parentRect)
+        // Ensure the tooltip stays inside the parent container
+        this.ensureTooltipInsideContainer(event, parentRect, this.tooltip.node())
+    }
+    /**
+     * @function ensureTooltipInsideContainer
+     * @description Prevents the tooltip from overflowing out of the App container (ensures that the tooltip is inside the gridviz container)
+     * @param {MouseEvent} event
+     * @param {DOMRect} parentRect
+     * @param {HTMLElement} tooltipNode
+     */
+    ensureTooltipInsideContainer(event, parentRect, tooltipNode) {
+        let node = tooltipNode
+        let parentWidth = parentRect.width
+        let parentHeight = parentRect.height
+
+        // Ensure tooltip doesn't go beyond the right edge
+        if (node.offsetLeft + node.clientWidth > parentWidth) {
+            let left = event.clientX - node.clientWidth - this.xOffset
+            node.style.left = left + 'px'
+        }
+
+        // Ensure tooltip doesn't go beyond the bottom edge
+        if (node.offsetTop + node.clientHeight > parentHeight) {
+            node.style.top = parentHeight - node.clientHeight + 'px'
+        }
+
+        // Ensure tooltip doesn't go above the top edge
+        if (node.offsetTop < 0) {
+            node.style.top = 0 + 'px'
+        }
+
+        // Ensure tooltip doesn't go beyond the left edge
+        if (node.offsetLeft < 0) {
+            node.style.left = 0 + 'px'
+        }
     }
 
     /*
@@ -145,39 +178,4 @@ export class Tooltip {
         this.tooltip.attr(k, v)
         return this
     }
-
-    /**
-     * @function ensureTooltipInsideContainer
-     * @description Prevents the tooltip from overflowing out of the App container (ensures that the tooltip is inside the gridviz container)
-     * @param {MouseEvent} event
-     * @param {DOMRect} parentRect
-     */
-    ensureTooltipInsideContainer = function (event, parentRect) {
-        let node = this.tooltip.node()
-        let parentWidth = parentRect.width
-        let parentHeight = parentRect.height
-
-        //too far right
-        if (node.offsetLeft > parentRect.left + parentWidth - node.clientWidth) {
-            let left = event.x - node.clientWidth - this.xOffset
-            node.style.left = left + 'px'
-            // check if mouse covers tooltip
-            if (node.offsetLeft + node.clientWidth > event.x) {
-                //move tooltip left so it doesnt cover mouse
-                let left2 = event.x - node.clientWidth - this.xOffset
-                node.style.left = left2 + 'px'
-            }
-            // node.style.top = node.offsetTop + config.yOffset + "px";
-        }
-
-        //too far down
-        if (node.offsetTop + node.clientHeight > parentRect.top + parentHeight) {
-            node.style.top = node.offsetTop - node.clientHeight + 'px'
-        }
-
-        //too far up
-        if (node.offsetTop < parentRect.top) {
-            node.style.top = parentRect.top + this.yOffset + 'px'
-        }
-    }
 }