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

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

@@ -2,31 +2,49 @@ import { either } from "fp-ts"
 import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
-import {
-	type StaticSlices,
+import type {
 	CompositeSlice,
 	Group,
-	isCompositeSlice,
-	isLegacySlice,
-	isStaticSharedSlice,
 	NestableWidget,
 	SharedSlice,
-	VariationFields,
+	Variation,
+	VariationFields} from "../../../customtypes";
+import {
+	type StaticSlices,
+	isCompositeSlice,
+	isLegacySlice,
+	isStaticSharedSlice
 } from "../../../customtypes"
+import type { FieldOrSliceType, LegacyContentCtx, WithTypes } from "../../LegacyContentCtx"
 import type {
-	FieldOrSliceType,
-	LegacyContentCtx,
-	WithTypes,
-} from "../../LegacyContentCtx"
-import {
-	ContentPath,
 	TraverseSliceContentFn,
+	TraverseSliceContentWithModelFn,
 	TraverseWidgetContentFn,
+	TraverseWidgetContentWithModelFn} from "../../utils";
+import {
+	ContentPath
 } from "../../utils"
 import { hasContentType } from "../../utils"
+import {
+	isGroupContent,
+	traverseGroupContentWithModel,
+	traverseGroupItemsContentWithModel,
+} from "../GroupContent"
+import {
+	isNestableContent,
+	isRepeatableContent,
+	isTableContent,
+	traverseRepeatableContentWithModel,
+	traverseTableContentWithModel,
+} from "../nestable"
+import type { CompositeSliceContent} from "./Slice/CompositeSliceContent";
 import { traverseCompositeSliceContent } from "./Slice/CompositeSliceContent"
+import type { SharedSliceContent} from "./Slice/SharedSliceContent";
 import { traverseSharedSliceContent } from "./Slice/SharedSliceContent"
+import type { SimpleSliceContent} from "./Slice/SimpleSliceContent";
 import { traverseSimpleSliceContent } from "./Slice/SimpleSliceContent"
+import type {
+	SharedSliceItemContent} from "./SliceItem";
 import {
 	isCompositeSliceItemContent,
 	isSharedSliceItemContent,
@@ -43,7 +61,7 @@ export const isSlicesContent = (u: unknown): u is SlicesContent =>
 
 type SlicesLegacy = Array<unknown>
 
-type SliceModel = VariationFields | NestableWidget | CompositeSlice | Group
+export type SliceModel = VariationFields | NestableWidget | CompositeSlice | Group
 
 export const SlicesLegacy = (ctx: LegacyContentCtx) => {
 	const codec = t.array(SlicesItemLegacy(ctx))
@@ -70,10 +88,7 @@ export const SlicesLegacy = (ctx: LegacyContentCtx) => {
 					(acc, s) => ({ ...acc, ...s.types }),
 					{ [ctx.keyOfType]: "Slices" },
 				),
-				keys: result.reduce<Record<string, string>>(
-					(acc, s) => ({ ...acc, ...s.keys }),
-					{},
-				),
+				keys: result.reduce<Record<string, string>>((acc, s) => ({ ...acc, ...s.keys }), {}),
 			}
 		},
 	)
