scichart 2.0.2146 → 2.0.2179

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

package/Charting/Visuals/Axis/LabelProvider/LabelProviderBase2D.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 __());
@@ -23,26 +25,87 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LabelProviderBase2D = void 0;
+exports.LabelProviderBase2D = exports.LabelInfo = void 0;
 var app_1 = require("../../../../constants/app");
-var Deleter_1 = require("../../../../Core/Deleter");
+var guid_1 = require("../../../../utils/guid");
+var TextureWorker_1 = require("../../../Services/Workers/TextureWorker");
+var SciChartDefaults_1 = require("../../SciChartDefaults");
 var TextureManager_1 = require("../../TextureManager/TextureManager");
+var LabelCache_1 = require("./LabelCache");
 var LabelProvider_1 = require("./LabelProvider");
+var LabelInfo = /** @class */ (function () {
+    function LabelInfo(tick, text, bitmapTexture, textureHeight, textureWidth) {
+        this.subs = [];
+        this.tick = tick;
+        this.text = text;
+        this.bitmapTexture = bitmapTexture;
+        this.textureHeight = textureHeight;
+        this.textureWidth = textureWidth;
+        this.lastUsed = Date.now();
+    }
+    LabelInfo.prototype.registerNotifier = function (callback) {
+        this.subs.push(callback);
+    };
+    LabelInfo.prototype.textureUpdated = function () {
+        this.subs.forEach(function (notifier) { return notifier(); });
+        this.subs = [];
+    };
+    return LabelInfo;
+}());
+exports.LabelInfo = LabelInfo;
 /**
  * The {@link LabelProviderBase2D} provides base functionality for 2D label providers, including caching of label textures
  */
