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

package/src/model/diff/variation.ts

@@ -0,0 +1,152 @@
+import type { GroupModel } from "../group"
+import { GroupFieldType } from "../group"
+import type { NestableModel } from "../nestable"
+import type { Variation } from "../slice"
+import { type DiffChange, DiffOperation } from "./changes"
+import { isNotEmpty, zipObjects } from "./utils"
+import type {
+	GroupWidgetWithFieldsDiff,
+	NestableWidgetDiff,
+	SlicePrimaryWidgetDiff,
+} from "./widgets"
+
+export type VariationMetadata = Omit<Variation, "primary" | "items">
+export type VariationDiff = DiffChange<
+	Variation,
+	Partial<VariationMetadata> & {
+		primary?: Record<string, SlicePrimaryWidgetDiff>
+		items?: Record<string, NestableWidgetDiff>
+	}
+>
+
+function compareVariationMeta(
+	variationA?: Variation,
+	variationB?: Variation,
+): Partial<VariationMetadata> {
+	const zippedVariations = zipObjects(variationA, variationB)
+
+	return Object.entries(zippedVariations).reduce((acc, [key, value]) => {
+		if (key === "primary" || key === "items") return acc
+
+		if (value?.left === value?.right) return acc
+		return { ...acc, [key]: value?.right }
+	}, {})
+}
+
+function compareWidgets<TWidget extends NestableModel | GroupModel>(
+	widgetsA?: { [key: string]: TWidget },
+	widgetsB?: { [key: string]: TWidget },
+):
+	| Record<string, TWidget extends GroupModel ? SlicePrimaryWidgetDiff : NestableWidgetDiff>
+	| undefined {
+	const zippedWidgets = zipObjects(widgetsA, widgetsB)
+
+	const diffWidgets = Object.entries(zippedWidgets).reduce((acc, [widgetKey, widgetValue]) => {
+		if (JSON.stringify(widgetValue?.left) === JSON.stringify(widgetValue?.right)) return acc
+
+		const changes = (() => {
+			if (!widgetValue?.left && !widgetValue?.right) return
+
+			if (widgetValue?.left && !widgetValue.right) {
+				return {
+					op: DiffOperation.Removed,
+				}
+			}
+
+			if (!widgetValue?.left && widgetValue?.right) {
+				if (widgetValue.right?.type === GroupFieldType) {
+					const group: GroupWidgetWithFieldsDiff = {
+						...widgetValue.right,
+						config: {
+							...widgetValue.right.config,
+							fields: {},
+						},
+					}
+					// On added groups, this basically marks all fields in the group as added
+					group.config.fields = compareWidgets(undefined, widgetValue.right.config?.fields) || {}
+
+					return {
+						op: DiffOperation.Added,
+						value: group,
+					}
+				}
+
+				return {
+					op: DiffOperation.Added,
+					value: widgetValue.right,
+				}
+			}
+
+			if (widgetValue.right?.type === GroupFieldType) {
+				const group: GroupWidgetWithFieldsDiff = {
+					...widgetValue.right,
+					config: {
+						...widgetValue.right.config,
+						fields: {},
+					},
+				}
+				// On updated groups, this also compares the fields inside the group
+				group.config.fields =
+					compareWidgets(
+						widgetValue.left?.type === GroupFieldType
+							? widgetValue.left?.config?.fields
+							: undefined,
+						widgetValue.right.config?.fields,
+					) || {}
+
+				return {
+					op: DiffOperation.Updated,
+					value: group,
+				}
+			}
+
+			return {
+				op: DiffOperation.Updated,
+				value: widgetValue.right,
+			}
+		})()
+
+		if (!changes) return acc
+
+		return {
+			...acc,
+			[widgetKey]: changes,
+		}
+	}, {})
+
+	return isNotEmpty(diffWidgets) ? diffWidgets : undefined
+}
+
+export const VariationComparator = {
+	compare(variationA?: Variation, variationB?: Variation): VariationDiff | undefined {
+		if (variationA && !variationB)
+			return {
+				op: DiffOperation.Removed,
+			}
+		if (!variationA && variationB) {
+			return {
+				op: DiffOperation.Added,
+				value: variationB,
+			}
+		}
+
+		const diffMeta = compareVariationMeta(variationA, variationB)
+
+		const diffPrimary = compareWidgets(variationA?.primary, variationB?.primary)
+		const diffItems = compareWidgets(variationA?.items, variationB?.items)
+
+		const diffVariation = {
+			...diffMeta,
+			...(diffPrimary ? { primary: diffPrimary } : {}),
+			...(diffItems ? { items: diffItems } : {}),
+		}
+
+		if (isNotEmpty(diffVariation)) {
+			return {
+				op: DiffOperation.Updated,
+				value: diffVariation,
+			}
+		}
+		return undefined
+	},
+}

