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

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

@@ -78,47 +78,36 @@ 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> = {}
+	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
+		}
+		primary[key] = onField({ path, key, field })
+	}
+
+	const items: Record<string, NestableWidget> = {}
+	for (const [key, field] of Object.entries(variation.items ?? {})) {
+		const path = [...prevPath, "items", key]
+		items[key] = (onField as OnFieldFn<NestableWidget>)({ path, key, field })
+	}
+
+	return {
+		...variation,
+		...(variation.primary && { primary }),
+		...(variation.items && { items }),
 	}
 }
 
@@ -128,15 +117,21 @@ 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({
+
+	const variations: Variation[] = []
+	for (const variation of slice.variations) {
+		const path = [...prevPath, variation.id]
+		variations.push(
+			traverseVariation({
 				path,
 				variation,
 				onField,
-			})
-		}),
+			}),
+		)
+	}
+
+	return {
+		...slice,
+		variations,
 	}
 }

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

@@ -120,60 +120,59 @@ 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]> = {}
+	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
-		}, {})
+						group: prevModel,
+						onField: onField as OnFieldFn<NestableWidget>,
+					}),
+				})
+				break
+			default:
+				model = onField({
+					path,
+					key,
+					field: prevModel,
+				})
+				break
+		}
+
+		choices[key] = model as typeof slices.config.choices[string]
+	}
+
 	return {
 		...slices,
-		...(slices.config && {
-			config: {
-				...slices.config,
-				...(choices && { choices }),
-			},
-		}),
+		config: {
+			...slices.config,
+			choices,
+		},
 	}
 }