@prismicio/types-internal 3.17.0 → 4.0.0-canary.65d3262

package/src/helpers/traverseContentWithModel.ts

@@ -0,0 +1,616 @@
+import type { DocumentContent } from "../content/document"
+import { GroupContentType } from "../content/group"
+import type { GroupContent, GroupItemContent } from "../content/group"
+import { isNestableContent } from "../content/nestable"
+import { isRepeatableContentValue, RepeatableContentType } from "../content/repeatable"
+import type { RepeatableContent } from "../content/repeatable"
+import { RichTextContentType } from "../content/richText"
+import { CompositeSliceContentType, SharedSliceContentType } from "../content/slice"
+import type { CompositeSliceContent, SharedSliceContent } from "../content/slice"
+import {
+	type CompositeSliceItemContent,
+	type SharedSliceItemContent,
+	type LegacySliceItemContent,
+	type SliceItemContent,
+	type SlicesContent,
+	SlicesContentType,
+} from "../content/slices"
+import { TableContentType, type TableContent } from "../content/table"
+import type { WidgetContent } from "../content/widget"
+import type { StaticCustomTypeModel } from "../model/customType"
+import type { GroupModel, NestedGroupModel } from "../model/group"
+import type { LinkModel } from "../model/link"
+import type { NestableModel } from "../model/nestable"
+import type {
+	CompositeSliceModel,
+	LegacySliceModel,
+	SharedSliceVariationContentModel,
+	SliceContentModel,
+} from "../model/slice"
+import type { StaticSlicesModel } from "../model/slices"
+import { TableCellModel } from "../model/table"
+import type { TableModel } from "../model/table"
+import type { StaticWidgetModel } from "../model/widget"
+import * as contentPath from "./contentPath"
+import * as customTypeModel from "./customTypeModel"
+
+type TraverseDocumentContentWithModelConfig = {
+	model: StaticCustomTypeModel
+	transformWidget?: TraverseWidgetContentWithModelFunction
+	transformSlice?: TraverseSliceContentWithModelFunction
+}
+
+export function traverseDocumentContentWithModel(
+	document: DocumentContent,
+	config: TraverseDocumentContentWithModelConfig,
+): DocumentContent {
+	const { model, transformWidget, transformSlice } = config
+
+	// Remove tabs from custom type model
+	const flatModel = model ? customTypeModel.flatten(model) : {}
+
+	const traversed: DocumentContent = {}
+	for (const [key, model] of Object.entries(flatModel)) {
+		const path = contentPath.make(
+			{ key: config.model.id, type: "CustomType" },
+			{ key, type: "Widget" },
+		)
+
+		const traversedContent = traverseWidgetContentWithModel(path, key, key, document[key], {
+			model,
+			transformWidget,
+			transformSlice,
+		})
+		if (traversedContent) {
+			traversed[key] = traversedContent
+		}
+	}
+
+	return traversed
+}
+
+type TraverseSlicesContentWithModelConfig = {
+	model: StaticSlicesModel
+	transformWidget?: TraverseWidgetContentWithModelFunction
+	transformSlice?: TraverseSliceContentWithModelFunction
+}
+
+export function traverseSlicesContentWithModel(
+	path: contentPath.Path,
+	key: string,
+	apiID: string,
+	content: SlicesContent | undefined,
+	config: TraverseSlicesContentWithModelConfig,
+): SlicesContent | undefined {
+	const { transformWidget = (args) => args.content, transformSlice = (args) => args.content } =
+		config
+
+	if (!content) {
+		return transformWidget({
+			path,
+			key,
+			apiID,
+			model: config.model,
+		})
+	}
+
+	const traversed: SlicesContent["value"] = []
+	for (const sliceItemContent of content.value) {
+		const sliceModel = config.model.config?.choices?.[sliceItemContent.name]
+
+		let traversedSliceItemContent: SliceItemContent | undefined
+		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 },
+					)
+				}
+			} 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 CompositeSliceItemContent,
+					{ model: sliceModel, transformWidget, transformSlice },
+				)
+			}
+		} else if (
+			sliceModel &&
+			sliceItemContent.widget.__TYPE__ !== SharedSliceContentType &&
+			sliceItemContent.widget.__TYPE__ !== CompositeSliceContentType
+		) {
+			traversedSliceItemContent = traverseLegacySliceContentWithModel(
+				path.concat({ key: sliceItemContent.key, type: "LegacySlice" }),
+				sliceItemContent.key,
+				sliceItemContent.name,
+				sliceItemContent as LegacySliceItemContent,
+				{ model: sliceModel, transformWidget, transformSlice },
+			)
+		}
+
+		if (traversedSliceItemContent) {
+			traversed.push(traversedSliceItemContent)
+		}
+	}
+
+	return transformWidget({
+		path,
+		key,
+		apiID,
+		content: { ...content, value: traversed },
+		model: config.model,
+	})
+}
+
+type TraverseSharedSliceContentWithModelConfig = {
+	model: SharedSliceVariationContentModel
+	transformWidget?: TraverseWidgetContentWithModelFunction
+	transformSlice?: TraverseSliceContentWithModelFunction
+}
+
+export function traverseSharedSliceContentWithModel(
+	path: contentPath.Path,
+	key: string,
+	apiID: string,
+	content: SharedSliceItemContent | undefined,
+	config: TraverseSharedSliceContentWithModelConfig,
+): SharedSliceItemContent | undefined {
+	if (!content) {
+		return
+	}
+
+	const { transformWidget = (args) => args.content, transformSlice = (args) => args.content } =
+		config
+
+	const traversedPrimary: SharedSliceContent["primary"] = {}
+	for (const [key, model] of Object.entries(config.model.fields.primary ?? {})) {
+		const traversedContent = traverseWidgetContentWithModel(
+			path.concat({ key: "primary", type: "primary" }, { key, type: "Widget" }),
+			key,
+			key,
+			content.widget.primary[key],
+			{ model, transformWidget },
+		)
+
+		if (
+			traversedContent &&
+			(isNestableContent(traversedContent) || traversedContent.__TYPE__ === GroupContentType)
+		) {
+			traversedPrimary[key] = traversedContent
+		}
+	}
+
+	const traversedItems = traverseGroupItemsContentWithModel(
+		path.concat({ key: "items", type: "items" }),
+		content.widget.items,
+		{ model: config.model.fields.items ?? {}, transformWidget },
+	)
+
+	return transformSlice({
+		path,
+		key,
+		apiID,
+		content: {
+			...content,
+			widget: { ...content.widget, primary: traversedPrimary, items: traversedItems },
+		},
+		model: config.model,
+	})
+}
+
+type TraverseCompositeSliceContentWithModelConfig = {
+	model: CompositeSliceModel | SharedSliceVariationContentModel
+	transformWidget?: TraverseWidgetContentWithModelFunction
+	transformSlice?: TraverseSliceContentWithModelFunction
+}
+
+export function traverseCompositeSliceContentWithModel(
+	path: contentPath.Path,
+	key: string,
+	apiID: string,
+	content: CompositeSliceItemContent | undefined,
+	config: TraverseCompositeSliceContentWithModelConfig,
+): CompositeSliceItemContent | SharedSliceItemContent | undefined {
+	if (!content) {
+		return
+	}
+
+	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(primaryModel ?? {})) {
+		const traversedContent = traverseWidgetContentWithModel(
+			path.concat({ key: "non-repeat", type: "primary" }, { key, type: "Widget" }),
+			key,
+			apiID,
+			content.widget.nonRepeat[key],
+			{ model, transformWidget },
+		)
+
+		if (traversedContent && isNestableContent(traversedContent)) {
+			traversedPrimary[key] = traversedContent
+		}
+	}
+
+	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: itemsModel ?? {}, transformWidget },
+	)
+
+	return transformSlice({
+		path,
+		key,
+		apiID,
+		content: {
+			...content,
+			widget: { ...content.widget, nonRepeat: traversedPrimary, repeat: traversedItems },
+		},
+		model: config.model,
+	})
+}
+
+type TraverseLegacySliceContentWithModelConfig = {
+	model: LegacySliceModel
+	transformWidget?: TraverseWidgetContentWithModelFunction
+	transformSlice?: TraverseSliceContentWithModelFunction
+}
+
+export function traverseLegacySliceContentWithModel(
+	path: contentPath.Path,
+	key: string,
+	apiID: string,
+	content: LegacySliceItemContent | undefined,
+	config: TraverseLegacySliceContentWithModelConfig,
+): LegacySliceItemContent | SharedSliceItemContent | undefined {
+	if (!content) {
+		return
+	}
+
+	const {
+		model,
+		transformWidget = (args) => args.content,
+		transformSlice = (args) => args.content,
+	} = config
+
+	const traversedContent = traverseWidgetContentWithModel(path, key, apiID, content.widget, {
+		model,
+		transformWidget,
+		transformSlice,
+	})
+
+	if (
+		traversedContent &&
+		(isNestableContent(traversedContent) || traversedContent.__TYPE__ === GroupContentType)
+	) {
+		return transformSlice({
+			path,
+			key,
+			apiID,
+			content: { ...content, widget: traversedContent },
+			model,
+		})
+	}
+}
+
+type TraverseGroupContentWithModelConfig = {
+	model: GroupModel
+	transformWidget: TraverseWidgetContentWithModelFunction
+}
+
+export function traverseGroupContentWithModel(
+	path: contentPath.Path,
+	key: string,
+	apiID: string,
+	content: GroupContent | undefined,
+	config: TraverseGroupContentWithModelConfig,
+): GroupContent | undefined {
+	const { model, transformWidget } = config
+
+	if (!content) {
+		return transformWidget({
+			path,
+			key,
+			apiID,
+			model,
+		})
+	}
+
+	const traversed = traverseGroupItemsContentWithModel(path, content.value, {
+		model: model.config?.fields ?? {},
+		transformWidget,
+	})
+
+	return transformWidget({
+		path,
+		key,
+		apiID,
+		content: { ...content, value: traversed },
+		model,
+	})
+}
+
+type TraverseGroupItemsContentWithModelConfig = {
+	model: Record<string, NestedGroupModel | NestableModel>
+	transformWidget: TraverseWidgetContentWithModelFunction
+}
+
+export function traverseGroupItemsContentWithModel(
+	path: contentPath.Path,
+	content: GroupItemContent[] | undefined,
+	config: TraverseGroupItemsContentWithModelConfig,
+): GroupItemContent[] {
+	const { transformWidget } = config
+
+	if (!content) {
+		return []
+	}
+
+	const traversed: GroupItemContent[] = []
+	for (const groupItemContent of content) {
+		const groupItemPath = path.concat({ key: groupItemContent.key, type: "GroupItem" })
+		const groupItemContentValue = Object.fromEntries(groupItemContent.value)
+
+		const traversedValue: GroupItemContent["value"] = []
+		for (const [key, model] of Object.entries(config.model)) {
+			const traversedContent = traverseWidgetContentWithModel(
+				groupItemPath.concat({ key, type: "Widget" }),
+				key,
+				key,
+				groupItemContentValue[key],
+				{ model, transformWidget },
+			)
+
+			if (
+				traversedContent &&
+				(isNestableContent(traversedContent) || traversedContent.__TYPE__ === GroupContentType)
+			) {
+				traversedValue.push([key, traversedContent])
+			}
+		}
+
+		traversed.push({ ...groupItemContent, value: traversedValue })
+	}
+
+	return traversed
+}
+
+type TraverseRepeatableContentWithModelConfig = {
+	model: LinkModel
+	transformWidget: TraverseWidgetContentWithModelFunction
+}
+
+export function traverseRepeatableContentWithModel(
+	path: contentPath.Path,
+	key: string,
+	apiID: string,
+	content: RepeatableContent | undefined,
+	config: TraverseRepeatableContentWithModelConfig,
+): RepeatableContent | undefined {
+	const { model, transformWidget } = config
+
+	if (!content) {
+		return transformWidget({
+			path,
+			key,
+			apiID,
+			model,
+		})
+	}
+
+	const nonRepeatModel =
+		model.type === "Link" && model.config
+			? { ...model, config: { ...model.config, repeat: false } }
+			: model
+
+	const traversed: RepeatableContent["value"] = []
+	for (let index = 0; index < content.value.length; index++) {
+		const traversedContent = traverseWidgetContentWithModel(
+			path.concat({ key: index.toString(), type: "Widget" }),
+			key,
+			apiID,
+			content.value[index],
+			{ model: nonRepeatModel, transformWidget },
+		)
+
+		if (traversedContent && isRepeatableContentValue(traversedContent)) {
+			traversed.push(traversedContent)
+		}
+	}
+
+	return transformWidget({
+		path,
+		key,
+		apiID,
+		content: { ...content, value: traversed },
+		model,
+	})
+}
+
+type TraverseTableContentWithModelConfig = {
+	model: TableModel
+	transformWidget: TraverseWidgetContentWithModelFunction
+}
+
+export function traverseTableContentWithModel(
+	path: contentPath.Path,
+	key: string,
+	apiID: string,
+	content: TableContent | undefined,
+	config: TraverseTableContentWithModelConfig,
+): TableContent | undefined {
+	const { model, transformWidget } = config
+
+	if (!content) {
+		return transformWidget({
+			path,
+			key,
+			apiID,
+			model,
+		})
+	}
+
+	const traversed: TableContent["content"] = []
+	for (let rowIndex = 0; rowIndex < content.content.length; rowIndex++) {
+		const traversedContent: TableContent["content"][number]["content"] = []
+		for (let cellIndex = 0; cellIndex < content.content[rowIndex].content.length; cellIndex++) {
+			const cellPath = path.concat({ key: [rowIndex, cellIndex].join(","), type: "Widget" })
+			const cell = content.content[rowIndex].content[cellIndex]
+
+			const transformed = transformWidget({
+				path: cellPath,
+				key,
+				apiID,
+				content: cell.content,
+				model: TableCellModel,
+			})
+
+			if (transformed && transformed.__TYPE__ === RichTextContentType) {
+				traversedContent.push({ ...cell, content: transformed })
+			} else {
+				traversedContent.push({
+					...cell,
+					content: {
+						__TYPE__: RichTextContentType,
+						value: [],
+					},
+				})
+			}
+		}
+		traversed.push({ ...content.content[rowIndex], content: traversedContent })
+	}
+
+	return transformWidget({
+		path,
+		key,
+		apiID,
+		content: { ...content, content: traversed },
+		model,
+	})
+}
+
+// Internals
+export type TraverseSliceContentWithModelFunction = <TContent extends SliceItemContent>(args: {
+	path: contentPath.Path
+	key: string
+	apiID: string
+	content?: TContent
+	model: SliceContentModel
+}) => TContent | SharedSliceItemContent | undefined
+
+export type TraverseWidgetContentWithModelFunction<
+	TContentTransformMode extends "preserve" | "widen" = "preserve",
+> = <TContent extends WidgetContent>(args: {
+	path: contentPath.Path
+	key: string
+	apiID: string
+	content?: TContent
+	model: StaticWidgetModel
+}) => (TContentTransformMode extends "preserve" ? TContent : WidgetContent) | undefined
+
+type TraverseWidgetContentWithModelConfig = {
+	model: StaticWidgetModel
+	transformWidget?: TraverseWidgetContentWithModelFunction
+	transformSlice?: TraverseSliceContentWithModelFunction
+}
+
+function traverseWidgetContentWithModel(
+	path: contentPath.Path,
+	key: string,
+	apiID: string,
+	content: WidgetContent | undefined,
+	config: TraverseWidgetContentWithModelConfig,
+): WidgetContent | undefined {
+	const {
+		model,
+		transformWidget = (args) => args.content,
+		transformSlice = (args) => args.content,
+	} = config
+
+	if (model.type === "Slices" || model.type === "Choice") {
+		const slices = content?.__TYPE__ === SlicesContentType ? content : undefined
+		return traverseSlicesContentWithModel(path, key, apiID, slices, {
+			transformWidget,
+			transformSlice,
+			model,
+		})
+	}
+
+	if (model.type === "Group") {
+		const group = content?.__TYPE__ === GroupContentType ? content : undefined
+		return traverseGroupContentWithModel(path, key, apiID, group, { transformWidget, model })
+	}
+
+	if (model.type === "Link" && model.config?.repeat) {
+		const repeatable = content?.__TYPE__ === RepeatableContentType ? content : undefined
+		return traverseRepeatableContentWithModel(path, key, apiID, repeatable, {
+			transformWidget,
+			model,
+		})
+	}
+
+	if (model.type === "Table") {
+		const table = content?.__TYPE__ === TableContentType ? content : undefined
+		return traverseTableContentWithModel(path, key, apiID, table, { transformWidget, model })
+	}
+
+	const nestable =
+		content?.__TYPE__ !== SlicesContentType &&
+		content?.__TYPE__ !== GroupContentType &&
+		content?.__TYPE__ !== RepeatableContentType &&
+		content?.__TYPE__ !== TableContentType
+			? content
+			: undefined
+	return transformWidget({ path, key, apiID, content: nestable, model })
+}