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

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"

package/src/import/validators/fields/nestable/ImportRichText/blocks/spans/HyperlinkSpan.ts

@@ -0,0 +1,24 @@
+import * as t from "io-ts"
+
+import { withCustomError } from "../../../../../../../validators/function"
+import { Link } from "../../../Link"
+import { SpanLocation } from "./SpanLocation"
+
+export const HyperlinkSpanType = t.literal("hyperlink")
+
+export type HyperlinkSpanType = t.TypeOf<typeof HyperlinkSpanType>
+
+export const HyperlinkSpan = t.exact(
+	t.intersection([
+		t.type({
+			type: HyperlinkSpanType,
+		}),
+		SpanLocation,
+		withCustomError(
+			t.type({
+				data: Link,
+			}),
+			() => "Hyperlink span must contain a 'data' field with link data",
+		),
+	]),
+)

package/src/import/validators/fields/nestable/ImportRichText/blocks/spans/SpanLocation.ts

@@ -0,0 +1,8 @@
+import * as t from "io-ts"
+
+import { Number } from "../../../../../../../validators"
+
+export const SpanLocation = t.type({
+	start: Number,
+	end: Number,
+})

package/src/import/validators/fields/nestable/ImportRichText/blocks/spans/TextSpan.ts

@@ -0,0 +1,26 @@
+import * as t from "io-ts"
+
+import { SpanLocation } from "./SpanLocation"
+
+const TextSpanTypes = {
+	Strong: "strong",
+	Em: "em",
+	Label: "label",
+} as const
+
+export const TextSpanType = t.keyof({
+	[TextSpanTypes.Strong]: null,
+	[TextSpanTypes.Em]: null,
+	[TextSpanTypes.Label]: null,
+})
+
+export const TextSpan = t.exact(
+	t.intersection([
+		t.type({
+			type: TextSpanType,
+		}),
+		SpanLocation,
+	]),
+)
+
+export type TextSpan = t.TypeOf<typeof TextSpan>

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

@@ -0,0 +1,2 @@
+export * from "./HyperlinkSpan"
+export * from "./TextSpan"

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

@@ -0,0 +1,2 @@
+export { ImportBlock } from "./ImportBlock"
+export { ImportRichText } from "./ImportRichText"

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

@@ -13,33 +13,38 @@ const LinkTypeValidator = t.type({
 	),
 })
 
-const WebLink = t.intersection([
-	t.type({
-		link_type: t.literal("Web"),
-		url: String,
-	}),
-	t.partial({
-		target: String,
-	}),
-])
+const WebLink = t.exact(
+	t.intersection([
+		t.type({
+			link_type: t.literal("Web"),
+			url: String,
+		}),
+		t.partial({
+			target: String,
+		}),
+	]),
+)
 export type WebLink = t.TypeOf<typeof WebLink>
 
-const DocumentLink = t.type({
+const DocumentLink = t.strict({
 	link_type: t.literal("Document"),
 	id: DocumentId,
 })
 export type DocumentLink = t.TypeOf<typeof DocumentLink>
 
-const MediaLink = t.type({
+const MediaLink = t.strict({
 	link_type: t.literal("Media"),
 	id: String,
 })
 export type MediaLink = t.TypeOf<typeof MediaLink>
 
-const Link = LinkTypeValidator.pipe(t.union([WebLink, DocumentLink, MediaLink]))
+export const Link = LinkTypeValidator.pipe(
+	t.union([WebLink, DocumentLink, MediaLink]),
+)
+export type Link = TypeOf<typeof Link>
 
 // This is the default value for the link
-const AnyLink = t.type({
+const AnyLink = t.strict({
 	link_type: t.literal("Any"),
 })
 

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

@@ -5,6 +5,7 @@ import { ImportDate } from "./Date"
 import { ImportEmbed } from "./Embed"
 import { ImportGeoPoint } from "./GeoPoint"
 import { ImportImage } from "./Image"
+import { ImportRichText } from "./ImportRichText"
 import { ImportLink } from "./Link"
 import { ImportNumber } from "./Number"
 import { ImportSelect } from "./Select"
@@ -23,6 +24,7 @@ export type ImportNestable =
 	| ImportLink
 	| ImportGeoPoint
 	| ImportImage
+	| ImportRichText
 
 export const ImportNestable = {
 	is(u: unknown): u is ImportNestable {
@@ -37,7 +39,8 @@ export const ImportNestable = {
 			ImportEmbed.is(u) ||
 			ImportLink.is(u) ||
 			ImportGeoPoint.is(u) ||
-			ImportImage().is(u)
+			ImportImage().is(u) ||
+			ImportRichText().is(u)
 		)
 	},
 	decode: (field: NestableWidget) => {
@@ -66,6 +69,8 @@ export const ImportNestable = {
 						return ImportImage(field)
 					case "GeoPoint":
 						return ImportGeoPoint
+					case "StructuredText":
+						return ImportRichText(field)
 					default:
 						throw new Error(`Unsupported type of nestable field ${field.type}`)
 				}

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

@@ -1,10 +1,11 @@
 export * from "./Boolean"
 export * from "./Color"
 export * from "./Date"
-export * from "./Embed"
+export { ImportEmbed } from "./Embed"
 export * from "./GeoPoint"
 export * from "./Image"
 export * from "./Image/index"
+export * from "./ImportRichText"
 export * from "./Link"
 export * from "./Nestable"
 export * from "./Number"