@prismicio/types-internal 3.17.0 → 4.0.0-canary.3fe5f1e

package/src/content/codec/uid.ts

@@ -0,0 +1,36 @@
+import { UIDLegacySchema } from "../legacy/uid"
+import type { UIDLegacy } from "../legacy/uid"
+import { UIDContentSchema, UIDContentType } from "../uid"
+import type { UIDContent } from "../uid"
+import type { LegacyContentCtx, LegacyCodec } from "./legacyContentCtx"
+
+export const UIDLegacyCodec = (ctx: LegacyContentCtx): LegacyCodec<UIDContent, UIDLegacy> => ({
+	name: "UIDLegacy",
+
+	is(input): input is UIDContent {
+		return UIDContentSchema.safeParse(input).success
+	},
+
+	toContent(input) {
+		const parsed = UIDLegacySchema.safeParse(input)
+		if (!parsed.success) {
+			return parsed
+		}
+
+		return {
+			success: true,
+			data: {
+				__TYPE__: UIDContentType,
+				value: parsed.data,
+			},
+		}
+	},
+
+	fromContent(input) {
+		return {
+			content: input.value,
+			types: { [ctx.keyOfType]: "UID" },
+			keys: {},
+		}
+	},
+})

package/src/content/codec/widget.ts

@@ -0,0 +1,58 @@
+import { z } from "zod/mini"
+
+import { GroupContentType } from "../group"
+import type { WidgetLegacy } from "../legacy/widget"
+import { SlicesContentType } from "../slices"
+import { UIDContentType } from "../uid"
+import { WidgetContentSchema } from "../widget"
+import type { WidgetContent } from "../widget"
+import { GroupLegacyCodec } from "./group"
+import type { LegacyCodec, LegacyContentCtx } from "./legacyContentCtx"
+import { NestableLegacyCodec } from "./nestable"
+import { SlicesLegacyCodec } from "./slices"
+import { UIDLegacyCodec } from "./uid"
+
+const UnsupportedWidgetLegacySchema = z.never()
+
+export const WidgetLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<WidgetContent, WidgetLegacy, true> => ({
+	name: "WidgetLegacy",
+
+	is(input): input is WidgetContent {
+		return WidgetContentSchema.safeParse(input).success
+	},
+
+	toContent(input) {
+		if (!ctx.fieldType) {
+			return UnsupportedWidgetLegacySchema.safeParse(
+				input,
+			) as z.core.util.SafeParseError<WidgetLegacy>
+		}
+
+		switch (ctx.fieldType) {
+			case "UID":
+				return UIDLegacyCodec(ctx).toContent(input)
+			case "Group":
+				return GroupLegacyCodec(ctx).toContent(input)
+			case "Choice":
+			case "Slices":
+				return SlicesLegacyCodec(ctx).toContent(input)
+			default:
+				return NestableLegacyCodec(ctx).toContent(input)
+		}
+	},
+
+	fromContent(input) {
+		switch (input.__TYPE__) {
+			case UIDContentType:
+				return UIDLegacyCodec(ctx).fromContent(input)
+			case GroupContentType:
+				return GroupLegacyCodec(ctx).fromContent(input)
+			case SlicesContentType:
+				return SlicesLegacyCodec(ctx).fromContent(input)
+			default:
+				return NestableLegacyCodec(ctx).fromContent(input)
+		}
+	},
+})

package/src/content/document.ts

@@ -0,0 +1,8 @@
+import { z } from "zod/mini"
+
+import { WidgetKeySchema } from "../common/widgetKey"
+import { WidgetContentSchema } from "./widget"
+
+export const DocumentContentSchema = z.record(WidgetKeySchema, WidgetContentSchema)
+
+export type DocumentContent = z.infer<typeof DocumentContentSchema>

package/src/content/embed.ts

@@ -0,0 +1,12 @@
+import { z } from "zod/mini"
+
+import { EmbedLegacySchema } from "./legacy/embed"
+
+export const EmbedContentType = "EmbedContent" as const
+
+export const EmbedContentSchema = z.extend(EmbedLegacySchema, {
+	__TYPE__: z.literal(EmbedContentType),
+	all: z.unknown(),
+})
+
+export type EmbedContent = z.infer<typeof EmbedContentSchema>

