@prismicio/types-internal 3.11.2 → 3.12.0-alpha.1

package/lib/customtypes/widgets/slices/CompositeSlice.js

@@ -31,33 +31,20 @@ exports.isCompositeSlice = isCompositeSlice;
 function traverseCompositeSlice(args) {
     var _a, _b;
     const { path: prevPath, slice, onField } = args;
-    let nonRepeat;
+    const nonRepeat = {};
     for (const [key, field] of Object.entries((_a = slice["non-repeat"]) !== null && _a !== void 0 ? _a : {})) {
         const path = [...prevPath, "non-repeat", key];
-        const newField = onField({ path, key, field });
-        if (field !== newField) {
-            if (!nonRepeat)
-                nonRepeat = { ...slice["non-repeat"] };
-            nonRepeat[key] = newField;
-        }
+        nonRepeat[key] = onField({ path, key, field });
     }
-    let repeat;
+    const repeat = {};
     for (const [key, field] of Object.entries((_b = slice.repeat) !== null && _b !== void 0 ? _b : {})) {
         const path = [...prevPath, "repeat", key];
-        const newField = onField({ path, key, field });
-        if (field !== newField) {
-            if (!repeat)
-                repeat = { ...slice.repeat };
-            repeat[key] = newField;
-        }
+        repeat[key] = onField({ path, key, field });
     }
-    // returns the traversed model instead of a new one if it didn't change
-    return repeat || nonRepeat
-        ? {
-            ...slice,
-            ...(nonRepeat && { "non-repeat": nonRepeat }),
-            ...(repeat && { repeat }),
-        }
-        : slice;
+    return {
+        ...slice,
+        ...(slice["non-repeat"] && { "non-repeat": nonRepeat }),
+        ...(slice.repeat && { repeat }),
+    };
 }
 exports.traverseCompositeSlice = traverseCompositeSlice;

package/lib/customtypes/widgets/slices/SharedSlice.js

