Skip to content

Echart world map chart#701

Merged
johbaxter merged 8 commits intodevfrom
EChart-Map-Chart
Apr 3, 2025
Merged

Echart world map chart#701
johbaxter merged 8 commits intodevfrom
EChart-Map-Chart

Conversation

@Gowrishankar-Palanisamy
Copy link
Copy Markdown
Contributor

Description

Create map chart block in new UI

Changes Made

Added the fields, events, styling and features of map chart.

@Gowrishankar-Palanisamy Gowrishankar-Palanisamy requested a review from a team as a code owner March 13, 2025 11:36
@Gowrishankar-Palanisamy Gowrishankar-Palanisamy linked an issue Mar 13, 2025 that may be closed by this pull request
14 tasks
@github-actions
Copy link
Copy Markdown

@CodiumAI-Agent /describe

@github-actions
Copy link
Copy Markdown

@CodiumAI-Agent /review

@QodoAI-Agent
Copy link
Copy Markdown

Title

Echart world map chart


User description

Description

Create map chart block in new UI

Changes Made

Added the fields, events, styling and features of map chart.


PR Type

Enhancement


Description

  • Add map data processing with comprehensive formatting

  • Create map selector for dynamic field binding

  • Introduce UI components for map chart settings

  • Integrate interactive map sizing tool and update assets


Changes walkthrough 📝

Relevant files
Enhancement
5 files
MapChartProcessData.tsx
Add extensive map data processing logic with multiple formatters
+2167/-0
MapSelector.ts
Create map selector function based on field metadata         
+609/-0 
MapChartBlockSettings.tsx
Implement settings UI for configuring map chart options   
+703/-0 
MapTool.tsx
Add interactive tool for adjusting map dimensions               
+153/-0 
index.ts
Update assets with world map active and hover icons           
+2/-0     
Additional files
13 files
VisualizationBlock.tsx +7/-0     
VisualizationBlockMenu.tsx +4/-0     
UpgradedVisualizationTool.tsx +57/-11 
LegendToggleMapChart.tsx +88/-0   
Map.tsx +294/-0 
MapChartColorData.tsx +28/-0   
MapChartTooltipData.ts +1135/-0
MapMarkerSize.tsx +116/-0 
TooltipMapChart.tsx +113/-0 
map-utility.tsx +8/-0     
world.tsx +32127/-0
package.json +2/-0     
default-menu.ts +106/-0 