package/src/content/empty.ts

@@ -0,0 +1,10 @@
+import { z } from "zod/mini"
+
+export const EmptyContentType = "EmptyContent" as const
+
+export const EmptyContentSchema = z.object({
+	type: z.string(),
+	__TYPE__: z.literal(EmptyContentType),
+})
+
+export type EmptyContent = z.infer<typeof EmptyContentSchema>

package/src/content/field.ts

@@ -0,0 +1,94 @@
+import { z } from "zod/mini"
+
+import type { SelectModel } from "../model/select"
+
+export const FieldContentType = "FieldContent" as const
+export const SelectFieldType = "Select" as const
+
+// Text
+export const TextContentSchema = z.object({
+	type: z.literal("Text"),
+	value: z.string().check(z.trim()),
+	__TYPE__: z.literal(FieldContentType),
+})
+
+// Color
+export const ColorContentSchema = z.object({
+	type: z.literal("Color"),
+	value: z.string().check(z.trim()),
+	__TYPE__: z.literal(FieldContentType),
+})
+
+// Date
+export const DateContentSchema = z.object({
+	type: z.literal("Date"),
+	value: z.string().check(z.trim()),
+	__TYPE__: z.literal(FieldContentType),
+})
+
+// Timestamp
+export const TimestampContentSchema = z.object({
+	type: z.literal("Timestamp"),
+	value: z.string().check(z.trim()),
+	__TYPE__: z.literal(FieldContentType),
+})
+
+// Number
+export const NumberContentSchema = z.object({
+	type: z.literal("Number"),
+	value: z.string().check(z.trim()),
+	__TYPE__: z.literal(FieldContentType),
+})
+
+// Range
+export const RangeContentSchema = z.object({
+	type: z.literal("Range"),
+	value: z.string().check(z.trim()),
+	__TYPE__: z.literal(FieldContentType),
+})
+
+// Select
+export const SelectContentSchema = z.object({
+	type: z.literal(SelectFieldType),
+	value: z.string().check(z.trim()),
+	__TYPE__: z.literal(FieldContentType),
+})
+
+// Fields
+export const FieldContentSchema: z.ZodMiniType<FieldContent> = z.union([
+	TextContentSchema,
+	ColorContentSchema,
+	DateContentSchema,
+	TimestampContentSchema,
+	NumberContentSchema,
+	RangeContentSchema,
+	SelectContentSchema,
+])
+
+export type TextContent = z.infer<typeof TextContentSchema>
+export type ColorContent = z.infer<typeof ColorContentSchema>
+export type DateContent = z.infer<typeof DateContentSchema>
+export type TimestampContent = z.infer<typeof TimestampContentSchema>
+export type NumberContent = z.infer<typeof NumberContentSchema>
+export type RangeContent = z.infer<typeof RangeContentSchema>
+export type SelectContent = z.infer<typeof SelectContentSchema>
+export type FieldContent =
+	| TextContent
+	| ColorContent
+	| DateContent
+	| TimestampContent
+	| NumberContent
+	| RangeContent
+	| SelectContent
+
+/**
+ * Returns the default value for a Select field based on its configuration.
+ */
+export const SelectContentDefaultValue = (field: SelectModel): SelectContent | undefined =>
+	field.config?.default_value
+		? {
+				__TYPE__: FieldContentType,
+				type: SelectFieldType,
+				value: field.config.default_value || "",
+			}
+		: undefined

package/src/content/geopoint.ts

@@ -0,0 +1,11 @@
+import { z } from "zod/mini"
+
+import { GeoPointLegacySchema } from "./legacy/geopoint"
+
+export const GeoPointContentType = "GeoPointContent" as const
+
+export const GeoPointContentSchema = z.extend(GeoPointLegacySchema, {
+	__TYPE__: z.literal(GeoPointContentType),
+})
+
+export type GeoPointContent = z.infer<typeof GeoPointContentSchema>

package/src/content/group.ts

