@syncfusion/ej2-maps 31.2.2 → 31.2.12

package/dist/es6/ej2-maps.es2015.js

@@ -6363,35 +6363,35 @@ class LayerPanel {
         }
         this.rectBounds = null;
         const shapeSettings = this.currentLayer.shapeSettings;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        Array.prototype.forEach.call(renderData, (geometryData) => {
-            if (!isNullOrUndefined(geometryData['geometry']) || !isNullOrUndefined(geometryData['coordinates'])) {
-                const type = !isNullOrUndefined(geometryData['geometry']) ? geometryData['geometry']['type'] : geometryData['type'];
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const coords = !isNullOrUndefined(geometryData['geometry']) ? geometryData['geometry']['coordinates'] :
-                    geometryData['coordinates'];
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const data = geometryData['geometry'];
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        for (let r = 0; r < renderData.length; r++) {
+            const geometryData = renderData[r];
+            const geom = geometryData['geometry'];
+            const hasGeom = !isNullOrUndefined(geom);
+            const hasCoords = !isNullOrUndefined(geometryData['coordinates']);
+            if (hasGeom || hasCoords) {
+                const type = hasGeom ? geom['type'] : geometryData['type'];
+                const coords = hasGeom ? geom['coordinates'] : geometryData['coordinates'];
+                const data = geom;
                 const properties = geometryData['properties'];
                 this.generatePoints(type, coords, data, properties);
             }
-        });
+        }
         this.currentLayer.rectBounds = this.rectBounds;
         if (isNullOrUndefined(this.mapObject.baseMapRectBounds) && this.currentLayer.isBaseLayer) {
             this.mapObject.baseMapRectBounds = this.rectBounds;
         }
         const colors = (!isNullOrUndefined(shapeSettings.palette) && shapeSettings.palette.length > 1) ?
             shapeSettings.palette : getShapeColor(this.mapObject.theme);
+        const areaRect = this.mapObject.mapAreaRect;
         const labelTemplateEle = createElement('div', {
             id: this.mapObject.element.id + '_LayerIndex_' + layerIndex + '_Label_Template_Group',
             className: this.mapObject.element.id + '_template'
         });
         labelTemplateEle.style.cssText = 'pointer-events: none; overflow: hidden; position: absolute;' +
-            'top:' + this.mapObject.mapAreaRect.y + 'px;' +
-            'left:' + this.mapObject.mapAreaRect.x + 'px;' +
-            'height:' + this.mapObject.mapAreaRect.height + 'px;' +
-            'width:' + this.mapObject.mapAreaRect.width + 'px;';
+            'top:' + areaRect.y + 'px;' +
+            'left:' + areaRect.x + 'px;' +
+            'height:' + areaRect.height + 'px;' +
+            'width:' + areaRect.width + 'px;';
         if (this.currentLayer.layerData.length !== 0) {
             for (let i = 0; i < this.currentLayer.layerData.length; i++) {
                 let k;
@@ -6436,11 +6436,12 @@ class LayerPanel {
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     this.currentLayer.dataSource, currentShapeData['property'], this.currentLayer.shapeDataPath, this.currentLayer.shapePropertyPath, this.currentLayer);
                     if (k !== null) {
-                        if (this.currentLayer.dataSource[k][shapeSettings.borderColorValuePath]) {
-                            borderValue.color = this.currentLayer.dataSource[k][shapeSettings.borderColorValuePath];
+                        const currentDataSource = this.currentLayer.dataSource[k];
+                        if (currentDataSource[shapeSettings.borderColorValuePath]) {
+                            borderValue.color = currentDataSource[shapeSettings.borderColorValuePath];
                         }
-                        if (this.currentLayer.dataSource[k][shapeSettings.borderWidthValuePath]) {
-                            borderValue.width = this.currentLayer.dataSource[k][shapeSettings.borderWidthValuePath];
+                        if (currentDataSource[shapeSettings.borderWidthValuePath]) {
+                            borderValue.width = currentDataSource[shapeSettings.borderWidthValuePath];
                         }
                     }
                 }
@@ -6503,17 +6504,26 @@ class LayerPanel {
                     switch (drawingType) {
                         case 'Polygon':
                             if (!currentShapeData['_isMultiPolygon']) {
-                                path += 'M' + (currentShapeData[0]['point']['x']) + ' ' + (currentShapeData[0]['point']['y']);
                                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                                currentShapeData.map((shapeData) => {
-                                    path += ' L ' + (shapeData['point']['x']) + ' ' + (shapeData['point']['y']);
-                                });
+                                const shapeData = currentShapeData;
+                                if (shapeData.length > 0) {
+                                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                    const firstPoint = shapeData[0]['point'];
+                                    const pathSegments = ['M', String(firstPoint['x']), String(firstPoint['y'])];
+                                    for (let index = 0; index < shapeData.length; index++) {
+                                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                        const point = shapeData[index]['point'];
+                                        pathSegments.push('L', String(point['x']), String(point['y']));
+                                    }
+                                    pathSegments.push('z');
+                                    path = pathSegments.join(' ');
+                                }
                             }
                             else {
                                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                                 path = this.generateMultiPolygonPath(currentShapeData);
+                                path += ' z ';
                             }
-                            path += ' z ';
                             if (path.length > 3) {
                                 pathOptions = new PathOption(shapeID, eventArgs.fill, eventArgs.border.width, eventArgs.border.color, opacity, eventArgs.border.opacity, shapeSettings.dashArray, path);
                                 pathEle = this.mapObject.renderer.drawPath(pathOptions);
@@ -6732,19 +6742,21 @@ class LayerPanel {
      */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     generateMultiPolygonPath(currentShapeData) {
-        let path = '';
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let shape;
-        for (let j = 0; j < currentShapeData.length; j++) {
-            path += 'M' + (currentShapeData[j][0]['point']['x']) + ' ' + (currentShapeData[j][0]['point']['y']);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            shape = currentShapeData[j];
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            shape.map((shapeData) => {
-                path += ' L ' + (shapeData['point']['x']) + ' ' + (shapeData['point']['y']);
-            });
+        const parts = [];
+        for (const shape of currentShapeData) {
+            if (!shape || shape.length === 0) {
+                continue;
+            }
+            const startX = shape[0].point.x;
+            const startY = shape[0].point.y;
+            parts.push(`M${startX} ${startY}`);
+            for (let i = 1; i < shape.length; i++) {
+                const x = shape[i].point.x;
+                const y = shape[i].point.y;
+                parts.push(` L ${x} ${y}`);
+            }
         }
-        return path;
+        return parts.join(' ');
     }
     /**
      * To render bubble.
@@ -7068,32 +7080,51 @@ class LayerPanel {
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     calculatePolygonBox(coordinates) {
+        // Use a simple for-loop, cache frequent lookups, and update rectBounds once
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const newData = [];
         const bounds = this.mapObject.baseMapBounds;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        coordinates.map((currentPoint) => {
+        const lonMin = bounds.longitude.min;
+        const lonMax = bounds.longitude.max;
+        const latMin = bounds.latitude.min;
+        const latMax = bounds.latitude.max;
+        let minX;
+        let minY;
+        let maxX;
+        let maxY;
+        for (let i = 0; i < coordinates.length; i++) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const currentPoint = coordinates[i];
             const latitude = currentPoint[1];
             const longitude = currentPoint[0];
-            if ((longitude >= bounds.longitude.min && longitude <= bounds.longitude.max)
-                && (latitude >= bounds.latitude.min && latitude <= bounds.latitude.max)) {
+            if (longitude >= lonMin && longitude <= lonMax && latitude >= latMin && latitude <= latMax) {
                 const point = convertGeoToPoint(latitude, longitude, this.currentFactor, this.currentLayer, this.mapObject);
-                if (isNullOrUndefined(this.rectBounds)) {
-                    this.rectBounds = { min: { x: point.x, y: point.y }, max: { x: point.x, y: point.y } };
+                if (minX === undefined) {
+                    minX = maxX = point.x;
+                    minY = maxY = point.y;
                 }
                 else {
-                    this.rectBounds['min']['x'] = Math.min(this.rectBounds['min']['x'], point.x);
-                    this.rectBounds['min']['y'] = Math.min(this.rectBounds['min']['y'], point.y);
-                    this.rectBounds['max']['x'] = Math.max(this.rectBounds['max']['x'], point.x);
-                    this.rectBounds['max']['y'] = Math.max(this.rectBounds['max']['y'], point.y);
-                }
-                newData.push({
-                    point: point,
-                    lat: latitude,
-                    lng: longitude
-                });
+                    // Update local bounds only
+                    minX = Math.min(minX, point.x);
+                    minY = Math.min(minY, point.y);
+                    maxX = Math.max(maxX, point.x);
+                    maxY = Math.max(maxY, point.y);
+                }
+                newData.push({ point: point, lat: latitude, lng: longitude });
             }
-        });
+        }
+        // Apply the accumulated bounds once to reduce repeated property access
+        if (newData.length) {
+            if (isNullOrUndefined(this.rectBounds)) {
+                this.rectBounds = { min: { x: minX, y: minY }, max: { x: maxX, y: maxY } };
+            }
+            else {
+                this.rectBounds.min.x = Math.min(this.rectBounds.min.x, minX);
+                this.rectBounds.min.y = Math.min(this.rectBounds.min.y, minY);
+                this.rectBounds.max.x = Math.max(this.rectBounds.max.x, maxX);
+                this.rectBounds.max.y = Math.max(this.rectBounds.max.y, maxY);
+            }
+        }
         return newData;
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any