@prismicio/types-internal 3.16.1 → 3.16.2-alpha.1

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

@@ -9,6 +9,7 @@ import {
 	ContentPath,
 	hasContentType,
 	TraverseWidgetContentFn,
+	TraverseWidgetContentWithModelFn,
 } from "../../utils"
 import {
 	isLinkContent,
@@ -162,3 +163,62 @@ export function traverseRepeatableContent({
 		})
 	}
 }
+
+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: key,
+					model: newModel,
+					content: fieldContent,
+				})
+
+				if (!transformedField) return acc
+
+				if (!isLinkContent(transformedField)) return acc
+
+				return acc.concat(transformedField)
+			}, []) ?? []
+
+		return transform({
+			path,
+			key,
+			apiId: key,
+			model,
+			content: content
+				? {
+						__TYPE__: content.__TYPE__,
+						type: content.type,
+						value: items,
+				  }
+				: undefined,
+		})
+	}
+}

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

@@ -11,6 +11,7 @@ import {
 	ContentPath,
 	hasContentType,
 	TraverseWidgetContentFn,
+	TraverseWidgetContentWithModelFn,
 	withKey,
 } from "../../utils"
 import { RichTextContent, RichTextLegacyContent } from "./RichTextContent"
@@ -173,3 +174,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/SlicesContent.ts