@@ -50,7 +50,7 @@ exports.isDynamicSharedSlice = isDynamicSharedSlice;
 function traverseVariation(args) {
     var _a, _b;
     const { path: prevPath, variation, onField } = args;
-    let primary;
+    const primary = {};
     for (const [key, prevField] of Object.entries((_a = variation.primary) !== null && _a !== void 0 ? _a : {})) {
         const path = [...prevPath, "primary", key];
         let field;
@@ -66,53 +66,34 @@ function traverseVariation(args) {
                 field = prevField;
                 break;
         }
-        const newField = onField({ path, key, field });
-        if (field !== newField) {
-            if (!primary)
-                primary = { ...variation.primary };
-            primary[key] = newField;
-        }
+        primary[key] = onField({ path, key, field });
     }
-    let items;
-    for (const [key, prevField] of Object.entries((_b = variation.items) !== null && _b !== void 0 ? _b : {})) {
+    const items = {};
+    for (const [key, field] of Object.entries((_b = variation.items) !== null && _b !== void 0 ? _b : {})) {
         const path = [...prevPath, "items", key];
-        const newField = onField({
-            path,
-            key,
-            field: prevField,
-        });
-        if (prevField !== newField) {
-            if (!items)
-                items = { ...variation.items };
-            items[key] = newField;
-        }
+        items[key] = onField({ path, key, field });
     }
-    // returns the traversed model instead of a new one if it didn't change
-    return primary || items
-        ? { ...variation, ...(primary && { primary }), ...(items && { items }) }
-        : variation;
+    return {
+        ...variation,
+        ...(variation.primary && { primary }),
+        ...(variation.items && { items }),
+    };
 }
 exports.traverseVariation = traverseVariation;
 function traverseSharedSlice(args) {
     const { path: prevPath, slice, onField } = args;
-    let variations;
-    for (let i = 0; i < slice.variations.length; i++) {
-        const variation = slice.variations[i];
-        if (!variation)
-            continue;
+    const variations = [];
+    for (const variation of slice.variations) {
         const path = [...prevPath, variation.id];
-        const newVariation = traverseVariation({
+        variations.push(traverseVariation({
             path,
             variation,
             onField,
-        });
-        if (newVariation !== variation) {
-            if (!variations)
-                variations = [...slice.variations];
-            variations[i] = newVariation;
-        }
+        }));
     }
-    // returns the traversed model instead of a new one if it didn't change
-    return variations ? { ...slice, variations } : slice;
+    return {
+        ...slice,
+        variations,
+    };
 }
 exports.traverseSharedSlice = traverseSharedSlice;

package/lib/customtypes/widgets/slices/SharedSliceZ.d.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+import type { SharedSliceRef } from "./SharedSliceRef";
+import type { DynamicSlice, StaticSlice } from "./Slice";
+export declare const Variation: any;
+export declare type Variation = z.infer<typeof Variation>;
+export declare type VariationFields = {
+    type: "SharedSlice";
+    sliceName: string;
+    variationId: string;
+    fields: Pick<Variation, "primary" | "items">;
+};
+export declare const SharedSliceType: "SharedSlice";
+export declare const SharedSlice: any;
+export declare type SharedSlice = z.infer<typeof SharedSlice>;
+export declare function isStaticSharedSlice(slice: StaticSlice): slice is SharedSlice;
+export declare function isDynamicSharedSlice(slice: DynamicSlice): slice is SharedSliceRef;

package/lib/customtypes/widgets/slices/SharedSliceZ.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDynamicSharedSlice = exports.isStaticSharedSlice = exports.SharedSlice = exports.SharedSliceType = exports.Variation = void 0;
+const zod_1 = require("zod");
+const NestableWidgetZ_1 = require("../nestable/NestableWidgetZ");
+const SlicePrimaryWidgetZ_1 = require("./SlicePrimaryWidgetZ");
+const IMAGE_PLACEHOLDER_URL = "https://images.prismic.io/slice-machine/621a5ec4-0387-4bc5-9860-2dd46cbc07cd_default_ss.png?auto=compress,format";
+// Helper for WidgetKey validation
+const WidgetKeySchema = zod_1.z.string().refine((val) => true, {
+    message: "Invalid widget key",
+});
+exports.Variation = zod_1.z.object({
+    id: zod_1.z.string(),
+    name: zod_1.z.string(),
+    description: zod_1.z.string(),
+    imageUrl: zod_1.z.string().default(IMAGE_PLACEHOLDER_URL),
+    docURL: zod_1.z.string(),
+    version: zod_1.z.string(),
+    display: zod_1.z.string().optional(),
+    primary: zod_1.z.record(WidgetKeySchema, SlicePrimaryWidgetZ_1.SlicePrimaryWidget).optional(),
+    items: zod_1.z.record(WidgetKeySchema, NestableWidgetZ_1.NestableWidget).optional(),
+}).strict();
+exports.SharedSliceType = "SharedSlice";
+exports.SharedSlice = zod_1.z.object({
+    id: zod_1.z.string(),
+    type: zod_1.z.literal(exports.SharedSliceType),
+    name: zod_1.z.string(),
+    variations: zod_1.z.array(exports.Variation).readonly(),
+    description: zod_1.z.string().optional(),
+    legacyPaths: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).optional(),
+}).strict();
+function isStaticSharedSlice(slice) {
+    return slice.type === "SharedSlice";
+}
+exports.isStaticSharedSlice = isStaticSharedSlice;
+function isDynamicSharedSlice(slice) {
+    return slice.type === "SharedSlice";
+}
+exports.isDynamicSharedSlice = isDynamicSharedSlice;

package/lib/customtypes/widgets/slices/SlicePrimaryWidgetZ.d.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+export declare const SlicePrimaryWidget: any;
+export declare type SlicePrimaryWidget = z.infer<typeof SlicePrimaryWidget>;

package/lib/customtypes/widgets/slices/SlicePrimaryWidgetZ.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlicePrimaryWidget = void 0;
+require("zod");
+const NestableWidgetZ_1 = require("../nestable/NestableWidgetZ");
+exports.SlicePrimaryWidget = NestableWidgetZ_1.NestableWidget;

package/lib/customtypes/widgets/slices/Slices.js

@@ -84,7 +84,7 @@ function traverseSlices(args) {
     const { path: prevPath, slices, onField } = args;
     if (!((_a = slices.config) === null || _a === void 0 ? void 0 : _a.choices))
         return slices;
-    let choices;
+    const choices = {};
     for (const [key, prevModel] of Object.entries(slices.config.choices)) {
         const path = [...prevPath, key];
         let model;
@@ -126,21 +126,14 @@ function traverseSlices(args) {
                 });
                 break;
         }
-        if (model !== prevModel) {
-            if (!choices)
-                choices = { ...slices.config.choices };
-            choices[key] = model;
-        }
+        choices[key] = model;
     }