package/src/model/diff/widgets.ts

@@ -0,0 +1,15 @@
+import type { GroupModel } from "../group"
+import type { NestableModel } from "../nestable"
+import type { DiffChange } from "./changes"
+
+export type NestableWidgetDiff = DiffChange<NestableModel, NestableModel>
+
+export type GroupWidgetWithFieldsDiff = Omit<GroupModel, "config"> & {
+	config: Omit<NonNullable<GroupModel["config"]>, "fields"> & {
+		fields?: Record<string, GroupWidgetDiff | NestableWidgetDiff>
+	}
+}
+
+export type GroupWidgetDiff = DiffChange<GroupWidgetWithFieldsDiff, GroupWidgetWithFieldsDiff>
+
+export type SlicePrimaryWidgetDiff = NestableWidgetDiff | GroupWidgetDiff

package/src/model/embed.ts

@@ -0,0 +1,15 @@
+import { z } from "zod/mini"
+
+const EmbedConfigSchema = z.object({
+	label: z.nullish(z.string()),
+	placeholder: z.optional(z.string()),
+	useAsTitle: z.optional(z.boolean()),
+})
+
+export const EmbedModelSchema = z.object({
+	type: z.literal("Embed"),
+	fieldset: z.nullish(z.string()),
+	config: z.optional(EmbedConfigSchema),
+})
+
+export type EmbedModel = z.infer<typeof EmbedModelSchema>

package/src/model/geopoint.ts

@@ -0,0 +1,13 @@
+import { z } from "zod/mini"
+
+const GeoPointConfigSchema = z.object({
+	label: z.nullish(z.string()),
+})
+
+export const GeoPointModelSchema = z.object({
+	type: z.literal("GeoPoint"),
+	fieldset: z.nullish(z.string()),
+	config: z.optional(GeoPointConfigSchema),
+})
+
+export type GeoPointModel = z.infer<typeof GeoPointModelSchema>

package/src/model/group.ts

@@ -0,0 +1,36 @@
+import { z } from "zod/mini"
+
+import { WidgetKeySchema } from "../common/widgetKey"
+import { NestableModelSchema } from "./nestable"
+
+export const GroupFieldType = "Group"
+
+// Factory to create group config schema with configurable widget types
+const createGroupConfigSchema = <TWidgets extends z.ZodMiniType>(widgets: TWidgets) =>
+	z.object({
+		label: z.nullish(z.string()),
+		repeat: z.optional(z.boolean()),
+		fields: z.optional(z.record(WidgetKeySchema, widgets)),
+	})
+
+// Factory to create group schema with configurable widget types
+const createGroupSchema = <TWidgets extends z.ZodMiniType>(widgets: TWidgets) =>
+	z.object({
+		type: z.literal(GroupFieldType),
+		fieldset: z.nullish(z.string()),
+		icon: z.optional(z.string()),
+		description: z.optional(z.string()),
+		config: z.optional(createGroupConfigSchema(widgets)),
+	})
+
+// NestedGroup - only allows Nestable in fields (no further nesting)
+export const NestedGroupModelSchema = createGroupSchema(NestableModelSchema)
+
+export type NestedGroupModel = z.infer<typeof NestedGroupModelSchema>
+
+// Group - allows Nestable | NestedGroup in fields (max 2 levels of nesting)
+export const GroupModelSchema = createGroupSchema(
+	z.union([NestableModelSchema, NestedGroupModelSchema]),
+)
+
+export type GroupModel = z.infer<typeof GroupModelSchema>

package/src/model/image.ts

