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

package/src/helpers/sliceContent.ts

@@ -0,0 +1,86 @@
+import type { GroupItemContent } from "../content/group"
+import type { SharedSliceContent } from "../content/slice"
+import type {
+	CompositeSliceItemContent,
+	LegacySliceItemContent,
+	SharedSliceItemContent,
+} from "../content/slices"
+import type { SharedSliceVariationContentModel } from "../model/slice"
+
+export const legacyToShared = (
+	content: LegacySliceItemContent,
+	model: SharedSliceVariationContentModel,
+): SharedSliceItemContent => {
+	const sliceUUID = content.key.split("$")[1]
+
+	const primary: SharedSliceContent["primary"] = {}
+	const items: SharedSliceContent["items"] = []
+	if (content.widget.__TYPE__ === "GroupContentType") {
+		// Group content
+		for (const item of content.widget.value) {
+			const value: GroupItemContent["value"] = []
+
+			for (const [key, nestable] of item.value) {
+				if (model.fields.items?.[key]) {
+					value.push([key, nestable])
+				}
+			}
+
+			items.push({ ...item, value })
+		}
+	} else if (model.fields.primary?.[content.name]) {
+		// Nestable content
+		primary[content.name] = content.widget
+	}
+
+	return {
+		key: `${model.sliceName}$${sliceUUID}`,
+		name: model.sliceName,
+		maybeLabel: content.maybeLabel,
+		widget: {
+			__TYPE__: "SharedSliceContent",
+			variation: model.variationID,
+			primary,
+			items,
+		},
+	}
+}
+
+export const compositeToShared = (
+	content: CompositeSliceItemContent,
+	model: SharedSliceVariationContentModel,
+): SharedSliceItemContent => {
+	const sliceUUID = content.key.split("$")[1]
+
+	const primary: SharedSliceContent["primary"] = {}
+	for (const [key, value] of Object.entries(content.widget.nonRepeat)) {
+		if (model.fields.primary?.[key]) {
+			primary[key] = value
+		}
+	}
+
+	const items: SharedSliceContent["items"] = []
+	for (const item of content.widget.repeat) {
+		const value: GroupItemContent["value"] = []
+
+		for (const [key, nestable] of item.value) {
+			if (model.fields.items?.[key]) {
+				value.push([key, nestable])
+			}
+		}
+
+		items.push({ ...item, value })
+	}
+
+	return {
+		key: `${model.sliceName}$${sliceUUID}`,
+		name: model.sliceName,
+		maybeLabel: content.maybeLabel,
+		widget: {
+			__TYPE__: "SharedSliceContent",
+			variation: model.variationID,
+			primary,
+			items,
+		},
+	}
+}

package/src/helpers/traverseContent.ts

@@ -24,7 +24,9 @@ import type { NestableModel } from "../model/nestable"
 import type {
 	CompositeSliceModel,
 	LegacySliceModel,
-	SharedSliceVariationModel,
+	SharedSliceModel,
+	SharedSliceVariationContentModel,
+	SliceContentModel,
 } from "../model/slice"
 import type { StaticSlicesModel } from "../model/slices"
 import { TableCellModel } from "../model/table"
