@payloadcms/next 3.80.0-canary.4 → 3.80.0-internal-debug.daef79f

package/dist/views/Version/RenderFieldsToDiff/utilities/countChangedFields.spec.js

@@ -1,861 +1,1040 @@
 import { describe, it, expect } from 'vitest';
 import { countChangedFields, countChangedFieldsInRows } from './countChangedFields.js';
-describe('countChangedFields', () => {
-  // locales can be undefined when not configured in payload.config.js
-  const locales = undefined;
-  it('should return 0 when no fields have changed', () => {
-    const fields = [{
-      name: 'a',
-      type: 'text'
-    }, {
-      name: 'b',
-      type: 'number'
-    }];
-    const valueFrom = {
-      a: 'original',
-      b: 123
-    };
-    const valueTo = {
-      a: 'original',
-      b: 123
-    };
-    const result = countChangedFields({
-      valueFrom,
-      fields,
-      valueTo,
-      locales
-    });
-    expect(result).toBe(0);
-  });
-  it('should count simple changed fields', () => {
-    const fields = [{
-      name: 'a',
-      type: 'text'
-    }, {
-      name: 'b',
-      type: 'number'
-    }];
-    const valueFrom = {
-      a: 'original',
-      b: 123
-    };
-    const valueTo = {
-      a: 'changed',
-      b: 123
-    };
-    const result = countChangedFields({
-      valueFrom,
-      fields,
-      valueTo,
-      locales
-    });
-    expect(result).toBe(1);
-  });
-  it('should count previously undefined fields', () => {
-    const fields = [{
-      name: 'a',
-      type: 'text'
-    }, {
-      name: 'b',
-      type: 'number'
-    }];
-    const valueFrom = {};
-    const valueTo = {
-      a: 'new',
-      b: 123
-    };
-    const result = countChangedFields({
-      valueFrom,
-      fields,
-      valueTo,
-      locales
-    });
-    expect(result).toBe(2);
-  });
-  it('should not count the id field because it is not displayed in the version view', () => {
-    const fields = [{
-      name: 'id',
-      type: 'text'
-    }, {
-      name: 'a',
-      type: 'text'
-    }];
-    const valueFrom = {
-      id: 'original',
-      a: 'original'
-    };
-    const valueTo = {
-      id: 'changed',
-      a: 'original'
-    };
-    const result = countChangedFields({
-      valueFrom,
-      fields,
-      valueTo,
-      locales
-    });
-    expect(result).toBe(0);
-  });
-  it('should count changed fields inside collapsible fields', () => {
-    const fields = [{
-      type: 'collapsible',
-      label: 'A collapsible field',
-      fields: [{
-        name: 'a',
-        type: 'text'
-      }, {
-        name: 'b',
-        type: 'text'
-      }, {
-        name: 'c',
-        type: 'text'
-      }]
-    }];
-    const valueFrom = {
-      a: 'original',
-      b: 'original',
-      c: 'original'
-    };
-    const valueTo = {
-      a: 'changed',
-      b: 'changed',
-      c: 'original'
-    };
-    const result = countChangedFields({
-      valueFrom,
-      fields,
-      valueTo,
-      locales
-    });
-    expect(result).toBe(2);
-  });
-  it('should count changed fields inside row fields', () => {
-    const fields = [{
-      type: 'row',
-      fields: [{
-        name: 'a',
-        type: 'text'
-      }, {
-        name: 'b',
-        type: 'text'
-      }, {
-        name: 'c',
-        type: 'text'
-      }]
-    }];
-    const valueFrom = {
-      a: 'original',
-      b: 'original',
-      c: 'original'
-    };
-    const valueTo = {
-      a: 'changed',
-      b: 'changed',
-      c: 'original'
-    };
-    const result = countChangedFields({
-      valueFrom,
-      fields,
-      valueTo,
-      locales
-    });
-    expect(result).toBe(2);
-  });
-  it('should count changed fields inside group fields', () => {
-    const fields = [{
-      type: 'group',
-      name: 'group',
-      fields: [{
-        name: 'a',
-        type: 'text'
-      }, {
-        name: 'b',
-        type: 'text'
-      }, {
-        name: 'c',
-        type: 'text'
-      }]
-    }];
-    const valueFrom = {
-      group: {
-        a: 'original',
-        b: 'original',
-        c: 'original'
-      }
-    };
-    const valueTo = {
-      group: {
-        a: 'changed',
-        b: 'changed',
-        c: 'original'
-      }
-    };
-    const result = countChangedFields({
-      valueFrom,
-      fields,
-      valueTo,
-      locales
-    });
-    expect(result).toBe(2);
-  });
-  it('should count changed fields inside unnamed tabs ', () => {
-    const fields = [{
-      type: 'tabs',
-      tabs: [{
-        label: 'Unnamed tab',
-        fields: [{
-          name: 'a',
-          type: 'text'
-        }, {
-          name: 'b',
-          type: 'text'
-        }, {
-          name: 'c',
-          type: 'text'
-        }]
-      }]
-    }];
-    const valueFrom = {
-      a: 'original',
-      b: 'original',
-      c: 'original'
-    };
-    const valueTo = {
-      a: 'changed',
-      b: 'changed',
-      c: 'original'
-    };
-    const result = countChangedFields({
-      valueFrom,
-      fields,
-      valueTo,
-      locales
-    });
-    expect(result).toBe(2);
-  });
-  it('should count changed fields inside named tabs ', () => {
-    const fields = [{
-      type: 'tabs',
-      tabs: [{
-        name: 'namedTab',
-        fields: [{
-          name: 'a',
-          type: 'text'
-        }, {
-          name: 'b',
-          type: 'text'
-        }, {
-          name: 'c',
-          type: 'text'
-        }]
-      }]
-    }];
-    const valueFrom = {
-      namedTab: {
-        a: 'original',
-        b: 'original',
-        c: 'original'
-      }
-    };
-    const valueTo = {
-      namedTab: {
-        a: 'changed',
-        b: 'changed',
-        c: 'original'
-      }
-    };
-    const result = countChangedFields({
-      valueFrom,
-      fields,
-      valueTo,
-      locales
-    });
-    expect(result).toBe(2);
-  });
-  it('should ignore UI fields', () => {
-    const fields = [{
-      name: 'a',
-      type: 'text'
-    }, {
-      name: 'b',
-      type: 'ui',
-      admin: {}
-    }];
-    const valueFrom = {
-      a: 'original',
-      b: 'original'
-    };
-    const valueTo = {
-      a: 'original',
-      b: 'changed'
-    };
-    const result = countChangedFields({
-      valueFrom,
-      fields,
-      valueTo,
-      locales
-    });
-    expect(result).toBe(0);
-  });
-  it('should count changed fields inside array fields', () => {
-    const fields = [{
-      name: 'arrayField',
-      type: 'array',
-      fields: [{
-        name: 'a',
-        type: 'text'
-      }, {
-        name: 'b',
-        type: 'text'
-      }, {
-        name: 'c',
-        type: 'text'
-      }]
-    }];
-    const valueFrom = {
-      arrayField: [{
-        a: 'original',
-        b: 'original',
-        c: 'original'
-      }, {
-        a: 'original',
-        b: 'original'
-      }]
-    };
-    const valueTo = {
-      arrayField: [{
-        a: 'changed',
-        b: 'changed',
-        c: 'original'
-      }, {
-        a: 'changed',
-        b: 'changed',
-        c: 'changed'
-      }]
-    };
-    const result = countChangedFields({
-      valueFrom,
-      fields,
-      valueTo,
-      locales
-    });
-    expect(result).toBe(5);
-  });
-  it('should count changed fields inside arrays nested inside of collapsibles', () => {
-    const fields = [{
-      type: 'collapsible',
-      label: 'A collapsible field',
-      fields: [{
-        name: 'arrayField',
-        type: 'array',
-        fields: [{
-          name: 'a',
-          type: 'text'
-        }, {
-          name: 'b',
-          type: 'text'
-        }, {
-          name: 'c',
-          type: 'text'
-        }]
-      }]
-    }];
-    const valueFrom = {
-      arrayField: [{
-        a: 'original',
-        b: 'original',
-        c: 'original'
-      }]
-    };
-    const valueTo = {
-      arrayField: [{
-        a: 'changed',
-        b: 'changed',
-        c: 'original'
-      }]
-    };
-    const result = countChangedFields({
-      valueFrom,
-      fields,
-      valueTo,
-      locales
-    });
-    expect(result).toBe(2);
-  });
-  it('should count changed fields inside blocks fields', () => {
-    const fields = [{
-      name: 'blocks',
-      type: 'blocks',
-      blocks: [{
-        slug: 'blockA',
-        fields: [{
-          name: 'a',
-          type: 'text'
-        }, {
-          name: 'b',
-          type: 'text'
-        }, {
-          name: 'c',
-          type: 'text'
-        }]
-      }]
-    }];
-    const valueFrom = {
-      blocks: [{
-        blockType: 'blockA',
-        a: 'original',
-        b: 'original',
-        c: 'original'
-      }, {
-        blockType: 'blockA',
-        a: 'original',
-        b: 'original'
-      }]
-    };
-    const valueTo = {
-      blocks: [{
-        blockType: 'blockA',
-        a: 'changed',
-        b: 'changed',
-        c: 'original'
-      }, {
-        blockType: 'blockA',
-        a: 'changed',
-        b: 'changed',
-        c: 'changed'
-      }]
-    };
-    const result = countChangedFields({
-      valueFrom,
-      fields,
-      valueTo,
-      locales
+describe('countChangedFields', ()=>{
+    // locales can be undefined when not configured in payload.config.js
+    const locales = undefined;
+    it('should return 0 when no fields have changed', ()=>{
+        const fields = [
+            {
+                name: 'a',
+                type: 'text'
+            },
+            {
+                name: 'b',
+                type: 'number'
+            }
+        ];
+        const valueFrom = {
+            a: 'original',
+            b: 123
+        };
+        const valueTo = {
+            a: 'original',
+            b: 123
+        };
+        const result = countChangedFields({
+            valueFrom,
+            fields,
+            valueTo,
+            locales
+        });
+        expect(result).toBe(0);
     });
-    expect(result).toBe(5);
-  });
-  it('should count changed fields between blocks with different slugs', () => {
-    const fields = [{
-      name: 'blocks',
-      type: 'blocks',
-      blocks: [{
-        slug: 'blockA',
-        fields: [{
-          name: 'a',
-          type: 'text'
-        }, {
-          name: 'b',
-          type: 'text'
-        }, {
-          name: 'c',
-          type: 'text'
-        }]
-      }, {
-        slug: 'blockB',
-        fields: [{
-          name: 'b',
-          type: 'text'
-        }, {
-          name: 'c',
-          type: 'text'
-        }, {
-          name: 'd',
-          type: 'text'
-        }]
-      }]
-    }];
-    const valueFrom = {
-      blocks: [{
-        blockType: 'blockA',
-        a: 'removed',
-        b: 'original',
-        c: 'original'
-      }]
-    };
-    const valueTo = {
-      blocks: [{
-        blockType: 'blockB',
-        b: 'original',
-        c: 'changed',
-        d: 'new'
-      }]
-    };
-    const result = countChangedFields({
-      valueFrom,
-      fields,
-      valueTo,
-      locales
+    it('should count simple changed fields', ()=>{
+        const fields = [
+            {
+                name: 'a',
+                type: 'text'
+            },
+            {
+                name: 'b',
+                type: 'number'
+            }
+        ];
+        const valueFrom = {
+            a: 'original',
+            b: 123
+        };
+        const valueTo = {
+            a: 'changed',
+            b: 123
+        };
+        const result = countChangedFields({
+            valueFrom,
+            fields,
+            valueTo,
+            locales
+        });
+        expect(result).toBe(1);
     });
-    expect(result).toBe(3);
-  });
-  describe('localized fields', () => {
-    const locales = ['en', 'de'];
-    it('should count simple localized fields', () => {
-      const fields = [{
-        name: 'a',
-        type: 'text',
-        localized: true
-      }, {
-        name: 'b',
-        type: 'text',
-        localized: true
-      }];
-      const valueFrom = {
-        a: {
-          en: 'original',
-          de: 'original'
-        },
-        b: {
-          en: 'original',
-          de: 'original'
-        }
-      };
-      const valueTo = {
-        a: {
-          en: 'changed',
-          de: 'original'
-        },
-        b: {
-          en: 'original',
-          de: 'original'
-        }
-      };
-      const result = countChangedFields({
-        valueFrom,
-        fields,
-        valueTo,
-        locales
-      });
-      expect(result).toBe(1);
+    it('should count previously undefined fields', ()=>{
+        const fields = [
+            {
+                name: 'a',
+                type: 'text'
+            },
+            {
+                name: 'b',
+                type: 'number'
+            }
+        ];
+        const valueFrom = {};
+        const valueTo = {
+            a: 'new',
+            b: 123
+        };
+        const result = countChangedFields({
+            valueFrom,
+            fields,
+            valueTo,
+            locales
+        });
+        expect(result).toBe(2);
     });
-    it('should count multiple locales of the same localized field', () => {
-      const locales = ['en', 'de'];
-      const fields = [{
-        name: 'a',
-        type: 'text',
-        localized: true
-      }, {
-        name: 'b',
-        type: 'text',
-        localized: true
-      }];
-      const valueFrom = {
-        a: {
-          en: 'original',
-          de: 'original'
-        },
-        b: {
-          en: 'original',
-          de: 'original'
-        }
-      };
-      const valueTo = {
-        a: {
-          en: 'changed',
-          de: 'changed'
-        },
-        b: {
-          en: 'original',
-          de: 'original'
-        }
-      };
-      const result = countChangedFields({
-        valueFrom,
-        fields,
-        valueTo,
-        locales
-      });
-      expect(result).toBe(2);
+    it('should not count the id field because it is not displayed in the version view', ()=>{
+        const fields = [
+            {
+                name: 'id',
+                type: 'text'
+            },
+            {
+                name: 'a',
+                type: 'text'
+            }
+        ];
+        const valueFrom = {
+            id: 'original',
+            a: 'original'
+        };
+        const valueTo = {
+            id: 'changed',
+            a: 'original'
+        };
+        const result = countChangedFields({
+            valueFrom,
+            fields,
+            valueTo,
+            locales
+        });
+        expect(result).toBe(0);
     });
-    it('should count changed fields inside localized groups fields', () => {
-      const fields = [{
-        type: 'group',
-        name: 'group',
-        localized: true,
-        fields: [{
-          name: 'a',
-          type: 'text'
-        }, {
-          name: 'b',
-          type: 'text'
-        }, {
-          name: 'c',
-          type: 'text'
-        }]
-      }];
-      const valueFrom = {
-        group: {
-          en: {
+    it('should count changed fields inside collapsible fields', ()=>{
+        const fields = [
+            {
+                type: 'collapsible',
+                label: 'A collapsible field',
+                fields: [
+                    {
+                        name: 'a',
+                        type: 'text'
+                    },
+                    {
+                        name: 'b',
+                        type: 'text'
+                    },
+                    {
+                        name: 'c',
+                        type: 'text'
+                    }
+                ]
+            }
+        ];
+        const valueFrom = {
             a: 'original',
             b: 'original',
             c: 'original'
-          },
-          de: {
-            a: 'original',
-            b: 'original',
-            c: 'original'
-          }
-        }
-      };
-      const valueTo = {
-        group: {
-          en: {
+        };
+        const valueTo = {
             a: 'changed',
             b: 'changed',
             c: 'original'
-          },
-          de: {
-            a: 'original',
-            b: 'changed',
-            c: 'original'
-          }
-        }
-      };
-      const result = countChangedFields({
-        valueFrom,
-        fields,
-        valueTo,
-        locales
-      });
-      expect(result).toBe(3);
+        };
+        const result = countChangedFields({
+            valueFrom,
+            fields,
+            valueTo,
+            locales
+        });
+        expect(result).toBe(2);
     });
-    it('should count changed fields inside localized tabs', () => {
-      const fields = [{
-        type: 'tabs',
-        tabs: [{
-          name: 'tab',
-          localized: true,
-          fields: [{
-            name: 'a',
-            type: 'text'
-          }, {
-            name: 'b',
-            type: 'text'
-          }, {
-            name: 'c',
-            type: 'text'
-          }]
-        }]
-      }];
-      const valueFrom = {
-        tab: {
-          en: {
-            a: 'original',
-            b: 'original',
-            c: 'original'
-          },
-          de: {
+    it('should count changed fields inside row fields', ()=>{
+        const fields = [
+            {
+                type: 'row',
+                fields: [
+                    {
+                        name: 'a',
+                        type: 'text'
+                    },
+                    {
+                        name: 'b',
+                        type: 'text'
+                    },
+                    {
+                        name: 'c',
+                        type: 'text'
+                    }
+                ]
+            }
+        ];
+        const valueFrom = {
             a: 'original',
             b: 'original',
             c: 'original'
-          }
-        }
-      };
-      const valueTo = {
-        tab: {
-          en: {
+        };
+        const valueTo = {
             a: 'changed',
             b: 'changed',
             c: 'original'
-          },
-          de: {
-            a: 'original',
-            b: 'changed',
-            c: 'original'
-          }
-        }
-      };
-      const result = countChangedFields({
-        valueFrom,
-        fields,
-        valueTo,
-        locales
-      });
-      expect(result).toBe(3);
+        };
+        const result = countChangedFields({
+            valueFrom,
+            fields,
+            valueTo,
+            locales
+        });
+        expect(result).toBe(2);
     });
-    it('should count changed fields inside localized array fields', () => {
-      const fields = [{
-        name: 'arrayField',
-        type: 'array',
-        localized: true,
-        fields: [{
-          name: 'a',
-          type: 'text'
-        }, {
-          name: 'b',
-          type: 'text'
-        }, {
-          name: 'c',
-          type: 'text'
-        }]
-      }];
-      const valueFrom = {
-        arrayField: {
-          en: [{
-            a: 'original',
-            b: 'original',
-            c: 'original'
-          }],
-          de: [{
+    it('should count changed fields inside group fields', ()=>{
+        const fields = [
+            {
+                type: 'group',
+                name: 'group',
+                fields: [
+                    {
+                        name: 'a',
+                        type: 'text'
+                    },
+                    {
+                        name: 'b',
+                        type: 'text'
+                    },
+                    {
+                        name: 'c',
+                        type: 'text'
+                    }
+                ]
+            }
+        ];
+        const valueFrom = {
+            group: {
+                a: 'original',
+                b: 'original',
+                c: 'original'
+            }
+        };
+        const valueTo = {
+            group: {
+                a: 'changed',
+                b: 'changed',
+                c: 'original'
+            }
+        };
+        const result = countChangedFields({
+            valueFrom,
+            fields,
+            valueTo,
+            locales
+        });
+        expect(result).toBe(2);
+    });
+    it('should count changed fields inside unnamed tabs ', ()=>{
+        const fields = [
+            {
+                type: 'tabs',
+                tabs: [
+                    {
+                        label: 'Unnamed tab',
+                        fields: [
+                            {
+                                name: 'a',
+                                type: 'text'
+                            },
+                            {
+                                name: 'b',
+                                type: 'text'
+                            },
+                            {
+                                name: 'c',
+                                type: 'text'
+                            }
+                        ]
+                    }
+                ]
+            }
+        ];
+        const valueFrom = {
             a: 'original',
             b: 'original',
             c: 'original'
-          }]
-        }
-      };
-      const valueTo = {
-        arrayField: {
-          en: [{
+        };
+        const valueTo = {
             a: 'changed',
             b: 'changed',
             c: 'original'
-          }],
-          de: [{
-            a: 'original',
-            b: 'changed',
-            c: 'original'
-          }]
-        }
-      };
-      const result = countChangedFields({
-        valueFrom,
-        fields,
-        valueTo,
-        locales
-      });
-      expect(result).toBe(3);
+        };
+        const result = countChangedFields({
+            valueFrom,
+            fields,
+            valueTo,
+            locales
+        });
+        expect(result).toBe(2);
+    });
+    it('should count changed fields inside named tabs ', ()=>{
+        const fields = [
+            {
+                type: 'tabs',
+                tabs: [
+                    {
+                        name: 'namedTab',
+                        fields: [
+                            {
+                                name: 'a',
+                                type: 'text'
+                            },
+                            {
+                                name: 'b',
+                                type: 'text'
+                            },
+                            {
+                                name: 'c',
+                                type: 'text'
+                            }
+                        ]
+                    }
+                ]
+            }
+        ];
+        const valueFrom = {
+            namedTab: {
+                a: 'original',
+                b: 'original',
+                c: 'original'
+            }
+        };
+        const valueTo = {
+            namedTab: {
+                a: 'changed',
+                b: 'changed',
+                c: 'original'
+            }
+        };
+        const result = countChangedFields({
+            valueFrom,
+            fields,
+            valueTo,
+            locales
+        });
+        expect(result).toBe(2);
     });
-    it('should count changed fields inside localized blocks fields', () => {
-      const fields = [{
-        name: 'blocks',
-        type: 'blocks',
-        localized: true,
-        blocks: [{
-          slug: 'blockA',
-          fields: [{
-            name: 'a',
-            type: 'text'
-          }, {
-            name: 'b',
-            type: 'text'
-          }, {
-            name: 'c',
-            type: 'text'
-          }]
-        }]
-      }];
-      const valueFrom = {
-        blocks: {
-          en: [{
-            blockType: 'blockA',
+    it('should ignore UI fields', ()=>{
+        const fields = [
+            {
+                name: 'a',
+                type: 'text'
+            },
+            {
+                name: 'b',
+                type: 'ui',
+                admin: {}
+            }
+        ];
+        const valueFrom = {
             a: 'original',
-            b: 'original',
-            c: 'original'
-          }],
-          de: [{
-            blockType: 'blockA',
+            b: 'original'
+        };
+        const valueTo = {
             a: 'original',
-            b: 'original',
-            c: 'original'
-          }]
-        }
-      };
-      const valueTo = {
-        blocks: {
-          en: [{
-            blockType: 'blockA',
-            a: 'changed',
-            b: 'changed',
-            c: 'original'
-          }],
-          de: [{
-            blockType: 'blockA',
-            a: 'original',
-            b: 'changed',
-            c: 'original'
-          }]
-        }
-      };
-      const result = countChangedFields({
-        valueFrom,
-        fields,
-        valueTo,
-        locales
-      });
-      expect(result).toBe(3);
+            b: 'changed'
+        };
+        const result = countChangedFields({
+            valueFrom,
+            fields,
+            valueTo,
+            locales
+        });
+        expect(result).toBe(0);
+    });
+    it('should count changed fields inside array fields', ()=>{
+        const fields = [
+            {
+                name: 'arrayField',
+                type: 'array',
+                fields: [
+                    {
+                        name: 'a',
+                        type: 'text'
+                    },
+                    {
+                        name: 'b',
+                        type: 'text'
+                    },
+                    {
+                        name: 'c',
+                        type: 'text'
+                    }
+                ]
+            }
+        ];
+        const valueFrom = {
+            arrayField: [
+                {
+                    a: 'original',
+                    b: 'original',
+                    c: 'original'
+                },
+                {
+                    a: 'original',
+                    b: 'original'
+                }
+            ]
+        };
+        const valueTo = {
+            arrayField: [
+                {
+                    a: 'changed',
+                    b: 'changed',
+                    c: 'original'
+                },
+                {
+                    a: 'changed',
+                    b: 'changed',
+                    c: 'changed'
+                }
+            ]
+        };
+        const result = countChangedFields({
+            valueFrom,
+            fields,
+            valueTo,
+            locales
+        });
+        expect(result).toBe(5);
+    });
+    it('should count changed fields inside arrays nested inside of collapsibles', ()=>{
+        const fields = [
+            {
+                type: 'collapsible',
+                label: 'A collapsible field',
+                fields: [
+                    {
+                        name: 'arrayField',
+                        type: 'array',
+                        fields: [
+                            {
+                                name: 'a',
+                                type: 'text'
+                            },
+                            {
+                                name: 'b',
+                                type: 'text'
+                            },
+                            {
+                                name: 'c',
+                                type: 'text'
+                            }
+                        ]
+                    }
+                ]
+            }
+        ];
+        const valueFrom = {
+            arrayField: [
+                {
+                    a: 'original',
+                    b: 'original',
+                    c: 'original'
+                }
+            ]
+        };
+        const valueTo = {
+            arrayField: [
+                {
+                    a: 'changed',
+                    b: 'changed',
+                    c: 'original'
+                }
+            ]
+        };
+        const result = countChangedFields({
+            valueFrom,
+            fields,
+            valueTo,
+            locales
+        });
+        expect(result).toBe(2);
+    });
+    it('should count changed fields inside blocks fields', ()=>{
+        const fields = [
+            {
+                name: 'blocks',
+                type: 'blocks',
+                blocks: [
+                    {
+                        slug: 'blockA',
+                        fields: [
+                            {
+                                name: 'a',
+                                type: 'text'
+                            },
+                            {
+                                name: 'b',
+                                type: 'text'
+                            },
+                            {
+                                name: 'c',
+                                type: 'text'
+                            }
+                        ]
+                    }
+                ]
+            }
+        ];
+        const valueFrom = {
+            blocks: [
+                {
+                    blockType: 'blockA',
+                    a: 'original',
+                    b: 'original',
+                    c: 'original'
+                },
+                {
+                    blockType: 'blockA',
+                    a: 'original',
+                    b: 'original'
+                }
+            ]
+        };
+        const valueTo = {
+            blocks: [
+                {
+                    blockType: 'blockA',
+                    a: 'changed',
+                    b: 'changed',
+                    c: 'original'
+                },
+                {
+                    blockType: 'blockA',
+                    a: 'changed',
+                    b: 'changed',
+                    c: 'changed'
+                }
+            ]
+        };
+        const result = countChangedFields({
+            valueFrom,
+            fields,
+            valueTo,
+            locales
+        });
+        expect(result).toBe(5);
+    });
+    it('should count changed fields between blocks with different slugs', ()=>{
+        const fields = [
+            {
+                name: 'blocks',
+                type: 'blocks',
+                blocks: [
+                    {
+                        slug: 'blockA',
+                        fields: [
+                            {
+                                name: 'a',
+                                type: 'text'
+                            },
+                            {
+                                name: 'b',
+                                type: 'text'
+                            },
+                            {
+                                name: 'c',
+                                type: 'text'
+                            }
+                        ]
+                    },
+                    {
+                        slug: 'blockB',
+                        fields: [
+                            {
+                                name: 'b',
+                                type: 'text'
+                            },
+                            {
+                                name: 'c',
+                                type: 'text'
+                            },
+                            {
+                                name: 'd',
+                                type: 'text'
+                            }
+                        ]
+                    }
+                ]
+            }
+        ];
+        const valueFrom = {
+            blocks: [
+                {
+                    blockType: 'blockA',
+                    a: 'removed',
+                    b: 'original',
+                    c: 'original'
+                }
+            ]
+        };
+        const valueTo = {
+            blocks: [
+                {
+                    blockType: 'blockB',
+                    b: 'original',
+                    c: 'changed',
+                    d: 'new'
+                }
+            ]
+        };
+        const result = countChangedFields({
+            valueFrom,
+            fields,
+            valueTo,
+            locales
+        });
+        expect(result).toBe(3);
+    });
+    describe('localized fields', ()=>{
+        const locales = [
+            'en',
+            'de'
+        ];
+        it('should count simple localized fields', ()=>{
+            const fields = [
+                {
+                    name: 'a',
+                    type: 'text',
+                    localized: true
+                },
+                {
+                    name: 'b',
+                    type: 'text',
+                    localized: true
+                }
+            ];
+            const valueFrom = {
+                a: {
+                    en: 'original',
+                    de: 'original'
+                },
+                b: {
+                    en: 'original',
+                    de: 'original'
+                }
+            };
+            const valueTo = {
+                a: {
+                    en: 'changed',
+                    de: 'original'
+                },
+                b: {
+                    en: 'original',
+                    de: 'original'
+                }
+            };
+            const result = countChangedFields({
+                valueFrom,
+                fields,
+                valueTo,
+                locales
+            });
+            expect(result).toBe(1);
+        });
+        it('should count multiple locales of the same localized field', ()=>{
+            const locales = [
+                'en',
+                'de'
+            ];
+            const fields = [
+                {
+                    name: 'a',
+                    type: 'text',
+                    localized: true
+                },
+                {
+                    name: 'b',
+                    type: 'text',
+                    localized: true
+                }
+            ];
+            const valueFrom = {
+                a: {
+                    en: 'original',
+                    de: 'original'
+                },
+                b: {
+                    en: 'original',
+                    de: 'original'
+                }
+            };
+            const valueTo = {
+                a: {
+                    en: 'changed',
+                    de: 'changed'
+                },
+                b: {
+                    en: 'original',
+                    de: 'original'
+                }
+            };
+            const result = countChangedFields({
+                valueFrom,
+                fields,
+                valueTo,
+                locales
+            });
+            expect(result).toBe(2);
+        });
+        it('should count changed fields inside localized groups fields', ()=>{
+            const fields = [
+                {
+                    type: 'group',
+                    name: 'group',
+                    localized: true,
+                    fields: [
+                        {
+                            name: 'a',
+                            type: 'text'
+                        },
+                        {
+                            name: 'b',
+                            type: 'text'
+                        },
+                        {
+                            name: 'c',
+                            type: 'text'
+                        }
+                    ]
+                }
+            ];
+            const valueFrom = {
+                group: {
+                    en: {
+                        a: 'original',
+                        b: 'original',
+                        c: 'original'
+                    },
+                    de: {
+                        a: 'original',
+                        b: 'original',
+                        c: 'original'
+                    }
+                }
+            };
+            const valueTo = {
+                group: {
+                    en: {
+                        a: 'changed',
+                        b: 'changed',
+                        c: 'original'
+                    },
+                    de: {
+                        a: 'original',
+                        b: 'changed',
+                        c: 'original'
+                    }
+                }
+            };
+            const result = countChangedFields({
+                valueFrom,
+                fields,
+                valueTo,
+                locales
+            });
+            expect(result).toBe(3);
+        });
+        it('should count changed fields inside localized tabs', ()=>{
+            const fields = [
+                {
+                    type: 'tabs',
+                    tabs: [
+                        {
+                            name: 'tab',
+                            localized: true,
+                            fields: [
+                                {
+                                    name: 'a',
+                                    type: 'text'
+                                },
+                                {
+                                    name: 'b',
+                                    type: 'text'
+                                },
+                                {
+                                    name: 'c',
+                                    type: 'text'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ];
+            const valueFrom = {
+                tab: {
+                    en: {
+                        a: 'original',
+                        b: 'original',
+                        c: 'original'
+                    },
+                    de: {
+                        a: 'original',
+                        b: 'original',
+                        c: 'original'
+                    }
+                }
+            };
+            const valueTo = {
+                tab: {
+                    en: {
+                        a: 'changed',
+                        b: 'changed',
+                        c: 'original'
+                    },
+                    de: {
+                        a: 'original',
+                        b: 'changed',
+                        c: 'original'
+                    }
+                }
+            };
+            const result = countChangedFields({
+                valueFrom,
+                fields,
+                valueTo,
+                locales
+            });
+            expect(result).toBe(3);
+        });
+        it('should count changed fields inside localized array fields', ()=>{
+            const fields = [
+                {
+                    name: 'arrayField',
+                    type: 'array',
+                    localized: true,
+                    fields: [
+                        {
+                            name: 'a',
+                            type: 'text'
+                        },
+                        {
+                            name: 'b',
+                            type: 'text'
+                        },
+                        {
+                            name: 'c',
+                            type: 'text'
+                        }
+                    ]
+                }
+            ];
+            const valueFrom = {
+                arrayField: {
+                    en: [
+                        {
+                            a: 'original',
+                            b: 'original',
+                            c: 'original'
+                        }
+                    ],
+                    de: [
+                        {
+                            a: 'original',
+                            b: 'original',
+                            c: 'original'
+                        }
+                    ]
+                }
+            };
+            const valueTo = {
+                arrayField: {
+                    en: [
+                        {
+                            a: 'changed',
+                            b: 'changed',
+                            c: 'original'
+                        }
+                    ],
+                    de: [
+                        {
+                            a: 'original',
+                            b: 'changed',
+                            c: 'original'
+                        }
+                    ]
+                }
+            };
+            const result = countChangedFields({
+                valueFrom,
+                fields,
+                valueTo,
+                locales
+            });
+            expect(result).toBe(3);
+        });
+        it('should count changed fields inside localized blocks fields', ()=>{
+            const fields = [
+                {
+                    name: 'blocks',
+                    type: 'blocks',
+                    localized: true,
+                    blocks: [
+                        {
+                            slug: 'blockA',
+                            fields: [
+                                {
+                                    name: 'a',
+                                    type: 'text'
+                                },
+                                {
+                                    name: 'b',
+                                    type: 'text'
+                                },
+                                {
+                                    name: 'c',
+                                    type: 'text'
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ];
+            const valueFrom = {
+                blocks: {
+                    en: [
+                        {
+                            blockType: 'blockA',
+                            a: 'original',
+                            b: 'original',
+                            c: 'original'
+                        }
+                    ],
+                    de: [
+                        {
+                            blockType: 'blockA',
+                            a: 'original',
+                            b: 'original',
+                            c: 'original'
+                        }
+                    ]
+                }
+            };
+            const valueTo = {
+                blocks: {
+                    en: [
+                        {
+                            blockType: 'blockA',
+                            a: 'changed',
+                            b: 'changed',
+                            c: 'original'
+                        }
+                    ],
+                    de: [
+                        {
+                            blockType: 'blockA',
+                            a: 'original',
+                            b: 'changed',
+                            c: 'original'
+                        }
+                    ]
+                }
+            };
+            const result = countChangedFields({
+                valueFrom,
+                fields,
+                valueTo,
+                locales
+            });
+            expect(result).toBe(3);
+        });
     });
-  });
 });
-describe('countChangedFieldsInRows', () => {
-  it('should count fields in array rows', () => {
-    const field = {
-      name: 'myArray',
-      type: 'array',
-      fields: [{
-        name: 'a',
-        type: 'text'
-      }, {
-        name: 'b',
-        type: 'text'
-      }, {
-        name: 'c',
-        type: 'text'
-      }]
-    };
-    const valueFromRows = [{
-      a: 'original',
-      b: 'original',
-      c: 'original'
-    }];
-    const valueToRows = [{
-      a: 'changed',
-      b: 'changed',
-      c: 'original'
-    }];
-    const result = countChangedFieldsInRows({
-      valueFromRows,
-      field,
-      locales: undefined,
-      valueToRows: valueToRows
+describe('countChangedFieldsInRows', ()=>{
+    it('should count fields in array rows', ()=>{
+        const field = {
+            name: 'myArray',
+            type: 'array',
+            fields: [
+                {
+                    name: 'a',
+                    type: 'text'
+                },
+                {
+                    name: 'b',
+                    type: 'text'
+                },
+                {
+                    name: 'c',
+                    type: 'text'
+                }
+            ]
+        };
+        const valueFromRows = [
+            {
+                a: 'original',
+                b: 'original',
+                c: 'original'
+            }
+        ];
+        const valueToRows = [
+            {
+                a: 'changed',
+                b: 'changed',
+                c: 'original'
+            }
+        ];
+        const result = countChangedFieldsInRows({
+            valueFromRows,
+            field,
+            locales: undefined,
+            valueToRows: valueToRows
+        });
+        expect(result).toBe(2);
     });
-    expect(result).toBe(2);
-  });
-  it('should count fields in blocks', () => {
-    const field = {
-      name: 'myBlocks',
-      type: 'blocks',
-      blocks: [{
-        slug: 'blockA',
-        fields: [{
-          name: 'a',
-          type: 'text'
-        }, {
-          name: 'b',
-          type: 'text'
-        }, {
-          name: 'c',
-          type: 'text'
-        }]
-      }]
-    };
-    const valueFromRows = [{
-      blockType: 'blockA',
-      a: 'original',
-      b: 'original',
-      c: 'original'
-    }];
-    const valueToRows = [{
-      blockType: 'blockA',
-      a: 'changed',
-      b: 'changed',
-      c: 'original'
-    }];
-    const result = countChangedFieldsInRows({
-      valueFromRows,
-      field,
-      locales: undefined,
-      valueToRows
+    it('should count fields in blocks', ()=>{
+        const field = {
+            name: 'myBlocks',
+            type: 'blocks',
+            blocks: [
+                {
+                    slug: 'blockA',
+                    fields: [
+                        {
+                            name: 'a',
+                            type: 'text'
+                        },
+                        {
+                            name: 'b',
+                            type: 'text'
+                        },
+                        {
+                            name: 'c',
+                            type: 'text'
+                        }
+                    ]
+                }
+            ]
+        };
+        const valueFromRows = [
+            {
+                blockType: 'blockA',
+                a: 'original',
+                b: 'original',
+                c: 'original'
+            }
+        ];
+        const valueToRows = [
+            {
+                blockType: 'blockA',
+                a: 'changed',
+                b: 'changed',
+                c: 'original'
+            }
+        ];
+        const result = countChangedFieldsInRows({
+            valueFromRows,
+            field,
+            locales: undefined,
+            valueToRows
+        });
+        expect(result).toBe(2);
     });
-    expect(result).toBe(2);
-  });
 });
+
 //# sourceMappingURL=countChangedFields.spec.js.map