@prismicio/types-internal 2.5.0-alpha.2 → 2.5.0-alpha.4

package/package.json

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

package/src/content/fields/GroupContent.ts

@@ -12,7 +12,6 @@ import {
 	type NestableWidget,
 	GroupFieldType,
 } from "../../customtypes"
-import { refineType } from "../../validators/function"
 import {
 	FieldOrSliceType,
 	getFieldCtx,
@@ -23,50 +22,9 @@ import { hasContentType } from "../utils"
 import { isNestableContent, NestableContent, NestableLegacy } from "./nestable"
 import { repeatableContentWithDefaultNestableContentValues } from "./withDefaultValues"
 
+export const GroupItemContentType = "GroupItemContent" as const
 export const GroupContentType = "GroupContentType" as const
-export const isGroupContent = (u: unknown): u is GroupContent =>
-	hasContentType(u) && u.__TYPE__ === GroupContentType
-
-const MAX_GROUP_DEPTH = 1
-const getGroupDepth = (group: GroupContent, depth = 0): number => {
-	// Stop searching when we're over limit
-	if (depth > MAX_GROUP_DEPTH) return depth
-
-	for (const item of group.value) {
-		for (const [_key, widget] of item.value) {
-			if (isGroupContent(widget)) {
-				depth = Math.max(depth, getGroupDepth(widget, depth + 1))
-			}
-		}
-	}
 
-	return depth
-}
-
-export const GroupContent: t.Type<GroupContent> = refineType(
-	t.recursion("GroupContent", () =>
-		t.strict({
-			__TYPE__: t.literal(GroupContentType),
-			value: t.array(GroupItemContent),
-		}),
-	),
-	"GroupContent",
-	(g) => {
-		if (getGroupDepth(g) > MAX_GROUP_DEPTH) {
-			throw new Error(
-				`GroupContent is nested too deeply (max ${MAX_GROUP_DEPTH} level)`,
-			)
-		}
-
-		return true
-	},
-)
-export type GroupContent = {
-	__TYPE__: typeof GroupContentType
-	value: GroupItemContent[]
-}
-
-export const GroupItemContentType = "GroupItemContent" as const
 export const GroupItemContent: t.Type<GroupItemContent> = t.recursion(
 	"GroupItemContent",
 	() =>
@@ -82,6 +40,29 @@ export type GroupItemContent = {
 	value: [string, NestableContent | GroupContent][]
 }
 
+export const GroupContent: t.Type<GroupContent> = t.recursion(
+	"GroupContent",
+	() =>
+		t.strict({
+			__TYPE__: t.literal(GroupContentType),
+			value: t.array(GroupItemContent),
+		}),
+)
+export type GroupContent = {
+	__TYPE__: typeof GroupContentType
+	value: GroupItemContent[]
+}
+
+export const isGroupContent = (u: unknown): u is GroupContent =>
+	hasContentType(u) &&
+	u.__TYPE__ === GroupContentType &&
+	GroupContent.decode(u)._tag === "Right"
+
+export const GroupContentDefaultValue: GroupContent = {
+	__TYPE__: GroupContentType,
+	value: [],
+}
+
 const itemLegacyReader = t.record(t.string, t.unknown)
 type GroupItemLegacy = t.TypeOf<typeof itemLegacyReader>
 
@@ -178,11 +159,6 @@ export const GroupLegacy = (
 	)
 }
 
-export const GroupContentDefaultValue: GroupContent = {
-	__TYPE__: GroupContentType,
-	value: [],
-}
-
 export function groupContentWithDefaultValues(
 	customType: Group,
 	content: GroupContent,

package/src/content/fields/nestable/RichTextContent/Blocks.ts

@@ -79,9 +79,12 @@ export const ValidatedSpans = <C extends typeof Span | typeof SpanLegacy>(
 	)
 }
 
-// We allow any `t.Type` here and let TypeScript infer the exact codec.
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const ImageBlockCodec = <T extends t.Type<any>>(linkCodec: T) =>
+// We allow any codec here and let TypeScript infer the resulting codec.
+// Typing it more precisely creates conflicts.
+//
+// Using `t.Mixed` rather than `t.Type<A, O>` causes `data.linkTo` to be
+// typed as `any`. It seems to be an issue with the `nullable` helper.
+const ImageBlockCodec = <A, O>(linkCodec: t.Type<A, O>) =>
 	t.exact(
 		t.intersection([
 			t.type({

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

@@ -59,15 +59,14 @@ export const CompositeSliceLegacy = (ctx: LegacyContentCtx) => {
 				legacyReader.decode(slice),
 				either.map((parsedSlice) => {
 					const repeat =
-						((() => {
+						(() => {
 							const itemsCtx = getFieldCtx("repeat", ctx)
 							const result = RepeatableWidgetsLegacy(itemsCtx).decode(
 								parsedSlice.repeat,
 							)
 							if (!result || isLeft(result)) return
 							return result.right
-							// We don't support nested groups on composite slice items
-						})() as t.TypeOf<typeof RepeatableWidgets>) || []
+						})() || []
 
 					const nonRepeat = Object.entries(
 						parsedSlice["non-repeat"] || {},
@@ -214,8 +213,7 @@ export function traverseCompositeSliceContent({
 			model:
 				model?.type === "SharedSlice" ? model?.fields.items : model?.repeat,
 			content: content.widget.repeat,
-			// We don't support nested groups on composite slice items
-		})(transformWidget) as t.TypeOf<typeof RepeatableWidgets>
+		})(transformWidget)
 
 		return transformSlice({
 			key: sliceKey,
@@ -275,8 +273,7 @@ export function migrateCompositeSlice(
 						[],
 					),
 				}
-				// We don't support nested groups on composite slice items
-			}, []) as t.TypeOf<typeof RepeatableWidgets>,
+			}, []),
 		},
 	}
 }

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

@@ -1,14 +1,21 @@
 import * as t from "io-ts"
 
 import type { LegacyContentCtx } from "../../../LegacyContentCtx"
-import { GroupItemContentType, GroupItemLegacy } from "../../GroupContent"
+import {
+	GroupContent,
+	GroupItemContentType,
+	GroupItemLegacy,
+} from "../../GroupContent"
 import { NestableContent } from "../../nestable"
 
 export const RepeatableWidgetsLegacy = (ctx: LegacyContentCtx) => {
 	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

@@ -61,7 +61,7 @@ export const SharedSliceLegacy = (ctx: LegacyContentCtx) => {
 				legacyReader.decode(slice),
 				either.map((parsedSlice) => {
 					const items =
-						((() => {
+						(() => {
 							const itemsCtx = getFieldCtx("items", ctx, [
 								"variations",
 								parsedSlice.variation,
@@ -71,8 +71,7 @@ export const SharedSliceLegacy = (ctx: LegacyContentCtx) => {
 							)
 							if (!result || isLeft(result)) return
 							return result.right
-							// We don't support nested groups on shared slice items
-						})() as t.TypeOf<typeof RepeatableWidgets>) || []
+						})() || []
 
 					const primary = Object.entries(parsedSlice.primary).reduce<
 						Record<string, SlicePrimaryContent>
@@ -250,8 +249,7 @@ export function traverseSharedSliceContent({
 			path: path.concat([{ key: "items", type: "items" }]),
 			model: model?.fields.items,
 			content: content.widget.items,
-			// We don't support nested groups on shared slice items
-		})(transformWidget) as t.TypeOf<typeof RepeatableWidgets>
+		})(transformWidget)
 
 		return transformSlice({
 			key: sliceKey,

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

@@ -27,7 +27,6 @@ import type {
 	SharedSliceItemContent,
 	SimpleSliceItemContent,
 } from "../SliceItem"
-import type { RepeatableWidgets } from "./RepeatableContent"
 
 export const SimpleSliceContent = t.union([NestableContent, GroupContent])
 export type SimpleSliceContent = t.TypeOf<typeof SimpleSliceContent>
@@ -160,8 +159,7 @@ export function migrateSimpleSlice(
 							[],
 						),
 					}
-					// We don't support nested groups on simple slices
-				}, []) as t.TypeOf<typeof RepeatableWidgets>,
+				}, []),
 			},
 		}
 	}