@@ -0,0 +1,54 @@
+import { z } from "zod/mini"
+
+/**
+ * SideConstraint accepts multiple input formats and normalizes to number | null:
+ * - Integer values
+ * - String integers (e.g., "100")
+ * - Pixel strings (e.g., "100px")
+ * - "auto" or "" → null
+ * - null
+ */
+export const SideConstraintSchema = z.union([
+	z.pipe(
+		z.literal("auto"),
+		z.transform(() => null),
+	),
+	z.pipe(
+		z.literal(""),
+		z.transform(() => null),
+	),
+	z.null(),
+	z.number().check(z.int()),
+	z.pipe(
+		z.string(),
+		z.transform((s: string) => parseInt(s.replace("px", ""), 10)),
+	),
+])
+
+export const ImageConstraintSchema = z.object({
+	width: z.optional(SideConstraintSchema),
+	height: z.optional(SideConstraintSchema),
+})
+
+export type ImageConstraint = z.infer<typeof ImageConstraintSchema>
+
+const ThumbnailSchema = z.object({
+	name: z.string(),
+	width: z.optional(SideConstraintSchema),
+	height: z.optional(SideConstraintSchema),
+})
+
+const ImageConfigSchema = z.object({
+	label: z.nullish(z.string()),
+	placeholder: z.optional(z.string()),
+	constraint: z.optional(ImageConstraintSchema),
+	thumbnails: z.optional(z.array(ThumbnailSchema)),
+})
+
+export const ImageModelSchema = z.object({
+	type: z.literal("Image"),
+	fieldset: z.nullish(z.string()),
+	config: z.optional(ImageConfigSchema),
+})
+
+export type ImageModel = z.infer<typeof ImageModelSchema>

package/src/model/integrationField.ts

@@ -0,0 +1,15 @@
+import { z } from "zod/mini"
+
+const IntegrationFieldConfigSchema = z.object({
+	label: z.nullish(z.string()),
+	placeholder: z.optional(z.string()),
+	catalog: z.optional(z.string()),
+})
+
+export const IntegrationFieldModelSchema = z.object({
+	type: z.literal("IntegrationFields"),
+	fieldset: z.nullish(z.string()),
+	config: z.optional(IntegrationFieldConfigSchema),
+})
+
+export type IntegrationFieldModel = z.infer<typeof IntegrationFieldModelSchema>

package/src/model/link.ts

