scichart 2.0.2204 → 2.1.2267

package/types/TSciChart3D.d.ts

@@ -22,17 +22,20 @@ export declare type TSciChart3D = {
     SCRTSetGlobalCopyToDestinationInterface: (param0: SCRTCopyToDestinationInterface) => void;
     SCRTSetClearAlphaParams: (enabled: boolean, alpha: number) => void;
     FloatVector: new () => FloatVector;
+    SCRTDoubleVector: new () => SCRTDoubleVector;
+    DoubleVector: new () => DoubleVector;
+    IntVector: new () => IntVector;
+    UIntVector: new () => UIntVector;
     eTSRTextureFormat: {
         TSR_TEXTUREFORMAT_A8B8G8R8: eTSRTextureFormat;
         TSR_TEXTUREFORMAT_R32F: eTSRTextureFormat;
     };
-    IntVector: new () => IntVector;
-    UIntVector: new () => UIntVector;
     TSRVector4: (new () => TSRVector4) & (new (x: number, y: number, z: number, w: number) => TSRVector4);
     StringVector: new () => StringVector;
-    DoubleVector: new () => DoubleVector;
     LinearCoordinateCalculatorDouble: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number) => LinearCoordinateCalculatorDouble;
     FlippedLinearCoordinateCalculatorDouble: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number) => FlippedLinearCoordinateCalculatorDouble;
+    LinearCoordinateCalculatorSingle: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number) => LinearCoordinateCalculatorSingle;
+    FlippedLinearCoordinateCalculatorSingle: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number) => FlippedLinearCoordinateCalculatorSingle;
     CategoryCoordinateCalculatorDouble: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number, IndexMin: number, IndexMax: number) => CategoryCoordinateCalculatorDouble;
     FlippedCategoryCoordinateCalculatorDouble: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number, IndexMin: number, IndexMax: number) => FlippedCategoryCoordinateCalculatorDouble;
     LogarithmicCoordinateCalculator: new (ViewportDimension: number, VisibleMin: number, VisibleMax: number, ViewportOffset: number, CoordOffset: number, LogBase: number) => LogarithmicCoordinateCalculator;