package/src/customtypes/widgets/Group.ts

@@ -2,75 +2,48 @@ import * as t from "io-ts"
 
 import { WidgetKey } from "../../common"
 import { StringOrNull } from "../../validators"
-import { refineType } from "../../validators/function"
 import { NestableWidget } from "./nestable/NestableWidget"
 
 export const GroupFieldType = "Group"
-export const GroupConfig: t.Type<GroupConfig> = t.recursion("GroupConfig", () =>
+
+// We're obliged to use `t.Mixed` here, otherwise the factory would be
+// referencing itself and TypeScript would infer its type as `any`
+const createGroupConfig = <TWidgets extends t.Mixed>(widgets: TWidgets) =>
 	t.exact(
 		t.partial({
 			label: StringOrNull,
 			repeat: t.boolean,
-			fields: t.record(
-				WidgetKey,
-				t.union([Group, NestableWidget as t.Type<NestableWidget>]),
-			),
+			fields: t.record(WidgetKey, widgets),
 		}),
-	),
-)
-export type GroupConfig = {
-	label?: string | null | undefined
-	repeat?: boolean
-	fields?: Record<string, Group | NestableWidget>
-}
-
-const MAX_GROUP_DEPTH = 1
-const getGroupDepth = (group: Group, depth = 0): number => {
-	// Stop searching when we're over limit
-	if (depth > MAX_GROUP_DEPTH) return depth
-
-	for (const key in group.config?.fields) {
-		const field = group.config?.fields[key]
-		if (field?.type === GroupFieldType) {
-			depth = Math.max(depth, getGroupDepth(field, depth + 1))
-		}
-	}
+	)
 