@@ -0,0 +1,99 @@
+import { z } from "zod/mini"
+
+import type { GroupModel } from "../model/group"
+import { NestableContentDefaultValue, NestableContentSchema } from "./nestable"
+import type { NestableContent } from "./nestable"
+
+// Item
+export const GroupItemContentType = "GroupItemContent" as const
+
+export const GroupItemContentSchema: z.ZodMiniType<GroupItemContent> = z.object({
+	__TYPE__: z.literal(GroupItemContentType),
+	key: z.string(),
+	value: z.array(
+		z.tuple([
+			z.string(),
+			z.union([
+				NestableContentSchema,
+				// `lazy` is used to handle circular dependency on GroupContentSchema
+				z.lazy(() => GroupContentSchema),
+			]),
+		]),
+	),
+})
+
+// Manual type definition to handle circular dependency on GroupItemContentSchema
+export type GroupItemContent = {
+	__TYPE__: typeof GroupItemContentType
+	key: string
+	value: [string, NestableContent | GroupContent][]
+}
+
+// Group
+export const GroupContentType = "GroupContentType" as const
+
+export const GroupContentSchema = z.object({
+	__TYPE__: z.literal(GroupContentType),
+	value: z.array(GroupItemContentSchema),
+})
+
+export type GroupContent = z.infer<typeof GroupContentSchema>
+
+export const NestableAndGroupContentSchema: z.ZodMiniType<NestableAndGroupContent> = z.union([
+	NestableContentSchema,
+	GroupContentSchema,
+])
+
+export type NestableAndGroupContent = NestableContent | GroupContent
+
+// Default values for GroupContent
+export function groupContentWithDefaultValues(
+	customType: GroupModel,
+	content: GroupContent,
+): GroupContent {
+	const fields = customType.config?.fields
+	if (!fields) return content
+
+	return {
+		...content,
+		value: content.value.map((groupItem) => {
+			const updatedValue = Object.entries(fields).reduce<GroupItemContent["value"]>(
+				(acc, [fieldKey, fieldDef]) => {
+					const existingField = groupItem.value.find(([key]) => key === fieldKey)
+
+					if (existingField) {
+						return [...acc, existingField]
+					}
+
+					// Field is missing, check if we can add a default value
+					if (fieldDef.type === "Group") {
+						// Recursively apply defaults to nested groups
+						return [
+							...acc,
+							[
+								fieldKey,
+								{
+									__TYPE__: GroupContentType,
+									value: [],
+								},
+							],
+						]
+					}
+
+					const defaultValue = NestableContentDefaultValue(fieldDef)
+					if (defaultValue) {
+						return [...acc, [fieldKey, defaultValue]]
+					}
+
+					return acc
+				},
+				[],
+			)
+
+			return {
+				...groupItem,
+				value: updatedValue,
+			}
+		}),
+	}
+}

package/src/content/image.ts