@@ -0,0 +1,147 @@
+import { z } from "zod/mini"
+
+// Accepts string | string[], normalizes string to [string]
+const MasksArrayStringSchema = z.pipe(
+	z.union([z.array(z.string()), z.string()]),
+	z.transform((val): readonly string[] => (typeof val === "string" ? [val] : val)),
+)
+
+// --- CustomTypes hierarchy (field selection in content relationship fields) ---
+
+// Level 2
+
+const noDuplicateStrings = z.refine(
+	(arr) => new Set(arr as string[]).size === (arr as string[]).length,
+	"Fields have duplicates.",
+)
+
+const CustomTypeLevel2FieldGroupFieldsSchema = z.readonly(
+	z.array(z.string()).check(noDuplicateStrings),
+)
+
+const CustomTypeLevel2FieldSchema = z.union([
+	z.object({ id: z.string(), fields: CustomTypeLevel2FieldGroupFieldsSchema }),
+	z.string(),
+])
+
+const noDuplicateIds = (items: unknown) => {
+	const arr = items as { id: string }[] | string[]
+	const ids = new Set(arr.map((item) => (typeof item === "string" ? item : item.id)))
+	return ids.size === arr.length
+}
+
+const CustomTypeLevel2FieldsSchema = z.readonly(
+	z.array(CustomTypeLevel2FieldSchema).check(z.refine(noDuplicateIds, "Fields have duplicates.")),
+)
+
+const CustomTypeLevel2Schema = z.union([
+	z.string(),
+	z.object({ id: z.string(), fields: CustomTypeLevel2FieldsSchema }),
+])
+
+const CustomTypesLevel2Schema = z.readonly(
+	z.array(CustomTypeLevel2Schema).check(z.refine(noDuplicateIds, "Custom types have duplicates.")),
+)
+
+// Level 1
+
+const CustomTypeLevel1FieldCustomTypesSchema = z.object({
+	id: z.string(),
+	customtypes: CustomTypesLevel2Schema,
+})
+
+const CustomTypeLevel1FieldGroupFieldSchema = z.union([
+	CustomTypeLevel1FieldCustomTypesSchema,
+	z.string(),
+])
+
+const CustomTypeLevel1FieldGroupFieldsSchema = z.readonly(
+	z
+		.array(CustomTypeLevel1FieldGroupFieldSchema)
+		.check(z.refine(noDuplicateIds, "Fields have duplicates.")),
+)
+
+const CustomTypeLevel1FieldSchema = z.union([
+	z.object({
+		id: z.string(),
+		fields: CustomTypeLevel1FieldGroupFieldsSchema,
+	}),
+	CustomTypeLevel1FieldCustomTypesSchema,
+	z.string(),
+])
+
+const CustomTypeLevel1FieldsSchema = z.readonly(
+	z.array(CustomTypeLevel1FieldSchema).check(z.refine(noDuplicateIds, "Fields have duplicates.")),
+)
+
+const CustomTypeLevel1Schema = z.union([
+	z.string(),
+	z.object({ id: z.string(), fields: CustomTypeLevel1FieldsSchema }),
+])
+
+const CustomTypesSchema = z.readonly(
+	z.array(CustomTypeLevel1Schema).check(({ value, issues }) => {
+		const cts = value as ({ id: string } | string)[]
+		const push = (message: string) => issues.push({ code: "custom", input: value, message })
+		const strings = new Set<string>()
+		const objects = new Set<string>()
+		for (const ct of cts) {
+			let failed = false
+			if (typeof ct === "string") {
+				failed = objects.has(ct)
+				strings.add(ct)
+			} else {
+				const { id } = ct
+				failed = strings.has(id) || objects.has(id)
+				objects.add(id)
+			}
+			if (failed) {
+				push("Custom types have duplicates.")
+				return
+			}
+		}
+		if (objects.size > 1) {
+			push("Cannot have multiple custom types with fields selection.")
+			return
+		}
+		if (strings.size > 0 && objects.size > 0) {
+			push("Cannot mix custom types as strings and objects with fields.")
+		}
+	}),
+)
+
+// --- Select with fallback to null ---
+
+const SelectWithFallbackSchema = z.pipe(
+	z.unknown(),
+	z.transform((val): "media" | "document" | "web" | null => {
+		if (val === "media" || val === "document" || val === "web" || val === null) {
+			return val
+		}
+		return null
+	}),
+)
+
+// --- LinkConfig and Link ---
+
+const LinkConfigSchema = z.object({
+	label: z.nullish(z.string()),
+	useAsTitle: z.optional(z.boolean()),
+	placeholder: z.optional(z.string()),
+	select: z.optional(SelectWithFallbackSchema),
+	customtypes: z.optional(CustomTypesSchema),
+	masks: z.optional(MasksArrayStringSchema),
+	tags: z.optional(MasksArrayStringSchema),
+	allowTargetBlank: z.optional(z.boolean()),
+	allowText: z.optional(z.boolean()),
+	repeat: z.optional(z.boolean()),
+	variants: z.optional(z.array(z.string())),
+})
+
+export const LinkModelSchema = z.object({
+	type: z.literal("Link"),
+	fieldset: z.nullish(z.string()),
+	config: z.optional(LinkConfigSchema),
+})
+
+export type LinkModel = z.infer<typeof LinkModelSchema>

package/src/model/nestable.ts