-	return depth
-}
-
-export const Group: t.Type<Group> = refineType(
-	t.recursion("Group", () =>
-		t.exact(
-			t.intersection([
-				t.type({
-					type: t.literal(GroupFieldType),
-				}),
-				t.partial({
-					fieldset: StringOrNull,
-					icon: t.string,
-					description: t.string,
-					config: GroupConfig,
-				}),
-			]),
-		),
-	),
-	"Group",
-	(g) => {
-		if (getGroupDepth(g) > MAX_GROUP_DEPTH) {
-			throw new Error(
-				`Group is nested too deeply (max ${MAX_GROUP_DEPTH} level)`,
-			)
-		}
-
-		return true
-	},
+// We're obliged to use `t.Mixed` here, otherwise the factory would be
+// referencing itself and TypeScript would infer its type as `any`
+const createGroup = <TWidgets extends t.Mixed>(widgets: TWidgets) =>
+	t.exact(
+		t.intersection([
+			t.type({
+				type: t.literal(GroupFieldType),
+			}),
+			t.partial({
+				fieldset: StringOrNull,
+				icon: t.string,
+				description: t.string,
+				config: createGroupConfig(widgets),
+			}),
+		]),
+	)
+
+export const NestedGroupConfig = createGroupConfig(NestableWidget)
+export type NestedGroupConfig = t.TypeOf<typeof NestedGroupConfig>
+
+export const NestedGroup = createGroup(NestableWidget)
+export type NestedGroup = t.TypeOf<typeof NestedGroup>
+
+export const GroupConfig = createGroupConfig(
+	t.union([NestableWidget, NestedGroup]),
 )
+export type GroupConfig = t.TypeOf<typeof GroupConfig>
 
-export type Group = {
-	type: typeof GroupFieldType
-	fieldset?: string | null | undefined
-	icon?: string
-	description?: string
-	config?: GroupConfig
-}
+export const Group = createGroup(t.union([NestableWidget, NestedGroup]))
+export type Group = t.TypeOf<typeof Group>

package/src/customtypes/widgets/slices/LegacySlice.ts

@@ -1,10 +1,10 @@
 import * as t from "io-ts"
 
-import { Group } from "../Group"
+import { NestedGroup } from "../Group"
 import { NestableWidget } from "../nestable/NestableWidget"
 import type { DynamicSlice, StaticSlice } from "./Slice"
 
-export const LegacySlice = t.union([NestableWidget, Group])
+export const LegacySlice = t.union([NestableWidget, NestedGroup])
 
 export type LegacySlice = t.TypeOf<typeof LegacySlice>