@prismicio/types-internal 2.2.0-alpha.16 → 2.2.0-alpha.17

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",
+	)
+}

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

@@ -4,55 +4,52 @@ import type { Validation } from "io-ts"
 import * as t from "io-ts"
 
 import type { Image as ImageDefinition } from "../../../../../customtypes"
-import { DefaultOrElse, EmptyObject } from "../../../../../validators"
+import { DefaultOrElse } from "../../../../../validators"
 import { withCustomError } from "../../../../../validators/function"
 import { ImportContent } from "../../ImportContent"
-import { decodeImageField, decodeThumbnails } from "./Decoder"
+import { defaultImportImage } from "./default"
+import {
+	mergeImageViewWithCtConstraints,
+	mergeThumbnailsWithCtConstraints,
+} from "./merge"
 import type { ImageFieldWithThumbnails } from "./model"
-import { ImageFieldValidator, ThumbnailsValidator } from "./Validator"
+import { ImportImageView, ImportThumbnails } from "./validators"
 
-const defaultImage = (field?: ImageDefinition) => {
-	// If there is not thumbnails we expect an empty object
-	if (!field?.config?.thumbnails || !field.config.thumbnails.length)
-		return EmptyObject
+/* For code clarity, the output of this validator will be simplified
+ *
+ *  Input -> type ImageAPIV2 = ImportImageView & ImportThumbnails
+ *  Output -> type ImageWithThumbnails 👇
+ */
 
-	// 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",
-	)
-}
-
-const ImageField = (field?: ImageDefinition) =>
+export const ImageFieldCodec = (field?: ImageDefinition) =>
 	new t.Type<ImageFieldWithThumbnails>(
 		"ImageField",
 		(u: unknown): u is ImageFieldWithThumbnails =>
-			ImageFieldValidator.is(u) &&
+			ImportImageView.is(u) &&
 			"thumbnails" in u &&
-			ThumbnailsValidator.is(u["thumbnails"]),
+			ImportThumbnails.is(u["thumbnails"]),
 		(u: unknown, ctx): Validation<ImageFieldWithThumbnails> => {
 			return pipe(
-				ImageFieldValidator.validate(u, ctx),
-				chain((mainImage) => {
-					const { id, dimensions, edit, copyright, alt, ...maybeThumbnails } =
-						mainImage
+				// Validating the higher level image
+				ImportImageView.validate(u, ctx),
+				chain((imageApiV2) => {
+					const { id, dimensions, edit, copyright, alt, ...thumbnails } =
+						imageApiV2
+
 					return pipe(
-						ThumbnailsValidator.validate(maybeThumbnails, ctx),
+						// Validating the thumbnails
+						ImportThumbnails.validate(thumbnails, ctx),
 						map((thumbnails) => ({
-							...decodeImageField(
-								mainImage,
-								mainImage,
+							...mergeImageViewWithCtConstraints(
+								imageApiV2,
+								imageApiV2,
 								field?.config?.constraint,
 							),
-							thumbnails: decodeThumbnails(mainImage, thumbnails, field),
+							thumbnails: mergeThumbnailsWithCtConstraints(
+								thumbnails,
+								imageApiV2,
+								field,
+							),
 						})),
 					)
 				}),
@@ -64,12 +61,13 @@ const ImageField = (field?: ImageDefinition) =>
 const ImageCodec = (field?: ImageDefinition) =>
 	withCustomError(
 		DefaultOrElse<Record<never, never>, ImageFieldWithThumbnails>(
-			defaultImage(field),
-		)(ImageField(field)),
+			defaultImportImage(field),
+		)(ImageFieldCodec(field)),
 		() => "An image field must be an object",
 	)
 
 export const ImportImage = (field?: ImageDefinition) =>
 	ImportContent("Image", ImageCodec(field))
 export type ImportImage = t.TypeOf<ReturnType<typeof ImportImage>>
+
 export * from "./model"

package/src/import/validators/fields/nestable/Image/{Decoder.ts → merge.ts}

@@ -1,32 +1,30 @@
-import type { TypeOf } from "io-ts"
-
 import type { Image } from "../../../../../customtypes"
 import type ImageConstraint from "../../../../../customtypes/widgets/shared/ImageConstraint"
 import type { ImageField } from "./model"
-import type { ImageFieldValidator, ThumbnailsValidator } from "./Validator"
+import type { ImportImageView, ImportThumbnails } from "./validators"
 
-// This function merges user input with custom type constraints.
-// If `image` is missing, `mainImage` is used for the encoding
-// (case when user input lacks thumbnail definition)
-export const decodeImageField = (
-	image: TypeOf<typeof ImageFieldValidator> | undefined,
-	mainImage: TypeOf<typeof ImageFieldValidator>,
-	constraints?: ImageConstraint,
+/* This function merges user input with custom type constraints.
+ *  If a thumbnails' data are missing (`image`) then the default is used (`defaultImage`)
+ */
+export const mergeImageViewWithCtConstraints = (
+	image: ImportImageView | undefined,
+	defaultImage: ImportImageView,
+	constraints: ImageConstraint | undefined,
 ): ImageField => {
 	const background = image?.edit?.background
 	const width =
 		constraints?.width ??
 		image?.dimensions?.width ??
-		mainImage.dimensions?.width
+		defaultImage?.dimensions?.width
 	const height =
 		constraints?.height ??
 		image?.dimensions?.height ??
-		mainImage.dimensions?.height
+		defaultImage?.dimensions?.height
 	const alt = image?.alt
 	const copyright = image?.copyright
 
 	return {
-		id: image?.id ?? mainImage?.id,
+		id: image?.id ?? defaultImage?.id,
 		edit: {
 			x: image?.edit?.x ?? 0,
 			y: image?.edit?.y ?? 0,
@@ -41,19 +39,24 @@ export const decodeImageField = (
 		...(copyright !== undefined ? { copyright } : {}),
 	}
 }
-// Merges provided thumbnails with custom type constraints.
-// If any thumbnail is missing, it is created using the origin image (`mainImage`)
-export const decodeThumbnails = (
-	mainImage: TypeOf<typeof ImageFieldValidator>,
-	thumbnails: TypeOf<typeof ThumbnailsValidator>,
+
+/* This function handles each thumbnail defined in the custom type.
+ *
+ *  For each of them it merges the user input with custom type constraints.
+ *
+ *  If a thumbnail is missing, the data from the default image is used.
+ */
+export const mergeThumbnailsWithCtConstraints = (
+	thumbnails: ImportThumbnails,
+	defaultImage: ImportImageView,
 	field?: Image,
 ) =>
 	field?.config?.thumbnails?.reduce(
 		(acc, thumbnail) => ({
 			...acc,
-			[thumbnail.name]: decodeImageField(
+			[thumbnail.name]: mergeImageViewWithCtConstraints(
 				thumbnails[thumbnail.name],
-				mainImage,
+				defaultImage,
 				thumbnail,
 			),
 		}),

package/src/import/validators/fields/nestable/Image/{Validator.ts → validators.ts}

@@ -7,12 +7,14 @@ import {
 } from "../../../../../validators/BasicTypes"
 import { withCustomError } from "../../../../../validators/function"
 
-export const ImageFieldValidator = withCustomError(
+export const ImportImageView = withCustomError(
 	t.intersection([
 		t.type({
+			// Image Id
 			id: String,
 		}),
 		t.partial({
+			// Dimensions here will be used if they are not defined in the custom type
 			dimensions: withCustomError(
 				t.partial({
 					width: Number,
@@ -20,6 +22,7 @@ export const ImageFieldValidator = withCustomError(
 				}),
 				() => "The value must be an object",
 			),
+			// Crop information
 			edit: withCustomError(
 				t.partial({
 					x: Number,
@@ -29,10 +32,14 @@ export const ImageFieldValidator = withCustomError(
 				}),
 				() => "The value must be an object",
 			),
+			// Copyrights and alt are set in the Asset by default but they can be overrided
 			copyright: StringOrNull,
 			alt: StringOrNull,
 		}),
 	]),
 	() => "The value must be an object",
 )
-export const ThumbnailsValidator = t.record(t.string, ImageFieldValidator)
+export type ImportImageView = t.TypeOf<typeof ImportImageView>
+
+export const ImportThumbnails = t.record(t.string, ImportImageView)
+export type ImportThumbnails = t.TypeOf<typeof ImportThumbnails>

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

@@ -0,0 +1,39 @@
+import * as t from "io-ts"
+
+import { withCustomError } from "../../../../../validators/function"
+import {
+	ImportBlockType,
+	ImportEmbedBlock,
+	ImportImageBlock,
+	ImportTextBlock,
+} from "./blocks"
+
+export type ImportBlock = ImportTextBlock | ImportImageBlock | ImportEmbedBlock
+
+export const ImportBlock = (allowedBlockTypes: string[]) =>
+	withCustomError(
+		t
+			.type({
+				type: ImportBlockType(allowedBlockTypes),
+			})
+			.pipe(
+				new t.Type<ImportBlock, ImportBlock, { type: ImportBlockType }>(
+					"ImportBlock",
+					(u): u is ImportBlock =>
+						t
+							.union([ImportTextBlock, ImportImageBlock, ImportEmbedBlock])
+							.is(u),
+					(u, c) => {
+						if (u.type === "image") {
+							return ImportImageBlock.validate(u, c)
+						} else if (u.type === "embed") {
+							return ImportEmbedBlock.validate(u, c)
+						} else {
+							return ImportTextBlock.validate(u, c)
+						}
+					},
+					t.identity,
+				),
+			),
+		() => "Rich text block must be an object",
+	)

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

@@ -0,0 +1,41 @@
+import * as t from "io-ts"
+
+import type { RichText as RichTextCustomType } from "../../../../../customtypes"
+import { EmptyArrayOrElse } from "../../../../../validators"
+import { withCustomError } from "../../../../../validators/function"
+import { ImportContent } from "../../ImportContent"
+import { ImportBlock } from "./ImportBlock"
+
+export const ImportRichText = (customType?: RichTextCustomType) =>
+	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(",")
+
+							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",
+								)
+							}
+						},
+						t.identity,
+					),
+				),
+				() => "Rich text field must be an array",
+			),
+		),
+	)
+export type ImportRichText = t.TypeOf<ReturnType<typeof ImportRichText>>

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

@@ -0,0 +1,44 @@
+import * as E from "fp-ts/Either"
+import { pipe } from "fp-ts/function"
+import * as t from "io-ts"
+
+import { withCustomError } from "../../../../../../validators/function"
+import { ImportEmbedBlockType } from "./ImportEmbedBlock"
+import { ImportImageBlockType } from "./ImportImageBlock"
+import { ImportTextBlockType } from "./ImportTextBlock"
+
+export type ImportBlockType =
+	| ImportTextBlockType
+	| ImportImageBlockType
+	| ImportEmbedBlockType
+
+const ImportBlockTypeValidator = withCustomError(
+	t.union([ImportTextBlockType, ImportImageBlockType, ImportEmbedBlockType]),
+	() =>
+		`Invalid block type. Supported block types are: ${Object.keys(
+			ImportTextBlockType.keys,
+		).join(", ")}, ${ImportImageBlockType.value}, ${
+			ImportEmbedBlockType.value
+		}`,
+)
+
+export const ImportBlockType = (allowedBlockTypes: string[]) =>
+	new t.Type<ImportBlockType>(
+		"ImportBlockType",
+		(u): u is ImportBlockType => ImportBlockTypeValidator.is(u),
+		(u, c) => {
+			return pipe(
+				ImportBlockTypeValidator.validate(u, c),
+				E.chain((validBlockType) =>
+					allowedBlockTypes.includes(validBlockType)
+						? t.success(validBlockType)
+						: t.failure(
+								u,
+								c,
+								`The block type '${validBlockType}' is not allowed in your document type. Enable the type for this rich text field to create the document.`,
+						  ),
+				),
+			)
+		},
+		t.identity,
+	)

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

@@ -0,0 +1,13 @@
+import * as t from "io-ts"
+
+import { ImportEmbedValue } from "../../Embed"
+
+export const ImportEmbedBlockType = t.literal("embed")
+export type ImportEmbedBlockType = t.TypeOf<typeof ImportEmbedBlockType>
+
+export const ImportEmbedBlock = t.strict({
+	type: ImportEmbedBlockType,
+	oembed: ImportEmbedValue,
+})
+
+export type ImportEmbedBlock = t.TypeOf<typeof ImportEmbedBlock>

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

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

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

@@ -0,0 +1,56 @@
+import * as t from "io-ts"
+
+import { String } from "../../../../../../validators"
+import { withCustomError } from "../../../../../../validators/function"
+import { Span } from "./Span"
+
+export const ImportTextBlockTypes = {
+	Paragraph: "paragraph",
+	OListItem: "o-list-item",
+	ListItem: "list-item",
+	Heading1: "heading1",
+	Heading2: "heading2",
+	Heading3: "heading3",
+	Heading4: "heading4",
+	Heading5: "heading5",
+	Heading6: "heading6",
+	Preformatted: "preformatted",
+} as const
+
+export const ImportTextBlockType = t.keyof({
+	[ImportTextBlockTypes.Paragraph]: null,
+	[ImportTextBlockTypes.OListItem]: null,
+	[ImportTextBlockTypes.ListItem]: null,
+	[ImportTextBlockTypes.Heading1]: null,
+	[ImportTextBlockTypes.Heading2]: null,
+	[ImportTextBlockTypes.Heading3]: null,
+	[ImportTextBlockTypes.Heading4]: null,
+	[ImportTextBlockTypes.Heading5]: null,
+	[ImportTextBlockTypes.Heading6]: null,
+	[ImportTextBlockTypes.Preformatted]: null,
+})
+
+export type ImportTextBlockType = t.TypeOf<typeof ImportTextBlockType>
+
+const TextDirection = withCustomError(
+	t.union([t.literal("ltr"), t.literal("rtl")]),
+	() => "The 'direction' property must be one of the following: ltr, rtl",
+)
+
+export const ImportTextBlock = t.exact(
+	t.intersection([
+		t.type({
+			type: ImportTextBlockType,
+			text: String,
+		}),
+		t.partial({
+			spans: withCustomError(
+				t.array(Span),
+				() => "The 'spans' field must be an array",
+			),
+			direction: TextDirection,
+		}),
+	]),
+)
+
+export type ImportTextBlock = t.TypeOf<typeof ImportTextBlock>

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

@@ -0,0 +1,44 @@
+import * as t from "io-ts"
+
+import { withCustomError } from "../../../../../../validators/function"
+import {
+	HyperlinkSpan,
+	HyperlinkSpanType,
+	TextSpan,
+	TextSpanType,
+} from "./spans"
+
+const SpanType = withCustomError(
+	t.union([HyperlinkSpanType, TextSpanType]),
+	() =>
+		`Span 'type' field must be specified and have one of the following values: ${Object.keys(
+			TextSpanType.keys,
+		).join(", ")} or ${HyperlinkSpanType.value}`,
+)
+export type SpanType = t.TypeOf<typeof SpanType>
+
+const SpanTypeValidator = withCustomError(
+	t.type({
+		type: SpanType,
+	}),
+	() => "Span must be an object",
+)
+
+const SpanShape = t.union([HyperlinkSpan, TextSpan])
+
+export type Span = t.TypeOf<typeof SpanShape>
+
+export const Span = SpanTypeValidator.pipe(
+	new t.Type<Span, Span, { type: SpanType }>(
+		"Span",
+		(u): u is Span => SpanShape.is(u),
+		(u, c) => {
+			if (HyperlinkSpanType.is(u.type)) {
+				return HyperlinkSpan.validate(u, c)
+			} else {
+				return TextSpan.validate(u, c)
+			}
+		},
+		t.identity,
+	),
+)

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

@@ -0,0 +1,4 @@
+export * from "./ImportBlockType"
+export * from "./ImportEmbedBlock"
+export * from "./ImportImageBlock"
+export * from "./ImportTextBlock"