@prismicio/types-internal 2.2.0-traverse.alpha-1 → 2.2.0-traverse.alpha-3

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

@@ -2,13 +2,22 @@ import { either } from "fp-ts"
 import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
-import type { ContentPath, TraverseContentFn } from "../../../_internal/utils"
 import {
-	type StaticSlice,
+	ContentPath,
+	SliceModel,
+	TraverseSliceContentFn,
+	TraverseWidgetContentFn,
+} from "../../../_internal/utils"
+import {
 	type StaticSlices,
+	CompositeSliceFields,
+	Group,
 	isCompositeSlice,
 	isLegacySlice,
 	isStaticSharedSlice,
+	NestableWidget,
+	SharedSlice,
+	VariationFields,
 } from "../../../customtypes"
 import type {
 	FieldOrSliceType,
@@ -16,10 +25,16 @@ import type {
 	WithTypes,
 } from "../../LegacyContentCtx"
 import { hasContentType } from "../../utils"
-import { traverseGroupContent } from "../GroupContent"
 import { traverseCompositeSliceContent } from "./Slice/CompositeSliceContent"
 import { traverseSharedSliceContent } from "./Slice/SharedSliceContent"
-import { SliceItemContent, SlicesItemLegacy } from "./SliceItem"
+import { traverseSimpleSliceContent } from "./Slice/SimpleSliceContent"
+import {
+	isCompositeSliceItemContent,
+	isSharedSliceItemContent,
+	isSimpleSliceItemContent,
+	SliceItemContent,
+	SlicesItemLegacy,
+} from "./SliceItem"
 
 export const SlicesContentType = "SliceContentType"
 
@@ -66,85 +81,175 @@ export const SlicesContent = t.type({
 
 export type SlicesContent = t.TypeOf<typeof SlicesContent>
 
+function findSliceModel(
+	slicesPath: ContentPath,
+	model: StaticSlices,
+	content: SliceItemContent,
+): SliceModel | undefined {
+	const defaultModel = model?.config?.choices?.[content.name]
+
+	// regular case for shared slices
+	const sharedSliceModel = (): VariationFields | undefined => {
+		if (isSharedSliceItemContent(content)) {
+			if (defaultModel && isStaticSharedSlice(defaultModel)) {
+				const variationDef = defaultModel.variations.find(
+					(v) => v.id === content.widget.variation,
+				)
+				return variationDef
+					? {
+							type: "SharedSlice",
+							sliceName: defaultModel.id,
+							variationId: variationDef.id,
+							fields: {
+								primary: variationDef.primary || {},
+								items: variationDef.items || {},
+							},
+					  }
+					: undefined
+			}
+		}
+		return
+	}
+
+	const migratedSliceModel = (): VariationFields | undefined => {
+		const legacyContentPath = ContentPath.append(
+			ContentPath.serialize(slicesPath),
+			content.name,
+		)
+
+		const migratedSliceModel = Object.values(model?.config?.choices || {}).find(
+			(sliceModel): sliceModel is SharedSlice => {
+				if (isStaticSharedSlice(sliceModel)) {
+					return !!sliceModel.legacyPaths?.[legacyContentPath]
+				}
+
+				return false
+			},
+		)
+		if (!migratedSliceModel) return
+
+		const migratedVariation = migratedSliceModel?.variations.find(
+			(v) => v.id === migratedSliceModel.legacyPaths?.[legacyContentPath],
+		)
+		if (!migratedVariation) return
+
+		return {
+			type: "SharedSlice",
+			sliceName: migratedSliceModel.id,
+			variationId: migratedVariation.id,
+			fields: {
+				primary: migratedVariation.primary || {},
+				items: migratedVariation.items || {},
+			},
+		}
+	}
+
+	const legacySliceModel = ():
+		| NestableWidget
+		| CompositeSliceFields
+		| Group
+		| undefined => {
+		if (!defaultModel) return
+
+		if (isCompositeSlice(defaultModel)) {
+			return {
+				type: "Slice",
+				fields: {
+					"non-repeat": defaultModel["non-repeat"] || {},
+					repeat: defaultModel.repeat || {},
+				},
+			}
+		}
+		if (isLegacySlice(defaultModel)) {
+			return defaultModel
+		}
+
+		return
+	}
+	return sharedSliceModel() || migratedSliceModel() || legacySliceModel()
+}
+
 export function traverseSlices({
 	path,
+	key,
 	model,
 	content,
 }: {
 	path: ContentPath
+	key: string
 	content: SlicesContent
 	model?: StaticSlices | undefined
 }) {
-	return (transform: TraverseContentFn): SlicesContent => {
+	return (
+		transformWidget: TraverseWidgetContentFn,
+		transformSlice: TraverseSliceContentFn,
+	): SlicesContent | undefined => {
 		const value = content.value.reduce<SlicesContent["value"]>(
 			(acc, sliceContent) => {
-				const sliceModel: StaticSlice | undefined =
-					model?.config?.choices?.[sliceContent.name]
-
-				const slicePath = path.concat({
-					key: sliceContent.key,
-					type: sliceContent.widget.__TYPE__,
-				})
-
-				const convertedSliceWidget = (() => {
-					switch (sliceContent.widget.__TYPE__) {
-						case "SharedSliceContent":
-							return traverseSharedSliceContent({
-								path: slicePath,
-								sliceName: sliceContent.name,
-								model:
-									sliceModel && isStaticSharedSlice(sliceModel)
-										? sliceModel
-										: undefined,
-								content: sliceContent.widget,
-							})(transform)
-						case "CompositeSliceContent":
-							return traverseCompositeSliceContent({
-								path: slicePath,
-								sliceName: sliceContent.name,
-								model:
-									sliceModel && isCompositeSlice(sliceModel)
-										? sliceModel
-										: undefined,
-								content: sliceContent.widget,
-							})(transform)
-						case "GroupContentType":
-							return traverseGroupContent({
-								path: slicePath,
-								model:
-									sliceModel &&
-									isLegacySlice(sliceModel) &&
-									sliceModel.type === "Group"
-										? sliceModel
-										: undefined,
-								content: sliceContent.widget,
-							})(transform)
-						default:
-							return sliceContent.widget
-					}
+				const sliceModel = model && findSliceModel(path, model, sliceContent)
+
+				const convertedSlice: SliceItemContent | undefined = (() => {
+					if (isSharedSliceItemContent(sliceContent))
+						return traverseSharedSliceContent({
+							path: path.concat({
+								key: sliceContent.key,
+								type: "SharedSlice",
+							}),
+							sliceKey: sliceContent.key,
+							sliceName: sliceContent.name,
+							model:
+								sliceModel?.type === "SharedSlice" ? sliceModel : undefined,
+							content: sliceContent,
+						})(transformWidget, transformSlice)
+
+					if (isCompositeSliceItemContent(sliceContent))
+						return traverseCompositeSliceContent({
+							path: path.concat({
+								key: sliceContent.key,
+								type: "Slice",
+							}),
+							sliceKey: sliceContent.key,
+							sliceName: sliceContent.name,
+							model:
+								sliceModel?.type === "Slice" ||
+								sliceModel?.type === "SharedSlice"
+									? sliceModel
+									: undefined,
+							content: sliceContent,
+						})(transformWidget, transformSlice)
+
+					if (isSimpleSliceItemContent(sliceContent))
+						return traverseSimpleSliceContent({
+							path: path.concat({
+								key: sliceContent.key,
+								type: "LegacySlice",
+							}),
+							sliceKey: sliceContent.key,
+							sliceName: sliceContent.name,
+							model:
+								sliceModel && sliceModel?.type !== "Slice"
+									? sliceModel
+									: undefined,
+							content: sliceContent,
+						})(transformWidget, transformSlice)
+
+					return
 				})()
 
-				const convertedSlice = transform({
-					key: sliceContent.key,
-					apiId: sliceContent.name,
-					path: slicePath,
-					model: sliceModel,
-					content: convertedSliceWidget,
-				})
-
-				const convertedSliceParent = convertedSlice && {
-					...sliceContent,
-					widget: convertedSlice,
-				}
-
-				return convertedSliceParent ? acc.concat(convertedSliceParent) : acc
+				return convertedSlice ? acc.concat(convertedSlice) : acc
 			},
 			[],
 		)
 
-		return {
-			__TYPE__: content.__TYPE__,
-			value,
-		}
+		return transformWidget({
+			path,
+			key,
+			apiId: key,
+			model,
+			content: {
+				__TYPE__: content.__TYPE__,
+				value,
+			},
+		})
 	}
 }

package/src/customtypes/CustomType.ts

@@ -215,7 +215,7 @@ export function filterMissingSharedSlices(
 
 export function flattenCustomTypeFields(
 	customType: StaticCustomType,
-): Partial<Record<string, StaticWidget>> {
+): Record<string, StaticWidget> {
 	return Object.values(customType.json).reduce(
 		(acc, tab) => ({
 			...acc,
@@ -224,3 +224,25 @@ export function flattenCustomTypeFields(
 		{},
 	)
 }
+
+export function collectSharedSlices(customType: {
+	customTypeId: string
+	fields: Record<string, StaticWidget>
+}): Record<string, SharedSlice> {
+	return Object.entries(customType.fields).reduce((acc, [, w]) => {
+		if (w.type === "Slices" || w.type === "Choice") {
+			return {
+				...acc,
+				...Object.entries(w.config?.choices || {}).reduce(
+					(sliceZoneAcc, [sliceKey, sliceModel]) => {
+						return sliceModel.type === "SharedSlice"
+							? { ...sliceZoneAcc, [sliceKey]: sliceModel }
+							: sliceZoneAcc
+					},
+					{},
+				),
+			}
+		}
+		return acc
+	}, {})
+}

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

@@ -1,5 +1,6 @@
 import * as t from "io-ts"
 
+import type { PickOnly } from "../../../_internal/utils"
 import { WidgetKey } from "../../../common"
 import { StringOrNull } from "../../../validators"
 import { NestableWidget } from "../nestable/NestableWidget"
@@ -32,6 +33,11 @@ export const CompositeSlice = t.exact(
 )
 export type CompositeSlice = t.TypeOf<typeof CompositeSlice>
 
+export type CompositeSliceFields = {
+	type: "Slice"
+	fields: PickOnly<CompositeSlice, "non-repeat" | "repeat">
+}
+
 export function isCompositeSlice(
 	slice: DynamicSlice | StaticSlice,
 ): slice is CompositeSlice {

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

@@ -1,6 +1,7 @@
 import * as t from "io-ts"
 import { withFallback } from "io-ts-types/lib/withFallback"
 
+import type { PickOnly } from "../../../_internal/utils"
 import { WidgetKey } from "../../../common"
 import { NestableWidget } from "../nestable/NestableWidget"
 import type { SharedSliceRef } from "./SharedSliceRef"
@@ -29,8 +30,18 @@ export const Variation = t.exact(
 
 export type Variation = t.TypeOf<typeof Variation>
 
+export type VariationFields = {
+	type: "SharedSlice"
+	sliceName: string
+	variationId: string
+	fields: PickOnly<Variation, "primary" | "items">
+}
+
 export const SharedSliceType = "SharedSlice"
 
+const LegacyPath = t.string
+const VariationId = t.string
+
 export const SharedSlice = t.exact(
 	t.intersection([
 		t.type({
@@ -41,6 +52,7 @@ export const SharedSlice = t.exact(
 		}),
 		t.partial({
 			description: t.string,
+			legacyPaths: t.record(LegacyPath, VariationId),
 		}),
 	]),
 )

package/src/import/converters/fields/nestable/Image.ts

@@ -1,11 +1,28 @@
 import type { Asset } from "../../../../common"
 import { getAssetOrThrow } from "../../../../common"
-import type { ImageContent } from "../../../../content"
+import type { ImageContent, ImageContentView } from "../../../../content"
 import { withOptionals } from "../../../../utils/Objects"
 import type { ImageField, ImportImage } from "../../../validators"
+import type { ImportImageBlock } from "../../../validators/fields/nestable/ImportRichText/blocks"
 
-function convertImage(imageField: ImageField, image: Asset) {
-	return withOptionals<Omit<ImageContent, "__TYPE__" | "thumbnails">>(
+function convertImage<Input extends ImageField | ImportImageBlock>(
+	inputImage: Input,
+	image: Asset,
+) {
+	// We can do that because anyway all properties being read
+	const imageField: ImageField = {
+		...inputImage,
+		edit:
+			"edit" in inputImage
+				? inputImage.edit
+				: {
+						x: 0,
+						y: 0,
+						zoom: 1,
+				  },
+		dimensions: "dimensions" in inputImage ? inputImage.dimensions : {},
+	}
+	return withOptionals<ImageContentView>(
 		{
 			origin: {
 				id: image.id,
@@ -57,6 +74,16 @@ function convertThumbnails(
 	)
 }
 
+export const imageBlockConverter = (
+	imageBlock: ImportImageBlock,
+	assets: Record<Asset["id"], Asset | undefined>,
+): ImageContentView => {
+	return convertImage<ImportImageBlock>(
+		imageBlock,
+		getAssetOrThrow(assets)(imageBlock.id),
+	)
+}
+
 // All assets from `imageField` must be present in `assets`
 // If not then function will throw an error
 export const imageConverter = (
@@ -66,7 +93,10 @@ export const imageConverter = (
 	if (!imageField) return
 
 	return {
-		...convertImage(imageField, getAssetOrThrow(assets)(imageField.id)),
+		...convertImage<ImageField>(
+			imageField,
+			getAssetOrThrow(assets)(imageField.id),
+		),
 		thumbnails: convertThumbnails(imageField, assets),
 		__TYPE__: "ImageContent" as const,
 	}

package/src/import/converters/fields/nestable/Nestable.ts

@@ -11,6 +11,7 @@ import {
 	imageConverter,
 	linkConverter,
 	numberConverter,
+	richTextConverter,
 	selectConverter,
 	textConverter,
 	timestampConverter,
@@ -44,6 +45,8 @@ export function convertNestableWidget(
 			return linkConverter(field.value, assets)
 		case "Image":
 			return imageConverter(field.value, assets)
+		case "StructuredText":
+			return richTextConverter(field.value, assets, embeds)
 		default:
 			throw new Error(
 				`Unsupported type of nestable converter ${JSON.stringify(field)}`,

package/src/import/converters/fields/nestable/RichText.ts

@@ -0,0 +1,62 @@
+import type { Asset, Embed } from "../../../../common"
+import type { Block, RichTextContent } from "../../../../content"
+import { RichTextContentType } from "../../../../content"
+import type { ImportBlock, ImportRichText } from "../../../validators"
+import { embedConverter } from "./Embed"
+import { imageBlockConverter } from "./Image"
+import { linkConverter } from "./Link"
+
+const richTextBlockConverter = (
+	importBlock: ImportBlock,
+	assets: Record<Asset["id"], Asset | undefined>,
+	embeds: Record<string, Embed | undefined>,
+): Block => {
+	if (importBlock.type === "image") {
+		return {
+			type: importBlock.type,
+			data: imageBlockConverter(importBlock, assets),
+		}
+	} else if (importBlock.type === "embed") {
+		const embedData = embedConverter(importBlock.oembed, embeds)
+		if (!embedData) throw new Error("Failed to convert embed data")
+		return {
+			type: importBlock.type,
+			data: embedData,
+		}
+	} else {
+		// Text block
+		return {
+			type: importBlock.type,
+			direction: importBlock.direction ?? "ltr",
+			content: {
+				text: importBlock.text,
+				spans:
+					importBlock.spans?.map((span) => {
+						const linkData =
+							span.type === "hyperlink"
+								? linkConverter(span.data, assets)
+								: undefined
+						return {
+							type: span.type,
+							start: span.start,
+							end: span.end,
+							data: linkData,
+						}
+					}) ?? [],
+			},
+		}
+	}
+}
+export const richTextConverter = (
+	richTextField: ImportRichText["value"],
+	assets: Record<Asset["id"], Asset | undefined>,
+	embeds: Record<string, Embed | undefined>,
+): RichTextContent | undefined => {
+	if (richTextField === null) return
+	return {
+		__TYPE__: RichTextContentType,
+		value: richTextField.map((block) =>
+			richTextBlockConverter(block, assets, embeds),
+		),
+	}
+}

package/src/import/converters/fields/nestable/index.ts

@@ -7,6 +7,7 @@ export * from "./Image"
 export * from "./Link"
 export * from "./Nestable"
 export * from "./Number"
+export * from "./RichText"
 export * from "./Select"
 export * from "./Text"
 export * from "./Timestamp"

package/src/import/validators/fields/ImportSlices/SharedSlice/SharedSlice.ts

@@ -24,7 +24,7 @@ export type SharedSlice = {
 	version: string | null | undefined
 }
 
-const SharedSliceShape = t.type({
+const SharedSliceShape = t.strict({
 	id: OptionalSharedSliceId,
 	slice_type: NonEmptyString,
 	name: String,

package/src/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceType.ts

@@ -15,7 +15,7 @@ export type SharedSliceType = {
  * slice_type - the validated slice_type
  * slice - SharedSlice custom type data matching the slice_type. We return it alongside the validated slice_type, because it is needed to decode the 'variation' field in the SharedSlice (see SharedSliceVariation.ts)
  */
-const SharedSliceTypeShape = t.type({
+const SharedSliceTypeShape = t.strict({
 	slice_type: NonEmptyString,
 	slice: SharedSliceCustomType,
 })

package/src/import/validators/fields/ImportSlices/SharedSlice/fields/SharedSliceVariation.ts

@@ -15,7 +15,7 @@ export type SharedSliceVariation = {
  * variation - the validated variation of the slice
  * data - Variation data matching the variation. We return it alongside the validated variation, because it is needed to decode the 'primary' and 'items' fields in the SharedSlice.
  */
-const SharedSliceVariationShape = t.type({
+const SharedSliceVariationShape = t.strict({
 	variation: NonEmptyString,
 	data: Variation,
 })

package/src/import/validators/fields/nestable/Embed.ts

@@ -1,5 +1,3 @@
-import * as Either from "fp-ts/Either"
-import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
 import { EmptyObjectOrElse } from "../../../../validators"
@@ -32,23 +30,12 @@ const EmbedUrl = new t.Type<URL, URL, unknown>(
 	t.identity,
 )
 
-const EmbedProto = t.type({
+export const ImportEmbedValue = t.strict({
 	embed_url: EmbedUrl,
 })
-type EmbedProto = t.TypeOf<typeof EmbedProto>
 
-type Embed = EmbedProto
-const Embed = new t.Type<Embed>(
-	"ImportEmbedValue",
-	(u: unknown): u is Embed => EmbedProto.is(u),
-	(u: unknown) => {
-		return pipe(
-			EmbedProto.decode(u),
-			Either.map((parsed) => ({ embed_url: parsed.embed_url })),
-		)
-	},
-	t.identity,
+export const ImportEmbed = ImportContent(
+	"Embed",
+	EmptyObjectOrElse(ImportEmbedValue),
 )
-
-export const ImportEmbed = ImportContent("Embed", EmptyObjectOrElse(Embed))
 export type ImportEmbed = t.TypeOf<typeof ImportEmbed>

package/src/import/validators/fields/nestable/GeoPoint.ts

@@ -5,7 +5,7 @@ import { EmptyObjectOrElse, NumberRange } from "../../../../validators"
 import { withCustomError } from "../../../../validators/function"
 import { ImportContent } from "../ImportContent"
 
-const GeooPoint = withCustomError(
+const GeoPoint = withCustomError(
 	t.strict({
 		latitude: NumberRange(-90, 90, "latitude"),
 		longitude: NumberRange(-180, 180, "longitude"),
@@ -16,6 +16,6 @@ const GeooPoint = withCustomError(
 
 export const ImportGeoPoint = ImportContent(
 	"GeoPoint",
-	EmptyObjectOrElse(GeooPoint),
+	EmptyObjectOrElse(GeoPoint),
 )
 export type ImportGeoPoint = TypeOf<typeof ImportGeoPoint>

package/src/import/validators/fields/nestable/Image/default.ts

@@ -0,0 +1,25 @@
+import * as t from "io-ts"
+
+import type { Image as ImageDefinition } from "../../../../../customtypes"
+import { EmptyObject } from "../../../../../validators"
+import { withCustomError } from "../../../../../validators/function"
+
+export const defaultImportImage = (field?: ImageDefinition) => {
+	// If there is not thumbnails we expect an empty object
+	if (!field?.config?.thumbnails || !field.config.thumbnails.length)
+		return EmptyObject
+
+	// If there are thumbnails, we expect an object with thumbnails as empty objects
+	return withCustomError(
+		t.strict(
+			field.config.thumbnails.reduce(
+				(acc, thumbnail) => ({
+					...acc,
+					[thumbnail.name]: EmptyObject,
+				}),
+				{},
+			),
+		),
+		() => "The value must be an object",
+	)
+}