-    // returns the traversed model instead of a new one if it didn't change
-    return choices
-        ? {
-            ...slices,
-            config: {
-                ...slices.config,
-                choices,
-            },
-        }
-        : slices;
+    return {
+        ...slices,
+        config: {
+            ...slices.config,
+            choices,
+        },
+    };
 }
 exports.traverseSlices = traverseSlices;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prismicio/types-internal",
-	"version": "3.11.2",
+	"version": "3.12.0-alpha.1",
 	"description": "Prismic types for Custom Types and Prismic Data",
 	"keywords": [
 		"typescript",

package/src/content/Document.ts

@@ -47,7 +47,10 @@ type DocumentLegacy = t.TypeOf<typeof legacyDocReader>
  * `DocumentLegacyCodec` handles decoding and encoding documents to the legacy
  * format used by Prismic DB, therefore, this function itself is not "legacy".
  */
-const DocumentLegacyCodec = (allTypes?: LegacyContentCtx["allTypes"]) => {
+const DocumentLegacyCodec = (
+	allTypes?: LegacyContentCtx["allTypes"],
+	allKeys?: LegacyContentCtx["allKeys"],
+) => {
 	return new t.Type<Document, WithTypes<DocumentLegacy>, unknown>(
 		"Document",
 		(u): u is Document => !!u && typeof u === "object",
@@ -57,7 +60,7 @@ const DocumentLegacyCodec = (allTypes?: LegacyContentCtx["allTypes"]) => {
 				either.map((parsedDoc) => {
 					return Object.entries(parsedDoc).reduce(
 						(acc, [widgetKey, widgetValue]) => {
-							const widgetCtx = defaultCtx(widgetKey, allTypes)
+							const widgetCtx = defaultCtx(widgetKey, allTypes, allKeys)
 							const parsedW = WidgetLegacy(widgetCtx).decode(widgetValue)
 							if (!parsedW || isLeft(parsedW)) return acc
 
@@ -78,9 +81,10 @@ const DocumentLegacyCodec = (allTypes?: LegacyContentCtx["allTypes"]) => {
 					return {
 						content: { ...acc.content, [key]: result.content },
 						types: { ...acc.types, ...result.types },
+						keys: { ...acc.keys, ...result.keys },
 					}
 				},
-				{ content: {}, types: {} },
+				{ content: {}, types: {}, keys: {} },
 			)
 		},
 	)
@@ -89,12 +93,13 @@ const DocumentLegacyCodec = (allTypes?: LegacyContentCtx["allTypes"]) => {
 function extractMetadata(data: { [p: string]: unknown }): {
 	types: Map<string, FieldOrSliceType>
 	widgets: Partial<Record<WidgetKey, unknown>>
+	keys: Map<string, string>
 	slugs: ReadonlyArray<string>
 	uid: string | undefined
 } {
 	const fields: [string, unknown][] = Object.entries(data)
 
-	const { types, widgets } = fields.reduce(
+	const { types, widgets, keys } = fields.reduce(
 		(acc, [k, v]) => {
 			if (k.endsWith("_TYPE")) {
 				const decodedValue = FieldOrSliceType.decode(v)
@@ -108,7 +113,23 @@ function extractMetadata(data: { [p: string]: unknown }): {
 					}
 				}
 			}
-			if (!k.endsWith("_POSITION") && !k.endsWith("_TYPE")) {
+			if (k.endsWith("_KEY")) {
+				const decodedValue = t.string.decode(v)
+				if (isRight(decodedValue)) {
+					return {
+						...acc,
+						keys: acc.keys.set(
+							k.substring(0, k.length - 4),
+							decodedValue.right,
+						),
+					}
+				}
+			}
+			if (
+				!k.endsWith("_POSITION") &&
+				!k.endsWith("_TYPE") &&
+				!k.endsWith("_KEY")
+			) {
 				return {
 					...acc,
 					widgets: {
@@ -122,6 +143,7 @@ function extractMetadata(data: { [p: string]: unknown }): {
 		{
 			types: new Map<string, FieldOrSliceType>(),
 			widgets: {},
+			keys: new Map<string, string>(),
 		},
 	)
 
@@ -131,6 +153,7 @@ function extractMetadata(data: { [p: string]: unknown }): {
 	return {
 		widgets,
 		types,
+		keys,
 		uid,
 		slugs,
 	}
@@ -150,9 +173,9 @@ function parseLegacyDocument(
 		t.record(WidgetKey, t.unknown).decode(legacyDoc),
 		either.chain((doc) => {
 			// extract all metadata, meaning all _TYPES keys from legacy format + the widgets as unknown
-			const { types, widgets } = extractMetadata(doc)
+			const { types, widgets, keys } = extractMetadata(doc)
 			// parse the actual widgets
-			return DocumentLegacyCodec(types).decode(widgets)
+			return DocumentLegacyCodec(types, keys).decode(widgets)
 		}),
 	)
 
@@ -161,7 +184,7 @@ function parseLegacyDocument(
 
 function encodeToLegacyDocument(document: Document): DocumentLegacy {
 	const encoded = DocumentLegacyCodec().encode(document)
-	return { ...encoded.content, ...encoded.types }
+	return { ...encoded.content, ...encoded.types, ...encoded.keys }
 }
 
 export const DocumentLegacy = {

package/src/content/LegacyContentCtx.ts

@@ -1,4 +1,5 @@
 import * as t from "io-ts"
+import { v4 as uuid } from "uuid"
 
 import { FieldType, SlicesTypes } from "../customtypes/widgets"
 
@@ -7,54 +8,109 @@ export const FieldOrSliceType = t.union([
 	t.literal("Repeatable.Link"),
 ])
 export type FieldOrSliceType = t.TypeOf<typeof FieldOrSliceType>
+
+interface LegacyContentCtxParams {
+	fieldKey: string
+	contentKey?: string
+	fieldPath?: Array<string>
+	contentPath?: Array<string>
+	allTypes?: Map<string, FieldOrSliceType>
+	allKeys?: Map<string, string>
+}
+
 export class LegacyContentCtx {
 	fieldKey: string
 	prefixedKey: string
 	keyOfType: string
+	keyOfKey: string
 	fieldPath: Array<string>
 	fieldType?: FieldOrSliceType | undefined
 	allTypes: Map<string, FieldOrSliceType>
+	allKeys: Map<string, string>
+	contentKey: string
+	contentPath: Array<string>
+	fieldContentKey: string
 
-	constructor(
-		fieldKey: string,
-		fieldPath?: Array<string>,
-		allTypes?: Map<string, FieldOrSliceType>,
-	) {
+	constructor({
+		fieldKey,
+		contentKey,
+		contentPath,
+		fieldPath,
+		allTypes,
+		allKeys,
+	}: LegacyContentCtxParams) {
 		this.fieldKey = fieldKey
+		this.contentKey = contentKey || fieldKey
 		this.fieldPath = fieldPath || []
+		this.contentPath = contentPath || []
 		this.allTypes = allTypes || new Map<string, FieldOrSliceType>()
+		this.allKeys = allKeys || new Map<string, string>()
 
 		const prefixedKey = Array.of(this.fieldPath, [this.fieldKey])
 			.flat()
 			.join(".")
 
+		const prefixedContentKey = Array.of(this.contentPath, [this.contentKey])
+			.flat()
+			.join(".")
+
 		this.prefixedKey = prefixedKey
 		this.keyOfType = `${prefixedKey}_TYPE`
-
+		this.keyOfKey = `${prefixedContentKey}_KEY`
 		this.fieldType = this.allTypes.get(this.prefixedKey)
+		this.fieldContentKey = this.allKeys.get(prefixedContentKey) ?? uuid()
+	}
+
+	withContentKey(contentKey: string): LegacyContentCtx {
+		return new LegacyContentCtx({
+			...this,
+			contentPath: [...this.contentPath, this.contentKey],
+			contentKey,
+		})
 	}
 }
 
-export function getFieldCtx(
-	fieldKey: string,
-	ctx: LegacyContentCtx,
-	prefixes?: Array<string>,
-): LegacyContentCtx {
-	return new LegacyContentCtx(
+interface GetFieldCtxParams {
+	fieldKey: string
+	contentKey?: string
+	ctx: LegacyContentCtx
+	prefixes?: Array<string>
+}
+
+export function getFieldCtx({
+	fieldKey,
+	contentKey: contentKeyParam,
+	ctx,
+	prefixes,
+}: GetFieldCtxParams): LegacyContentCtx {
+	const contentKey = contentKeyParam || fieldKey
+	return new LegacyContentCtx({
 		fieldKey,
-		[...ctx.fieldPath, ctx.fieldKey, ...(prefixes || [])],
-		ctx.allTypes,
-	)
+		contentKey,
+		contentPath: [...ctx.contentPath, ctx.contentKey, ...(prefixes || [])],
+		fieldPath: [...ctx.fieldPath, ctx.fieldKey, ...(prefixes || [])],
+		allTypes: ctx.allTypes,
+		allKeys: ctx.allKeys,
+	})
 }
 
 export function defaultCtx(
 	key: string,
 	allTypes: Map<string, FieldOrSliceType> = new Map(),
+	allKeys: Map<string, string> = new Map(),
 ): LegacyContentCtx {
-	return new LegacyContentCtx(key, [], allTypes)
+	return new LegacyContentCtx({
+		fieldKey: key,
+		contentKey: key,
+		contentPath: [],
+		fieldPath: [],
+		allTypes,
+		allKeys,
+	})
 }
 
 export type WithTypes<T> = {
+	keys: Record<string, string>
 	types: Record<string, FieldOrSliceType>
 	content: T
 }

package/src/content/fields/GroupContent.ts

@@ -1,4 +1,4 @@
-import { either } from "fp-ts"
+import { array, either } from "fp-ts"
 import { isLeft } from "fp-ts/lib/Either"
 import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
@@ -38,6 +38,7 @@ export const GroupItemContent: t.Type<GroupItemContent> = t.recursion(
 	() =>
 		t.strict({
 			__TYPE__: t.literal(GroupItemContentType),
+			key: t.string,
 			value: t.array(
 				t.tuple([t.string, t.union([NestableContent, GroupContent])]),
 			),
@@ -45,6 +46,7 @@ export const GroupItemContent: t.Type<GroupItemContent> = t.recursion(
 )
 export type GroupItemContent = {
 	__TYPE__: typeof GroupItemContentType
+	key: string
 	value: [string, NestableContent | GroupContent][]
 }
 
@@ -70,9 +72,9 @@ export const GroupContentDefaultValue: GroupContent = {
 }
 
 const itemLegacyReader = t.record(t.string, t.unknown)
-type GroupItemLegacy = t.TypeOf<typeof itemLegacyReader>
+export type GroupItemLegacy = t.TypeOf<typeof itemLegacyReader>
 
-export const GroupItemLegacy = (ctx: LegacyContentCtx) => {
+export const GroupItemLegacy = (ctx: LegacyContentCtx, index: number) => {
 	return new t.Type<GroupItemContent, WithTypes<GroupItemLegacy>>(
 		"GroupItemLegacy",
 		(u): u is GroupItemContent =>
@@ -81,10 +83,15 @@ export const GroupItemLegacy = (ctx: LegacyContentCtx) => {
 			const parsed = pipe(
 				itemLegacyReader.decode(u),
 				either.map((items) => {
+					const groupItemCtx = ctx.withContentKey(`${index}`)
 					const parsedItems = Object.entries(items).reduce<
 						Array<[string, NestableContent | GroupContent]>
 					>((acc, [itemKey, itemValue]) => {
-						const itemCtx = getFieldCtx(itemKey, ctx)
+						const itemCtx = getFieldCtx({
+							fieldKey: itemKey,
+							contentKey: itemKey,
+							ctx: groupItemCtx,
+						})
 						const result =
 							itemCtx.fieldType === GroupFieldType
 								? GroupLegacy(itemCtx).decode(itemValue)
@@ -99,15 +106,17 @@ export const GroupItemLegacy = (ctx: LegacyContentCtx) => {
 					return {
 						value: parsedItems,
 						__TYPE__: GroupItemContentType,
+						key: groupItemCtx.fieldContentKey,
 					}
 				}),
 			)
 			return parsed
 		},
 		(item) => {
+			const groupItemCtx = ctx.withContentKey(`${index}`)
 			return item.value.reduce<WithTypes<GroupItemLegacy>>(
 				(acc, [key, value]) => {
-					const itemCtx = getFieldCtx(key, ctx)
+					const itemCtx = getFieldCtx({ fieldKey: key, ctx })
 					const encoded = isGroupContent(value)
 						? GroupLegacy(itemCtx).encode(value)
 						: NestableLegacy(itemCtx).encode(value)
@@ -117,20 +126,46 @@ export const GroupItemLegacy = (ctx: LegacyContentCtx) => {
 					return {
 						content: { ...acc.content, [key]: encoded.content },
 						types: { ...acc.types, ...encoded.types },
+						keys: { ...acc.keys, ...encoded.keys },
 					}
 				},
-				{ content: {}, types: {} },
+				{ content: {}, types: {}, keys: { [groupItemCtx.keyOfKey]: item.key } },
 			)
 		},
 	)
 }
 
+export function arrayWithIndexCodec<T, O>(
+	f: (index: number) => t.Type<T, O, unknown>,
+): t.Type<Array<T>, O[], unknown> {
+	return new t.Type<Array<T>, O[], unknown>(
+		"ArrayWithIndexCodec",
+		(u): u is Array<T> => Array.isArray(u),
+		(items) =>
+			pipe(
+				t.array(t.unknown).decode(items),
+				either.chain((validItems) => {
+					const decodedItems = validItems.map((item, index) => {
+						return f(index).decode(item)
+					})
+					return array.sequence(either.Applicative)(decodedItems)
+				}),
+			),
+		(items) => items.map((item, index) => f(index).encode(item)),
+	)
+}
+
 type GroupLegacy = Array<GroupItemLegacy>
 export const GroupLegacy = (
 	ctx: LegacyContentCtx,
 ): t.Type<GroupContent, WithTypes<GroupLegacy>, unknown> => {
-	const codecDecode = t.array(t.union([t.null, GroupItemLegacy(ctx)]))
-	const codecEncode = t.array(GroupItemLegacy(ctx))
+	const codecDecode = arrayWithIndexCodec<
+		GroupItemContent | null,
+		WithTypes<GroupItemLegacy> | null
+	>((index) => t.union([GroupItemLegacy(ctx, index), t.null]))
+
+	const codecEncode = (items: GroupItemContent[]) =>
+		items.map((item, index) => GroupItemLegacy(ctx, index).encode(item))
 
 	return new t.Type<GroupContent, WithTypes<GroupLegacy>, unknown>(
 		"GroupLegacy",
@@ -139,19 +174,22 @@ export const GroupLegacy = (
 			return pipe(
 				codecDecode.decode(items),
 				either.map((parsedItems) => {
+					const value = parsedItems.map((i, index) => {
+						if (i === null) {
+							const key = ctx.withContentKey(`${index}`).fieldContentKey
+							return { __TYPE__: GroupItemContentType, key, value: [] }
+						}
+						return i
+					})
 					return {
-						value: parsedItems.map((i) => {
-							if (i === null) {
-								return { __TYPE__: GroupItemContentType, value: [] }
-							} else return i
-						}),
+						value,
 						__TYPE__: GroupContentType,
 					}
 				}),
 			)
 		},
 		(g: GroupContent) => {
-			const res = codecEncode.encode(g.value)
+			const res = codecEncode(g.value)
 			return {
 				content: res.map((block) => block.content),
 				types: res.reduce<Record<string, FieldOrSliceType>>(
@@ -160,6 +198,9 @@ export const GroupLegacy = (
 					},
 					{ [ctx.keyOfType]: GroupFieldType },
 				),
+				keys: res.reduce<Record<string, string>>((acc, block) => {
+					return { ...acc, ...block.keys }
+				}, {}),
 			}
 		},
 	)
@@ -223,9 +264,9 @@ export function traverseGroupItemsContent({
 	model?: Record<string, Group | NestableWidget> | undefined
 }) {
 	return (transform: TraverseWidgetContentFn): Array<GroupItemContent> => {
-		return content.map((groupItem, index) => {
+		return content.map((groupItem) => {
 			const groupItemPath = path.concat([
-				{ key: index.toString(), type: "GroupItem" },
+				{ key: groupItem.key, type: "GroupItem" },
 			])
 
 			const groupItemFields = groupItem.value.reduce<GroupItemContent["value"]>(
@@ -284,6 +325,7 @@ export function traverseGroupItemsContent({
 
 			return {
 				__TYPE__: groupItem.__TYPE__,
+				key: groupItem.key,
 				value: groupItemFields,
 			}
 		})

package/src/content/fields/UIDContent.ts

@@ -29,6 +29,7 @@ export const UIDLegacy = (ctx: LegacyContentCtx) =>
 			return {
 				content: uid.value,
 				types: { [ctx.keyOfType]: "UID" },
+				keys: {},
 			}
 		},
 	)

package/src/content/fields/nestable/BooleanContent.ts

@@ -29,6 +29,7 @@ export const BooleanLegacy = (ctx: LegacyContentCtx) =>
 			return {
 				content: b.value,
 				types: { [ctx.keyOfType]: "Boolean" },
+				keys: {},
 			}
 		},
 	)

package/src/content/fields/nestable/EmbedContent.ts

@@ -58,6 +58,7 @@ export const EmbedLegacy = (ctx: LegacyContentCtx) =>
 				 **/
 				content: embed.all,
 				types: { [ctx.keyOfType]: "Embed" },
+				keys: {},
 			}
 		},
 	)