@@ -88,27 +90,67 @@ export function traverseSlicesContent(
 	for (const sliceItemContent of content.value) {
 		const sliceModel = config.model?.config?.choices?.[sliceItemContent.name]
 
-		let traversedSliceItemContent: SliceItemContent | undefined
-		if (sliceItemContent.widget.__TYPE__ === SharedSliceContentType) {
-			let model: SharedSliceVariationModel | undefined
-			if (sliceModel?.type === "SharedSlice") {
-				const variationID = sliceItemContent.widget.variation
-				const variationModel = sliceModel.variations.find(
-					(variation) => variation.id === variationID,
-				)
-				if (variationModel) {
-					model = {
+		let sliceContentModel: SliceContentModel | undefined
+
+		// Happy path, content and model are both shared slices
+		if (
+			sliceItemContent.widget.__TYPE__ === SharedSliceContentType &&
+			sliceModel?.type === "SharedSlice"
+		) {
+			const variationID = sliceItemContent.widget.variation
+			const variationModel = sliceModel.variations.find((variation) => variation.id === variationID)
+			if (variationModel) {
+				sliceContentModel = {
+					type: "SharedSlice",
+					sliceName: sliceModel.id,
+					variationID: variationModel.id,
+					fields: {
+						primary: variationModel.primary || {},
+						items: variationModel.items || {},
+					},
+				}
+			}
+		}
+
+		// Migrated path, content is composite or legacy, model is shared slice
+		if (!sliceContentModel) {
+			const legacyPath = contentPath.append(contentPath.serialize(path), sliceItemContent.name)
+
+			// Find the migrated slice model who's legacy path matches the content path
+			const migratedSliceModel = Object.values(config.model?.config?.choices || {}).find(
+				(model): model is SharedSliceModel => {
+					return model.type === "SharedSlice" && Boolean(model.legacyPaths?.[legacyPath])
+				},
+			)
+
+			if (migratedSliceModel) {
+				// Find the variation that matches the legacy path
+				const variation = migratedSliceModel.variations.find((variation) => {
+					return variation.id === migratedSliceModel.legacyPaths?.[legacyPath]
+				})
+
+				if (variation) {
+					sliceContentModel = {
 						type: "SharedSlice",
-						sliceName: sliceModel.id,
-						variationID,
+						sliceName: migratedSliceModel.id,
+						variationID: variation.id,
 						fields: {
-							primary: variationModel.primary || {},
-							items: variationModel.items || {},
+							primary: variation.primary || {},
+							items: variation.items || {},
 						},
 					}
 				}
 			}
+		}
+
+		// Non-migrated path, content and model are composite or legacy
+		if (!sliceContentModel && sliceModel && sliceModel.type !== "SharedSlice") {
+			sliceContentModel = sliceModel
+		}
 
+		let traversedSliceItemContent: SliceItemContent | undefined
+		if (sliceItemContent.widget.__TYPE__ === SharedSliceContentType) {
+			const model = sliceContentModel?.type === "SharedSlice" ? sliceContentModel : undefined
 			traversedSliceItemContent = traverseSharedSliceContent(
 				path.concat({ key: sliceItemContent.key, type: "SharedSlice" }),
 				sliceItemContent.key,
@@ -117,7 +159,10 @@ export function traverseSlicesContent(
 				{ model, transformWidget, transformSlice },
 			)
 		} else if (sliceItemContent.widget.__TYPE__ === CompositeSliceContentType) {
-			const model = sliceModel?.type === "Slice" ? sliceModel : undefined
+			const model =
+				sliceContentModel?.type === "Slice" || sliceContentModel?.type === "SharedSlice"
+					? sliceContentModel
+					: undefined
 			traversedSliceItemContent = traverseCompositeSliceContent(
 				path.concat({ key: sliceItemContent.key, type: "Slice" }),
 				sliceItemContent.key,
@@ -126,8 +171,7 @@ export function traverseSlicesContent(
 				{ model, transformWidget, transformSlice },
 			)
 		} else {
-			const model =
-				sliceModel?.type !== "SharedSlice" && sliceModel?.type !== "Slice" ? sliceModel : undefined
+			const model = sliceContentModel?.type !== "Slice" ? sliceContentModel : undefined
 			traversedSliceItemContent = traverseLegacySliceContent(
 				path.concat({ key: sliceItemContent.key, type: "LegacySlice" }),
 				sliceItemContent.key,
@@ -152,7 +196,7 @@ export function traverseSlicesContent(
 }
 
 type TraverseSharedSliceContentConfig = {
-	model?: SharedSliceVariationModel
+	model?: SharedSliceVariationContentModel
 	transformWidget?: TraverseWidgetContentFunction
 	transformSlice?: TraverseSliceContentFunction
 }
@@ -206,7 +250,7 @@ export function traverseSharedSliceContent(
 }
 
 type TraverseCompositeSliceContentConfig = {
-	model?: CompositeSliceModel
+	model?: CompositeSliceModel | SharedSliceVariationContentModel
 	transformWidget?: TraverseWidgetContentFunction
 	transformSlice?: TraverseSliceContentFunction
 }
@@ -217,20 +261,22 @@ export function traverseCompositeSliceContent(
 	apiID: string,
 	content: CompositeSliceItemContent,
 	config: TraverseCompositeSliceContentConfig,
-): CompositeSliceItemContent | undefined {
+): CompositeSliceItemContent | SharedSliceItemContent | undefined {
 	const { transformWidget = (args) => args.content, transformSlice = (args) => args.content } =
 		config
 
+	const primaryModel =
+		config.model?.type === "SharedSlice"
+			? config.model?.fields.primary
+			: config.model?.["non-repeat"]
 	const traversedPrimary: CompositeSliceContent["nonRepeat"] = {}
 	for (const [key, fieldContent] of Object.entries(content.widget.nonRepeat)) {
-		const model = config.model?.["non-repeat"]?.[key]
-
 		const traversedContent = traverseWidgetContent(
 			path.concat({ key: "non-repeat", type: "primary" }, { key, type: "Widget" }),
 			key,
 			apiID,
 			fieldContent,
-			{ model, transformWidget },
+			{ model: primaryModel?.[key], transformWidget },
 		)
 
 		if (traversedContent && isNestableContent(traversedContent)) {
@@ -238,10 +284,12 @@ export function traverseCompositeSliceContent(
 		}
 	}
 
+	const itemsModel =
+		config.model?.type === "SharedSlice" ? config.model?.fields.items : config.model?.repeat
 	const traversedItems = traverseGroupItemsContent(
 		path.concat({ key: "repeat", type: "items" }),
 		content.widget.repeat,
-		{ model: config.model?.repeat, transformWidget },
+		{ model: itemsModel, transformWidget },
 	)
 
 	return transformSlice({
@@ -257,7 +305,7 @@ export function traverseCompositeSliceContent(
 }
 
 type TraverseLegacySliceContentConfig = {
-	model?: LegacySliceModel
+	model?: LegacySliceModel | SharedSliceVariationContentModel
 	transformWidget?: TraverseWidgetContentFunction
 	transformSlice?: TraverseSliceContentFunction
 }
@@ -268,15 +316,30 @@ export function traverseLegacySliceContent(
 	apiID: string,
 	content: LegacySliceItemContent,
 	config: TraverseLegacySliceContentConfig,
-): LegacySliceItemContent | undefined {
+): LegacySliceItemContent | SharedSliceItemContent | undefined {
 	const {
 		model,
 		transformWidget = (args) => args.content,
 		transformSlice = (args) => args.content,
 	} = config
 
+	let legacySliceModel: LegacySliceModel | undefined
+	if (content.widget.__TYPE__ === "GroupContentType") {
+		if (model?.type === "Group") {
+			legacySliceModel = model
+		} else if (model?.type === "SharedSlice") {
+			legacySliceModel = { type: "Group", config: { fields: model.fields.items } }
+		}
+	} else {
+		if (model?.type === "SharedSlice") {
+			legacySliceModel = model.fields.primary?.[content.name]
+		} else if (model?.type !== "Group") {
+			legacySliceModel = model
+		}
+	}
+
 	const traversedContent = traverseWidgetContent(path, key, apiID, content.widget, {
-		model,
+		model: legacySliceModel,
 		transformWidget,
 		transformSlice,
 	})
@@ -465,8 +528,8 @@ export type TraverseSliceContentFunction = <TContent extends SliceItemContent>(a
 	key: string
 	apiID: string
 	content: TContent
-	model?: SliceModel
-}) => TContent | undefined
+	model?: SliceContentModel
+}) => TContent | SharedSliceItemContent | undefined
 
 export type TraverseWidgetContentFunction<
 	TContentTransformMode extends "preserve" | "widen" = "preserve",
@@ -479,8 +542,6 @@ export type TraverseWidgetContentFunction<
 }) => (TContentTransformMode extends "preserve" ? TContent : WidgetContent) | undefined
 
 // Internals
-type SliceModel = SharedSliceVariationModel | CompositeSliceModel | LegacySliceModel
-
 type TraverseWidgetContentConfig = {
 	model?: StaticWidgetModel
 	transformWidget?: TraverseWidgetContentFunction

package/src/helpers/traverseContentWithModel.ts

@@ -24,7 +24,8 @@ import type { NestableModel } from "../model/nestable"
 import type {
 	CompositeSliceModel,
 	LegacySliceModel,
-	SharedSliceVariationModel,
+	SharedSliceVariationContentModel,
+	SliceContentModel,
 } from "../model/slice"
 import type { StaticSlicesModel } from "../model/slices"
 import { TableCellModel } from "../model/table"
@@ -95,49 +96,70 @@ export function traverseSlicesContentWithModel(
 
 	const traversed: SlicesContent["value"] = []
 	for (const sliceItemContent of content.value) {
-		const model = config.model.config?.choices?.[sliceItemContent.name]
+		const sliceModel = config.model.config?.choices?.[sliceItemContent.name]
 
 		let traversedSliceItemContent: SliceItemContent | undefined
-		if (
-			model?.type === "SharedSlice" &&
-			sliceItemContent.widget.__TYPE__ === SharedSliceContentType
-		) {
-			const variationID = sliceItemContent.widget.variation
-			const variationModel = model.variations.find((variation) => variation.id === variationID)
-			if (variationModel) {
-				const sharedSliceVariationModel: SharedSliceVariationModel = {
-					type: "SharedSlice",
-					sliceName: model.id,
-					variationID,
-					fields: {
-						primary: variationModel.primary || {},
-						items: variationModel.items || {},
-					},
+		if (sliceModel?.type === "SharedSlice") {
+			if (sliceItemContent.widget.__TYPE__ === SharedSliceContentType) {
+				// Happy path, content and model are both shared slices
+				const variationID = sliceItemContent.widget.variation
+				const variationModel = sliceModel.variations.find(
+					(variation) => variation.id === variationID,
+				)
+				if (variationModel) {
+					const model: SharedSliceVariationContentModel = {
+						type: "SharedSlice",
+						sliceName: sliceModel.id,
+						variationID: variationModel.id,
+						fields: {
+							primary: variationModel.primary || {},
+							items: variationModel.items || {},
+						},
+					}
+
+					traversedSliceItemContent = traverseSharedSliceContentWithModel(
+						path.concat({ key: sliceItemContent.key, type: "SharedSlice" }),
+						sliceItemContent.key,
+						sliceItemContent.name,
+						sliceItemContent as SharedSliceItemContent,
+						{ model, transformWidget, transformSlice },
+					)
 				}
-
-				traversedSliceItemContent = traverseSharedSliceContentWithModel(
-					path.concat({ key: sliceItemContent.key, type: "SharedSlice" }),
+			} else if (sliceItemContent.widget.__TYPE__ === CompositeSliceContentType) {
+				// Migrated path, content is composite, model is shared slice
+				const variationModel = sliceModel.variations[0]
+				if (variationModel) {
+					const model: SharedSliceVariationContentModel = {
+						type: "SharedSlice",
+						sliceName: sliceModel.id,
+						variationID: variationModel.id,
+						fields: {
+							primary: variationModel.primary || {},
+							items: variationModel.items || {},
+						},
+					}
+
+					traversedSliceItemContent = traverseCompositeSliceContentWithModel(
+						path.concat({ key: sliceItemContent.key, type: "Slice" }),
+						sliceItemContent.key,
+						sliceItemContent.name,
+						sliceItemContent as CompositeSliceItemContent,
+						{ model, transformWidget, transformSlice },
+					)
+				}
+			}
+		} else if (sliceModel?.type === "Slice") {
+			if (sliceItemContent.widget.__TYPE__ === CompositeSliceContentType) {
+				traversedSliceItemContent = traverseCompositeSliceContentWithModel(
+					path.concat({ key: sliceItemContent.key, type: "Slice" }),
 					sliceItemContent.key,
 					sliceItemContent.name,
-					sliceItemContent as SharedSliceItemContent,
-					{ model: sharedSliceVariationModel, transformWidget, transformSlice },
+					sliceItemContent as CompositeSliceItemContent,
+					{ model: sliceModel, transformWidget, transformSlice },
 				)
 			}
 		} else if (
-			model?.type === "Slice" &&
-			sliceItemContent.widget.__TYPE__ === CompositeSliceContentType
-		) {
-			traversedSliceItemContent = traverseCompositeSliceContentWithModel(
-				path.concat({ key: sliceItemContent.key, type: "Slice" }),
-				sliceItemContent.key,
-				sliceItemContent.name,
-				sliceItemContent as CompositeSliceItemContent,
-				{ model, transformWidget, transformSlice },
-			)
-		} else if (
-			model &&
-			model?.type !== "SharedSlice" &&
-			model?.type !== "Slice" &&
+			sliceModel &&
 			sliceItemContent.widget.__TYPE__ !== SharedSliceContentType &&
 			sliceItemContent.widget.__TYPE__ !== CompositeSliceContentType
 		) {
@@ -146,7 +168,7 @@ export function traverseSlicesContentWithModel(
 				sliceItemContent.key,
 				sliceItemContent.name,
 				sliceItemContent as LegacySliceItemContent,
-				{ model, transformWidget, transformSlice },
+				{ model: sliceModel, transformWidget, transformSlice },
 			)
 		}
 
@@ -165,7 +187,7 @@ export function traverseSlicesContentWithModel(
 }
 
 type TraverseSharedSliceContentWithModelConfig = {
-	model: SharedSliceVariationModel
+	model: SharedSliceVariationContentModel
 	transformWidget?: TraverseWidgetContentWithModelFunction
 	transformSlice?: TraverseSliceContentWithModelFunction
 }
@@ -221,7 +243,7 @@ export function traverseSharedSliceContentWithModel(
 }
 
 type TraverseCompositeSliceContentWithModelConfig = {
-	model: CompositeSliceModel
+	model: CompositeSliceModel | SharedSliceVariationContentModel
 	transformWidget?: TraverseWidgetContentWithModelFunction
 	transformSlice?: TraverseSliceContentWithModelFunction
 }
@@ -232,7 +254,7 @@ export function traverseCompositeSliceContentWithModel(
 	apiID: string,
 	content: CompositeSliceItemContent | undefined,
 	config: TraverseCompositeSliceContentWithModelConfig,
-): CompositeSliceItemContent | undefined {
+): CompositeSliceItemContent | SharedSliceItemContent | undefined {
 	if (!content) {
 		return
 	}
@@ -240,8 +262,12 @@ export function traverseCompositeSliceContentWithModel(
 	const { transformWidget = (args) => args.content, transformSlice = (args) => args.content } =
 		config
 
+	const primaryModel =
+		config.model?.type === "SharedSlice"
+			? config.model?.fields.primary
+			: config.model?.["non-repeat"]
 	const traversedPrimary: CompositeSliceContent["nonRepeat"] = {}
-	for (const [key, model] of Object.entries(config.model?.["non-repeat"] ?? {})) {
+	for (const [key, model] of Object.entries(primaryModel ?? {})) {
 		const traversedContent = traverseWidgetContentWithModel(
 			path.concat({ key: "non-repeat", type: "primary" }, { key, type: "Widget" }),
 			key,
@@ -255,10 +281,12 @@ export function traverseCompositeSliceContentWithModel(
 		}
 	}
 
+	const itemsModel =
+		config.model?.type === "SharedSlice" ? config.model?.fields.items : config.model?.repeat
 	const traversedItems = traverseGroupItemsContentWithModel(
 		path.concat({ key: "repeat", type: "items" }),
 		content.widget.repeat,
-		{ model: config.model.repeat ?? {}, transformWidget },
+		{ model: itemsModel ?? {}, transformWidget },
 	)
 
 	return transformSlice({
@@ -285,7 +313,7 @@ export function traverseLegacySliceContentWithModel(
 	apiID: string,
 	content: LegacySliceItemContent | undefined,
 	config: TraverseLegacySliceContentWithModelConfig,
-): LegacySliceItemContent | undefined {
+): LegacySliceItemContent | SharedSliceItemContent | undefined {
 	if (!content) {
 		return
 	}
@@ -513,16 +541,13 @@ export function traverseTableContentWithModel(
 }
 
 // Internals
-
-type SliceModel = SharedSliceVariationModel | CompositeSliceModel | LegacySliceModel
-
 export type TraverseSliceContentWithModelFunction = <TContent extends SliceItemContent>(args: {
 	path: contentPath.Path
 	key: string
 	apiID: string
 	content?: TContent
-	model: SliceModel
-}) => TContent | undefined
+	model: SliceContentModel
+}) => TContent | SharedSliceItemContent | undefined
 
 export type TraverseWidgetContentWithModelFunction<
 	TContentTransformMode extends "preserve" | "widen" = "preserve",

package/src/index.ts

@@ -69,13 +69,15 @@ export type {
 	CompositeSliceModel,
 	SharedSliceModel,
 	SharedSliceRefModel,
-	SharedSliceVariationModel,
+	SharedSliceVariationContentModel as SharedSliceVariationModel,
 	StaticSliceModel,
 	DynamicSliceModel,
+	SliceContentModel,
 	SliceModelType,
 } from "./model/slice"
 export type { DynamicSlicesModel, StaticSlicesModel } from "./model/slices"
 export type { TableModel } from "./model/table"
+export { TableCellModelNodeTypes } from "./model/table"
 export type { TextModel } from "./model/text"
 export type { TimestampModel } from "./model/timestamp"
 export type { UIDModel } from "./model/uid"
@@ -88,6 +90,7 @@ export { LegacyContentCtx, getFieldCtx, defaultCtx } from "./content/codec/legac
 export * as contentPath from "./helpers/contentPath"
 export * as customTypeModel from "./helpers/customTypeModel"
 export * as documentContent from "./helpers/documentContent"
+export * as sliceContent from "./helpers/sliceContent"
 export {
 	traverseDocumentContent,
 	traverseSlicesContent,