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

package/src/model/boolean.ts

@@ -0,0 +1,15 @@
+import { z } from "zod/mini"
+
+const BooleanConfigSchema = z.object({
+	label: z.nullish(z.string()),
+	default_value: z.optional(z.boolean()),
+	placeholder_true: z.optional(z.string()),
+	placeholder_false: z.optional(z.string()),
+})
+
+export const BooleanModelSchema = z.object({
+	type: z.literal("Boolean"),
+	config: z.optional(BooleanConfigSchema),
+})
+
+export type BooleanModel = z.infer<typeof BooleanModelSchema>

package/src/model/color.ts

@@ -0,0 +1,14 @@
+import { z } from "zod/mini"
+
+const ColorConfigSchema = z.object({
+	label: z.nullish(z.string()),
+	placeholder: z.optional(z.string()),
+})
+
+export const ColorModelSchema = z.object({
+	type: z.literal("Color"),
+	fieldset: z.nullish(z.string()),
+	config: z.optional(ColorConfigSchema),
+})
+
+export type ColorModel = z.infer<typeof ColorModelSchema>

package/src/model/customType.ts

@@ -0,0 +1,26 @@
+import { z } from "zod/mini"
+
+import { DynamicSectionModelSchema, StaticSectionModelSchema } from "./section"
+
+// CustomTypeFormat - "page" | "custom"
+export const CustomTypeFormatSchema = z.enum(["page", "custom"])
+export type CustomTypeFormat = z.infer<typeof CustomTypeFormatSchema>
+
+// Factory to create CustomType schema with configurable section type
+const createCustomTypeSchema = <T extends z.ZodMiniType>(sectionSchema: T) =>
+	z.object({
+		id: z.string(),
+		label: z.nullish(z.string()),
+		repeatable: z._default(z.boolean(), true),
+		json: z.record(z.string(), sectionSchema),
+		status: z._default(z.boolean(), true),
+		format: z._default(CustomTypeFormatSchema, "custom"),
+	})
+
+// StaticCustomType - uses StaticSection (with full SharedSlice definitions)
+export const StaticCustomTypeModelSchema = createCustomTypeSchema(StaticSectionModelSchema)
+export type StaticCustomTypeModel = z.infer<typeof StaticCustomTypeModelSchema>
+
+// CustomType (dynamic) - uses DynamicSection (with SharedSliceRef references)
+export const CustomTypeModelSchema = createCustomTypeSchema(DynamicSectionModelSchema)
+export type CustomTypeModel = z.infer<typeof CustomTypeModelSchema>

package/src/model/date.ts

@@ -0,0 +1,15 @@
+import { z } from "zod/mini"
+
+const DateConfigSchema = z.object({
+	label: z.nullish(z.string()),
+	placeholder: z.optional(z.string()),
+	default: z.optional(z.string()),
+})
+
+export const DateModelSchema = z.object({
+	type: z.literal("Date"),
+	fieldset: z.nullish(z.string()),
+	config: z.optional(DateConfigSchema),
+})
+
+export type DateModel = z.infer<typeof DateModelSchema>

package/src/model/diff/index.ts

@@ -0,0 +1,4 @@
+export * from "./changes"
+export * from "./sharedSlice"
+export * from "./variation"
+export * from "./widgets"

package/src/{customtypes/diff/SharedSlice.ts → model/diff/sharedSlice.ts}

@@ -1,11 +1,11 @@
-import { Arrays, Objects } from "../../utils"
-import type { SharedSlice, Variation } from "../widgets/slices"
-import { type DiffChange, DiffOperation } from "./Changes"
-import { VariationComparator, VariationDiff } from "./Variation"
+import type { SharedSliceModel, SharedSliceModelVariation } from "../slice"
+import { type DiffChange, DiffOperation } from "./changes"
+import { isNotEmpty, toRecord, zipObjects } from "./utils"
+import { type VariationDiff, VariationComparator } from "./variation"
 
-export type SliceMetadata = Omit<SharedSlice, "variations">
+export type SliceMetadata = Omit<SharedSliceModel, "variations">
 export type SliceDiff = DiffChange<
