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

package/src/content/fields/nestable/FieldContent/ColorContent.ts

@@ -35,6 +35,7 @@ export const ColorLegacy = (ctx: LegacyContentCtx) =>
 			return {
 				content: b.value,
 				types: { [ctx.keyOfType]: ColorFieldType },
+				keys: {},
 			}
 		},
 	)

package/src/content/fields/nestable/FieldContent/DateContent.ts

@@ -35,6 +35,7 @@ export const DateLegacy = (ctx: LegacyContentCtx) =>
 			return {
 				content: b.value,
 				types: { [ctx.keyOfType]: DateFieldType },
+				keys: {},
 			}
 		},
 	)

package/src/content/fields/nestable/FieldContent/NumberContent.ts

@@ -35,6 +35,7 @@ export const NumberLegacy = (ctx: LegacyContentCtx) =>
 			return {
 				content: b.value,
 				types: { [ctx.keyOfType]: NumberFieldType },
+				keys: {},
 			}
 		},
 	)

package/src/content/fields/nestable/FieldContent/RangeContent.ts

@@ -35,6 +35,7 @@ export const RangeLegacy = (ctx: LegacyContentCtx) =>
 			return {
 				content: b.value,
 				types: { [ctx.keyOfType]: RangeFieldType },
+				keys: {},
 			}
 		},
 	)

package/src/content/fields/nestable/FieldContent/SelectContent.ts

@@ -35,6 +35,7 @@ export const SelectLegacy = (ctx: LegacyContentCtx) =>
 			return {
 				content: b.value,
 				types: { [ctx.keyOfType]: SelectFieldType },
+				keys: {},
 			}
 		},
 	)

package/src/content/fields/nestable/FieldContent/TextContent.ts

@@ -35,6 +35,7 @@ export const TextLegacy = (ctx: LegacyContentCtx) =>
 			return {
 				content: b.value,
 				types: { [ctx.keyOfType]: TextFieldType },
+				keys: {},
 			}
 		},
 	)

package/src/content/fields/nestable/FieldContent/TimestampContent.ts

@@ -35,6 +35,7 @@ export const TimestampLegacy = (ctx: LegacyContentCtx) =>
 			return {
 				content: b.value,
 				types: { [ctx.keyOfType]: TimestampFieldType },
+				keys: {},
 			}
 		},
 	)

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

@@ -34,6 +34,7 @@ export const GeoPointLegacy = (ctx: LegacyContentCtx) =>
 		(geo: GeoPointContent) => ({
 			content: { position: geo.position },
 			types: { [ctx.keyOfType]: "GeoPoint" },
+			keys: {},
 		}),
 	)
 

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

@@ -86,6 +86,7 @@ export const ImageLegacy = (ctx: LegacyContentCtx) =>
 					],
 				),
 				types: { [ctx.keyOfType]: "Image" },
+				keys: {},
 			}
 		},
 	)

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

@@ -38,6 +38,7 @@ export const IntegrationFieldLegacy = (ctx: LegacyContentCtx) =>
 			return {
 				content: i.value,
 				types: { [ctx.keyOfType]: "IntegrationFields" },
+				keys: {},
 			}
 		},
 	)

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

@@ -562,6 +562,7 @@ export const LinkContentLegacy = (ctx: LegacyContentCtx) =>
 					key,
 				}),
 				types: { [ctx.keyOfType]: "Link" },
+				keys: {},
 			}
 		},
 	)
@@ -627,6 +628,7 @@ export const FilledLinkContentLegacy = (ctx: LegacyContentCtx) => {
 					key,
 				}),
 				types: { [ctx.keyOfType]: "Link" },
+				keys: {},
 			}
 		},
 	)

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

@@ -88,6 +88,10 @@ export const RepeatableLegacy = (
 			return {
 				content: encodedItems.map((encodedItem) => encodedItem.content),
 				types: { [ctx.keyOfType]: `Repeatable.${fieldType}` },
+				keys: encodedItems.reduce<Record<string, string>>(
+					(acc, item) => ({ ...acc, ...item.keys }),
+					{},
+				),
 			}
 		},
 	)

package/src/content/fields/nestable/RichTextContent/index.ts

@@ -36,6 +36,7 @@ export const RichTextLegacy = (ctx: LegacyContentCtx) =>
 			return {
 				content: RichTextLegacyContent.encode(r.value),
 				types: { [ctx.keyOfType]: "StructuredText" },
+				keys: {},
 			}
 		},
 	)

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