@@ -48,7 +51,7 @@ export declare type TSciChart3D = {
         IsDivisibleBy: (value: number, divisor: number) => boolean;
         Constrain: (value: number, lowerBound: number, upperBound: number) => number;
         RoundToDigits: (value: number, decimals: number) => number;
-        MinMax: (inputValues: DoubleVector) => DoubleRange;
+        MinMax: (inputValues: SCRTDoubleVector) => DoubleRange;
         LinearInterpolateI: (from: number, to: number, ratio: number) => number;
     };
     SCRTLicenseType: {
@@ -274,6 +277,7 @@ export declare type TSciChart3D = {
     };
 };
 export declare class FloatVector {
+    dataPtr(offset: number): number;
     push_back(element: number): void;
     pop_back(): void;
     size(): number;
@@ -291,15 +295,40 @@ export declare class FloatVector {
 export declare class TSRTexture {
     delete(): void;
 }
-export declare class TSRMesh {
+export declare class SCRTDoubleVector {
+    push_back(_dNewValue: number): void;
+    resize(_iNewSize: number, _dInitialValue: number): void;
+    resizeFast(_iNewSize: number): void;
+    reserve(_iCount: number): void;
+    clear(): void;
+    size(): number;
+    capacity(): number;
+    get(_iIndex: number): number;
+    set(_iIndex: number, _dValue: number): void;
+    insertAt(_iIndex: number, _dValue: number): void;
+    removeAt(_iIndex: number): void;
+    removeRange(_iIndex: number, _iCount: number): void;
+    dataPtr(_iOffset: number): number;
     delete(): void;
 }
-export declare class TSRIndexedMesh extends TSRMesh {
+export declare class DoubleVector {
+    dataPtr(offset: number): number;
+    push_back(element: number): void;
+    pop_back(): void;
+    size(): number;
+    resize(size: number, initialValue: number): void;
+    reserve(size: number): void;
+    clear(): void;
+    fill(element: number): void;
+    insertAt(index: number, element: number): void;
+    removeAt(index: number): void;
+    removeRange(index: number, count: number): void;
     delete(): void;
-}
-export declare class eTSRTextureFormat {
+    set(index: number, element: number): void;
+    get(index: number): number;
 }
 export declare class IntVector {
+    dataPtr(offset: number): number;
     push_back(element: number): void;
     pop_back(): void;
     size(): number;
@@ -315,6 +344,7 @@ export declare class IntVector {
     get(index: number): number;
 }
 export declare class UIntVector {
+    dataPtr(offset: number): number;
     push_back(element: number): void;
     pop_back(): void;
     size(): number;
@@ -329,6 +359,14 @@ export declare class UIntVector {
     set(index: number, element: number): void;
     get(index: number): number;
 }
+export declare class TSRMesh {
+    delete(): void;
+}
+export declare class TSRIndexedMesh extends TSRMesh {
+    delete(): void;
+}
+export declare class eTSRTextureFormat {
+}
 export declare class TSRVector4 {
     x: number;
     y: number;
@@ -337,6 +375,7 @@ export declare class TSRVector4 {
     delete(): void;
 }
 export declare class StringVector {
+    dataPtr(offset: number): number;
     push_back(element: string): void;
     pop_back(): void;
     size(): number;
@@ -357,23 +396,9 @@ export declare class StringVector {
 export declare class CoordinateCalculator {
     GetCoordinate(dataValue: number): number;
     GetDataValue(coordinate: number): number;
+    CanSupportMatrices(): boolean;
     delete(): void;
 }
-export declare class DoubleVector {
-    push_back(element: number): void;
-    pop_back(): void;
-    size(): number;
-    resize(size: number, initialValue: number): void;
-    reserve(size: number): void;
-    clear(): void;
-    fill(element: number): void;
-    insertAt(index: number, element: number): void;
-    removeAt(index: number): void;
-    removeRange(index: number, count: number): void;
-    delete(): void;
-    set(index: number, element: number): void;
-    get(index: number): number;
-}
 /**
  *WebAssembly / Native Linear Coordinate Calculator: Converts pixel coordinates to data-values and vice versa. Double precision version.
  */
@@ -386,20 +411,32 @@ export declare class LinearCoordinateCalculatorDouble extends CoordinateCalculat
 export declare class FlippedLinearCoordinateCalculatorDouble extends CoordinateCalculator {
     delete(): void;
 }
+/**
+ *WebAssembly / Native Linear Coordinate Calculator: Converts pixel coordinates to data-values and vice versa. Float32 version.
+ */
+export declare class LinearCoordinateCalculatorSingle extends CoordinateCalculator {
+    delete(): void;
+}
+/**
+ *WebAssembly / Native Flipped Linear Coordinate Calculator: Converts pixel coordinates to data-values and vice versa. Float32 version. Inverse of {@link LinearCoordinateCalculatorSingle}
+ */
+export declare class FlippedLinearCoordinateCalculatorSingle extends CoordinateCalculator {
+    delete(): void;
+}
 /**
  *WebAssembly / Native Catetory Coordinate Calculator: Converts pixel coordinates to data-values and vice versa. Uses index not data-value for conversion
  */
 export declare class CategoryCoordinateCalculatorDouble extends CoordinateCalculator {
-    TransformDataToIndex(dataValue: number, baseXValues: DoubleVector): number;
-    TransformIndexToData(index: number, baseXValues: DoubleVector): number;
+    TransformDataToIndex(dataValue: number, baseXValues: SCRTDoubleVector): number;
+    TransformIndexToData(index: number, baseXValues: SCRTDoubleVector): number;
     delete(): void;
 }
 /**
  *WebAssembly / Native Catetory Coordinate Calculator: Converts pixel coordinates to data-values and vice versa. Uses index not data-value for conversion. Inverse of CategoryCoordinateCalculatorDouble
  */
 export declare class FlippedCategoryCoordinateCalculatorDouble extends CoordinateCalculator {
-    TransformDataToIndex(dataValue: number, baseXValues: DoubleVector): number;
-    TransformIndexToData(index: number, baseXValues: DoubleVector): number;
+    TransformDataToIndex(dataValue: number, baseXValues: SCRTDoubleVector): number;
+    TransformIndexToData(index: number, baseXValues: SCRTDoubleVector): number;
     delete(): void;
 }
 /**
@@ -437,6 +474,7 @@ export declare class SCRTCredentials {
     delete(): void;
 }
 export declare class WStringVector {
+    dataPtr(offset: number): number;
     push_back(element: string): void;
     pop_back(): void;
     size(): number;
@@ -645,7 +683,7 @@ export declare class SCRTPoint3DSceneEntity extends SCRTSceneEntity {
     SetPointMarkerMesh(mesh: TSRIndexedMesh): void;
     SetPointSize(pointSize: number): void;
     SetPointColor(pointColor: number): void;
-    UpdateMeshesVec(xValues: DoubleVector, yValues: DoubleVector, zValues: DoubleVector, colors: IntVector, scaleFactors: FloatVector, params: SCRTPoint3DSceneEntityParams): void;
+    UpdateMeshesVec(xValues: SCRTDoubleVector, yValues: SCRTDoubleVector, zValues: SCRTDoubleVector, colors: IntVector, scaleFactors: FloatVector, params: SCRTPoint3DSceneEntityParams): void;
     delete(): void;
 }
 export declare class SCRTPoint3DSceneEntityWrapper {

package/types/TStackedAxisLength.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Length defined as an absolute number or percentage
+ */
+export declare type TStackedAxisLength = number | string;

package/types/TStackedAxisLength.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Requires TS ^4.1
+// export type TStackedAxisLength = number | `${number}%`;

package/utils/array.d.ts

@@ -1,4 +1,11 @@
+import { NumberArray } from "../types/NumberArray";
 export declare function getUniqueValues(array: string[]): string[];
 export declare function countUnique(iterable: string[]): number;
 export declare const areArraysEqual: (leftArray: number[], rightArray: number[]) => boolean;
 export declare function arrayRemove<T>(array: T[], item: T): T[];
+/**
+ * returns true if the array is sorted
+ * @param arr The array
+ * @param ascending If True checks for sorted ascending, if False for descending
+ */
+export declare function isArraySorted(arr: NumberArray, ascending?: boolean): boolean;

package/utils/array.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.arrayRemove = exports.areArraysEqual = exports.countUnique = exports.getUniqueValues = void 0;
+exports.isArraySorted = exports.arrayRemove = exports.areArraysEqual = exports.countUnique = exports.getUniqueValues = void 0;
 function getUniqueValues(array) {
     var onlyUnique = function (value, index, self) {
         if (value === undefined || value === null)
@@ -41,3 +41,21 @@ function arrayRemove(array, item) {
     return array;
 }
 exports.arrayRemove = arrayRemove;
+/**
+ * returns true if the array is sorted
+ * @param arr The array
+ * @param ascending If True checks for sorted ascending, if False for descending
+ */
+function isArraySorted(arr, ascending) {
+    if (ascending === void 0) { ascending = true; }
+    var sorted = true;
+    var checkUnsortedFn = ascending ? function (i) { return arr[i] > arr[i + 1]; } : function (i) { return arr[i] < arr[i + 1]; };
+    for (var i = 0; i < arr.length - 1; i++) {
+        if (checkUnsortedFn(i)) {
+            sorted = false;
+            break;
+        }
+    }
+    return sorted;
+}
+exports.isArraySorted = isArraySorted;

package/utils/calcAverage.d.ts

@@ -1,9 +1,9 @@
-import { DoubleVector } from "../types/TSciChart";
+import { SCRTDoubleVector } from "../types/TSciChart";
 /**
  * @description Calculates average for DoubleVector
  * @param doubleVector
  * @param averageNum - number of values to respect for the average
  * @param index - index of the latest value to include, by default equals to length-1 of DoubleVector
  */
-export declare const calcAverageForDoubleVector: (doubleVector: DoubleVector, averageNum: number, index?: number) => number;
+export declare const calcAverageForDoubleVector: (doubleVector: SCRTDoubleVector, averageNum: number, index?: number) => number;
 export declare const calcAverageForArray: (ar: number[], averageNum: number, index?: number) => number;

package/utils/ccall/appendDoubleVectorFromJsArray.d.ts

@@ -0,0 +1,19 @@
+import { NumberArray } from "../../types/NumberArray";
+import { SCRTDoubleVector, TSciChart } from "../../types/TSciChart";
+export declare const SIZEOF_NUMBER = 8;
+/**
+ * Inserts the values from the source Js array into the destination wasm array (and resizes) at index destIndex
+ * @param wasmContext
+ * @param source
+ * @param dest
+ * @param destIndex
+ */
+export declare function insertDoubleVectorFromJsArray(wasmContext: TSciChart, source: NumberArray, dest: SCRTDoubleVector, destIndex: number): void;
+/**
+ * Resizes the destinationVector by jsArray.length and copies the values into it
+ * @param wasmContext
+ * @param destinationVector
+ * @param jsArray
+ * @param experimentalMethod
+ */
+export declare function appendDoubleVectorFromJsArray(wasmContext: TSciChart, destinationVector: SCRTDoubleVector, jsArray: NumberArray, experimentalMethod?: boolean): void;

package/utils/ccall/appendDoubleVectorFromJsArray.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appendDoubleVectorFromJsArray = exports.insertDoubleVectorFromJsArray = exports.SIZEOF_NUMBER = void 0;
+var Guard_1 = require("../../Core/Guard");
+exports.SIZEOF_NUMBER = 8;
+/**
+ * Inserts the values from the source Js array into the destination wasm array (and resizes) at index destIndex
+ * @param wasmContext
+ * @param source
+ * @param dest
+ * @param destIndex
+ */
+function insertDoubleVectorFromJsArray(wasmContext, source, dest, destIndex) {
+    // Sanity checks
+    Guard_1.Guard.notNull(wasmContext, "wasmContext");
+    Guard_1.Guard.notNull(source, "source");
+    Guard_1.Guard.notNull(dest, "dest");
+    Guard_1.Guard.isTrue(destIndex >= 0, "destIndex must be greater than or equal to zero");
+    Guard_1.Guard.isTrue(destIndex <= dest.size(), "destIndex must be less than or equal to dest.size()");
+    var count = source.length;
+    if (count === 0)
+        return;
+    var beforeSize = dest.size();
+    // Resize the dest vector to fit memory
+    dest.resizeFast(beforeSize + count);
+    // Shift memory up for the insert
+    if (destIndex < beforeSize) {
+        wasmContext.SCRTMemMove(dest.dataPtr(destIndex + count), // Dest
+        dest.dataPtr(destIndex), // Src
+        beforeSize * exports.SIZEOF_NUMBER); // count in bytes
+    }
+    // Overwrite dest memory with Js array
+    // @ts-ignore
+    wasmContext.HEAPF64.set(source, dest.dataPtr(destIndex) / exports.SIZEOF_NUMBER);
+}
+exports.insertDoubleVectorFromJsArray = insertDoubleVectorFromJsArray;
+/**
+ * Resizes the destinationVector by jsArray.length and copies the values into it
+ * @param wasmContext
+ * @param destinationVector
+ * @param jsArray
+ * @param experimentalMethod
+ */
+function appendDoubleVectorFromJsArray(wasmContext, destinationVector, jsArray, experimentalMethod) {
+    if (experimentalMethod === void 0) { experimentalMethod = true; }
+    var buffer;
+    try {
+        if (experimentalMethod) {
+            var vectorSize = destinationVector.size();
+            var arraySize = jsArray.length;
+            var startPosition = vectorSize;
+            var endPosition = startPosition + arraySize;
+            // Resize without initializing values
+            destinationVector.resizeFast(endPosition);
+            // Get pointer to destination
+            var bufferPointer = destinationVector.dataPtr(startPosition);
+            // HEAPF64.set copies js array into buffer pointer
+            // @ts-ignore
+            wasmContext.HEAPF64.set(jsArray, bufferPointer / exports.SIZEOF_NUMBER);
+        }
+        else {
+            var vectorSize = destinationVector.size();
+            var arraySize = jsArray.length;
+            var startPosition = vectorSize;
+            var endPosition = startPosition + arraySize;
+            /// because plain c functions were receiving the object pointer as null, this is the way around that...
+            wasmContext.SCRTSetActiveDoubleVector(destinationVector, vectorSize);
+            // Allocate some space in the heap for the data (making sure to use the appropriate memory size of the elements)
+            // @ts-ignore
+            buffer = wasmContext._malloc(arraySize * 8);
+            // Assign the data to the heap - Keep in mind bytes per element
+            // @ts-ignore
+            wasmContext.HEAPF64.set(jsArray, buffer / exports.SIZEOF_NUMBER);
+            // Finally, call the function
+            // Here we use start position 0 and the end position array.length
+            // @ts-ignore
+            wasmContext.ccall("SCRTFillActiveDoubleVector", null, ["number", "number", "number"], [buffer, startPosition, endPosition]);
+        }
+    }
+    catch (e) {
+        console.log(e);
+    }
+    finally {
+        // To avoid memory leaks we need to always clear out the allocated heap data
+        if (buffer) {
+            // @ts-ignore
+            wasmContext._free(buffer);
+        }
+    }
+}
+exports.appendDoubleVectorFromJsArray = appendDoubleVectorFromJsArray;

package/utils/hash.d.ts

@@ -0,0 +1,7 @@
+export declare const hashUtils: {
+    generateHash: (s: string) => number;
+    generateObjectHash: (obj: any) => number;
+    generateBooleanHash: (value: boolean) => number;
+    generateNumberHash: (value: number) => number;
+    generateCombinedHash: (hashes: number[]) => number;
+};

package/utils/hash.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashUtils = void 0;
+// https://stackoverflow.com/questions/7616461/generate-a-hash-from-string-in-javascript
+var generateHash = function (s) {
+    return s.split("").reduce(function (a, b) {
+        a = (a << 5) - a + b.charCodeAt(0);
+        return a & a;
+    }, 0);
+};
+var generateObjectHash = function (obj) {
+    var str = JSON.stringify(obj);
+    return generateHash(str);
+};
+var generateBooleanHash = function (value) {
+    if (value === false)
+        return generateHash("0");
+    if (value === true)
+        return generateHash("1");
+    return generateHash("-1");
+};
+var generateNumberHash = function (value) {
+    var str = value.toString(10);
+    return generateHash(str);
+};
+var generateCombinedHash = function (hashes) {
+    return hashes.reduce(function (prev, curr) { return (prev * 397) ^ curr; }, 0);
+};
+exports.hashUtils = {
+    generateHash: generateHash,
+    generateObjectHash: generateObjectHash,
+    generateBooleanHash: generateBooleanHash,
+    generateNumberHash: generateNumberHash,
+    generateCombinedHash: generateCombinedHash
+};

package/utils/tooltip.d.ts

@@ -0,0 +1,42 @@
+import { TTooltipProps } from "../Charting/ChartModifiers/RolloverModifier";
+import { Rect } from "../Core/Rect";
+export declare enum ESize {
+    width = "width",
+    height = "height"
+}
+export declare enum ECoord {
+    xCoord = "xCoord",
+    yCoord = "yCoord"
+}
+export declare enum EShift {
+    xCoordShift = "xCoordShift",
+    yCoordShift = "yCoordShift"
+}
+declare type TSize = ESize.width | ESize.height;
+declare type TCoord = ECoord.xCoord | ECoord.yCoord;
+declare type TShift = EShift.xCoordShift | EShift.yCoordShift;
+export declare type TPositionPoperties = {
+    sizePropertyName: TSize;
+    coordPropertyName: TCoord;
+    shiftPropertyName: TShift;
+};
+/** @ignore */
+export declare const spreadTooltips: (tooltipArray: TTooltipProps[], pixelRatio: number, positionProperties: TPositionPoperties, spacing: number, seriesViewRect: Rect) => Map<number, number>;
+/** @ignore */
+export declare const checkHasOverlap: (tooltipArray: TTooltipProps[], spacing: number, pixelRatio: number, positionProperties: TPositionPoperties) => boolean;
+/** @ignore */
+export declare const getTotalSize: (tooltipArray: TTooltipProps[], sizePropertyName: TSize) => number;
+/** @ignore */
+export declare const getTotalSpacing: (tooltipArray: TTooltipProps[], spacing: number) => number;
+/** @ignore */
+export declare const getStartPoint: (coord: number, shift: number, pixelRatio: number) => number;
+/** @ignore */
+export declare const getEndPoint: (coord: number, shift: number, pixelRatio: number, size: number) => number;
+/** @ignore */
+export declare const getUpdatedPoints: (startPoint: number, endPoint: number, totalBoxModel: number, size: number) => {
+    start: number;
+    end: number;
+};
+/** @ignore */
+export declare const getTooltipPositionProperties: (isVerticalChart: boolean) => TPositionPoperties;
+export {};

package/utils/tooltip.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTooltipPositionProperties = exports.getUpdatedPoints = exports.getEndPoint = exports.getStartPoint = exports.getTotalSpacing = exports.getTotalSize = exports.checkHasOverlap = exports.spreadTooltips = exports.EShift = exports.ECoord = exports.ESize = void 0;
+var ESize;
+(function (ESize) {
+    ESize["width"] = "width";
+    ESize["height"] = "height";
+})(ESize = exports.ESize || (exports.ESize = {}));
+var ECoord;
+(function (ECoord) {
+    ECoord["xCoord"] = "xCoord";
+    ECoord["yCoord"] = "yCoord";
+})(ECoord = exports.ECoord || (exports.ECoord = {}));
+var EShift;
+(function (EShift) {
+    EShift["xCoordShift"] = "xCoordShift";
+    EShift["yCoordShift"] = "yCoordShift";
+})(EShift = exports.EShift || (exports.EShift = {}));
+/** @ignore */
+var spreadTooltips = function (tooltipArray, pixelRatio, positionProperties, spacing, seriesViewRect) {
+    var shiftMap = new Map();
+    var length = tooltipArray.length;
+    var totalSize = (0, exports.getTotalSize)(tooltipArray, positionProperties.sizePropertyName);
+    var totalSpacing = (0, exports.getTotalSpacing)(tooltipArray, spacing);
+    var totalBoxModel = totalSize + totalSpacing;
+    var firstTooltip = tooltipArray[0];
+    var lastTooltip = tooltipArray[length - 1];
+    var startPoint = (0, exports.getStartPoint)(firstTooltip[positionProperties.coordPropertyName], firstTooltip[positionProperties.shiftPropertyName], pixelRatio);
+    var endPoint = (0, exports.getEndPoint)(lastTooltip[positionProperties.coordPropertyName], lastTooltip[positionProperties.shiftPropertyName], pixelRatio, lastTooltip[positionProperties.sizePropertyName]);
+    var updatedPoints = (0, exports.getUpdatedPoints)(startPoint, endPoint, totalBoxModel, seriesViewRect[positionProperties.sizePropertyName]);
+    startPoint = updatedPoints.start;
+    endPoint = updatedPoints.end;
+    var currentPadding = (endPoint - startPoint - totalSize) / (tooltipArray.length - 1);
+    tooltipArray.reduce(function (tooltipTopCoord, tooltip) {
+        shiftMap.set(tooltip.index, (tooltipTopCoord - tooltip[positionProperties.coordPropertyName]) / pixelRatio);
+        return tooltipTopCoord + tooltip[positionProperties.sizePropertyName] + currentPadding;
+    }, startPoint);
+    return shiftMap;
+};
+exports.spreadTooltips = spreadTooltips;
+/** @ignore */
+var checkHasOverlap = function (tooltipArray, spacing, pixelRatio, positionProperties) {
+    var length = tooltipArray.length;
+    for (var i = 0; i < length - 1; i++) {
+        var currentTooltip = tooltipArray[i];
+        var currentTooltipEndPoint = currentTooltip[positionProperties.coordPropertyName] +
+            currentTooltip[positionProperties.sizePropertyName] +
+            currentTooltip[positionProperties.shiftPropertyName] * pixelRatio;
+        var nextTooltip = tooltipArray[i + 1];
+        var nextTooltipStartPoint = nextTooltip[positionProperties.coordPropertyName] +
+            nextTooltip[positionProperties.shiftPropertyName] * pixelRatio;
+        var diff = nextTooltipStartPoint - currentTooltipEndPoint;
+        if (diff < spacing)
+            return true;
+    }
+    return false;
+};
+exports.checkHasOverlap = checkHasOverlap;
+/** @ignore */
+var getTotalSize = function (tooltipArray, sizePropertyName) {
+    return tooltipArray.reduce(function (acc, tooltip) {
+        var size = tooltip[sizePropertyName];
+        return typeof size === "number" ? acc + size : acc;
+    }, 0);
+};
+exports.getTotalSize = getTotalSize;
+/** @ignore */
+var getTotalSpacing = function (tooltipArray, spacing) {
+    return (tooltipArray.length - 1) * spacing;
+};
+exports.getTotalSpacing = getTotalSpacing;
+/** @ignore */
+var getStartPoint = function (coord, shift, pixelRatio) { return coord + shift * pixelRatio; };
+exports.getStartPoint = getStartPoint;
+/** @ignore */
+var getEndPoint = function (coord, shift, pixelRatio, size) {
+    return coord + shift * pixelRatio + size;
+};
+exports.getEndPoint = getEndPoint;
+/** @ignore */
+var getUpdatedPoints = function (startPoint, endPoint, totalBoxModel, size) {
+    var additionalWidth = totalBoxModel - (endPoint - startPoint);
+    var additionalWidthHalf = additionalWidth / 2;
+    var availableWidthFromStart = startPoint;
+    var availableWidthFromEnd = size - endPoint;
+    var start = startPoint - additionalWidthHalf;
+    var end = endPoint + additionalWidthHalf;
+    if (availableWidthFromStart < additionalWidthHalf) {
+        start = 0;
+        end = endPoint + (additionalWidth - availableWidthFromStart);
+    }
+    if (availableWidthFromEnd < additionalWidthHalf) {
+        start = startPoint - (additionalWidth - availableWidthFromEnd);
+        end = size;
+    }
+    return {
+        start: start,
+        end: end
+    };
+};
+exports.getUpdatedPoints = getUpdatedPoints;
+/** @ignore */
+var getTooltipPositionProperties = function (isVerticalChart) {
+    if (isVerticalChart) {
+        return {
+            sizePropertyName: ESize.width,
+            coordPropertyName: ECoord.xCoord,
+            shiftPropertyName: EShift.xCoordShift
+        };
+    }
+    else {
+        return {
+            sizePropertyName: ESize.height,
+            coordPropertyName: ECoord.yCoord,
+            shiftPropertyName: EShift.yCoordShift
+        };
+    }
+};
+exports.getTooltipPositionProperties = getTooltipPositionProperties;

package/utils/ccall/fillDoubleVectorFromJsArray.d.ts

@@ -1,3 +0,0 @@
-import { NumberArray } from "../../types/NumberArray";
-import { DoubleVector, TSciChart } from "../../types/TSciChart";
-export declare function fillDoubleVectorFromJsArray(wasmContext: TSciChart, doubleVector: DoubleVector, array: NumberArray): void;

package/utils/ccall/fillDoubleVectorFromJsArray.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fillDoubleVectorFromJsArray = void 0;
-function fillDoubleVectorFromJsArray(wasmContext, doubleVector, array) {
-    var buffer;
-    try {
-        var vectorSize = doubleVector.size();
-        var arraySize = array.length;
-        var startPosition = vectorSize;
-        var endPosition = startPosition + arraySize;
-        /// because plain c functions were receiving the object pointer as null, this is the way around that...
-        wasmContext.SCRTSetActiveDoubleVector(doubleVector, vectorSize);
-        // Allocate some space in the heap for the data (making sure to use the appropriate memory size of the elements)
-        // @ts-ignore
-        buffer = wasmContext._malloc(arraySize * 8);
-        // Assign the data to the heap - Keep in mind bytes per element
-        // @ts-ignore
-        wasmContext.HEAPF64.set(array, buffer / 8);
-        // Finally, call the function
-        // Here we use start position 0 and the end position array.length
-        // @ts-ignore
-        wasmContext.ccall("SCRTFillActiveDoubleVector", null, ["number", "number", "number"], [buffer, startPosition, endPosition]);
-    }
-    catch (e) {
-        console.log(e);
-    }
-    finally {
-        // To avoid memory leaks we need to always clear out the allocated heap data
-        // @ts-ignore
-        wasmContext._free(buffer);
-    }
-}
-exports.fillDoubleVectorFromJsArray = fillDoubleVectorFromJsArray;

package/utils/performance.d.ts

@@ -1,5 +0,0 @@
-/**
- * Awaits for the next frame and resolves.
- * FOR BROWSER ONLY, DOES NOT WORK IN NODE.JS
- */
-export declare function nextFrameRender(): Promise<unknown>;

package/utils/performance.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.nextFrameRender = void 0;
-/**
- * Awaits for the next frame and resolves.
- * FOR BROWSER ONLY, DOES NOT WORK IN NODE.JS
- */
-function nextFrameRender() {
-    return new Promise(function (resolve) { return requestAnimationFrame(resolve); });
-}
-exports.nextFrameRender = nextFrameRender;