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

package/lib/customtypes/widgets/slices/Slices.d.ts

@@ -145,6 +145,7 @@ export declare function slicesConfigReader<T extends SharedSlice | SharedSliceRe
             tags: t.Type<readonly string[], object, unknown>;
             allowTargetBlank: t.BooleanC;
             allowText: t.BooleanC;
+            repeat: t.BooleanC;
         }>>;
     }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
         type: t.LiteralC<"Image">;
@@ -311,6 +312,7 @@ export declare function slicesConfigReader<T extends SharedSlice | SharedSliceRe
                     tags: t.Type<readonly string[], object, unknown>;
                     allowTargetBlank: t.BooleanC;
                     allowText: t.BooleanC;
+                    repeat: t.BooleanC;
                 }>>;
             }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
                 type: t.LiteralC<"Image">;
@@ -477,6 +479,7 @@ export declare function slicesConfigReader<T extends SharedSlice | SharedSliceRe
                 tags: t.Type<readonly string[], object, unknown>;
                 allowTargetBlank: t.BooleanC;
                 allowText: t.BooleanC;
+                repeat: t.BooleanC;
             }>>;
         }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
             type: t.LiteralC<"Image">;
@@ -635,6 +638,7 @@ export declare function slicesConfigReader<T extends SharedSlice | SharedSliceRe
                 tags: t.Type<readonly string[], object, unknown>;
                 allowTargetBlank: t.BooleanC;
                 allowText: t.BooleanC;
+                repeat: t.BooleanC;
             }>>;
         }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
             type: t.LiteralC<"Image">;
@@ -805,6 +809,7 @@ export declare const StaticSlicesConfig: t.ExactC<t.PartialC<{
             tags: t.Type<readonly string[], object, unknown>;
             allowTargetBlank: t.BooleanC;
             allowText: t.BooleanC;
+            repeat: t.BooleanC;
         }>>;
     }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
         type: t.LiteralC<"Image">;
@@ -971,6 +976,7 @@ export declare const StaticSlicesConfig: t.ExactC<t.PartialC<{
                     tags: t.Type<readonly string[], object, unknown>;
                     allowTargetBlank: t.BooleanC;
                     allowText: t.BooleanC;
+                    repeat: t.BooleanC;
                 }>>;
             }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
                 type: t.LiteralC<"Image">;
@@ -1137,6 +1143,7 @@ export declare const StaticSlicesConfig: t.ExactC<t.PartialC<{
                 tags: t.Type<readonly string[], object, unknown>;
                 allowTargetBlank: t.BooleanC;
                 allowText: t.BooleanC;
+                repeat: t.BooleanC;
             }>>;
         }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
             type: t.LiteralC<"Image">;
@@ -1295,6 +1302,7 @@ export declare const StaticSlicesConfig: t.ExactC<t.PartialC<{
                 tags: t.Type<readonly string[], object, unknown>;
                 allowTargetBlank: t.BooleanC;
                 allowText: t.BooleanC;
+                repeat: t.BooleanC;
             }>>;
         }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
             type: t.LiteralC<"Image">;
@@ -1424,6 +1432,7 @@ export declare const StaticSlicesConfig: t.ExactC<t.PartialC<{
                         tags?: readonly string[];
                         allowTargetBlank?: boolean;
                         allowText?: boolean;
+                        repeat?: boolean;
                     };
                 }) | ({
                     type: "Number";
@@ -1591,6 +1600,7 @@ export declare const StaticSlicesConfig: t.ExactC<t.PartialC<{
                                     tags?: readonly string[];
                                     allowTargetBlank?: boolean;
                                     allowText?: boolean;
+                                    repeat?: boolean;
                                 };
                             }) | ({
                                 type: "Number";
@@ -1758,6 +1768,7 @@ export declare const StaticSlicesConfig: t.ExactC<t.PartialC<{
                                                 tags?: readonly string[];
                                                 allowTargetBlank?: boolean;
                                                 allowText?: boolean;
+                                                repeat?: boolean;
                                             };
                                         }) | ({
                                             type: "Number";
@@ -1924,6 +1935,7 @@ export declare const StaticSlicesConfig: t.ExactC<t.PartialC<{
                         tags?: readonly string[];
                         allowTargetBlank?: boolean;
                         allowText?: boolean;
+                        repeat?: boolean;
                     };
                 }) | ({
                     type: "Number";
@@ -2145,6 +2157,7 @@ export declare const DynamicSlicesConfig: t.ExactC<t.PartialC<{
             tags: t.Type<readonly string[], object, unknown>;
             allowTargetBlank: t.BooleanC;
             allowText: t.BooleanC;
+            repeat: t.BooleanC;
         }>>;
     }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
         type: t.LiteralC<"Image">;
@@ -2311,6 +2324,7 @@ export declare const DynamicSlicesConfig: t.ExactC<t.PartialC<{
                     tags: t.Type<readonly string[], object, unknown>;
                     allowTargetBlank: t.BooleanC;
                     allowText: t.BooleanC;
+                    repeat: t.BooleanC;
                 }>>;
             }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
                 type: t.LiteralC<"Image">;
