@prismicio/types-internal 2.9.0-alpha.0 → 2.9.0-alpha.2

package/src/content/fields/GroupContent.ts

@@ -20,6 +20,7 @@ import {
 } from "../LegacyContentCtx"
 import { hasContentType } from "../utils"
 import { isNestableContent, NestableContent, NestableLegacy } from "./nestable"
+import { traverseRepeatableContent } from "./RepeatableContent"
 import { repeatableContentWithDefaultNestableContentValues } from "./withDefaultValues"
 
 export const GroupItemContentType = "GroupItemContent" as const
@@ -235,6 +236,18 @@ export function traverseGroupItemsContent({
 							model: fieldDef,
 							content: fieldContent,
 						})(transform)
+					} else if (
+						(!fieldDef ||
+							(fieldDef?.type === "Link" && fieldDef.config?.repeat)) &&
+						fieldContent.__TYPE__ === "RepeatableContent"
+					) {
+						transformedField = traverseRepeatableContent({
+							path: groupItemPath.concat([{ key: fieldKey, type: "Widget" }]),
+							key: fieldKey,
+							apiId: fieldKey,
+							model: fieldDef,
+							content: fieldContent,
+						})(transform)
 					} else {
 						transformedField = transform({
 							path: groupItemPath.concat([{ key: fieldKey, type: "Widget" }]),

package/src/content/fields/RepeatableContent.ts

@@ -7,25 +7,19 @@ import type {
 	ContentPath,
 	TraverseWidgetContentFn,
 } from "../../_internal/utils"
-import {
-	type Link,
-	NestableFieldTypes,
-	NestableWidget,
-} from "../../customtypes"
+import type { Link, NestableWidget } from "../../customtypes"
 import type { LegacyContentCtx, WithTypes } from "../LegacyContentCtx"
-import { LinkContent, LinkContentLegacy, LinkContentType } from "./nestable"
-
-export const RepeatableContentType = "RepeatableContent" as const
-export const RepeatableFieldType = "Repeatable" as const
-
-export const RepeatableItemContent = LinkContent
-export type RepeatableItemContent = t.TypeOf<typeof RepeatableItemContent>
+import {
+	isLinkContent,
+	LinkContent,
+	LinkContentLegacy,
+	LinkContentType,
+} from "./nestable"
 
 export const RepeatableContent = t.strict({
-	__TYPE__: t.literal(RepeatableContentType),
-	type: NestableFieldTypes,
-	// TODO: How to ensure it's an array of only one type
-	value: t.array(RepeatableItemContent),
+	__TYPE__: t.literal("RepeatableContent"),
+	type: t.literal("Link"),
+	value: t.array(LinkContent),
 })
 
 export type RepeatableContent = t.TypeOf<typeof RepeatableContent>
@@ -34,40 +28,34 @@ export const isRepeatableContent = RepeatableContent.is
 
 export const RepeatableLegacy = (
 	ctx: LegacyContentCtx,
-	fieldType: NestableFieldTypes,
+	fieldType: "Link",
 ): t.Type<RepeatableContent, WithTypes<Array<unknown>>, unknown> => {
-	const codecDecode = t.array(t.unknown)
-	const codecEncode = t.array(RepeatableItemContent)
-
 	return new t.Type<RepeatableContent, WithTypes<Array<unknown>>, unknown>(
 		"RepeatableLegacy",
 		isRepeatableContent,
 		(items) => {
 			const parsed = pipe(
-				codecDecode.decode(items),
+				t.array(t.unknown).decode(items),
 				either.map((items) => {
-					const parsedItems = items.reduce<Array<RepeatableItemContent>>(
-						(acc, item) => {
-							let result
+					const parsedItems = items.reduce<Array<LinkContent>>((acc, item) => {
+						let result
 
-							switch (fieldType) {
-								case "Link":
-									result = LinkContentLegacy(ctx).decode(item)
-									break
-							}
+						switch (fieldType) {
+							case "Link":
+								result = LinkContentLegacy(ctx).decode(item)
+								break
+						}
 
-							if (!result) return acc
-							if (isLeft(result)) return acc
+						if (!result) return acc
+						if (isLeft(result)) return acc
 
-							return [...acc, result.right]
-						},
-						[],
-					)
+						return [...acc, result.right]
+					}, [])
 
 					return {
 						value: parsedItems,
 						type: fieldType,
-						__TYPE__: RepeatableContentType,
+						__TYPE__: "RepeatableContent" as const,
 					}
 				}),
 			)
@@ -75,7 +63,7 @@ export const RepeatableLegacy = (
 			return parsed
 		},
 		(r: RepeatableContent) => {
-			const res = codecEncode.encode(r.value)
+			const res = t.array(LinkContent).encode(r.value)
 			const encodedItems = res.reduce<Array<WithTypes<unknown>>>(
 				(acc, item) => {
 					let encoded
@@ -119,7 +107,7 @@ export function traverseRepeatableContent({
 	return (
 		transform: TraverseWidgetContentFn,
 	): RepeatableContent | undefined => {
-		const items = content.value.reduce<Array<RepeatableItemContent>>(
+		const items = content.value.reduce<Array<LinkContent>>(
 			(acc, fieldContent, index) => {
 				const itemPath = path.concat([
 					{ key: index.toString(), type: "Widget" },
@@ -136,6 +124,9 @@ export function traverseRepeatableContent({
 				// 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)
 			},
 			[],

package/src/content/fields/index.ts

@@ -1,6 +1,7 @@
 export * from "./EmptyContent"
 export * from "./GroupContent"
 export * from "./nestable"
+export * from "./RepeatableContent"
 export * from "./slices"
 export * from "./UIDContent"
 export * from "./WidgetContent"

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

@@ -1,13 +1,12 @@
 import { isRight } from "fp-ts/lib/Either"
 import * as t from "io-ts"
 
-import { type NestableWidget, NestableFieldTypes } from "../../../customtypes"
+import type { NestableWidget } from "../../../customtypes"
 import type { LegacyContentCtx } from "../../LegacyContentCtx"
 import { EmptyContent, EmptyLegacy, isEmptyContent } from "../EmptyContent"
 import {
 	isRepeatableContent,
 	RepeatableContent,
-	RepeatableContentType,
 	RepeatableLegacy,
 } from "../RepeatableContent"
 import {
@@ -147,13 +146,8 @@ export const NestableLegacy = (ctx: LegacyContentCtx) => {
 			const nullValue = EmptyLegacy(ctx.fieldType).decode(value)
 			if (isRight(nullValue)) return nullValue
 
-			const fieldTypeSplit = ctx?.fieldType?.split(".")
-			const fieldType = fieldTypeSplit?.[1] ?? ctx.fieldType
-
-			if (!NestableFieldTypes.is(fieldType)) return
-
 			const codec = (() => {
-				switch (fieldType) {
+				switch (ctx.fieldType) {
 					case "Text":
 						return TextLegacy(ctx)
 					case "Color":
@@ -184,6 +178,8 @@ export const NestableLegacy = (ctx: LegacyContentCtx) => {
 						return LinkContentLegacy(ctx)
 					case "Separator":
 						return SeparatorLegacy(ctx)
+					case "Repeatable.Link":
+						return RepeatableLegacy(ctx, "Link")
 					default:
 						return
 				}
@@ -191,21 +187,9 @@ export const NestableLegacy = (ctx: LegacyContentCtx) => {
 
 			if (!codec) return
 
-			// We check if the Nestable Content is repeated. If so, we decode each
-			// item in the array using the specific codec for the repeated content.
-			if (fieldTypeSplit?.[0] === "Repeatable") {
-				return RepeatableLegacy(ctx, fieldType).decode(value)
-			}
-
 			return codec.decode(value)
 		},
 		encode(value: NestableContent) {
-			// We check if the Nestable Content is repeated. If so, we decode each
-			// item in the array using the specific codec for the repeated content.
-			if (value.__TYPE__ === RepeatableContentType) {
-				return RepeatableLegacy(ctx, value.type).encode(value)
-			}
-
 			switch (value.__TYPE__) {
 				case FieldContentType: {
 					if (value.type === "Text") return TextLegacy(ctx).encode(value)
@@ -234,6 +218,8 @@ export const NestableLegacy = (ctx: LegacyContentCtx) => {
 					return LinkContentLegacy(ctx).encode(value)
 				case SeparatorContentType:
 					return SeparatorLegacy(ctx).encode(value)
+				case "RepeatableContent":
+					return RepeatableLegacy(ctx, value.type).encode(value)
 
 				default:
 					return

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

@@ -26,6 +26,10 @@ import {
 	traverseGroupItemsContent,
 } from "../../GroupContent"
 import { isNestableContent } from "../../nestable"
+import {
+	isRepeatableContent,
+	traverseRepeatableContent,
+} from "../../RepeatableContent"
 import {
 	repeatableContentWithDefaultNestableContentValues,
 	withDefaultSlicePrimaryContentValues,
@@ -215,6 +219,20 @@ export function traverseSharedSliceContent({
 						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.config?.repeat
+								? fieldDef
+								: undefined,
+					})(transformWidget)
 				} else if (isNestableContent(fieldContent)) {
 					return transformWidget({
 						path: path.concat([

package/src/customtypes/widgets/Widget.ts

@@ -61,21 +61,6 @@ export const FieldType = t.keyof({
 	[GroupFieldType]: null,
 	[SlicesFieldType]: null,
 	[LegacySlicesFieldType]: null,
-	[`Repeatable.Color`]: null,
-	[`Repeatable.Boolean`]: null,
-	[`Repeatable.Number`]: null,
-	[`Repeatable.Embed`]: null,
-	[`Repeatable.GeoPoint`]: null,
-	[`Repeatable.Date`]: null,
-	[`Repeatable.Range`]: null,
-	[`Repeatable.StructuredText`]: null,
-	[`Repeatable.Select`]: null,
-	[`Repeatable.Separator`]: null,
-	[`Repeatable.Text`]: null,
-	[`Repeatable.Timestamp`]: null,
-	[`Repeatable.Link`]: null,
-	[`Repeatable.Image`]: null,
-	[`Repeatable.IntegrationFields`]: null,
 })
 
 export type FieldType = t.TypeOf<typeof FieldType>

package/src/customtypes/widgets/nestable/Link.ts

@@ -79,7 +79,12 @@ export const LinkConfig = t.exact(
 		tags: MasksArrayString,
 		allowTargetBlank: t.boolean,
 		allowText: t.boolean,
-		repeat: withFallback(t.boolean, false),
+
+		/**
+		 * `repeat` property is used to allow multiple links to be added.
+		 * `undefined` means that the field is not repeatable (hence repeat = false).
+		 */
+		repeat: t.boolean,
 	}),
 )
 export type LinkConfig = t.TypeOf<typeof LinkConfig>
@@ -91,10 +96,7 @@ export const Link = t.exact(
 		}),
 		t.partial({
 			fieldset: StringOrNull,
-			config: withFallback(LinkConfig, {
-				select: null,
-				repeat: false,
-			}),
+			config: LinkConfig,
 		}),
 	]),
 )

package/src/customtypes/widgets/nestable/NestableWidget.ts

@@ -1,20 +1,20 @@
 import * as t from "io-ts"
 
-import { BooleanField, BooleanFieldType } from "./BooleanField"
-import { Color, ColorFieldType } from "./Color"
-import { Date, DateFieldType } from "./Date"
-import { Embed, EmbedFieldType } from "./Embed"
-import { GeoPoint, GeoPointFieldType } from "./GeoPoint"
-import { Image, ImageFieldType } from "./Image"
-import { IntegrationField, IntegrationFieldType } from "./IntegrationField"
-import { Link, LinkFieldType } from "./Link"
-import { Number, NumberFieldType } from "./Number"
-import { Range, RangeFieldType } from "./Range"
-import { RichText, RichTextFieldType } from "./RichText"
-import { Select, SelectFieldType } from "./Select"
-import { Separator, SeparatorFieldType } from "./Separator"
-import { Text, TextFieldType } from "./Text"
-import { Timestamp, TimestampFieldType } from "./Timestamp"
+import { BooleanField } from "./BooleanField"
+import { Color } from "./Color"
+import { Date } from "./Date"
+import { Embed } from "./Embed"
+import { GeoPoint } from "./GeoPoint"
+import { Image } from "./Image"
+import { IntegrationField } from "./IntegrationField"
+import { Link } from "./Link"
+import { Number } from "./Number"
+import { Range } from "./Range"
+import { RichText } from "./RichText"
+import { Select } from "./Select"
+import { Separator } from "./Separator"
+import { Text } from "./Text"
+import { Timestamp } from "./Timestamp"
 
 export const NestableWidget = t.union([
 	Color,
@@ -35,22 +35,4 @@ export const NestableWidget = t.union([
 ])
 
 export type NestableWidget = t.TypeOf<typeof NestableWidget>
-
-export const NestableFieldTypes = t.union([
-	t.literal(ColorFieldType),
-	t.literal(BooleanFieldType),
-	t.literal(EmbedFieldType),
-	t.literal(GeoPointFieldType),
-	t.literal(DateFieldType),
-	t.literal(NumberFieldType),
-	t.literal(RangeFieldType),
-	t.literal(RichTextFieldType),
-	t.literal(SelectFieldType),
-	t.literal(SeparatorFieldType),
-	t.literal(TextFieldType),
-	t.literal(TimestampFieldType),
-	t.literal(LinkFieldType),
-	t.literal(ImageFieldType),
-	t.literal(IntegrationFieldType),
-])
-export type NestableFieldTypes = t.TypeOf<typeof NestableFieldTypes>
+export type NestableFieldTypes = NestableWidget["type"]