zrender-nightly 5.5.0-dev.20221128 → 5.5.0-dev.20221129

package/lib/core/platform.js

@@ -39,8 +39,8 @@ export var platformApi = {
             else {
                 text = text || '';
                 font = font || DEFAULT_FONT;
-                var res = /^([0-9]*?)px$/.exec(font);
-                var fontSize = +(res && res[1]) || DEFAULT_FONT_SIZE;
+                var res = /(\d+)px/.exec(font);
+                var fontSize = res && +res[1] || DEFAULT_FONT_SIZE;
                 var width = 0;
                 if (font.indexOf('mono') >= 0) {
                     width = fontSize * text.length;

package/lib/core/util.d.ts

@@ -68,13 +68,20 @@ export declare function assert(condition: any, message?: string): void;
 export declare function trim(str: string): string;
 export declare function setAsPrimitive(obj: any): void;
 export declare function isPrimitive(obj: any): boolean;
+interface MapInterface<T, KEY extends string | number = string | number> {
+    delete(key: KEY): boolean;
+    has(key: KEY): boolean;
+    get(key: KEY): T | undefined;
+    set(key: KEY, value: T): this;
+    keys(): KEY[];
+    forEach(callback: (value: T, key: KEY) => void): void;
+}
 export declare class HashMap<T, KEY extends string | number = string | number> {
-    data: {
-        [key in KEY]: T;
-    };
+    data: MapInterface<T, KEY>;
     constructor(obj?: HashMap<T, KEY> | {
         [key in KEY]?: T;
     } | KEY[]);
+    hasKey(key: KEY): boolean;
     get(key: KEY): T;
     set(key: KEY, value: T): T;
     each<Context>(cb: (this: Context, value?: T, key?: KEY) => void, context?: Context): void;

package/lib/core/util.js

@@ -422,11 +422,48 @@ export function setAsPrimitive(obj) {
 export function isPrimitive(obj) {
     return obj[primitiveKey];
 }
+var MapPolyfill = (function () {
+    function MapPolyfill() {
+        this.data = {};
+    }
+    MapPolyfill.prototype["delete"] = function (key) {
+        var existed = this.has(key);
+        if (existed) {
+            delete this.data[key];
+        }
+        return existed;
+    };
+    MapPolyfill.prototype.has = function (key) {
+        return this.data.hasOwnProperty(key);
+    };
+    MapPolyfill.prototype.get = function (key) {
+        return this.data[key];
+    };
+    MapPolyfill.prototype.set = function (key, value) {
+        this.data[key] = value;
+        return this;
+    };
+    MapPolyfill.prototype.keys = function () {
+        return keys(this.data);
+    };
+    MapPolyfill.prototype.forEach = function (callback) {
+        var data = this.data;
+        for (var key in data) {
+            if (data.hasOwnProperty(key)) {
+                callback(data[key], key);
+            }
+        }
+    };
+    return MapPolyfill;
+}());
+var isNativeMapSupported = typeof Map === 'function';
+function maybeNativeMap() {
+    return (isNativeMapSupported ? new Map() : new MapPolyfill());
+}
 var HashMap = (function () {
     function HashMap(obj) {
-        this.data = {};
         var isArr = isArray(obj);
-        this.data = {};
+        this.data = maybeNativeMap();
         var thisMap = this;
         (obj instanceof HashMap)
             ? obj.each(visit)
@@ -435,24 +472,29 @@ var HashMap = (function () {
             isArr ? thisMap.set(value, key) : thisMap.set(key, value);
         }
     }
+    HashMap.prototype.hasKey = function (key) {
+        return this.data.has(key);
+    };
     HashMap.prototype.get = function (key) {
-        return this.data.hasOwnProperty(key) ? this.data[key] : null;
+        return this.data.get(key);
     };
     HashMap.prototype.set = function (key, value) {
-        return (this.data[key] = value);
+        this.data.set(key, value);
+        return value;
     };
     HashMap.prototype.each = function (cb, context) {
-        for (var key in this.data) {
-            if (this.data.hasOwnProperty(key)) {
-                cb.call(context, this.data[key], key);
-            }
-        }
+        this.data.forEach(function (value, key) {
+            cb.call(context, value, key);
+        });
     };
     HashMap.prototype.keys = function () {
-        return keys(this.data);
+        var keys = this.data.keys();
+        return isNativeMapSupported
+            ? Array.from(keys)
+            : keys;
     };
     HashMap.prototype.removeKey = function (key) {
-        delete this.data[key];
+        this.data["delete"](key);
     };
     return HashMap;
 }());

package/lib/svg/Painter.js

@@ -243,7 +243,7 @@ function createBackgroundVNode(width, height, backgroundColor, scope) {
         else {
             var _a = normalizeColor(backgroundColor), color = _a.color, opacity = _a.opacity;
             bgVNode.attrs.fill = color;
-            opacity < 1 && (bgVNode.attrs.fillOpacity = opacity);
+            opacity < 1 && (bgVNode.attrs['fill-opacity'] = opacity);
         }
     }
     return bgVNode;

package/lib/svg/graphic.js

@@ -108,11 +108,12 @@ export function brushSVGPath(el, scope) {
         builtinShpDef[0](shape, attrs, mul);
     }
     else {
+        var needBuildPath = !el.path || el.shapeChanged();
         if (!el.path) {
             el.createPathProxy();
         }
         var path = el.path;
-        if (el.shapeChanged()) {
+        if (needBuildPath) {
             path.beginPath();
             el.buildPath(path, el.shape);
             el.pathUpdated();

package/lib/zrender.d.ts

@@ -84,7 +84,7 @@ export declare function dispose(zr: ZRender): void;
 export declare function disposeAll(): void;
 export declare function getInstance(id: number): ZRender;
 export declare function registerPainter(name: string, Ctor: PainterBaseCtor): void;
-export declare const version = "5.5.0-dev.20221128";
+export declare const version = "5.5.0-dev.20221129";
 export interface ZRenderType extends ZRender {
 }
 export {};

package/lib/zrender.js

@@ -261,5 +261,5 @@ export function getInstance(id) {
 export function registerPainter(name, Ctor) {
     painterCtors[name] = Ctor;
 }
-export var version = '5.5.0-dev.20221128';
+export var version = '5.5.0-dev.20221129';
 ;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zrender-nightly",
-  "version": "5.5.0-dev.20221128",
+  "version": "5.5.0-dev.20221129",
   "description": "A lightweight graphic library providing 2d draw for Apache ECharts",
   "keywords": [
     "canvas",

package/src/core/platform.ts

@@ -75,8 +75,8 @@ export const platformApi: Platform = {
                 text = text || '';
                 font = font || DEFAULT_FONT;
                 // Use font size if there is no other method can be used.
-                const res = /^([0-9]*?)px$/.exec(font);
-                const fontSize = +(res && res[1]) || DEFAULT_FONT_SIZE;
+                const res = /(\d+)px/.exec(font);
+                const fontSize = res && +res[1] || DEFAULT_FONT_SIZE;
                 let width = 0;
                 if (font.indexOf('mono') >= 0) {   // is monospace
                     width = fontSize * text.length;
@@ -103,7 +103,7 @@ export const platformApi: Platform = {
 
 export function setPlatformAPI(newPlatformApis: Partial<Platform>) {
     for (let key in platformApi) {
-        // Don't assign unkown methods.
+        // Don't assign unknown methods.
         if ((newPlatformApis as any)[key]) {
             (platformApi as any)[key] = (newPlatformApis as any)[key];
         }

package/src/core/util.ts

@@ -653,20 +653,72 @@ export function isPrimitive(obj: any): boolean {
     return obj[primitiveKey];
 }
 
+interface MapInterface<T, KEY extends string | number = string | number> {
+    delete(key: KEY): boolean;
+    has(key: KEY): boolean;
+    get(key: KEY): T | undefined;
+    set(key: KEY, value: T): this;
+    keys(): KEY[];
+    forEach(callback: (value: T, key: KEY) => void): void;
+}
+
+class MapPolyfill<T, KEY extends string | number = string | number> implements MapInterface<T, KEY> {
+    private data: Record<KEY, T> = {} as Record<KEY, T>;
+
+    delete(key: KEY): boolean {
+        const existed = this.has(key);
+        if (existed) {
+            delete this.data[key];
+        }
+        return existed;
+    }
+    has(key: KEY): boolean {
+        return this.data.hasOwnProperty(key);
+    }
+    get(key: KEY): T | undefined {
+        return this.data[key];
+    }
+    set(key: KEY, value: T): this {
+        this.data[key] = value;
+        return this;
+    }
+    keys(): KEY[] {
+        return keys(this.data);
+    }
+    forEach(callback: (value: T, key: KEY) => void): void {
+        // This is a potential performance bottleneck, see details in
+        // https://github.com/ecomfe/zrender/issues/965, however it is now
+        // less likely to occur as we default to native maps when possible.
+        const data = this.data;
+        for (const key in data) {
+            if (data.hasOwnProperty(key)) {
+                callback(data[key], key);
+            }
+        }
+    }
+}
+
+// We want to use native Map if it is available, but we do not want to polyfill the global scope
+// in case users ship their own polyfills or patch the native map object in any way.
+const isNativeMapSupported = typeof Map === 'function';
+function maybeNativeMap<T, KEY extends string | number = string | number>(): MapInterface<T, KEY> {
+    // Map may be a native class if we are running in an ES6 compatible environment.
+    // eslint-disable-next-line
+    return (isNativeMapSupported ? new Map<KEY, T>() : new MapPolyfill<T, KEY>()) as MapInterface<T, KEY>;
+}
 
 /**
  * @constructor
- * @param {Object} obj Only apply `ownProperty`.
+ * @param {Object} obj
  */
 export class HashMap<T, KEY extends string | number = string | number> {
-
-    data: {[key in KEY]: T} = {} as {[key in KEY]: T};
+    data: MapInterface<T, KEY>
 
     constructor(obj?: HashMap<T, KEY> | { [key in KEY]?: T } | KEY[]) {
         const isArr = isArray(obj);
         // Key should not be set on this, otherwise
         // methods get/set/... may be overrided.
-        this.data = {} as {[key in KEY]: T};
+        this.data = maybeNativeMap<T, KEY>();
         const thisMap = this;
 
         (obj instanceof HashMap)
@@ -678,16 +730,18 @@ export class HashMap<T, KEY extends string | number = string | number> {
         }
     }
 
-    // Do not provide `has` method to avoid defining what is `has`.
-    // (We usually treat `null` and `undefined` as the same, different
-    // from ES6 Map).
+    // `hasKey` instead of `has` for potential misleading.
+    hasKey(key: KEY): boolean {
+        return this.data.has(key);
+    }
     get(key: KEY): T {
-        return this.data.hasOwnProperty(key) ? this.data[key] : null;
+        return this.data.get(key);
     }
     set(key: KEY, value: T): T {
         // Comparing with invocation chaining, `return value` is more commonly
         // used in this case: `const someVal = map.set('a', genVal());`
-        return (this.data[key] = value);
+        this.data.set(key, value);
+        return value;
     }
     // Although util.each can be performed on this hashMap directly, user
     // should not use the exposed keys, who are prefixed.
@@ -695,18 +749,20 @@ export class HashMap<T, KEY extends string | number = string | number> {
         cb: (this: Context, value?: T, key?: KEY) => void,
         context?: Context
     ) {
-        for (let key in this.data) {
-            if (this.data.hasOwnProperty(key)) {
-                cb.call(context, this.data[key], key);
-            }
-        }
+        this.data.forEach((value, key) => {
+            cb.call(context, value, key);
+        });
     }
     keys(): KEY[] {
-        return keys(this.data);
+        const keys = this.data.keys();
+        return isNativeMapSupported
+            // Native map returns an iterator so we need to convert it to an array
+            ? Array.from(keys)
+            : keys;
     }
     // Do not use this method if performance sensitive.
-    removeKey(key: KEY) {
-        delete this.data[key];
+    removeKey(key: KEY): void {
+        this.data.delete(key);
     }
 }
 

package/src/svg/Painter.ts

@@ -393,7 +393,7 @@ function createBackgroundVNode(
         else {
             const { color, opacity } = normalizeColor(backgroundColor);
             bgVNode.attrs.fill = color;
-            opacity < 1 && (bgVNode.attrs.fillOpacity = opacity);
+            opacity < 1 && (bgVNode.attrs['fill-opacity'] = opacity);
         }
     }
     return bgVNode;

package/src/svg/graphic.ts

@@ -170,12 +170,13 @@ export function brushSVGPath(el: Path, scope: BrushScope) {
         builtinShpDef[0](shape, attrs, mul);
     }
     else {
+        const needBuildPath = !el.path || el.shapeChanged();
         if (!el.path) {
             el.createPathProxy();
         }
         const path = el.path;
 
-        if (el.shapeChanged()) {
+        if (needBuildPath) {
             path.beginPath();
             el.buildPath(path, el.shape);
             el.pathUpdated();

package/src/zrender.ts

@@ -485,7 +485,7 @@ export function registerPainter(name: string, Ctor: PainterBaseCtor) {
 /**
  * @type {string}
  */
-export const version = '5.5.0-dev.20221128';
+export const version = '5.5.0-dev.20221129';
 
 
 export interface ZRenderType extends ZRender {};