@@ -2477,6 +2491,7 @@ export declare const DynamicSlicesConfig: t.ExactC<t.PartialC<{
                 tags: t.Type<readonly string[], object, unknown>;
                 allowTargetBlank: t.BooleanC;
                 allowText: t.BooleanC;
+                repeat: t.BooleanC;
             }>>;
         }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
             type: t.LiteralC<"Image">;
@@ -2635,6 +2650,7 @@ export declare const DynamicSlicesConfig: t.ExactC<t.PartialC<{
                 tags: t.Type<readonly string[], object, unknown>;
                 allowTargetBlank: t.BooleanC;
                 allowText: t.BooleanC;
+                repeat: t.BooleanC;
             }>>;
         }>]>>, t.ExactC<t.IntersectionC<[t.TypeC<{
             type: t.LiteralC<"Image">;
@@ -2781,6 +2797,7 @@ export declare const StaticSlices: t.ExactC<t.IntersectionC<[t.TypeC<{
                     tags?: readonly string[];
                     allowTargetBlank?: boolean;
                     allowText?: boolean;
+                    repeat?: boolean;
                 };
             }) | ({
                 type: "Number";
@@ -2948,6 +2965,7 @@ export declare const StaticSlices: t.ExactC<t.IntersectionC<[t.TypeC<{
                                 tags?: readonly string[];
                                 allowTargetBlank?: boolean;
                                 allowText?: boolean;
+                                repeat?: boolean;
                             };
                         }) | ({
                             type: "Number";
@@ -3116,6 +3134,7 @@ export declare const StaticSlices: t.ExactC<t.IntersectionC<[t.TypeC<{
                             tags?: readonly string[];
                             allowTargetBlank?: boolean;
                             allowText?: boolean;
+                            repeat?: boolean;
                         };
                     }) | ({
                         type: "Number";
@@ -3276,6 +3295,7 @@ export declare const StaticSlices: t.ExactC<t.IntersectionC<[t.TypeC<{
                             tags?: readonly string[];
                             allowTargetBlank?: boolean;
                             allowText?: boolean;
+                            repeat?: boolean;
                         };
                     }) | ({
                         type: "Number";
@@ -3452,6 +3472,7 @@ export declare const StaticSlices: t.ExactC<t.IntersectionC<[t.TypeC<{
                                 tags?: readonly string[];
                                 allowTargetBlank?: boolean;
                                 allowText?: boolean;
+                                repeat?: boolean;
                             };
                         }) | ({
                             type: "Number";
@@ -3619,6 +3640,7 @@ export declare const StaticSlices: t.ExactC<t.IntersectionC<[t.TypeC<{
                                             tags?: readonly string[];
                                             allowTargetBlank?: boolean;
                                             allowText?: boolean;
+                                            repeat?: boolean;
                                         };
                                     }) | ({
                                         type: "Number";
@@ -3786,6 +3808,7 @@ export declare const StaticSlices: t.ExactC<t.IntersectionC<[t.TypeC<{
                                                         tags?: readonly string[];
                                                         allowTargetBlank?: boolean;
                                                         allowText?: boolean;
+                                                        repeat?: boolean;
                                                     };
                                                 }) | ({
                                                     type: "Number";
@@ -3952,6 +3975,7 @@ export declare const StaticSlices: t.ExactC<t.IntersectionC<[t.TypeC<{
                                 tags?: readonly string[];
                                 allowTargetBlank?: boolean;
                                 allowText?: boolean;
+                                repeat?: boolean;
                             };
                         }) | ({
                             type: "Number";
@@ -4139,6 +4163,7 @@ export declare const DynamicSlices: t.ExactC<t.IntersectionC<[t.TypeC<{
                     tags?: readonly string[];
                     allowTargetBlank?: boolean;
                     allowText?: boolean;
+                    repeat?: boolean;
                 };
             }) | ({
                 type: "Number";
@@ -4306,6 +4331,7 @@ export declare const DynamicSlices: t.ExactC<t.IntersectionC<[t.TypeC<{
                                 tags?: readonly string[];
                                 allowTargetBlank?: boolean;
                                 allowText?: boolean;
+                                repeat?: boolean;
                             };
                         }) | ({
                             type: "Number";
@@ -4474,6 +4500,7 @@ export declare const DynamicSlices: t.ExactC<t.IntersectionC<[t.TypeC<{
                             tags?: readonly string[];
                             allowTargetBlank?: boolean;
                             allowText?: boolean;
+                            repeat?: boolean;
                         };
                     }) | ({
                         type: "Number";
@@ -4634,6 +4661,7 @@ export declare const DynamicSlices: t.ExactC<t.IntersectionC<[t.TypeC<{
                             tags?: readonly string[];
                             allowTargetBlank?: boolean;
                             allowText?: boolean;
+                            repeat?: boolean;
                         };
                     }) | ({
                         type: "Number";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prismicio/types-internal",
-	"version": "2.8.0",
+	"version": "2.9.0-alpha.1",
 	"description": "Prismic types for Custom Types and Prismic Data",
 	"keywords": [
 		"typescript",

package/src/_internal/utils.ts

@@ -3,6 +3,7 @@ import type {
 	SliceItemContent,
 	WidgetContent,
 } from "../content"
+import type { RepeatableContent } from "../content/fields/RepeatableContent"
 import type {
 	CompositeSlice,
 	Group,
@@ -30,7 +31,7 @@ export type TraverseSliceContentFn = <
 }) => S | SharedSliceItemContent | undefined
 
 export type TraverseWidgetContentFn = <
-	C extends WidgetContent,
+	C extends WidgetContent | RepeatableContent,
 	D extends NestableWidget | StaticSlices | Group | UID,
 >({
 	path,
@@ -56,6 +57,7 @@ export type ContentPathEntry = {
 		| "GroupItem"
 		| "primary"
 		| "items"
+		| "RepeatableItem"
 	key: string
 }
 

package/src/content/Document.ts

@@ -24,6 +24,7 @@ import {
 	NestableContentDefaultValue,
 	slicesContentWithDefaultValues,
 	traverseGroupContent,
+	traverseRepeatableContent,
 	traverseSlices,
 	WidgetContent,
 	WidgetLegacy,
@@ -293,6 +294,17 @@ export function traverseDocument({
 							model: fieldModel?.type === "Group" ? fieldModel : undefined,
 							content,
 						})(transformWidget)
+					case "RepeatableContent":
+						return traverseRepeatableContent({
+							path,
+							key,
+							apiId: key,
+							model:
+								fieldModel?.type === "Link" && fieldModel.config?.repeat
+									? fieldModel
+									: undefined,
+							content,
+						})(transformWidget)
 					default:
 						return transformWidget({
 							path,

package/src/content/LegacyContentCtx.ts

@@ -2,7 +2,10 @@ import * as t from "io-ts"
 
 import { FieldType, SlicesTypes } from "../customtypes/widgets"
 
-export const FieldOrSliceType = t.union([FieldType, SlicesTypes])
+export const FieldOrSliceType = t.union([
+	t.union([FieldType, SlicesTypes]),
+	t.literal("Repeatable.Link"),
+])
 export type FieldOrSliceType = t.TypeOf<typeof FieldOrSliceType>
 export class LegacyContentCtx {
 	fieldKey: string

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

@@ -0,0 +1,147 @@
+import { either } from "fp-ts"
+import { isLeft } from "fp-ts/lib/Either"
+import { pipe } from "fp-ts/lib/function"
+import * as t from "io-ts"
+
+import type {
+	ContentPath,
+	TraverseWidgetContentFn,
+} from "../../_internal/utils"
+import type { Link, NestableWidget } from "../../customtypes"
+import type { LegacyContentCtx, WithTypes } from "../LegacyContentCtx"
+import {
+	isLinkContent,
+	LinkContent,
+	LinkContentLegacy,
+	LinkContentType,
+} from "./nestable"
+
+export const RepeatableContent = t.strict({
+	__TYPE__: t.literal("RepeatableContent"),
+	type: t.literal("Link"),
+	value: t.array(LinkContent),
+})
+
+export type RepeatableContent = t.TypeOf<typeof RepeatableContent>
+
+export const isRepeatableContent = RepeatableContent.is
+
+export const RepeatableLegacy = (
+	ctx: LegacyContentCtx,
+	fieldType: "Link",
+): t.Type<RepeatableContent, WithTypes<Array<unknown>>, unknown> => {
+	return new t.Type<RepeatableContent, WithTypes<Array<unknown>>, unknown>(
+		"RepeatableLegacy",
+		isRepeatableContent,
+		(items) => {
+			const parsed = pipe(
+				t.array(t.unknown).decode(items),
+				either.map((items) => {
+					const parsedItems = items.reduce<Array<LinkContent>>((acc, item) => {
+						let result
+
+						switch (fieldType) {
+							case "Link":
+								result = LinkContentLegacy(ctx).decode(item)
+								break
+						}
+
+						if (!result) return acc
+						if (isLeft(result)) return acc
+
+						return [...acc, result.right]
+					}, [])
+
+					return {
+						value: parsedItems,
+						type: fieldType,
+						__TYPE__: "RepeatableContent" as const,
+					}
+				}),
+			)
+
+			return parsed
+		},
+		(r: RepeatableContent) => {
+			const res = t.array(LinkContent).encode(r.value)
+			const encodedItems = res.reduce<Array<WithTypes<unknown>>>(
+				(acc, item) => {
+					let encoded
+
+					switch (item.__TYPE__) {
+						case LinkContentType:
+							encoded = LinkContentLegacy(ctx).encode(item)
+							break
+					}
+
+					if (!encoded) return acc
+
+					return [...acc, encoded]
+				},
+				[],
+			)
+
+			return {
+				content: encodedItems.map((encodedItem) => encodedItem.content),
+				types: { [ctx.keyOfType]: `Repeatable.${fieldType}` },
+			}
+		},
+	)
+}
+
+export type RepeatableCustomType = Link
+
+export function traverseRepeatableContent({
+	path,
+	key,
+	apiId,
+	model,
+	content,
+}: {
+	path: ContentPath
+	key: string
+	apiId: string
+	content: RepeatableContent
+	model?: NestableWidget | undefined
+}) {
+	return (
+		transform: TraverseWidgetContentFn,
+	): RepeatableContent | undefined => {
+		const items = content.value.reduce<Array<LinkContent>>(
+			(acc, fieldContent, index) => {
+				const itemPath = path.concat([
+					{ key: index.toString(), type: "Widget" },
+				])
+
+				const transformedField = transform({
+					path: itemPath,
+					key: key,
+					apiId: apiId,
+					model: model,
+					content: fieldContent,
+				})
+
+				// 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)
+			},
+			[],
+		)
+
+		return transform({
+			path,
+			key,
+			apiId,
+			model,
+			content: {
+				__TYPE__: content.__TYPE__,
+				type: content.type,
+				value: items,
+			},
+		})
+	}
+}

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/LinkContent.ts

@@ -1,3 +1,27 @@
+/**
+ * LinkContent is a union of different link content types.
+ *
+ * Most link content types are built from a union of a filled and an unfilled version.
+ *
+ * Filled versions make sure that the important fields that make the link work
+ * are present. They are also exported for when there's a need to ensure that
+ * the link is filled when used in a specific context, e.g. links in rich text fields.
+ *
+ * Unfilled versions are used when the link is not filled yet but contains other
+ * information like the text.
+ *
+ * There are some exceptions that don't have a filled version (e.g. MediaLink)
+ * for when the exact subtype is not yet known.
+ *
+ * Unfilled versions all have a special `kind` property that is used to
+ * determine the type of the link. For legacy reasons, filled versions don't
+ * necessarily require this property or its type is loose (e.g. `string`). In
+ * this cases, the type is determined based on a specific combination of the
+ * rest of the link data. This is why the order of the subtypes in the union is
+ * important and should be from the most specific to the least specific. A
+ * battery of tests ensures that the correct type is inferred.
+ */
+
 import { either } from "fp-ts"
 import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"

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

@@ -4,6 +4,11 @@ import * as t from "io-ts"
 import type { NestableWidget } from "../../../customtypes"
 import type { LegacyContentCtx } from "../../LegacyContentCtx"
 import { EmptyContent, EmptyLegacy, isEmptyContent } from "../EmptyContent"
+import {
+	isRepeatableContent,
+	RepeatableContent,
+	RepeatableLegacy,
+} from "../RepeatableContent"
 import {
 	BooleanContent,
 	BooleanContentDefaultValue,
@@ -96,6 +101,7 @@ export const NestableContent = t.union([
 	LinkContent,
 	RichTextContent,
 	SeparatorContent,
+	RepeatableContent,
 ])
 export type NestableContent = t.TypeOf<typeof NestableContent>
 export type NestableContentType = NestableContent["__TYPE__"]
@@ -129,7 +135,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 {
@@ -171,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
 				}
@@ -209,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/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,
+			}),
 		}),
 	]),
 )