Need help?
  • Type /help how to ... in the comments thread for any questions about PR-Agent usage.
  • Check out the documentation for more information.
  • @github-actions
    Copy link
    Copy Markdown

    @CodiumAI-Agent /improve

    @QodoAI-Agent
    Copy link
    Copy Markdown

    PR Reviewer Guide 🔍

    Here are some key observations to aid the review process:

    ⏱️ Estimated effort to review: 5 🔵🔵🔵🔵🔵
    🧪 No relevant tests
    🔒 No security concerns identified
    ⚡ Recommended focus areas for review

    Complexity

    The processData function contains an extremely high number of nested conditional branches and duplicated logic. This impacts maintainability and readability. Consider refactoring by modularizing shared logic and reducing repetition.

    export const processData = (apiData, data) => {
        let fields = "",
            label = "",
            latitude = "",
            longitude = "",
            size = "",
            color = "",
            tooltip = "";
        if (data.option.hasOwnProperty("_state")) {
            fields = data.option["_state"]["fields"];
            label = fields["label"];
            latitude = fields["Latitude"];
            longitude = fields["Longitude"];
            size = fields["size"];
            color = fields["color"];
            tooltip = fields["tooltip"];
        }
        const formatItem = (label, latitude, longitude) => ({
            value: [longitude, latitude], // latitude and longitude values
            label: {
                formatter: label.toString(), // Use array[0] as the label
            },
        });
    
        const formatDataItem = (
            label,
            latitude,
            longitude,
            size,
            color,
            tooltip,
            colorMap = null,
        ) => {
            if (!colorMap.has(color)) {
                colorMap.set(
                    color,
                    data.option["color"][
                        colorMap.size % data.option["color"]?.length
                    ],
                );
            }
            const adjustedSize = Math.min(size + data.option["symbolSize"], 50);
            return {
                value: [longitude, latitude], // latitude and longitude values
                label: {
                    formatter: label.toString(), // Use array[0] as the label
                },
                tempSymbolSize: size, // Individual symbol size
                symbolSize: adjustedSize, // Individual symbol size
                itemStyle: {
                    color: colorMap.get(color),
                    colorValue: color,
                },
                tooltipValue: tooltip, //tooltip value
            };
        };
        const formatData = (
            label,
            latitude,
            longitude,
            size,
            color,
            colorMap = null,
        ) => {
            if (!colorMap.has(color)) {
                colorMap.set(
                    color,
                    data.option["color"][
                        colorMap.size % data.option["color"]?.length
                    ],
                );
            }
            const adjustedSize = Math.min(size + data.option["symbolSize"], 50);
            return {
                value: [longitude, latitude], // latitude and longitude values
                label: {
                    formatter: label.toString(), // Use array[0] as the label
                },
                tempSymbolSize: size, // Individual symbol size
                symbolSize: adjustedSize, // Individual symbol size
                itemStyle: {
                    color: colorMap.get(color),
                    colorValue: color,
                },
            };
        };
        const formatItemData = (
            label,
            latitude,
            longitude,
            color,
            tooltip,
            colorMap = null,
        ) => {
            if (!colorMap.has(color)) {
                colorMap.set(
                    color,
                    data.option["color"][
                        colorMap.size % data.option["color"]?.length
                    ],
                );
            }
            return {
                value: [longitude, latitude], // latitude and longitude values
                label: {
                    formatter: label.toString(), // Use array[0] as the label
                },
                itemStyle: {
                    color: colorMap.get(color),
                    colorValue: color,
                },
                tooltipValue: tooltip, //tooltip value
            };
        };
        const formatItems = (label, latitude, longitude, size, tooltip) => {
            const adjustedSize = Math.min(size + data.option["symbolSize"], 50);
            return {
                value: [longitude, latitude], // latitude and longitude values
                label: {
                    formatter: label.toString(), // Use array[0] as the label
                },
                tempSymbolSize: size, // Individual symbol size
                symbolSize: adjustedSize, // Individual symbol size
                tooltipValue: tooltip, //tooltip value
            };
        };
        const formatColorDataItem = (
            label,
            latitude,
            longitude,
            color,
            colorMap = null,
        ) => {
            if (!colorMap.has(color)) {
                colorMap.set(
                    color,
                    data.option["color"][
                        colorMap.size % data.option["color"]?.length
                    ],
                );
            }
            return {
                value: [longitude, latitude], // latitude and longitude values
                label: {
                    formatter: label.toString(),
                },
                itemStyle: {
                    color: colorMap.get(color),
                    colorValue: color,
                },
            };
        };
        const formatSizeDataItem = (label, latitude, longitude, size) => {
            const adjustedSize = Math.min(size + data.option["symbolSize"], 50);
    
            return {
                value: [longitude, latitude], // latitude and longitude values
                label: {
                    formatter: label.toString(), // Use array[0] as the label
                },
                tempSymbolSize: size, // Individual symbol size
                symbolSize: adjustedSize, // Individual symbol size
            };
        };
        const formatTooltipDataItem = (label, latitude, longitude, tooltip) => ({
            value: [longitude, latitude], // latitude and longitude values
            label: {
                formatter: label.toString(), // Use array[0] as the label
            },
            tooltipValue: tooltip, //tooltip value
        });
    
        if (apiData["values"]) {
            if (data.option.hasOwnProperty("_state")) {
                if (data.option["_state"].hasOwnProperty("fields")) {
                    if (
                        label &&
                        latitude &&
                        longitude &&
                        size &&
                        color &&
                        tooltip
                    ) {
                        const colorMap = new Map();
                        if (
                            latitude === longitude &&
                            latitude === size &&
                            latitude === color &&
                            latitude === tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[1],
                                    item[1],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude == longitude &&
                            label == size &&
                            label == color &&
                            label == tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[0],
                                    item[0],
                                    item[0],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude == longitude &&
                            latitude == size &&
                            label == color &&
                            label == tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[1],
                                    item[0],
                                    item[0],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude == longitude &&
                            latitude == size &&
                            label == color &&
                            latitude == tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[1],
                                    item[0],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude == longitude &&
                            label == size &&
                            latitude == color &&
                            label == tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[0],
                                    item[1],
                                    item[0],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude == longitude &&
                            label == size &&
                            label == color &&
                            latitude == tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[0],
                                    item[0],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude == longitude &&
                            size == color &&
                            size == tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[2],
                                    item[2],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude == longitude &&
                            label == color &&
                            size == tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[2],
                                    item[0],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude == longitude &&
                            size == tooltip &&
                            latitude == color
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[2],
                                    item[1],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude == longitude &&
                            size == color &&
                            latitude == tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[2],
                                    item[2],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude === size &&
                            latitude === color &&
                            latitude === tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[1],
                                    item[1],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            longitude === size &&
                            longitude === color &&
                            longitude === tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[2],
                                    item[2],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude === size &&
                            latitude === color &&
                            longitude === tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[1],
                                    item[1],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude === size &&
                            longitude === color &&
                            latitude === tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[1],
                                    item[2],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            longitude === size &&
                            latitude === color &&
                            latitude === tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[2],
                                    item[1],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            longitude === size &&
                            longitude === color &&
                            latitude === tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[2],
                                    item[2],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            longitude === size &&
                            latitude === color &&
                            longitude === tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[2],
                                    item[1],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude === size &&
                            longitude === color &&
                            longitude === tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[1],
                                    item[2],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude === size &&
                            latitude === tooltip &&
                            label === color
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[1],
                                    item[0],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            longitude === size &&
                            longitude === tooltip &&
                            label === color
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[2],
                                    item[0],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude === size &&
                            longitude === tooltip &&
                            label === color
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[1],
                                    item[0],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            longitude === size &&
                            latitude === tooltip &&
                            label === color
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[2],
                                    item[0],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude == longitude &&
                            label == size &&
                            latitude == tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[0],
                                    item[2],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude == longitude &&
                            latitude == size &&
                            latitude == tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[1],
                                    item[2],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude == longitude &&
                            label == color &&
                            latitude == tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[2],
                                    item[0],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude == longitude &&
                            label == size &&
                            label == color
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[0],
                                    item[0],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude == longitude &&
                            label == color &&
                            label == tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[2],
                                    item[0],
                                    item[0],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude == longitude &&
                            label == size &&
                            label == tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[0],
                                    item[2],
                                    item[0],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude == longitude &&
                            latitude == size &&
                            latitude == color
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[1],
                                    item[1],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude == longitude &&
                            latitude == size &&
                            latitude == tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[1],
                                    item[2],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude == longitude &&
                            latitude == color &&
                            latitude == tooltip
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[2],
                                    item[1],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude === longitude &&
                            latitude === size &&
                            label === color
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[1],
                                    item[0],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (size == color && latitude == tooltip) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[3],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (size == color && longitude == tooltip) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[3],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (size == color && longitude == tooltip) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[3],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (size == color && size == tooltip) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[3],
                                    item[3],
                                    colorMap,
                                ),
                            }));
                        }
                        if (size == tooltip && latitude == color) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[1],
                                    item[3],
                                    colorMap,
                                ),
                            }));
                        }
                        if (size == tooltip && longitude == color) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[2],
                                    item[3],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude == longitude && latitude == size) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[1],
                                    item[2],
                                    item[3],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude == longitude && latitude == color) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[2],
                                    item[1],
                                    item[3],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude == longitude && size == color) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[2],
                                    item[2],
                                    item[3],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude == longitude && latitude == tooltip) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude == longitude && size == tooltip) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude == longitude && label == size) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[0],
                                    item[2],
                                    item[3],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude == longitude && label == color) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[2],
                                    item[0],
                                    item[3],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude == longitude && label == tooltip) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[0],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude == size && label == color) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[1],
                                    item[0],
                                    item[3],
                                    colorMap,
                                ),
                            }));
                        }
                        if (longitude === size && label === color) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[2],
                                    item[0],
                                    item[3],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude === tooltip && label === color) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[0],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (longitude === tooltip && label === color) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[0],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude === size && latitude === color) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[1],
                                    item[1],
                                    item[3],
                                    colorMap,
                                ),
                            }));
                        }
                        if (longitude === size && longitude === color) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[2],
                                    item[2],
                                    item[3],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude === size && latitude === tooltip) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[1],
                                    item[3],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (longitude === size && longitude === tooltip) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[2],
                                    item[3],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude === color && latitude === tooltip) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[1],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (longitude === color && longitude === tooltip) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[2],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude === size && longitude === color) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[1],
                                    item[2],
                                    item[3],
                                    colorMap,
                                ),
                            }));
                        }
                        if (longitude === size && latitude === color) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[2],
                                    item[1],
                                    item[3],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude === size && longitude === tooltip) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[1],
                                    item[3],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (longitude === size && latitude === tooltip) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[2],
                                    item[3],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude === color && longitude === tooltip) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[1],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (longitude === color && latitude === tooltip) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[2],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (size === tooltip && label === color) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[0],
                                    item[3],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude == longitude) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[4],
                                    colorMap,
                                ),
                            }));
                        }
                        if (label === color) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[0],
                                    item[4],
                                    colorMap,
                                ),
                            }));
                        }
                        if (size === label) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[4],
                                    item[5],
                                    colorMap,
                                ),
                            }));
                        }
                        if (tooltip === label) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[4],
                                    item[5],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude === size) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[1],
                                    item[3],
                                    item[4],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude === color) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[1],
                                    item[4],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude === tooltip) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[4],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (longitude === size) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[2],
                                    item[3],
                                    item[4],
                                    colorMap,
                                ),
                            }));
                        }
                        if (longitude === color) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[2],
                                    item[4],
                                    colorMap,
                                ),
                            }));
                        }
                        if (longitude === tooltip) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[4],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (size === color) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[3],
                                    item[4],
                                    colorMap,
                                ),
                            }));
                        }
                        if (size === tooltip) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[4],
                                    item[3],
                                    colorMap,
                                ),
                            }));
                        }
                        if (color === tooltip) {
                            return apiData.values.map((item) => ({
                                ...formatDataItem(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[4],
                                    item[4],
                                    colorMap,
                                ),
                            }));
                        }
                        return apiData.values.map((item) => ({
                            ...formatDataItem(
                                item[0],
                                item[1],
                                item[2],
                                item[3],
                                item[4],
                                item[5],
                                colorMap,
                            ),
                        }));
                    }
                    if (label && latitude && longitude && size && color) {
                        const colorMap = new Map();
                        if (
                            latitude == longitude &&
                            latitude == size &&
                            label == color
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatData(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[1],
                                    item[0],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude == longitude &&
                            latitude == size &&
                            latitude == color
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatData(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[1],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude == longitude && latitude == color) {
                            return apiData.values.map((item) => ({
                                ...formatData(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[2],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude == longitude && size == color) {
                            return apiData.values.map((item) => ({
                                ...formatData(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[2],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude == longitude && label == color) {
                            return apiData.values.map((item) => ({
                                ...formatData(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[2],
                                    item[0],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude == longitude && latitude == size) {
                            return apiData.values.map((item) => ({
                                ...formatData(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[1],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude === size && latitude === color) {
                            return apiData.values.map((item) => ({
                                ...formatData(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[1],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (longitude === size && longitude === color) {
                            return apiData.values.map((item) => ({
                                ...formatData(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[2],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude === size && longitude === color) {
                            return apiData.values.map((item) => ({
                                ...formatData(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[1],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (longitude === size && latitude === color) {
                            return apiData.values.map((item) => ({
                                ...formatData(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[2],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude === size && label === color) {
                            return apiData.values.map((item) => ({
                                ...formatData(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[1],
                                    item[0],
                                    colorMap,
                                ),
                            }));
                        }
                        if (longitude === size && label === color) {
                            return apiData.values.map((item) => ({
                                ...formatData(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[2],
                                    item[0],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude == longitude) {
                            return apiData.values.map((item) => ({
                                ...formatData(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[2],
                                    item[3],
                                    colorMap,
                                ),
                            }));
                        }
                        if (label === color) {
                            return apiData.values.map((item) => ({
                                ...formatData(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[0],
                                    colorMap,
                                ),
                            }));
                        }
                        if (size === color) {
                            return apiData.values.map((item) => ({
                                ...formatData(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[3],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude === size) {
                            return apiData.values.map((item) => ({
                                ...formatData(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[1],
                                    item[3],
                                    colorMap,
                                ),
                            }));
                        }
                        if (longitude === size) {
                            return apiData.values.map((item) => ({
                                ...formatData(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[2],
                                    item[3],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude === color) {
                            return apiData.values.map((item) => ({
                                ...formatData(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (longitude === color) {
                            return apiData.values.map((item) => ({
                                ...formatData(
                                    item[0],
                                    item[1],
                                    item[2],
                                    item[3],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        return apiData.values.map((item) => ({
                            ...formatData(
                                item[0],
                                item[1],
                                item[2],
                                item[3],
                                item[4],
                                colorMap,
                            ),
                        }));
                    }
                    if (label && latitude && longitude && color && tooltip) {
                        const colorMap = new Map();
                        if (
                            latitude == longitude &&
                            latitude == tooltip &&
                            label == color
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatItemData(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[0],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (
                            latitude == longitude &&
                            latitude == tooltip &&
                            latitude == color
                        ) {
                            return apiData.values.map((item) => ({
                                ...formatItemData(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[1],
                                    item[1],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude == longitude && latitude == color) {
                            return apiData.values.map((item) => ({
                                ...formatItemData(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[1],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude == longitude && label == color) {
                            return apiData.values.map((item) => ({
                                ...formatItemData(
                                    item[0],
                                    item[1],
                                    item[1],
                                    item[0],
                                    item[2],
                                    colorMap,
                                ),
                            }));
                        }
                        if (latitude == longitude && latitude == ...

    @QodoAI-Agent
    Copy link
    Copy Markdown

    QodoAI-Agent commented Mar 13, 2025

    PR Code Suggestions ✨

    Latest suggestions up to 69ed599

    CategorySuggestion                                                                                                                                    Impact
    Possible issue
    Ensure default return value

    Add a default return (e.g. an empty array) at the end of the function to handle
    cases when none of the conditions match, preventing unintended undefined returns.

    libs/renderer/src/components/block-defaults/echart-visualization-block/variant/map-chart/MapChartProcessData.tsx [2164-2167]

     if (data.option.hasOwnProperty("_state")) {
    -    // many nested if ( ... ) { return ... } blocks
    +    // ... existing nested mappings
     }
    +return [];
    Suggestion importance[1-10]: 8

    __

    Why: Adding a default return (like an empty array) prevents unintended undefined results when none of the conditions match, addressing a critical runtime risk.

    Medium
    General
    Simplify nested mapping logic

    Refactor and consolidate the repeated and deeply nested conditional mapping logic
    into smaller, helper functions or a lookup table to improve maintainability.

    libs/renderer/src/components/block-defaults/echart-visualization-block/variant/map-chart/MapChartProcessData.tsx [173-1319]

    -if (data.option.hasOwnProperty("_state")) {
    -    if (apiData["values"]) {
    -        if (data.option["_state"].hasOwnProperty("fields")) {
    -            if (label && latitude && longitude && size && color && tooltip) {
    -                const colorMap = new Map();
    -                if (latitude === longitude && latitude === size && label === color && latitude === tooltip) {
    -                    return apiData.values.map((item) => ({
    -                        ...formatDataItem(
    -                            item[0],
    -                            item[1],
    -                            item[1],
    -                            item[1],
    -                            item[1],
    -                            item[1],
    -                            colorMap,
    -                        ),
    -                    }));
    -                }
    -                // ... many similar conditions
    -            }
    -            // ... additional nested conditionals
    -        }
    -        // ...
    -    }
    +// Define a helper that selects the correct mapping function and parameters based on the field values
    +const getMappingFunction = (fields) => {
    +    // logic for determining mapping logic from field configuration
    +    return (item: any, colorMap: Map<any, any>) => formatDataItem(/* parameters based on fields and item */);
    +};
    +
    +if (data.option.hasOwnProperty("_state") && apiData["values"]) {
    +    const mappingFunction = getMappingFunction(fields);
    +    return apiData.values.map((item) => mappingFunction(item, new Map()));
     }
    Suggestion importance[1-10]: 7

    __

    Why: The suggestion aims to refactor the deeply nested and repetitive conditional mapping logic into helper functions, which improves maintainability and readability without altering core functionality.

    Medium
    Standardize equality checks

    Use consistent strict equality operators (===) instead of loose equality (==) to
    ensure that type comparisons are safe.

    libs/renderer/src/components/block-defaults/echart-visualization-block/variant/map-chart/MapChartProcessData.tsx [203-212]

     if (
    -    latitude == longitude &&
    -    label == size &&
    -    label == color &&
    -    label == tooltip
    +    latitude === longitude &&
    +    label === size &&
    +    label === color &&
    +    label === tooltip
     ) {
         return apiData.values.map((item) => ({
             ...formatDataItem(
                 item[0],
                 item[1],
                 item[1],
                 item[0],
                 item[0],
                 item[0],
                 colorMap,
             ),
         }));
     }
    Suggestion importance[1-10]: 5

    __

    Why: Replacing loose equality operators with strict equality enhances code safety and clarity; however, its impact is mostly stylistic and minor.

    Low

    Previous suggestions

    Suggestions up to commit 4deb2f4
    CategorySuggestion                                                                                                                                    Impact
    Possible issue
    Safely parse JSON input

    Wrap the JSON.parse call in a try-catch block to handle invalid JSON input and
    prevent potential runtime errors.

    libs/renderer/src/components/block-defaults/echart-visualization-block/variant/map-chart/MapMarkerSize.tsx [91-101]

     const handleChangeSymbolSize = (e) => {
    -    let option = JSON.parse(value);
    -    setMarkerSize(e.target.value);
    -    option["series"][0]["symbolSize"] = e.target.value;
    -    option["symbolSize"] = e.target.value;
    -    setData(path, option as PathValue<D["data"], typeof path>);
    +    try {
    +        let option = JSON.parse(value);
    +        const newSize = Number(e.target.value);
    +        setMarkerSize(newSize);
    +        option["series"][0]["symbolSize"] = newSize;
    +        option["symbolSize"] = newSize;
    +        setData(path, option as PathValue<D["data"], typeof path>);
    +    } catch (error) {
    +        console.error("Invalid JSON in value:", error);
    +    }
     };
    Suggestion importance[1-10]: 8

    __

    Why: Wrapping JSON.parse in a try-catch block improves robustness against invalid JSON, and converting the value to a number ensures type consistency, making this a meaningful improvement to error handling.

    Medium
    Ensure numeric marker size

    Convert the input value to a numeric type when updating the marker size to ensure
    type consistency.

    libs/renderer/src/components/block-defaults/echart-visualization-block/variant/map-chart/MapMarkerSize.tsx [95]

    -setMarkerSize(e.target.value);
    +setMarkerSize(Number(e.target.value));
    Suggestion importance[1-10]: 5

    __

    Why: Converting the marker size from the input to a number prevents type issues, offering a minor yet useful enhancement to the code.

    Low
    General
    Refactor repetitive conditional blocks

    Refactor repeated condition blocks into helper functions or mapping configurations
    to simplify control flow.

    libs/renderer/src/components/block-defaults/echart-visualization-block/variant/map-chart/MapChartProcessData.tsx [177-194]

    -if (
    -    latitude === longitude &&
    -    latitude === size &&
    -    label === color &&
    -    label === tooltip
    -) {
    +// Example: Define mapping configurations and a handler function
    +const mappingConfigs = [
    +  {
    +    conditions: [latitude === longitude, latitude === size, label === color, label === tooltip],
    +    formatter: formatDataItem,
    +  },
    +  // additional configurations...
    +];
    +
    +for (const config of mappingConfigs) {
    +  if (config.conditions.every(cond => cond)) {
         return apiData.values.map((item) => ({
    -        ...formatDataItem(
    -            item[0],
    -            item[1],
    -            item[1],
    -            item[1],
    -            item[1],
    -            item[1],
    -            colorMap,
    -        ),
    +      ...config.formatter(
    +        item[0],
    +        item[1],
    +        item[1],
    +        item[1],
    +        item[1],
    +        item[1],
    +        colorMap,
    +      ),
         }));
    +  }
     }
    Suggestion importance[1-10]: 5

    __

    Why: The suggestion offers to extract repeated conditional logic into a helper or mapping configuration, which improves maintainability but does not fix a critical bug.

    Low
    Abstract repeated color mapping

    Abstract the color mapping logic into a helper function to eliminate duplicate code
    segments.

    libs/renderer/src/components/block-defaults/echart-visualization-block/variant/map-chart/MapChartProcessData.tsx [34-41]

    -if (!colorMap.has(color)) {
    -    colorMap.set(
    -        color,
    -        data.option["color"][
    -            colorMap.size % data.option["color"]?.length
    -        ],
    -    );
    -}
    +const getColor = (color, colorMap, colors) => {
    +  if (!colorMap.has(color)) {
    +    colorMap.set(color, colors[colorMap.size % colors.length]);
    +  }
    +  return colorMap.get(color);
    +};
    +// Usage in formatting functions:
    +// color: getColor(color, colorMap, data.option["color"])
    Suggestion importance[1-10]: 5

    __

    Why: Abstracting the color mapping logic into a helper function reduces duplicate code and improves clarity; however, it is a moderate refactoring exercise rather than a critical fix.

    Low
    Simplify nested tooltip logic

    Refactor the deeply nested and duplicated conditional logic in the tooltip formatter
    to simplify and improve maintainability.

    libs/renderer/src/components/block-defaults/echart-visualization-block/variant/map-chart/MapChartTooltipData.ts [1-17]

     export const formatdatapoints = (apiData, data) => {
    -    let fields = "",
    -        label = "",
    -        latitude = "",
    -        longitude = "",
    -        size = "",
    -        color = "",
    -        tooltip = "";
    -    if (data.option.hasOwnProperty("_state")) {
    -        fields = data.option["_state"]["fields"];
    -        label = fields["label"];
    -        latitude = fields["Latitude"];
    -        longitude = fields["Longitude"];
    -        size = fields["size"];
    -        color = fields["color"];
    -        tooltip = fields["tooltip"];
    -    }
    -    ...
    +    if (!data.option || !data.option._state) return "";
    +    const fields = data.option._state.fields;
    +    const { label, Latitude: latitude, Longitude: longitude, size, color, tooltip } = fields;
    +    const getSelectorType = type => fields[type] === "NUMBER" ? "Average of" : "Count of";
    +    const selectors = {
    +        latitude: "Coordinates:",
    +        longitude: getSelectorType("LongitudeDataType"),
    +        size: getSelectorType("sizeDataType"),
    +        tooltip: getSelectorType("tooltipDataType"),
    +        color: "Unique Group Concat of",
    +    };
    +    // Use helper functions or switch statements to cover distinct cases, reducing duplicate code.
    +    // ...
    +}
    Suggestion importance[1-10]: 5

    __

    Why: The suggestion refactors the initial field extraction and simplifies the nested logic; however, it only partly addresses the duplicated conditional tooltip cases and is more of a readability improvement than a critical fix.

    Low
    Standardize equality operators

    Standardize all equality checks by using strict operators to ensure consistent
    behavior.

    libs/renderer/src/components/block-defaults/echart-visualization-block/variant/map-chart/MapChartProcessData.tsx [200-202]

    -if (latitude == longitude && label == size && latitude == tooltip) {
    +if (latitude === longitude && label === size && latitude === tooltip) {
         // code block...
     }
    Suggestion importance[1-10]: 3

    __

    Why: Changing loose equality (==) to strict equality (===) is a minor stylistic improvement that enhances consistency but has low overall impact.

    Low

    @Gowrishankar-Palanisamy
    Copy link
    Copy Markdown
    Contributor Author

    Here by I attached the block.json file
    block.json

    @johbaxter johbaxter merged commit 84bf276 into dev Apr 3, 2025
    3 checks passed
    @johbaxter johbaxter deleted the EChart-Map-Chart branch April 3, 2025 18:26
    @github-actions
    Copy link
    Copy Markdown

    github-actions bot commented Apr 3, 2025

    @CodiumAI-Agent /update_changelog

    @QodoAI-Agent
    Copy link
    Copy Markdown

    Changelog updates: 🔄

    2025-04-03 [https://github.com//pull/701]

    Added

    • New echart world map chart block with integrated UI settings and selectors.

    to commit the new content to the CHANGELOG.md file, please type:
    '/update_changelog --pr_update_changelog.push_changelog_changes=true'

    Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

    Labels

    None yet

    Projects

    None yet

    Development

    Successfully merging this pull request may close these issues.

    Create Map Chart

    3 participants