@prismicio/types-internal 4.0.0-pr.6.eb53f11 → 4.0.0-pr.7.9dec8db

package/src/content/legacy/nestable.ts

@@ -1,19 +1,31 @@
 import { z } from "zod/mini"
 
+import type { BooleanLegacy } from "./boolean"
 import { BooleanLegacySchema } from "./boolean"
+import type { EmbedLegacy } from "./embed"
 import { EmbedLegacyLooseSchema } from "./embed"
+import type { EmptyLegacy } from "./empty"
 import { EmptyLegacySchema } from "./empty"
+import type { StringLegacy } from "./field"
 import { StringLegacySchema } from "./field"
+import type { GeoPointLegacy } from "./geopoint"
 import { GeoPointLegacySchema } from "./geopoint"
+import type { ImageLegacy } from "./image"
 import { ImageLegacySchema } from "./image"
+import type { IntegrationFieldLegacy } from "./integrationField"
 import { IntegrationFieldLegacySchema } from "./integrationField"
+import type { LinkLegacy } from "./link"
 import { LinkLegacySchema } from "./link"
+import type { RepeatableLegacy } from "./repeatable"
 import { RepeatableLegacySchema } from "./repeatable"
+import type { RichTextLegacy } from "./richText"
 import { RichTextLegacySchema } from "./richText"
+import type { SeparatorLegacy } from "./separator"
 import { SeparatorLegacySchema } from "./separator"
+import type { TableLegacy } from "./table"
 import { TableLegacySchema } from "./table"
 
