@prismicio/types-internal 2.2.0-alpha.7 → 2.2.0-alpha.8

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

@@ -1,8 +1,14 @@
-import * as Either from "fp-ts/Either"
+import * as Either from "fp-ts/lib/Either"
 import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
+import { withMessage } from "io-ts-types"
 
 import { EmptyObjectOrElse } from "../../../../validators"
+import {
+	NumberOrNull,
+	String,
+	StringOrNull,
+} from "../../../../validators/BasicTypes"
 import { ImportContent } from "../ImportContent"
 
 type URL = string
@@ -32,23 +38,49 @@ const EmbedUrl = new t.Type<URL, URL, unknown>(
 	t.identity,
 )
 
-const EmbedProto = t.type({
-	embed_url: EmbedUrl,
-})
+const EmbedProto = t.exact(
+	t.intersection([
+		t.type({
+			embed_url: EmbedUrl,
+			type: String,
+		}),
+		t.partial({
+			version: withMessage(
+				t.union([t.string, t.number, t.null]),
+				() => "The value must be either string, number or null",
+			),
+			title: String,
+			author_name: StringOrNull,
+			author_url: StringOrNull,
+			provider_name: StringOrNull,
+			provider_url: StringOrNull,
+			cache_age: withMessage(
+				t.union([t.string, t.number, t.null]),
+				() => "The value must be either string, number or null",
+			),
+			thumbnail_url: StringOrNull,
+			thumbnail_width: NumberOrNull,
+			thumbnail_height: NumberOrNull,
+			html: StringOrNull,
+		}),
+	]),
+)
 type EmbedProto = t.TypeOf<typeof EmbedProto>
 
