manipulate two array of objects make new array and update the attribute of object1 and add in the new array and modify nested object if needed

If I got the logic properly, it is not just simple as the issue of your previous question...

In your previous question, the data property of the default object was replaced by the data property of the modified object. In this situation, you have to add those new data elements of the modified object into the default one (if those elements don't exist) and mark as removed the ones that are present in the default object but not in the modified.

If you want a performant algorithm, you will need to have some considerations. For example:

1. Reduce the source arrays (obj1, obj2) to javascript objects to avoid unnecessary double loops with find or filter methods, and decrease the complexity from O(n*n) to O(n).
2. Reduce the data array of the obj1, with the purpose of decrease the complexity to O(1) when getting a value, and avoid a find method which is O(n).
3. Set each data element of the obj1 as removed by default... and change the status only if it was not removed from the data object of obj2.

You can try something like this, it's quite more complex than the other algorithm but I believe that is one of the performant ways to solve this.

    let checkRemovals = (obj1, obj2) => {
        const defaultObject = obj1.reduce((acc, { id, ...rest }) => { acc[id] = rest; return acc }, {});
        const modifiedObject = obj2.reduce((acc, { id, ...rest }) => { acc[id] = rest; return acc }, {});
        
        // Basic actions in the default object
        obj1.forEach(({ id }) => {
            defaultObject[id].removed = !modifiedObject[id] ? 'Y' : 'N';
            
            if (defaultObject[id].data) {
                defaultObject[id].data = defaultObject[id].data.reduce((acc, { label, ...rest }) => {
                    acc[label] = { ...rest, removed: 'Y' };
                    return acc;
                }, {});
            }
        });
        
        // Update and add new elements
        obj2.forEach(({ id, data, ...rest }) => {
            // If it not exists in the default object, add it
            if (!defaultObject[id]) {
                defaultObject[id] = {
                    ...rest,
                    data: data.reduce((acc, { labelname, id, ...rest }) => {
                        acc[labelname] = { ...rest, dataid: id, removed: 'N' };
                        return acc
                    }, {})
                }
            }
            // If it exists, update it
            else {
                const mainID = id;
                
                data.forEach(({ id, labelname, ...rest }) => {
                    if (defaultObject[mainID].data[labelname]) {
                        defaultObject[mainID].data[labelname].removed = 'N';
                    }
                    else {
                        defaultObject[mainID].data[labelname] = { ...rest, dataid: id, removed: 'N' };
                    }
                });
            }
        });
        
        // Build the result
        const result = [];
        Object.keys(defaultObject).forEach(key => {
            const { data, ...rest } = defaultObject[key];
            
            result.push({
                ...rest,
                id: key,
                data: Object.keys(data).reduce((acc, key) => {
                    acc.push({ label: key, ...data[key] });
                    return acc;
                }, [])
            })
        });
        
        return result;
    }