@ni/nimble-components 18.5.4 → 18.5.6

package/dist/all-components-bundle.js

@@ -28418,6 +28418,7 @@
         grid-row: 2;
         grid-column-start: 1;
         grid-column-end: 4;
+        overflow: auto;
     }
 `;
 
@@ -33172,6 +33173,18 @@ Instead styling against the role which is more general and likely a better appro
       return (reverse ? -1 : 1) * (inc < 0 ? 1 / -inc : inc);
     }
 
+    function quantileSorted(values, p, valueof = number$1) {
+      if (!(n = values.length) || isNaN(p = +p)) return;
+      if (p <= 0 || n < 2) return +valueof(values[0], 0, values);
+      if (p >= 1) return +valueof(values[n - 1], n - 1, values);
+      var n,
+          i = (n - 1) * p,
+          i0 = Math.floor(i),
+          value0 = +valueof(values[i0], i0, values),
+          value1 = +valueof(values[i0 + 1], i0 + 1, values);
+      return value0 + (value1 - value0) * (i - i0);
+    }
+
     function range(start, stop, step) {
       start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;
 
@@ -33870,6 +33883,61 @@ Instead styling against the role which is more general and likely a better appro
       return linearish(scale);
     }
 
+    function quantile() {
+      var domain = [],
+          range = [],
+          thresholds = [],
+          unknown;
+
+      function rescale() {
+        var i = 0, n = Math.max(1, range.length);
+        thresholds = new Array(n - 1);
+        while (++i < n) thresholds[i - 1] = quantileSorted(domain, i / n);
+        return scale;
+      }
+
+      function scale(x) {
+        return x == null || isNaN(x = +x) ? unknown : range[bisect(thresholds, x)];
+      }
+
+      scale.invertExtent = function(y) {
+        var i = range.indexOf(y);
+        return i < 0 ? [NaN, NaN] : [
+          i > 0 ? thresholds[i - 1] : domain[0],
+          i < thresholds.length ? thresholds[i] : domain[domain.length - 1]
+        ];
+      };
+
+      scale.domain = function(_) {
+        if (!arguments.length) return domain.slice();
+        domain = [];
+        for (let d of _) if (d != null && !isNaN(d = +d)) domain.push(d);
+        domain.sort(ascending);
+        return rescale();
+      };
+
+      scale.range = function(_) {
+        return arguments.length ? (range = Array.from(_), rescale()) : range.slice();
+      };
+
+      scale.unknown = function(_) {
+        return arguments.length ? (unknown = _, scale) : unknown;
+      };
+
+      scale.quantiles = function() {
+        return thresholds.slice();
+      };
+
+      scale.copy = function() {
+        return quantile()
+            .domain(domain)
+            .range(range)
+            .unknown(unknown);
+      };
+
+      return initRange.apply(scale, arguments);
+    }
+
     const WaferMapQuadrant = {
         bottomLeft: 'bottom-left',
         bottomRight: 'bottom-right',
@@ -33896,13 +33964,7 @@ Instead styling against the role which is more general and likely a better appro
      */
     class Computations {
         constructor(wafermap) {
-            this.baseMargin = {
-                top: 0,
-                right: 0,
-                bottom: 0,
-                left: 0
-            };
-            this.defaultAlign = 0.5;
+            this.defaultPadding = 0;
             this.baseMarginPercentage = 0.04;
             const canvasDimensions = {
                 width: wafermap.canvasWidth,
@@ -33927,11 +33989,13 @@ Instead styling against the role which is more general and likely a better appro
             const containerDiameter = Math.min(this.containerDimensions.width, this.containerDimensions.height);
             // this scale is used for positioning the dies on the canvas
             this.horizontalScale = this.createHorizontalScale(wafermap.quadrant, gridDimensions, containerDiameter);
+            this.invertedHorizontalScale = this.createInvertedHorizontalScale(wafermap.quadrant, gridDimensions, containerDiameter);
             // this scale is used for positioning the dies on the canvas
             this.verticalScale = this.createVerticalScale(wafermap.quadrant, gridDimensions, containerDiameter);
+            this.invertedVerticalScale = this.createInvertedVerticalScale(wafermap.quadrant, gridDimensions, containerDiameter);
             this.dieDimensions = {
-                width: this.calculateGridWidth(gridDimensions.cols, this.containerDimensions.width),
-                height: this.calculateGridHeight(gridDimensions.rows, this.containerDimensions.height)
+                width: this.horizontalScale.bandwidth(),
+                height: this.verticalScale.bandwidth()
             };
             this.radius = containerDiameter / 2;
         }
@@ -33968,42 +34032,46 @@ Instead styling against the role which is more general and likely a better appro
             };
         }
         createHorizontalScale(axisLocation, grid, containerWidth) {
+            const scale = band()
+                .domain(range(grid.origin.x, grid.origin.x + grid.cols))
+                .paddingInner(0)
+                .paddingOuter(0)
+                .align(0)
+                .round(false);
             if (axisLocation === WaferMapQuadrant.bottomLeft
                 || axisLocation === WaferMapQuadrant.topLeft) {
-                return linear()
-                    .domain([grid.origin.x, grid.origin.x + grid.cols])
-                    .range([0, containerWidth]);
+                return scale.range([0, containerWidth]);
             }
-            return linear()
-                .domain([grid.origin.x - 1, grid.origin.x + grid.cols - 1])
-                .range([containerWidth, 0]);
+            return scale.range([containerWidth, 0]);
+        }
+        createInvertedHorizontalScale(axisLocation, grid, containerWidth) {
+            const scale = quantile().domain([0, containerWidth]);
+            if (axisLocation === WaferMapQuadrant.bottomLeft
+                || axisLocation === WaferMapQuadrant.topLeft) {
+                return scale.range(range(grid.origin.x, grid.origin.x + grid.cols));
+            }
+            return scale.range(range(grid.origin.x, grid.origin.x + grid.cols).reverse());
         }
         createVerticalScale(axisLocation, grid, containerHeight) {
+            const scale = band()
+                .domain(range(grid.origin.y, grid.origin.y + grid.rows))
+                .paddingInner(this.defaultPadding)
+                .paddingOuter(0)
+                .align(0)
+                .round(false);
             if (axisLocation === WaferMapQuadrant.bottomLeft
                 || axisLocation === WaferMapQuadrant.bottomRight) {
-                return linear()
-                    .domain([grid.origin.y - 1, grid.origin.y + grid.rows - 1])
-                    .range([containerHeight, 0]);
-            }
-            return linear()
-                .domain([grid.origin.y, grid.origin.y + grid.rows])
-                .range([0, containerHeight]);
-        }
-        calculateGridWidth(cols, containerWidth) {
-            return band()
-                .align(this.defaultAlign)
-                .padding(0)
-                .domain(this.horizontalScale.ticks(cols))
-                .range([0, containerWidth])
-                .bandwidth();
-        }
-        calculateGridHeight(rows, containerHeight) {
-            return band()
-                .align(this.defaultAlign)
-                .padding(0)
-                .domain(this.verticalScale.ticks(rows))
-                .range([0, containerHeight])
-                .bandwidth();
+                return scale.range([containerHeight, 0]);
+            }
+            return scale.range([0, containerHeight]);
+        }
+        createInvertedVerticalScale(axisLocation, grid, containerHeight) {
+            const scale = quantile().domain([0, containerHeight]);
+            if (axisLocation === WaferMapQuadrant.bottomLeft
+                || axisLocation === WaferMapQuadrant.bottomRight) {
+                return scale.range(range(grid.origin.y, grid.origin.y + grid.rows).reverse());
+            }
+            return scale.range(range(grid.origin.y, grid.origin.y + grid.rows));
         }
         calculateMarginAddition(baseMargin, addedMargin) {
             return {
@@ -34028,9 +34096,11 @@ Instead styling against the role which is more general and likely a better appro
             this.labelsFontSize = this.calculateLabelsFontSize(dieDimensions, wafermap.maxCharacters);
             this.diesRenderInfo = [];
             for (const die of wafermap.dies) {
+                const scaledX = horizontalScale(die.x) ?? 0;
+                const scaledY = verticalScale(die.y) ?? 0;
                 this.diesRenderInfo.push({
-                    x: horizontalScale(die.x) + margin.right,
-                    y: verticalScale(die.y) + margin.top,
+                    x: scaledX + margin.right,
+                    y: scaledY + margin.top,
                     fillStyle: this.calculateFillStyle(die.value, wafermap.colorScaleMode, wafermap.highlightedValues),
                     text: this.buildLabel(die.value, wafermap.maxCharacters, wafermap.dieLabelsHidden, wafermap.dieLabelsSuffix)
                 });
@@ -34124,9 +34194,15 @@ Instead styling against the role which is more general and likely a better appro
         get horizontalScale() {
             return this.computations.horizontalScale;
         }
+        get invertedHorizontalScale() {
+            return this.computations.invertedHorizontalScale;
+        }
         get verticalScale() {
             return this.computations.verticalScale;
         }
+        get invertedVerticalScale() {
+            return this.computations.invertedVerticalScale;
+        }
         get labelsFontSize() {
             return this.prerendering.labelsFontSize;
         }
@@ -34324,8 +34400,8 @@ Instead styling against the role which is more general and likely a better appro
                 ? Math.floor
                 : Math.ceil;
             // go to x and y scale to get the x,y values of the die.
-            const x = xRoundFunction(this.wafermap.dataManager.horizontalScale.invert(mousePosition.x - this.wafermap.dataManager.margin.left));
-            const y = yRoundFunction(this.wafermap.dataManager.verticalScale.invert(mousePosition.y - this.wafermap.dataManager.margin.top));
+            const x = xRoundFunction(this.wafermap.dataManager.invertedHorizontalScale(mousePosition.x - this.wafermap.dataManager.margin.left));
+            const y = yRoundFunction(this.wafermap.dataManager.invertedVerticalScale(mousePosition.y - this.wafermap.dataManager.margin.top));
             return { x, y };
         }
         hoversOverDie(mousePosition) {