scichart 2.1.0-beta.40 → 2.1.2261

package/Charting/ChartModifiers/RolloverModifier.d.ts

@@ -49,6 +49,7 @@ export declare type TTooltipProps = {
     isCategoryAxis: boolean;
     isY1: boolean;
     height: number;
+    width: number;
     seriesInfo: SeriesInfo;
 };
 /**
@@ -237,15 +238,16 @@ export declare class RolloverModifier extends ChartModifierBase2D implements IIn
  * @param pixelRatio
  * @param isY1
  */
-export declare const calcTooltipProps: (index: number, rs: IRenderableSeries, rolloverProps: RolloverModifierRenderableSeriesProps, seriesViewRect: Rect, xValue: number, yValue: number, absoluteXCoord: number, absoluteYCoord: number, hitTestInfo: HitTestInfo, pixelRatio: number, isY1?: boolean) => TTooltipProps;
+export declare const calcTooltipProps: (index: number, rs: IRenderableSeries, rolloverProps: RolloverModifierRenderableSeriesProps, seriesViewRect: Rect, xValue: number, yValue: number, absoluteXCoord: number, absoluteYCoord: number, hitTestInfo: HitTestInfo, pixelRatio: number, isY1?: boolean, isVerticalChart?: boolean) => TTooltipProps;
 /**
  * @ignore
  * @description Used internally, calculates tooltip positions to avoid overlapping
  * @param tooltipArray
  * @param allowTooltipOverlapping
- * @param tooltipPaddingTop
+ * @param spacing
  * @param seriesViewRect
  * @param pixelRatio
+ * @param isVerticalChart
  */
-export declare const calcTooltipPositions: (tooltipArray: TTooltipProps[], allowTooltipOverlapping: boolean, tooltipPaddingTop: number, seriesViewRect: Rect, pixelRatio: number) => TTooltipProps[];
+export declare const calcTooltipPositions: (tooltipArray: TTooltipProps[], allowTooltipOverlapping: boolean, spacing: number, seriesViewRect: Rect, pixelRatio: number, isVerticalChart?: boolean) => TTooltipProps[];
 export {};

package/Charting/ChartModifiers/RolloverModifier.js

@@ -20,6 +20,7 @@ var classFactory_1 = require("../../Builder/classFactory");
 var BaseType_1 = require("../../types/BaseType");
 var ChartModifierType_1 = require("../../types/ChartModifierType");
 var SeriesType_1 = require("../../types/SeriesType");
+var tooltip_1 = require("../../utils/tooltip");
 var translate_1 = require("../../utils/translate");
 var AnnotationBase_1 = require("../Visuals/Annotations/AnnotationBase");
 var LineAnnotation_1 = require("../Visuals/Annotations/LineAnnotation");
@@ -50,7 +51,7 @@ var EMousePosition;
     EMousePosition["SeriesArea"] = "SeriesArea";
 })(EMousePosition || (EMousePosition = {}));
 /** @ignore */
