slice-machine-ui 2.16.2-alpha.jp-cr-empty-customtypes.2 → 2.16.2-alpha.jp-cr-ui-fix-invalid-fields-checked.1

package/src/features/builder/fields/contentRelationship/__tests__/ContentRelationshipFieldPicker.test.ts

@@ -1,3 +1,4 @@
+import { CustomType } from "@prismicio/types-internal/lib/customtypes";
 import { describe, expect, it } from "vitest";
 
 import {
@@ -6,260 +7,1177 @@ import {
 } from "../ContentRelationshipFieldPicker";
 
 describe("ContentRelationshipFieldPicker", () => {
-  it("should count picked fields with a custom type as string", () => {
-    const customtypes = ["ct1"];
+  describe("countPickedFields", () => {
+    const allCustomTypes: CustomType[] = [
+      {
+        id: "ct1",
+        label: "CT 1",
+        repeatable: false,
+        status: true,
+        json: {
+          Main: {
+            f1: {
+              type: "Link",
+              config: {
+                select: "document",
+                customtypes: ["ct2"],
+              },
+            },
+            f2: {
+              type: "Link",
+              config: {
+                select: "document",
+                customtypes: ["ct2"],
+              },
+            },
+            g1: {
+              type: "Group",
+              config: {
+                fields: {
+                  f1: {
+                    type: "Boolean",
+                  },
+                  f2: {
+                    type: "Link",
+                    config: {
+                      select: "document",
+                      customtypes: ["ct2"],
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+      {
+        id: "ct2",
+        label: "CT 2",
+        repeatable: false,
+        status: true,
+        json: {
+          Main: {
+            f1: {
+              type: "Boolean",
+            },
+            g2: {
+              type: "Group",
+              config: {
+                fields: {
+                  f1: {
+                    type: "Boolean",
+                  },
+                  f2: {
+                    type: "Boolean",
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    ];
 
-    const result = countPickedFields(
-      convertLinkCustomtypesToFieldCheckMap(customtypes),
-    );
+    it("should count picked fields with a custom type as string", () => {
+      const customtypes = ["ct1"];
 
-    expect(result).toEqual({
-      pickedFields: 0,
-      nestedPickedFields: 0,
+      const result = countPickedFields(
+        convertLinkCustomtypesToFieldCheckMap({
+          linkCustomtypes: customtypes,
+          allCustomTypes,
+        }),
+      );
+
+      expect(result).toEqual({
+        pickedFields: 0,
+        nestedPickedFields: 0,
+      });
     });
-  });
 
-  it("should count picked fields with multiple custom types as string", () => {
-    const customtypes = ["ct1", "ct2"];
+    it("should count picked fields with multiple custom types as string", () => {
+      const customtypes = ["ct1", "ct2"];
 
-    const result = countPickedFields(
-      convertLinkCustomtypesToFieldCheckMap(customtypes),
-    );
+      const result = countPickedFields(
+        convertLinkCustomtypesToFieldCheckMap({
+          linkCustomtypes: customtypes,
+          allCustomTypes,
+        }),
+      );
 
-    expect(result).toEqual({
-      pickedFields: 0,
-      nestedPickedFields: 0,
+      expect(result).toEqual({
+        pickedFields: 0,
+        nestedPickedFields: 0,
+      });
     });
-  });
 
-  it("should count picked fields with custom type as object and one field", () => {
-    const customtypes = [
-      {
-        id: "ct1",
-        fields: ["f1"],
-      },
-    ];
+    it("should count picked fields with custom type as object and one field", () => {
+      const customtypes = [
+        {
+          id: "ct1",
+          fields: ["f1"],
+        },
+      ];
+
+      const result = countPickedFields(
+        convertLinkCustomtypesToFieldCheckMap({
+          linkCustomtypes: customtypes,
+          allCustomTypes,
+        }),
+      );
+
+      expect(result).toEqual({
+        pickedFields: 1,
+        nestedPickedFields: 0,
+      });
+    });
+
+    it("should count picked fields with custom type as object and one nested field", () => {
+      const customtypes = [
+        {
+          id: "ct1",
+          fields: [
+            {
+              id: "f1",
+              customtypes: [
+                {
+                  id: "ct2",
+                  fields: ["f1"],
+                },
+              ],
+            },
+          ],
+        },
+      ];
+
+      const result = countPickedFields(
+        convertLinkCustomtypesToFieldCheckMap({
+          linkCustomtypes: customtypes,
+          allCustomTypes,
+        }),
+      );
+
+      expect(result).toEqual({
+        pickedFields: 1,
+        nestedPickedFields: 1,
+      });
+    });
+
+    it("should count picked fields with custom type as object with group field", () => {
+      const customtypes = [
+        {
+          id: "ct1",
+          fields: [
+            {
+              id: "g1",
+              fields: ["f1", "f2"],
+            },
+          ],
+        },
+      ];
+
+      const test = convertLinkCustomtypesToFieldCheckMap({
+        linkCustomtypes: customtypes,
+        allCustomTypes,
+      });
+      const result = countPickedFields(test);
 
-    const result = countPickedFields(
-      convertLinkCustomtypesToFieldCheckMap(customtypes),
-    );
+      expect(result).toEqual({
+        pickedFields: 2,
+        nestedPickedFields: 0,
+      });
+    });
+
+    it("should count picked fields with custom type as object with group field and nested custom type", () => {
+      const customtypes = [
+        {
+          id: "ct1",
+          fields: [
+            {
+              id: "g1",
+              fields: [
+                "f1",
+                {
+                  id: "f2",
+                  customtypes: [
+                    {
+                      id: "ct2",
+                      fields: ["f1"],
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ];
+
+      const result = countPickedFields(
+        convertLinkCustomtypesToFieldCheckMap({
+          linkCustomtypes: customtypes,
+          allCustomTypes,
+        }),
+      );
+
+      expect(result).toEqual({
+        pickedFields: 2,
+        nestedPickedFields: 1,
+      });
+    });
+
+    it("should count picked fields with custom type as object with group field, nested custom type and nested group field", () => {
+      const customtypes = [
+        {
+          id: "ct1",
+          fields: [
+            {
+              id: "g1",
+              fields: [
+                "f1",
+                {
+                  id: "f2",
+                  customtypes: [
+                    {
+                      id: "ct2",
+                      fields: [
+                        "f1",
+                        {
+                          id: "g2",
+                          fields: ["f1", "f2"],
+                        },
+                      ],
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ];
+
+      const result = countPickedFields(
+        convertLinkCustomtypesToFieldCheckMap({
+          linkCustomtypes: customtypes,
+          allCustomTypes,
+        }),
+      );
+
+      expect(result).toEqual({
+        pickedFields: 4,
+        nestedPickedFields: 3,
+      });
+    });
+
+    it("should count picked fields with custom type as object with nested custom type and nested group field", () => {
+      const customtypes = [
+        {
+          id: "ct1",
+          fields: [
+            "f1",
+            {
+              id: "f2",
+              customtypes: [
+                {
+                  id: "ct2",
+                  fields: [
+                    "f1",
+                    {
+                      id: "g2",
+                      fields: ["f1", "f2"],
+                    },
+                  ],
+                },
+              ],
+            },
+          ],
+        },
+      ];
+
+      const result = countPickedFields(
+        convertLinkCustomtypesToFieldCheckMap({
+          linkCustomtypes: customtypes,
+          allCustomTypes,
+        }),
+      );
+
+      expect(result).toEqual({
+        pickedFields: 4,
+        nestedPickedFields: 3,
+      });
+    });
+
+    it("should count picked fields with custom type as object with nested custom type without fields", () => {
+      const customtypes = [
+        {
+          id: "ct1",
+          fields: [
+            "f1",
+            {
+              id: "f2",
+              customtypes: [
+                {
+                  id: "ct2",
+                  fields: [],
+                },
+              ],
+            },
+          ],
+        },
+      ];
+
+      const result = countPickedFields(
+        convertLinkCustomtypesToFieldCheckMap({
+          linkCustomtypes: customtypes,
+          allCustomTypes,
+        }),
+      );
+
+      expect(result).toEqual({
+        pickedFields: 1,
+        nestedPickedFields: 0,
+      });
+    });
+
+    it("should count picked fields with custom type as object with group field without fields", () => {
+      const customtypes = [
+        {
+          id: "ct1",
+          fields: [
+            "f1",
+            {
+              id: "g1",
+              fields: [],
+            },
+          ],
+        },
+      ];
 
-    expect(result).toEqual({
-      pickedFields: 1,
-      nestedPickedFields: 0,
+      const result = countPickedFields(
+        convertLinkCustomtypesToFieldCheckMap({
+          linkCustomtypes: customtypes,
+          allCustomTypes,
+        }),
+      );
+
+      expect(result).toEqual({
+        pickedFields: 1,
+        nestedPickedFields: 0,
+      });
     });
   });
 
-  it("should count picked fields with custom type as object and one nested field", () => {
-    const customtypes = [
-      {
-        id: "ct1",
-        fields: [
+  describe("createContentRelationshipFieldCheckMap", () => {
+    it("should include existing/valid referenced fields", () => {
+      const customType: CustomType = {
+        id: "customType",
+        label: "Custom Type",
+        repeatable: false,
+        status: true,
+        json: {
+          Main: {
+            textField: {
+              type: "Text",
+            },
+            booleanField: {
+              type: "Boolean",
+            },
+            structuredTextField: {
+              type: "StructuredText",
+            },
+            imageField: {
+              type: "Image",
+            },
+            linkField: {
+              type: "Link",
+            },
+            colorField: {
+              type: "Color",
+            },
+            dateField: {
+              type: "Date",
+            },
+            geoPointField: {
+              type: "GeoPoint",
+            },
+            slicesField: {
+              type: "GeoPoint",
+            },
+            numberField: {
+              type: "Number",
+            },
+            rangeField: {
+              type: "Range",
+            },
+            selectField: {
+              type: "Select",
+            },
+            timestampField: {
+              type: "Timestamp",
+            },
+            separatorField: {
+              type: "Separator",
+            },
+            tableField: {
+              type: "Table",
+            },
+            integrationFieldsField: {
+              type: "IntegrationFields",
+            },
+          },
+        },
+      };
+
+      const result = convertLinkCustomtypesToFieldCheckMap({
+        linkCustomtypes: [
           {
-            id: "f1",
-            customtypes: [
+            id: "customType",
+            fields: [
+              "textField",
+              "booleanField",
+              "structuredTextField",
+              "imageField",
+              "linkField",
+              "colorField",
+              "dateField",
+              "geoPointField",
+              "slicesField",
+              "numberField",
+              "rangeField",
+              "selectField",
+              "timestampField",
+              "separatorField",
+              "tableField",
+              "integrationFieldsField",
+            ],
+          },
+        ],
+        allCustomTypes: [customType],
+      });
+
+      expect(result).toEqual({
+        customType: {
+          textField: {
+            type: "checkbox",
+            value: true,
+          },
+          booleanField: {
+            type: "checkbox",
+            value: true,
+          },
+          structuredTextField: {
+            type: "checkbox",
+            value: true,
+          },
+          imageField: {
+            type: "checkbox",
+            value: true,
+          },
+          linkField: {
+            type: "checkbox",
+            value: true,
+          },
+          colorField: {
+            type: "checkbox",
+            value: true,
+          },
+          dateField: {
+            type: "checkbox",
+            value: true,
+          },
+          geoPointField: {
+            type: "checkbox",
+            value: true,
+          },
+          slicesField: {
+            type: "checkbox",
+            value: true,
+          },
+          numberField: {
+            type: "checkbox",
+            value: true,
+          },
+          rangeField: {
+            type: "checkbox",
+            value: true,
+          },
+          selectField: {
+            type: "checkbox",
+            value: true,
+          },
+          timestampField: {
+            type: "checkbox",
+            value: true,
+          },
+          separatorField: {
+            type: "checkbox",
+            value: true,
+          },
+          tableField: {
+            type: "checkbox",
+            value: true,
+          },
+          integrationFieldsField: {
+            type: "checkbox",
+            value: true,
+          },
+        },
+      });
+    });
+
+    it("should not include non-existing/invalid referenced fields", () => {
+      const customType2: CustomType = {
+        id: "customType2",
+        label: "Custom Type 2",
+        repeatable: false,
+        status: true,
+        json: {
+          Main: {
+            booleanField: {
+              type: "Boolean",
+            },
+          },
+        },
+      };
+
+      const customType: CustomType = {
+        id: "customType",
+        label: "Custom Type",
+        repeatable: false,
+        status: true,
+        json: {
+          Main: {
+            mdField: {
+              type: "StructuredText",
+            },
+            crField: {
+              type: "Link",
+              config: {
+                select: "document",
+                customtypes: ["customType2"],
+              },
+            },
+            groupField: {
+              type: "Group",
+              config: {
+                fields: {
+                  groupFieldA: {
+                    type: "Boolean",
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
+
+      const result = convertLinkCustomtypesToFieldCheckMap({
+        linkCustomtypes: [
+          {
+            id: "customType",
+            fields: [
+              "mdField",
+              "nonExistingField",
+              {
+                id: "nonExistingGroup",
+                fields: ["groupFieldA"],
+              },
+              {
+                id: "crField",
+                customtypes: [
+                  {
+                    id: "customType2",
+                    fields: ["nonExistingNestedField"],
+                  },
+                ],
+              },
               {
-                id: "ct2",
-                fields: ["f1"],
+                id: "groupField",
+                fields: ["nonExistingGroupField"],
               },
             ],
           },
         ],
-      },
-    ];
-
-    const result = countPickedFields(
-      convertLinkCustomtypesToFieldCheckMap(customtypes),
-    );
+        allCustomTypes: [customType, customType2],
+      });
 
-    expect(result).toEqual({
-      pickedFields: 1,
-      nestedPickedFields: 1,
+      expect(result).toEqual({
+        customType: {
+          mdField: {
+            type: "checkbox",
+            value: true,
+          },
+        },
+      });
     });
-  });
 
-  it("should count picked fields with custom type as object with group field", () => {
-    const customtypes = [
-      {
-        id: "ct1",
-        fields: [
+    it("should not include an invalid field (uid, slices & choice)", () => {
+      const customType: CustomType = {
+        id: "customType",
+        label: "Custom Type",
+        repeatable: false,
+        status: true,
+        json: {
+          Main: {
+            booleanField: {
+              type: "Boolean",
+            },
+            typeUid: {
+              type: "UID",
+            },
+            uid: {
+              type: "Boolean",
+            },
+            choice: {
+              type: "Choice",
+              config: {
+                choices: {
+                  choice1: {
+                    type: "Boolean",
+                  },
+                },
+              },
+            },
+            slices: {
+              type: "Slices",
+              config: {
+                choices: {
+                  slice1: {
+                    type: "SharedSlice",
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
+
+      const result = convertLinkCustomtypesToFieldCheckMap({
+        linkCustomtypes: [
           {
-            id: "g1",
-            fields: ["f1", "f2"],
+            id: "customType",
+            fields: ["booleanField", "typeUid", "uid", "choice", "slices"],
           },
         ],
-      },
-    ];
+        allCustomTypes: [customType],
+      });
 
-    const result = countPickedFields(
-      convertLinkCustomtypesToFieldCheckMap(customtypes),
-    );
+      expect(result).toEqual({
+        customType: {
+          booleanField: {
+            type: "checkbox",
+            value: true,
+          },
+        },
+      });
+    });
 
-    expect(result).toEqual({
-      pickedFields: 2,
-      nestedPickedFields: 0,
+    it("should include a correctly referenced group field", () => {
+      const customType: CustomType = {
+        id: "customType",
+        label: "Custom Type",
+        repeatable: false,
+        status: true,
+        json: {
+          Main: {
+            groupField: {
+              type: "Group",
+              config: {
+                label: "Group Field",
+                fields: {
+                  booleanField: {
+                    type: "Boolean",
+                    config: {
+                      label: "Boolean Field",
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
+
+      const result = convertLinkCustomtypesToFieldCheckMap({
+        linkCustomtypes: [
+          {
+            id: "customType",
+            fields: [
+              {
+                id: "groupField",
+                fields: ["booleanField"],
+              },
+            ],
+          },
+        ],
+        allCustomTypes: [customType],
+      });
+
+      expect(result).toEqual({
+        customType: {
+          groupField: {
+            type: "group",
+            value: {
+              booleanField: {
+                type: "checkbox",
+                value: true,
+              },
+            },
+          },
+        },
+      });
     });
-  });
 
-  it("should count picked fields with custom type as object with group field and nested custom type", () => {
-    const customtypes = [
-      {
-        id: "ct1",
-        fields: [
+    it("should include a field correctly referenced as a group inside a nested custom type", () => {
+      const customType: CustomType = {
+        id: "customType",
+        label: "Custom Type",
+        repeatable: false,
+        status: true,
+        json: {
+          Main: {
+            groupField: {
+              type: "Group",
+              config: {
+                label: "Group Field",
+                fields: {
+                  booleanField: {
+                    type: "Boolean",
+                    config: {
+                      label: "Boolean Field",
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
+
+      const customTypeWithContentRelationship: CustomType = {
+        id: "customTypeWithContentRelationship",
+        label: "Custom Type With Content Relationship",
+        repeatable: false,
+        status: true,
+        json: {
+          Main: {
+            contentRelationshipField: {
+              type: "Link",
+              config: {
+                select: "document",
+                customtypes: ["customType"],
+              },
+            },
+          },
+        },
+      };
+
+      const result = convertLinkCustomtypesToFieldCheckMap({
+        linkCustomtypes: [
           {
-            id: "g1",
+            id: "customTypeWithContentRelationship",
             fields: [
-              "f1",
               {
-                id: "f2",
+                id: "contentRelationshipField",
                 customtypes: [
                   {
-                    id: "ct2",
-                    fields: ["f1"],
+                    id: "customType",
+                    fields: [
+                      {
+                        id: "groupField",
+                        fields: ["booleanField"],
+                      },
+                    ],
                   },
                 ],
               },
             ],
           },
         ],
-      },
-    ];
+        allCustomTypes: [customType, customTypeWithContentRelationship],
+      });
+
+      expect(result).toEqual({
+        customTypeWithContentRelationship: {
+          contentRelationshipField: {
+            type: "contentRelationship",
+            value: {
+              customType: {
+                groupField: {
+                  type: "group",
+                  value: {
+                    booleanField: {
+                      type: "checkbox",
+                      value: true,
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      });
+    });
 
-    const result = countPickedFields(
-      convertLinkCustomtypesToFieldCheckMap(customtypes),
-    );
+    it("should not include a regular field incorrectly referenced as a group", () => {
+      const customType: CustomType = {
+        id: "customType",
+        label: "Custom Type",
+        repeatable: false,
+        status: true,
+        json: {
+          Main: {
+            booleanField: {
+              type: "Boolean",
+            },
+          },
+        },
+      };
+
+      const result = convertLinkCustomtypesToFieldCheckMap({
+        linkCustomtypes: [
+          {
+            id: "customType",
+            fields: [
+              {
+                id: "groupField",
+                fields: ["booleanField"],
+              },
+            ],
+          },
+        ],
+        allCustomTypes: [customType],
+      });
 
-    expect(result).toEqual({
-      pickedFields: 2,
-      nestedPickedFields: 1,
+      expect(result).toEqual({});
     });
-  });
 
-  it("should count picked fields with custom type as object with group field, nested custom type and nested group field", () => {
-    const customtypes = [
-      {
-        id: "ct1",
-        fields: [
+    it("should not include a field referenced as a group field when it's not one", () => {
+      const customType: CustomType = {
+        id: "customType",
+        label: "Custom Type",
+        repeatable: false,
+        status: true,
+        json: {
+          Main: {
+            booleanField: {
+              type: "Boolean",
+            },
+          },
+        },
+      };
+
+      const result = convertLinkCustomtypesToFieldCheckMap({
+        linkCustomtypes: [
+          {
+            id: "customType",
+            fields: [
+              {
+                id: "booleanField",
+                fields: ["fieldA"],
+              },
+            ],
+          },
+        ],
+        allCustomTypes: [customType],
+      });
+
+      expect(result).toEqual({});
+    });
+
+    it("should not include a group field referenced as a regular field (string/no picked fields)", () => {
+      const customType: CustomType = {
+        id: "customType",
+        label: "Custom Type",
+        repeatable: false,
+        status: true,
+        json: {
+          Main: {
+            groupField: {
+              type: "Group",
+              config: {
+                label: "Group Field",
+                fields: {
+                  booleanField: {
+                    type: "Boolean",
+                    config: {
+                      label: "Boolean Field",
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
+
+      const result = convertLinkCustomtypesToFieldCheckMap({
+        linkCustomtypes: [
           {
-            id: "g1",
+            id: "customType",
+            fields: ["groupField"],
+          },
+        ],
+        allCustomTypes: [customType],
+      });
+
+      expect(result).toEqual({});
+    });
+
+    it("should not include a field referenced as a content relationship field when it's not one", () => {
+      const customTypeA: CustomType = {
+        id: "customTypeA",
+        label: "Custom Type A",
+        repeatable: false,
+        status: true,
+        json: {
+          Main: {
+            booleanField: {
+              type: "Boolean",
+            },
+          },
+        },
+      };
+      const customTypeB: CustomType = {
+        id: "customTypeB",
+        label: "Custom Type B",
+        repeatable: false,
+        status: true,
+        json: {
+          Main: {
+            colorField: {
+              type: "Color",
+            },
+          },
+        },
+      };
+
+      const result = convertLinkCustomtypesToFieldCheckMap({
+        linkCustomtypes: [
+          {
+            id: "customTypeA",
             fields: [
-              "f1",
               {
-                id: "f2",
+                id: "booleanField",
                 customtypes: [
                   {
-                    id: "ct2",
-                    fields: [
-                      "f1",
-                      {
-                        id: "g2",
-                        fields: ["f1", "f2"],
-                      },
-                    ],
+                    id: "customTypeB",
+                    fields: ["colorField"],
                   },
                 ],
               },
             ],
           },
         ],
-      },
-    ];
-
-    const result = countPickedFields(
-      convertLinkCustomtypesToFieldCheckMap(customtypes),
-    );
+        allCustomTypes: [customTypeB, customTypeA],
+      });
 
-    expect(result).toEqual({
-      pickedFields: 4,
-      nestedPickedFields: 3,
+      expect(result).toEqual({});
     });
-  });
 
-  it("should count picked fields with custom type as object with nested custom type and nested group field", () => {
-    const customtypes = [
-      {
-        id: "ct1",
-        fields: [
-          "f1",
+    it("should not include a content relationship field if it references a non existing custom type", () => {
+      const customTypeWithField: CustomType = {
+        id: "customTypeWithField",
+        label: "Custom Type With Field",
+        repeatable: false,
+        status: true,
+        json: {
+          Main: {
+            colorField: {
+              type: "Color",
+              config: {
+                label: "Color Field",
+              },
+            },
+          },
+        },
+      };
+      const customType: CustomType = {
+        id: "customType",
+        label: "Custom Type",
+        repeatable: false,
+        status: true,
+        json: {
+          Main: {
+            contentRelationshipField: {
+              type: "Link",
+              config: {
+                select: "document",
+                customtypes: ["customTypeWithField"],
+              },
+            },
+            groupField: {
+              type: "Group",
+              config: {
+                fields: {
+                  contentRelationshipFieldInsideGroup: {
+                    type: "Link",
+                    config: {
+                      select: "document",
+                      customtypes: ["customTypeWithField"],
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
+
+      const result = convertLinkCustomtypesToFieldCheckMap({
+        linkCustomtypes: [
           {
-            id: "f2",
-            customtypes: [
+            id: "customType",
+            fields: [
+              {
+                id: "contentRelationshipField",
+                customtypes: [
+                  {
+                    id: "nonExistingCustomType",
+                    fields: ["colorField"],
+                  },
+                ],
+              },
               {
-                id: "ct2",
+                id: "groupField",
                 fields: [
-                  "f1",
                   {
-                    id: "g2",
-                    fields: ["f1", "f2"],
+                    id: "contentRelationshipFieldInsideGroup",
+                    customtypes: [
+                      {
+                        id: "nonExistingCustomType",
+                        fields: ["colorField"],
+                      },
+                    ],
                   },
                 ],
               },
             ],
           },
         ],
-      },
-    ];
+        allCustomTypes: [customType, customTypeWithField],
+      });
+
+      expect(result).toEqual({});
+    });
 
-    const result = countPickedFields(
-      convertLinkCustomtypesToFieldCheckMap(customtypes),
-    );
+    it("should not include a regular field referenced as a content relationship field", () => {
+      const customType: CustomType = {
+        id: "customType",
+        label: "Custom Type",
+        repeatable: false,
+        status: true,
+        json: {
+          Main: {
+            booleanField: {
+              type: "Boolean",
+            },
+          },
+        },
+      };
 
-    expect(result).toEqual({
-      pickedFields: 4,
-      nestedPickedFields: 3,
+      const result = convertLinkCustomtypesToFieldCheckMap({
+        linkCustomtypes: [
+          {
+            id: "customType",
+            fields: [
+              {
+                id: "booleanField",
+                customtypes: [],
+              },
+            ],
+          },
+        ],
+        allCustomTypes: [customType],
+      });
+
+      expect(result).toEqual({});
     });
-  });
 
-  it("should count picked fields with custom type as object with nested custom type without fields", () => {
-    const customtypes = [
-      {
-        id: "ct1",
-        fields: [
-          "f1",
+    it("should not include a regular field referenced as a group field", () => {
+      const customType: CustomType = {
+        id: "customType",
+        label: "Custom Type",
+        repeatable: false,
+        status: true,
+        json: {
+          Main: {
+            booleanField: {
+              type: "Boolean",
+            },
+          },
+        },
+      };
+
+      const result = convertLinkCustomtypesToFieldCheckMap({
+        linkCustomtypes: [
           {
-            id: "f2",
-            customtypes: [
+            id: "customType",
+            fields: [
               {
-                id: "ct2",
+                id: "booleanField",
                 fields: [],
               },
             ],
           },
         ],
-      },
-    ];
-
-    const result = countPickedFields(
-      convertLinkCustomtypesToFieldCheckMap(customtypes),
-    );
+        allCustomTypes: [customType],
+      });
 
-    expect(result).toEqual({
-      pickedFields: 1,
-      nestedPickedFields: 0,
+      expect(result).toEqual({});
     });
-  });
 
-  it("should count picked fields with custom type as object with group field without fields", () => {
-    const customtypes = [
-      {
-        id: "ct1",
-        fields: [
-          "f1",
+    it("should not check for valid fields if allCustomTypes prop is not provided", () => {
+      const result = convertLinkCustomtypesToFieldCheckMap({
+        linkCustomtypes: [
           {
-            id: "g1",
-            fields: [],
+            id: "customTypeA",
+            fields: [
+              "fieldA",
+              {
+                id: "groupA",
+                fields: ["groupFieldA"],
+              },
+              {
+                id: "contentRelationshipA",
+                customtypes: [
+                  {
+                    id: "customTypeB",
+                    fields: ["fieldB"],
+                  },
+                ],
+              },
+            ],
           },
         ],
-      },
-    ];
-
-    const result = countPickedFields(
-      convertLinkCustomtypesToFieldCheckMap(customtypes),
-    );
+      });
 
-    expect(result).toEqual({
-      pickedFields: 1,
-      nestedPickedFields: 0,
+      expect(result).toEqual({
+        customTypeA: {
+          fieldA: {
+            type: "checkbox",
+            value: true,
+          },
+          groupA: {
+            type: "group",
+            value: {
+              groupFieldA: {
+                type: "checkbox",
+                value: true,
+              },
+            },
+          },
+          contentRelationshipA: {
+            type: "contentRelationship",
+            value: {
+              customTypeB: {
+                fieldB: {
+                  type: "checkbox",
+                  value: true,
+                },
+              },
+            },
+          },
+        },
+      });
     });
   });
 });