@prismicio/types-internal 3.17.0-pr.145.680cd65 → 3.17.2

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

@@ -4,28 +4,38 @@ import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
 import type { CompositeSlice, VariationFields } from "../../../../customtypes"
-import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
-import { getFieldCtx } from "../../../LegacyContentCtx"
-import type {
+import {
+	getFieldCtx,
+	LegacyContentCtx,
+	WithTypes,
+} from "../../../LegacyContentCtx"
+import {
 	ContentPath,
+	hasContentType,
 	TraverseSliceContentFn,
-	TraverseWidgetContentFn} from "../../../utils";
-import {
-	hasContentType
+	TraverseWidgetContentFn,
 } from "../../../utils"
-import type { GroupItemContent} from "../../GroupContent";
-import { traverseGroupItemsContent } from "../../GroupContent"
-import { isNestableContent, NestableContent, NestableLegacy } from "../../nestable"
+import { GroupItemContent, traverseGroupItemsContent } from "../../GroupContent"
+import {
+	isNestableContent,
+	NestableContent,
+	NestableLegacy,
+} from "../../nestable"
 import {
 	repeatableContentWithDefaultNestableContentValues,
 	withDefaultNestableContentValues,
 } from "../../withDefaultValues"
-import type { CompositeSliceItemContent, SharedSliceItemContent } from "../SliceItem"
+import type {
+	CompositeSliceItemContent,
+	SharedSliceItemContent,
+} from "../SliceItem"
 import { RepeatableWidgets, RepeatableWidgetsLegacy } from "./RepeatableContent"
 
 export const CompositeSliceContentType = "CompositeSliceContent"
 
-export const isCompositeSliceContent = (u: unknown): u is CompositeSliceContent =>
+export const isCompositeSliceContent = (
+	u: unknown,
+): u is CompositeSliceContent =>
 	hasContentType(u) && u.__TYPE__ === CompositeSliceContentType
 
 const legacyReader = t.exact(
@@ -37,7 +47,11 @@ const legacyReader = t.exact(
 type CompositeSliceLegacy = t.TypeOf<typeof legacyReader>
 
 export const CompositeSliceLegacy = (ctx: LegacyContentCtx) => {
-	return new t.Type<CompositeSliceContent, WithTypes<CompositeSliceLegacy>, unknown>(
+	return new t.Type<
+		CompositeSliceContent,
+		WithTypes<CompositeSliceLegacy>,
+		unknown
+	>(
 		"CompositeSliceLegacy",
 		isCompositeSliceContent,
 		(slice) => {
@@ -47,14 +61,16 @@ export const CompositeSliceLegacy = (ctx: LegacyContentCtx) => {
 					const repeat =
 						(() => {
 							const itemsCtx = getFieldCtx({ fieldKey: "repeat", ctx })
-							const result = RepeatableWidgetsLegacy(itemsCtx).decode(parsedSlice.repeat)
+							const result = RepeatableWidgetsLegacy(itemsCtx).decode(
+								parsedSlice.repeat,
+							)
 							if (!result || isLeft(result)) return
 							return result.right
 						})() || []
 
-					const nonRepeat = Object.entries(parsedSlice["non-repeat"] || {}).reduce<
-						Record<string, NestableContent>
-					>((acc, [key, value]) => {
+					const nonRepeat = Object.entries(
+						parsedSlice["non-repeat"] || {},
+					).reduce<Record<string, NestableContent>>((acc, [key, value]) => {
 						const fieldCtx = getFieldCtx({
 							fieldKey: key,
 							ctx,
@@ -78,7 +94,9 @@ export const CompositeSliceLegacy = (ctx: LegacyContentCtx) => {
 			)
 		},
 		(s: CompositeSliceContent) => {
-			const nonRepeat = Object.entries(s.nonRepeat).reduce<WithTypes<{ [key: string]: unknown }>>(
+			const nonRepeat = Object.entries(s.nonRepeat).reduce<
+				WithTypes<{ [key: string]: unknown }>
+			>(
 				(acc, [key, value]) => {
 					const FieldCtx = getFieldCtx({
 						fieldKey: key,
@@ -140,10 +158,11 @@ export function compositeSliceContentWithDefaultValues(
 		customType["non-repeat"] ?? {},
 		content.nonRepeat,
 	)
-	const updatedRepeatContent = repeatableContentWithDefaultNestableContentValues(
-		customType.repeat ?? {},
-		content.repeat,
-	)
+	const updatedRepeatContent =
+		repeatableContentWithDefaultNestableContentValues(
+			customType.repeat ?? {},
+			content.repeat,
+		)
 
 	return {
 		...content,
@@ -204,7 +223,8 @@ export function traverseCompositeSliceContent({
 
 		const items = traverseGroupItemsContent({
 			path: path.concat([{ key: "repeat", type: "items" }]),
-			model: model?.type === "SharedSlice" ? model?.fields.items : model?.repeat,
+			model:
+				model?.type === "SharedSlice" ? model?.fields.items : model?.repeat,
 			content: content.widget.repeat,
 		})(transformWidget)
 
@@ -237,16 +257,19 @@ export function migrateCompositeSlice(
 		widget: {
 			__TYPE__: "SharedSliceContent",
 			variation: model.variationId,
-			primary: Object.entries(content.widget.nonRepeat).reduce((acc, [fieldKey, fieldContent]) => {
-				if (!model.fields.primary?.[fieldKey]) {
-					console.warn(
-						`The widget ${fieldKey} in the non-repeat zone of the composite slice [${model.sliceName}] with key [${content.key}] doesn't exist in the model.`,
-					)
-					return acc
-				}
+			primary: Object.entries(content.widget.nonRepeat).reduce(
+				(acc, [fieldKey, fieldContent]) => {
+					if (!model.fields.primary?.[fieldKey]) {
+						console.warn(
+							`The widget ${fieldKey} in the non-repeat zone of the composite slice [${model.sliceName}] with key [${content.key}] doesn't exist in the model.`,
+						)
+						return acc
+					}
 
-				return { ...acc, [fieldKey]: fieldContent }
-			}, {}),
+					return { ...acc, [fieldKey]: fieldContent }
+				},
+				{},
+			),
 			items: content.widget.repeat.map((groupItem) => {
 				return {
 					__TYPE__: "GroupItemContent",

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

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

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

@@ -4,17 +4,27 @@ import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 import { withFallback } from "io-ts-types"
 
-import { type SharedSlice, type VariationFields, GroupFieldType } from "../../../../customtypes"
-import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
-import { getFieldCtx } from "../../../LegacyContentCtx"
-import type {
+import {
+	type SharedSlice,
+	type VariationFields,
+	GroupFieldType,
+} from "../../../../customtypes"
+import {
+	getFieldCtx,
+	LegacyContentCtx,
+	WithTypes,
+} from "../../../LegacyContentCtx"
+import {
 	ContentPath,
+	hasContentType,
 	TraverseSliceContentFn,
-	TraverseWidgetContentFn} from "../../../utils";
-import {
-	hasContentType
+	TraverseWidgetContentFn,
 } from "../../../utils"
-import { isGroupContent, traverseGroupContent, traverseGroupItemsContent } from "../../GroupContent"
+import {
+	isGroupContent,
+	traverseGroupContent,
+	traverseGroupItemsContent,
+} from "../../GroupContent"
 import {
 	isNestableContent,
 	isRepeatableContent,
@@ -63,7 +73,9 @@ export const SharedSliceLegacy = (ctx: LegacyContentCtx) => {
 								ctx,
 								prefixes: ["variations", parsedSlice.variation],
 							})
-							const result = RepeatableWidgetsLegacy(itemsCtx).decode(parsedSlice.items)
+							const result = RepeatableWidgetsLegacy(itemsCtx).decode(
+								parsedSlice.items,
+							)
 							if (!result || isLeft(result)) return
 							return result.right
 						})() || []
@@ -94,7 +106,9 @@ export const SharedSliceLegacy = (ctx: LegacyContentCtx) => {
 			)
 		},
 		(s: SharedSliceContent) => {
-			const primary = Object.entries(s.primary).reduce<WithTypes<Record<string, unknown>>>(
+			const primary = Object.entries(s.primary).reduce<
+				WithTypes<Record<string, unknown>>
+			>(
 				(acc, [key, value]) => {
 					const FieldCtx = getFieldCtx({
 						fieldKey: key,
@@ -157,12 +171,17 @@ export function sharedSliceContentWithDefaultValues(
 	customType: SharedSlice,
 	content: SharedSliceContent,
 ): SharedSliceContent {
-	const variationConfig = customType.variations.find((v) => v.id === content.variation)
+	const variationConfig = customType.variations.find(
+		(v) => v.id === content.variation,
+	)
 
 	const primaryConfig = variationConfig?.primary ?? {}
 	const itemsConfig = variationConfig?.items ?? {}
 
-	const updatedPrimaryContent = withDefaultSlicePrimaryContentValues(primaryConfig, content.primary)
+	const updatedPrimaryContent = withDefaultSlicePrimaryContentValues(
+		primaryConfig,
+		content.primary,
+	)
 	const updatedItemsContent = repeatableContentWithDefaultNestableContentValues(
 		itemsConfig,
 		content.items,
@@ -192,75 +211,74 @@ export function traverseSharedSliceContent({
 		transformWidget: TraverseWidgetContentFn,
 		transformSlice: TraverseSliceContentFn,
 	): SharedSliceItemContent | undefined => {
-		const primary = Object.entries(content.widget.primary).reduce<SharedSliceContent["primary"]>(
-			(acc, [fieldKey, fieldContent]) => {
-				const fieldDef = model?.fields?.primary?.[fieldKey]
+		const primary = Object.entries(content.widget.primary).reduce<
+			SharedSliceContent["primary"]
+		>((acc, [fieldKey, fieldContent]) => {
+			const fieldDef = model?.fields?.primary?.[fieldKey]
 
-				const transformedField = (() => {
-					if (isGroupContent(fieldContent)) {
-						return traverseGroupContent({
-							path: path.concat([
-								{ key: "primary", type: "primary" },
-								{ key: fieldKey, type: "Widget" },
-							]),
-							key: fieldKey,
-							apiId: fieldKey,
-							content: fieldContent,
-							model: fieldDef?.type === GroupFieldType ? fieldDef : undefined,
-						})(transformWidget)
-					} else if (isRepeatableContent(fieldContent)) {
-						return traverseRepeatableContent({
-							path: path.concat([
-								{ key: "primary", type: "primary" },
-								{ key: fieldKey, type: "Widget" },
-							]),
-							key: fieldKey,
-							apiId: fieldKey,
-							content: fieldContent,
-							model: fieldDef?.type === "Link" ? fieldDef : undefined,
-						})(transformWidget)
-					} else if (isTableContent(fieldContent)) {
-						return traverseTableContent({
-							path: path.concat([
-								{ key: "primary", type: "primary" },
-								{ key: fieldKey, type: "Widget" },
-							]),
-							key: fieldKey,
-							apiId: fieldKey,
-							content: fieldContent,
-							model: fieldDef?.type === "Table" ? fieldDef : undefined,
-						})(transformWidget)
-					} else if (isNestableContent(fieldContent)) {
-						return transformWidget({
-							path: path.concat([
-								{ key: "primary", type: "primary" },
-								{ key: fieldKey, type: "Widget" },
-							]),
-							key: fieldKey,
-							apiId: fieldKey,
-							model: fieldDef,
-							content: fieldContent,
-						})
-					} else {
-						return undefined
-					}
-				})()
-
-				// Can happen if the transform function returns undefined to filter out a field
-				if (!transformedField) return acc
-				if (!isSlicePrimaryContent(transformedField)) {
-					console.warn(
-						`Warn: Non nestable or group content with key [${fieldKey}] detected in a shared slice [${sliceName}] with key [${sliceKey}]`,
-					)
+			const transformedField = (() => {
+				if (isGroupContent(fieldContent)) {
+					return traverseGroupContent({
+						path: path.concat([
+							{ key: "primary", type: "primary" },
+							{ key: fieldKey, type: "Widget" },
+						]),
+						key: fieldKey,
+						apiId: fieldKey,
+						content: fieldContent,
+						model: fieldDef?.type === GroupFieldType ? fieldDef : undefined,
+					})(transformWidget)
+				} else if (isRepeatableContent(fieldContent)) {
+					return traverseRepeatableContent({
+						path: path.concat([
+							{ key: "primary", type: "primary" },
+							{ key: fieldKey, type: "Widget" },
+						]),
+						key: fieldKey,
+						apiId: fieldKey,
+						content: fieldContent,
+						model: fieldDef?.type === "Link" ? fieldDef : undefined,
+					})(transformWidget)
+				} else if (isTableContent(fieldContent)) {
+					return traverseTableContent({
+						path: path.concat([
+							{ key: "primary", type: "primary" },
+							{ key: fieldKey, type: "Widget" },
+						]),
+						key: fieldKey,
+						apiId: fieldKey,
+						content: fieldContent,
+						model: fieldDef?.type === "Table" ? fieldDef : undefined,
+					})(transformWidget)
+				} else if (isNestableContent(fieldContent)) {
+					return transformWidget({
+						path: path.concat([
+							{ key: "primary", type: "primary" },
+							{ key: fieldKey, type: "Widget" },
+						]),
+						key: fieldKey,
+						apiId: fieldKey,
+						model: fieldDef,
+						content: fieldContent,
+					})
+				} else {
+					return undefined
 				}
+			})()
 
-				return {
-					...acc,
-					[fieldKey]: transformedField,
-				}
-			},
-			{},
-		)
+			// Can happen if the transform function returns undefined to filter out a field
+			if (!transformedField) return acc
+			if (!isSlicePrimaryContent(transformedField)) {
+				console.warn(
+					`Warn: Non nestable or group content with key [${fieldKey}] detected in a shared slice [${sliceName}] with key [${sliceKey}]`,
+				)
+			}
+
+			return {
+				...acc,
+				[fieldKey]: transformedField,
+			}
+		}, {})
 
 		const items = traverseGroupItemsContent({
 			path: path.concat([{ key: "items", type: "items" }]),

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

@@ -1,18 +1,32 @@
 import * as t from "io-ts"
 
-import type { Group, NestableWidget, VariationFields } from "../../../../customtypes"
+import type {
+	Group,
+	NestableWidget,
+	VariationFields,
+} from "../../../../customtypes"
 import type { LegacyContentCtx } from "../../../LegacyContentCtx"
-import type { ContentPath, TraverseSliceContentFn, TraverseWidgetContentFn } from "../../../utils"
 import type {
-	GroupItemContent} from "../../GroupContent";
+	ContentPath,
+	TraverseSliceContentFn,
+	TraverseWidgetContentFn,
+} from "../../../utils"
 import {
 	GroupContent,
+	GroupItemContent,
 	GroupLegacy,
 	isGroupContent,
 	traverseGroupContent,
 } from "../../GroupContent"
-import { isNestableContent, NestableContent, NestableLegacy } from "../../nestable"
-import type { SharedSliceItemContent, SimpleSliceItemContent } from "../SliceItem"
+import {
+	isNestableContent,
+	NestableContent,
+	NestableLegacy,
+} from "../../nestable"
+import type {
+	SharedSliceItemContent,
+	SimpleSliceItemContent,
+} from "../SliceItem"
 
 export const SimpleSliceContent = t.union([NestableContent, GroupContent])
 export type SimpleSliceContent = t.TypeOf<typeof SimpleSliceContent>
@@ -56,21 +70,22 @@ export function traverseSimpleSliceContent({
 		transformSlice: TraverseSliceContentFn,
 	): SharedSliceItemContent | SimpleSliceItemContent | undefined => {
 		if (isGroupContent(content.widget)) {
-			const convertedGroupWidget: GroupContent | undefined = traverseGroupContent({
-				path,
-				key: content.key,
-				apiId: content.name,
-				model: (() => {
-					if (model?.type === "Group") return model
-					if (model?.type === "SharedSlice")
-						return {
-							type: "Group",
-							config: { fields: model.fields.items || {} },
-						}
-					return
-				})(),
-				content: content.widget,
-			})(transformWidget)
+			const convertedGroupWidget: GroupContent | undefined =
+				traverseGroupContent({
+					path,
+					key: content.key,
+					apiId: content.name,
+					model: (() => {
+						if (model?.type === "Group") return model
+						if (model?.type === "SharedSlice")
+							return {
+								type: "Group",
+								config: { fields: model.fields.items || {} },
+							}
+						return
+					})(),
+					content: content.widget,
+				})(transformWidget)
 
 			return (
 				convertedGroupWidget &&
@@ -92,7 +107,8 @@ export function traverseSimpleSliceContent({
 			apiId: content.name,
 			path,
 			model: (() => {
-				if (model?.type === "SharedSlice") return model.fields.primary?.[content.name]
+				if (model?.type === "SharedSlice")
+					return model.fields.primary?.[content.name]
 				if (model?.type !== "Group") return model
 				return
 			})(),
@@ -137,7 +153,9 @@ export function migrateSimpleSlice(
 						key: groupItem.key,
 						value: groupItem.value.reduce<GroupItemContent["value"]>(
 							(acc, [fieldKey, fieldContent]) => {
-								return model.fields.items?.[fieldKey] ? acc.concat([[fieldKey, fieldContent]]) : acc
+								return model.fields.items?.[fieldKey]
+									? acc.concat([[fieldKey, fieldContent]])
+									: acc
 							},
 							[],
 						),
@@ -153,7 +171,9 @@ export function migrateSimpleSlice(
 		widget: {
 			__TYPE__: "SharedSliceContent",
 			variation: model.variationId,
-			primary: model.fields.primary?.[content.name] ? { [content.name]: content.widget } : {},
+			primary: model.fields.primary?.[content.name]
+				? { [content.name]: content.widget }
+				: {},
 			items: [],
 		},
 	}

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

@@ -3,7 +3,11 @@ import * as t from "io-ts"
 import { GroupFieldType } from "../../../../customtypes"
 import type { LegacyContentCtx } from "../../../LegacyContentCtx"
 import { GroupContent, GroupLegacy, isGroupContent } from "../../GroupContent"
-import { isNestableContent, NestableContent, NestableLegacy } from "../../nestable"
+import {
+	isNestableContent,
+	NestableContent,
+	NestableLegacy,
+} from "../../nestable"
 
 export const SlicePrimaryContent = t.union([NestableContent, GroupContent])
 

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

@@ -1,7 +1,10 @@
 import * as t from "io-ts"
 
 import type { LegacyContentCtx } from "../../../LegacyContentCtx"
-import { CompositeSliceContent, CompositeSliceLegacy } from "./CompositeSliceContent"
+import {
+	CompositeSliceContent,
+	CompositeSliceLegacy,
+} from "./CompositeSliceContent"
 import { SharedSliceContent, SharedSliceLegacy } from "./SharedSliceContent"
 import { SimpleSliceContent, SimpleSliceLegacy } from "./SimpleSliceContent"
 
@@ -35,7 +38,11 @@ export const SliceLegacy = (ctx: LegacyContentCtx) => {
 	}
 }
 
-export const SliceContent = t.union([CompositeSliceContent, SharedSliceContent, SimpleSliceContent])
+export const SliceContent = t.union([
+	CompositeSliceContent,
+	SharedSliceContent,
+	SimpleSliceContent,
+])
 
 export type SliceContent = t.TypeOf<typeof SliceContent>
 

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

@@ -5,8 +5,11 @@ import * as t from "io-ts"
 
 import type { StaticSlice } from "../../../customtypes"
 import { nullable } from "../../../validators/function"
-import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx";
-import { getFieldCtx } from "../../LegacyContentCtx"
+import {
+	getFieldCtx,
+	LegacyContentCtx,
+	WithTypes,
+} from "../../LegacyContentCtx"
 import type { TraverseSliceContentFn } from "../../utils"
 import { isGroupContent } from "../GroupContent"
 import { isNestableContent } from "../nestable"
@@ -17,19 +20,19 @@ import {
 	SliceContent,
 	SliceLegacy,
 } from "./Slice"
-import type {
-	CompositeSliceContent} from "./Slice/CompositeSliceContent";
 import {
+	CompositeSliceContent,
 	isCompositeSliceContent,
 	migrateCompositeSlice,
 } from "./Slice/CompositeSliceContent"
-import type { SharedSliceContent } from "./Slice/SharedSliceContent";
-import { isSharedSliceContent } from "./Slice/SharedSliceContent"
-import type {
-	SimpleSliceContent} from "./Slice/SimpleSliceContent";
+import {
+	isSharedSliceContent,
+	SharedSliceContent,
+} from "./Slice/SharedSliceContent"
 import {
 	isSimpleSliceContent,
-	migrateSimpleSlice
+	migrateSimpleSlice,
+	SimpleSliceContent,
 } from "./Slice/SimpleSliceContent"
 
 export const SliceItemContent = t.type({
@@ -42,7 +45,9 @@ export type SliceItemContent = t.TypeOf<typeof SliceItemContent>
 export type SharedSliceItemContent = Omit<SliceItemContent, "widget"> & {
 	widget: SharedSliceContent
 }
-export function isSharedSliceItemContent(item: SliceItemContent): item is SharedSliceItemContent {
+export function isSharedSliceItemContent(
+	item: SliceItemContent,
+): item is SharedSliceItemContent {
 	return isSharedSliceContent(item.widget)
 }
 
@@ -57,7 +62,9 @@ export function isCompositeSliceItemContent(
 export type SimpleSliceItemContent = Omit<SliceItemContent, "widget"> & {
 	widget: SimpleSliceContent
 }
-export function isSimpleSliceItemContent(item: SliceItemContent): item is SimpleSliceItemContent {
+export function isSimpleSliceItemContent(
+	item: SliceItemContent,
+): item is SimpleSliceItemContent {
 	return isGroupContent(item.widget) || isNestableContent(item.widget)
 }
 
@@ -73,11 +80,16 @@ export function sliceItemContentWithDefaultValues(
 		return compositeSliceContentWithDefaultValues(customType, content)
 	}
 
-	if (customType.type === "Group" && isGroupContent(content) && customType.config?.fields) {
-		const updateGroupFieldValue = repeatableContentWithDefaultNestableContentValues(
-			customType.config.fields,
-			content.value,
-		)
+	if (
+		customType.type === "Group" &&
+		isGroupContent(content) &&
+		customType.config?.fields
+	) {
+		const updateGroupFieldValue =
+			repeatableContentWithDefaultNestableContentValues(
+				customType.config.fields,
+				content.value,
+			)
 
 		return {
 			...content,
@@ -118,7 +130,10 @@ export const SlicesItemLegacy = (ctx: LegacyContentCtx) => {
 				itemLegacyReader.decode(sliceItem),
 				either.chain((parsedSlice) => {
 					const stopIdx = parsedSlice.key.indexOf("$")
-					const sliceName = parsedSlice.key.substring(0, stopIdx > 0 ? stopIdx : undefined)
+					const sliceName = parsedSlice.key.substring(
+						0,
+						stopIdx > 0 ? stopIdx : undefined,
+					)
 					const itemCtx = getFieldCtx({
 						fieldKey: sliceName,
 						contentKey: parsedSlice.key,
@@ -157,7 +172,10 @@ export const SlicesItemLegacy = (ctx: LegacyContentCtx) => {
 	)
 }
 
-export const migrateSliceItem: TraverseSliceContentFn = ({ model, content }) => {
+export const migrateSliceItem: TraverseSliceContentFn = ({
+	model,
+	content,
+}) => {
 	if (isCompositeSliceItemContent(content) && model?.type === "SharedSlice")
 		return migrateCompositeSlice(model, content)
 	if (isSimpleSliceItemContent(content) && model?.type === "SharedSlice")