+// tslint:disable-next-line: max-classes-per-file
 var LabelProviderBase2D = /** @class */ (function (_super) {
     __extends(LabelProviderBase2D, _super);
     function LabelProviderBase2D(options) {
-        var _a;
+        var _a, _b, _c;
         var _this = _super.call(this, options) || this;
         _this.useCache = !app_1.IS_TEST_ENV;
         _this.tickToText = new Map();
-        _this.labelCacheByText = new Map();
-        _this.cachedLabelStyle = null;
         _this.rotationProperty = 0;
+        _this.providerId = (0, guid_1.generateGuid)();
         _this.rotationProperty = (_a = options === null || options === void 0 ? void 0 : options.rotation) !== null && _a !== void 0 ? _a : _this.rotationProperty;
+        _this.asyncLabels = (_b = options === null || options === void 0 ? void 0 : options.asyncLabels) !== null && _b !== void 0 ? _b : SciChartDefaults_1.SciChartDefaults.asyncLabels;
+        _this.useSharedCache = (_c = options === null || options === void 0 ? void 0 : options.useSharedCache) !== null && _c !== void 0 ? _c : SciChartDefaults_1.SciChartDefaults.useSharedCache;
         return _this;
     }
     Object.defineProperty(LabelProviderBase2D.prototype, "rotation", {
@@ -50,8 +113,10 @@ var LabelProviderBase2D = /** @class */ (function (_super) {
             return this.rotationProperty;
         },
         set: function (value) {
-            this.rotationProperty = value;
-            this.invalidateParent();
+            if (this.rotationProperty !== value) {
+                this.rotationProperty = value;
+                this.invalidateParent();
+            }
         },
         enumerable: false,
         configurable: true
@@ -63,12 +128,12 @@ var LabelProviderBase2D = /** @class */ (function (_super) {
     LabelProviderBase2D.prototype.getLabels = function (majorTicks) {
         var _this = this;
         var axis = this.parentAxis;
-        if (!this.cachedLabelStyle) {
-            this.cachedLabelStyle = __assign({}, axis.dpiAdjustedLabelStyle);
+        if (!this.styleId) {
+            this.styleId = LabelCache_1.labelCache.getStyleId(this.getCachedStyle());
         }
-        else if (!this.checkTextStyleEqual(this.cachedLabelStyle, axis.dpiAdjustedLabelStyle)) {
+        else if (!LabelCache_1.labelCache.checkStyle(this.styleId, this.getCachedStyle())) {
             this.delete();
-            this.cachedLabelStyle = __assign({}, axis.dpiAdjustedLabelStyle);
+            this.styleId = LabelCache_1.labelCache.getStyleId(this.getCachedStyle());
         }
         var ticks = majorTicks;
         if (this.parentAxis.isCategoryAxis) {
@@ -82,20 +147,21 @@ var LabelProviderBase2D = /** @class */ (function (_super) {
                 var cachedLabelText = this.tickToText.get(tick);
                 var cachedLabel = void 0;
                 if (cachedLabelText) {
-                    cachedLabel = this.labelCacheByText.get(cachedLabelText);
+                    cachedLabel = LabelCache_1.labelCache.getLabel(cachedLabelText, this.styleId);
                     labels.push(cachedLabelText);
-                    cachedLabel.lastUsed = Date.now();
                 }
                 else {
                     var text = this.formatLabel(tick);
-                    var texture = this.getLabelTexture(text, axis.axisRenderer.textureManager, axis.dpiAdjustedLabelStyle);
-                    cachedLabel = __assign(__assign({ tick: tick, text: text }, texture), { lastUsed: Date.now() });
                     this.tickToText.set(tick, text);
-                    this.labelCacheByText.set(text, cachedLabel);
+                    var texture = this.getCachedLabelTexture(text, axis.axisRenderer.textureManager, axis.dpiAdjustedLabelStyle);
+                    if (texture.textureWidth !== null) {
+                        cachedLabel = new LabelInfo(tick, text, texture.bitmapTexture, texture.textureHeight, texture.textureWidth);
+                        LabelCache_1.labelCache.setLabel(text, this.styleId, cachedLabel);
+                    }
                     labels.push(text);
                 }
             }
-            this.pruneCache(majorTicks.length * 2);
+            LabelCache_1.labelCache.pruneCache();
         }
         else {
             labels = ticks.map(function (t) { return _this.formatLabel(t); });
@@ -111,10 +177,10 @@ var LabelProviderBase2D = /** @class */ (function (_super) {
      */
     LabelProviderBase2D.prototype.getLabelHeight = function (ctx, labelText, labelStyle) {
         if (this.rotationProperty % 90 === 0 || this.parentAxis.isHorizontalAxis) {
-            var cachedLabel = this.labelCacheByText.get(labelText);
-            if (!cachedLabel) {
+            var cachedLabel = LabelCache_1.labelCache.getLabel(labelText, this.styleId);
+            if (!cachedLabel || !cachedLabel.textureHeight) {
                 var fontSize = labelStyle.fontSize, padding = labelStyle.padding;
-                return TextureManager_1.measureTextHeight(fontSize) + (padding === null || padding === void 0 ? void 0 : padding.top) + (padding === null || padding === void 0 ? void 0 : padding.bottom);
+                return (0, TextureManager_1.measureTextHeight)(fontSize) + (padding === null || padding === void 0 ? void 0 : padding.top) + (padding === null || padding === void 0 ? void 0 : padding.bottom);
             }
             return cachedLabel.textureHeight;
         }
@@ -131,10 +197,10 @@ var LabelProviderBase2D = /** @class */ (function (_super) {
      */
     LabelProviderBase2D.prototype.getLabelWidth = function (ctx, labelText, labelStyle) {
         if (this.rotationProperty % 90 === 0 || !this.parentAxis.isHorizontalAxis) {
-            var cachedlabel = this.labelCacheByText.get(labelText);
-            if (!cachedlabel) {
+            var cachedlabel = LabelCache_1.labelCache.getLabel(labelText, this.styleId);
+            if (!cachedlabel || !cachedlabel.textureWidth) {
                 var padding = labelStyle.padding;
-                return TextureManager_1.measureTextWidth(ctx, labelText) + padding.left + padding.right;
+                return (0, TextureManager_1.measureTextWidth)(ctx, labelText) + padding.left + padding.right;
             }
             return cachedlabel.textureWidth;
         }
@@ -183,57 +249,110 @@ var LabelProviderBase2D = /** @class */ (function (_super) {
      * @param labelStyle The style for the text
      * @returns A TTextureObject containing the bitmapTexture and the size
      */
-    LabelProviderBase2D.prototype.getLabelTexture = function (labelText, textureManager, labelStyle) {
-        var cachedLabel = this.labelCacheByText.get(labelText);
+    LabelProviderBase2D.prototype.getCachedLabelTexture = function (labelText, textureManager, labelStyle) {
+        var _this = this;
+        var _a;
+        var cachedLabel = LabelCache_1.labelCache.getLabel(labelText, this.styleId);
         if (cachedLabel) {
+            if (cachedLabel.textureWidth === undefined) {
+                // Log when this texture request was made. Kill and restart if too old
+                // Make sure this chart redraws if it is waiting on a label that was requested by a different chart
+                cachedLabel.registerNotifier(function () { return _super.prototype.invalidateParent.call(_this); });
+            }
             return {
-                textureWidth: cachedLabel.textureWidth,
+                textureWidth: (_a = cachedLabel.textureWidth) !== null && _a !== void 0 ? _a : null,
                 textureHeight: cachedLabel.textureHeight,
                 bitmapTexture: cachedLabel.bitmapTexture
             };
         }
+        else if (this.asyncLabels) {
+            // Capture the styleId as it might have changed by the time the result comes in.
+            var callBackStyleId_1 = this.styleId;
+            this.getLabelTextureAsync(labelText, textureManager, labelStyle).then(function (result) {
+                var cached = LabelCache_1.labelCache.getLabel(labelText, callBackStyleId_1);
+                // This may not exist if the target chart has been deleted already.
+                if (cached) {
+                    cached.textureHeight = result.textureHeight;
+                    cached.textureWidth = result.textureWidth;
+                    cached.bitmapTexture = result.bitmapTexture;
+                    cached.textureUpdated();
+                    // this.invalidateParent also clears cache, which we don't want here.
+                    _super.prototype.invalidateParent.call(_this);
+                }
+            });
+            return {
+                textureWidth: undefined,
+                textureHeight: undefined,
+                bitmapTexture: undefined
+            };
+        }
         else {
-            return textureManager.createTextTexture([labelText], labelStyle, this.rotationProperty);
+            return this.getLabelTexture(labelText, textureManager, labelStyle);
         }
     };
+    /**
+     * 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
+     */
+    LabelProviderBase2D.prototype.getLabelTextureAsync = function (labelText, textureManager, labelStyle) {
+        return __awaiter(this, void 0, void 0, function () {
+            var image;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!TextureWorker_1.textureWorker.isActive) return [3 /*break*/, 2];
+                        return [4 /*yield*/, TextureWorker_1.textureWorker.measureAndGetImageData([labelText], labelStyle, this.rotationProperty)];
+                    case 1:
+                        image = _a.sent();
+                        return [2 /*return*/, textureManager.createTextureFromImageData(image.imageData, image.textureWidth, image.textureHeight)];
+                    case 2: return [2 /*return*/, this.getLabelTexture(labelText, textureManager, labelStyle)];
+                }
+            });
+        });
+    };
+    /**
+     * 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
+     */
+    LabelProviderBase2D.prototype.getLabelTexture = function (labelText, textureManager, labelStyle) {
+        return textureManager.createTextTexture([labelText], labelStyle, this.rotationProperty);
+    };
     LabelProviderBase2D.prototype.delete = function () {
-        var labels = Array.from(this.labelCacheByText.values());
-        for (var _i = 0, labels_1 = labels; _i < labels_1.length; _i++) {
-            var label = labels_1[_i];
-            try {
-                label.bitmapTexture = Deleter_1.deleteSafe(label.bitmapTexture);
-            }
-            catch (err) { }
+        if (this.styleId) {
+            LabelCache_1.labelCache.freeStyle(this.styleId);
         }
         this.tickToText.clear();
-        this.labelCacheByText.clear();
-        this.cachedLabelStyle = null;
-    };
-    LabelProviderBase2D.prototype.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.equals(style2.padding));
+        this.styleId = null;
     };
     LabelProviderBase2D.prototype.toJSON = function () {
         var json = _super.prototype.toJSON.call(this);
         var options = {
-            rotation: this.rotation
+            rotation: this.rotation,
+            asyncLabels: this.asyncLabels,
+            useSharedCache: this.useSharedCache
         };
         Object.assign(json.options, options);
         return json;
     };
+    /**
+     * 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
+     */
+    LabelProviderBase2D.prototype.getCachedStyle = function () {
+        var axis = this.parentAxis;
+        return __assign(__assign({}, axis.dpiAdjustedLabelStyle), { rotation: this.rotation, providerId: this.useSharedCache ? undefined : this.providerId });
+    };
     LabelProviderBase2D.prototype.clearCache = function () {
         if (this.useCache) {
             // Clear cache if property changed
-            var labels = Array.from(this.labelCacheByText.values());
-            for (var index = 0; index < this.labelCacheByText.size; index++) {
-                var element = labels[index];
-                element.bitmapTexture = Deleter_1.deleteSafe(element.bitmapTexture);
-                this.labelCacheByText.delete(element.text);
+            if (this.styleId) {
+                LabelCache_1.labelCache.freeStyle(this.styleId);
+                this.styleId = undefined;
             }
             this.tickToText.clear();
         }
@@ -242,28 +361,6 @@ var LabelProviderBase2D = /** @class */ (function (_super) {
         this.clearCache();
         _super.prototype.invalidateParent.call(this);
     };
-    LabelProviderBase2D.prototype.pruneCache = function (maxSize) {
-        if (this.labelCacheByText.size > maxSize) {
-            // remove more than we need so we do this less.
-            var toRemove = (maxSize - this.labelCacheByText.size) * 2;
-            // Sort the items by LastUsed ascending
-            var labels = Array.from(this.labelCacheByText.values());
-            labels.sort(function (a, b) { return a.lastUsed - b.lastUsed; });
-            var tickMap = Array.from(this.tickToText.entries());
-            // remove earliest
-            for (var index = 0; index < toRemove; index++) {
-                var element = labels[index];
-                element.bitmapTexture = Deleter_1.deleteSafe(element.bitmapTexture);
-                this.labelCacheByText.delete(element.text);
-                for (var _i = 0, tickMap_1 = tickMap; _i < tickMap_1.length; _i++) {
-                    var entry = tickMap_1[_i];
-                    if (entry[1] === element.text) {
-                        this.tickToText.delete(entry[0]);
-                    }
-                }
-            }
-        }
-    };
     return LabelProviderBase2D;
 }(LabelProvider_1.LabelProvider));
 exports.LabelProviderBase2D = LabelProviderBase2D;

package/Charting/Visuals/Axis/LabelProvider/LogarithmicLabelProvider.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 __());
@@ -42,8 +44,8 @@ var LogarithmicLabelProvider = /** @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.Scientific, labelPrecision: (_b = options === null || options === void 0 ? void 0 : options.labelPrecision) !== null && _b !== void 0 ? _b : 1 }, options)) || this;
         _this.formatLabelProperty = function (dataValue) {
             return _this.numericFormat === NumericFormat_1.ENumericFormat.Scientific
-                ? _this.applyFormat(number_1.toScientific(dataValue, _this.precision, _this.logarithmicBase))
-                : _this.applyFormat(number_1.formatNumber(dataValue, _this.numericFormat, _this.precision));
+                ? _this.applyFormat((0, number_1.toScientific)(dataValue, _this.precision, _this.logarithmicBase))
+                : _this.applyFormat((0, number_1.formatNumber)(dataValue, _this.numericFormat, _this.precision));
         };
         return _this;
     }