@syncfusion/ej2-maps 31.2.2 → 32.1.19

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

@@ -6618,35 +6618,40 @@ var LayerPanel = /** @__PURE__ @class */ (function () {
         }
         this.rectBounds = null;
         var shapeSettings = this.currentLayer.shapeSettings;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        Array.prototype.forEach.call(renderData, function (geometryData) {
-            if (!isNullOrUndefined(geometryData['geometry']) || !isNullOrUndefined(geometryData['coordinates'])) {
-                var type = !isNullOrUndefined(geometryData['geometry']) ? geometryData['geometry']['type'] : geometryData['type'];
+        for (var r = 0; r < renderData.length; r++) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            var geometryData = renderData[r];
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            var geom = geometryData['geometry'];
+            var hasGeom = !isNullOrUndefined(geom);
+            var hasCoords = !isNullOrUndefined(geometryData['coordinates']);
+            if (hasGeom || hasCoords) {
+                var type = hasGeom ? geom['type'] : geometryData['type'];
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                var coords = !isNullOrUndefined(geometryData['geometry']) ? geometryData['geometry']['coordinates'] :
-                    geometryData['coordinates'];
+                var coords = hasGeom ? geom['coordinates'] : geometryData['coordinates'];
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                var data = geometryData['geometry'];
+                var data = geom;
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 var properties = geometryData['properties'];
-                _this.generatePoints(type, coords, data, 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;
         }
         var colors = (!isNullOrUndefined(shapeSettings.palette) && shapeSettings.palette.length > 1) ?
             shapeSettings.palette : getShapeColor(this.mapObject.theme);
+        var areaRect = this.mapObject.mapAreaRect;
         var 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) {
             var _loop_1 = function (i) {
                 var k = void 0;
@@ -6691,11 +6696,13 @@ var LayerPanel = /** @__PURE__ @class */ (function () {
                     // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     this_1.currentLayer.dataSource, currentShapeData['property'], this_1.currentLayer.shapeDataPath, this_1.currentLayer.shapePropertyPath, this_1.currentLayer);
                     if (k !== null) {
-                        if (this_1.currentLayer.dataSource[k][shapeSettings.borderColorValuePath]) {
-                            borderValue.color = this_1.currentLayer.dataSource[k][shapeSettings.borderColorValuePath];
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        var currentDataSource = this_1.currentLayer.dataSource[k];
+                        if (currentDataSource[shapeSettings.borderColorValuePath]) {
+                            borderValue.color = currentDataSource[shapeSettings.borderColorValuePath];
                         }
-                        if (this_1.currentLayer.dataSource[k][shapeSettings.borderWidthValuePath]) {
-                            borderValue.width = this_1.currentLayer.dataSource[k][shapeSettings.borderWidthValuePath];
+                        if (currentDataSource[shapeSettings.borderWidthValuePath]) {
+                            borderValue.width = currentDataSource[shapeSettings.borderWidthValuePath];
                         }
                     }
                 }
@@ -6758,17 +6765,26 @@ var LayerPanel = /** @__PURE__ @class */ (function () {
                     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(function (shapeData) {
-                                    path += ' L ' + (shapeData['point']['x']) + ' ' + (shapeData['point']['y']);
-                                });
+                                var shapeData = currentShapeData;
+                                if (shapeData.length > 0) {
+                                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                    var firstPoint = shapeData[0]['point'];
+                                    var pathSegments = ['M', String(firstPoint['x']), String(firstPoint['y'])];
+                                    for (var index = 0; index < shapeData.length; index++) {
+                                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                                        var 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);
@@ -6996,19 +7012,22 @@ var LayerPanel = /** @__PURE__ @class */ (function () {
      */
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     LayerPanel.prototype.generateMultiPolygonPath = function (currentShapeData) {
-        var path = '';
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        var shape;
-        for (var 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(function (shapeData) {
-                path += ' L ' + (shapeData['point']['x']) + ' ' + (shapeData['point']['y']);
-            });
+        var parts = [];
+        for (var _i = 0, currentShapeData_1 = currentShapeData; _i < currentShapeData_1.length; _i++) {
+            var shape = currentShapeData_1[_i];
+            if (!shape || shape.length === 0) {
+                continue;
+            }
+            var startX = shape[0].point.x;
+            var startY = shape[0].point.y;
+            parts.push("M" + startX + " " + startY);
+            for (var i = 1; i < shape.length; i++) {
+                var x = shape[i].point.x;
+                var y = shape[i].point.y;
+                parts.push(" L " + x + " " + y);
+            }
         }
-        return path;
+        return parts.join(' ');
     };
     /**
      * To render bubble.
@@ -7334,33 +7353,51 @@ var LayerPanel = /** @__PURE__ @class */ (function () {
     };
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     LayerPanel.prototype.calculatePolygonBox = function (coordinates) {
-        var _this = this;
+        // Use a simple for-loop, cache frequent lookups, and update rectBounds once
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         var newData = [];
         var bounds = this.mapObject.baseMapBounds;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        coordinates.map(function (currentPoint) {
+        var lonMin = bounds.longitude.min;
+        var lonMax = bounds.longitude.max;
+        var latMin = bounds.latitude.min;
+        var latMax = bounds.latitude.max;
+        var minX;
+        var minY;
+        var maxX;
+        var maxY;
+        for (var i = 0; i < coordinates.length; i++) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            var currentPoint = coordinates[i];
             var latitude = currentPoint[1];
             var longitude = currentPoint[0];
-            if ((longitude >= bounds.longitude.min && longitude <= bounds.longitude.max)
-                && (latitude >= bounds.latitude.min && latitude <= bounds.latitude.max)) {
-                var 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 (longitude >= lonMin && longitude <= lonMax && latitude >= latMin && latitude <= latMax) {
+                var point = convertGeoToPoint(latitude, longitude, this.currentFactor, this.currentLayer, this.mapObject);
+                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