scichart 3.1.348 → 3.2.434

package/Charting3D/Visuals/createSingle3d.js

@@ -4,10 +4,13 @@ exports.createSingle3dInternal = void 0;
 // @ts-ignore
 var WasmModule3D = require("../../_wasm/scichart3d");
 var chartBuilder_1 = require("../../Builder/chartBuilder");
+var licenseManager2D_1 = require("../../Charting/Visuals/licenseManager2D");
 var loader_1 = require("../../Charting/Visuals/loader");
+var SciChartDefaults_1 = require("../../Charting/Visuals/SciChartDefaults");
 var sciChartInitCommon_1 = require("../../Charting/Visuals/sciChartInitCommon");
 var SciChartSurfaceBase_1 = require("../../Charting/Visuals/SciChartSurfaceBase");
 var BuildStamp_1 = require("../../Core/BuildStamp");
+var DeletableEntity_1 = require("../../Core/DeletableEntity");
 var WebGlHelper_1 = require("../../Core/WebGlHelper");
 var licenseManager3D_1 = require("./licenseManager3D");
 var SciChart3DSurface_1 = require("./SciChart3DSurface");
@@ -15,7 +18,7 @@ var createSingle3dInternal = function (divElement, options) {
     (0, chartBuilder_1.ensureRegistrations)();
     return new Promise(function (resolve, reject) {
         var _a, _b, _c, _d;
-        var canvases = sciChartInitCommon_1.default.initCanvas(divElement, (_a = options === null || options === void 0 ? void 0 : options.widthAspect) !== null && _a !== void 0 ? _a : 0, (_b = options === null || options === void 0 ? void 0 : options.heightAspect) !== null && _b !== void 0 ? _b : 0);
+        var canvases = sciChartInitCommon_1.default.initCanvas(divElement, (_a = options === null || options === void 0 ? void 0 : options.widthAspect) !== null && _a !== void 0 ? _a : 0, (_b = options === null || options === void 0 ? void 0 : options.heightAspect) !== null && _b !== void 0 ? _b : 0, undefined, undefined, options === null || options === void 0 ? void 0 : options.touchAction);
         var loader = (_c = options === null || options === void 0 ? void 0 : options.loader) !== null && _c !== void 0 ? _c : new loader_1.DefaultSciChartLoader();
         var loaderDiv = loader.addChartLoader(canvases.domDivContainer, (_d = options === null || options === void 0 ? void 0 : options.theme) !== null && _d !== void 0 ? _d : SciChartSurfaceBase_1.SciChartSurfaceBase.DEFAULT_THEME);
         var webGLSupport = WebGlHelper_1.WebGlHelper.getWebGlSupport();
@@ -29,7 +32,23 @@ var createSingle3dInternal = function (divElement, options) {
                 loader.removeChartLoader(canvases.domDivContainer, loaderDiv);
                 // @ts-ignore
                 wasmContext.doNotCaptureKeyboard = true;
-                initDrawEngineSingleChart(wasmContext, canvases, resolve, (_a = options === null || options === void 0 ? void 0 : options.theme) !== null && _a !== void 0 ? _a : SciChartSurfaceBase_1.SciChartSurfaceBase.DEFAULT_THEME);
+                var revocable = (0, DeletableEntity_1.createWasmContextRevocableProxy)(wasmContext);
+                var customResolve = function (res) {
+                    res.sciChart3DSurface.addDeletable({
+                        delete: function () {
+                            revocable.revoke();
+                            revocable = undefined;
+                        }
+                    });
+                    resolve(res);
+                };
+                initDrawEngineSingleChart(revocable.proxy, canvases, customResolve, (_a = options === null || options === void 0 ? void 0 : options.theme) !== null && _a !== void 0 ? _a : SciChartSurfaceBase_1.SciChartSurfaceBase.DEFAULT_THEME);
+                // initDrawEngineSingleChart(
+                //     wasmContext,
+                //     canvases,
+                //     resolve,
+                //     (options?.theme as IThemeProvider) ?? SciChartSurfaceBase.DEFAULT_THEME
+                // );
                 (0, BuildStamp_1.checkBuildStamp)(wasmContext);
             })
                 .catch(function (ex) {
@@ -47,8 +66,6 @@ exports.createSingle3dInternal = createSingle3dInternal;
 // SINGLE CHART FUNCTIONS
 /** @ignore */
 var initDrawEngineSingleChart = function (wasmContext, canvases, resolve, theme) {
-    var width = canvases.domCanvas2D.width;
-    var height = canvases.domCanvas2D.height;
     // @ts-ignore
     wasmContext.preRun.push(function () { return (ENV.SDL_EMSCRIPTEN_KEYBOARD_ELEMENT = "#chart_WebGL"); });
     var scs;
@@ -57,6 +74,17 @@ var initDrawEngineSingleChart = function (wasmContext, canvases, resolve, theme)
         InitializeChart: function () {
             scs = new SciChart3DSurface_1.SciChart3DSurface(wasmContext, { canvases: canvases });
             scs.applyTheme(theme);
+            scs.addDeletable({
+                delete: function () {
+                    // Halt the engine
+                    wasmContext.TSRRequestExit();
+                    frameRenderer3D.delete();
+                    wasmContext.SCRTGetGlobalSampleChartInterface().SetFrameRenderer(null);
+                    wasmContext.SCRTGetGlobalSampleChartInterface().delete();
+                    wasmContext.SCRTSetGlobalSampleChartInterface(null);
+                    licenseManager2D_1.licenseManager.clear();
+                }
+            });
             setTimeout(function () {
                 scs.invalidateElement();
                 (0, licenseManager3D_1.applyLicense3D)(wasmContext, scs, true);
@@ -82,6 +110,8 @@ var initDrawEngineSingleChart = function (wasmContext, canvases, resolve, theme)
     var frameRenderer3D = new wasmContext.SCRTFrameRenderer3D();
     chartInitObj.SetFrameRenderer(frameRenderer3D);
     chartInitObj.SetFPSCounterEnabled(false);
+    // This may not be used in the case of 3D charts, but we set the property anyway as its passed down to TSR engine when initialising
+    chartInitObj.SetWasmBufferSizesKb(SciChartDefaults_1.SciChartDefaults.wasmBufferSizesKb);
     wasmContext.SCRTSetGlobalSampleChartInterface(chartInitObj);
     // @ts-ignore
     wasmContext.callMain();

package/Charting3D/Visuals/licenseManager3D.js

@@ -3,36 +3,40 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyLicense3D = void 0;
 var licenseManager2D_1 = require("../../Charting/Visuals/licenseManager2D");
 // tslint:disable: no-console
-var callbacks3D = {
-    getLicenseChallenge3D: function () {
-        var challenge = licenseContext3D.SCRTCredentials.GetLicenseChallenge();
-        var orderId = licenseContext3D.SCRTCredentials.GetOrderId();
-        return { challenge: challenge, orderId: orderId };
-    },
-    setChallengeResponse3D: function (token) { return licenseContext3D.SCRTCredentials.ApplyLicenseResponse(token); },
-    setNewLicense3D: function (keyCode) {
-        var requiresValidation = false;
-        var trialExpired;
-        licenseContext3D.SCRTCredentials.SetRuntimeLicenseKeyW(keyCode);
-        requiresValidation = licenseContext3D.SCRTCredentials.RequiresValidation();
-        trialExpired =
-            licenseContext3D.SCRTCredentials.GetLicenseType() ===
-                licenseContext3D.SCRTLicenseType.LICENSE_TYPE_TRIAL_EXPIRED;
-        (0, licenseManager2D_1.updateLicenseDisplay)((0, licenseManager2D_1.getLicenseInfo)(licenseContext3D), sciChartSurface3D, false, true);
-        return { requiresValidation: requiresValidation, trialExpired: trialExpired };
-    },
-    updateLicenseDisplay3D: function () { return (0, licenseManager2D_1.updateLicenseDisplay)((0, licenseManager2D_1.getLicenseInfo)(licenseContext3D), sciChartSurface3D, false, true); }
+var getCallbacks3D = function (licenseContext3D, sciChartSurface) {
+    return {
+        getLicenseChallenge3D: function () {
+            var challenge = licenseContext3D.SCRTCredentials.GetLicenseChallenge();
+            var orderId = licenseContext3D.SCRTCredentials.GetOrderId();
+            return { challenge: challenge, orderId: orderId };
+        },
+        setChallengeResponse3D: function (token) { return licenseContext3D.SCRTCredentials.ApplyLicenseResponse(token); },
+        setNewLicense3D: function (keyCode) {
+            var requiresValidation = false;
+            var trialExpired;
+            licenseContext3D.SCRTCredentials.SetRuntimeLicenseKeyW(keyCode);
+            requiresValidation = licenseContext3D.SCRTCredentials.RequiresValidation();
+            trialExpired =
+                licenseContext3D.SCRTCredentials.GetLicenseType() ===
+                    licenseContext3D.SCRTLicenseType.LICENSE_TYPE_TRIAL_EXPIRED;
+            (0, licenseManager2D_1.updateLicenseDisplay)((0, licenseManager2D_1.getLicenseInfo)(licenseContext3D), sciChartSurface, false, true);
+            return { requiresValidation: requiresValidation, trialExpired: trialExpired };
+        },
+        updateLicenseDisplay3D: function () {
+            return (0, licenseManager2D_1.updateLicenseDisplay)((0, licenseManager2D_1.getLicenseInfo)(licenseContext3D), sciChartSurface, false, true);
+        }
+    };
 };
 var shouldApplyLicense3D = true;
-var licenseContext3D;
-var sciChartSurface3D;
+// let licenseContext3D: TSciChart3D;
+// let sciChartSurface3D: SciChart3DSurface;
 var applyLicense3D = function (licenseContext, sciChartSurface, isSingle) {
     if (isSingle || shouldApplyLicense3D) {
-        licenseContext3D = licenseContext;
-        sciChartSurface3D = sciChartSurface;
+        // licenseContext3D = licenseContext as TSciChart3D;
+        // sciChartSurface3D = sciChartSurface as SciChart3DSurface;
         // set up callbacks
-        (0, licenseManager2D_1.setCallbacks3D)(callbacks3D);
-        (0, licenseManager2D_1.applyLicense)(licenseContext, sciChartSurface3D);
+        (0, licenseManager2D_1.setCallbacks3D)(getCallbacks3D(licenseContext, sciChartSurface));
+        (0, licenseManager2D_1.applyLicense)(licenseContext, sciChartSurface);
     }
     else {
         (0, licenseManager2D_1.updateLicenseDisplay)((0, licenseManager2D_1.getLicenseInfo)(licenseContext), sciChartSurface, false, false);

package/Core/BuildStamp.d.ts

@@ -1,4 +1,4 @@
 import { TSciChart } from "../types/TSciChart";
 import { TSciChart3D } from "../types/TSciChart3D";
-export declare const libraryVersion = "3.1.348";
+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-04T00:00:00";
+var buildStamp = "2023-07-25T00:00:00";
 var result;
 // tslint:disable-next-line:no-var-requires
-exports.libraryVersion = "3.1.348";
+exports.libraryVersion = "3.2.434";
 var checkBuildStamp = function (wasmContext) {
     if (result !== undefined)
         return result;

package/Core/DeletableEntity.d.ts

@@ -0,0 +1,34 @@
+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;
+}
+/** @ignore */
+export declare class DeletableEntityProxyHandler implements ProxyHandler<any> {
+    protected disposableEntityId: string;
+    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

@@ -0,0 +1,138 @@
+"use strict";
+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)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWasmContextRevocableProxy = exports.WasmContextProxyHandler = exports.WasmObjectConstructorProxyHandler = exports.DeletableEntityProxyHandler = exports.DeletableEntity = exports.createTrackableProxy = void 0;
+var MemoryUsageHelper_1 = require("../utils/MemoryUsageHelper");
+/** @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) {
+        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;
+/** @ignore */
+var DeletableEntityProxyHandler = /** @class */ (function () {
+    function DeletableEntityProxyHandler(id) {
+        this.disposableEntityId = id;
+    }
+    DeletableEntityProxyHandler.prototype.construct = function (real, constructParams) {
+        console.warn("construct called on Deletable", this.disposableEntityId);
+        return real;
+    };
+    DeletableEntityProxyHandler.prototype.apply = function (target, thisArg, argArray) {
+        console.warn("apply called on Deletable", this.disposableEntityId);
+    };
+    DeletableEntityProxyHandler.prototype.get = function (constructedEntity, propertyName, receiver) {
+        var _this = this;
+        if (propertyName === "delete") {
+            return function () {
+                var params = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    params[_i] = arguments[_i];
+                }
+                var removedSuccessfully = MemoryUsageHelper_1.MemoryUsageHelper.objectRegistry.remove(_this.disposableEntityId);
+                if (!removedSuccessfully) {
+                    console.warn("Failed to remove ".concat(_this.disposableEntityId, " from the Object Registry Probably it has been already deleted!"));
+                }
+                return constructedEntity[propertyName].apply(constructedEntity, params);
+            };
+        }
+        return constructedEntity[propertyName];
+    };
+    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 (0, exports.createTrackableProxy)(realConstructedEntity, true);
+    };
+    return WasmObjectConstructorProxyHandler;
+}());
+exports.WasmObjectConstructorProxyHandler = WasmObjectConstructorProxyHandler;
+// https://stackoverflow.com/a/48036194
+var handler = {
+    construct: function () {
+        return handler;
+    }
+}; //Must return ANY object, so reuse one
+var isConstructor = function (someObj) {
+    try {
+        return !!new new Proxy(someObj, handler)();
+    }
+    catch (e) {
+        return false;
+    }
+};
+/** @ignore */
+var WasmContextProxyHandler = /** @class */ (function () {
+    function WasmContextProxyHandler() {
+        this.constructorProxyHandler = new WasmObjectConstructorProxyHandler();
+    }
+    WasmContextProxyHandler.prototype.get = function (target, name, receiver) {
+        var originalExposedProperty = target[name];
+        var isNativeObjectConstructor = isConstructor(originalExposedProperty);
+        if (isNativeObjectConstructor) {
+            return new Proxy(originalExposedProperty, this.constructorProxyHandler);
+        }
+        return originalExposedProperty;
+    };
+    return WasmContextProxyHandler;
+}());
+exports.WasmContextProxyHandler = WasmContextProxyHandler;
+/** @ignore */
+var createWasmContextRevocableProxy = function (wasmContext) {
+    MemoryUsageHelper_1.MemoryUsageHelper.register(wasmContext, "wasmContext");
+    var proxyHandler = {};
+    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/Globals.d.ts

@@ -0,0 +1,11 @@
+import { TSciChartDestination } from "../Charting/Visuals/SciChartSurfaceBase";
+/** @ignore */
+export declare const sciChartDestinations: TSciChartDestination[];
+/** @ignore */
+export declare const sciChart3DDestinations: TSciChartDestination[];
+/** @ignore */
+export declare const sciChartSingleDestinations: TSciChartDestination[];
+/** @ignore */
+export declare const sciChart3DSingleDestinations: TSciChartDestination[];
+/** @ignore */
+export declare const sciChartPieDestinations: TSciChartDestination[];

package/Core/Globals.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sciChartPieDestinations = exports.sciChart3DSingleDestinations = exports.sciChartSingleDestinations = exports.sciChart3DDestinations = exports.sciChartDestinations = void 0;
+/** @ignore */
+exports.sciChartDestinations = [];
+/** @ignore */
+exports.sciChart3DDestinations = [];
+/** @ignore */
+exports.sciChartSingleDestinations = [];
+/** @ignore */
+exports.sciChart3DSingleDestinations = [];
+/** @ignore */
+exports.sciChartPieDestinations = [];

package/Core/Guard.d.ts

@@ -45,5 +45,11 @@ export declare class Guard {
      * @param name
      */
     static argumentIsRealNumber(d: number, name: string): void;
+    /**
+     * Asserts a numeric argument is a real number: not null (undefined), not NaN and not infinite
+     * @param d
+     * @param name
+     */
+    static argumentIsRealInteger(d: number, name: string): void;
 }
 export {};

package/Core/Guard.js

@@ -76,6 +76,16 @@ var Guard = /** @class */ (function () {
             throw new Error("Argument ".concat(name, " must be a real number (not infinite, not NAN)"));
         }
     };
+    /**
+     * Asserts a numeric argument is a real number: not null (undefined), not NaN and not infinite
+     * @param d
+     * @param name
+     */
+    Guard.argumentIsRealInteger = function (d, name) {
+        if (!Number.isInteger(d) || !(0, isRealNumber_1.isRealNumber)(d)) {
+            throw new Error("Argument ".concat(name, " must be a real integer number (not infinite, not NAN)"));
+        }
+    };
     return Guard;
 }());
 exports.Guard = Guard;

package/Core/Mouse/MouseManager.d.ts

@@ -17,6 +17,29 @@ export declare class MouseManager {
      * For subCharts - to track if the mousepointer is over the subChart, so we can fake Enter and Leave events
      */
     isOver: boolean;
+    /**
+     * Max allowed interval between taps for them to be considered a double tap action.
+     * @remarks used by double tap polyfill
+     */
+    maxTapDuration: number;
+    /**
+     * Toggles usage of double tap polyfill
+     */
+    enableDoubleTapPolyfill: boolean;
+    /**
+     * Tracks if double tap action fired dbclick event
+     */
+    protected supportsDoubleTap: boolean;
+    /**
+     * Tracks status of double tap event.
+     * Positive value means that polyfill was used to handle the event.
+     */
+    protected doubleTapHandled: boolean;
+    /**
+     * Defines whether double tap polyfill should  always be used
+     */
+    forceDoubleTapPolyfill: boolean;
+    protected lastTapTime: number;
     /**
      * Creates an instance of the {@link MouseManager}
      * @param target The target {@link SciChartSurfaceBase} that we are listening to events on

package/Core/Mouse/MouseManager.js

@@ -34,6 +34,19 @@ var MouseManager = /** @class */ (function () {
          * For subCharts - to track if the mousepointer is over the subChart, so we can fake Enter and Leave events
          */
         this.isOver = false;
+        /**
+         * Max allowed interval between taps for them to be considered a double tap action.
+         * @remarks used by double tap polyfill
+         */
+        this.maxTapDuration = 500;
+        /**
+         * Toggles usage of double tap polyfill
+         */
+        this.enableDoubleTapPolyfill = true;
+        /**
+         * Defines whether double tap polyfill should  always be used
+         */
+        this.forceDoubleTapPolyfill = false;
         // We allow null target for testing purpose
         this.sciChartSurface = target;
         this.onPointerMove = this.onPointerMove.bind(this);
@@ -105,6 +118,34 @@ var MouseManager = /** @class */ (function () {
         // call args.nativeEvent.preventDefault() in the chart modifier instead of calling event.preventDefault() here
         var modifierEvent = ModifierMouseArgs_1.ModifierMouseArgs.fromPointerEvent(event);
         this.modifierMouseDown(modifierEvent);
+        // workaround for handling double tap in case "dbclick" is not fired
+        // (usually happens if touch-action is restricting the event).
+        // If enabled, polyfill will be used on the first occurrence of double tap
+        // to check if the event is captured by browser and fired as `dbclick`.
+        // Then, if double tap is captured natively, the polyfill will not be used on subsequent onPointerDown calls
+        var shouldUsePolyfillForDoubleTap = this.forceDoubleTapPolyfill || (this.enableDoubleTapPolyfill && !this.supportsDoubleTap);
+        var isTouchEvent = event.pointerType === "touch" || event.pointerType === "pen";
+        if (shouldUsePolyfillForDoubleTap && isTouchEvent) {
+            var currentTime = new Date().getTime();
+            var wasTappedBefore = !!this.lastTapTime;
+            var satisfiesDoubleTapInterval = currentTime - this.lastTapTime < this.maxTapDuration;
+            var isSingleTouchEvent = event.isPrimary;
+            if (wasTappedBefore && isSingleTouchEvent && satisfiesDoubleTapInterval) {
+                this.lastTapTime = undefined;
+                // mark that double tap event was already handled
+                this.doubleTapHandled = true;
+                // execute double click behavior
+                var tapEvent = ModifierMouseArgs_1.ModifierMouseArgs.fromPointerEvent(event);
+                this.modifierDoubleClick(tapEvent);
+            }
+            else {
+                this.lastTapTime = currentTime;
+                this.doubleTapHandled = false;
+            }
+        }
+        else {
+            this.doubleTapHandled = false;
+        }
     };
     /**
      * Internal function called when 'pointerup' event is fired on the target element
@@ -119,6 +160,12 @@ var MouseManager = /** @class */ (function () {
      * @param event The {@link PointerEvent}
      */
     MouseManager.prototype.onDoubleClick = function (event) {
+        if (this.doubleTapHandled) {
+            // source of `dbclick` event was a double tap
+            this.supportsDoubleTap = true;
+            // since event already handled by polyfill
+            return;
+        }
         var modifierEvent = ModifierMouseArgs_1.ModifierMouseArgs.fromMouseEvent(event);
         this.modifierDoubleClick(modifierEvent);
     };
@@ -283,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}
@@ -529,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/Telemetry.js

@@ -6,6 +6,7 @@ var cookie_1 = require("../utils/cookie");
 var BuildStamp_1 = require("./BuildStamp");
 var app_1 = require("../constants/app");
 var guid_1 = require("../utils/guid");
+var licensingClasses_1 = require("../types/licensingClasses");
 var sessionTime = 60 * 60 * 1000;
 var hasSent = false;
 var setUserCookie = function (userId, sessionId, sessionStart) {
@@ -37,8 +38,8 @@ var shouldSendTelemetry = function () {
     // Not if we've already done it
     if (hasSent)
         return false;
-    // not if the license is not dev
-    if (!licenseManager2dState_1.licenseManager2dState.getIsDev())
+    // not if the license is not community and not dev
+    if (licenseManager2dState_1.licenseManager2dState.getLicenseType() !== licensingClasses_1.LicenseType.Community && !licenseManager2dState_1.licenseManager2dState.getIsDev())
         return false;
     // not if telemetry not enabled
     if (!licenseManager2dState_1.licenseManager2dState.getTelemetry())
@@ -92,10 +93,7 @@ var sendTelemetry = function () {
             }
         }
     };
-    if (window.location.hostname.includes(".csb.app") ||
-        window.location.hostname.includes(".codesandbox.io") ||
-        window.location.hostname.includes("fiddle.jshell.net") ||
-        window.location.hostname.includes("cdpn.io")) {
+    if (licenseManager2dState_1.licenseManager2dState.getLicenseType() === licensingClasses_1.LicenseType.Community) {
         eventData.data.baseData.properties.url = window.location.href;
     }
     var endPointUrl = "https://dc.services.visualstudio.com/v2/track";