scichart 2.0.2139 → 2.0.2185

package/Charting/Visuals/Axis/LabelProvider/DateLabelProvider.js

@@ -3,10 +3,12 @@ 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 (b.hasOwnProperty(p)) d[p] = b[p]; };
+            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 __());
@@ -43,11 +45,11 @@ var DateLabelProvider = /** @class */ (function (_super) {
         var _this = _super.call(this, __assign({ labelFormat: (_a = options === null || options === void 0 ? void 0 : options.labelFormat) !== null && _a !== void 0 ? _a : NumericFormat_1.ENumericFormat.Date_DDMMYYYY, cursorLabelFormat: (_b = options === null || options === void 0 ? void 0 : options.cursorLabelFormat) !== null && _b !== void 0 ? _b : NumericFormat_1.ENumericFormat.Date_DDMMYYYY }, options)) || this;
         _this.type = LabelProviderType_1.ELabelProviderType.Date;
         _this.formatLabelProperty = function (dataValue) {
-            return _this.applyFormat(number_1.formatNumber(dataValue, _this.numericFormat, _this.precision));
+            return _this.applyFormat((0, number_1.formatNumber)(dataValue, _this.numericFormat, _this.precision));
         };
         _this.formatCursorLabelProperty = function (dataValue) {
             var _a, _b;
-            return _this.applyFormat(number_1.formatNumber(dataValue, (_a = _this.cursorNumericFormat) !== null && _a !== void 0 ? _a : _this.numericFormat, (_b = _this.cursorPrecision) !== null && _b !== void 0 ? _b : _this.precision));
+            return _this.applyFormat((0, number_1.formatNumber)(dataValue, (_a = _this.cursorNumericFormat) !== null && _a !== void 0 ? _a : _this.numericFormat, (_b = _this.cursorPrecision) !== null && _b !== void 0 ? _b : _this.precision));
         };
         return _this;
     }

package/Charting/Visuals/Axis/LabelProvider/LabelCache.d.ts

@@ -0,0 +1,41 @@
+import { TTextStyle } from "../AxisCore";
+import { LabelInfo } from "./LabelProviderBase2D";
+export declare type TCachedLabelStyle = TTextStyle & {
+    providerId: string;
+    rotation?: number;
+    extras?: string;
+};
+/**
+ * A global cache for labels, used by all labelProviders, to reduce the amount of time spent creating label textures.
+ */
+export declare const labelCache: {
+    /** Get an identifier for the given text style.  Returns an existing identifier if a matching style exists in the cache */
+    getStyleId: (style: TCachedLabelStyle) => string;
+    /**
+     * Notify the cache that a style is no longer used.
+     * Linked labels are only deleted when there are no remaining uses, and then only after minAge has passed.
+     */
+    freeStyle: (styleId: string) => void;
+    /** Get a label from the cache.  Returns undefined if none found. */
+    getLabel: (text: string, styleId: string) => LabelInfo;
+    /** Add a label to the cache */
+    setLabel: (text: string, styleId: string, label: LabelInfo) => void;
+    /** Check if a text style matches the one for the given id */
+    checkStyle: (currentStyleId: string, newStyle: TCachedLabelStyle) => boolean;
+    /** Get the maximum number of labels allowed to be stored in the cache.  Used when calling pruneCache */
+    getMaxSize: () => number;
+    /** Set the maximum number of labels allowed to be stored in the cache.  Used when calling pruneCache */
+    setMaxSize: (size: number) => void;
+    /** Get the minimum age (time since last used) of labels in the cache.
+     * This prevents recently used labels from being pruned, or removed when style is freed
+     */
+    getMinAge: () => number;
+    /** Set the minimum age (time since last used) of labels in the cache.
+     * This prevents recently used labels from being pruned, or removed when style is freed
+     */
+    setMinAge: (ageInMs: number) => void;
+    /** Remove old labels from the cache, if there are more than MaxSize.   */
+    pruneCache: () => void;
+    /** Completely clears and resets the cache.  Testing use only */
+    resetCache: () => void;
+};

package/Charting/Visuals/Axis/LabelProvider/LabelCache.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.labelCache = void 0;
+var Deleter_1 = require("../../../../Core/Deleter");
+var labelCacheByTextAndStyle = new Map();
+var styleCache = {};
+var lastStyleId = 0;
+var getStyleId = function (style) {
+    for (var key in styleCache) {
+        if (styleCache.hasOwnProperty(key)) {
+            var otherStyle = styleCache[key];
+            if (otherStyle) {
+                if (checkTextStyleEqual(style, otherStyle.style)) {
+                    otherStyle.uses++;
+                    return key;
+                }
+            }
+        }
+    }
+    lastStyleId++;
+    var newStyleId = lastStyleId.toString();
+    styleCache[newStyleId] = { style: style, uses: 1 };
+    return newStyleId;
+};
+var freeStyle = function (styleId) {
+    var style = styleCache[styleId];
+    if (style) {
+        style.uses--;
+        setTimeout(function () {
+            var styleToClear = styleCache[styleId];
+            if (styleToClear && styleToClear.uses === 0) {
+                clearCacheByStyle(styleId);
+            }
+        }, minAge);
+    }
+};
+var makeCacheKey = function (text, styleId) {
+    return "".concat(text, "|:|").concat(styleId);
+};
+var parseCacheKey = function (key) {
+    var sep = key.indexOf("|:|");
+    var text = key.substring(0, sep - 1);
+    var styleId = key.substring(sep + 3);
+    return { text: text, styleId: styleId };
+};
+var getLabel = function (text, styleId) {
+    var key = makeCacheKey(text, styleId);
+    var label = labelCacheByTextAndStyle.get(key);
+    if (label) {
+        label.lastUsed = Date.now();
+    }
+    return label;
+};
+var setLabel = function (text, styleId, label) {
+    var key = makeCacheKey(text, styleId);
+    // TODO should we worry about key collisions if using custom textures?
+    labelCacheByTextAndStyle.set(key, label);
+};
+var checkStyle = function (currentStyleId, newStyle) {
+    var currentStyle = styleCache[currentStyleId.toString()];
+    if (currentStyle) {
+        return checkTextStyleEqual(currentStyle.style, newStyle);
+    }
+    return false;
+};
+var clearCacheByStyle = function (styleId) {
+    for (var _i = 0, _a = Array.from(labelCacheByTextAndStyle.keys()); _i < _a.length; _i++) {
+        var keyStr = _a[_i];
+        var _b = parseCacheKey(keyStr), text = _b.text, keyStyleId = _b.styleId;
+        if (keyStyleId === styleId) {
+            labelCacheByTextAndStyle.delete(keyStr);
+        }
+    }
+};
+var maxSize = 100;
+var minAge = 1000 * 60;
+var lastUsed = 0;
+var getMaxSize = function () { return maxSize; };
+var setMaxSize = function (size) {
+    maxSize = size;
+};
+var getMinAge = function () { return minAge; };
+var setMinAge = function (ageInMs) {
+    minAge = ageInMs;
+};
+var pruneCache = function () {
+    var latest = Date.now() - minAge;
+    if (labelCacheByTextAndStyle.size > maxSize && lastUsed < latest) {
+        try {
+            // remove more than we need so we do this less.
+            var toRemove = (labelCacheByTextAndStyle.size - maxSize) * 2;
+            // Sort the items by LastUsed ascending
+            var labels = Array.from(labelCacheByTextAndStyle.entries());
+            labels.sort(function (a, b) { return a[1].lastUsed - b[1].lastUsed; });
+            // remove earliest
+            for (var index = 0; index < toRemove; index++) {
+                var _a = labels[index], key = _a[0], label = _a[1];
+                if (label.lastUsed < latest) {
+                    label.bitmapTexture = (0, Deleter_1.deleteSafe)(label.bitmapTexture);
+                    labelCacheByTextAndStyle.delete(key);
+                }
+                else if (index === 0) {
+                    lastUsed = label.lastUsed;
+                }
+            }
+        }
+        catch (err) {
+            console.warn(err);
+        }
+    }
+};
+var checkTextStyleEqual = function (style1, style2) {
+    return (style1.alignment === style2.alignment &&
+        style1.color === style2.color &&
+        style1.fontFamily === style2.fontFamily &&
+        style1.fontSize === style2.fontSize &&
+        style1.fontStyle === style2.fontStyle &&
+        style1.fontWeight === style2.fontWeight &&
+        ((style1.padding === undefined && style2.padding === undefined) || style1.padding.equals(style2.padding)) &&
+        style1.extras === style2.extras &&
+        style1.rotation === style2.rotation &&
+        style1.providerId === style2.providerId);
+};
+var resetCache = function () {
+    labelCacheByTextAndStyle.clear();
+    // tslint:disable-next-line: forin
+    for (var key in styleCache) {
+        delete styleCache[key];
+    }
+};
+/**
+ * A global cache for labels, used by all labelProviders, to reduce the amount of time spent creating label textures.
+ */
+exports.labelCache = {
+    /** Get an identifier for the given text style.  Returns an existing identifier if a matching style exists in the cache */
+    getStyleId: getStyleId,
+    /**
+     * Notify the cache that a style is no longer used.
+     * Linked labels are only deleted when there are no remaining uses, and then only after minAge has passed.
+     */
+    freeStyle: freeStyle,
+    /** Get a label from the cache.  Returns undefined if none found. */
+    getLabel: getLabel,
+    /** Add a label to the cache */
+    setLabel: setLabel,
+    /** Check if a text style matches the one for the given id */
+    checkStyle: checkStyle,
+    /** Get the maximum number of labels allowed to be stored in the cache.  Used when calling pruneCache */
+    getMaxSize: getMaxSize,
+    /** Set the maximum number of labels allowed to be stored in the cache.  Used when calling pruneCache */
+    setMaxSize: setMaxSize,
+    /** Get the minimum age (time since last used) of labels in the cache.
+     * This prevents recently used labels from being pruned, or removed when style is freed
+     */
+    getMinAge: getMinAge,
+    /** Set the minimum age (time since last used) of labels in the cache.
+     * This prevents recently used labels from being pruned, or removed when style is freed
+     */
+    setMinAge: setMinAge,
+    /** Remove old labels from the cache, if there are more than MaxSize.   */
+    pruneCache: pruneCache,
+    /** Completely clears and resets the cache.  Testing use only */
+    resetCache: resetCache
+};

package/Charting/Visuals/Axis/LabelProvider/LabelProvider.d.ts

@@ -95,7 +95,7 @@ export declare abstract class LabelProvider {
     applyFormat(value: string): string;
     toJSON(): {
         type: string;
-        options: Required<Pick<ILabelOptions, "labelFormat" | "labelPrecision" | "cursorLabelFormat" | "cursorLabelPrecision" | "labelPrefix" | "labelPostfix">>;
+        options: Required<Omit<ILabelOptions, never>>;
     };
     protected invalidateParent(): void;
 }

package/Charting/Visuals/Axis/LabelProvider/LabelProviderBase2D.d.ts

@@ -2,26 +2,57 @@ import { IDeletable } from "../../../../Core/IDeletable";
 import { TSRTexture } from "../../../../types/TSciChart";
 import { TextureManager, TTextureObject } from "../../TextureManager/TextureManager";
 import { TTextStyle } from "../AxisCore";
+import { TCachedLabelStyle } from "./LabelCache";
 import { ILabelOptions, LabelProvider } from "./LabelProvider";
-export declare type TLabelInfo = {
+export declare class LabelInfo {
     tick: number;
     text: string;
     bitmapTexture: TSRTexture;
     textureHeight: number;
     textureWidth: number;
     lastUsed: number;
-};
+    private subs;
+    constructor(tick: number, text: string, bitmapTexture: TSRTexture, textureHeight: number, textureWidth: number);
+    registerNotifier(callback: () => void): void;
+    textureUpdated(): void;
+}
 export interface ILabel2DOptions extends ILabelOptions {
     rotation?: number;
+    /**
+     * Experimental - set true to enable async label texture creation
+     * Can be set globally using SciChartDefaults.asyncLabels = true;
+     * When false getLabelTexture is used.  When true, getLabelTextureAsync is used.
+     */
+    asyncLabels?: boolean;
+    /**
+     * Whether to use cached labels from other axes that have the same style.
+     * You may need to set this false if you are overriding getLabelTexture or getLabelTextureAsync without setting a unique style.
+     */
+    useSharedCache?: boolean;
 }
 /**
  * The {@link LabelProviderBase2D} provides base functionality for 2D label providers, including caching of label textures
  */
 export declare abstract class LabelProviderBase2D extends LabelProvider implements IDeletable {
     useCache: boolean;
+    /** Whether to use cached labels from other axes that have the same style.
+     * You may need to set this false if you are overriding getLabelTexture without setting a unique style.
+     * Can be set globally using SciChartDefaults.  Currently default false.
+     */
+    useSharedCache: boolean;
+    /**
+     * Experimental - set true to enable async label texture creation
+     * Can be set globally using SciChartDefaults.  Currently default false.
+     */
+    asyncLabels: boolean;
     protected tickToText: Map<number, string>;
-    protected labelCacheByText: Map<string, TLabelInfo>;
-    private cachedLabelStyle;
+    /**
+     * This is the id for the text style used by this axis, as stored in the label cache. Cached labels are accessed by text and styleId.
+     * If you have useSharedCache = true and are overriding getLabelTexture or getLabelTextureAsync and do not ensure the style is unique,
+     * you might not get the labels you expect.
+     * You can either set useSharedCache = false, set this to some unique value, or override getCachedStyle
+     */
+    protected styleId: string;
     private rotationProperty;
     constructor(options?: ILabel2DOptions);
     get rotation(): number;
@@ -72,14 +103,33 @@ export declare abstract class LabelProviderBase2D extends LabelProvider implemen
      * @param labelStyle The style for the text
      * @returns A TTextureObject containing the bitmapTexture and the size
      */
+    getCachedLabelTexture(labelText: string, textureManager: TextureManager, labelStyle: TTextStyle): TTextureObject;
+    /**
+     * Create a texture for the given label text asynchronously. This method is called if asyncLabels is true, otherwise getLabelTexture is used.
+     * If overriding this method with useSharedCache = true, consider setting it false for this LabelProvider,
+     * otherwise other axes using the same style and text may see your custom texture. Alternatively you can override getCachedStyle or set styleId directly
+     */
+    getLabelTextureAsync(labelText: string, textureManager: TextureManager, labelStyle: TTextStyle): Promise<TTextureObject>;
+    /**
+     * Create a texture for the given label text. This method is called if asyncLabels is false, otherwise getLabelTextureAsync is used.
+     * If overriding this method with useSharedCache = true, consider setting it false for this LabelProvider,
+     * otherwise other axes using the same style and text may see your custom texture. Alternatively you can override getCachedStyle or set styleId directly
+     */
     getLabelTexture(labelText: string, textureManager: TextureManager, labelStyle: TTextStyle): TTextureObject;
     delete(): void;
-    checkTextStyleEqual(style1: TTextStyle, style2: TTextStyle): boolean;
     toJSON(): {
         type: string;
-        options: Required<Pick<ILabelOptions, "labelFormat" | "labelPrecision" | "cursorLabelFormat" | "cursorLabelPrecision" | "labelPrefix" | "labelPostfix">>;
+        options: Required<Omit<ILabelOptions, never>>;
     };
+    protected providerId: string;
+    /**
+     * This method creates the text style to be stored in the label cache.
+     * When useSharedCache = true, the label cache will generate a new styleId if this style does not match any existing style.
+     * Cached labels are accessed by text and styleId.
+     * If you are overriding getLabelTexture or getLabelTextureAsync and do not ensure the style is unique, you might not get the labels you expect.
+     * You can either set useSharedCache = false, override this and set the extras field in {@link TCachedLabelStyle}, or set styleId directly
+     */
+    protected getCachedStyle(): TCachedLabelStyle;
     protected clearCache(): void;
     protected invalidateParent(): void;
-    protected pruneCache(maxSize: number): void;
 }