@windborne/grapher 1.0.47 → 1.0.49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@windborne/grapher",
-  "version": "1.0.47",
+  "version": "1.0.49",
   "description": "Graphing library",
   "main": "src/index.js",
   "module": "dist/bundle.esm.js",

package/src/renderer/draw_area.js

@@ -141,56 +141,6 @@ export default function drawArea(
   for (let pathI = 0; pathI < areaPaths.length; pathI++) {
     const path = areaPaths[pathI];
     const areaBottomPath = areaBottomPaths && areaBottomPaths[pathI];
-    
-    // Determine if this path segment is positive or negative for gradient application
-    let isPositive = true;
-    if (hasNegatives && negativeGradient && path.length > 0) {
-      // Check the average Y position of the path to determine if it's above or below zero
-      let sumY = 0;
-      for (let i = 0; i < path.length; i++) {
-        sumY += path[i][1];
-      }
-      const avgY = sumY / path.length;
-      isPositive = avgY <= zero; // In screen coordinates, smaller Y is higher up (positive)
-    }
-    
-    // Set the fill style based on whether this is a positive or negative segment
-    if (hasNegatives && negativeGradient) {
-      if (isPositive) {
-        // Use the original gradient or color for positive areas
-        if (gradient && gradient.length >= 2) {
-          const globalGradient = context.createLinearGradient(0, 0, 0, sizing.renderHeight);
-          for (let i = 0; i < gradient.length; i++) {
-            const value = gradient[i];
-            if (Array.isArray(value)) {
-              globalGradient.addColorStop(value[0], value[1]);
-            } else {
-              globalGradient.addColorStop(i / (gradient.length - 1), value);
-            }
-          }
-          context.fillStyle = globalGradient;
-        } else {
-          context.fillStyle = color;
-        }
-      } else {
-        // Use negativeGradient for negative areas
-        if (negativeGradient.length >= 2) {
-          const negGradient = context.createLinearGradient(0, 0, 0, sizing.renderHeight);
-          for (let i = 0; i < negativeGradient.length; i++) {
-            const value = negativeGradient[i];
-            if (Array.isArray(value)) {
-              negGradient.addColorStop(value[0], value[1]);
-            } else {
-              negGradient.addColorStop(i / (negativeGradient.length - 1), value);
-            }
-          }
-          context.fillStyle = negGradient;
-        } else {
-          context.fillStyle = negativeColor || color;
-        }
-      }
-    }
-    
     context.beginPath();
 
     const [firstX, _startY] = path[0];
@@ -361,7 +311,6 @@ function drawAreaWithCutoff(
     shadowBlur,
     inRenderSpaceAreaBottom,
     cutoffIndex,
-    cutoffTimeValue,
     cutoffOpacity,
     originalData,
     selectionBounds,
@@ -369,9 +318,7 @@ function drawAreaWithCutoff(
   }
 ) {
   let cutoffTime;
-  if (cutoffTimeValue !== undefined && cutoffTimeValue !== null) {
-    cutoffTime = cutoffTimeValue;
-  } else if (typeof originalData[0] === "object" && originalData[0].length === 2) {
+  if (typeof originalData[0] === "object" && originalData[0].length === 2) {
     const baseIndex = Math.floor(cutoffIndex);
     const fraction = cutoffIndex - baseIndex;
 

package/src/state/calculate_data_bounds.js

@@ -2,8 +2,8 @@ function finalizeBounds(bounds, { dates }) {
     const initial = (bounds.minX === null && bounds.maxX === null) || bounds.minY === null || bounds.maxY === null;
 
     for (let key of Object.keys(bounds)) {
-        if (typeof bounds[key] !== 'number') {
-            bounds[key] = 0;
+        if (typeof bounds[key] !== 'number' && bounds[key] !== null) {
+            bounds[key] = null;
         }
     }
 
@@ -73,6 +73,10 @@ export default function calculateDataBounds(inDataSpace, {percentile=100, percen
     let prevX = null;
 
     for (let [x, y] of inDataSpace) {
+        if (x === null) {
+            continue;
+        }
+        
         if (x instanceof Date) {
             x = x.valueOf();
             dates = true;
@@ -118,6 +122,5 @@ export default function calculateDataBounds(inDataSpace, {percentile=100, percen
         }
     }
     
-
     return finalizeBounds(bounds, {dates});
 }

package/src/state/expand_bounds.js

@@ -31,9 +31,6 @@ export default function expandBounds(bounds, {expandYWith = [], extendXForNBars=
 
     const range = expandedBounds.maxY - expandedBounds.minY;
     const midpoint = expandedBounds.minY + range/2;
-    const padding = 0.05 * range / 2;
-    const beforeMin = expandedBounds.minY;
-    const beforeMax = expandedBounds.maxY;
     expandedBounds.minY = Math.min(expandedBounds.minY, midpoint - 1.05*range/2);
     expandedBounds.maxY = Math.max(expandedBounds.maxY, midpoint + 1.05*range/2);
     

package/src/state/merge_bounds.js

@@ -19,23 +19,23 @@ export default function mergeBounds(boundsList) {
         }
         mergedBounds.initial = false;
 
-        if (mergedBounds.minX === null || minX < mergedBounds.minX) {
+        if (minX !== null && (mergedBounds.minX === null || minX < mergedBounds.minX)) {
             mergedBounds.minX = minX;
         }
 
-        if (mergedBounds.maxX === null || maxX > mergedBounds.maxX) {
+        if (maxX !== null && (mergedBounds.maxX === null || maxX > mergedBounds.maxX)) {
             mergedBounds.maxX = maxX;
         }
 
-        if (mergedBounds.closestSpacing === null || closestSpacing < mergedBounds.closestSpacing) {
+        if (closestSpacing !== null && (mergedBounds.closestSpacing === null || closestSpacing < mergedBounds.closestSpacing)) {
             mergedBounds.closestSpacing = closestSpacing;
         }
 
-        if (mergedBounds.minY === null || minY < mergedBounds.minY) {
+        if (minY !== null && (mergedBounds.minY === null || minY < mergedBounds.minY)) {
             mergedBounds.minY = minY;
         }
 
-        if (mergedBounds.maxY === null || maxY > mergedBounds.maxY) {
+        if (maxY !== null && (mergedBounds.maxY === null || maxY > mergedBounds.maxY)) {
             mergedBounds.maxY = maxY;
         }
     }

package/src/state/state_controller.js

@@ -802,15 +802,27 @@ export default class StateController extends Eventable {
                 const expandYWith = [];
                 for (let singleSeries of axis.series) {
                     if (singleSeries._rangeValues && singleSeries._rangeValues.length > 0) {
-                        const visibleDataPoints = singleSeries.inDataSpace.filter(([x, y]) => 
-                            axis.targetBounds.minX <= x && x <= axis.targetBounds.maxX
-                        );
-                        
                         const visibleRangeValues = [];
-                        for (let i = 0; i < visibleDataPoints.length; i++) {
-                            const dataPointIndex = singleSeries.inDataSpace.indexOf(visibleDataPoints[i]);
-                            if (dataPointIndex >= 0) {
-                                const rangeIndex = dataPointIndex * 2;
+                        
+                        for (let i = 0; i < singleSeries.inDataSpace.length; i++) {
+                            const [x, y] = singleSeries.inDataSpace[i];
+                            let xValue = x;
+                            let minXValue = axis.targetBounds.minX;
+                            let maxXValue = axis.targetBounds.maxX;
+                            
+                            if (x instanceof Date) {
+                                xValue = x.valueOf();
+                            }
+                            if (minXValue instanceof Date) {
+                                minXValue = minXValue.valueOf();
+                            }
+                            if (maxXValue instanceof Date) {
+                                maxXValue = maxXValue.valueOf();
+                            }
+                            
+                            if (minXValue !== null && maxXValue !== null && 
+                                xValue >= minXValue && xValue <= maxXValue) {
+                                const rangeIndex = i * 2;
                                 if (rangeIndex < singleSeries._rangeValues.length) {
                                     visibleRangeValues.push(singleSeries._rangeValues[rangeIndex]);
                                     if (rangeIndex + 1 < singleSeries._rangeValues.length) {
@@ -854,15 +866,27 @@ export default class StateController extends Eventable {
                 }
 
                 if (singleSeries._rangeValues && singleSeries._rangeValues.length > 0) {
-                    const visibleDataPoints = singleSeries.inDataSpace.filter(([x, y]) => 
-                        singleSeries.selectedBounds.minX <= x && x <= singleSeries.selectedBounds.maxX
-                    );
-                    
                     const visibleRangeValues = [];
-                    for (let i = 0; i < visibleDataPoints.length; i++) {
-                        const dataPointIndex = singleSeries.inDataSpace.indexOf(visibleDataPoints[i]);
-                        if (dataPointIndex >= 0) {
-                            const rangeIndex = dataPointIndex * 2;
+                    
+                    for (let i = 0; i < singleSeries.inDataSpace.length; i++) {
+                        const [x, y] = singleSeries.inDataSpace[i];
+                        let xValue = x;
+                        let minXValue = singleSeries.selectedBounds.minX;
+                        let maxXValue = singleSeries.selectedBounds.maxX;
+                        
+                        if (x instanceof Date) {
+                            xValue = x.valueOf();
+                        }
+                        if (minXValue instanceof Date) {
+                            minXValue = minXValue.valueOf();
+                        }
+                        if (maxXValue instanceof Date) {
+                            maxXValue = maxXValue.valueOf();
+                        }
+                        
+                        if (minXValue !== null && maxXValue !== null && 
+                            xValue >= minXValue && xValue <= maxXValue) {
+                            const rangeIndex = i * 2;
                             if (rangeIndex < singleSeries._rangeValues.length) {
                                 visibleRangeValues.push(singleSeries._rangeValues[rangeIndex]);
                                 if (rangeIndex + 1 < singleSeries._rangeValues.length) {