@windborne/grapher 1.0.43 → 1.0.45

package/package.json

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

package/src/state/calculate_data_bounds.js

@@ -66,7 +66,7 @@ export default function calculateDataBounds(inDataSpace, {percentile=100, percen
     };
 
     if (percentile !== 100 && inDataSpace.length) {
-        return percentileBounds(inDataSpace, bounds, {percentile, percentileAsymmetry});
+        return percentileBounds(inDataSpace, bounds, {percentile, percentileAsymmetry, rangeValues});
     }
 
     let dates = false;
@@ -117,6 +117,7 @@ export default function calculateDataBounds(inDataSpace, {percentile=100, percen
             }
         }
     }
+    
 
     return finalizeBounds(bounds, {dates});
 }

package/src/state/expand_bounds.js

@@ -31,8 +31,12 @@ export default function expandBounds(bounds, {expandYWith = [], extendXForNBars=
 
     const range = expandedBounds.maxY - expandedBounds.minY;
     const midpoint = expandedBounds.minY + range/2;
-    expandedBounds.minY = midpoint - 1.05*range/2;
-    expandedBounds.maxY = midpoint + 1.05*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);
+    
 
     if (expandedBounds.minY === expandedBounds.maxY && expandedBounds.minY !== null) {
         if (expandedBounds.minY > 0) {

package/src/state/space_conversions/simple_series_to_data_space.js

@@ -14,12 +14,22 @@ export default function simpleSeriesToDataSpace(singleSeries, options={}) {
         throw new Error(`Cannot normalize ${type} (expected a simple type)`);
     }
 
-    const inDataSpace = {
+    const result = {
         tuples: tuplesToDataSpace,
         values: valuesToDataSpace,
         objects: objectsToDataSpace
     }[type](options.data || singleSeries.simpleData || singleSeries.data, singleSeries, options);
 
+    let inDataSpace;
+    let rangeValues = [];
+
+    if (Array.isArray(result)) {
+        inDataSpace = result;
+    } else {
+        inDataSpace = result.data;
+        rangeValues = result.rangeValues || [];
+    }
+
     if (singleSeries.square) {
         const square = [];
         let prevY = options.prevY;
@@ -58,6 +68,13 @@ export default function simpleSeriesToDataSpace(singleSeries, options={}) {
         }
     }
 
+    if (rangeValues.length > 0) {
+        return {
+            data: inDataSpace,
+            rangeValues: rangeValues
+        };
+    }
+
     return inDataSpace;
 }
 
@@ -239,7 +256,10 @@ function objectsToDataSpace(data, series, options) {
     }
 
     if (rangeValues.length > 0) {
-        series._rangeValues = rangeValues;
+        return {
+            data: inDataSpace,
+            rangeValues: rangeValues
+        };
     }
 
     return inDataSpace;

package/src/state/state_controller.js

@@ -613,16 +613,35 @@ export default class StateController extends Eventable {
             }
 
             const simpleData = this._seriesToSimpleData(singleSeries);
-            singleSeries.inDataSpace = simpleSeriesToDataSpace({
+            const dataSpaceResult = simpleSeriesToDataSpace({
                 ...singleSeries,
                 data: simpleData
             }, {
                 stateController: this
             });
+            
+            let inDataSpace, rangeValues;
+            if (Array.isArray(dataSpaceResult)) {
+                inDataSpace = dataSpaceResult;
+                rangeValues = [];
+            } else {
+                inDataSpace = dataSpaceResult.data;
+                rangeValues = dataSpaceResult.rangeValues || [];
+            }
+            
+            singleSeries.inDataSpace = inDataSpace;
             singleSeries.simpleDataSliceStart = simpleData.length;
-            singleSeries.dataBounds = calculateDataBounds(singleSeries.inDataSpace, { 
-                rangeValues: singleSeries._rangeValues || [] 
+            singleSeries._rangeValues = rangeValues;
+            const allYValues = [...inDataSpace.map(([x, y]) => y).filter(y => typeof y === 'number'), ...rangeValues];
+            const extendedDataSpace = inDataSpace.map(([x, y]) => [x, y]);
+            for (let rangeValue of rangeValues) {
+                extendedDataSpace.push([null, rangeValue]);
+            }
+            
+            singleSeries.dataBounds = calculateDataBounds(extendedDataSpace, { 
+                rangeValues: rangeValues 
             });
+            
             if (singleSeries.rendering === 'bar') {
                 singleSeries.dataBounds = expandBounds(singleSeries.dataBounds, { extendXForNBars: singleSeries.inDataSpace.length, expandYWith: singleSeries.expandYWith });
             }
@@ -780,7 +799,48 @@ export default class StateController extends Eventable {
                     axis.targetBounds = axis.targetBounds.byAxis[axis.axisIndex];
                 }
 
-                axis.currentBounds = axis.targetBounds;
+                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;
+                                if (rangeIndex < singleSeries._rangeValues.length) {
+                                    visibleRangeValues.push(singleSeries._rangeValues[rangeIndex]);
+                                    if (rangeIndex + 1 < singleSeries._rangeValues.length) {
+                                        visibleRangeValues.push(singleSeries._rangeValues[rangeIndex + 1]);
+                                    }
+                                }
+                            }
+                        }
+                        
+                        if (visibleRangeValues.length > 0) {
+                            expandYWith.push(...visibleRangeValues);
+                        }
+                    }
+                }
+
+                if (expandYWith.length > 0) {
+                    const boundsToExpand = { ...axis.targetBounds };
+                    
+                    if (boundsToExpand.minY === null) {
+                        boundsToExpand.minY = Math.min(...expandYWith.filter(y => typeof y === 'number'));
+                    }
+                    
+                    if (boundsToExpand.maxY === null) {
+                        boundsToExpand.maxY = Math.max(...expandYWith.filter(y => typeof y === 'number'));
+                    }
+                    
+                    axis.currentBounds = boundsToExpand;
+                } else {
+                    axis.currentBounds = axis.targetBounds;
+                }
                 continue;
             }
 
@@ -799,7 +859,27 @@ export default class StateController extends Eventable {
                 }
 
                 if (singleSeries._rangeValues && singleSeries._rangeValues.length > 0) {
-                    expandYWith.push(...singleSeries._rangeValues);
+                    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;
+                            if (rangeIndex < singleSeries._rangeValues.length) {
+                                visibleRangeValues.push(singleSeries._rangeValues[rangeIndex]);
+                                if (rangeIndex + 1 < singleSeries._rangeValues.length) {
+                                    visibleRangeValues.push(singleSeries._rangeValues[rangeIndex + 1]);
+                                }
+                            }
+                        }
+                    }
+                    
+                    if (visibleRangeValues.length > 0) {
+                        expandYWith.push(...visibleRangeValues);
+                    }
                 }
             }