@@ -0,0 +1,39 @@
+import { z } from "zod/mini"
+
+import { BooleanModelSchema } from "./boolean"
+import { ColorModelSchema } from "./color"
+import { DateModelSchema } from "./date"
+import { EmbedModelSchema } from "./embed"
+import { GeoPointModelSchema } from "./geopoint"
+import { ImageModelSchema } from "./image"
+import { IntegrationFieldModelSchema } from "./integrationField"
+import { LinkModelSchema } from "./link"
+import { NumberModelSchema } from "./number"
+import { RangeModelSchema } from "./range"
+import { RichTextModelSchema } from "./richText"
+import { SelectModelSchema } from "./select"
+import { SeparatorModelSchema } from "./separator"
+import { TableModelSchema } from "./table"
+import { TextModelSchema } from "./text"
+import { TimestampModelSchema } from "./timestamp"
+
+export const NestableModelSchema = z.union([
+	BooleanModelSchema,
+	ColorModelSchema,
+	DateModelSchema,
+	EmbedModelSchema,
+	GeoPointModelSchema,
+	ImageModelSchema,
+	IntegrationFieldModelSchema,
+	LinkModelSchema,
+	NumberModelSchema,
+	RangeModelSchema,
+	RichTextModelSchema,
+	SelectModelSchema,
+	SeparatorModelSchema,
+	TableModelSchema,
+	TextModelSchema,
+	TimestampModelSchema,
+])
+
+export type NestableModel = z.infer<typeof NestableModelSchema>

package/src/model/number.ts

@@ -0,0 +1,26 @@
+import { z } from "zod/mini"
+
+// Accepts number directly or string that parses to number (like io-ts NumberFromString)
+const NumberOrStringToNumber = z.union([
+	z.number(),
+	z.pipe(
+		z.string(),
+		z.transform((s) => Number(s)),
+	),
+])
+
+const NumberConfigSchema = z.object({
+	label: z.nullish(z.string()),
+	placeholder: z.optional(z.string()),
+	min: z.optional(NumberOrStringToNumber),
+	max: z.optional(NumberOrStringToNumber),
+	step: z.optional(NumberOrStringToNumber),
+})
+
+export const NumberModelSchema = z.object({
+	type: z.literal("Number"),
+	fieldset: z.nullish(z.string()),
+	config: z.optional(NumberConfigSchema),
+})
+
+export type NumberModel = z.infer<typeof NumberModelSchema>

package/src/model/range.ts

@@ -0,0 +1,26 @@
+import { z } from "zod/mini"
+
+// Accepts number directly or string that parses to number (like io-ts NumberFromString)
+const NumberOrStringToNumber = z.union([
+	z.number(),
+	z.pipe(
+		z.string(),
+		z.transform((s) => Number(s)),
+	),
+])
+
+const RangeConfigSchema = z.object({
+	label: z.nullish(z.string()),
+	placeholder: z.optional(z.string()),
+	min: z.optional(NumberOrStringToNumber),
+	max: z.optional(NumberOrStringToNumber),
+	step: z.optional(NumberOrStringToNumber),
+})
+
+export const RangeModelSchema = z.object({
+	type: z.literal("Range"),
+	fieldset: z.nullish(z.string()),
+	config: z.optional(RangeConfigSchema),
+})
+
+export type RangeModel = z.infer<typeof RangeModelSchema>

package/src/model/richText.ts

