@prismicio/types-internal 3.11.0 → 3.11.2-alpha.0

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

@@ -45,33 +45,32 @@ export function traverseCompositeSlice(args: {
 	onField: OnFieldFn<NestableWidget>
 }): CompositeSlice {
 	const { path: prevPath, slice, onField } = args
-	const nonRepeat =
-		slice["non-repeat"] &&
-		Object.entries(slice["non-repeat"]).reduce<Record<string, NestableWidget>>(
-			(acc, [key, field]) => {
-				const path = prevPath.concat("non-repeat", key)
-				acc[key] = onField({ path, key, field })
-				return acc
-			},
-			{},
-		)
-	const repeat =
-		slice.repeat &&
-		Object.entries(slice.repeat).reduce<Record<string, NestableWidget>>(
-			(acc, [key, field]) => {
-				const path = prevPath.concat("repeat", key)
-				acc[key] = onField({ path, key, field })
-				return acc
-			},
-			{},
-		)
-	return {
-		...slice,
-		...(nonRepeat && {
-			"non-repeat": nonRepeat,
-		}),
-		...(repeat && {
-			repeat,
-		}),
+
+	const nonRepeat: Record<string, NestableWidget> = {}
+	let nonRepeatChanged = false
+	for (const [key, field] of Object.entries(slice["non-repeat"] ?? {})) {
+		const path = [...prevPath, "non-repeat", key]
+		const newField = onField({ path, key, field })
+
+		if (!nonRepeatChanged && field !== newField) nonRepeatChanged = true
+		nonRepeat[key] = newField
 	}
+
+	const repeat: Record<string, NestableWidget> = {}
+	let repeatChanged = false
+	for (const [key, field] of Object.entries(slice.repeat ?? {})) {
+		const path = [...prevPath, "repeat", key]
+		const newField = onField({ path, key, field })
+
+		if (!repeatChanged && field !== newField) repeatChanged = true
+		repeat[key] = newField
+	}
+
+	return nonRepeatChanged || repeatChanged
+		? {
+				...slice,
+				...(nonRepeatChanged && { "non-repeat": nonRepeat }),
+				...(repeatChanged && { repeat }),
+		  }
+		: slice
 }

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

@@ -78,48 +78,50 @@ export function traverseVariation(args: {
 	onField: OnFieldFn<NestableWidget | Group | NestedGroup>
 }): Variation {
 	const { path: prevPath, variation, onField } = args
-	return {
-		...variation,
-		...(variation.primary && {
-			primary: Object.entries(variation.primary).reduce<
-				Record<string, NestableWidget | Group>
-			>((acc, [key, prevField]) => {
-				const path = prevPath.concat("primary", key)
-				let field
-				switch (prevField.type) {
-					case "Group":
-						field = traverseGroup({
-							path,
-							group: prevField,
-							onField: onField as OnFieldFn<NestableWidget | NestedGroup>,
-						})
-						break
-					default:
-						field = prevField
-						break
-				}
-				acc[key] = onField({
-					path,
-					key,
-					field,
-				})
-				return acc
-			}, {}),
-		}),
-		...(variation.items && {
-			items: Object.entries(variation.items).reduce<
-				Record<string, NestableWidget>
-			>((acc, [key, field]) => {
-				const path = prevPath.concat("items", key)
-				acc[key] = (onField as OnFieldFn<NestableWidget>)({
+
+	const primary: Record<string, NestableWidget | Group> = {}
+	let primaryChanged = false
+	for (const [key, prevField] of Object.entries(variation.primary ?? {})) {
+		const path = [...prevPath, "primary", key]
+		let field
+		switch (prevField.type) {
+			case "Group":
+				field = traverseGroup({
 					path,
-					key,
-					field,
+					group: prevField,
+					onField: onField as OnFieldFn<NestableWidget | NestedGroup>,
 				})
-				return acc
-			}, {}),
-		}),
+				break
+			default:
+				field = prevField
+				break
+		}
+
+		const newField = onField({ path, key, field })
+		if (!primaryChanged && field !== newField) primaryChanged = true
+		primary[key] = newField
 	}
+
+	const items: Record<string, NestableWidget> = {}
+	let itemsChanged = false
+	for (const [key, prevField] of Object.entries(variation.items ?? {})) {
+		const path = [...prevPath, "items", key]
+		const newField = (onField as OnFieldFn<NestableWidget>)({
+			path,
+			key,
+			field: prevField,
+		})
+		if (!itemsChanged && prevField !== newField) itemsChanged = true
+		items[key] = newField
+	}
+
+	return primaryChanged || itemsChanged
+		? {
+				...variation,
+				...(primaryChanged && { primary }),
+				...(itemsChanged && { items }),
+		  }
+		: variation
 }
 
 export function traverseSharedSlice(args: {
@@ -128,15 +130,25 @@ export function traverseSharedSlice(args: {
 	onField: OnFieldFn<NestableWidget | Group | NestedGroup>
 }): SharedSlice {
 	const { path: prevPath, slice, onField } = args
-	return {
-		...slice,
-		variations: slice.variations.map((variation) => {
-			const path = prevPath.concat(variation.id)
-			return traverseVariation({
-				path,
-				variation,
-				onField,
-			})
-		}),
+
+	const variations: Variation[] = []
+	let changed = false
+	for (const variation of slice.variations) {
+		const path = [...prevPath, variation.id]
+		const newVariation = traverseVariation({
+			path,
+			variation,
+			onField,
+		})
+
+		if (!changed && newVariation !== variation) changed = true
+		variations.push(newVariation)
 	}
+
+	return changed
+		? {
+				...slice,
+				variations,
+		  }
+		: slice
 }

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

@@ -120,60 +120,63 @@ export function traverseSlices<T extends DynamicSlices | StaticSlices>(args: {
 	onField: OnFieldFn<NestableWidget | Group | NestedGroup>
 }): T {
 	const { path: prevPath, slices, onField } = args
-	const choices =
-		slices.config?.choices &&
-		Object.entries(slices.config.choices).reduce<
-			Record<string, typeof slices.config.choices[string]>
-		>((acc, [key, prevModel]) => {
-			const path = prevPath.concat(key)
-			let model
-			switch (prevModel.type) {
-				case "Slice":
-					model = traverseCompositeSlice({
-						path,
-						slice: prevModel,
-						onField: onField as OnFieldFn<NestableWidget>,
-					})
-					break
-				case "SharedSlice":
-					if ("variations" in prevModel)
-						model = traverseSharedSlice({
-							path,
-							slice: prevModel as SharedSlice,
-							onField,
-						})
-					else model = prevModel
-					break
-				// Group and other fields are technically possible because of legacy slices.
-				case "Group":
-					model = onField({
+
+	if (!slices.config?.choices) return slices
+
+	const choices: Record<string, typeof slices.config.choices[string]> = {}
+	let changed = false
+	for (const [key, prevModel] of Object.entries(slices.config.choices)) {
+		const path = [...prevPath, key]
+		let model
+		switch (prevModel.type) {
+			case "Slice":
+				model = traverseCompositeSlice({
+					path,
+					slice: prevModel,
+					onField: onField as OnFieldFn<NestableWidget>,
+				})
+				break
+			case "SharedSlice":
+				if ("variations" in prevModel)
+					model = traverseSharedSlice({
 						path,
-						key,
-						field: traverseNestedGroup({
-							path,
-							group: prevModel,
-							onField: onField as OnFieldFn<NestableWidget>,
-						}),
+						slice: prevModel as SharedSlice,
+						onField,
 					})
-					break
-				default:
-					model = onField({
+				else model = prevModel
+				break
+			// Group and other fields are technically possible because of legacy slices.
+			case "Group":
+				model = onField({
+					path,
+					key,
+					field: traverseNestedGroup({
 						path,
-						key,
-						field: prevModel,
-					})
-					break
-			}
-			acc[key] = model as typeof slices.config.choices[string]
-			return acc
-		}, {})
-	return {
-		...slices,
-		...(slices.config && {
-			config: {
-				...slices.config,
-				...(choices && { choices }),
-			},
-		}),
+						group: prevModel,
+						onField: onField as OnFieldFn<NestableWidget>,
+					}),
+				})
+				break
+			default:
+				model = onField({
+					path,
+					key,
+					field: prevModel,
+				})
+				break
+		}
+
+		if (!changed && model !== prevModel) changed = true
+		choices[key] = model as typeof slices.config.choices[string]
 	}
+
+	return changed
+		? {
+				...slices,
+				config: {
+					...slices.config,
+					choices,
+				},
+		  }
+		: slices
 }