-	SharedSlice,
+	SharedSliceModel,
 	Partial<
 		SliceMetadata & {
 			variations?: Partial<Record<string, VariationDiff>>
@@ -14,13 +14,13 @@ export type SliceDiff = DiffChange<
 >
 
 function compareSliceMeta(
-	sliceA?: SharedSlice,
-	sliceB?: SharedSlice,
+	sliceA?: SharedSliceModel,
+	sliceB?: SharedSliceModel,
 ): Partial<SliceMetadata> {
-	const zippedSlices = Objects.zipObjects(sliceA, sliceB)
+	const zippedSlices = zipObjects(sliceA, sliceB)
 
 	return Object.entries(zippedSlices).reduce((acc, [key, value]) => {
-		if (key === `variations`) return acc
+		if (key === "variations") return acc
 
 		if (value?.left === value?.right) return acc
 		return { ...acc, [key]: value?.right }
@@ -28,7 +28,7 @@ function compareSliceMeta(
 }
 
 export const SliceComparator = {
-	compare(sliceA?: SharedSlice, sliceB?: SharedSlice): SliceDiff | undefined {
+	compare(sliceA?: SharedSliceModel, sliceB?: SharedSliceModel): SliceDiff | undefined {
 		if (!sliceA && sliceB)
 			return {
 				op: DiffOperation.Added,
@@ -41,9 +41,9 @@ export const SliceComparator = {
 
 		const diffMeta = compareSliceMeta(sliceA, sliceB)
 
-		const zippedSlices = Objects.zipObjects<Variation>(
-			sliceA && Arrays.toRecord(sliceA.variations, (v) => v.id),
-			sliceB && Arrays.toRecord(sliceB.variations, (v) => v.id),
+		const zippedSlices = zipObjects<SharedSliceModelVariation>(
+			sliceA && toRecord(sliceA.variations, (v) => v.id),
+			sliceB && toRecord(sliceB.variations, (v) => v.id),
 		)
 
 		const diffVariations = Object.entries(zippedSlices).reduce<
@@ -61,12 +61,10 @@ export const SliceComparator = {
 
 		const diffSlice = {
 			...diffMeta,
-			...(Objects.isNotEmpty(diffVariations)
-				? { variations: diffVariations }
-				: {}),
+			...(isNotEmpty(diffVariations) ? { variations: diffVariations } : {}),
 		}
 
-		if (Objects.isNotEmpty(diffSlice)) {
+		if (isNotEmpty(diffSlice)) {
 			return {
 				op: DiffOperation.Updated,
 				value: diffSlice,

package/src/model/diff/utils.ts

@@ -0,0 +1,45 @@
+/**
+ * Zips two objects together by their keys, creating an object with
+ * both left and right values for each key.
+ */
+export function zipObjects<A, B = A>(
+	objLeft?: Partial<Record<string, A>> | undefined,
+	objRight?: Partial<Record<string, B>> | undefined,
+): Partial<Record<string, { left?: A | undefined; right?: B | undefined }>> {
+	const allKeys = [...new Set(Object.keys(objLeft || {}).concat(Object.keys(objRight || {})))]
+
+	return allKeys.reduce<Record<string, { left?: A | undefined; right?: B | undefined }>>(
+		(acc, key) => {
+			const left = objLeft?.[key]
+			const right = objRight?.[key]
+			return {
+				...acc,
+				[key]: { left, right },
+			}
+		},
+		{},
+	)
+}
+
+/**
+ * Returns true if the object has at least one key.
+ */
+export function isNotEmpty<A extends object>(obj: A): boolean {
+	return Boolean(Object.keys(obj).length)
+}
+
+/**
+ * Converts an array to a record using the provided key function.
+ */
+export function toRecord<A extends object>(
+	arr: ReadonlyArray<A>,
+	key: (obj: A) => string,
+): Record<string, A> {
+	return arr.reduce<Record<string, A>>((acc, entry) => {
+		const k = key(entry)
+		return {
+			...acc,
+			[k]: entry,
+		}
+	}, {})
+}

package/src/model/diff/variation.ts

@@ -0,0 +1,155 @@
+import type { GroupModel } from "../group"
+import { GroupFieldType } from "../group"
+import type { NestableModel } from "../nestable"
+import type { SharedSliceModelVariation } from "../slice"
+import { type DiffChange, DiffOperation } from "./changes"
+import { isNotEmpty, zipObjects } from "./utils"
+import type {
+	GroupWidgetWithFieldsDiff,
+	NestableWidgetDiff,
+	SlicePrimaryWidgetDiff,
+} from "./widgets"
+
+export type VariationMetadata = Omit<SharedSliceModelVariation, "primary" | "items">
+export type VariationDiff = DiffChange<
+	SharedSliceModelVariation,
+	Partial<VariationMetadata> & {
+		primary?: Record<string, SlicePrimaryWidgetDiff>
+		items?: Record<string, NestableWidgetDiff>
+	}
+>
+
+function compareVariationMeta(
+	variationA?: SharedSliceModelVariation,
+	variationB?: SharedSliceModelVariation,
+): 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?: SharedSliceModelVariation,
+		variationB?: SharedSliceModelVariation,
+	): 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,39 @@
+import { z } from "zod/mini"
+
+import { WidgetKeySchema } from "../common/widgetKey"
+import type { NestableModel } from "./nestable"
+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]) as z.ZodMiniType<
+		NestableModel | NestedGroupModel
+	>,
+)
+
+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.ZodMiniType<number | null> = 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,141 @@
+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): 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.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
+	.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
+	.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
+	.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
+	.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.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>