@prismicio/types-internal 2.2.1 → 2.3.0

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

@@ -21,6 +21,10 @@ import {
 	NestableContent,
 	NestableLegacy,
 } from "../../nestable"
+import {
+	repeatableContentWithDefaultNestableContentValues,
+	withDefaultNestableContentValues,
+} from "../../withDefaultValues"
 import type {
 	CompositeSliceItemContent,
 	SharedSliceItemContent,
@@ -133,6 +137,27 @@ export const CompositeSliceContent = t.strict({
 
 export type CompositeSliceContent = t.TypeOf<typeof CompositeSliceContent>
 
+export function compositeSliceContentWithDefaultValues(
+	customType: CompositeSlice,
+	content: CompositeSliceContent,
+): CompositeSliceContent {
+	const updatedNonRepeatContent = withDefaultNestableContentValues(
+		customType["non-repeat"] ?? {},
+		content.nonRepeat,
+	)
+	const updatedRepeatContent =
+		repeatableContentWithDefaultNestableContentValues(
+			customType.repeat ?? {},
+			content.repeat,
+		)
+
+	return {
+		...content,
+		nonRepeat: updatedNonRepeatContent,
+		repeat: updatedRepeatContent,
+	}
+}
+
 export function traverseCompositeSliceContent({
 	path,
 	sliceKey,

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

@@ -9,7 +9,7 @@ import type {
 	TraverseSliceContentFn,
 	TraverseWidgetContentFn,
 } from "../../../../_internal/utils"
-import type { VariationFields } from "../../../../customtypes"
+import type { SharedSlice, VariationFields } from "../../../../customtypes"
 import {
 	getFieldCtx,
 	LegacyContentCtx,
@@ -22,6 +22,10 @@ import {
 	NestableContent,
 	NestableLegacy,
 } from "../../nestable"
+import {
+	repeatableContentWithDefaultNestableContentValues,
+	withDefaultNestableContentValues,
+} from "../../withDefaultValues"
 import type { SharedSliceItemContent } from "../SliceItem"
 import { RepeatableWidgets, RepeatableWidgetsLegacy } from "./RepeatableContent"
 
@@ -141,6 +145,33 @@ export const SharedSliceContent = t.strict({
 })
 export type SharedSliceContent = t.TypeOf<typeof SharedSliceContent>
 
+export function sharedSliceContentWithDefaultValues(
+	customType: SharedSlice,
+	content: SharedSliceContent,
+): SharedSliceContent {
+	const variationConfig = customType.variations.find(
+		(v) => v.id === content.variation,
+	)
+
+	const primaryConfig = variationConfig?.primary ?? {}
+	const itemsConfig = variationConfig?.items ?? {}
+
+	const updatedPrimaryContent = withDefaultNestableContentValues(
+		primaryConfig,
+		content.primary,
+	)
+	const updatedItemsContent = repeatableContentWithDefaultNestableContentValues(
+		itemsConfig,
+		content.items,
+	)
+
+	return {
+		...content,
+		primary: updatedPrimaryContent,
+		items: updatedItemsContent,
+	}
+}
+
 export function traverseSharedSliceContent({
 	path,
 	sliceKey,

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

@@ -4,6 +4,7 @@ import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
 import type { TraverseSliceContentFn } from "../../../_internal/utils"
+import type { StaticSlice } from "../../../customtypes"
 import { nullable } from "../../../validators/function"
 import {
 	getFieldCtx,
@@ -12,7 +13,13 @@ import {
 } from "../../LegacyContentCtx"
 import { isGroupContent } from "../GroupContent"
 import { isNestableContent } from "../nestable"
-import { SliceContent, SliceLegacy } from "./Slice"
+import { repeatableContentWithDefaultNestableContentValues } from "../withDefaultValues"
+import {
+	compositeSliceContentWithDefaultValues,
+	sharedSliceContentWithDefaultValues,
+	SliceContent,
+	SliceLegacy,
+} from "./Slice"
 import {
 	CompositeSliceContent,
 	isCompositeSliceContent,
@@ -61,6 +68,41 @@ export function isSimpleSliceItemContent(
 	return isGroupContent(item.widget) || isNestableContent(item.widget)
 }
 
+export function sliceItemContentWithDefaultValues(
+	customType: StaticSlice,
+	content: SliceContent,
+): SliceContent {
+	if (customType.type === "SharedSlice" && isSharedSliceContent(content)) {
+		return sharedSliceContentWithDefaultValues(customType, content)
+	}
+
+	if (customType.type === "Slice" && isCompositeSliceContent(content)) {
+		return compositeSliceContentWithDefaultValues(customType, content)
+	}
+
+	if (
+		customType.type === "Group" &&
+		isGroupContent(content) &&
+		customType.config?.fields
+	) {
+		const updateGroupFieldValue =
+			repeatableContentWithDefaultNestableContentValues(
+				customType.config.fields,
+				content.value,
+			)
+
+		return {
+			...content,
+			value: updateGroupFieldValue,
+		}
+	}
+
+	// Note - SimpleSliceContent can also be a NestableContent, but in that case we have no default value to fill, because the content is already there.
+	// There is no key specified in custom type that does not have a value provided like in other cases.
+
+	return content
+}
+
 const itemLegacyReader = t.exact(
 	t.intersection([
 		t.type({

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

@@ -33,6 +33,7 @@ import {
 	isSharedSliceItemContent,
 	isSimpleSliceItemContent,
 	SliceItemContent,
+	sliceItemContentWithDefaultValues,
 	SlicesItemLegacy,
 } from "./SliceItem"
 
@@ -81,6 +82,35 @@ export const SlicesContent = t.type({
 
 export type SlicesContent = t.TypeOf<typeof SlicesContent>
 
+export function slicesContentWithDefaultValues(
+	codec: StaticSlices,
+	content: SlicesContent,
+): SlicesContent {
+	const choices = codec?.config?.choices
+
+	if (choices === undefined) return content
+
+	const updateSlicesValue = content.value.map((slice) => {
+		const sliceConfig = choices[slice.name]
+		if (sliceConfig) {
+			const updatedSliceWidget = sliceItemContentWithDefaultValues(
+				sliceConfig,
+				slice.widget,
+			)
+			return {
+				...slice,
+				widget: updatedSliceWidget,
+			}
+		}
+		return slice
+	})
+
+	return {
+		...content,
+		value: updateSlicesValue,
+	}
+}
+
 function findSliceModel(
 	slicesPath: ContentPath,
 	model: StaticSlices,

package/src/content/fields/withDefaultValues.ts

@@ -0,0 +1,48 @@
+import type { NestableWidget } from "../../customtypes"
+import type { NestableContent } from "./nestable"
+import { NestableContentDefaultValue } from "./nestable"
+
+export function withDefaultNestableContentValues(
+	customType: Record<string, NestableWidget>,
+	content: Record<string, NestableContent>,
+): Record<string, NestableContent> {
+	return Object.entries(customType).reduce<Record<string, NestableContent>>(
+		(updatedContent, [widgetKey, widgetDef]) => {
+			if (content[widgetKey] === undefined) {
+				const defaultValue = NestableContentDefaultValue(widgetDef)
+				return defaultValue !== undefined
+					? {
+							...updatedContent,
+							[widgetKey]: defaultValue,
+					  }
+					: updatedContent
+			}
+
+			return updatedContent
+		},
+		content,
+	)
+}
+
+export function repeatableContentWithDefaultNestableContentValues<
+	T extends {
+		value: [string, NestableContent][]
+	},
+>(fields: Record<string, NestableWidget>, content: T[]): T[] {
+	const groupKeys = Object.entries(fields)
+	return content.map((contentItem) => {
+		return groupKeys.reduce((updatedContentItem, [key, fieldDef]) => {
+			if (!contentItem.value.find(([_key]) => _key === key)) {
+				const defaultValue = NestableContentDefaultValue(fieldDef)
+				return {
+					...updatedContentItem,
+					value: [
+						...updatedContentItem.value,
+						...(defaultValue ? [[key, defaultValue]] : []),
+					],
+				}
+			}
+			return updatedContentItem
+		}, contentItem)
+	})
+}