-var TOOLTIP_PADDING_TOP = 4;
+var TOOLTIP_SPACING = 4;
 /**
  * The RolloverModifier provides tooltip and cursor behavior on a 2D {@link SciChartSurface}
  * within SciChart - High Performance {@link https://www.scichart.com/javascript-chart-features | JavaScript Charts}
@@ -518,7 +519,7 @@ var RolloverModifier = /** @class */ (function (_super) {
                     if (isVisible) {
                         var absoluteXCoord = _this.isVerticalChart() ? hitTestInfo.yCoord : hitTestInfo.xCoord;
                         var absoluteYCoord = _this.isVerticalChart() ? hitTestInfo.xCoord : hitTestInfo.yCoord;
-                        var tooltipProps = (0, exports.calcTooltipProps)(index, rs, rs.rolloverModifierProps, _this.parentSurface.seriesViewRect, hitTestInfo.xValue, hitTestInfo.yValue, absoluteXCoord, absoluteYCoord, hitTestInfo, DpiHelper_1.DpiHelper.PIXEL_RATIO);
+                        var tooltipProps = (0, exports.calcTooltipProps)(index, rs, rs.rolloverModifierProps, _this.parentSurface.seriesViewRect, hitTestInfo.xValue, hitTestInfo.yValue, absoluteXCoord, absoluteYCoord, hitTestInfo, DpiHelper_1.DpiHelper.PIXEL_RATIO, false, _this.isVerticalChart());
                         if (tooltipProps)
                             tooltipArray.push(tooltipProps);
                     }
@@ -528,7 +529,7 @@ var RolloverModifier = /** @class */ (function (_super) {
                     if (isVisibleY1) {
                         var absoluteXCoord = _this.isVerticalChart() ? hitTestInfo.y1Coord : hitTestInfo.xCoord;
                         var absoluteYCoord = _this.isVerticalChart() ? hitTestInfo.xCoord : hitTestInfo.y1Coord;
-                        var tooltipY1Props = (0, exports.calcTooltipProps)(index, rs, rs.rolloverModifierProps1, _this.parentSurface.seriesViewRect, hitTestInfo.xValue, hitTestInfo.y1Value, absoluteXCoord, absoluteYCoord, hitTestInfo, DpiHelper_1.DpiHelper.PIXEL_RATIO, true);
+                        var tooltipY1Props = (0, exports.calcTooltipProps)(index, rs, rs.rolloverModifierProps1, _this.parentSurface.seriesViewRect, hitTestInfo.xValue, hitTestInfo.y1Value, absoluteXCoord, absoluteYCoord, hitTestInfo, DpiHelper_1.DpiHelper.PIXEL_RATIO, true, _this.isVerticalChart());
                         if (tooltipY1Props)
                             tooltipArray.push(tooltipY1Props);
                     }
@@ -538,7 +539,7 @@ var RolloverModifier = /** @class */ (function (_super) {
         var orderedTooltipArray = tooltipArray.sort(function (a, b) {
             return a.yCoord > b.yCoord ? 1 : b.yCoord > a.yCoord ? -1 : 0;
         });
-        var tooltipPositions = (0, exports.calcTooltipPositions)(orderedTooltipArray, this.allowTooltipOverlapping, TOOLTIP_PADDING_TOP * DpiHelper_1.DpiHelper.PIXEL_RATIO, this.parentSurface.seriesViewRect, DpiHelper_1.DpiHelper.PIXEL_RATIO);
+        var tooltipPositions = (0, exports.calcTooltipPositions)(orderedTooltipArray, this.allowTooltipOverlapping, TOOLTIP_SPACING * DpiHelper_1.DpiHelper.PIXEL_RATIO, this.parentSurface.seriesViewRect, DpiHelper_1.DpiHelper.PIXEL_RATIO, this.isVerticalChart());
         tooltipPositions.forEach(function (el) {
             var rs = rsList[el.index];
             var showTooltip = _this.showTooltip && el.seriesInfo.isHit;
@@ -589,8 +590,9 @@ exports.RolloverModifier = RolloverModifier;
  * @param pixelRatio
  * @param isY1
  */
-var calcTooltipProps = function (index, rs, rolloverProps, seriesViewRect, xValue, yValue, absoluteXCoord, absoluteYCoord, hitTestInfo, pixelRatio, isY1) {
+var calcTooltipProps = function (index, rs, rolloverProps, seriesViewRect, xValue, yValue, absoluteXCoord, absoluteYCoord, hitTestInfo, pixelRatio, isY1, isVerticalChart) {
     if (isY1 === void 0) { isY1 = false; }
+    if (isVerticalChart === void 0) { isVerticalChart = false; }
     var visibleRange = rs.yAxis.visibleRange;
     var isVisible = visibleRange.min <= yValue && yValue <= visibleRange.max;
     if (isVisible) {
@@ -601,13 +603,21 @@ var calcTooltipProps = function (index, rs, rolloverProps, seriesViewRect, xValu
         var scaledHeight = height * pixelRatio;
         var distTop = absoluteYCoord;
         var distBottom = seriesViewRect.height - absoluteYCoord;
+        var defaultVerticalShift = 5 * pixelRatio;
         var xCoordShift = seriesViewRect.width - absoluteXCoord < scaledWidth ? -width : 5;
-        var yCoordShift = -height / 2;
-        if (distTop < scaledHeight / 2) {
-            yCoordShift = -distTop / pixelRatio;
+        var yCoordShift = isVerticalChart ? defaultVerticalShift : -height / 2;
+        if (isVerticalChart) {
+            if (distBottom < scaledHeight + defaultVerticalShift) {
+                yCoordShift = ((scaledHeight + defaultVerticalShift) / pixelRatio) * -1;
+            }
         }
-        else if (distBottom < scaledHeight / 2) {
-            yCoordShift = -(scaledHeight - distBottom) / pixelRatio;
+        else {
+            if (distTop < scaledHeight / 2) {
+                yCoordShift = -distTop / pixelRatio;
+            }
+            else if (distBottom < scaledHeight / 2) {
+                yCoordShift = -(scaledHeight - distBottom) / pixelRatio;
+            }
         }
         var newRecord = {
             index: index,
@@ -621,6 +631,7 @@ var calcTooltipProps = function (index, rs, rolloverProps, seriesViewRect, xValu
             xCoordShift: xCoordShift,
             yCoordShift: yCoordShift,
             height: scaledHeight,
+            width: scaledWidth,
             seriesInfo: seriesInfo
         };
         return newRecord;
@@ -628,85 +639,32 @@ var calcTooltipProps = function (index, rs, rolloverProps, seriesViewRect, xValu
     return undefined;
 };
 exports.calcTooltipProps = calcTooltipProps;
-/** @ignore */
-var spreadTooltips = function (tooltipArray, totalTooltipsHeight, startY, endY, pixelRatio) {
-    var currentTotalPadding = endY - startY - totalTooltipsHeight;
-    var currentPadding = currentTotalPadding / (tooltipArray.length - 1);
-    tooltipArray.reduce(function (tooltipTopYCoord, tooltip) {
-        tooltip.yCoordShift = (tooltipTopYCoord - tooltip.yCoord) / pixelRatio;
-        return tooltipTopYCoord + tooltip.height + currentPadding;
-    }, startY);
-};
 /**
  * @ignore
  * @description Used internally, calculates tooltip positions to avoid overlapping
  * @param tooltipArray
  * @param allowTooltipOverlapping
- * @param tooltipPaddingTop
+ * @param spacing
  * @param seriesViewRect
  * @param pixelRatio
+ * @param isVerticalChart
  */
-var calcTooltipPositions = function (tooltipArray, allowTooltipOverlapping, tooltipPaddingTop, seriesViewRect, pixelRatio) {
+var calcTooltipPositions = function (tooltipArray, allowTooltipOverlapping, spacing, seriesViewRect, pixelRatio, isVerticalChart) {
+    if (isVerticalChart === void 0) { isVerticalChart = false; }
+    var positionProperties = (0, tooltip_1.getTooltipPositionProperties)(isVerticalChart);
+    var hasOverlap = (0, tooltip_1.checkHasOverlap)(tooltipArray, spacing, pixelRatio, positionProperties);
     var length = tooltipArray.length;
-    if (!allowTooltipOverlapping && length >= 2) {
-        var checkHasOverlap = function () {
-            for (var i = 0; i < length - 1; i++) {
-                var tooltip0 = tooltipArray[i];
-                var scaledHeightTooltip0 = tooltip0.height;
-                var scaledYShiftTooltip0 = tooltip0.yCoordShift * pixelRatio;
-                var bottomYTooltip0 = tooltip0.yCoord + scaledHeightTooltip0 + scaledYShiftTooltip0;
-                var tooltip1 = tooltipArray[i + 1];
-                var scaledYShiftTooltip1 = tooltip1.yCoordShift * pixelRatio;
-                var topYTooltip1 = tooltip1.yCoord + scaledYShiftTooltip1;
-                var diff = topYTooltip1 - bottomYTooltip0;
-                if (diff < tooltipPaddingTop)
-                    return true;
-            }
-            return false;
-        };
-        if (checkHasOverlap()) {
-            var totalTooltipsHeight = tooltipArray.reduce(function (prev, cur) { return prev + cur.height; }, 0);
-            var totalPadding = (length - 1) * tooltipPaddingTop;
-            var totalTooltipsHeightWithPadding = totalTooltipsHeight + totalPadding;
-            var notEnoughViewRectHeight = seriesViewRect.height <= totalTooltipsHeightWithPadding;
-            if (notEnoughViewRectHeight) {
-                var deltaYCoord = tooltipArray[length - 1].yCoord - tooltipArray[0].yCoord;
-                var centerY = tooltipArray[0].yCoord + deltaYCoord / 2;
-                var initialY_1 = centerY - totalTooltipsHeight / 2;
-                tooltipArray.reduce(function (prevSum, cur, index, arr) {
-                    var sum = index === 0 ? initialY_1 : prevSum + arr[index - 1].height + tooltipPaddingTop;
-                    // need to get not scaled value
-                    cur.yCoordShift = (sum - cur.yCoord) / pixelRatio;
-                    return sum;
-                }, 0);
-            }
-            else {
-                var firstTooltip = tooltipArray[0];
-                var lastTooltip = tooltipArray[length - 1];
-                var startY = firstTooltip.yCoord + firstTooltip.yCoordShift * pixelRatio;
-                var endY = lastTooltip.yCoord + lastTooltip.yCoordShift * pixelRatio + lastTooltip.height;
-                var isEnoughHeight = endY - startY >= totalTooltipsHeightWithPadding;
-                if (isEnoughHeight) {
-                    spreadTooltips(tooltipArray, totalTooltipsHeight, startY, endY, pixelRatio);
-                }
-                else {
-                    var additionalHeightNeeded = totalTooltipsHeightWithPadding - (endY - startY);
-                    var availableHeightFromStart = startY;
-                    var availableHeightFromEnd = seriesViewRect.height - endY;
-                    var newStartY = startY - additionalHeightNeeded / 2;
-                    var newEndY = endY + additionalHeightNeeded / 2;
-                    if (availableHeightFromStart < additionalHeightNeeded / 2) {
-                        newStartY = 0;
-                        newEndY = endY + (additionalHeightNeeded - availableHeightFromStart);
-                    }
-                    else if (availableHeightFromEnd < additionalHeightNeeded / 2) {
-                        newStartY = startY - (additionalHeightNeeded - availableHeightFromEnd);
-                        newEndY = seriesViewRect.height;
-                    }
-                    spreadTooltips(tooltipArray, totalTooltipsHeight, newStartY, newEndY, pixelRatio);
-                }
-            }
-        }
+    if (!allowTooltipOverlapping && length >= 2 && hasOverlap) {
+        var spreadMap_1 = (0, tooltip_1.spreadTooltips)(tooltipArray, pixelRatio, positionProperties, spacing, seriesViewRect);
+        tooltipArray.forEach(function (tooltip) {
+            tooltip[positionProperties.shiftPropertyName] = spreadMap_1.get(tooltip.index);
+        });
+    }
+    // centering for vertical charts without overlapping
+    if (isVerticalChart && !hasOverlap) {
+        tooltipArray.forEach(function (tooltip) {
+            return (tooltip[positionProperties.shiftPropertyName] = -(tooltip.width / 2) / pixelRatio);
+        });
     }
     return tooltipArray;
 };

package/Charting/Model/PointSeries/BasePointSeriesResampled.js

@@ -27,9 +27,9 @@ var BasePointSeriesResampled = /** @class */ (function () {
      * Updates SCRTDoubleVector from IntVector
      */
     BasePointSeriesResampled.prototype.updateIndexes = function () {
-        // We are not using this.intIndexes.size() because for OHLC after calling ExtremeResamplerHelper.mergeIndexes()
-        // it is bigger than the actual size
         var resultCount = this.count;
+        // console.log("resultCount", resultCount);
+        // console.log("this.indexes", this.indexes);
         this.indexes.resizeFast(resultCount);
         // TODO: Find an effective way to copy indexes
         for (var i = 0; i < resultCount; i++) {

package/Charting/Numerics/Resamplers/ExtremeResamplerHelper.d.ts

@@ -38,7 +38,7 @@ export declare class ExtremeResamplerHelper implements IDeletable {
      */
     resampleIntoPointSeries(wasmContext: TSciChart, rp: ResamplingParams, xOriginalValues: SCRTDoubleVector, yOriginalValues: SCRTDoubleVector, indexesOut: IntVector, xResampledValuesOut: SCRTDoubleVector, yResampledValuesOut: SCRTDoubleVector, fillBasicNativeArgs?: boolean): void;
     mergeIndexes(indices: IntVector, size1: number, size2: number, mergedIndicesOut: IntVector): number;
-    copyValuesByIndexes(indices: IntVector, xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, y1Values: SCRTDoubleVector, count: number, isCategoryAxis: boolean, xValuesOut: SCRTDoubleVector, yValuesOut: SCRTDoubleVector, y1ValuesOut: SCRTDoubleVector): void;
+    copyValuesByIndexes(indices: IntVector, xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, y1Values: SCRTDoubleVector, count: number, isCategoryAxis: boolean, xValuesOut: SCRTDoubleVector, yValuesOut: SCRTDoubleVector, y1ValuesOut: SCRTDoubleVector, y1Offset?: number): void;
     /** @inheritDoc */
     delete(): void;
     private debugParameters;

package/Charting/Numerics/Resamplers/ExtremeResamplerHelper.js

@@ -90,13 +90,15 @@ var ExtremeResamplerHelper = /** @class */ (function () {
     ExtremeResamplerHelper.prototype.mergeIndexes = function (indices, size1, size2, mergedIndicesOut) {
         return this.nativeResampler.MergeIndices(indices, size1, size2, mergedIndicesOut);
     };
-    ExtremeResamplerHelper.prototype.copyValuesByIndexes = function (indices, xValues, yValues, y1Values, count, isCategoryAxis, xValuesOut, yValuesOut, y1ValuesOut) {
+    ExtremeResamplerHelper.prototype.copyValuesByIndexes = function (indices, xValues, yValues, y1Values, count, isCategoryAxis, xValuesOut, yValuesOut, y1ValuesOut, y1Offset) {
+        if (y1Offset === void 0) { y1Offset = 0; }
         var mp = this.nativeMergeIndexParams;
         mp.SetIndices(indices);
         this.xInput.SetInput(xValues);
         mp.SetXInput(this.xInput);
         mp.SetYInput(yValues);
         mp.SetY1Input(y1Values);
+        mp.SetY1Offset(y1Offset);
         mp.count = count;
         mp.isCategoryData = isCategoryAxis;
         mp.SetXOut(xValuesOut);

package/Charting/Services/SciChartRenderer.js

@@ -258,6 +258,9 @@ var SciChartRenderer = /** @class */ (function () {
         // TODO: Calculate XRange before resample but YRange after resample for faster autorange on large datasets
         for (var i = 0; i < this.sciChartSurface.renderableSeries.size(); i++) {
             var series = this.sciChartSurface.renderableSeries.get(i);
+            // don't try and draw series with no data
+            if (!series.isStacked && !series.dataSeries)
+                continue;
             // TODO: Do resampling, store result for use in drawing
             var xAxis = xAxesById.item(series.xAxisId);
             var seriesRenderPassInfo = SciChartRenderer.resampleSeries(xAxis, series, seriesViewRect);

package/Charting/Visuals/Axis/CategoryAxisBase.d.ts

@@ -6,11 +6,30 @@ import { AxisBase2D, IAxisBase2dOptions } from "./AxisBase2D";
 import { ILabel2DOptions } from "./LabelProvider/LabelProviderBase2D";
 export declare type TCategoryCoordCalc = CategoryCoordinateCalculator | FlippedCategoryCoordinateCalculator;
 export interface ICategoryAxisBaseOptions extends IAxisBase2dOptions, ILabel2DOptions {
+    /**
+     * The default x values to use if no series or data is added to the chart.
+     * The tick values shown will depend on the visible range, which for category axis is by index, not by value.
+     * eg if you want default values [10, 20, 30, 40] you would need to set visibleRange: new NumberRange(0,3)
+     * By default it will start at 0 and increment by 1, up to the size of the visible range.
+     * To change the start and step set defaultXStart and defaultXStep
+     */
+    defaultXValues?: number[];
+    /**
+     * The starting value for default x values.  See defaultXValues
+     */
+    defaultXStart?: number;
+    /**
+     * The step size for default x values.  See defaultXValues
+     */
+    defaultXStep?: number;
 }
 /**
  * @summary A 2D Chart Category Axis Base type
  */
 export declare abstract class CategoryAxisBase extends AxisBase2D {
+    private defaultXValuesProperty;
+    private defaultXStartProperty;
+    private defaultXStepProperty;
     /**
      * Creates an instance of a {@link CategoryAxisBase}
      * @param webAssemblyContext The {@link TSciChart | SciChart 2D WebAssembly Context} containing native methods and
@@ -22,6 +41,38 @@ export declare abstract class CategoryAxisBase extends AxisBase2D {
      * @inheritDoc
      */
     get isCategoryAxis(): boolean;
+    /**
+     * The default x values to use if no series or data is added to the chart.
+     * The tick values shown will depend on the visible range, which for category axis is by index, not by value.
+     * eg if you want default values [10, 20, 30, 40] you would need to set visibleRange: new NumberRange(0,3)
+     * By default it will start at 0 and increment by 1, up to the size of the visible range.
+     * To change the start and step set defaultXStart and defaultXStep
+     */
+    get defaultXValues(): number[];
+    /**
+     * The default x values to use if no series or data is added to the chart.
+     * The tick values shown will depend on the visible range, which for category axis is by index, not by value.
+     * eg if you want default values [10, 20, 30, 40] you would need to set visibleRange: new NumberRange(0,3)
+     * By default it will start at 0 and increment by 1, up to the size of the visible range.
+     * To change the start and step set defaultXStart and defaultXStep
+     */
+    set defaultXValues(values: number[]);
+    /**
+     * The starting value for default x values.  See defaultXValues
+     */
+    get defaultXStart(): number;
+    /**
+     * The starting value for default x values.  See defaultXValues
+     */
+    set defaultXStart(value: number);
+    /**
+     * The step size for default x values.  See defaultXValues
+     */
+    get defaultXStep(): number;
+    /**
+     * The step size for default x values.  See defaultXValues
+     */
+    set defaultXStep(value: number);
     /**
      * @inheritDoc
      */

package/Charting/Visuals/Axis/CategoryAxisBase.js

@@ -19,6 +19,7 @@ exports.CategoryAxisBase = void 0;
 var Deleter_1 = require("../../../Core/Deleter");
 var NumberRange_1 = require("../../../Core/NumberRange");
 var SeriesType_1 = require("../../../types/SeriesType");
+var appendDoubleVectorFromJsArray_1 = require("../../../utils/ccall/appendDoubleVectorFromJsArray");
 var CategoryCoordinateCalculator_1 = require("../../Numerics/CoordinateCalculators/CategoryCoordinateCalculator");
 var FlippedCategoryCoordinateCalculator_1 = require("../../Numerics/CoordinateCalculators/FlippedCategoryCoordinateCalculator");
 var NumericTickProvider_1 = require("../../Numerics/TickProviders/NumericTickProvider");
@@ -36,7 +37,14 @@ var CategoryAxisBase = /** @class */ (function (_super) {
      * @param options Optional parameters of type {@link ICategoryAxisBaseOptions} used to configure the axis at instantiation time
      */
     function CategoryAxisBase(webAssemblyContext, options) {
+        var _a, _b, _c;
         var _this = _super.call(this, webAssemblyContext, options) || this;
+        _this.defaultXValuesProperty = [];
+        _this.defaultXStartProperty = 0;
+        _this.defaultXStepProperty = 1;
+        _this.defaultXValuesProperty = (_a = options === null || options === void 0 ? void 0 : options.defaultXValues) !== null && _a !== void 0 ? _a : _this.defaultXValuesProperty;
+        _this.defaultXStartProperty = (_b = options === null || options === void 0 ? void 0 : options.defaultXStart) !== null && _b !== void 0 ? _b : _this.defaultXStartProperty;
+        _this.defaultXStepProperty = (_c = options === null || options === void 0 ? void 0 : options.defaultXStep) !== null && _c !== void 0 ? _c : _this.defaultXStepProperty;
         _this.tickProvider = new NumericTickProvider_1.NumericTickProvider(_this.webAssemblyContext2D);
         _this.deltaCalculator = new CategoryDeltaCalculator_1.CategoryDeltaCalculator(_this.webAssemblyContext2D);
         return _this;
@@ -51,6 +59,68 @@ var CategoryAxisBase = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(CategoryAxisBase.prototype, "defaultXValues", {
+        /**
+         * The default x values to use if no series or data is added to the chart.
+         * The tick values shown will depend on the visible range, which for category axis is by index, not by value.
+         * eg if you want default values [10, 20, 30, 40] you would need to set visibleRange: new NumberRange(0,3)
+         * By default it will start at 0 and increment by 1, up to the size of the visible range.
+         * To change the start and step set defaultXStart and defaultXStep
+         */
+        get: function () {
+            return this.defaultXValuesProperty;
+        },
+        /**
+         * The default x values to use if no series or data is added to the chart.
+         * The tick values shown will depend on the visible range, which for category axis is by index, not by value.
+         * eg if you want default values [10, 20, 30, 40] you would need to set visibleRange: new NumberRange(0,3)
+         * By default it will start at 0 and increment by 1, up to the size of the visible range.
+         * To change the start and step set defaultXStart and defaultXStep
+         */
+        set: function (values) {
+            this.defaultXValuesProperty = values;
+            if (this.invalidateParentCallback)
+                this.invalidateParentCallback();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(CategoryAxisBase.prototype, "defaultXStart", {
+        /**
+         * The starting value for default x values.  See defaultXValues
+         */
+        get: function () {
+            return this.defaultXStartProperty;
+        },
+        /**
+         * The starting value for default x values.  See defaultXValues
+         */
+        set: function (value) {
+            this.defaultXStartProperty = value;
+            if (this.invalidateParentCallback)
+                this.invalidateParentCallback();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(CategoryAxisBase.prototype, "defaultXStep", {
+        /**
+         * The step size for default x values.  See defaultXValues
+         */
+        get: function () {
+            return this.defaultXStepProperty;
+        },
+        /**
+         * The step size for default x values.  See defaultXValues
+         */
+        set: function (value) {
+            this.defaultXStepProperty = value;
+            if (this.invalidateParentCallback)
+                this.invalidateParentCallback();
+        },
+        enumerable: false,
+        configurable: true
+    });
     /**
      * @inheritDoc
      */
@@ -60,16 +130,6 @@ var CategoryAxisBase = /** @class */ (function (_super) {
         var coordCalc = this.getCurrentCoordinateCalculatorInternal();
         var scs = this.parentSurface;
         var renderableSeries = scs.renderableSeries.asArray().find(function (rs) { return rs.xAxisId === _this.id; });
-        if (!renderableSeries) {
-            throw new Error("category x axis with id=".concat(this.id, " should have renderable series"));
-        }
-        if (!renderableSeries.hasDataSeries()) {
-            throw new Error("category x axis with id=".concat(this.id, " should have data series"));
-        }
-        var dataSeriesLength = renderableSeries.getDataSeriesValuesCount();
-        if (dataSeriesLength === 0) {
-            throw new Error("category x axis with id=".concat(this.id, " should have data series count > 0"));
-        }
         this.setBaseXValues(coordCalc, renderableSeries);
         this.coordCalcCache = coordCalc;
     };
@@ -84,16 +144,6 @@ var CategoryAxisBase = /** @class */ (function (_super) {
         var shouldFlip = !(this.isXAxis !== this.flippedCoordinates);
         var scs = this.parentSurface;
         var renderableSeries = scs.renderableSeries.asArray().find(function (rs) { return rs.xAxisId === _this.id; });
-        if (!renderableSeries) {
-            throw new Error("category x axis with id=".concat(this.id, " should have renderable series"));
-        }
-        if (!renderableSeries.hasDataSeries()) {
-            throw new Error("category x axis with id=".concat(this.id, " should have data series"));
-        }
-        var dataSeriesLength = renderableSeries.getDataSeriesValuesCount();
-        if (dataSeriesLength === 0) {
-            throw new Error("category x axis with id=".concat(this.id, " should have data series count > 0"));
-        }
         var coordCalc = shouldFlip
             ? new FlippedCategoryCoordinateCalculator_1.FlippedCategoryCoordinateCalculator(this.webAssemblyContext2D, size, 0, 0, min, max, this.offset)
             : new CategoryCoordinateCalculator_1.CategoryCoordinateCalculator(this.webAssemblyContext2D, size, 0, 0, min, max, this.offset);
@@ -128,6 +178,21 @@ var CategoryAxisBase = /** @class */ (function (_super) {
         return Math.min(Math.max(1, this.maxAutoTicks), coordCalc.baseXValues.size());
     };
     CategoryAxisBase.prototype.setBaseXValues = function (coordCalc, renderableSeries) {
+        var _this = this;
+        if (!(renderableSeries === null || renderableSeries === void 0 ? void 0 : renderableSeries.dataSeries)) {
+            if (!coordCalc.baseXValues) {
+                var defaultBaseXValues = new this.webAssemblyContext2D.SCRTDoubleVector();
+                if (this.defaultXValues && this.defaultXValues.length > 0) {
+                    (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext2D, defaultBaseXValues, this.defaultXValues);
+                }
+                else {
+                    var xValues = Array.from(Array(this.visibleRange.diff), function (_, i) { return _this.defaultXStart + i * _this.defaultXStep; });
+                    (0, appendDoubleVectorFromJsArray_1.appendDoubleVectorFromJsArray)(this.webAssemblyContext2D, defaultBaseXValues, xValues);
+                }
+                coordCalc.baseXValues = defaultBaseXValues;
+            }
+            return;
+        }
         if (renderableSeries.type === SeriesType_1.ESeriesType.UniformHeatmapSeries) {
             throw Error("Category Axis is not supported for UniformHeatmapRenderableSeries");
         }

package/Charting/Visuals/Axis/LabelProvider/SmartDateLabelProvider.js

@@ -117,7 +117,8 @@ var SmartDateLabelProvider = /** @class */ (function (_super) {
     };
     SmartDateLabelProvider.prototype.formatTradeChartLabel = function (tradeChartLabelFormat, value, prevValue, prevPrevValue) {
         if (tradeChartLabelFormat === ETradeChartLabelFormat.Minutes) {
-            var newDate = !prevValue || (0, date_1.formatUnixDateToHumanStringMMMDD)(value) !== (0, date_1.formatUnixDateToHumanStringMMMDD)(prevValue);
+            var newDate = prevValue === undefined ||
+                (0, date_1.formatUnixDateToHumanStringMMMDD)(value) !== (0, date_1.formatUnixDateToHumanStringMMMDD)(prevValue);
             if (newDate) {
                 return (0, date_1.formatUnixDateToHumanStringMMMDD)(value);
             }
@@ -126,7 +127,8 @@ var SmartDateLabelProvider = /** @class */ (function (_super) {
             }
         }
         else if (tradeChartLabelFormat === ETradeChartLabelFormat.Days) {
-            var newMonth = !prevValue || (0, date_1.formatUnixDateToHumanStringMMM)(value) !== (0, date_1.formatUnixDateToHumanStringMMM)(prevValue);
+            var newMonth = prevValue === undefined ||
+                (0, date_1.formatUnixDateToHumanStringMMM)(value) !== (0, date_1.formatUnixDateToHumanStringMMM)(prevValue);
             if (newMonth) {
                 return (0, date_1.formatUnixDateToHumanStringMMM)(value);
             }
@@ -135,12 +137,13 @@ var SmartDateLabelProvider = /** @class */ (function (_super) {
             }
         }
         else if (tradeChartLabelFormat === ETradeChartLabelFormat.Months) {
-            var newYear = !prevValue || (0, date_1.formatUnixDateToHumanStringYYYY)(value) !== (0, date_1.formatUnixDateToHumanStringYYYY)(prevValue);
+            var newYear = prevValue === undefined ||
+                (0, date_1.formatUnixDateToHumanStringYYYY)(value) !== (0, date_1.formatUnixDateToHumanStringYYYY)(prevValue);
             if (newYear) {
                 return (0, date_1.formatUnixDateToHumanStringYYYY)(value);
             }
             // If previous label was year, display month label
-            var prevPrevNewYear = !prevPrevValue ||
+            var prevPrevNewYear = prevPrevValue === undefined ||
                 (0, date_1.formatUnixDateToHumanStringYYYY)(prevValue) !== (0, date_1.formatUnixDateToHumanStringYYYY)(prevPrevValue);
             var newMonth = prevPrevNewYear || (0, date_1.formatUnixDateToHumanStringMMM)(value) !== (0, date_1.formatUnixDateToHumanStringMMM)(prevValue);
             if (newMonth) {

package/Charting/Visuals/RenderableSeries/BaseOhlcRenderableSeries.js

@@ -171,9 +171,6 @@ var BaseOhlcRenderableSeries = /** @class */ (function (_super) {
             else {
                 this.pointSeries.xRange = rp.xVisibleRange;
             }
-            var rpHigh = rp.clone({
-                resamplingMode: rp.resamplingMode === ResamplingMode_1.EResamplingMode.None ? ResamplingMode_1.EResamplingMode.None : ResamplingMode_1.EResamplingMode.Max
-            });
             var ps = this.pointSeries;
             var ds = this.dataSeries;
             var xValues = ds.getNativeXValues();
@@ -181,22 +178,79 @@ var BaseOhlcRenderableSeries = /** @class */ (function (_super) {
             var highValues = ds.getNativeHighValues();
             var lowValues = ds.getNativeLowValues();
             var closeValues = ds.getNativeCloseValues();
-            this.resamplerHelper.resampleIntoPointSeries(this.webAssemblyContext, rpHigh, xValues, highValues, this.xyyTempPointSeries.intIndexes, this.xyyTempPointSeries.xValues, this.xyyTempPointSeries.yValues);
-            var xySize = this.xyyTempPointSeries.intIndexes.size();
+            var originalIndexes = ds.getNativeIndexes();
+            // 1) calc ps.highValues
+            var rpHigh = rp.clone({
+                resamplingMode: rp.resamplingMode === ResamplingMode_1.EResamplingMode.None ? ResamplingMode_1.EResamplingMode.None : ResamplingMode_1.EResamplingMode.Max
+            });
+            this.resamplerHelper.resampleIntoPointSeries(this.webAssemblyContext, rpHigh, xValues, highValues, this.xyyTempPointSeries.intIndexes, // don't care
+            this.xyyTempPointSeries.xValues, // don't care
+            ps.highValues);
+            // console.log("high count ", ps.highValues.size());
+            this.xyyTempPointSeries.clearIntIndexes();
+            // 2) calc ps.lowValues
             var rpLow = rp.clone({
                 resamplingMode: rp.resamplingMode === ResamplingMode_1.EResamplingMode.None ? ResamplingMode_1.EResamplingMode.None : ResamplingMode_1.EResamplingMode.Min
             });
-            this.resamplerHelper.resampleIntoPointSeries(this.webAssemblyContext, rpLow, xValues, lowValues, this.xyyTempPointSeries.intIndexes, this.xyyTempPointSeries.xValues, this.xyyTempPointSeries.y1Values);
-            // Because intIndexes vector is not cleared indexes for rpLow are appended at the end of rpHigh indexes
-            var xy1Size = this.xyyTempPointSeries.intIndexes.size() - xySize;
-            // We merge indexes excluding duplicates for rpLow and rpHigh into one vector
-            var mergedSize = this.resamplerHelper.mergeIndexes(this.xyyTempPointSeries.intIndexes, xySize, xy1Size, ps.intIndexes);
-            // Clear the intIndexes as long as we do not need them any more
-            this.xyyTempPointSeries.intIndexes.clear();
-            // Get values by indexes for High and Low values
-            this.resamplerHelper.copyValuesByIndexes(ps.intIndexes, xValues, highValues, lowValues, mergedSize, rp.isCategoryAxis, ps.xValues, ps.highValues, ps.lowValues);
-            // Get values by indexes for Open and Close values
-            this.resamplerHelper.copyValuesByIndexes(ps.intIndexes, xValues, openValues, closeValues, mergedSize, rp.isCategoryAxis, ps.xValues, ps.openValues, ps.closeValues);
+            this.resamplerHelper.resampleIntoPointSeries(this.webAssemblyContext, rpLow, xValues, lowValues, this.xyyTempPointSeries.intIndexes, // don't care
+            this.xyyTempPointSeries.xValues, ps.lowValues);
+            // console.log("low count ", ps.lowValues.size());
+            // We don't want the indexes for high/low
+            this.xyyTempPointSeries.clearIntIndexes();
+            this.xyyTempPointSeries.y1Values.clear();
+            // 3) Get batch indexes
+            // Resample indexes to get start and end of batch
+            var rpOpenClose = rp.clone({
+                resamplingMode: rp.resamplingMode === ResamplingMode_1.EResamplingMode.None ? ResamplingMode_1.EResamplingMode.None : ResamplingMode_1.EResamplingMode.Min
+            });
+            this.resamplerHelper.resampleIntoPointSeries(this.webAssemblyContext, rpOpenClose, xValues, originalIndexes, ps.intIndexes, this.xyyTempPointSeries.xValues, // don't care
+            this.xyyTempPointSeries.y1Values // don't care
+            );
+            var openCloseSize = ps.intIndexes.size();
+            this.xyyTempPointSeries.y1Values.clear();
+            // 4) calc ps.openValues, ps.closeValues
+            // console.log("open/close count ", openCloseSize);
+            // indexes 0, 1, 2, 3, 4, 5, 6, 7
+            // opens   3, 4, 7, 8, 3, 5, 9, 6
+            // closes  8, 3, 5, 9, 6, 3
+            // batch 0, 3, 6
+            // batch 0 - open 3 (index 0), close 8 (index 2)
+            var lastIndexOfFirstBatch = ps.intIndexes.get(3) - ps.intIndexes.get(2) - 1;
+            // console.log(
+            //     "indexes ",
+            //     ps.intIndexes.get(0),
+            //     ps.intIndexes.get(1),
+            //     ps.intIndexes.get(2),
+            //     ps.intIndexes.get(3),
+            //     ps.intIndexes.get(4),
+            //     ps.intIndexes.get(5),
+            //     ps.intIndexes.get(6)
+            // );
+            // console.log(
+            //     "x values ",
+            //     xValues.get(0),
+            //     xValues.get(1),
+            //     xValues.get(2),
+            //     xValues.get(3),
+            //     xValues.get(4),
+            //     xValues.get(5),
+            //     xValues.get(6)
+            // );
+            // console.log("Max index", rp.indexesRange.max);
+            // const batchWidth = rp.xVisibleRange.diff / rp.viewportRect.width;
+            // console.log(
+            //     "Batch width ",
+            //     batchWidth,
+            //     Math.floor(Math.log2(batchWidth)),
+            //     Math.pow(2, Math.floor(Math.log2(batchWidth)))
+            // );
+            // console.log("X Spacing ", rp.xVisibleRange.diff / rp.indexesRange.max);
+            // console.log("original points / resampled points ", xValues.size() / openCloseSize);
+            // console.log("lastIndexOfFirstBatch ", lastIndexOfFirstBatch);
+            // Get values by indexes for Open values
+            this.resamplerHelper.copyValuesByIndexes(ps.intIndexes, xValues, openValues, closeValues, openCloseSize, rp.isCategoryAxis, ps.xValues, ps.openValues, ps.closeValues, lastIndexOfFirstBatch);
+            // Last close value is handled in c++;
+            // 5) update indexes for category axis
             if (rp.isCategoryAxis)
                 ps.updateIndexes();
             ps.clearIntIndexes();