scichart 3.2.0-beta → 3.2.442

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

package/Core/OneTimePerformanceWarning.d.ts

@@ -2,5 +2,5 @@ export declare class OneTimePerformanceWarning {
     private warnedProperty;
     private messageProperty;
     constructor(message: string);
-    warn(): void;
+    warn(): boolean;
 }

package/Core/OneTimePerformanceWarning.js

@@ -10,9 +10,10 @@ var OneTimePerformanceWarning = /** @class */ (function () {
     }
     OneTimePerformanceWarning.prototype.warn = function () {
         if (!SciChartDefaults_1.SciChartDefaults.performanceWarnings || this.warnedProperty || !licenseManager2dState_1.licenseManager2dState.getIsDev())
-            return;
+            return false;
         console.warn(this.messageProperty);
         this.warnedProperty = true;
+        return true;
     };
     return OneTimePerformanceWarning;
 }());