scichart 3.2.0-beta → 3.2.434

package/Charting3D/Visuals/createMaster3d.js

@@ -198,12 +198,17 @@ var createMaster = function () {
                             }
                         }
                         else {
-                            if (process.env.NODE_ENV !== "production") {
-                                if (MemoryUsageHelper_1.MemoryUsageHelper.isMemoryUsageDebugEnabled &&
-                                    sciChart3DSurface.otherSurfaces.length === 0) {
-                                    console.warn("SciChart3DSurface.autoDisposeWasmContext is disabled, thus wasmContext should be disposed explicitly using \"SciChartSurface.disposeSharedWasmContext()\".");
+                            try {
+                                if (process.env.NODE_ENV !== "production") {
+                                    if (MemoryUsageHelper_1.MemoryUsageHelper.isMemoryUsageDebugEnabled &&
+                                        sciChart3DSurface.otherSurfaces.length === 0) {
+                                        console.warn("SciChart3DSurface.autoDisposeWasmContext is disabled, thus wasmContext should be disposed explicitly using \"SciChartSurface.disposeSharedWasmContext()\".");
+                                    }
                                 }
                             }
+                            catch (err) {
+                                console.warn(err);
+                            }
                         }
                     }
                 });

package/Core/BuildStamp.d.ts

@@ -1,4 +1,4 @@
 import { TSciChart } from "../types/TSciChart";
 import { TSciChart3D } from "../types/TSciChart3D";
-export declare const libraryVersion = "3.2.0-beta";
+export declare const libraryVersion = "3.2.434";
 export declare const checkBuildStamp: (wasmContext: TSciChart | TSciChart3D) => boolean;

package/Core/BuildStamp.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkBuildStamp = exports.libraryVersion = void 0;
-var buildStamp = "2023-07-12T00:00:00";
+var buildStamp = "2023-07-25T00:00:00";
 var result;
 // tslint:disable-next-line:no-var-requires
