scichart 3.1.348 → 3.2.0-beta

package/utils/MemoryUsageHelper.d.ts

@@ -0,0 +1,45 @@
+declare type TWeakRef = {
+    deref: () => any;
+};
+/** @ignore */
+declare type TObjectEntryInfo = {
+    isWasmObject: boolean;
+    /** WeakRef for the original object */
+    objectRef: TWeakRef;
+};
+export declare class ObjectRegistry {
+    protected weakMapRegistry: WeakMap<object, any>;
+    protected undeletedObjectsMap: Map<string, TObjectEntryInfo>;
+    protected uncollectedObjectsMap: Map<string, TObjectEntryInfo>;
+    protected finalizationRegistry: any;
+    add(obj: any, id: string, isWasmObject?: boolean): void;
+    remove(id: string): boolean;
+    getObjectId(obj: any): any;
+    has(id: string): boolean;
+    deleteIDeletableObjects(): void;
+    deleteWasmObjects(): void;
+    log(): void;
+    generateCurrentState(): any;
+    protected deleteEntry(entry: TObjectEntryInfo, key: string): void;
+    protected onCollect(id: string): void;
+}
+/** @ignore */
+export declare const generateIdentifier: (entity: any) => string;
+export declare class MemoryUsageHelper {
+    protected static isMemoryUsageDebugEnabledProperty: boolean;
+    static objectRegistry: ObjectRegistry;
+    static get isMemoryUsageDebugEnabled(): boolean;
+    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;
+    static unregister(id: string): void;
+    static destroyMultiChart(): void;
+    static destroySingleCharts(): void;
+    static destroyPieCharts(): void;
+    static destroyAllCharts(): void;
+}
+export {};

package/utils/MemoryUsageHelper.js

@@ -0,0 +1,171 @@
+"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");
+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);
+        });
+    }
+    ObjectRegistry.prototype.add = function (obj, id, isWasmObject) {
+        if (isWasmObject === void 0) { isWasmObject = false; }
+        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);
+        // @ts-ignore WeakRef
+        var objectRef = new WeakRef(obj);
+        var objInfo = { isWasmObject: isWasmObject, objectRef: objectRef };
+        if (obj.delete) {
+            this.undeletedObjectsMap.set(id, objInfo);
+        }
+        this.uncollectedObjectsMap.set(id, objInfo);
+    };
+    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);
+    };
+    ObjectRegistry.prototype.has = function (id) {
+        return this.undeletedObjectsMap.has(id);
+    };
+    ObjectRegistry.prototype.deleteIDeletableObjects = function () {
+        var _this = this;
+        this.undeletedObjectsMap.forEach(function (entry, key) {
+            if (!entry.isWasmObject) {
+                _this.deleteEntry(entry, key);
+            }
+        });
+    };
+    ObjectRegistry.prototype.deleteWasmObjects = function () {
+        var _this = this;
+        this.undeletedObjectsMap.forEach(function (entry, key) {
+            if (entry.isWasmObject) {
+                _this.deleteEntry(entry, key);
+            }
+        });
+    };
+    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");
+    };
+    ObjectRegistry.prototype.generateCurrentState = 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;
+    };
+    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!"));
+        }
+    };
+    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;
+var MemoryUsageHelper = /** @class */ (function () {
+    function MemoryUsageHelper() {
+    }
+    Object.defineProperty(MemoryUsageHelper, "isMemoryUsageDebugEnabled", {
+        get: function () {
+            return this.isMemoryUsageDebugEnabledProperty;
+        },
+        set: function (value) {
+            this.isMemoryUsageDebugEnabledProperty = value;
+            if (process.env.NODE_ENV !== "production") {
+                if (value && !MemoryUsageHelper.objectRegistry) {
+                    MemoryUsageHelper.objectRegistry = new ObjectRegistry();
+                }
+                return;
+            }
+            if (value) {
+                console.warn("Memory usage debug enabled! Consider disabling it for production build 'MemoryUsageHelper.isMemoryUsageDebugEnabled = false'.");
+            }
+        },
+        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));
+    };
+    MemoryUsageHelper.unregister = function (id) {
+        var _a;
+        (_a = MemoryUsageHelper.objectRegistry) === null || _a === void 0 ? void 0 : _a.remove(id);
+    };
+    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); });
+    };
+    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); });
+    };
+    MemoryUsageHelper.destroyPieCharts = function () {
+        Globals_1.sciChartPieDestinations.forEach(function (destination) { return destination.sciChartSurface.delete(true); });
+    };
+    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/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;