@prismicio/types-internal 2.2.0-traverse.alpha-5 → 2.2.0-traverse.alpha-7

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

@@ -1,5 +1,5 @@
 import { either } from "fp-ts"
-import { isLeft, isRight } from "fp-ts/lib/Either"
+import { isRight } from "fp-ts/lib/Either"
 import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
@@ -18,66 +18,54 @@ import {
 import { ImageContentView } from "../ImageContent"
 import { Link, LinkLegacy } from "../LinkContent"
 
-export const Meta = t.exact(
-	t.intersection([
-		t.partial({
-			data: t.unknown,
-		}),
-		t.type({
-			start: t.number,
-			end: t.number,
-			type: t.union([RichTextNodeTypeCodec, t.literal("label")]),
-		}),
-	]),
-)
-export type Meta = t.TypeOf<typeof Meta>
-
-// export alias for code clarity
-export const Span = Meta
-export type Span = Meta
-
-export const ValidatedMetas = (linkCodec: LinkCodec) =>
-	new t.Type<Meta[], Meta[], unknown>(
-		"ValidatedMetas",
-		(metas): metas is Meta[] => Array.isArray(metas) && metas.every(Meta.is),
-		(metas: unknown, c) => {
-			if (Array.isArray(metas)) {
-				const res = metas
-					.reduce<Array<Meta>>((acc, maybeMeta) => {
-						const maybeDecodedMeta = Meta.decode(maybeMeta)
-						if (isRight(maybeDecodedMeta)) {
-							const meta = maybeDecodedMeta.right
-							// if it's an hyperlink it should have data validated as link otherwise we don't care and keep the meta
-							if (meta.data && meta.type === "hyperlink") {
-								const decoded = linkCodec.decode(meta.data)
-								if (isLeft(decoded)) return acc
-
-								return [...acc, { ...meta, data: decoded.right }]
-							} else if (meta.type !== "hyperlink") {
-								return [...acc, meta]
-							}
-						}
-						return acc
+const SpanFn = (linkCodec: typeof Link | typeof LinkLegacy) =>
+	t.exact(
+		t.intersection([
+			t.partial({
+				data: linkCodec,
+			}),
+			t.type({
+				start: t.number,
+				end: t.number,
+				type: t.union([RichTextNodeTypeCodec, t.literal("label")]),
+			}),
+		]),
+	)
+
+export const Span = SpanFn(Link)
+export type Span = t.TypeOf<typeof Span>
+
+export const SpanLegacy = SpanFn(LinkLegacy)
+export type SpanLegacy = t.TypeOf<typeof SpanLegacy>
+
+export const ValidatedSpans = <C extends typeof Span | typeof SpanLegacy>(
+	spanCodec: C,
+) => {
+	type S = t.TypeOf<C>
+
+	return new t.Type<S[], S[], unknown>(
+		"ValidatedSpans",
+		(spans): spans is S[] => Array.isArray(spans) && spans.every(spanCodec.is),
+		(spans: unknown, c) => {
+			if (Array.isArray(spans)) {
+				const res = spans
+					.reduce<Array<S>>((acc, maybeSpan) => {
+						const decodedSpan = spanCodec.decode(maybeSpan)
+						return isRight(decodedSpan) ? [...acc, decodedSpan.right] : acc
 					}, [])
-					.sort((m1: Meta, m2: Meta) => m1.start - m2.start)
+					.sort((m1: S, m2: S) => m1.start - m2.start)
 				return t.success(res)
-			} else return t.failure(metas, c)
+			} else return t.failure(spans, c)
 		},
 		(m) => {
-			return m.reduce<Array<Meta>>((acc, meta) => {
-				if (meta.type === "hyperlink" && meta.data) {
-					// since the Span data are typed as unknown we have to redecode for type safety and then encode to either new format or legacy.
-					const decoded = linkCodec.decode(meta.data)
-					if (isLeft(decoded)) return acc
-
-					return [...acc, { ...meta, data: linkCodec.encode(decoded.right) }]
-				}
-				return [...acc, Meta.encode(meta)]
+			return m.reduce<Array<S>>((acc, meta) => {
+				return [...acc, spanCodec.encode(meta)]
 			}, [])
 		},
 	)
+}
 
-const ImageBlockCodec = (linkCodec: LinkCodec) =>
+const ImageBlockCodec = (linkCodec: typeof Link | typeof LinkLegacy) =>
 	t.exact(
 		t.intersection([
 			t.type({
@@ -169,8 +157,9 @@ export function checkEmbedBlock(block: Block): block is EmbedBlock {
 	return block.type === RichTextNodeType.embed
 }
 
-type LinkCodec = typeof Link | typeof LinkLegacy
-const TextBlockCodec = (linkCodec: LinkCodec) =>
+const TextBlockCodec = <C extends typeof Span | typeof SpanLegacy>(
+	spanCodec: C,
+) =>
 	t.exact(
 		t.intersection([
 			t.type({
@@ -184,7 +173,7 @@ const TextBlockCodec = (linkCodec: LinkCodec) =>
 						text: t.string,
 					}),
 					t.partial({
-						spans: ValidatedMetas(linkCodec),
+						spans: ValidatedSpans(spanCodec),
 					}),
 				]),
 			}),
@@ -195,10 +184,11 @@ const TextBlockCodec = (linkCodec: LinkCodec) =>
 		]),
 	)
 
-export const TextBlock = TextBlockCodec(Link)
+/* These Text block will decode codec A and encode from codec B to A */
+export const TextBlock = TextBlockCodec(Span)
 export type TextBlock = t.TypeOf<typeof TextBlock>
 
-const TextBlockLegacy = TextBlockCodec(LinkLegacy)
+const TextBlockLegacy = TextBlockCodec(SpanLegacy)
 type TextBlockLegacy = t.TypeOf<typeof TextBlockLegacy>
 
 const legacyBlockCodec = t.union([

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

@@ -8,10 +8,7 @@ import type {
 	TraverseSliceContentFn,
 	TraverseWidgetContentFn,
 } from "../../../../_internal/utils"
-import type {
-	CompositeSliceFields,
-	VariationFields,
-} from "../../../../customtypes"
+import type { CompositeSlice, VariationFields } from "../../../../customtypes"
 import {
 	getFieldCtx,
 	LegacyContentCtx,
@@ -147,7 +144,7 @@ export function traverseCompositeSliceContent({
 	sliceKey: string
 	sliceName: string
 	content: CompositeSliceItemContent
-	model?: VariationFields | CompositeSliceFields | undefined
+	model?: VariationFields | CompositeSlice | undefined
 }) {
 	return (
 		transformWidget: TraverseWidgetContentFn,
@@ -159,7 +156,7 @@ export function traverseCompositeSliceContent({
 			const fieldDef = (() => {
 				return model?.type === "SharedSlice"
 					? model?.fields?.primary?.[fieldKey]
-					: model?.fields?.repeat?.[fieldKey]
+					: model?.["non-repeat"]?.[fieldKey]
 			})()
 
 			const transformedField = transformWidget({
@@ -183,9 +180,7 @@ export function traverseCompositeSliceContent({
 		const items = traverseGroupItemsContent({
 			path: path.concat([{ key: "repeat", type: "items" }]),
 			model:
-				model?.type === "SharedSlice"
-					? model?.fields.items
-					: model?.fields.repeat,
+				model?.type === "SharedSlice" ? model?.fields.items : model?.repeat,
 			content: content.widget.repeat,
 		})(transformWidget)
 

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

@@ -10,7 +10,7 @@ import {
 } from "../../../_internal/utils"
 import {
 	type StaticSlices,
-	CompositeSliceFields,
+	CompositeSlice,
 	Group,
 	isCompositeSlice,
 	isLegacySlice,
@@ -146,7 +146,7 @@ function findSliceModel(
 
 	const legacySliceModel = ():
 		| NestableWidget
-		| CompositeSliceFields
+		| CompositeSlice
 		| Group
 		| undefined => {
 		if (!defaultModel) return
@@ -154,10 +154,8 @@ function findSliceModel(
 		if (isCompositeSlice(defaultModel)) {
 			return {
 				type: "Slice",
-				fields: {
-					"non-repeat": defaultModel["non-repeat"] || {},
-					repeat: defaultModel.repeat || {},
-				},
+				"non-repeat": defaultModel["non-repeat"] || {},
+				repeat: defaultModel.repeat || {},
 			}
 		}
 		if (isLegacySlice(defaultModel)) {
@@ -180,10 +178,13 @@ export function traverseSlices({
 	content: SlicesContent
 	model?: StaticSlices | undefined
 }) {
-	return (
-		transformWidget: TraverseWidgetContentFn,
-		transformSlice: TraverseSliceContentFn,
-	): SlicesContent | undefined => {
+	return ({
+		transformWidget = ({ content }) => content,
+		transformSlice = ({ content }) => content,
+	}: {
+		transformWidget?: TraverseWidgetContentFn
+		transformSlice?: TraverseSliceContentFn
+	}): SlicesContent | undefined => {
 		const value = content.value.reduce<SlicesContent["value"]>(
 			(acc, sliceContent) => {
 				const sliceModel = model && findSliceModel(path, model, sliceContent)

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

@@ -1,6 +1,5 @@
 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"
@@ -33,11 +32,6 @@ 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/import/converters/fields/nestable/Image.ts

@@ -5,22 +5,20 @@ import { withOptionals } from "../../../../utils/Objects"
 import type { ImageField, ImportImage } from "../../../validators"
 import type { ImportImageBlock } from "../../../validators/fields/nestable/ImportRichText/blocks"
 
-function convertImage<Input extends ImageField | ImportImageBlock>(
+export function convertImageView<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 : {},
+		edit: {
+			x: 0,
+			y: 0,
+			zoom: 1,
+			...inputImage.edit,
+		},
+		dimensions: inputImage.dimensions ?? {},
 	}
 	return withOptionals<ImageContentView>(
 		{
@@ -64,7 +62,7 @@ function convertThumbnails(
 		(acc, [thumbnailName, thumbnail]) => {
 			return {
 				...acc,
-				[thumbnailName]: convertImage(
+				[thumbnailName]: convertImageView(
 					thumbnail,
 					getAssetOrThrow(assets)(thumbnail.id),
 				),
@@ -74,16 +72,6 @@ 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 = (
@@ -93,7 +81,7 @@ export const imageConverter = (
 	if (!imageField) return
 
 	return {
-		...convertImage<ImageField>(
+		...convertImageView<ImageField>(
 			imageField,
 			getAssetOrThrow(assets)(imageField.id),
 		),

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

@@ -0,0 +1,17 @@
+import type { Embed } from "../../../../../common"
+import type { EmbedBlock } from "../../../../../content"
+import type { ImportEmbedBlock } from "../../../../validators/fields/nestable/ImportRichText/blocks"
+import { embedConverter } from "../Embed"
+
+export function embedBlockConverter(
+	block: ImportEmbedBlock,
+	embeds: Record<string, Embed | undefined>,
+): EmbedBlock {
+	const embedData = embedConverter(block.oembed, embeds)
+
+	if (!embedData) throw new Error("Failed to convert embed data")
+	return {
+		type: block.type,
+		data: embedData,
+	}
+}

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

@@ -0,0 +1,17 @@
+import { Asset, getAssetOrThrow } from "../../../../../common"
+import type { ImageBlock } from "../../../../../content"
+import type { ImportImageBlock } from "../../../../validators/fields/nestable/ImportRichText/blocks"
+import { convertImageView } from "../Image"
+
+export function imageBlockConverter(
+	block: ImportImageBlock,
+	assets: Record<Asset["id"], Asset | undefined>,
+): ImageBlock {
+	return {
+		type: block.type,
+		data: convertImageView<ImportImageBlock>(
+			block,
+			getAssetOrThrow(assets)(block.id),
+		),
+	}
+}

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

@@ -0,0 +1,23 @@
+import type { Asset, Embed } from "../../../../../common"
+import type { RichTextContent } from "../../../../../content"
+import { RichTextContentType } from "../../../../../content"
+import type { ImportRichText } from "../../../../validators"
+import { embedBlockConverter } from "./embedBlock"
+import { imageBlockConverter } from "./imageBlock"
+import { textBlockConverter } from "./textBlock"
+
+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) => {
+			if (block.type === "image") return imageBlockConverter(block, assets)
+			else if (block.type === "embed") return embedBlockConverter(block, embeds)
+			return textBlockConverter(block, assets)
+		}),
+	}
+}

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

@@ -0,0 +1,48 @@
+import type { Asset } from "../../../../../common"
+import type { TextBlock } from "../../../../../content"
+import type { ImportTextBlock } from "../../../../validators/fields/nestable/ImportRichText/blocks"
+import { linkConverter } from "../Link"
+
+export function textBlockConverter(
+	block: ImportTextBlock,
+	assets: Record<Asset["id"], Asset | undefined>,
+): TextBlock {
+	return {
+		type: block.type,
+		content: {
+			text: block.text,
+			...(() => {
+				if (block.spans) {
+					const convertedSpans = spansConverter(block.spans, assets)
+					if (!convertedSpans) return {}
+
+					return { spans: convertedSpans }
+				}
+				return {}
+			})(),
+		},
+		...(block.direction ? { direction: block.direction } : {}),
+	}
+}
+
+function spansConverter(
+	spans: NonNullable<ImportTextBlock["spans"]>,
+	assets: Record<Asset["id"], Asset | undefined>,
+): TextBlock["content"]["spans"] {
+	return spans.map((span) => {
+		return {
+			type: span.type,
+			start: span.start,
+			end: span.end,
+			...(() => {
+				if (span.type === "hyperlink") {
+					const convertedLinkContent = linkConverter(span.data, assets)
+					if (!convertedLinkContent) return {}
+
+					return { data: convertedLinkContent?.value }
+				}
+				return {}
+			})(),
+		}
+	})
+}

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

@@ -2,7 +2,7 @@ export * from "./Boolean"
 export * from "./Color"
 export * from "./Date"
 export * from "./Embed"
-export * from "./GeooPoint"
+export * from "./GeoPoint"
 export * from "./Image"
 export * from "./Link"
 export * from "./Nestable"

package/src/import/validators/fields/ImportContent.ts

@@ -10,14 +10,14 @@ export const ImportContent = <T extends FieldType, A, O = A>(
 	valueCodec: t.Type<A, O>,
 ) =>
 	new t.Type<{ type: T; value: A }, O>(
-		"ImportField",
+		`ImportField: ${valueCodec.name}`,
 		(u: unknown): u is { type: T; value: A } => {
 			if (!isObject(u)) return false
 			return type === u["type"] && valueCodec.is(u["value"])
 		},
-		(u: unknown) => {
+		(u: unknown, c) => {
 			return pipe(
-				valueCodec.decode(u),
+				valueCodec.validate(u, c),
 				either.map((decodedValue) => {
 					return {
 						type,

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

@@ -3,7 +3,7 @@ import { pipe } from "fp-ts/function"
 import * as t from "io-ts"
 
 import type { StaticSlices } from "../../../../customtypes"
-import { EmptyObjectOrElse } from "../../../../validators"
+import { EmptyArrayOrElse } from "../../../../validators"
 import { ImportContent } from "../ImportContent"
 import { SharedSlice } from "./SharedSlice"
 import {
@@ -16,13 +16,14 @@ export const ImportSlices = (staticSlices: StaticSlices) => {
 
 	// For now we only support the SharedSlice, however if we want to support more in the future
 	// we would have to change the codec here to something like this: t.array(t.union([ImportSharedSlice(sharedSlices), NewSliceCodec(newSliceCustomTypes)])).
-	const SlicesArrayCodec = t.array(SharedSlice(supportedSlices))
+	const SharedSliceCodec = SharedSlice(supportedSlices)
+	const SlicesArrayCodec = t.array(SharedSliceCodec)
 
 	return ImportContent(
 		"Slices",
-		EmptyObjectOrElse(
-			new t.Type<SharedSlice[]>(
-				"ImportSlices",
+		EmptyArrayOrElse(
+			new t.ArrayType<typeof SharedSliceCodec, SharedSlice[]>(
+				SlicesArrayCodec.name,
 				(u): u is SharedSlice[] => SlicesArrayCodec.is(u),
 				(u, c) => {
 					return pipe(
@@ -46,6 +47,7 @@ export const ImportSlices = (staticSlices: StaticSlices) => {
 					)
 				},
 				t.identity,
+				SharedSliceCodec,
 			),
 		),
 	)

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

@@ -83,8 +83,8 @@ export const SharedSliceContentEntry = (
 								errors.map((error) => {
 									const context = [
 										...c,
-										...error.context.filter(({ key }) => !!key), // We replace the "" key coming from ImportNestable decoder
 										{ key, actual: content, type: codec },
+										...error.context.slice(1), // We ignore the first context element with "" key coming from ImportNestable decoder
 									]
 
 									const updatedError: t.ValidationError = { ...error, context }

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

@@ -1,3 +1,5 @@
+import * as E from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
 import * as t from "io-ts"
 
 import type { RichText as RichTextCustomType } from "../../../../../customtypes"
@@ -6,36 +8,47 @@ import { withCustomError } from "../../../../../validators/function"
 import { ImportContent } from "../../ImportContent"
 import { ImportBlock } from "./ImportBlock"
 
-export const ImportRichText = (customType?: RichTextCustomType) =>
-	ImportContent(
+export const ImportRichText = (customType?: RichTextCustomType) => {
+	const single = customType?.config?.single?.split(",")
+	const multi = customType?.config?.multi?.split(",")
+	const allowedBlockTypes = multi || single
+
+	const isSingleBlockAllowed = multi === undefined && single !== undefined
+
+	const BlockCodec = ImportBlock(allowedBlockTypes ?? [])
+	const RichTextArrayCodec = withCustomError(
+		t.array(BlockCodec),
+		() => "Rich text field must be an array",
+	)
+
+	return ImportContent(
 		"StructuredText",
 		EmptyArrayOrElse(
-			withCustomError(
-				t.array(t.unknown).pipe(
-					new t.Type<ImportBlock[], ImportBlock[], unknown[]>(
-						"RichTextField",
-						(u): u is ImportBlock[] => t.array(ImportBlock([])).is(u),
-						(u, c) => {
-							const single = customType?.config?.single?.split(",")
-							const multi = customType?.config?.multi?.split(",")
+			new t.ArrayType<typeof BlockCodec, ImportBlock[], ImportBlock[]>(
+				RichTextArrayCodec.name,
+				(u): u is ImportBlock[] => RichTextArrayCodec.is(u),
+				(u, c) => {
+					if (allowedBlockTypes === undefined) {
+						throw new Error(
+							"Invalid custom type for the rich text field: the model is missing a 'single' or 'multi' field defining a list of allowed block types",
+						)
+					}
 
-							if (multi) {
-								return t.array(ImportBlock(multi)).validate(u, c)
-							} else if (single) {
-								return u.length > 1
-									? t.failure(u, c, "This field only allows one block")
-									: t.array(ImportBlock(single)).validate(u, c)
-							} else {
-								throw new Error(
-									"Rich text config must have either a 'single' or 'multi' field defined",
-								)
+					return pipe(
+						RichTextArrayCodec.validate(u, c),
+						E.chain((blocks) => {
+							if (isSingleBlockAllowed && blocks.length > 1) {
+								return t.failure(blocks, c, "This field only allows one block")
 							}
-						},
-						t.identity,
-					),
-				),
-				() => "Rich text field must be an array",
+							return t.success(blocks)
+						}),
+					)
+				},
+				t.identity,
+				BlockCodec,
 			),
 		),
 	)
+}
+
 export type ImportRichText = t.TypeOf<ReturnType<typeof ImportRichText>>

package/src/import/validators/fields/nestable/ImportRichText/blocks/ImportImageBlock.ts

@@ -1,13 +1,17 @@
 import * as t from "io-ts"
 
-import { String } from "../../../../../../validators"
+import { ImportImageView } from "../../Image/validators"
 
 export const ImportImageBlockType = t.literal("image")
 export type ImportImageBlockType = t.TypeOf<typeof ImportImageBlockType>
 
-export const ImportImageBlock = t.strict({
-	type: ImportImageBlockType,
-	id: String,
-})
+export const ImportImageBlock = t.exact(
+	t.intersection([
+		t.type({
+			type: ImportImageBlockType,
+		}),
+		ImportImageView,
+	]),
+)
 
 export type ImportImageBlock = t.TypeOf<typeof ImportImageBlock>

package/src/validators/DefaultOrElse.ts

@@ -6,11 +6,11 @@ import { EmptyArray, EmptyObject } from "./BasicTypes"
 export const DefaultOrElse = <I, A, O = A>(inputValidator: t.Type<I>) => {
 	return (codec: t.Type<A, O>) =>
 		new t.Type<A | null, O | undefined>(
-			"DefaultOrElse",
+			`DefaultOrElse<${inputValidator.name}, ${codec.name}>`,
 			(u: unknown): u is A | null => null === u || codec.is(u),
-			(u: unknown) => {
-				if (isRight(inputValidator.decode(u))) return t.success(null)
-				return codec.decode(u)
+			(u: unknown, c) => {
+				if (isRight(inputValidator.validate(u, c))) return t.success(null)
+				return codec.validate(u, c)
 			},
 			(chunk) => (chunk ? codec.encode(chunk) : undefined),
 		)