-type Embed = EmbedProto
-const Embed = new t.Type<Embed>(
+type Embed = EmbedProto & {
+	all: unknown
+}
+const embedValue = new t.Type<Embed>(
 	"ImportEmbedValue",
-	(u: unknown): u is Embed => EmbedProto.is(u),
+	(u: unknown): u is Embed => EmbedProto.is(u) && "all" in u,
 	(u: unknown) => {
 		return pipe(
 			EmbedProto.decode(u),
-			Either.map((parsed) => ({ embed_url: parsed.embed_url })),
+			Either.map((parsed) => ({ ...parsed, all: u })),
 		)
 	},
 	t.identity,
 )
 
-export const ImportEmbed = ImportContent("Embed", EmptyObjectOrElse(Embed))
+export const ImportEmbed = ImportContent("Embed", EmptyObjectOrElse(embedValue))
 export type ImportEmbed = t.TypeOf<typeof ImportEmbed>

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

@@ -3,23 +3,24 @@ import { pipe } from "fp-ts/lib/function"
 import type { Validation } from "io-ts"
 import * as t from "io-ts"
 
-import { withOptionals } from "../../../../utils/Objects"
+import type { Image } from "../../../../customtypes"
+import type ImageConstraint from "../../../../customtypes/widgets/shared/ImageConstraint"
 import { AnyObject, NullOrElse, Number } from "../../../../validators"
-import { String, StringOrNull } from "../../../../validators/BasicTypes"
+import { String, StringOrNull } from "../../../../validators"
 import { ImportContent } from "../ImportContent"
 
-const ImageFieldCodec = AnyObject.pipe(
+const ImageFieldValidator = AnyObject.pipe(
 	t.intersection([
 		t.type({
 			id: String,
 		}),
 		t.partial({
+			width: Number,
+			height: Number,
 			edit: AnyObject.pipe(
-				t.strict({
+				t.partial({
 					x: Number,
 					y: Number,
-					width: Number,
-					height: Number,
 					zoom: Number,
 					background: String,
 				}),
@@ -30,48 +31,98 @@ const ImageFieldCodec = AnyObject.pipe(
 	]),
 )
 
-const ThumbnailsCodec = t.record(t.string, ImageFieldCodec)
-type Thumbnails = t.TypeOf<typeof ThumbnailsCodec>
+const ThumbnailsValidator = t.record(t.string, ImageFieldValidator)
 
-export type ImageField = t.TypeOf<typeof ImageFieldCodec>
+export type ImageField = {
+	id: string
+	width?: number
+	height?: number
+	edit: {
+		x: number
+		y: number
+		zoom: number
+		background?: string
+	}
+	credit?: string | null
+	alt?: string | null
+}
+type ImageFieldWithThumbnails = ImageField & {
+	thumbnails: Record<string, ImageField>
+}
 
-type ImageFieldWithThumbnails = ImageField & { thumbnails: Thumbnails }
+const encodeImageField = (
+	image: t.TypeOf<typeof ImageFieldValidator> | undefined,
+	mainImage: t.TypeOf<typeof ImageFieldValidator>,
+	constraints?: ImageConstraint,
+): ImageField => {
+	const background = image?.edit?.background
+	const width = constraints?.width ?? image?.width
+	const height = constraints?.height ?? image?.height
+	const alt = image?.alt
+	const credit = image?.credit
 
-const ImageFieldWithThumbnails = new t.Type(
-	"ImageFieldWithThumbnails",
-	(u: unknown): u is ImageFieldWithThumbnails =>
-		ImageFieldCodec.is(u) &&
-		"thumbnails" in u &&
-		ThumbnailsCodec.is(u["thumbnails"]),
-	(u: unknown, ctx): Validation<ImageFieldWithThumbnails> => {
-		return pipe(
-			ImageFieldCodec.validate(u, ctx),
-			chain((proto) => {
-				const { id, edit, credit, alt, ...maybeThumbnails } = proto
-				return pipe(
-					ThumbnailsCodec.validate(maybeThumbnails, ctx),
-					map((thumbnails) =>
-						withOptionals<ImageFieldWithThumbnails>(
-							{
-								id,
-								thumbnails,
-							},
-							[
-								["edit", edit],
-								["credit", credit],
-								["alt", alt],
-							],
-						),
-					),
-				)
-			}),
-		)
-	},
-	t.identity,
-)
+	return {
+		id: image?.id ?? mainImage?.id,
+		edit: {
+			x: image?.edit?.x ?? 0,
+			y: image?.edit?.y ?? 0,
+			zoom: image?.edit?.zoom ?? 1,
+			...(background !== undefined ? { background } : {}),
+		},
+		...(width !== undefined ? { width } : {}),
+		...(height !== undefined ? { height } : {}),
+		...(alt !== undefined ? { alt } : {}),
+		...(credit !== undefined ? { credit } : {}),
+	}
+}
 
-export const ImportImage = ImportContent(
-	"Image",
-	NullOrElse(ImageFieldWithThumbnails),
-)
-export type ImportImage = t.TypeOf<typeof ImportImage>
+const encodeThumbnails = (
+	mainImage: t.TypeOf<typeof ImageFieldValidator>,
+	thumbnails: t.TypeOf<typeof ThumbnailsValidator>,
+	field?: Image,
+) =>
+	field?.config?.thumbnails?.reduce(
+		(acc, thumbnail) => ({
+			...acc,
+			[thumbnail.name]: encodeImageField(
+				thumbnails[thumbnail.name],
+				mainImage,
+				thumbnail,
+			),
+		}),
+		{},
+	) ?? {}
+
+const ImageFieldWithThumbnails = (field?: Image) =>
+	new t.Type<ImageFieldWithThumbnails>(
+		"ImageFieldWithThumbnails",
+		(u: unknown): u is ImageFieldWithThumbnails =>
+			ImageFieldValidator.is(u) &&
+			"thumbnails" in u &&
+			ThumbnailsValidator.is(u["thumbnails"]),
+		(u: unknown, ctx): Validation<ImageFieldWithThumbnails> => {
+			return pipe(
+				ImageFieldValidator.validate(u, ctx),
+				chain((mainImage) => {
+					const { id, width, height, edit, credit, alt, ...maybeThumbnails } =
+						mainImage
+					return pipe(
+						ThumbnailsValidator.validate(maybeThumbnails, ctx),
+						map((thumbnails) => ({
+							...encodeImageField(
+								mainImage,
+								mainImage,
+								field?.config?.constraint,
+							),
+							thumbnails: encodeThumbnails(mainImage, thumbnails, field),
+						})),
+					)
+				}),
+			)
+		},
+		t.identity,
+	)
+
+export const ImportImage = (field?: Image) =>
+	ImportContent("Image", NullOrElse(ImageFieldWithThumbnails(field)))
+export type ImportImage = t.TypeOf<ReturnType<typeof ImportImage>>

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

@@ -37,7 +37,7 @@ export const ImportNestable = {
 			ImportEmbed.is(u) ||
 			ImportLink.is(u) ||
 			ImportGeoPoint.is(u) ||
-			ImportImage.is(u)
+			ImportImage().is(u)
 		)
 	},
 	decode: (field: NestableWidget) => {
@@ -63,7 +63,7 @@ export const ImportNestable = {
 					case "Link":
 						return ImportLink
 					case "Image":
-						return ImportImage
+						return ImportImage(field)
 					case "GeoPoint":
 						return ImportGeoPoint
 					default:

package/src/utils/Objects.ts

@@ -44,10 +44,10 @@ export function isObject(value: unknown): value is Record<string, unknown> {
 
 export function mapValues<T, O>(
 	record: Record<string, T>,
-	fn: (value: T) => O,
+	fn: (value: T, key: string) => O,
 ): Record<string, O> {
 	return Object.entries<T>(record).reduce<Record<string, O>>(
-		(acc, [key, value]) => ({ ...acc, [key]: fn(value) }),
+		(acc, [key, value]) => ({ ...acc, [key]: fn(value, key) }),
 		{},
 	)
 }

package/src/common/Embed.ts

@@ -1,23 +0,0 @@
-export type Embed = {
-	type: string
-	version?: string | null
-	author_name?: string | null
-	author_url?: string | null
-	provider_name?: string | null
-	provider_url?: string | null
-	cache_age?: string | null
-	thumbnail_url?: string | null
-	thumbnail_width?: number | null
-	thumbnail_height?: number | null
-	html?: string | null
-	title?: string | null
-}
-
-export type EmbedUrl = string
-
-export const getEmbedOrThrow =
-	(embeds: Record<string, Embed>) => (embedUrl: string) => {
-		const embed = embeds[embedUrl]
-		if (!embed) throw new Error(`Missing embed with url '${embedUrl}'`)
-		return embed
-	}