@prismicio/types-internal 3.17.0 → 4.0.0-canary.4689e2d

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,80 @@
+import { z } from "zod/mini"
+
+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

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,46 @@
+import { z } from "zod/mini"
+
+import { 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

package/src/content/image.ts

@@ -0,0 +1,15 @@
+import { z } from "zod/mini"
+
+import { ImageLegacyViewSchema, ImageLegacySchema } from "./legacy/image"
+
+export const ImageContentType = "ImageContent" as const
+
+export const ImageContentViewSchema = ImageLegacyViewSchema
+
+export type ImageContentView = z.infer<typeof ImageLegacyViewSchema>
+
+export const ImageContentSchema = z.extend(ImageLegacySchema, {
+	__TYPE__: z.literal(ImageContentType),
+})
+
+export type ImageContent = z.infer<typeof ImageContentSchema>

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 ImageLegacyViewSchema = 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 ImageLegacyViewSchema>
+
+export const ImageLegacySchema = z.extend(ImageLegacyViewSchema, {
+	thumbnails: z.optional(z.record(z.string(), ImageLegacyViewSchema)),
+})
+
+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>

package/src/content/legacy/link.ts

@@ -0,0 +1,194 @@
+import { z } from "zod/mini"
+
+import { NonEmptyStringSchema } from "../../common/nonEmptyString"
+
+export const LinkKind = {
+	Image: "image",
+	File: "file",
+	Media: "media",
+	Document: "document",
+	External: "web",
+	Any: "any",
+} as const
+
+export const LinkType = {
+	Image: "ImageLink",
+	File: "FileLink",
+	Document: "DocumentLink",
+	External: "ExternalLink",
+	Media: "MediaLink",
+	Any: "AnyLink",
+} as const
+
+// Image
+export const FilledImageLinkLegacyValueSchema = z.strictObject({
+	// `kind` was normalized to the literal (legacy behavior)
+	kind: z.pipe(
+		z.string(),
+		z.transform(() => LinkKind.Image),
+	),
+	id: z.string(),
+	url: z.string(),
+	height: z.string(),
+	width: z.string(),
+	size: z.string(),
+	name: z.string(),
+	date: z.nullish(z.string()),
+})
+
+export const EmptyImageLinkLegacyValueSchema = z.strictObject({
+	kind: z.literal(LinkKind.Image),
+})
+
+// File
+export const FilledFileLinkLegacyValueSchema = z.strictObject({
+	// `kind` was normalized to the literal (legacy behavior)
+	kind: z.pipe(
+		z.string(),
+		z.transform(() => LinkKind.File),
+	),
+	id: z.string(),
+	url: z.string(),
+	name: z.string(),
+	size: z.transform((value) => (typeof value === "string" ? value : "0")),
+	date: z.nullish(z.string()),
+})
+
+export const EmptyFileLinkLegacyValueSchema = z.strictObject({
+	kind: z.literal(LinkKind.File),
+})
+
+// Media
+
+// Media link only represent the empty state as they turn into
+// file or image links when they filled.
+export const EmptyMediaLinkLegacyValueSchema = z.strictObject({
+	kind: z.literal(LinkKind.Media),
+})
+
+// Document
+export const FilledDocumentLinkLegacyValueSchema = z.strictObject({
+	// `kind` is not part of the filled schema... (legacy behavior)
+	// We transform it to the literal for consistency.
+	kind: z.pipe(
+		z.optional(z.literal(LinkKind.Document)),
+		z.transform(() => LinkKind.Document),
+	),
+	id: NonEmptyStringSchema,
+})
+
+export const EmptyDocumentLinkLegacyValueSchema = z.strictObject({
+	kind: z.literal(LinkKind.Document),
+})
+
+// External
+export const FilledExternalLinkLegacyValueSchema = z.strictObject({
+	// It's odd that `kind` is optional here... (legacy behavior)
+	// We transform it to the literal for consistency.
+	kind: z.pipe(
+		z.optional(z.literal(LinkKind.External)),
+		z.transform(() => LinkKind.External),
+	),
+	url: z.string(),
+	target: z.nullish(z.string()),
+	preview: z.nullish(
+		z.strictObject({
+			title: z.optional(z.string()),
+		}),
+	),
+})
+
+export const EmptyExternalLinkLegacyValueSchema = z.strictObject({
+	kind: z.literal(LinkKind.External),
+})
+
+// Any
+export const AnyLinkLegacySchema = z.strictObject({
+	kind: z.transform(() => LinkKind.Any),
+})
+
+// All
+
+export const FilledLinkLegacyValueSchema: z.ZodMiniType<FilledLinkLegacyValue> = z.union([
+	FilledImageLinkLegacyValueSchema,
+	FilledFileLinkLegacyValueSchema,
+	FilledDocumentLinkLegacyValueSchema,
+	FilledExternalLinkLegacyValueSchema,
+])
+
+type FilledImageLinkLegacyValue = z.infer<typeof FilledImageLinkLegacyValueSchema>
+type FilledFileLinkLegacyValue = z.infer<typeof FilledFileLinkLegacyValueSchema>
+type FilledDocumentLinkLegacyValue = z.infer<typeof FilledDocumentLinkLegacyValueSchema>
+type FilledExternalLinkLegacyValue = z.infer<typeof FilledExternalLinkLegacyValueSchema>
+export type FilledLinkLegacyValue =
+	| FilledImageLinkLegacyValue
+	| FilledFileLinkLegacyValue
+	| FilledDocumentLinkLegacyValue
+	| FilledExternalLinkLegacyValue
+
+const EmptyLinkLegacyValueSchema: z.ZodMiniType<EmptyLinkLegacyValue> = z.union([
+	EmptyImageLinkLegacyValueSchema,
+	EmptyFileLinkLegacyValueSchema,
+	EmptyMediaLinkLegacyValueSchema,
+	EmptyDocumentLinkLegacyValueSchema,
+	EmptyExternalLinkLegacyValueSchema,
+	AnyLinkLegacySchema,
+])
+
+type EmptyImageLinkLegacyValue = z.infer<typeof EmptyImageLinkLegacyValueSchema>
+type EmptyFileLinkLegacyValue = z.infer<typeof EmptyFileLinkLegacyValueSchema>
+type EmptyMediaLinkLegacyValue = z.infer<typeof EmptyMediaLinkLegacyValueSchema>
+type EmptyDocumentLinkLegacyValue = z.infer<typeof EmptyDocumentLinkLegacyValueSchema>
+type EmptyExternalLinkLegacyValue = z.infer<typeof EmptyExternalLinkLegacyValueSchema>
+type AnyLinkLegacy = z.infer<typeof AnyLinkLegacySchema>
+export type EmptyLinkLegacyValue =
+	| EmptyImageLinkLegacyValue
+	| EmptyFileLinkLegacyValue
+	| EmptyMediaLinkLegacyValue
+	| EmptyDocumentLinkLegacyValue
+	| EmptyExternalLinkLegacyValue
+	| AnyLinkLegacy
+
+const LinkLegacyValueSchema: z.ZodMiniType<LinkLegacyValue> = z.union([
+	FilledLinkLegacyValueSchema,
+	EmptyLinkLegacyValueSchema,
+])
+
+export type LinkLegacyValue = FilledLinkLegacyValue | EmptyLinkLegacyValue
+
+// We cannot use z.extend here because we're working with unions.
+// z.intersection wouldn't work also for the same reason.
+export const LinkLegacySchema = z.pipe(
+	z.pipe(
+		z.pipe(
+			z.record(z.string(), z.unknown()),
+			z.transform(
+				({
+					key,
+					text,
+					variant,
+					...value
+				}): {
+					key?: unknown
+					text?: unknown
+					variant?: unknown
+					value: Record<string, unknown>
+				} => ({ key, text, variant, value }),
+			),
+		),
+		z.object({
+			key: z.optional(z.string()),
+			text: z.optional(z.string()),
+			variant: z.optional(z.string()),
+			value: LinkLegacyValueSchema as z.ZodMiniType<LinkLegacyValue, Record<string, unknown>>,
+		}),
+	),
+	z.transform(({ key, text, variant, value }) => ({
+		key: z.uuidv4().safeParse(key).data ?? crypto.randomUUID(),
+		...(text ? { text } : {}),
+		...(variant ? { variant } : {}),
+		...value,
+	})),
+)
+
+export type LinkLegacy = z.infer<typeof LinkLegacySchema>