@prismicio/types-internal 2.2.0-traverse.alpha-6 → 2.2.0-traverse.alpha-8

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),
 		)

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

@@ -1,62 +0,0 @@
-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),
-		),
-	}
-}