scichart 2.0.2228 → 2.1.2273

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;