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

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

@@ -1,9 +1,15 @@
 import { isRight } from "fp-ts/lib/Either"
 import * as t from "io-ts"
 
-import type { NestableWidget } from "../../../customtypes"
+import { type NestableWidget, NestableFieldTypes } from "../../../customtypes"
 import type { LegacyContentCtx } from "../../LegacyContentCtx"
 import { EmptyContent, EmptyLegacy, isEmptyContent } from "../EmptyContent"
+import {
+	isRepeatableContent,
+	RepeatableContent,
+	RepeatableContentType,
+	RepeatableLegacy,
+} from "../RepeatableContent"
 import {
 	BooleanContent,
 	BooleanContentDefaultValue,
@@ -96,6 +102,7 @@ export const NestableContent = t.union([
 	LinkContent,
 	RichTextContent,
 	SeparatorContent,
+	RepeatableContent,
 ])
 export type NestableContent = t.TypeOf<typeof NestableContent>
 export type NestableContentType = NestableContent["__TYPE__"]
@@ -129,7 +136,8 @@ export const isNestableContent = (u: unknown): u is NestableContent =>
 	isIntegrationFieldContent(u) ||
 	isLinkContent(u) ||
 	isSeparatorContent(u) ||
-	isEmptyContent(u)
+	isEmptyContent(u) ||
+	isRepeatableContent(u)
 
 export const NestableLegacy = (ctx: LegacyContentCtx) => {
 	return {
@@ -139,8 +147,13 @@ 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 (ctx.fieldType) {
+				switch (fieldType) {
 					case "Text":
 						return TextLegacy(ctx)
 					case "Color":
@@ -178,9 +191,21 @@ 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)

package/src/customtypes/widgets/Widget.ts

@@ -61,6 +61,21 @@ 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,6 +79,7 @@ export const LinkConfig = t.exact(
 		tags: MasksArrayString,
 		allowTargetBlank: t.boolean,
 		allowText: t.boolean,
+		repeat: withFallback(t.boolean, false),
 	}),
 )
 export type LinkConfig = t.TypeOf<typeof LinkConfig>
@@ -90,7 +91,10 @@ export const Link = t.exact(
 		}),
 		t.partial({
 			fieldset: StringOrNull,
-			config: LinkConfig,
+			config: withFallback(LinkConfig, {
+				select: null,
+				repeat: false,
+			}),
 		}),
 	]),
 )

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

@@ -1,20 +1,20 @@
 import * as t from "io-ts"
 
-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"
+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"
 
 export const NestableWidget = t.union([
 	Color,
@@ -35,4 +35,22 @@ export const NestableWidget = t.union([
 ])
 
 export type NestableWidget = t.TypeOf<typeof NestableWidget>
-export type NestableFieldTypes = NestableWidget["type"]
+
+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>