@@ -97,10 +112,7 @@ export function slicesContentWithDefaultValues(
 	const updateSlicesValue = content.value.map((slice) => {
 		const sliceConfig = choices[slice.name]
 		if (sliceConfig) {
-			const updatedSliceWidget = sliceItemContentWithDefaultValues(
-				sliceConfig,
-				slice.widget,
-			)
+			const updatedSliceWidget = sliceItemContentWithDefaultValues(sliceConfig, slice.widget)
 			return {
 				...slice,
 				widget: updatedSliceWidget,
@@ -126,9 +138,7 @@ function findSliceModel(
 	const sharedSliceModel = (): VariationFields | undefined => {
 		if (isSharedSliceItemContent(content)) {
 			if (defaultModel && isStaticSharedSlice(defaultModel)) {
-				const variationDef = defaultModel.variations.find(
-					(v) => v.id === content.widget.variation,
-				)
+				const variationDef = defaultModel.variations.find((v) => v.id === content.widget.variation)
 				return variationDef
 					? {
 							type: "SharedSlice",
@@ -138,7 +148,7 @@ function findSliceModel(
 								primary: variationDef.primary || {},
 								items: variationDef.items || {},
 							},
-					  }
+						}
 					: undefined
 			}
 		}
@@ -146,10 +156,7 @@ function findSliceModel(
 	}
 
 	const migratedSliceModel = (): VariationFields | undefined => {
-		const legacyContentPath = ContentPath.append(
-			ContentPath.serialize(slicesPath),
-			content.name,
-		)
+		const legacyContentPath = ContentPath.append(ContentPath.serialize(slicesPath), content.name)
 
 		const migratedSliceModel = Object.values(model?.config?.choices || {}).find(
 			(sliceModel): sliceModel is SharedSlice => {
@@ -178,11 +185,7 @@ function findSliceModel(
 		}
 	}
 
-	const legacySliceModel = ():
-		| NestableWidget
-		| CompositeSlice
-		| Group
-		| undefined => {
+	const legacySliceModel = (): NestableWidget | CompositeSlice | Group | undefined => {
 		if (!defaultModel) return
 
 		if (isCompositeSlice(defaultModel)) {
@@ -219,72 +222,392 @@ export function traverseSlices({
 		transformWidget?: TraverseWidgetContentFn
 		transformSlice?: TraverseSliceContentFn
 	}): SlicesContent | undefined => {
-		const value = content.value.reduce<SlicesContent["value"]>(
-			(acc, sliceContent) => {
-				const sliceModel = model && findSliceModel(path, model, sliceContent)
-
-				const convertedSlice: SliceItemContent | undefined = (() => {
-					if (isSharedSliceItemContent(sliceContent))
-						return traverseSharedSliceContent({
-							path: path.concat({
-								key: sliceContent.key,
-								type: "SharedSlice",
-							}),
+		const value = content.value.reduce<SlicesContent["value"]>((acc, sliceContent) => {
+			const sliceModel = model && findSliceModel(path, model, sliceContent)
+
+			const convertedSlice: SliceItemContent | undefined = (() => {
+				if (isSharedSliceItemContent(sliceContent))
+					return traverseSharedSliceContent({
+						path: path.concat({
+							key: sliceContent.key,
+							type: "SharedSlice",
+						}),
+						sliceKey: sliceContent.key,
+						sliceName: sliceContent.name,
+						model: sliceModel?.type === "SharedSlice" ? sliceModel : undefined,
+						content: sliceContent,
+					})(transformWidget, transformSlice)
+
+				if (isCompositeSliceItemContent(sliceContent))
+					return traverseCompositeSliceContent({
+						path: path.concat({
+							key: sliceContent.key,
+							type: "Slice",
+						}),
+						sliceKey: sliceContent.key,
+						sliceName: sliceContent.name,
+						model:
+							sliceModel?.type === "Slice" || sliceModel?.type === "SharedSlice"
+								? sliceModel
+								: undefined,
+						content: sliceContent,
+					})(transformWidget, transformSlice)
+
+				if (isSimpleSliceItemContent(sliceContent))
+					return traverseSimpleSliceContent({
+						path: path.concat({
+							key: sliceContent.key,
+							type: "LegacySlice",
+						}),
+						sliceKey: sliceContent.key,
+						sliceName: sliceContent.name,
+						model: sliceModel && sliceModel?.type !== "Slice" ? sliceModel : undefined,
+						content: sliceContent,
+					})(transformWidget, transformSlice)
+
+				return
+			})()
+
+			return convertedSlice ? acc.concat(convertedSlice) : acc
+		}, [])
+
+		return transformWidget({
+			path,
+			key,
+			apiId: key,
+			model,
+			content: {
+				__TYPE__: content.__TYPE__,
+				value,
+			},
+		})
+	}
+}
+
+function buildVariationFields(sharedSlice: SharedSlice, variation: Variation): VariationFields {
+	return {
+		type: "SharedSlice",
+		sliceName: sharedSlice.id,
+		variationId: variation.id,
+		fields: {
+			primary: variation.primary ?? {},
+			items: variation.items ?? {},
+		},
+	}
+}
+
+export 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: sliceContent.name,
-							model:
-								sliceModel?.type === "SharedSlice" ? sliceModel : undefined,
+							sliceName,
+							model: variationFields,
 							content: sliceContent,
 						})(transformWidget, transformSlice)
-
-					if (isCompositeSliceItemContent(sliceContent))
-						return traverseCompositeSliceContent({
-							path: path.concat({
-								key: sliceContent.key,
-								type: "Slice",
-							}),
+					}
+				} else if (isCompositeSliceItemContent(sliceContent)) {
+					const defaultVariation = sliceModel.variations[0]
+					if (defaultVariation) {
+						const variationFields = buildVariationFields(sliceModel, defaultVariation)
+						convertedSlice = traverseCompositeSliceContentWithModel({
+							path: slicePath,
 							sliceKey: sliceContent.key,
-							sliceName: sliceContent.name,
-							model:
-								sliceModel?.type === "Slice" ||
-								sliceModel?.type === "SharedSlice"
-									? sliceModel
-									: undefined,
+							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 (isSimpleSliceItemContent(sliceContent))
-						return traverseSimpleSliceContent({
-							path: path.concat({
+						if (groupModel) {
+							convertedWidget = traverseGroupContentWithModel({
+								path: slicePath,
 								key: sliceContent.key,
-								type: "LegacySlice",
-							}),
-							sliceKey: sliceContent.key,
-							sliceName: sliceContent.name,
-							model:
-								sliceModel && sliceModel?.type !== "Slice"
-									? sliceModel
-									: undefined,
-							content: sliceContent,
-						})(transformWidget, transformSlice)
+								model: groupModel,
+								content: sliceContent.widget,
+							})(transformWidget)
+						}
+					} else if (isNestableContent(sliceContent.widget)) {
+						const nestableModel = sliceModel?.type !== "Group" ? sliceModel : undefined
 
-					return
-				})()
+						if (nestableModel) {
+							convertedWidget = transformWidget({
+								key: sliceContent.key,
+								apiId: sliceName,
+								path: slicePath,
+								model: nestableModel,
+								content: sliceContent.widget,
+							})
+						}
+					}
 
-				return convertedSlice ? acc.concat(convertedSlice) : acc
-			},
-			[],
-		)
+					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: {
-				__TYPE__: content.__TYPE__,
-				value,
-			},
+			content: content
+				? {
+						__TYPE__: content.__TYPE__,
+						value,
+					}
+				: undefined,
 		})
 	}
 }

package/src/content/fields/withDefaultValues.ts

@@ -1,11 +1,13 @@
+import type {
+	Group} from "../../customtypes";
 import {
 	type NestableWidget,
 	type SlicePrimaryWidget,
-	Group,
 	GroupFieldType,
 } from "../../customtypes"
+import type {
+	GroupContent} from "./GroupContent";
 import {
-	GroupContent,
 	GroupContentDefaultValue,
 	GroupContentType,
 	groupContentWithDefaultValues,
@@ -42,10 +44,7 @@ export function withDefaultSlicePrimaryContentValues(
 		}
 
 		if (widgetDef.type === GroupFieldType && isGroupContent(widgetContent)) {
-			updatedContent[widgetKey] = groupContentWithDefaultValues(
-				widgetDef,
-				widgetContent,
-			)
+			updatedContent[widgetKey] = groupContentWithDefaultValues(widgetDef, widgetContent)
 		}
 	}
 
@@ -64,7 +63,7 @@ export function withDefaultNestableContentValues(
 					? {
 							...updatedContent,
 							[widgetKey]: defaultValue,
-					  }
+						}
 					: updatedContent
 			}
 
@@ -82,9 +81,7 @@ export function repeatableContentWithDefaultNestableContentValues<
 	const groupKeys = Object.entries(fields)
 	return content.map((contentItem) => {
 		return groupKeys.reduce((updatedContentItem, [key, fieldDef]) => {
-			const maybeContentItemValue = contentItem.value.find(
-				([_key]) => _key === key,
-			)
+			const maybeContentItemValue = contentItem.value.find(([_key]) => _key === key)
 
 			if (fieldDef.type === "Group") {
 				const defaultValue = groupContentWithDefaultValues(
@@ -106,10 +103,7 @@ export function repeatableContentWithDefaultNestableContentValues<
 				const defaultValue = NestableContentDefaultValue(fieldDef)
 				return {
 					...updatedContentItem,
-					value: [
-						...updatedContentItem.value,
-						...(defaultValue ? [[key, defaultValue]] : []),
-					],
+					value: [...updatedContentItem.value, ...(defaultValue ? [[key, defaultValue]] : [])],
 				}
 			}
 

package/src/content/helpers.ts

@@ -0,0 +1,27 @@
+import * as t from "io-ts"
+
+type WithContentType = { __TYPE__: string }
+export function hasContentType(obj: unknown): obj is WithContentType {
+	return typeof obj === "object" && obj !== null && "__TYPE__" in obj
+}
+
+const isUuid = (input: unknown): input is string =>
+	typeof input === "string" &&
+	/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i.test(
+		input,
+	)
+
+const uuidWithFallback = new t.Type<string, string, unknown>(
+	"UUID",
+	isUuid,
+	(u, c) => {
+		if (typeof u === "undefined") return t.success(crypto.randomUUID())
+		if (isUuid(u)) return t.success(u)
+		return t.failure(u, c)
+	},
+	t.identity,
+)
+
+export function withKey<C extends t.Mixed>(codec: C) {
+	return t.intersection([t.strict({ key: uuidWithFallback }), codec])
+}