-exports.libraryVersion = "3.2.0-beta";
+exports.libraryVersion = "3.2.434";
 var checkBuildStamp = function (wasmContext) {
     if (result !== undefined)
         return result;

package/Core/DeletableEntity.d.ts

@@ -1,27 +1,33 @@
 import type { TSciChart } from "../types/TSciChart";
 import { IDeletable } from "./IDeletable";
+/** @ignore */
+export declare const createTrackableProxy: <T extends IDeletable>(target: T, isWasmObject?: boolean) => T;
+/** Utility class responsible for adding its instance to {@link MemoryUsageHelper.objectRegistry} when Memory Usage Debug Mode is enabled
+ * @remarks
+ * It wraps the returned instance into a proxy object, so internal reference comparisons may fail
+ * */
 export declare abstract class DeletableEntity implements IDeletable {
     constructor(entity?: IDeletable);
     abstract delete(): void;
 }
-export declare class DeletableEntityWrapper extends DeletableEntity {
-    delete(): void;
-}
-export declare const wrapDeletableEntity: (entity: any) => DeletableEntityWrapper;
+/** @ignore */
 export declare class DeletableEntityProxyHandler implements ProxyHandler<any> {
     protected disposableEntityId: string;
-    constructor(entity: IDeletable);
+    constructor(id: string);
     construct(real: any, constructParams: any[]): any;
     apply(target: any, thisArg: any, argArray: any[]): void;
     get(constructedEntity: any, propertyName: string, receiver: any): any;
 }
+/** @ignore */
 export declare class WasmObjectConstructorProxyHandler implements ProxyHandler<any> {
     construct(targetFunction: any, constructParams: any[], newTarget: Function): object;
 }
+/** @ignore */
 export declare class WasmContextProxyHandler implements ProxyHandler<TSciChart> {
     protected constructorProxyHandler: WasmObjectConstructorProxyHandler;
     get(target: any, name: string, receiver: any): any;
 }
+/** @ignore */
 export declare const createWasmContextRevocableProxy: <TContextType extends object>(wasmContext: TContextType) => {
     proxy: TContextType;
     revoke: () => void;

package/Core/DeletableEntity.js

@@ -1,19 +1,4 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
         if (ar || !(i in from)) {
@@ -24,42 +9,46 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createWasmContextRevocableProxy = exports.WasmContextProxyHandler = exports.WasmObjectConstructorProxyHandler = exports.DeletableEntityProxyHandler = exports.wrapDeletableEntity = exports.DeletableEntityWrapper = exports.DeletableEntity = void 0;
+exports.createWasmContextRevocableProxy = exports.WasmContextProxyHandler = exports.WasmObjectConstructorProxyHandler = exports.DeletableEntityProxyHandler = exports.DeletableEntity = exports.createTrackableProxy = void 0;
 var MemoryUsageHelper_1 = require("../utils/MemoryUsageHelper");
-// TODO add method for deleting everything
-// first IDeletable
-// then Native
+/** @ignore */
+var createTrackableProxy = function (target, isWasmObject) {
+    if (isWasmObject === void 0) { isWasmObject = false; }
+    var disposableEntityId = (0, MemoryUsageHelper_1.generateIdentifier)(target);
+    var revocableToken = Proxy.revocable(target, new DeletableEntityProxyHandler(disposableEntityId));
+    MemoryUsageHelper_1.MemoryUsageHelper.objectRegistry.add(target, disposableEntityId, {
+        proxy: revocableToken.proxy,
+        revocableToken: revocableToken,
+        isWasmObject: isWasmObject
+    });
+    return revocableToken.proxy;
+};
+exports.createTrackableProxy = createTrackableProxy;
+/** Utility class responsible for adding its instance to {@link MemoryUsageHelper.objectRegistry} when Memory Usage Debug Mode is enabled
+ * @remarks
+ * It wraps the returned instance into a proxy object, so internal reference comparisons may fail
+ * */
 var DeletableEntity = /** @class */ (function () {
     function DeletableEntity(entity) {
-        if (process.env.NODE_ENV !== "production") {
-            if (MemoryUsageHelper_1.MemoryUsageHelper.isMemoryUsageDebugEnabled) {
-                var target = entity !== null && entity !== void 0 ? entity : this;
-                return new Proxy(target, new DeletableEntityProxyHandler(target));
+        try {
+            if (process.env.NODE_ENV !== "production") {
+                if (MemoryUsageHelper_1.MemoryUsageHelper.isMemoryUsageDebugEnabled) {
+                    var target = entity !== null && entity !== void 0 ? entity : this;
+                    return (0, exports.createTrackableProxy)(target, false);
+                }
             }
         }
+        catch (err) {
+            console.warn("Error while creating an object proxy: ".concat(err, " "));
+        }
     }
     return DeletableEntity;
 }());
 exports.DeletableEntity = DeletableEntity;
-var DeletableEntityWrapper = /** @class */ (function (_super) {
-    __extends(DeletableEntityWrapper, _super);
-    function DeletableEntityWrapper() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    DeletableEntityWrapper.prototype.delete = function () {
-        console.log("DeletableEntityWrapper delete");
-    };
-    return DeletableEntityWrapper;
-}(DeletableEntity));
-exports.DeletableEntityWrapper = DeletableEntityWrapper;
-var wrapDeletableEntity = function (entity) {
-    return new DeletableEntityWrapper(entity);
-};
-exports.wrapDeletableEntity = wrapDeletableEntity;
+/** @ignore */
 var DeletableEntityProxyHandler = /** @class */ (function () {
-    function DeletableEntityProxyHandler(entity) {
-        this.disposableEntityId = (0, MemoryUsageHelper_1.generateIdentifier)(entity);
-        MemoryUsageHelper_1.MemoryUsageHelper.objectRegistry.add(entity, this.disposableEntityId);
+    function DeletableEntityProxyHandler(id) {
+        this.disposableEntityId = id;
     }
     DeletableEntityProxyHandler.prototype.construct = function (real, constructParams) {
         console.warn("construct called on Deletable", this.disposableEntityId);
@@ -88,13 +77,14 @@ var DeletableEntityProxyHandler = /** @class */ (function () {
     return DeletableEntityProxyHandler;
 }());
 exports.DeletableEntityProxyHandler = DeletableEntityProxyHandler;
+/** @ignore */
 var WasmObjectConstructorProxyHandler = /** @class */ (function () {
     function WasmObjectConstructorProxyHandler() {
     }
     WasmObjectConstructorProxyHandler.prototype.construct = function (targetFunction, constructParams, newTarget) {
         var realConstructedEntity = new (targetFunction.bind.apply(targetFunction, __spreadArray([void 0], constructParams, false)))();
         //TODO check if DeletableEntityWrapper
-        return new Proxy(realConstructedEntity, new DeletableEntityProxyHandler(realConstructedEntity));
+        return (0, exports.createTrackableProxy)(realConstructedEntity, true);
     };
     return WasmObjectConstructorProxyHandler;
 }());
@@ -113,6 +103,7 @@ var isConstructor = function (someObj) {
         return false;
     }
 };
+/** @ignore */
 var WasmContextProxyHandler = /** @class */ (function () {
     function WasmContextProxyHandler() {
         this.constructorProxyHandler = new WasmObjectConstructorProxyHandler();
@@ -128,14 +119,20 @@ var WasmContextProxyHandler = /** @class */ (function () {
     return WasmContextProxyHandler;
 }());
 exports.WasmContextProxyHandler = WasmContextProxyHandler;
+/** @ignore */
 var createWasmContextRevocableProxy = function (wasmContext) {
     MemoryUsageHelper_1.MemoryUsageHelper.register(wasmContext, "wasmContext");
     var proxyHandler = {};
-    if (process.env.NODE_ENV !== "production") {
-        if (MemoryUsageHelper_1.MemoryUsageHelper.isMemoryUsageDebugEnabled) {
-            proxyHandler = new WasmContextProxyHandler();
+    try {
+        if (process.env.NODE_ENV !== "production") {
+            if (MemoryUsageHelper_1.MemoryUsageHelper.isMemoryUsageDebugEnabled) {
+                proxyHandler = new WasmContextProxyHandler();
+            }
         }
     }
+    catch (err) {
+        console.warn(err);
+    }
     return Proxy.revocable(wasmContext, proxyHandler);
 };
 exports.createWasmContextRevocableProxy = createWasmContextRevocableProxy;

package/Core/Mouse/MouseManager.js

@@ -330,6 +330,10 @@ var MouseManager = /** @class */ (function () {
                 updateModifiers();
             }
         }
+        else {
+            // Process even if not master so ZoomPan can work with modifierGroups
+            updateModifiers();
+        }
     };
     /**
      * Internal function called to route a mouse up event to all {@link sciChartSurface.chartModifiers}
@@ -576,6 +580,8 @@ var MouseManager = /** @class */ (function () {
     };
     MouseManager.prototype.processSubChartEvent = function (eventType, scs, args, subCharts, masterData) {
         var _this = this;
+        // modifiers on parent may prevent handling of modifer on subchart
+        args.handled = false;
         this.callEvent(eventType, scs, args);
         scs.chartModifierGroups.forEach(function (modifierGroup) {
             subCharts