@@ -0,0 +1,103 @@
+import { z } from "zod/mini"
+
+import { ImageViewLegacySchema, ImageLegacySchema } from "./legacy/image"
+
+export const ImageContentType = "ImageContent" as const
+
+export const ImageViewContentSchema = ImageViewLegacySchema
+
+type ImageViewContent = z.infer<typeof ImageViewLegacySchema>
+
+export const ImageContentSchema = z.extend(ImageLegacySchema, {
+	__TYPE__: z.literal(ImageContentType),
+})
+
+export type ImageContent = z.infer<typeof ImageContentSchema>
+
+// Helpers
+
+export interface CroppedImage {
+	zoom: number
+	/** X coordinate of the crop rect on the original image */
+	x: number
+	/** Y coordinate of the crop rect on the original image */
+	y: number
+
+	/** The width of the crop rect over the original image */
+	cropWidth: number
+	/** The height of the crop rect over the original image */
+	cropHeight: number
+
+	/** Final (user defined via W input) width of the image */
+	width: number
+	/** Final (user defined via H input) height of the image */
+	height: number
+}
+
+interface BuildCropUrlArgs {
+	origin: ImageContent["origin"]
+	/** Image crop parameters */
+	croppedImage: CroppedImage
+}
+
+export function buildCropUrl(args: BuildCropUrlArgs): string {
+	const { origin, croppedImage } = args
+	const { x, y, width, height, cropHeight, cropWidth } = croppedImage
+
+	const url = new URL(origin.url)
+
+	const hasResize = origin.height !== height || origin.width !== width
+
+	const hasCrop = x !== 0 || y !== 0 || cropHeight !== origin.height || cropWidth !== origin.width
+
+	if (hasCrop) {
+		const crop = [x, y, cropWidth, cropHeight].map(Math.round).join(",")
+
+		url.searchParams.set("rect", crop)
+		url.searchParams.set("w", width.toString())
+		url.searchParams.set("h", height.toString())
+	}
+
+	if (hasResize) {
+		url.searchParams.set("w", width.toString())
+		url.searchParams.set("h", height.toString())
+	}
+
+	return url.toString()
+}
+
+export function getCroppedImage({ contentView }: { contentView: ImageViewContent }): CroppedImage {
+	const {
+		edit: {
+			crop: { x, y },
+			zoom,
+		},
+		width,
+		height,
+		origin: { width: originWidth, height: originHeight },
+	} = contentView
+
+	let cropWidth
+	let cropHeight
+	const originAspect = originWidth / originHeight
+	const cropAspect = width / height
+	if (cropAspect >= originAspect) {
+		// crop and origin image would be the same width if zoom was equal to 1
+		cropWidth = originWidth / zoom
+		cropHeight = cropWidth / cropAspect
+	} else {
+		// crop and origin image would be the same height if zoom was equal to 1
+		cropHeight = originHeight / zoom
+		cropWidth = cropHeight * cropAspect
+	}
+
+	return {
+		x,
+		y,
+		width,
+		height,
+		zoom,
+		cropWidth,
+		cropHeight,
+	}
+}

package/src/content/integrationField.ts

@@ -0,0 +1,10 @@
+import { z } from "zod/mini"
+
+export const IntegrationFieldContentType = "IntegrationFieldsContent" as const
+
+export const IntegrationFieldContentSchema = z.object({
+	__TYPE__: z.literal(IntegrationFieldContentType),
+	value: z.string(),
+})
+
+export type IntegrationFieldContent = z.infer<typeof IntegrationFieldContentSchema>

package/src/content/legacy/boolean.ts

@@ -0,0 +1,5 @@
+import { z } from "zod/mini"
+
+export const BooleanLegacySchema = z.boolean()
+
+export type BooleanLegacy = z.infer<typeof BooleanLegacySchema>

package/src/content/legacy/document.ts

@@ -0,0 +1,25 @@
+import { z } from "zod/mini"
+
+import { WidgetKeySchema } from "../../common/widgetKey"
+import type { WidgetKey } from "../../common/widgetKey"
+
+export const DocumentLegacySchema = z.pipe(
+	z.record(z.string(), z.unknown()),
+	z.transform((value) => {
+		const documentLegacy: Record<WidgetKey, unknown> = {}
+
+		for (const [widgetKey, widgetValue] of Object.entries(value)) {
+			// Keep v3 behavior: invalid widget keys are dropped, but the document
+			// decode still succeeds. Widget value validation happens later in
+			// DocumentLegacyCodec via WidgetLegacyCodec.
+			const result = WidgetKeySchema.safeParse(widgetKey)
+			if (result.success) {
+				documentLegacy[result.data] = widgetValue
+			}
+		}
+
+		return documentLegacy
+	}),
+)
+
+export type DocumentLegacy = z.infer<typeof DocumentLegacySchema>

package/src/content/legacy/embed.ts

@@ -0,0 +1,23 @@
+import { z } from "zod/mini"
+
+const EmbedShape = {
+	embed_url: z.string(),
+	type: z.string(),
+	version: z.nullish(z.union([z.string(), z.number()])),
+	title: z.nullish(z.string()),
+	author_name: z.nullish(z.string()),
+	author_url: z.nullish(z.string()),
+	provider_name: z.nullish(z.string()),
+	provider_url: z.nullish(z.string()),
+	cache_age: z.nullish(z.union([z.string(), z.number()])),
+	thumbnail_url: z.nullish(z.string()),
+	thumbnail_width: z.nullish(z.number()),
+	thumbnail_height: z.nullish(z.number()),
+	html: z.nullish(z.string()),
+}
+
+export const EmbedLegacySchema = z.object(EmbedShape)
+
+export const EmbedLegacyLooseSchema = z.looseObject(EmbedShape)
+
+export type EmbedLegacy = z.infer<typeof EmbedLegacySchema>