-export const NestableLegacySchema = z.union([
+export const NestableLegacySchema: z.ZodMiniType<NestableLegacy> = z.union([
 	EmptyLegacySchema,
 	BooleanLegacySchema,
 	EmbedLegacyLooseSchema,
@@ -28,4 +40,16 @@ export const NestableLegacySchema = z.union([
 	TableLegacySchema,
 ])
 
-export type NestableLegacy = z.infer<typeof NestableLegacySchema>
+export type NestableLegacy =
+	| EmptyLegacy
+	| BooleanLegacy
+	| EmbedLegacy
+	| StringLegacy
+	| GeoPointLegacy
+	| ImageLegacy
+	| IntegrationFieldLegacy
+	| LinkLegacy
+	| RepeatableLegacy
+	| RichTextLegacy
+	| SeparatorLegacy
+	| TableLegacy

package/src/content/legacy/repeatable.ts

@@ -1,20 +1,7 @@
 import { z } from "zod/mini"
 
-import { LinkLegacySchema } from "./link"
-
-const RepeatableLinkLegacySchema = z.pipe(
-	z.array(z.unknown()),
-	z.transform((value) =>
-		value.flatMap((item) => {
-			try {
-				return [LinkLegacySchema.parse(item)]
-			} catch {
-				return []
-			}
-		}),
-	),
-)
-
-export const RepeatableLegacySchema = RepeatableLinkLegacySchema
+// Keep the legacy schema non-lossy; item-level link decoding lives in
+// `codec/repeatable.ts`, where the field model is available.
+export const RepeatableLegacySchema = z.array(z.unknown())
 
 export type RepeatableLegacy = z.infer<typeof RepeatableLegacySchema>

package/src/content/legacy/richText.ts

@@ -4,10 +4,11 @@ import { z } from "zod/mini"
 // avoid runtime circular dependencies!
 import type { EmbedContentSchema } from "../embed"
 import type { ImageViewContentSchema } from "../image"
-import type { FilledLinkValueContentSchema } from "../link"
+import type { FilledLinkValueContent, FilledLinkValueContentSchema } from "../link"
 import { EmbedLegacyLooseSchema } from "./embed"
 import { ImageViewLegacySchema } from "./image"
 import { FilledLinkValueLegacySchema } from "./link"
+import type { FilledLinkValueLegacy } from "./link"
 
 export const RichTextNodeType = {
 	paragraph: "paragraph",
@@ -28,6 +29,13 @@ export const RichTextNodeType = {
 } as const
 
 // Spans
+type HyperlinkSpan<TData extends FilledLinkValueLegacy | FilledLinkValueContent> = {
+	type: typeof RichTextNodeType.hyperlink
+	start: number
+	end: number
+	data: TData
+}
+
 const getHyperlinkSpanSchema = <
 	TData extends typeof FilledLinkValueLegacySchema | typeof FilledLinkValueContentSchema,
 >(
@@ -40,7 +48,14 @@ const getHyperlinkSpanSchema = <
 		data,
 	})
 
-const LabelSpanSchema = z.object({
+type LabelSpan = {
+	type: "label"
+	start: number
+	end: number
+	data: string
+}
+
+const LabelSpanSchema: z.ZodMiniType<LabelSpan> = z.object({
 	type: z.literal("label"),
 	start: z.number(),
 	end: z.number(),
@@ -50,7 +65,13 @@ const LabelSpanSchema = z.object({
 	),
 })
 
-const BasicSpanSchema = z.object({
+type BasicSpan = {
+	type: typeof RichTextNodeType.strong | typeof RichTextNodeType.em | "list-item"
+	start: number
+	end: number
+}
+
+const BasicSpanSchema: z.ZodMiniType<BasicSpan> = z.object({
 	type: z.union([
 		z.literal(RichTextNodeType.strong),
 		z.literal(RichTextNodeType.em),
@@ -60,6 +81,11 @@ const BasicSpanSchema = z.object({
 	end: z.number(),
 })
 
+export type Span<TLink extends FilledLinkValueLegacy | FilledLinkValueContent> =
+	| HyperlinkSpan<TLink>
+	| LabelSpan
+	| BasicSpan
+
 // oxlint-disable-next-line explicit-module-boundary-types
 export const getSpanSchema = <
 	TLinkSchema extends typeof FilledLinkValueLegacySchema | typeof FilledLinkValueContentSchema,
@@ -114,6 +140,8 @@ export const getTextBlockSchema = <
 
 const TextBlockLegacySchema = getTextBlockSchema(FilledLinkValueLegacySchema)
 
+type TextBlockLegacy = z.infer<typeof TextBlockLegacySchema>
+
 // Image block
 
 // oxlint-disable-next-line explicit-module-boundary-types
@@ -136,6 +164,8 @@ const ImageBlockLegacySchema = getImageBlockSchema(
 	FilledLinkValueLegacySchema,
 )
 
+type ImageBlockLegacy = z.infer<typeof ImageBlockLegacySchema>
+
 // Embed block
 // oxlint-disable-next-line explicit-module-boundary-types
 export const getEmbedBlockSchema = <
@@ -152,14 +182,16 @@ export const getEmbedBlockSchema = <
 
 const EmbedBlockLegacySchema = getEmbedBlockSchema(EmbedLegacyLooseSchema)
 
+type EmbedBlockLegacy = z.infer<typeof EmbedBlockLegacySchema>
+
 // Blocks
-export const RichTextLegacyBlockSchema = z.union([
+export const RichTextLegacyBlockSchema: z.ZodMiniType<RichTextLegacyBlock> = z.union([
 	TextBlockLegacySchema,
 	ImageBlockLegacySchema,
 	EmbedBlockLegacySchema,
 ])
 
-export type RichTextLegacyBlock = z.infer<typeof RichTextLegacyBlockSchema>
+export type RichTextLegacyBlock = TextBlockLegacy | ImageBlockLegacy | EmbedBlockLegacy
 
 export const RichTextLegacySchema = z.array(RichTextLegacyBlockSchema)
 

package/src/content/legacy/slice.ts

@@ -1,7 +1,6 @@
 import { z } from "zod/mini"
 
 import { GroupItemLegacySchema, NestableAndGroupLegacySchema } from "./group"
-import { NestableLegacySchema } from "./nestable"
 
 // Legacy (before 2020)
 export const LegacySliceLegacySchema = NestableAndGroupLegacySchema
@@ -9,29 +8,31 @@ export const LegacySliceLegacySchema = NestableAndGroupLegacySchema
 export type LegacySliceLegacy = z.infer<typeof LegacySliceLegacySchema>
 
 // Composite (2020 to 2021)
+// Keep non-repeat values raw here: array-shaped legacy payloads are ambiguous until
+// `codec/slice.ts` resolves the field model and picks the right decoder.
 export const CompositeSliceLegacySchema = z.object({
-	"non-repeat": z.optional(z.record(z.string(), NestableLegacySchema)),
+	"non-repeat": z.optional(z.record(z.string(), z.unknown())),
 	repeat: z.optional(z.array(GroupItemLegacySchema)),
 })
 
 export type CompositeSliceLegacy = z.infer<typeof CompositeSliceLegacySchema>
 
 // Shared (2021 to present)
+// Keep primary values raw here: array-shaped legacy payloads are ambiguous until
+// `codec/slice.ts` resolves the field model and picks the right decoder.
 export const SharedSliceLegacySchema = z.object({
 	variation: z.string(),
-	primary: z.transform(
-		(value) => z.record(z.string(), NestableAndGroupLegacySchema).safeParse(value).data || {},
-	),
+	primary: z.transform((value) => z.record(z.string(), z.unknown()).safeParse(value).data || {}),
 	items: z.transform((value) => z.array(GroupItemLegacySchema).safeParse(value).data || []),
 })
 
 export type SharedSliceLegacy = z.infer<typeof SharedSliceLegacySchema>
 
 // All
-export const SliceLegacySchema = z.union([
+export const SliceLegacySchema: z.ZodMiniType<SliceLegacy> = z.union([
 	LegacySliceLegacySchema,
 	CompositeSliceLegacySchema,
 	SharedSliceLegacySchema,
 ])
 
-export type SliceLegacy = z.infer<typeof SliceLegacySchema>
+export type SliceLegacy = LegacySliceLegacy | CompositeSliceLegacy | SharedSliceLegacy

package/src/content/legacy/widget.ts

@@ -1,15 +1,19 @@
 import { z } from "zod/mini"
 
+import type { GroupLegacy } from "./group"
 import { GroupLegacySchema } from "./group"
+import type { NestableLegacy } from "./nestable"
 import { NestableLegacySchema } from "./nestable"
+import type { SlicesLegacy } from "./slices"
 import { SlicesLegacySchema } from "./slices"
+import type { UIDLegacy } from "./uid"
 import { UIDLegacySchema } from "./uid"
 
-export const WidgetLegacySchema = z.union([
+export const WidgetLegacySchema: z.ZodMiniType<WidgetLegacy> = z.union([
 	UIDLegacySchema,
 	GroupLegacySchema,
 	SlicesLegacySchema,
 	NestableLegacySchema,
 ])
 
-export type WidgetLegacy = z.infer<typeof WidgetLegacySchema>
+export type WidgetLegacy = UIDLegacy | GroupLegacy | SlicesLegacy | NestableLegacy

package/src/content/link.ts

@@ -63,7 +63,7 @@ const AnyLinkValueContentSchema = z.extend(AnyLinkLegacySchema, {
 // All
 
 // Used by content/richText
-export const FilledLinkValueContentSchema = z.union([
+export const FilledLinkValueContentSchema: z.ZodMiniType<FilledLinkValueContent> = z.union([
 	FilledImageLinkValueContentSchema,
 	FilledFileLinkValueContentSchema,
 	FilledDocumentLinkValueContentSchema,
@@ -71,9 +71,17 @@ export const FilledLinkValueContentSchema = z.union([
 ])
 
 // Used by content/legacy/link
-export type FilledLinkValueContent = z.infer<typeof FilledLinkValueContentSchema>
-
-const EmptyLinkValueContentSchema = z.union([
+type FilledImageLinkValueContent = z.infer<typeof FilledImageLinkValueContentSchema>
+type FilledFileLinkValueContent = z.infer<typeof FilledFileLinkValueContentSchema>
+type FilledDocumentLinkValueContent = z.infer<typeof FilledDocumentLinkValueContentSchema>
+type FilledExternalLinkValueContent = z.infer<typeof FilledExternalLinkValueContentSchema>
+export type FilledLinkValueContent =
+	| FilledImageLinkValueContent
+	| FilledFileLinkValueContent
+	| FilledDocumentLinkValueContent
+	| FilledExternalLinkValueContent
+
+const EmptyLinkValueContentSchema: z.ZodMiniType<EmptyLinkValueContent> = z.union([
 	EmptyImageLinkValueContentSchema,
 	EmptyFileLinkValueContentSchema,
 	EmptyMediaLinkValueContentSchema,
@@ -83,12 +91,27 @@ const EmptyLinkValueContentSchema = z.union([
 ])
 
 // Used by content/codec/link
-export type EmptyLinkValueContent = z.infer<typeof EmptyLinkValueContentSchema>
-
-const LinkValueContentSchema = z.union([FilledLinkValueContentSchema, EmptyLinkValueContentSchema])
+type EmptyImageLinkValueContent = z.infer<typeof EmptyImageLinkValueContentSchema>
+type EmptyFileLinkValueContent = z.infer<typeof EmptyFileLinkValueContentSchema>
+type EmptyMediaLinkValueContent = z.infer<typeof EmptyMediaLinkValueContentSchema>
+type EmptyDocumentLinkValueContent = z.infer<typeof EmptyDocumentLinkValueContentSchema>
+type EmptyExternalLinkValueContent = z.infer<typeof EmptyExternalLinkValueContentSchema>
+type AnyLinkValueContent = z.infer<typeof AnyLinkValueContentSchema>
+export type EmptyLinkValueContent =
+	| EmptyImageLinkValueContent
+	| EmptyFileLinkValueContent
+	| EmptyMediaLinkValueContent
+	| EmptyDocumentLinkValueContent
+	| EmptyExternalLinkValueContent
+	| AnyLinkValueContent
+
+const LinkValueContentSchema: z.ZodMiniType<LinkValueContent> = z.union([
+	FilledLinkValueContentSchema,
+	EmptyLinkValueContentSchema,
+])
 
 // Used by content/codec/link
-export type LinkValueContent = z.infer<typeof LinkValueContentSchema>
+export type LinkValueContent = FilledLinkValueContent | EmptyLinkValueContent
 
 // Content
 export const LinkContentType = "LinkContent" as const
@@ -117,7 +140,7 @@ export const LinkContentSchema = z.object({
 			z.object({
 				text: z.optional(z.string()),
 				variant: z.optional(z.string()),
-				value: z.union([FilledLinkValueContentSchema, EmptyLinkValueContentSchema]),
+				value: LinkValueContentSchema as z.ZodMiniType<LinkValueContent, Record<string, unknown>>,
 			}),
 		),
 		z.transform(({ text, variant, value }) => ({

package/src/content/nestable.ts

@@ -1,9 +1,21 @@
 import { z } from "zod/mini"
 
 import type { NestableModel } from "../model/nestable"
+import type { BooleanContent } from "./boolean"
 import { BooleanContentDefaultValue, BooleanContentSchema, BooleanContentType } from "./boolean"
+import type { EmbedContent } from "./embed"
 import { EmbedContentSchema, EmbedContentType } from "./embed"
+import type { EmptyContent } from "./empty"
 import { EmptyContentSchema, EmptyContentType } from "./empty"
+import type {
+	ColorContent,
+	DateContent,
+	NumberContent,
+	RangeContent,
+	SelectContent,
+	TextContent,
+	TimestampContent,
+} from "./field"
 import {
 	ColorContentSchema,
 	DateContentSchema,
@@ -15,16 +27,24 @@ import {
 	TextContentSchema,
 	TimestampContentSchema,
 } from "./field"
+import type { GeoPointContent } from "./geopoint"
 import { GeoPointContentSchema, GeoPointContentType } from "./geopoint"
+import type { ImageContent } from "./image"
 import { ImageContentSchema, ImageContentType } from "./image"
+import type { IntegrationFieldContent } from "./integrationField"
 import { IntegrationFieldContentSchema, IntegrationFieldContentType } from "./integrationField"
+import type { LinkContent } from "./link"
 import { LinkContentSchema, LinkContentType } from "./link"
+import type { RepeatableContent } from "./repeatable"
 import { RepeatableContentSchema, RepeatableContentType } from "./repeatable"
+import type { RichTextContent } from "./richText"
 import { RichTextContentSchema, RichTextContentType } from "./richText"
+import type { SeparatorContent } from "./separator"
 import { SeparatorContentSchema, SeparatorContentType } from "./separator"
+import type { TableContent } from "./table"
 import { TableContentSchema, TableContentType } from "./table"
 
-export const NestableContentSchema = z.union([
+export const NestableContentSchema: z.ZodMiniType<NestableContent> = z.union([
 	EmptyContentSchema,
 	BooleanContentSchema,
 	ColorContentSchema,
@@ -45,7 +65,25 @@ export const NestableContentSchema = z.union([
 	TimestampContentSchema,
 ])
 
-export type NestableContent = z.infer<typeof NestableContentSchema>
+export type NestableContent =
+	| EmptyContent
+	| BooleanContent
+	| ColorContent
+	| DateContent
+	| EmbedContent
+	| GeoPointContent
+	| ImageContent
+	| IntegrationFieldContent
+	| LinkContent
+	| NumberContent
+	| RangeContent
+	| RepeatableContent
+	| RichTextContent
+	| SelectContent
+	| SeparatorContent
+	| TableContent
+	| TextContent
+	| TimestampContent
 
 const NestableContentTypes = [
 	EmptyContentType,
@@ -62,6 +100,8 @@ const NestableContentTypes = [
 	TableContentType,
 ]
 type NestableContentType = (typeof NestableContentTypes)[number]
+
+/** @internal */
 export function isNestableContent(content: {
 	__TYPE__: string
 }): content is { __TYPE__: NestableContentType } {

package/src/content/richText.ts

@@ -8,35 +8,47 @@ import {
 	getSpanSchema,
 	getTextBlockSchema,
 } from "./legacy/richText"
+import type { Span } from "./legacy/richText"
+import type { FilledLinkValueContent } from "./link"
 import { FilledLinkValueContentSchema } from "./link"
 
 // Spans
-export const RichTextContentSpanSchema = getSpanSchema(FilledLinkValueContentSchema)
+export type RichTextContentSpan = Span<FilledLinkValueContent>
 
-export type RichTextContentSpan = z.infer<typeof RichTextContentSpanSchema>
+export const RichTextContentSpanSchema: z.ZodMiniType<RichTextContentSpan> = getSpanSchema(
+	FilledLinkValueContentSchema,
+)
 
 // Blocks
 const TextBlockValueSchema = getTextBlockSchema(FilledLinkValueContentSchema)
+type TextBlockValue = z.infer<typeof TextBlockValueSchema>
+
 const ImageBlockValueSchema = getImageBlockSchema(
 	ImageViewContentSchema,
 	FilledLinkValueContentSchema,
 )
+type ImageBlockValue = z.infer<typeof ImageBlockValueSchema>
+
 const EmbedBlockValueSchema = getEmbedBlockSchema(EmbedContentSchema)
+type EmbedBlockValue = z.infer<typeof EmbedBlockValueSchema>
 
-export const RichTextContentBlockSchema = z.union([
+export const RichTextContentBlockSchema: z.ZodMiniType<RichTextContentBlock> = z.union([
 	TextBlockValueSchema,
 	ImageBlockValueSchema,
 	EmbedBlockValueSchema,
 ])
 
 // Used by content/codec/richText
-export type RichTextContentBlock = z.infer<typeof RichTextContentBlockSchema>
+export type RichTextContentBlock = TextBlockValue | ImageBlockValue | EmbedBlockValue
 
 export const RichTextContentType = "StructuredTextContent" as const
 
-export const RichTextContentSchema = z.object({
+export type RichTextContent = {
+	__TYPE__: typeof RichTextContentType
+	value: RichTextContentBlock[]
+}
+
+export const RichTextContentSchema: z.ZodMiniType<RichTextContent> = z.object({
 	__TYPE__: z.literal(RichTextContentType),
 	value: z.array(RichTextContentBlockSchema),
 })
-
-export type RichTextContent = z.infer<typeof RichTextContentSchema>

package/src/content/slice.ts

@@ -32,10 +32,10 @@ export const SharedSliceContentSchema = z.object({
 export type SharedSliceContent = z.infer<typeof SharedSliceContentSchema>
 
 // All
-export const SliceContentSchema = z.union([
+export const SliceContentSchema: z.ZodMiniType<SliceContent> = z.union([
 	LegacySliceContentSchema,
 	CompositeSliceContentSchema,
 	SharedSliceContentSchema,
 ])
 
-export type SliceContent = z.infer<typeof SliceContentSchema>
+export type SliceContent = LegacySliceContent | CompositeSliceContent | SharedSliceContent

package/src/content/widget.ts

@@ -1,17 +1,21 @@
 import { z } from "zod/mini"
 
+import type { GroupContent } from "./group"
 import { GroupContentSchema } from "./group"
+import type { NestableContent } from "./nestable"
 import { NestableContentSchema } from "./nestable"
+import type { SlicesContent } from "./slices"
 import { SlicesContentSchema } from "./slices"
+import type { UIDContent } from "./uid"
 import { UIDContentSchema } from "./uid"
 
-export const WidgetContentSchema = z.union([
+export const WidgetContentSchema: z.ZodMiniType<WidgetContent> = z.union([
 	GroupContentSchema,
 	NestableContentSchema,
 	UIDContentSchema,
 	SlicesContentSchema,
 ])
 
-export type WidgetContent = z.infer<typeof WidgetContentSchema>
+export type WidgetContent = GroupContent | NestableContent | UIDContent | SlicesContent
 
 export type ContentType = WidgetContent["__TYPE__"]

package/src/helpers/customTypeModel.ts

@@ -67,3 +67,47 @@ export function collectSharedSlices(
 
 	return sharedSlices
 }
+
+export function filterMissingSharedSlices<
+	TCustomType extends StaticCustomTypeModel | CustomTypeModel,
+>(
+	customType: TCustomType,
+	sharedSlices: Map<string, SharedSliceModel> | Record<string, SharedSliceModel>,
+): TCustomType {
+	const json: TCustomType["json"] = {}
+
+	const sharedSlicesMap =
+		sharedSlices instanceof Map ? sharedSlices : new Map(Object.entries(sharedSlices))
+
+	for (const [tabKey, tab] of Object.entries(customType.json)) {
+		const tabJSON: typeof tab = {}
+		for (const [key, widget] of Object.entries(tab)) {
+			switch (widget.type) {
+				case "Slices":
+				case "Choice":
+					const choices: Required<typeof widget>["config"]["choices"] = {}
+					for (const [id, model] of Object.entries(widget.config?.choices || {})) {
+						if (model.type === "SharedSlice") {
+							if (sharedSlicesMap.get(id)) {
+								choices[id] = model
+							}
+						} else {
+							choices[id] = model
+						}
+					}
+
+					tabJSON[key] = {
+						...widget,
+						config: { ...widget.config, choices },
+					}
+					break
+				default:
+					tabJSON[key] = widget
+			}
+		}
+
+		json[tabKey] = tabJSON
+	}
+
+	return { ...customType, json }
+}

package/src/helpers/documentContent.ts

@@ -5,10 +5,15 @@ import { defaultCtx } from "../content/codec/legacyContentCtx"
 import type { DocumentContent } from "../content/document"
 import type { DocumentLegacy } from "../content/legacy/document"
 import { DocumentLegacySchema } from "../content/legacy/document"
+import { isNestableContent } from "../content/nestable"
+import type { CompositeSliceItemContent, LegacySliceItemContent } from "../content/slices"
 import type { WidgetContent } from "../content/widget"
+import type { StaticCustomTypeModel } from "../model/customType"
 import type { FieldOrSliceType } from "../model/widget"
 import { FieldOrSliceTypeSchema } from "../model/widget"
 import * as contentPath from "./contentPath"
+import * as customTypeModel from "./customTypeModel"
+import * as sliceContent from "./sliceContent"
 import { traverseDocumentContent } from "./traverseContent"
 
 export function collectWidgets<TWidgetContent extends WidgetContent>(
@@ -37,7 +42,10 @@ export function collectWidgets<TWidgetContent extends WidgetContent>(
 	return collected
 }
 
-export function fromLegacy(legacy: DocumentLegacy): DocumentContent | undefined {
+export function fromLegacy(
+	legacy: DocumentLegacy,
+	model: StaticCustomTypeModel,
+): DocumentContent | undefined {
 	const parsed = DocumentLegacySchema.safeParse(legacy)
 	if (!parsed.success) {
 		return
@@ -67,6 +75,29 @@ export function fromLegacy(legacy: DocumentLegacy): DocumentContent | undefined
 		return
 	}
 
+	const needsMigration = Object.values(customTypeModel.collectSharedSlices(model)).some((slice) =>
+		Boolean(slice.legacyPaths),
+	)
+
+	if (needsMigration) {
+		return traverseDocumentContent(result.data, {
+			model,
+			transformSlice: ({ content, model }) => {
+				if (model?.type === "SharedSlice") {
+					if (content.widget.__TYPE__ === "CompositeSliceContent") {
+						return sliceContent.compositeToShared(content as CompositeSliceItemContent, model)
+					} else if (
+						content.widget.__TYPE__ === "GroupContentType" ||
+						isNestableContent(content.widget)
+					) {
+						return sliceContent.legacyToShared(content as LegacySliceItemContent, model)
+					}
+				}
+				return content
+			},
+		})
+	}
+
 	return result.data
 }