@@ -22,6 +22,7 @@ export const SeparatorLegacy = (ctx: LegacyContentCtx) =>
 			return {
 				content: {},
 				types: { [ctx.keyOfType]: "Separator" },
+				keys: {},
 			}
 		},
 	)

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

@@ -108,6 +108,7 @@ export const TableLegacy = (ctx: LegacyContentCtx) =>
 					})),
 				}),
 				types: { [ctx.keyOfType]: "Table" },
+				keys: {},
 			}
 		},
 	)

package/src/content/fields/slices/Slice/CompositeSliceContent.ts

@@ -60,7 +60,7 @@ export const CompositeSliceLegacy = (ctx: LegacyContentCtx) => {
 				either.map((parsedSlice) => {
 					const repeat =
 						(() => {
-							const itemsCtx = getFieldCtx("repeat", ctx)
+							const itemsCtx = getFieldCtx({ fieldKey: "repeat", ctx })
 							const result = RepeatableWidgetsLegacy(itemsCtx).decode(
 								parsedSlice.repeat,
 							)
@@ -71,7 +71,11 @@ export const CompositeSliceLegacy = (ctx: LegacyContentCtx) => {
 					const nonRepeat = Object.entries(
 						parsedSlice["non-repeat"] || {},
 					).reduce<Record<string, NestableContent>>((acc, [key, value]) => {
-						const fieldCtx = getFieldCtx(key, ctx, ["non-repeat"])
+						const fieldCtx = getFieldCtx({
+							fieldKey: key,
+							ctx,
+							prefixes: ["non-repeat"],
+						})
 						if (!fieldCtx) return acc
 
 						const result = NestableLegacy(fieldCtx).decode(value)
@@ -94,7 +98,11 @@ export const CompositeSliceLegacy = (ctx: LegacyContentCtx) => {
 				WithTypes<{ [key: string]: unknown }>
 			>(
 				(acc, [key, value]) => {
-					const FieldCtx = getFieldCtx(key, ctx, ["non-repeat"])
+					const FieldCtx = getFieldCtx({
+						fieldKey: key,
+						ctx,
+						prefixes: ["non-repeat"],
+					})
 
 					const result = NestableLegacy(FieldCtx).encode(value)
 					if (!result) return acc
@@ -102,14 +110,15 @@ export const CompositeSliceLegacy = (ctx: LegacyContentCtx) => {
 					return {
 						content: { ...acc.content, [key]: result.content },
 						types: { ...acc.types, ...result.types },
+						keys: { ...acc.keys, ...result.keys },
 					}
 				},
-				{ content: {}, types: {} },
+				{ content: {}, types: {}, keys: {} },
 			)
 
 			const repeat =
 				(() => {
-					const itemsCtx = getFieldCtx("repeat", ctx)
+					const itemsCtx = getFieldCtx({ fieldKey: "repeat", ctx })
 					const result = RepeatableWidgetsLegacy(itemsCtx).encode(s.repeat)
 					return result
 				})() || []
@@ -124,6 +133,10 @@ export const CompositeSliceLegacy = (ctx: LegacyContentCtx) => {
 					...nonRepeat.types,
 					...repeat.reduce((acc, i) => ({ ...acc, ...i.types }), {}),
 				},
+				keys: {
+					...nonRepeat.keys,
+					...repeat.reduce((acc, i) => ({ ...acc, ...i.keys }), {}),
+				},
 			}
 		},
 	)
@@ -260,6 +273,7 @@ export function migrateCompositeSlice(
 			items: content.widget.repeat.map((groupItem) => {
 				return {
 					__TYPE__: "GroupItemContent",
+					key: groupItem.key,
 					value: groupItem.value.reduce<GroupItemContent["value"]>(
 						(acc, [fieldKey, fieldContent]) => {
 							if (!model.fields.items?.[fieldKey]) {

package/src/content/fields/slices/Slice/RepeatableContent.ts

@@ -1,15 +1,19 @@
 import * as t from "io-ts"
 
-import type { LegacyContentCtx } from "../../../LegacyContentCtx"
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx"
 import {
+	arrayWithIndexCodec,
 	GroupContent,
+	GroupItemContent,
 	GroupItemContentType,
 	GroupItemLegacy,
 } from "../../GroupContent"
 import { NestableContent } from "../../nestable"
 
 export const RepeatableWidgetsLegacy = (ctx: LegacyContentCtx) => {
-	return t.array(GroupItemLegacy(ctx))
+	return arrayWithIndexCodec<GroupItemContent, WithTypes<GroupItemLegacy>>(
+		(index) => GroupItemLegacy(ctx, index),
+	)
 }
 
 const RepeatableWidget = t.tuple([
@@ -18,6 +22,7 @@ const RepeatableWidget = t.tuple([
 ])
 const RepeatableWidgetsBlock = t.strict({
 	__TYPE__: t.literal(GroupItemContentType),
+	key: t.string,
 	value: t.array(RepeatableWidget),
 })
 

package/src/content/fields/slices/Slice/SharedSliceContent.ts

@@ -68,10 +68,11 @@ export const SharedSliceLegacy = (ctx: LegacyContentCtx) => {
 				either.map((parsedSlice) => {
 					const items =
 						(() => {
-							const itemsCtx = getFieldCtx("items", ctx, [
-								"variations",
-								parsedSlice.variation,
-							])
+							const itemsCtx = getFieldCtx({
+								fieldKey: "items",
+								ctx,
+								prefixes: ["variations", parsedSlice.variation],
+							})
 							const result = RepeatableWidgetsLegacy(itemsCtx).decode(
 								parsedSlice.items,
 							)
@@ -82,11 +83,11 @@ export const SharedSliceLegacy = (ctx: LegacyContentCtx) => {
 					const primary = Object.entries(parsedSlice.primary).reduce<
 						Record<string, SlicePrimaryContent>
 					>((acc, [key, value]) => {
-						const FieldCtx = getFieldCtx(key, ctx, [
-							"variations",
-							parsedSlice.variation,
-							"primary",
-						])
+						const FieldCtx = getFieldCtx({
+							fieldKey: key,
+							ctx,
+							prefixes: ["variations", parsedSlice.variation, "primary"],
+						})
 
 						const result = SlicePrimaryLegacy(FieldCtx).decode(value)
 						if (!result) return acc
@@ -109,11 +110,11 @@ export const SharedSliceLegacy = (ctx: LegacyContentCtx) => {
 				WithTypes<Record<string, unknown>>
 			>(
 				(acc, [key, value]) => {
-					const FieldCtx = getFieldCtx(key, ctx, [
-						"variations",
-						s.variation,
-						"primary",
-					])
+					const FieldCtx = getFieldCtx({
+						fieldKey: key,
+						ctx,
+						prefixes: ["variations", s.variation, "primary"],
+					})
 
 					const result = SlicePrimaryLegacy(FieldCtx).encode(value)
 					if (!result) return acc
@@ -121,17 +122,19 @@ export const SharedSliceLegacy = (ctx: LegacyContentCtx) => {
 					return {
 						content: { ...acc.content, [key]: result.content },
 						types: { ...acc.types, ...result.types },
+						keys: { ...acc.keys, ...result.keys },
 					}
 				},
-				{ content: {}, types: {} },
+				{ content: {}, types: {}, keys: {} },
 			)
 
 			const items =
 				(() => {
-					const itemsCtx = getFieldCtx("items", ctx, [
-						"variations",
-						s.variation,
-					])
+					const itemsCtx = getFieldCtx({
+						fieldKey: "items",
+						ctx,
+						prefixes: ["variations", s.variation],
+					})
 					const result = RepeatableWidgetsLegacy(itemsCtx).encode(s.items)
 					return result
 				})() || []
@@ -147,6 +150,10 @@ export const SharedSliceLegacy = (ctx: LegacyContentCtx) => {
 					...primary.types,
 					...items.reduce((acc, i) => ({ ...acc, ...i.types }), {}),
 				},
+				keys: {
+					...primary.keys,
+					...items.reduce((acc, i) => ({ ...acc, ...i.keys }), {}),
+				},
 			}
 		},
 	)

package/src/content/fields/slices/Slice/SimpleSliceContent.ts

@@ -150,6 +150,7 @@ export function migrateSimpleSlice(
 				items: content.widget.value.map((groupItem) => {
 					return {
 						__TYPE__: "GroupItemContent",
+						key: groupItem.key,
 						value: groupItem.value.reduce<GroupItemContent["value"]>(
 							(acc, [fieldKey, fieldContent]) => {
 								return model.fields.items?.[fieldKey]

package/src/content/fields/slices/SliceItem.ts

@@ -115,7 +115,7 @@ const itemLegacyReader = t.exact(
 	]),
 )
 
-type SliceItemLegacy = t.TypeOf<typeof itemLegacyReader>
+export type SliceItemLegacy = t.TypeOf<typeof itemLegacyReader>
 
 export const SlicesItemLegacy = (ctx: LegacyContentCtx) => {
 	return new t.Type<SliceItemContent, WithTypes<SliceItemLegacy>, unknown>(
@@ -134,7 +134,11 @@ export const SlicesItemLegacy = (ctx: LegacyContentCtx) => {
 						0,
 						stopIdx > 0 ? stopIdx : undefined,
 					)
-					const itemCtx = getFieldCtx(sliceName, ctx)
+					const itemCtx = getFieldCtx({
+						fieldKey: sliceName,
+						contentKey: parsedSlice.key,
+						ctx,
+					})
 					const item = SliceLegacy(itemCtx).decode(parsedSlice.value)
 					if (!item || isLeft(item)) return t.failure(sliceItem, context)
 
@@ -148,7 +152,11 @@ export const SlicesItemLegacy = (ctx: LegacyContentCtx) => {
 			)
 		},
 		(sItem: SliceItemContent) => {
-			const itemCtx = getFieldCtx(sItem.name, ctx)
+			const itemCtx = getFieldCtx({
+				fieldKey: sItem.name,
+				contentKey: sItem.key,
+				ctx,
+			})
 			const result = SliceLegacy(itemCtx).encode(sItem.widget)
 
 			return {
@@ -158,6 +166,7 @@ export const SlicesItemLegacy = (ctx: LegacyContentCtx) => {
 					value: result?.content || {},
 				},
 				types: result?.types || {},
+				keys: result?.keys || {},
 			}
 		},
 	)

package/src/content/fields/slices/SlicesContent.ts

@@ -46,7 +46,6 @@ type SlicesLegacy = Array<unknown>
 
 export const SlicesLegacy = (ctx: LegacyContentCtx) => {
 	const codec = t.array(SlicesItemLegacy(ctx))
-
 	return new t.Type<SlicesContent, WithTypes<SlicesLegacy>, unknown>(
 		"SlicesLegacy",
 		isSlicesContent,
@@ -70,6 +69,10 @@ export const SlicesLegacy = (ctx: LegacyContentCtx) => {
 					(acc, s) => ({ ...acc, ...s.types }),
 					{ [ctx.keyOfType]: "Slices" },
 				),
+				keys: result.reduce<Record<string, string>>(
+					(acc, s) => ({ ...acc, ...s.keys }),
+					{},
+				),
 			}
 		},
 	)

package/src/customtypes/CustomType.ts

@@ -261,20 +261,17 @@ export function traverseCustomType<
 }): T {
 	const { customType, onField } = args
 
-	let json: Record<string, typeof customType.json[string]> | undefined
+	const json: Record<string, typeof customType.json[string]> = {}
 	for (const [key, section] of Object.entries(customType.json)) {
-		const newSection = traverseSection({
+		json[key] = traverseSection({
 			path: [key],
 			section,
 			onField,
 		})
-
-		if (newSection !== section) {
-			if (!json) json = { ...customType.json }
-			json[key] = newSection
-		}
 	}
 
-	// returns the traversed model instead of a new one if it didn't change
-	return json ? { ...customType, json } : customType
+	return {
+		...customType,
+		json,
+	}
 }

package/src/customtypes/Section.ts

@@ -52,7 +52,7 @@ export function traverseSection<
 }): T {
 	const { path: prevPath, section: prevSection, onField } = args
 
-	let section: T | undefined
+	const section = { ...prevSection }
 	for (const [key, prevModel] of Object.entries(prevSection)) {
 		const path = [...prevPath, key]
 		let model
@@ -84,13 +84,7 @@ export function traverseSection<
 				})
 				break
 		}
-
-		if (model !== prevModel) {
-			if (!section) section = { ...prevSection }
-			section[key] = model
-		}
+		section[key] = model
 	}
-
-	// returns the traversed model instead of a new one if it didn't change
-	return section ?? prevSection
+	return section
 }

package/src/customtypes/widgets/Group.ts

@@ -58,23 +58,23 @@ export function traverseNestedGroup(args: {
 
 	if (!group.config?.fields) return group
 
-	let fields: Record<string, NestableWidget> | undefined
-	for (const [key, field] of Object.entries(group.config.fields)) {
+	const fields: Record<string, NestableWidget> = {}
+	for (const [key, prevField] of Object.entries(group.config.fields)) {
 		const path = [...prevPath, key]
-		const newField = onField({
+		fields[key] = onField({
 			path,
 			key,
-			field,
+			field: prevField,
 		})
-
-		if (field !== newField) {
-			if (!fields) fields = { ...group.config.fields }
-			fields[key] = newField
-		}
 	}
 
-	// returns the traversed model instead of a new one if it didn't change
-	return fields ? { ...group, config: { ...group.config, fields } } : group
+	return {
+		...group,
+		config: {
+			...group.config,
+			fields,
+		},
+	}
 }
 
 export function traverseGroup(args: {
@@ -86,7 +86,7 @@ export function traverseGroup(args: {
 
 	if (!group.config?.fields) return group
 
-	let fields: Record<string, NestableWidget | NestedGroup> | undefined
+	const fields: Record<string, NestableWidget | NestedGroup> = {}
 	for (const [key, prevField] of Object.entries(group.config.fields)) {
 		const path = [...prevPath, key]
 		let field
@@ -102,19 +102,18 @@ export function traverseGroup(args: {
 				field = prevField
 				break
 		}
-
-		const newField = onField({
+		fields[key] = onField({
 			path,
 			key,
 			field,
 		})
-
-		if (field !== newField) {
-			if (!fields) fields = { ...group.config.fields }
-			fields[key] = newField
-		}
 	}
 
-	// returns the traversed model instead of a new one if it didn't change
-	return fields ? { ...group, config: { ...group.config, fields } } : group
+	return {
+		...group,
+		config: {
+			...group.config,
+			fields,
+		},
+	}
 }

package/src/customtypes/widgets/slices/CompositeSlice.ts

@@ -46,34 +46,21 @@ export function traverseCompositeSlice(args: {
 }): CompositeSlice {
 	const { path: prevPath, slice, onField } = args
 
-	let nonRepeat: Record<string, NestableWidget> | undefined
+	const nonRepeat: Record<string, NestableWidget> = {}
 	for (const [key, field] of Object.entries(slice["non-repeat"] ?? {})) {
 		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: Record<string, NestableWidget> | undefined
+	const repeat: Record<string, NestableWidget> = {}
 	for (const [key, field] of Object.entries(slice.repeat ?? {})) {
 		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 }),
+	}
 }

package/src/customtypes/widgets/slices/SharedSlice.ts

@@ -79,7 +79,7 @@ export function traverseVariation(args: {
 }): Variation {
 	const { path: prevPath, variation, onField } = args
 
-	let primary: Record<string, NestableWidget | Group> | undefined
+	const primary: Record<string, NestableWidget | Group> = {}
 	for (const [key, prevField] of Object.entries(variation.primary ?? {})) {
 		const path = [...prevPath, "primary", key]
 		let field
@@ -95,32 +95,20 @@ export 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: Record<string, NestableWidget> | undefined
-	for (const [key, prevField] of Object.entries(variation.items ?? {})) {
+	const items: Record<string, NestableWidget> = {}
+	for (const [key, field] of Object.entries(variation.items ?? {})) {
 		const path = [...prevPath, "items", key]
-		const newField = (onField as OnFieldFn<NestableWidget>)({
-			path,
-			key,
-			field: prevField,
-		})
-		if (prevField !== newField) {
-			if (!items) items = { ...variation.items }
-			items[key] = newField
-		}
+		items[key] = (onField as OnFieldFn<NestableWidget>)({ 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 }),
+	}
 }
 
 export function traverseSharedSlice(args: {
@@ -130,23 +118,20 @@ export function traverseSharedSlice(args: {
 }): SharedSlice {
 	const { path: prevPath, slice, onField } = args
 
-	let variations: Variation[] | undefined
-	for (let i = 0; i < slice.variations.length; i++) {
-		const variation = slice.variations[i]
-		if (!variation) continue
+	const variations: Variation[] = []
+	for (const variation of slice.variations) {
 		const path = [...prevPath, variation.id]
-		const newVariation = traverseVariation({
-			path,
-			variation,
-			onField,
-		})
-
-		if (newVariation !== variation) {
-			if (!variations) variations = [...slice.variations]
-			variations[i] = newVariation
-		}
+		variations.push(
+			traverseVariation({
+				path,
+				variation,
+				onField,
+			}),
+		)
 	}
 
-	// returns the traversed model instead of a new one if it didn't change
-	return variations ? { ...slice, variations } : slice
+	return {
+		...slice,
+		variations,
+	}
 }