package/src/content/legacy/empty.ts

@@ -0,0 +1,10 @@
+import { z } from "zod/mini"
+
+export const EmptyLegacySchema = z.union([
+	z.null(),
+	z.object({
+		value: z.null(),
+	}),
+])
+
+export type EmptyLegacy = z.infer<typeof EmptyLegacySchema>

package/src/content/legacy/field.ts

@@ -0,0 +1,8 @@
+import { z } from "zod/mini"
+
+export const StringLegacySchema = z.pipe(
+	z.string(),
+	z.transform((s: string) => s.trim()),
+)
+
+export type StringLegacy = z.infer<typeof StringLegacySchema>

package/src/content/legacy/geopoint.ts

@@ -0,0 +1,10 @@
+import { z } from "zod/mini"
+
+export const GeoPointLegacySchema = z.object({
+	position: z.object({
+		lat: z.number(),
+		lng: z.number(),
+	}),
+})
+
+export type GeoPointLegacy = z.infer<typeof GeoPointLegacySchema>

package/src/content/legacy/group.ts

@@ -0,0 +1,23 @@
+import { z } from "zod/mini"
+
+import type { NestableLegacy } from "./nestable"
+import { NestableLegacySchema } from "./nestable"
+
+// Keep item values raw here: array-shaped legacy payloads are ambiguous until
+// `codec/group.ts` resolves the field model and picks the right decoder.
+export const GroupItemLegacySchema = z.record(z.string(), z.unknown())
+
+export type GroupItemLegacy = z.infer<typeof GroupItemLegacySchema>
+
+export const GroupLegacySchema: z.ZodMiniType<GroupLegacy> = z.array(
+	z.union([GroupItemLegacySchema, z.null()]),
+)
+
+export type GroupLegacy = (GroupItemLegacy | null)[]
+
+export const NestableAndGroupLegacySchema: z.ZodMiniType<NestableAndGroupLegacy> = z.union([
+	NestableLegacySchema,
+	GroupLegacySchema,
+])
+
+export type NestableAndGroupLegacy = NestableLegacy | GroupLegacy

package/src/content/legacy/image.ts

@@ -0,0 +1,43 @@
+import { z } from "zod/mini"
+
+const OriginSchema = z.object({
+	id: z.string(),
+	url: z.string(),
+	width: z.number(),
+	height: z.number(),
+})
+
+const CropSchema = z.object({
+	x: z.number(),
+	y: z.number(),
+})
+
+const EditSchema = z.object({
+	zoom: z.number(),
+	crop: CropSchema,
+	background: z.string(),
+})
+
+const NonEmptyStringOrNullSchema = z.pipe(
+	z.nullish(z.string()),
+	z.transform((value) => (typeof value === "string" && value.length > 0 ? value : null)),
+)
+
+export const ImageViewLegacySchema = z.object({
+	origin: OriginSchema,
+	width: z.number(),
+	height: z.number(),
+	edit: EditSchema,
+	url: z.optional(z.string()),
+	credits: z.optional(NonEmptyStringOrNullSchema),
+	alt: z.optional(NonEmptyStringOrNullSchema),
+	provider: z.nullish(z.string()),
+})
+
+export type ImageLegacyView = z.infer<typeof ImageViewLegacySchema>
+
+export const ImageLegacySchema = z.extend(ImageViewLegacySchema, {
+	thumbnails: z.optional(z.record(z.string(), ImageViewLegacySchema)),
+})
+
+export type ImageLegacy = z.infer<typeof ImageLegacySchema>

package/src/content/legacy/integrationField.ts

@@ -0,0 +1,5 @@
+import { z } from "zod/mini"
+
+export const IntegrationFieldLegacySchema = z.string()
+
+export type IntegrationFieldLegacy = z.infer<typeof IntegrationFieldLegacySchema>