scichart 3.1.348 → 3.2.434

package/utils/MemoryUsageHelper.d.ts

@@ -0,0 +1,92 @@
+/** @ignore */
+declare type TWeakRef<T = any> = {
+    deref: () => T;
+};
+/** @ignore */
+declare type TObjectEntryInfo = {
+    isWasmObject: boolean;
+    /** WeakRef for the original object */
+    objectRef: TWeakRef;
+    /** WeakRef for the proxy of the object */
+    proxyRef?: TWeakRef;
+    /** revocableToken for the proxy of the object */
+    revocableTokenRef?: TWeakRef<ReturnType<ProxyConstructor["revocable"]>>;
+};
+/** @ignore */
+declare type TObjectEntryOptions = {
+    isWasmObject?: boolean;
+    revocableToken?: ReturnType<ProxyConstructor["revocable"]>;
+    proxy?: any;
+};
+/** ObjectRegistry represents a structure for storing object lifecycle info.
+ * Adding an object to the registry will place it into a category of undeleted until it is remove from the registry.
+ * Also the object will be placed into a category of uncollected until it is disposed by garbage collector.
+ */
+export declare class ObjectRegistry {
+    weakMapRegistry: WeakMap<object, any>;
+    undeletedObjectsMap: Map<string, TObjectEntryInfo>;
+    uncollectedObjectsMap: Map<string, TObjectEntryInfo>;
+    protected finalizationRegistry: any;
+    /** Adds an object and its related info to the registry */
+    add(obj: any, id: string, options?: TObjectEntryOptions): void;
+    /** Removes the object from the undeleted objects collection */
+    remove(id: string): boolean;
+    getObjectId(obj: any): any;
+    /** Calls `delete` on instances of {@link IDeletable} objects within the registry */
+    deleteIDeletableObjects(): void;
+    /** Calls `delete` on instances of Web Assembly objects within the registry */
+    deleteWasmObjects(): void;
+    /** Outputs the state of registry to the console */
+    log(): void;
+    /** Returns the state of the registry */
+    getState(): any;
+    /** Calls `delete` on a specific object within the registry */
+    protected deleteEntry(entry: TObjectEntryInfo, key: string): void;
+    /** The callback executed when an object is being garbage collected */
+    protected onCollect(id: string): void;
+}
+/** @ignore */
+export declare const generateIdentifier: (entity: any) => string;
+/** {@link MemoryUsageHelper} provides tools for tracking, debugging, and testing common issus related to lifecycle of SciChart entities. */
+export declare class MemoryUsageHelper {
+    protected static isMemoryUsageDebugEnabledProperty: boolean;
+    static objectRegistry: ObjectRegistry;
+    /** Gets or sets the `Memory Usage Debug Mode`.
+     * Enabling the mode, provides warnings about wrong usage or cleanup.
+     * Also it wraps SciChart entities and adds them to the {@link objectRegistry} to track their lifecycle
+     */
+    static get isMemoryUsageDebugEnabled(): boolean;
+    /** Gets or sets the `Memory Usage Debug Mode`.
+     * Enabling the mode, provides warnings about wrong usage or cleanup.
+     * Also it wraps SciChart entities and adds them to the {@link objectRegistry} to track their lifecycle
+     */
+    static set isMemoryUsageDebugEnabled(value: boolean);
+    /**
+     * Adds entity to the object registry to keep track of it being collected
+     * @param entity
+     * @param id optional custom ID of the entity
+     */
+    static register(entity: any, id?: string): void;
+    /**
+     * Removes entity from the object registry
+     * @param id ID of the entity
+     */
+    static unregister(id: string): void;
+    /**
+     * Calls `delete` on all 2D and 3D charts instantiated with {@link SciChartSurface.create} or {@link SciChart3DSurface.create}
+     */
+    static destroyMultiChart(): void;
+    /**
+     * Calls `delete` on all 2D and 3D charts instantiated with {@link SciChartSurface.createSingle} or {@link SciChart3DSurface.createSingle}
+     */
+    static destroySingleCharts(): void;
+    /**
+     * Calls `delete` on all charts instantiated with {@link SciChartPieSurface.create}
+     */
+    static destroyPieCharts(): void;
+    /**
+     * Calls `delete` on all charts
+     */
+    static destroyAllCharts(): void;
+}
+export {};

