@prismicio/types-internal 3.17.0-alpha.2 → 3.17.0-pr.144.0c8207f

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

@@ -5,17 +5,14 @@ import * as t from "io-ts"
 
 import type { Link, NestableWidget } from "../../../customtypes"
 import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx"
-import {
+import type {
 	ContentPath,
-	hasContentType,
 	TraverseWidgetContentFn,
-} from "../../utils"
+	TraverseWidgetContentWithModelFn} from "../../utils";
 import {
-	isLinkContent,
-	LinkContent,
-	LinkContentLegacy,
-	LinkContentType,
-} from "./LinkContent"
+	hasContentType
+} from "../../utils"
+import { isLinkContent, LinkContent, LinkContentLegacy, LinkContentType } from "./LinkContent"
 
 const RepeatableContentType = "RepeatableContent" as const
 
@@ -68,22 +65,19 @@ export const RepeatableLegacy = (
 		},
 		(r: RepeatableContent) => {
 			const res = t.array(LinkContent).encode(r.value)
-			const encodedItems = res.reduce<Array<WithTypes<unknown>>>(
-				(acc, item) => {
-					let encoded
-
-					switch (item.__TYPE__) {
-						case LinkContentType:
-							encoded = LinkContentLegacy(ctx).encode(item)
-							break
-					}
+			const encodedItems = res.reduce<Array<WithTypes<unknown>>>((acc, item) => {
+				let encoded
 
-					if (!encoded) return acc
+				switch (item.__TYPE__) {
+					case LinkContentType:
+						encoded = LinkContentLegacy(ctx).encode(item)
+						break
+				}
 
-					return [...acc, encoded]
-				},
-				[],
-			)
+				if (!encoded) return acc
+
+				return [...acc, encoded]
+			}, [])
 
 			return {
 				content: encodedItems.map((encodedItem) => encodedItem.content),
@@ -112,53 +106,101 @@ export function traverseRepeatableContent({
 	content: RepeatableContent
 	model?: NestableWidget | undefined
 }) {
-	return (
-		transform: TraverseWidgetContentFn,
-	): RepeatableContent | undefined => {
-		const items = content.value.reduce<Array<LinkContent>>(
-			(acc, fieldContent, index) => {
-				const itemPath = path.concat([
-					{ key: index.toString(), type: "Widget" },
-				])
-
-				// Content inside repeatable can't be repeatable.
+	return (transform: TraverseWidgetContentFn): RepeatableContent | undefined => {
+		const items = content.value.reduce<Array<LinkContent>>((acc, fieldContent, index) => {
+			const itemPath = path.concat([{ key: index.toString(), type: "Widget" }])
+
+			// Content inside repeatable can't be repeatable.
+			const newModel =
+				model?.type === "Link" && model.config
+					? {
+							...model,
+							config: { ...model.config, repeat: false },
+						}
+					: model
+
+			const transformedField = transform({
+				path: itemPath,
+				key: key,
+				apiId: apiId,
+				model: newModel,
+				content: fieldContent,
+			})
+
+			// Can happen if the transform function returns undefined to filter out a field
+			if (!transformedField) return acc
+
+			// If the transformed field is not a link content, we don't include it
+			if (!isLinkContent(transformedField)) return acc
+
+			return acc.concat(transformedField)
+		}, [])
+
+		return transform({
+			path,
+			key,
+			apiId,
+			model,
+			content: {
+				__TYPE__: content.__TYPE__,
+				type: content.type,
+				value: items,
+			},
+		})
+	}
+}
+
+export function traverseRepeatableContentWithModel({
+	path,
+	key,
+	model,
+	content,
+}: {
+	path: ContentPath
+	key: string
+	model: NestableWidget
+	content: RepeatableContent | undefined
+}): (transform: TraverseWidgetContentWithModelFn) => RepeatableContent | undefined {
+	return (transform) => {
+		const items =
+			content?.value.reduce<Array<LinkContent>>((acc, fieldContent, index) => {
+				const itemPath = path.concat([{ key: index.toString(), type: "Widget" }])
+
 				const newModel =
 					model?.type === "Link" && model.config
 						? {
 								...model,
 								config: { ...model.config, repeat: false },
-						  }
+							}
 						: model
 
 				const transformedField = transform({
 					path: itemPath,
 					key: key,
-					apiId: apiId,
+					apiId: key,
 					model: newModel,
 					content: fieldContent,
 				})
 
-				// Can happen if the transform function returns undefined to filter out a field
 				if (!transformedField) return acc
 
-				// If the transformed field is not a link content, we don't include it
 				if (!isLinkContent(transformedField)) return acc
 
 				return acc.concat(transformedField)
-			},
-			[],
-		)
+			}, []) ?? []
 
 		return transform({
 			path,
 			key,
-			apiId,
+			apiId: key,
 			model,
-			content: {
-				__TYPE__: content.__TYPE__,
-				type: content.type,
-				value: items,
-			},
+			content: content
+				? {
+						__TYPE__: content.__TYPE__,
+						type: content.type,
+						value: items,
+					}
+				: undefined,
 		})
 	}
 }

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

@@ -4,18 +4,11 @@ import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 import { withFallback } from "io-ts-types"
 
-import {
-	RichTextNodeType,
-	RichTextNodeTypeCodec,
-} from "../../../../customtypes/widgets/nestable"
+import { RichTextNodeType, RichTextNodeTypeCodec } from "../../../../customtypes/widgets/nestable"
 import { StringOrNull } from "../../../../validators"
 import { nullable, refineType } from "../../../../validators/function"
-import {
-	EmbedContent,
-	EmbedContentLegacy,
-	EmbedContentType,
-	EmbedLegacy,
-} from "../EmbedContent"
+import type { EmbedLegacy } from "../EmbedContent";
+import { EmbedContent, EmbedContentLegacy, EmbedContentType } from "../EmbedContent"
 import { ImageContentView } from "../ImageContent"
 import { FilledLink, FilledLinkLegacy } from "../LinkContent"
 
@@ -47,16 +40,10 @@ const basicSpan = t.strict({
 export const Span = t.union([linkSpan(FilledLink), labelSpan, basicSpan])
 export type Span = t.TypeOf<typeof Span>
 
-export const SpanLegacy = t.union([
-	linkSpan(FilledLinkLegacy),
-	labelSpan,
-	basicSpan,
-])
+export const SpanLegacy = t.union([linkSpan(FilledLinkLegacy), labelSpan, basicSpan])
 export type SpanLegacy = t.TypeOf<typeof SpanLegacy>
 
-export const ValidatedSpans = <C extends typeof Span | typeof SpanLegacy>(
-	spanCodec: C,
-) => {
+export const ValidatedSpans = <C extends typeof Span | typeof SpanLegacy>(spanCodec: C) => {
 	type S = t.TypeOf<C>
 
 	return new t.Type<S[], S[], unknown>(
@@ -180,9 +167,7 @@ export function checkEmbedBlock(block: Block): block is EmbedBlock {
 	return block.type === RichTextNodeType.embed
 }
 
-const TextBlockCodec = <C extends typeof Span | typeof SpanLegacy>(
-	spanCodec: C,
-) =>
+const TextBlockCodec = <C extends typeof Span | typeof SpanLegacy>(spanCodec: C) =>
 	t.exact(
 		t.intersection([
 			t.type({
@@ -214,17 +199,12 @@ export type TextBlock = t.TypeOf<typeof TextBlock>
 export const TextBlockLegacy = TextBlockCodec(SpanLegacy)
 export type TextBlockLegacy = t.TypeOf<typeof TextBlockLegacy>
 
-const legacyBlockCodec = t.union([
-	EmbedBlockLegacy,
-	ImageBlockLegacy,
-	TextBlockLegacy,
-])
+const legacyBlockCodec = t.union([EmbedBlockLegacy, ImageBlockLegacy, TextBlockLegacy])
 type BlockLegacy = t.TypeOf<typeof legacyBlockCodec>
 
 export const BlockLegacy = new t.Type<Block, BlockLegacy, unknown>(
 	"BlockLegacy",
-	(u): u is Block =>
-		EmbedBlockLegacy.is(u) || ImageBlockLegacy.is(u) || TextBlockLegacy.is(u),
+	(u): u is Block => EmbedBlockLegacy.is(u) || ImageBlockLegacy.is(u) || TextBlockLegacy.is(u),
 	(legacyBlock) => legacyBlockCodec.decode(legacyBlock),
 	(block: Block) => {
 		return (() => {

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

@@ -13,9 +13,7 @@ export const SeparatorLegacy = (ctx: LegacyContentCtx) =>
 		"SeparatorLegacy",
 		isSeparatorContent,
 		() => {
-			return t.success(
-				SeparatorContent.encode({ __TYPE__: SeparatorContentType }),
-			)
+			return t.success(SeparatorContent.encode({ __TYPE__: SeparatorContentType }))
 		},
 
 		() => {

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

@@ -2,16 +2,13 @@ import { either } from "fp-ts"
 import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
-import {
-	type NestableWidget,
-	TableCell as TableCellModel,
-} from "../../../customtypes"
+import { type NestableWidget, TableCell as TableCellModel } from "../../../customtypes"
+import { hasContentType, withKey } from "../../helpers"
 import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx"
-import {
+import type {
 	ContentPath,
-	hasContentType,
 	TraverseWidgetContentFn,
-	withKey,
+	TraverseWidgetContentWithModelFn,
 } from "../../utils"
 import { RichTextContent, RichTextLegacyContent } from "./RichTextContent"
 
@@ -173,3 +170,62 @@ export function traverseTableContent({
 		})
 	}
 }
+
+export function traverseTableContentWithModel({
+	path,
+	key,
+	model,
+	content,
+}: {
+	path: ContentPath
+	key: string
+	model: NestableWidget
+	content: TableContent | undefined
+}): (transform: TraverseWidgetContentWithModelFn) => TableContent | undefined {
+	return (transform) => {
+		const tableContent =
+			content?.content.map((row, rowIndex) => ({
+				...row,
+				content: row.content.map((cell, cellIndex) => {
+					const itemPath = path.concat([
+						{
+							key: [rowIndex.toString(), cellIndex.toString()].join(","),
+							type: "Widget",
+						},
+					])
+
+					const cellContent = transform({
+						path: itemPath,
+						key,
+						apiId: key,
+						model: TableCellModel,
+						content: {
+							__TYPE__: cell.content.__TYPE__,
+							value: cell.content.value,
+						},
+					}) || {
+						__TYPE__: "StructuredTextContent",
+						value: [],
+					}
+
+					return {
+						...cell,
+						content: cellContent,
+					}
+				}),
+			})) ?? []
+
+		return transform({
+			path,
+			key,
+			apiId: key,
+			model,
+			content: content
+				? {
+						__TYPE__: content.__TYPE__,
+						content: tableContent,
+					}
+				: undefined,
+		})
+	}
+}

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

@@ -4,38 +4,28 @@ import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
 import type { CompositeSlice, VariationFields } from "../../../../customtypes"
-import {
-	getFieldCtx,
-	LegacyContentCtx,
-	WithTypes,
-} from "../../../LegacyContentCtx"
-import {
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
+import { getFieldCtx } from "../../../LegacyContentCtx"
+import type {
 	ContentPath,
-	hasContentType,
 	TraverseSliceContentFn,
-	TraverseWidgetContentFn,
-} from "../../../utils"
-import { GroupItemContent, traverseGroupItemsContent } from "../../GroupContent"
+	TraverseWidgetContentFn} from "../../../utils";
 import {
-	isNestableContent,
-	NestableContent,
-	NestableLegacy,
-} from "../../nestable"
+	hasContentType
+} from "../../../utils"
+import type { GroupItemContent} from "../../GroupContent";
+import { 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(
@@ -47,11 +37,7 @@ 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) => {
@@ -61,16 +47,14 @@ 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,
@@ -94,9 +78,7 @@ 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,
@@ -158,11 +140,10 @@ export function compositeSliceContentWithDefaultValues(
 		customType["non-repeat"] ?? {},
 		content.nonRepeat,
 	)
-	const updatedRepeatContent =
-		repeatableContentWithDefaultNestableContentValues(
-			customType.repeat ?? {},
-			content.repeat,
-		)
+	const updatedRepeatContent = repeatableContentWithDefaultNestableContentValues(
+		customType.repeat ?? {},
+		content.repeat,
+	)
 
 	return {
 		...content,
@@ -223,8 +204,7 @@ 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)
 
@@ -257,19 +237,16 @@ 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,25 +1,23 @@
 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,