@@ -0,0 +1,106 @@
+import { z } from "zod/mini"
+
+import { ImageConstraintSchema } from "./image"
+
+export const RichTextFieldType = "StructuredText"
+
+export const DEFAULT_OPTION = "paragraph"
+
+export const RichTextNodeType = {
+	heading1: "heading1",
+	heading2: "heading2",
+	heading3: "heading3",
+	heading4: "heading4",
+	heading5: "heading5",
+	heading6: "heading6",
+	paragraph: "paragraph",
+	preformatted: "preformatted",
+	orderedList: "o-list-item",
+	list: "list-item",
+	image: "image",
+	embed: "embed",
+	hyperlink: "hyperlink",
+	strong: "strong",
+	em: "em",
+	rtl: "rtl",
+} as const
+
+const VALID_NODE_TYPES = Object.values(RichTextNodeType)
+
+/**
+ * RichTextOptions parses comma-separated node types, filters invalid ones,
+ * and defaults to "paragraph" if empty or null.
+ */
+const RichTextOptionsSchema = z.pipe(
+	z.union([z.string(), z.null()]),
+	z.transform((s: string | null) => {
+		if (!s) return DEFAULT_OPTION
+		const entries = s.split(",").map((e: string) => e.trim())
+		const filtered = entries.filter((e: string) =>
+			VALID_NODE_TYPES.includes(e as (typeof VALID_NODE_TYPES)[number]),
+		)
+		return filtered.length ? filtered.join(",") : DEFAULT_OPTION
+	}),
+)
+
+/**
+ * RichTextLabels accepts multiple formats and normalizes to string[]:
+ * - null → []
+ * - "label" → ["label"]
+ * - ["a", "b"] → ["a", "b"]
+ * - { "": [{name: "a"}], "key": [{name: "b"}] } → ["a", "b"] (legacy format)
+ */
+const LegacyLabelsFormat = z.record(z.string(), z.array(z.object({ name: z.string() })))
+
+const RichTextLabelsSchema = z.pipe(
+	z.union([
+		z.pipe(
+			z.null(),
+			z.transform(() => [] as string[]),
+		),
+		z.pipe(
+			z.string(),
+			z.transform((s: string) => [s]),
+		),
+		z.array(z.string()),
+		z.pipe(
+			LegacyLabelsFormat,
+			z.transform((obj: Record<string, Array<{ name: string }>>) => {
+				const entries = Object.entries(obj)
+				if (!entries.length) return [] as string[]
+
+				// Handle legacy format with empty key
+				if (obj[""]) {
+					return obj[""].map((l: { name: string }) => l.name)
+				}
+
+				// Convert all entries to flat array of names
+				return entries
+					.reduce<string[]>((acc, [, labelsEntries]) => {
+						return acc.concat(labelsEntries.map((l: { name: string }) => l.name))
+					}, [])
+					.filter(Boolean)
+			}),
+		),
+	]),
+	z.transform((result: string[]) => result as readonly string[]),
+)
+
+const RichTextConfigSchema = z.object({
+	label: z.nullish(z.string()),
+	placeholder: z.optional(z.string()),
+	useAsTitle: z.optional(z.boolean()),
+	single: z.optional(RichTextOptionsSchema),
+	multi: z.optional(RichTextOptionsSchema),
+	imageConstraint: z.optional(ImageConstraintSchema),
+	labels: z.optional(RichTextLabelsSchema),
+	allowTargetBlank: z.optional(z.boolean()),
+})
+
+export const RichTextModelSchema = z.object({
+	type: z.literal(RichTextFieldType),
+	fieldset: z.nullish(z.string()),
+	config: z.optional(RichTextConfigSchema),
+})
+
+export type RichTextModel = z.infer<typeof RichTextModelSchema>

package/src/model/section.ts

@@ -0,0 +1,12 @@
+import { z } from "zod/mini"
+
+import { WidgetKeySchema } from "../common/widgetKey"
+import { DynamicWidgetModelSchema, StaticWidgetModelSchema } from "./widget"
+
+// StaticSection = Record<WidgetKey, StaticWidget>
+export const StaticSectionModelSchema = z.record(WidgetKeySchema, StaticWidgetModelSchema)
+export type StaticSectionModel = z.infer<typeof StaticSectionModelSchema>
+
+// DynamicSection = Record<WidgetKey, DynamicWidget>
+export const DynamicSectionModelSchema = z.record(WidgetKeySchema, DynamicWidgetModelSchema)
+export type DynamicSectionModel = z.infer<typeof DynamicSectionModelSchema>

package/src/model/select.ts

@@ -0,0 +1,30 @@
+import { z } from "zod/mini"
+
+// Options can be string, number, or boolean - all coerced to string
+// Matches io-ts behavior: t.union([t.string, StringFromNumber, StringFromBoolean])
+const SelectOptionSchema = z.union([
+	z.string(),
+	z.pipe(
+		z.number(),
+		z.transform((n) => n.toString()),
+	),
+	z.pipe(
+		z.boolean(),
+		z.transform((b) => b.toString()),
+	),
+])
+
+const SelectConfigSchema = z.object({
+	label: z.nullish(z.string()),
+	placeholder: z.optional(z.string()),
+	default_value: z.optional(z.string()),
+	options: z.optional(z.readonly(z.array(SelectOptionSchema))),
+})
+
+export const SelectModelSchema = z.object({
+	type: z.literal("Select"),
+	fieldset: z.nullish(z.string()),
+	config: z.optional(SelectConfigSchema),
+})
+
+export type SelectModel = z.infer<typeof SelectModelSchema>