package/utils/MemoryUsageHelper.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryUsageHelper = exports.generateIdentifier = exports.ObjectRegistry = void 0;
+var Globals_1 = require("../Core/Globals");
+var guid_1 = require("./guid");
+/** ObjectRegistry represents a structure for storing object lifecycle info.
+ * Adding an object to the registry will place it into a category of undeleted until it is remove from the registry.
+ * Also the object will be placed into a category of uncollected until it is disposed by garbage collector.
+ */
+var ObjectRegistry = /** @class */ (function () {
+    function ObjectRegistry() {
+        var _this = this;
+        this.weakMapRegistry = new WeakMap();
+        // This structure is useful for tracking DeletableEntity or Native objects
+        // which were not disposed using delete method
+        this.undeletedObjectsMap = new Map();
+        this.uncollectedObjectsMap = new Map();
+        // @ts-ignore
+        this.finalizationRegistry = new FinalizationRegistry(function (id) {
+            _this.uncollectedObjectsMap.delete(id);
+            _this.onCollect(id);
+        });
+    }
+    /** Adds an object and its related info to the registry */
+    ObjectRegistry.prototype.add = function (obj, id, options) {
+        var _a, _b;
+        if (options === void 0) { options = { isWasmObject: false }; }
+        var isWasmObject = options.isWasmObject;
+        if (this.weakMapRegistry.has(obj)) {
+            console.warn("Adding existing entry to the registry!", id);
+        }
+        if (this.undeletedObjectsMap.has(id)) {
+            console.warn("Adding existing entry id to the registry!", id);
+        }
+        this.finalizationRegistry.register(obj, id);
+        this.weakMapRegistry.set(obj, id);
+        var proxy = (_b = (_a = options === null || options === void 0 ? void 0 : options.revocableToken) === null || _a === void 0 ? void 0 : _a.proxy) !== null && _b !== void 0 ? _b : options === null || options === void 0 ? void 0 : options.proxy;
+        var revocableToken = options === null || options === void 0 ? void 0 : options.revocableToken;
+        if (proxy) {
+            this.weakMapRegistry.set(proxy, id);
+        }
+        // @ts-ignore WeakRef
+        var objectRef = new WeakRef(obj);
+        // @ts-ignore WeakRef
+        var proxyRef = proxy && new WeakRef(proxy);
+        // @ts-ignore WeakRef
+        var revocableTokenRef = revocableToken && new WeakRef(revocableToken);
+        var objInfo = { isWasmObject: isWasmObject, objectRef: objectRef, proxyRef: proxyRef, revocableTokenRef: revocableTokenRef };
+        if (obj.delete) {
+            this.undeletedObjectsMap.set(id, objInfo);
+        }
+        this.uncollectedObjectsMap.set(id, objInfo);
+    };
+    /** Removes the object from the undeleted objects collection */
+    ObjectRegistry.prototype.remove = function (id) {
+        if (!this.undeletedObjectsMap.has(id) && !this.uncollectedObjectsMap.has(id)) {
+            console.warn("".concat(id, " was not found in the ObjectRegistry!"));
+        }
+        return this.undeletedObjectsMap.delete(id);
+    };
+    ObjectRegistry.prototype.getObjectId = function (obj) {
+        return this.weakMapRegistry.get(obj);
+    };
+    /** Calls `delete` on instances of {@link IDeletable} objects within the registry */
+    ObjectRegistry.prototype.deleteIDeletableObjects = function () {
+        var _this = this;
+        this.undeletedObjectsMap.forEach(function (entry, key) {
+            if (!entry.isWasmObject) {
+                _this.deleteEntry(entry, key);
+            }
+        });
+    };
+    /** Calls `delete` on instances of Web Assembly objects within the registry */
+    ObjectRegistry.prototype.deleteWasmObjects = function () {
+        var _this = this;
+        this.undeletedObjectsMap.forEach(function (entry, key) {
+            if (entry.isWasmObject) {
+                _this.deleteEntry(entry, key);
+            }
+        });
+    };
+    /** Outputs the state of registry to the console */
+    ObjectRegistry.prototype.log = function () {
+        var _this = this;
+        var undeletedObjectsIds = Array.from(this.undeletedObjectsMap.keys());
+        var uncollectedObjectsIds = Array.from(this.uncollectedObjectsMap.keys());
+        var collectedNotDeleted = undeletedObjectsIds.filter(function (id) { return !_this.uncollectedObjectsMap.has(id); });
+        var deletedNotCollected = uncollectedObjectsIds.filter(function (id) { return !_this.undeletedObjectsMap.has(id); });
+        console.log("Object Registry Log Start:");
+        console.log("undeletedObjectsMap", this.undeletedObjectsMap);
+        console.log("uncollectedObjectsMap", this.uncollectedObjectsMap);
+        console.log("collectedNotDeleted", collectedNotDeleted);
+        console.log("deletedNotCollected", deletedNotCollected);
+        console.log("weakMap", this.weakMapRegistry);
+        console.log("Object Registry Log End");
+    };
+    /** Returns the state of the registry */
+    ObjectRegistry.prototype.getState = function () {
+        var undeletedObjectsIds = Array.from(this.undeletedObjectsMap.keys());
+        var uncollectedObjectsIds = Array.from(this.uncollectedObjectsMap.keys());
+        var state = {};
+        if (undeletedObjectsIds.length) {
+            state.undeletedObjectsIds = undeletedObjectsIds;
+        }
+        if (uncollectedObjectsIds.length) {
+            state.uncollectedObjectsIds = uncollectedObjectsIds;
+        }
+        return state;
+    };
+    /** Calls `delete` on a specific object within the registry */
+    ObjectRegistry.prototype.deleteEntry = function (entry, key) {
+        var originalObject = entry.objectRef.deref();
+        if (originalObject) {
+            originalObject.delete();
+            this.remove(key);
+        }
+        else {
+            console.warn("Looks like the ".concat(key, " has already been garbage collected, thus the proper cleanup could not be executed!"));
+        }
+    };
+    /** The callback executed when an object is being garbage collected */
+    ObjectRegistry.prototype.onCollect = function (id) {
+        // Override with custom behavior
+    };
+    return ObjectRegistry;
+}());
+exports.ObjectRegistry = ObjectRegistry;
+/** @ignore */
+var generateIdentifier = function (entity) {
+    return "".concat(entity === null || entity === void 0 ? void 0 : entity.constructor.name, "_").concat((0, guid_1.generateGuid)());
+};
+exports.generateIdentifier = generateIdentifier;
+/** {@link MemoryUsageHelper} provides tools for tracking, debugging, and testing common issus related to lifecycle of SciChart entities. */
+var MemoryUsageHelper = /** @class */ (function () {
+    function MemoryUsageHelper() {
+    }
+    Object.defineProperty(MemoryUsageHelper, "isMemoryUsageDebugEnabled", {
+        /** Gets or sets the `Memory Usage Debug Mode`.
+         * Enabling the mode, provides warnings about wrong usage or cleanup.
+         * Also it wraps SciChart entities and adds them to the {@link objectRegistry} to track their lifecycle
+         */
+        get: function () {
+            return this.isMemoryUsageDebugEnabledProperty;
+        },
+        /** Gets or sets the `Memory Usage Debug Mode`.
+         * Enabling the mode, provides warnings about wrong usage or cleanup.
+         * Also it wraps SciChart entities and adds them to the {@link objectRegistry} to track their lifecycle
+         */
+        set: function (value) {
+            if (value) {
+                console.warn("Memory usage debug enabled! Make sure to disable it for production build!");
+            }
+            try {
+                if (process.env.NODE_ENV !== "production") {
+                    this.isMemoryUsageDebugEnabledProperty = value;
+                    if (value && !MemoryUsageHelper.objectRegistry) {
+                        MemoryUsageHelper.objectRegistry = new ObjectRegistry();
+                    }
+                    return;
+                }
+            }
+            catch (err) {
+                console.warn(err);
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Adds entity to the object registry to keep track of it being collected
+     * @param entity
+     * @param id optional custom ID of the entity
+     */
+    MemoryUsageHelper.register = function (entity, id) {
+        var _a;
+        if (!entity) {
+            console.warn("Registering invalid object \"".concat(entity, "\"!"));
+            return;
+        }
+        (_a = MemoryUsageHelper.objectRegistry) === null || _a === void 0 ? void 0 : _a.add(entity, id !== null && id !== void 0 ? id : (0, exports.generateIdentifier)(entity));
+    };
+    /**
+     * Removes entity from the object registry
+     * @param id ID of the entity
+     */
+    MemoryUsageHelper.unregister = function (id) {
+        var _a;
+        (_a = MemoryUsageHelper.objectRegistry) === null || _a === void 0 ? void 0 : _a.remove(id);
+    };
+    /**
+     * Calls `delete` on all 2D and 3D charts instantiated with {@link SciChartSurface.create} or {@link SciChart3DSurface.create}
+     */
+    MemoryUsageHelper.destroyMultiChart = function () {
+        Globals_1.sciChartDestinations.forEach(function (destination) { return destination.sciChartSurface.delete(true); });
+        Globals_1.sciChart3DDestinations.forEach(function (destination) { return destination.sciChartSurface.delete(true); });
+    };
+    /**
+     * Calls `delete` on all 2D and 3D charts instantiated with {@link SciChartSurface.createSingle} or {@link SciChart3DSurface.createSingle}
+     */
+    MemoryUsageHelper.destroySingleCharts = function () {
+        Globals_1.sciChartSingleDestinations.forEach(function (destination) { return destination.sciChartSurface.delete(true); });
+        Globals_1.sciChart3DSingleDestinations.forEach(function (destination) { return destination.sciChartSurface.delete(true); });
+    };
+    /**
+     * Calls `delete` on all charts instantiated with {@link SciChartPieSurface.create}
+     */
+    MemoryUsageHelper.destroyPieCharts = function () {
+        Globals_1.sciChartPieDestinations.forEach(function (destination) { return destination.sciChartSurface.delete(true); });
+    };
+    /**
+     * Calls `delete` on all charts
+     */
+    MemoryUsageHelper.destroyAllCharts = function () {
+        MemoryUsageHelper.destroyMultiChart();
+        MemoryUsageHelper.destroySingleCharts();
+        MemoryUsageHelper.destroyPieCharts();
+    };
+    MemoryUsageHelper.isMemoryUsageDebugEnabledProperty = false;
+    return MemoryUsageHelper;
+}());
+exports.MemoryUsageHelper = MemoryUsageHelper;

package/utils/array.d.ts

@@ -18,3 +18,11 @@ export declare function isArraySorted(arr: NumberArray, ascending?: boolean): bo
  * @returns
  */
 export declare function makeIncArray(length: number, multiplier?: number, map?: (n: number, index?: number) => number): number[];
+/**
+ * Helper function to append an array to a target array, treating the target as a circular buffer
+ * @param source
+ * @param target
+ * @param fifoCapacity
+ * @param startIndex
+ */
+export declare function appendRangeFifo(source: any[], target: any[], fifoCapacity: number, startIndex: number): void;

package/utils/array.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeIncArray = exports.isArraySorted = exports.arrayRemove = exports.areArraysEqual = exports.countUnique = exports.getUniqueValues = void 0;
+exports.appendRangeFifo = exports.makeIncArray = 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)
@@ -77,3 +77,60 @@ function makeIncArray(length, multiplier, map) {
     }
 }
 exports.makeIncArray = makeIncArray;
+/**
+ * Helper function to append an array to a target array, treating the target as a circular buffer
+ * @param source
+ * @param target
+ * @param fifoCapacity
+ * @param startIndex
+ */
+function appendRangeFifo(source, target, fifoCapacity, startIndex) {
+    var targetSize = target.length;
+    var length = source.length;
+    //console.log("s,t ", source, target);
+    if (fifoCapacity >= targetSize + length) {
+        // Space to append all data.  Use normal method
+        target.length += length;
+        // merge new values into the collection
+        for (var i = 0; i < length; ++i) {
+            target[targetSize + i] = source[i];
+        }
+    }
+    else if (length > fifoCapacity) {
+        // new data is larger than buffer.  Replace buffer with end of data
+        var dataIndex = length - fifoCapacity;
+        var dataThatWillFit = source.slice(dataIndex);
+        target = dataThatWillFit;
+    }
+    else if (fifoCapacity > targetSize) {
+        // buffer not full yet, but new data will overflow
+        var remainingCap = fifoCapacity - targetSize;
+        target.length = fifoCapacity;
+        for (var i = 0; i < length; ++i) {
+            if (i < remainingCap) {
+                target[targetSize + i] = source[i];
+            }
+            else {
+                target[remainingCap - i] = source[i];
+            }
+        }
+    }
+    else {
+        // buffer already full
+        var remainingCap = length;
+        if (startIndex + length > fifoCapacity) {
+            // need to do two writes
+            remainingCap = fifoCapacity - startIndex;
+        }
+        for (var i = 0; i < length; ++i) {
+            if (i < remainingCap) {
+                target[startIndex + i] = source[i];
+            }
+            else {
+                target[remainingCap - i] = source[i];
+            }
+        }
+    }
+    //console.log("t: ", target);
+}
+exports.appendRangeFifo = appendRangeFifo;

package/utils/colorUtil.d.ts

@@ -31,3 +31,10 @@ export declare function uintArgbColorToAbgr(argbColor: number): number;
 export declare function uintArgbColorMultiplyOpacity(argbColor: number, opacity: number): number;
 export declare function uintArgbColorOverrideOpacity(argbColor: number, opacity: number): number;
 export declare function uintArgbColorIsTransparent(argbColor: number): boolean;
+/**
+ * Applies the given opacity to an html color code or name, returning an html color code.
+ * @param color
+ * @param opacity
+ * @returns
+ */
+export declare function applyOpacityToHtmlColor(color: string, opacity: number): string;

package/utils/colorUtil.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uintArgbColorIsTransparent = exports.uintArgbColorOverrideOpacity = exports.uintArgbColorMultiplyOpacity = exports.uintArgbColorToAbgr = exports.linearColorMapLerp = exports.uintArgbColorLerp = exports.uintArgbColorLerp24bit = void 0;
+exports.applyOpacityToHtmlColor = exports.uintArgbColorIsTransparent = exports.uintArgbColorOverrideOpacity = exports.uintArgbColorMultiplyOpacity = exports.uintArgbColorToAbgr = exports.linearColorMapLerp = exports.uintArgbColorLerp = exports.uintArgbColorLerp24bit = void 0;
 var TLinearColorMap_1 = require("../types/TLinearColorMap");
 var parseColor_1 = require("./parseColor");
 /**
@@ -115,3 +115,15 @@ function uintArgbColorIsTransparent(argbColor) {
     return alpha !== 0xff000000;
 }
 exports.uintArgbColorIsTransparent = uintArgbColorIsTransparent;
+/**
+ * Applies the given opacity to an html color code or name, returning an html color code.
+ * @param color
+ * @param opacity
+ * @returns
+ */
+function applyOpacityToHtmlColor(color, opacity) {
+    var tarbg = (0, parseColor_1.parseColorToTArgb)(color);
+    tarbg.opacity = Math.floor(opacity * 256);
+    return (0, parseColor_1.parseTArgbToHtmlColor)(tarbg);
+}
+exports.applyOpacityToHtmlColor = applyOpacityToHtmlColor;

package/utils/logger.d.ts

@@ -1,3 +1,5 @@
 export declare class Logger {
+    static enableDebug: boolean;
     static log(message?: any, ...optionalParameters: any): void;
+    static debug(message?: any, ...optionalParameters: any): void;
 }

package/utils/logger.js

@@ -4,6 +4,7 @@ exports.Logger = void 0;
 var Logger = /** @class */ (function () {
     function Logger() {
     }
+    // public static enableLog = false;
     Logger.log = function (message) {
         var optionalParameters = [];
         for (var _i = 1; _i < arguments.length; _i++) {
@@ -11,6 +12,16 @@ var Logger = /** @class */ (function () {
         }
         console.log(message, optionalParameters);
     };
+    Logger.debug = function (message) {
+        var optionalParameters = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            optionalParameters[_i - 1] = arguments[_i];
+        }
+        if (Logger.enableDebug) {
+            console.debug(message, optionalParameters);
+        }
+    };
+    Logger.enableDebug = false;
     return Logger;
 }());
 exports.Logger = Logger;

package/utils/parseColor.js

@@ -128,10 +128,10 @@ exports.parseArgbToHtmlColor = parseArgbToHtmlColor;
  * @param targb
  */
 var parseTArgbToHtmlColor = function (targb) {
-    var r = targb.red.toString(16);
-    var g = targb.green.toString(16);
-    var b = targb.blue.toString(16);
-    var a = targb.opacity.toString(16);
+    var r = convertComponent(targb.red);
+    var g = convertComponent(targb.green);
+    var b = convertComponent(targb.blue);
+    var a = convertComponent(targb.opacity);
     return ("#" + r + g + b + a).toUpperCase();
 };
 exports.parseTArgbToHtmlColor = parseTArgbToHtmlColor;
@@ -176,6 +176,21 @@ var convertOpacity = function (opacity) {
     }
     return Math.floor(opacity * 256);
 };
+/**
+ * @ignore
+ * Converts number (color component) from 0 to 256 to hex string, with 0 padding
+ * @param component
+ */
+var convertComponent = function (component) {
+    if (component >= 256) {
+        return "ff";
+    }
+    if (component <= 0) {
+        return "00";
+    }
+    var hex = component.toString(16);
+    return hex.length === 1 ? "0" + hex : hex;
+};
 // https://www.w3schools.com/colors/colors_names.asp
 // https://en.wikipedia.org/wiki/Web_colors
 // http://www.colors.commutercreative.com/grid/