@@ -11,6 +11,7 @@ import {
 	isStaticSharedSlice,
 	NestableWidget,
 	SharedSlice,
+	Variation,
 	VariationFields,
 } from "../../../customtypes"
 import type {
@@ -21,16 +22,40 @@ import type {
 import {
 	ContentPath,
 	TraverseSliceContentFn,
+	TraverseSliceContentWithModelFn,
 	TraverseWidgetContentFn,
+	TraverseWidgetContentWithModelFn,
 } from "../../utils"
 import { hasContentType } from "../../utils"
-import { traverseCompositeSliceContent } from "./Slice/CompositeSliceContent"
-import { traverseSharedSliceContent } from "./Slice/SharedSliceContent"
-import { traverseSimpleSliceContent } from "./Slice/SimpleSliceContent"
+import {
+	isGroupContent,
+	traverseGroupContentWithModel,
+	traverseGroupItemsContentWithModel,
+} from "../GroupContent"
+import {
+	isNestableContent,
+	isRepeatableContent,
+	isTableContent,
+	traverseRepeatableContentWithModel,
+	traverseTableContentWithModel,
+} from "../nestable"
+import {
+	CompositeSliceContent,
+	traverseCompositeSliceContent,
+} from "./Slice/CompositeSliceContent"
+import {
+	SharedSliceContent,
+	traverseSharedSliceContent,
+} from "./Slice/SharedSliceContent"
+import {
+	SimpleSliceContent,
+	traverseSimpleSliceContent,
+} from "./Slice/SimpleSliceContent"
 import {
 	isCompositeSliceItemContent,
 	isSharedSliceItemContent,
 	isSimpleSliceItemContent,
+	SharedSliceItemContent,
 	SliceItemContent,
 	sliceItemContentWithDefaultValues,
 	SlicesItemLegacy,
@@ -288,3 +313,361 @@ export function traverseSlices({
 		})
 	}
 }
+
+function buildVariationFields(
+	sharedSlice: SharedSlice,
+	variation: Variation,
+): VariationFields {
+	return {
+		type: "SharedSlice",
+		sliceName: sharedSlice.id,
+		variationId: variation.id,
+		fields: {
+			primary: variation.primary ?? {},
+			items: variation.items ?? {},
+		},
+	}
+}
+
+function traverseSharedSliceContentWithModel({
+	path,
+	sliceKey,
+	sliceName,
+	model,
+	content,
+}: {
+	path: ContentPath
+	sliceKey: string
+	sliceName: string
+	model: VariationFields
+	content: SharedSliceItemContent | undefined
+}): (
+	transformWidget: TraverseWidgetContentWithModelFn,
+	transformSlice: TraverseSliceContentWithModelFn,
+) => SharedSliceItemContent | undefined {
+	return (transformWidget, transformSlice) => {
+		if (!content) {
+			return undefined
+		}
+
+		const primary = Object.entries(model.fields.primary ?? {}).reduce<
+			SharedSliceContent["primary"]
+		>((acc, [fieldKey, fieldModel]) => {
+			const fieldContent = content.widget.primary[fieldKey]
+
+			const fieldPath = path.concat([
+				{ key: "primary", type: "primary" },
+				{ key: fieldKey, type: "Widget" },
+			])
+
+			let transformedField
+			if (fieldModel.type === "Group") {
+				const groupContent = isGroupContent(fieldContent)
+					? fieldContent
+					: undefined
+				transformedField = traverseGroupContentWithModel({
+					path: fieldPath,
+					key: fieldKey,
+					model: fieldModel,
+					content: groupContent,
+				})(transformWidget)
+			} else if (
+				fieldModel.type === "Link" &&
+				fieldModel.config?.repeat === true
+			) {
+				const repeatableContent = isRepeatableContent(fieldContent)
+					? fieldContent
+					: undefined
+				transformedField = traverseRepeatableContentWithModel({
+					path: fieldPath,
+					key: fieldKey,
+					model: fieldModel,
+					content: repeatableContent,
+				})(transformWidget)
+			} else if (fieldModel.type === "Table") {
+				const tableContent = isTableContent(fieldContent)
+					? fieldContent
+					: undefined
+				transformedField = traverseTableContentWithModel({
+					path: fieldPath,
+					key: fieldKey,
+					model: fieldModel,
+					content: tableContent,
+				})(transformWidget)
+			} else {
+				const nestableContent = isNestableContent(fieldContent)
+					? fieldContent
+					: undefined
+				transformedField = transformWidget({
+					path: fieldPath,
+					key: fieldKey,
+					apiId: fieldKey,
+					model: fieldModel,
+					content: nestableContent,
+				})
+			}
+
+			if (!transformedField) return acc
+
+			return {
+				...acc,
+				[fieldKey]: transformedField,
+			}
+		}, {})
+
+		const items = traverseGroupItemsContentWithModel({
+			path: path.concat([{ key: "items", type: "items" }]),
+			model: model.fields.items ?? {},
+			content: content.widget.items,
+		})(transformWidget)
+
+		return transformSlice({
+			key: sliceKey,
+			apiId: sliceName,
+			path,
+			model,
+			content: {
+				...content,
+				widget: {
+					__TYPE__: "SharedSliceContent",
+					variation: content.widget.variation,
+					primary,
+					items,
+				},
+			},
+		})
+	}
+}
+
+function traverseCompositeSliceContentWithModel({
+	path,
+	sliceKey,
+	sliceName,
+	model,
+	content,
+}: {
+	path: ContentPath
+	sliceKey: string
+	sliceName: string
+	model: CompositeSlice | VariationFields
+	content: SliceItemContent | undefined
+}): (
+	transformWidget: TraverseWidgetContentWithModelFn,
+	transformSlice: TraverseSliceContentWithModelFn,
+) => SliceItemContent | undefined {
+	return (transformWidget, transformSlice) => {
+		if (!content || !isCompositeSliceItemContent(content)) {
+			return undefined
+		}
+
+		const nonRepeatModel =
+			model.type === "SharedSlice"
+				? model.fields.primary ?? {}
+				: model["non-repeat"] ?? {}
+		const repeatModel =
+			model.type === "SharedSlice"
+				? model.fields.items ?? {}
+				: model.repeat ?? {}
+
+		const nonRepeat = Object.entries(nonRepeatModel).reduce<
+			CompositeSliceContent["nonRepeat"]
+		>((acc, [fieldKey, fieldModel]) => {
+			const fieldContent = content.widget.nonRepeat[fieldKey]
+			const fieldPath = path.concat([
+				{ key: "non-repeat", type: "primary" },
+				{ key: fieldKey, type: "Widget" },
+			])
+
+			const nestableContent = isNestableContent(fieldContent)
+				? fieldContent
+				: undefined
+
+			const transformedField = transformWidget({
+				path: fieldPath,
+				key: fieldKey,
+				apiId: sliceName,
+				model: fieldModel,
+				content: nestableContent,
+			})
+
+			if (!transformedField || !isNestableContent(transformedField)) return acc
+
+			return {
+				...acc,
+				[fieldKey]: transformedField,
+			}
+		}, {})
+
+		const repeat = traverseGroupItemsContentWithModel({
+			path: path.concat([{ key: "repeat", type: "items" }]),
+			model: repeatModel,
+			content: content.widget.repeat,
+		})(transformWidget)
+
+		return transformSlice({
+			key: sliceKey,
+			apiId: sliceName,
+			path,
+			model: model.type === "SharedSlice" ? model : model,
+			content: {
+				...content,
+				widget: {
+					__TYPE__: content.widget.__TYPE__,
+					nonRepeat,
+					repeat,
+				},
+			},
+		})
+	}
+}
+
+export function traverseSlicesWithModel({
+	path,
+	key,
+	model,
+	content,
+}: {
+	path: ContentPath
+	key: string
+	model: StaticSlices
+	content: SlicesContent | undefined
+}): (args: {
+	transformWidget: TraverseWidgetContentWithModelFn
+	transformSlice: TraverseSliceContentWithModelFn
+}) => SlicesContent | undefined {
+	return ({ transformWidget, transformSlice }) => {
+		const choices = model.config?.choices ?? {}
+
+		const value = (content?.value ?? []).reduce<SlicesContent["value"]>(
+			(acc, sliceContent) => {
+				const sliceName = sliceContent.name
+				const sliceModel = choices[sliceName]
+
+				if (!sliceModel) {
+					return acc
+				}
+
+				const slicePath = path.concat({
+					key: sliceContent.key,
+					type: isStaticSharedSlice(sliceModel)
+						? "SharedSlice"
+						: isCompositeSlice(sliceModel)
+						? "Slice"
+						: "LegacySlice",
+				})
+
+				let convertedSlice: SliceItemContent | undefined
+
+				if (isStaticSharedSlice(sliceModel)) {
+					if (isSharedSliceItemContent(sliceContent)) {
+						const variation = sliceModel.variations.find(
+							(v) => v.id === sliceContent.widget.variation,
+						)
+						if (variation) {
+							const variationFields = buildVariationFields(
+								sliceModel,
+								variation,
+							)
+							convertedSlice = traverseSharedSliceContentWithModel({
+								path: slicePath,
+								sliceKey: sliceContent.key,
+								sliceName,
+								model: variationFields,
+								content: sliceContent,
+							})(transformWidget, transformSlice)
+						}
+					} else if (isCompositeSliceItemContent(sliceContent)) {
+						const defaultVariation = sliceModel.variations[0]
+						if (defaultVariation) {
+							const variationFields = buildVariationFields(
+								sliceModel,
+								defaultVariation,
+							)
+							convertedSlice = traverseCompositeSliceContentWithModel({
+								path: slicePath,
+								sliceKey: sliceContent.key,
+								sliceName,
+								model: variationFields,
+								content: sliceContent,
+							})(transformWidget, transformSlice)
+						}
+					}
+				} else if (isCompositeSlice(sliceModel)) {
+					if (isCompositeSliceItemContent(sliceContent)) {
+						convertedSlice = traverseCompositeSliceContentWithModel({
+							path: slicePath,
+							sliceKey: sliceContent.key,
+							sliceName,
+							model: sliceModel,
+							content: sliceContent,
+						})(transformWidget, transformSlice)
+					}
+				} else if (isLegacySlice(sliceModel)) {
+					if (isSimpleSliceItemContent(sliceContent)) {
+						let convertedWidget: SimpleSliceContent | undefined
+
+						if (isGroupContent(sliceContent.widget)) {
+							const groupModel =
+								sliceModel?.type === "Group" ? sliceModel : undefined
+
+							if (groupModel) {
+								convertedWidget = traverseGroupContentWithModel({
+									path: slicePath,
+									key: sliceContent.key,
+									model: groupModel,
+									content: sliceContent.widget,
+								})(transformWidget)
+							}
+						} else if (isNestableContent(sliceContent.widget)) {
+							const nestableModel =
+								sliceModel?.type !== "Group" ? sliceModel : undefined
+
+							if (nestableModel) {
+								convertedWidget = transformWidget({
+									key: sliceContent.key,
+									apiId: sliceName,
+									path: slicePath,
+									model: nestableModel,
+									content: sliceContent.widget,
+								})
+							}
+						}
+
+						convertedSlice =
+							convertedWidget &&
+							transformSlice({
+								key: sliceContent.key,
+								apiId: sliceName,
+								path: slicePath,
+								model: sliceModel,
+								content: {
+									...sliceContent,
+									widget: convertedWidget,
+								},
+							})
+					}
+				}
+
+				if (convertedSlice) {
+					acc.push(convertedSlice)
+				}
+
+				return acc
+			},
+			[],
+		)
+
+		return transformWidget({
+			path,
+			key,
+			apiId: key,
+			model,
+			content: content
+				? {
+						__TYPE__: content.__TYPE__,
+						value,
+				  }
+				: undefined,
+		})
+	}
+}

package/src/content/utils.ts

@@ -90,6 +90,44 @@ export type TraverseWidgetContentFn<
 	| ([ContentTransformMode] extends ["preserve"] ? C : WidgetContent)
 	| undefined
 
+export type TraverseWidgetContentWithModelFn<
+	ContentTransformMode extends "preserve" | "widen" = "preserve",
+> = <
+	C extends WidgetContent | undefined,
+	D extends NestableWidget | StaticSlices | Group | UID,
+>({
+	path,
+	key,
+	apiId,
+	model,
+	content,
+}: {
+	path: ContentPath
+	key: string
+	apiId: string
+	model: D
+	content: C
+}) =>
+	| ([ContentTransformMode] extends ["preserve"] ? C : WidgetContent)
+	| undefined
+
+export type TraverseSliceContentWithModelFn = <
+	S extends SliceItemContent | SharedSliceItemContent | undefined,
+	D extends VariationFields | CompositeSlice | Group | NestableWidget,
+>({
+	path,
+	key,
+	apiId,
+	model,
+	content,
+}: {
+	path: ContentPath
+	key: string
+	apiId: string
+	model: D
+	content: S
+}) => S | SharedSliceItemContent | undefined
+
 export type ContentPathEntry = {
 	type:
 		| "CustomType"