@prismicio/types-internal 2.5.0 → 2.6.0

package/package.json

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

package/src/_internal/utils.ts

@@ -7,7 +7,6 @@ import type {
 	CompositeSlice,
 	Group,
 	NestableWidget,
-	NestedGroup,
 	StaticSlices,
 	UID,
 	VariationFields,
@@ -89,4 +88,4 @@ export type SliceModel =
 	| VariationFields
 	| NestableWidget
 	| CompositeSlice
-	| NestedGroup
+	| Group

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

@@ -15,6 +15,7 @@ import {
 	WithTypes,
 } from "../../../LegacyContentCtx"
 import { hasContentType } from "../../../utils"
+import { GroupItemContent, traverseGroupItemsContent } from "../../GroupContent"
 import {
 	isNestableContent,
 	NestableContent,
@@ -28,12 +29,7 @@ import type {
 	CompositeSliceItemContent,
 	SharedSliceItemContent,
 } from "../SliceItem"
-import {
-	RepeatableWidgetItemContent,
-	RepeatableWidgets,
-	RepeatableWidgetsLegacy,
-	traverseRepeatableWidgetItemsContent,
-} from "./RepeatableContent"
+import { RepeatableWidgets, RepeatableWidgetsLegacy } from "./RepeatableContent"
 
 export const CompositeSliceContentType = "CompositeSliceContent"
 
@@ -212,7 +208,7 @@ export function traverseCompositeSliceContent({
 			}
 		}, {})
 
-		const items = traverseRepeatableWidgetItemsContent({
+		const items = traverseGroupItemsContent({
 			path: path.concat([{ key: "repeat", type: "items" }]),
 			model:
 				model?.type === "SharedSlice" ? model?.fields.items : model?.repeat,
@@ -264,7 +260,7 @@ export function migrateCompositeSlice(
 			items: content.widget.repeat.map((groupItem) => {
 				return {
 					__TYPE__: "GroupItemContent",
-					value: groupItem.value.reduce<RepeatableWidgetItemContent["value"]>(
+					value: groupItem.value.reduce<GroupItemContent["value"]>(
 						(acc, [fieldKey, fieldContent]) => {
 							if (!model.fields.items?.[fieldKey]) {
 								console.warn(

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

@@ -1,252 +1,21 @@
-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 { NestableWidget, NestedGroup } from "../../../../customtypes"
+import type { LegacyContentCtx } from "../../../LegacyContentCtx"
 import {
-	FieldOrSliceType,
-	getFieldCtx,
-	LegacyContentCtx,
-	WithTypes,
-} from "../../../LegacyContentCtx"
-import { hasContentType } from "../../../utils"
-import { GroupContentType, GroupItemContentType } from "../../GroupContent"
-import {
-	isNestableContent,
-	NestableContent,
-	NestableLegacy,
-} from "../../nestable"
-
-/**
- * This is essentially a copy of `GroupItemContent` that doesn't support
- * nested groups to keep accurate content types for legacy slice.
- */
-const RepeatableWidgetItemContent = t.strict({
-	__TYPE__: t.literal(GroupItemContentType),
-	value: t.array(t.tuple([t.string, NestableContent])),
-})
-export type RepeatableWidgetItemContent = t.TypeOf<
-	typeof RepeatableWidgetItemContent
->
-
-const itemLegacyReader = t.record(t.string, t.unknown)
-type RepeatableWidgetItemLegacy = t.TypeOf<typeof itemLegacyReader>
-
-/**
- * This is essentially a copy of `GroupItemLegacy` that doesn't support
- * nested groups to keep accurate content types for legacy slice.
- */
-const RepeatableWidgetItemLegacy = (ctx: LegacyContentCtx) => {
-	return new t.Type<
-		RepeatableWidgetItemContent,
-		WithTypes<RepeatableWidgetItemLegacy>
-	>(
-		"RepeatableWidgetItemLegacy",
-		(u): u is RepeatableWidgetItemContent =>
-			hasContentType(u) && u.__TYPE__ === GroupItemContentType,
-		(u) => {
-			const parsed = pipe(
-				itemLegacyReader.decode(u),
-				either.map((items) => {
-					const parsedItems = Object.entries(items).reduce<
-						Array<[string, NestableContent]>
-					>((acc, [itemKey, itemValue]) => {
-						const itemCtx = getFieldCtx(itemKey, ctx)
-						const result = NestableLegacy(itemCtx).decode(itemValue)
-						if (!result) return acc
-
-						if (isLeft(result)) return acc
-						return [...acc, [itemKey, result.right]]
-					}, [])
-
-					return {
-						value: parsedItems,
-						__TYPE__: GroupItemContentType,
-					}
-				}),
-			)
-			return parsed
-		},
-		(item) => {
-			return item.value.reduce<WithTypes<RepeatableWidgetItemLegacy>>(
-				(acc, [key, value]) => {
-					const itemCtx = getFieldCtx(key, ctx)
-					const encoded = NestableLegacy(itemCtx).encode(value)
-					if (!encoded) return acc
-
-					return {
-						content: { ...acc.content, [key]: encoded.content },
-						types: { ...acc.types, ...encoded.types },
-					}
-				},
-				{ content: {}, types: {} },
-			)
-		},
-	)
-}
-
-/**
- * This is essentially a copy of `GroupLegacy` that doesn't support
- * nested groups to keep accurate content types for legacy slice.
- */
-type RepeatableWidgetLegacy = Array<RepeatableWidgetItemLegacy>
-export const RepeatableWidgetLegacy = (ctx: LegacyContentCtx) => {
-	const codecDecode = t.array(
-		t.union([t.null, RepeatableWidgetItemLegacy(ctx)]),
-	)
-	const codecEncode = t.array(RepeatableWidgetItemLegacy(ctx))
-
-	return new t.Type<
-		RepeatableWidgetContent,
-		WithTypes<RepeatableWidgetLegacy>,
-		unknown
-	>(
-		"RepeatableWidgetLegacy",
-		isRepeatableWidgetContent,
-		(items) => {
-			return pipe(
-				codecDecode.decode(items),
-				either.map((parsedItems) => {
-					return {
-						value: parsedItems.map((i) => {
-							if (i === null) {
-								return { __TYPE__: GroupItemContentType, value: [] }
-							} else return i
-						}),
-						__TYPE__: GroupContentType,
-					}
-				}),
-			)
-		},
-		(g: RepeatableWidgetContent) => {
-			const res = codecEncode.encode(g.value)
-			return {
-				content: res.map((block) => block.content),
-				types: res.reduce<Record<string, FieldOrSliceType>>(
-					(acc, block) => {
-						return { ...acc, ...block.types }
-					},
-					{ [ctx.keyOfType]: "Group" },
-				),
-			}
-		},
-	)
-}
-
-/**
- * This is essentially a copy of `isGroupContent` that doesn't support
- * nested groups to keep accurate content types for legacy slice.
- */
-export const isRepeatableWidgetContent = (
-	u: unknown,
-): u is RepeatableWidgetContent =>
-	hasContentType(u) && u.__TYPE__ === GroupContentType
-
-export const RepeatableWidgetContent = t.strict({
-	__TYPE__: t.literal(GroupContentType),
-	value: t.array(RepeatableWidgetItemContent),
-})
-export type RepeatableWidgetContent = t.TypeOf<typeof RepeatableWidgetContent>
-
-/**
- * This is essentially a copy of `traverseGroupContent` that doesn't support
- * nested groups to keep accurate content types for legacy slice.
- */
-export function traverseRepeatableWidgetContent({
-	path,
-	key,
-	apiId,
-	model,
-	content,
-}: {
-	path: ContentPath
-	key: string
-	apiId: string
-	content: RepeatableWidgetContent
-	model?: NestedGroup | undefined
-}) {
-	return (
-		transform: TraverseWidgetContentFn,
-	): RepeatableWidgetContent | undefined => {
-		const repeatableWidgetItems = traverseRepeatableWidgetItemsContent({
-			path,
-			model: model?.config?.fields,
-			content: content.value,
-		})(transform)
-
-		return transform({
-			path,
-			key,
-			apiId,
-			model,
-			content: {
-				__TYPE__: content.__TYPE__,
-				value: repeatableWidgetItems,
-			},
-		})
-	}
-}
-
-/**
- * This is essentially a copy of `traverseGroupItemContent` that doesn't support
- * nested groups to keep accurate content types for legacy slice.
- */
-export function traverseRepeatableWidgetItemsContent({
-	path,
-	model,
-	content,
-}: {
-	path: ContentPath
-	content: Array<RepeatableWidgetItemContent>
-	model?: Record<string, NestableWidget> | undefined
-}) {
-	return (
-		transform: TraverseWidgetContentFn,
-	): Array<RepeatableWidgetItemContent> => {
-		return content.map((repeatableWidgetItem, index) => {
-			const repeatableWidgetItemPath = path.concat([
-				{ key: index.toString(), type: "GroupItem" },
-			])
-
-			const repeatableWidgetItemFields = repeatableWidgetItem.value.reduce<
-				RepeatableWidgetItemContent["value"]
-			>((acc, [fieldKey, fieldContent]) => {
-				const fieldDef = model?.[fieldKey]
-
-				const transformedField = transform({
-					path: repeatableWidgetItemPath.concat([
-						{ key: fieldKey, type: "Widget" },
-					]),
-					key: fieldKey,
-					apiId: fieldKey,
-					model: fieldDef,
-					content: fieldContent,
-				})
-				// Can happen if the transform function returns undefined to filter out a field
-				if (!transformedField || !isNestableContent(transformedField))
-					return acc
-
-				return acc.concat([[fieldKey, transformedField]])
-			}, [])
-
-			return {
-				__TYPE__: repeatableWidgetItem.__TYPE__,
-				value: repeatableWidgetItemFields,
-			}
-		})
-	}
-}
+	GroupContent,
+	GroupItemContentType,
+	GroupItemLegacy,
+} from "../../GroupContent"
+import { NestableContent } from "../../nestable"
 
 export const RepeatableWidgetsLegacy = (ctx: LegacyContentCtx) => {
-	return t.array(RepeatableWidgetItemLegacy(ctx))
+	return t.array(GroupItemLegacy(ctx))
 }
 
-const RepeatableWidget = t.tuple([t.string, NestableContent])
+const RepeatableWidget = t.tuple([
+	t.string,
+	t.union([NestableContent, GroupContent]),
+])
 const RepeatableWidgetsBlock = t.strict({
 	__TYPE__: t.literal(GroupItemContentType),
 	value: t.array(RepeatableWidget),

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

@@ -20,18 +20,18 @@ import {
 	WithTypes,
 } from "../../../LegacyContentCtx"
 import { hasContentType } from "../../../utils"
-import { isGroupContent, traverseGroupContent } from "../../GroupContent"
+import {
+	isGroupContent,
+	traverseGroupContent,
+	traverseGroupItemsContent,
+} from "../../GroupContent"
 import { isNestableContent } from "../../nestable"
 import {
 	repeatableContentWithDefaultNestableContentValues,
 	withDefaultSlicePrimaryContentValues,
 } from "../../withDefaultValues"
 import type { SharedSliceItemContent } from "../SliceItem"
-import {
-	RepeatableWidgets,
-	RepeatableWidgetsLegacy,
-	traverseRepeatableWidgetItemsContent,
-} from "./RepeatableContent"
+import { RepeatableWidgets, RepeatableWidgetsLegacy } from "./RepeatableContent"
 import {
 	isSlicePrimaryContent,
 	SlicePrimaryContent,
@@ -245,7 +245,7 @@ export function traverseSharedSliceContent({
 			}
 		}, {})
 
-		const items = traverseRepeatableWidgetItemsContent({
+		const items = traverseGroupItemsContent({
 			path: path.concat([{ key: "items", type: "items" }]),
 			model: model?.fields.items,
 			content: content.widget.items,

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

@@ -6,11 +6,18 @@ import type {
 	TraverseWidgetContentFn,
 } from "../../../../_internal/utils"
 import type {
+	Group,
 	NestableWidget,
-	NestedGroup,
 	VariationFields,
 } from "../../../../customtypes"
 import type { LegacyContentCtx } from "../../../LegacyContentCtx"
+import {
+	GroupContent,
+	GroupItemContent,
+	GroupLegacy,
+	isGroupContent,
+	traverseGroupContent,
+} from "../../GroupContent"
 import {
 	isNestableContent,
 	NestableContent,
@@ -20,35 +27,24 @@ import type {
 	SharedSliceItemContent,
 	SimpleSliceItemContent,
 } from "../SliceItem"
-import {
-	isRepeatableWidgetContent,
-	RepeatableWidgetContent,
-	RepeatableWidgetItemContent,
-	RepeatableWidgetLegacy,
-	traverseRepeatableWidgetContent,
-} from "./RepeatableContent"
 
-export const SimpleSliceContent = t.union([
-	NestableContent,
-	RepeatableWidgetContent,
-])
+export const SimpleSliceContent = t.union([NestableContent, GroupContent])
 export type SimpleSliceContent = t.TypeOf<typeof SimpleSliceContent>
 
 export const isSimpleSliceContent = (u: unknown): u is SimpleSliceContent =>
-	isNestableContent(u) || isRepeatableWidgetContent(u)
+	isNestableContent(u) || isGroupContent(u)
 
 export const SimpleSliceLegacy = (ctx: LegacyContentCtx) => {
 	return {
 		decode: (() => {
-			if (ctx.fieldType === "Group")
-				return RepeatableWidgetLegacy(ctx).decode.bind(null)
+			if (ctx.fieldType === "Group") return GroupLegacy(ctx).decode.bind(null)
 			return NestableLegacy(ctx).decode.bind(null)
 		})(),
 
 		encode: (value: SimpleSliceContent) => {
 			switch (value.__TYPE__) {
 				case "GroupContentType":
-					return RepeatableWidgetLegacy(ctx).encode(value)
+					return GroupLegacy(ctx).encode(value)
 				default:
 					return NestableLegacy(ctx).encode(value)
 			}
@@ -67,15 +63,15 @@ export function traverseSimpleSliceContent({
 	sliceKey: string
 	sliceName: string
 	content: SimpleSliceItemContent
-	model?: VariationFields | NestedGroup | NestableWidget | undefined
+	model?: VariationFields | Group | NestableWidget | undefined
 }) {
 	return (
 		transformWidget: TraverseWidgetContentFn,
 		transformSlice: TraverseSliceContentFn,
 	): SharedSliceItemContent | SimpleSliceItemContent | undefined => {
-		if (isRepeatableWidgetContent(content.widget)) {
-			const convertedGroupWidget: RepeatableWidgetContent | undefined =
-				traverseRepeatableWidgetContent({
+		if (isGroupContent(content.widget)) {
+			const convertedGroupWidget: GroupContent | undefined =
+				traverseGroupContent({
 					path,
 					key: content.key,
 					apiId: content.name,
@@ -154,7 +150,7 @@ export function migrateSimpleSlice(
 				items: content.widget.value.map((groupItem) => {
 					return {
 						__TYPE__: "GroupItemContent",
-						value: groupItem.value.reduce<RepeatableWidgetItemContent["value"]>(
+						value: groupItem.value.reduce<GroupItemContent["value"]>(
 							(acc, [fieldKey, fieldContent]) => {
 								return model.fields.items?.[fieldKey]
 									? acc.concat([[fieldKey, fieldContent]])

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

@@ -47,7 +47,6 @@ export const SliceContent = t.union([
 export type SliceContent = t.TypeOf<typeof SliceContent>
 
 export * from "./CompositeSliceContent"
-export * from "./RepeatableContent"
 export * from "./SharedSliceContent"
 export * from "./SimpleSliceContent"
 export * from "./SlicePrimaryContent"

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

@@ -11,11 +11,11 @@ import {
 import {
 	type StaticSlices,
 	CompositeSlice,
+	Group,
 	isCompositeSlice,
 	isLegacySlice,
 	isStaticSharedSlice,
 	NestableWidget,
-	NestedGroup,
 	SharedSlice,
 	VariationFields,
 } from "../../../customtypes"
@@ -177,7 +177,7 @@ function findSliceModel(
 	const legacySliceModel = ():
 		| NestableWidget
 		| CompositeSlice
-		| NestedGroup
+		| Group
 		| undefined => {
 		if (!defaultModel) return