scichart 3.1.348 → 3.2.0-beta

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.0-beta";
 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-12T00:00:00";
 var result;
 // tslint:disable-next-line:no-var-requires
-exports.libraryVersion = "3.1.348";
+exports.libraryVersion = "3.2.0-beta";
 var checkBuildStamp = function (wasmContext) {
     if (result !== undefined)
         return result;

package/Core/DeletableEntity.d.ts

@@ -0,0 +1,28 @@
+import type { TSciChart } from "../types/TSciChart";
+import { IDeletable } from "./IDeletable";
+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;
+export declare class DeletableEntityProxyHandler implements ProxyHandler<any> {
+    protected disposableEntityId: string;
+    constructor(entity: IDeletable);
+    construct(real: any, constructParams: any[]): any;
+    apply(target: any, thisArg: any, argArray: any[]): void;
+    get(constructedEntity: any, propertyName: string, receiver: any): any;
+}
+export declare class WasmObjectConstructorProxyHandler implements ProxyHandler<any> {
+    construct(targetFunction: any, constructParams: any[], newTarget: Function): object;
+}
+export declare class WasmContextProxyHandler implements ProxyHandler<TSciChart> {
+    protected constructorProxyHandler: WasmObjectConstructorProxyHandler;
+    get(target: any, name: string, receiver: any): any;
+}
+export declare const createWasmContextRevocableProxy: <TContextType extends object>(wasmContext: TContextType) => {
+    proxy: TContextType;
+    revoke: () => void;
+};

package/Core/DeletableEntity.js

@@ -0,0 +1,141 @@
+"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)) {
+            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.wrapDeletableEntity = exports.DeletableEntityWrapper = exports.DeletableEntity = void 0;
+var MemoryUsageHelper_1 = require("../utils/MemoryUsageHelper");
+// TODO add method for deleting everything
+// first IDeletable
+// then Native
+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));
+            }
+        }
+    }
+    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;
+var DeletableEntityProxyHandler = /** @class */ (function () {
+    function DeletableEntityProxyHandler(entity) {
+        this.disposableEntityId = (0, MemoryUsageHelper_1.generateIdentifier)(entity);
+        MemoryUsageHelper_1.MemoryUsageHelper.objectRegistry.add(entity, this.disposableEntityId);
+    }
+    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;
+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 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;
+    }
+};
+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;
+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();
+        }
+    }
+    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);
     };

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";