@prismicio/types-internal 3.17.0 → 4.0.0-canary.72def6d

package/src/content/codec/slices.ts

@@ -0,0 +1,130 @@
+import { SliceItemLegacySchema, SlicesLegacySchema } from "../legacy/slices"
+import type { SliceItemLegacy, SlicesLegacy } from "../legacy/slices"
+import { SliceItemContentSchema, SlicesContentSchema, SlicesContentType } from "../slices"
+import type { SliceItemContent, SlicesContent } from "../slices"
+import { type LegacyContentCtx, type LegacyCodec, getFieldCtx } from "./legacyContentCtx"
+import { SliceLegacyCodec } from "./slice"
+
+// Item
+export const SliceItemLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<SliceItemContent, SliceItemLegacy> => ({
+	name: "SlicesItemLegacy",
+
+	is(input): input is SliceItemContent {
+		return SliceItemContentSchema.safeParse(input).success
+	},
+
+	decode(input) {
+		const parsed = SliceItemLegacySchema.safeParse(input)
+		if (!parsed.success) {
+			return parsed
+		}
+
+		const sliceName = parsed.data.key.split("$")[0]
+		const itemCtx = getFieldCtx({
+			fieldKey: sliceName,
+			contentKey: parsed.data.key,
+			ctx,
+		})
+		const result = SliceLegacyCodec(itemCtx).decode(parsed.data.value)
+
+		if (!result.success) {
+			return result
+		}
+
+		return {
+			success: true,
+			data: {
+				key: parsed.data.key,
+				name: sliceName,
+				maybeLabel: parsed.data.label || undefined,
+				widget: result.data,
+			},
+		}
+	},
+
+	encode(input) {
+		const itemCtx = getFieldCtx({
+			fieldKey: input.name,
+			contentKey: input.key,
+			ctx,
+		})
+		const result = SliceLegacyCodec(itemCtx).encode(input.widget)
+
+		if (!result) {
+			return {
+				content: {
+					key: input.key,
+					label: input.maybeLabel,
+					value: {},
+				},
+				types: {},
+				keys: {},
+			}
+		}
+
+		return {
+			content: {
+				key: input.key,
+				label: input.maybeLabel,
+				value: result.content,
+			},
+			types: result.types,
+			keys: result.keys,
+		}
+	},
+})
+
+// Slices
+export const SlicesLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<SlicesContent, SlicesLegacy> => ({
+	name: "SlicesLegacy",
+
+	is(input): input is SlicesContent {
+		return SlicesContentSchema.safeParse(input).success
+	},
+
+	decode(input) {
+		const parsed = SlicesLegacySchema.safeParse(input)
+		if (!parsed.success) {
+			return parsed
+		}
+
+		const value: SlicesContent["value"] = []
+		for (let index = 0; index < parsed.data.length; index++) {
+			const item = parsed.data[index]
+			const result = SliceItemLegacyCodec(ctx).decode(item)
+			if (!result.success) {
+				return result
+			}
+			value.push(result.data)
+		}
+
+		return {
+			success: true,
+			data: { __TYPE__: SlicesContentType, value },
+		}
+	},
+
+	encode(input) {
+		const legacy: ReturnType<LegacyCodec<SlicesContent, SlicesLegacy>["encode"]> = {
+			content: [],
+			types: { [ctx.keyOfType]: "Slices" },
+			keys: {},
+		}
+
+		for (let index = 0; index < input.value.length; index++) {
+			const item = input.value[index]
+			const result = SliceItemLegacyCodec(ctx).encode(item)
+			if (!result) continue
+
+			legacy.content.push(result.content)
+			legacy.types = { ...legacy.types, ...result.types }
+			legacy.keys = { ...legacy.keys, ...result.keys }
+		}
+
+		return legacy
+	},
+})

package/src/content/codec/table.ts

@@ -0,0 +1,65 @@
+import { TableLegacySchema } from "../legacy/table"
+import type { TableLegacy } from "../legacy/table"
+import { RichTextContentType } from "../richText"
+import { TableContentSchema, TableContentType } from "../table"
+import type { TableContent } from "../table"
+import type { LegacyContentCtx, LegacyCodec } from "./legacyContentCtx"
+import { blockLegacyToValue, blockValueToLegacy } from "./richText"
+
+export const TableLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<TableContent, TableLegacy> => ({
+	name: "TableLegacy",
+
+	is(input): input is TableContent {
+		return TableContentSchema.safeParse(input).success
+	},
+
+	decode(input) {
+		const parsed = TableLegacySchema.safeParse(input)
+		if (!parsed.success) {
+			return parsed
+		}
+
+		return {
+			success: true,
+			data: {
+				__TYPE__: TableContentType,
+				content: parsed.data.content.map((row) => {
+					return {
+						...row,
+						content: row.content.map((cell) => {
+							return {
+								...cell,
+								content: {
+									__TYPE__: RichTextContentType,
+									value: cell.content.map((block) => blockLegacyToValue(block)),
+								},
+							}
+						}),
+					}
+				}),
+			},
+		}
+	},
+
+	encode(input) {
+		return {
+			content: {
+				content: input.content.map((row) => {
+					return {
+						...row,
+						content: row.content.map((cell) => {
+							return {
+								...cell,
+								content: cell.content.value.map((block) => blockValueToLegacy(block)),
+							}
+						}),
+					}
+				}),
+			},
+			types: { [ctx.keyOfType]: "Table" },
+			keys: {},
+		}
+	},
+})

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
+	},
+
+	decode(input) {
+		const parsed = UIDLegacySchema.safeParse(input)
+		if (!parsed.success) {
+			return parsed
+		}
+
+		return {
+			success: true,
+			data: {
+				__TYPE__: UIDContentType,
+				value: parsed.data,
+			},
+		}
+	},
+
+	encode(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
+	},
+
+	decode(input) {
+		if (!ctx.fieldType) {
+			return UnsupportedWidgetLegacySchema.safeParse(
+				input,
+			) as z.core.util.SafeParseError<WidgetLegacy>
+		}
+
+		switch (ctx.fieldType) {
+			case "UID":
+				return UIDLegacyCodec(ctx).decode(input)
+			case "Group":
+				return GroupLegacyCodec(ctx).decode(input)
+			case "Choice":
+			case "Slices":
+				return SlicesLegacyCodec(ctx).decode(input)
+			default:
+				return NestableLegacyCodec(ctx).decode(input)
+		}
+	},
+
+	encode(input) {
+		switch (input.__TYPE__) {
+			case UIDContentType:
+				return UIDLegacyCodec(ctx).encode(input)
+			case GroupContentType:
+				return GroupLegacyCodec(ctx).encode(input)
+			case SlicesContentType:
+				return SlicesLegacyCodec(ctx).encode(input)
+			default:
+				return NestableLegacyCodec(ctx).encode(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,87 @@
+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.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 = z.infer<typeof FieldContentSchema>
+
+/**
+ * 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,96 @@
+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.union([NestableContentSchema, GroupContentSchema])
+
+export type NestableAndGroupContent = z.infer<typeof NestableAndGroupContentSchema>
+
+// 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>