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

package/src/model/nestable.ts

@@ -0,0 +1,71 @@
+import { z } from "zod/mini"
+
+import type { BooleanModel } from "./boolean"
+import { BooleanModelSchema } from "./boolean"
+import type { ColorModel } from "./color"
+import { ColorModelSchema } from "./color"
+import type { DateModel } from "./date"
+import { DateModelSchema } from "./date"
+import type { EmbedModel } from "./embed"
+import { EmbedModelSchema } from "./embed"
+import type { GeoPointModel } from "./geopoint"
+import { GeoPointModelSchema } from "./geopoint"
+import type { ImageModel } from "./image"
+import { ImageModelSchema } from "./image"
+import type { IntegrationFieldModel } from "./integrationField"
+import { IntegrationFieldModelSchema } from "./integrationField"
+import type { LinkModel } from "./link"
+import { LinkModelSchema } from "./link"
+import type { NumberModel } from "./number"
+import { NumberModelSchema } from "./number"
+import type { RangeModel } from "./range"
+import { RangeModelSchema } from "./range"
+import type { RichTextModel } from "./richText"
+import { RichTextModelSchema } from "./richText"
+import type { SelectModel } from "./select"
+import { SelectModelSchema } from "./select"
+import type { SeparatorModel } from "./separator"
+import { SeparatorModelSchema } from "./separator"
+import type { TableModel } from "./table"
+import { TableModelSchema } from "./table"
+import type { TextModel } from "./text"
+import { TextModelSchema } from "./text"
+import type { TimestampModel } from "./timestamp"
+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 =
+	| BooleanModel
+	| ColorModel
+	| DateModel
+	| EmbedModel
+	| GeoPointModel
+	| ImageModel
+	| IntegrationFieldModel
+	| LinkModel
+	| NumberModel
+	| RangeModel
+	| RichTextModel
+	| SelectModel
+	| SeparatorModel
+	| TableModel
+	| TextModel
+	| TimestampModel

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,109 @@
+import { z } from "zod/mini"
+
+import { ImageConstraintSchema } from "./image"
+
+export const RichTextFieldType = "StructuredText"
+
+export const DEFAULT_OPTION = "paragraph"
+
+export const RichTextModelNodeType = {
+	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
+
+export type RichTextModelNodeTypes =
+	(typeof RichTextModelNodeType)[keyof typeof RichTextModelNodeType]
+
+const VALID_NODE_TYPES = Object.values(RichTextModelNodeType)
+
+/**
+ * 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.ZodMiniType<string[]> = 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 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.ZodMiniType<string> = 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.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>

package/src/model/separator.ts

@@ -0,0 +1,12 @@
+import { z } from "zod/mini"
+
+const SeparatorConfigSchema = z.object({
+	label: z.nullish(z.string()),
+})
+
+export const SeparatorModelSchema = z.object({
+	type: z.literal("Separator"),
+	config: z.optional(SeparatorConfigSchema),
+})
+
+export type SeparatorModel = z.infer<typeof SeparatorModelSchema>

package/src/model/slice.ts

@@ -0,0 +1,131 @@
+import { z } from "zod/mini"
+
+import { WidgetKeySchema } from "../common/widgetKey"
+import type { GroupModel, NestedGroupModel } from "./group"
+import { GroupModelSchema, NestedGroupModelSchema } from "./group"
+import type { NestableModel } from "./nestable"
+import { NestableModelSchema } from "./nestable"
+
+// Simple (before 2020)
+export const LegacySliceModelSchema: z.ZodMiniType<LegacySliceModel> = z.union([
+	NestableModelSchema,
+	NestedGroupModelSchema,
+])
+
+export type LegacySliceModel = NestableModel | NestedGroupModel
+
+// Composite (2020 to 2021)
+export const CompositeSliceType = "Slice" as const
+
+const CompositeSliceConfigSchema = z.object({
+	label: z.nullish(z.string()),
+})
+
+export const CompositeSliceModelSchema = z.object({
+	type: z.literal(CompositeSliceType),
+	fieldset: z.nullish(z.string()),
+	description: z.optional(z.string()),
+	icon: z.optional(z.string()),
+	display: z.optional(z.string()),
+	"non-repeat": z.optional(z.record(WidgetKeySchema, NestableModelSchema)),
+	repeat: z.optional(z.record(WidgetKeySchema, NestableModelSchema)),
+	config: z.optional(CompositeSliceConfigSchema),
+})
+
+export type CompositeSliceModel = z.infer<typeof CompositeSliceModelSchema>
+
+// Shared (2021 to present)
+export const SharedSliceType = "SharedSlice" as const
+
+const IMAGE_PLACEHOLDER_URL =
+	"https://images.prismic.io/slice-machine/621a5ec4-0387-4bc5-9860-2dd46cbc07cd_default_ss.png?auto=compress,format"
+
+export const SharedSliceModelVariationSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	description: z.string(),
+	imageUrl: z._default(z.string(), IMAGE_PLACEHOLDER_URL),
+	docURL: z.string(),
+	version: z.string(),
+	display: z.optional(z.string()),
+	primary: z.optional(
+		z.record(
+			z.string(),
+			z.union([NestableModelSchema, GroupModelSchema]) as z.ZodMiniType<NestableModel | GroupModel>,
+		),
+	),
+	items: z.optional(z.record(z.string(), NestableModelSchema)),
+})
+
+export type SharedSliceModelVariation = z.infer<typeof SharedSliceModelVariationSchema>
+
+export const SharedSliceModelSchema = z.object({
+	id: z.string(),
+	type: z.literal(SharedSliceType),
+	name: z.string(),
+	variations: z.array(SharedSliceModelVariationSchema),
+	description: z.optional(z.string()),
+	legacyPaths: z.optional(z.record(z.string(), z.string())),
+})
+
+export type SharedSliceModel = z.infer<typeof SharedSliceModelSchema>
+
+export const SharedSliceRefModelSchema = z.object({
+	type: z.literal(SharedSliceType),
+})
+
+export type SharedSliceRefModel = z.infer<typeof SharedSliceRefModelSchema>
+
+// Used to represent a shared slice content which can only be
+// of a given shared slice variation type.
+export const SharedSliceVariationContentModelSchema = z.object({
+	type: z.literal(SharedSliceType),
+	sliceName: z.string(),
+	variationID: z.string(),
+	fields: z.pick(SharedSliceModelVariationSchema, { primary: true, items: true }),
+})
+
+export type SharedSliceVariationContentModel = z.infer<
+	typeof SharedSliceVariationContentModelSchema
+>
+
+// All
+
+// Used when slices reference SharedSlice by ref (not full definition)
+export const DynamicSliceModelSchema: z.ZodMiniType<DynamicSliceModel> = z.union([
+	CompositeSliceModelSchema,
+	LegacySliceModelSchema,
+	SharedSliceRefModelSchema,
+])
+
+export type DynamicSliceModel = CompositeSliceModel | LegacySliceModel | SharedSliceRefModel
+
+// Used when slices include full SharedSlice definition
+export const StaticSliceModelSchema: z.ZodMiniType<StaticSliceModel> = z.union([
+	CompositeSliceModelSchema,
+	LegacySliceModelSchema,
+	SharedSliceModelSchema,
+])
+
+export type StaticSliceModel = CompositeSliceModel | LegacySliceModel | SharedSliceModel
+
+// Used to represent a slice content model as shared slice variations
+// can only be of a given shared slice variation type.
+export const SliceContentModelSchema: z.ZodMiniType<SliceContentModel> = z.union([
+	CompositeSliceModelSchema,
+	LegacySliceModelSchema,
+	SharedSliceVariationContentModelSchema,
+])
+
+export type SliceContentModel =
+	| CompositeSliceModel
+	| LegacySliceModel
+	| SharedSliceVariationContentModel
+
+// Model types
+export const SliceModelTypeSchema = z.union([
+	z.literal(CompositeSliceType),
+	z.literal(SharedSliceType),
+])
+
+export type SliceModelType = z.infer<typeof SliceModelTypeSchema>

package/src/model/slices.ts

@@ -0,0 +1,54 @@
+import { z } from "zod/mini"
+
+import { WidgetKeySchema } from "../common/widgetKey"
+import { StaticSliceModelSchema, DynamicSliceModelSchema } from "./slice"
+
+export const LegacySlicesFieldType = "Choice"
+export const SlicesFieldType = "Slices"
+
+// Label configuration for slices
+const SlicesLabelSchema = z.object({
+	name: z.string(),
+	display: z.optional(z.string()),
+})
+
+export const SlicesLabelsSchema = z.union([
+	z.record(z.string(), z.array(SlicesLabelSchema)),
+	z.null(),
+])
+
+// Config
+const getSlicesConfigSchema = <
+	TSliceSchema extends typeof StaticSliceModelSchema | typeof DynamicSliceModelSchema,
+>(
+	sliceSchema: TSliceSchema,
+) =>
+	z.object({
+		label: z.nullish(z.string()),
+		labels: z.optional(SlicesLabelsSchema),
+		choices: z.optional(z.record(WidgetKeySchema, sliceSchema)),
+	})
+
+const StaticSlicesConfigSchema = getSlicesConfigSchema(StaticSliceModelSchema)
+
+const DynamicSlicesConfigSchema = getSlicesConfigSchema(DynamicSliceModelSchema)
+
+// Model
+const getSlicesSchema = <
+	TConfig extends typeof StaticSlicesConfigSchema | typeof DynamicSlicesConfigSchema,
+>(
+	configSchema: TConfig,
+) =>
+	z.object({
+		type: z.union([z.literal(SlicesFieldType), z.literal(LegacySlicesFieldType)]),
+		fieldset: z.nullish(z.string()),
+		config: z.optional(configSchema),
+	})
+
+export const StaticSlicesModelSchema = getSlicesSchema(StaticSlicesConfigSchema)
+
+export type StaticSlicesModel = z.infer<typeof StaticSlicesModelSchema>
+
+export const DynamicSlicesModelSchema = getSlicesSchema(DynamicSlicesConfigSchema)
+
+export type DynamicSlicesModel = z.infer<typeof DynamicSlicesModelSchema>

package/src/model/table.ts

@@ -0,0 +1,29 @@
+import { z } from "zod/mini"
+
+import { RichTextModelNodeType, type RichTextModel } from "./richText"
+
+const TableConfigSchema = z.object({
+	label: z.nullish(z.string()),
+})
+
+export const TableModelSchema = z.object({
+	type: z.literal("Table"),
+	config: z.optional(TableConfigSchema),
+})
+
+export type TableModel = z.infer<typeof TableModelSchema>
+
+// TableCell configuration constant (used for cell rich text configuration)
+export const TableCellModelNodeTypes = [
+	RichTextModelNodeType.paragraph,
+	RichTextModelNodeType.strong,
+	RichTextModelNodeType.em,
+	RichTextModelNodeType.hyperlink,
+]
+
+export const TableCellModel: RichTextModel = {
+	type: "StructuredText" as const,
+	config: {
+		multi: TableCellModelNodeTypes.join(","),
+	},
+}

package/src/model/text.ts

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

package/src/model/timestamp.ts

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

package/src/model/uid.ts

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

package/src/model/widget.ts

@@ -0,0 +1,67 @@
+import { z } from "zod/mini"
+
+import type { GroupModel } from "./group"
+import { GroupModelSchema } from "./group"
+import type { NestableModel } from "./nestable"
+import { NestableModelSchema } from "./nestable"
+import { SliceModelTypeSchema } from "./slice"
+import type { DynamicSlicesModel, StaticSlicesModel } from "./slices"
+import { DynamicSlicesModelSchema, StaticSlicesModelSchema } from "./slices"
+import type { UIDModel } from "./uid"
+import { UIDModelSchema } from "./uid"
+
+// StaticWidget = UID | Nestable | Group | StaticSlices
+export const StaticWidgetModelSchema: z.ZodMiniType<StaticWidgetModel> = z.union([
+	UIDModelSchema,
+	NestableModelSchema,
+	GroupModelSchema,
+	StaticSlicesModelSchema,
+])
+
+export type StaticWidgetModel = UIDModel | NestableModel | GroupModel | StaticSlicesModel
+
+// DynamicWidget = UID | Nestable | Group | DynamicSlices
+export const DynamicWidgetModelSchema: z.ZodMiniType<DynamicWidgetModel> = z.union([
+	UIDModelSchema,
+	NestableModelSchema,
+	GroupModelSchema,
+	DynamicSlicesModelSchema,
+])
+
+export type DynamicWidgetModel = UIDModel | NestableModel | GroupModel | DynamicSlicesModel
+
+// FieldModelType - all possible field type strings
+export const FieldModelTypeSchema = z.enum([
+	"Color",
+	"Boolean",
+	"Number",
+	"Embed",
+	"GeoPoint",
+	"Date",
+	"Range",
+	"StructuredText",
+	"Select",
+	"Separator",
+	"Table",
+	"Text",
+	"Timestamp",
+	"Link",
+	"Image",
+	"IntegrationFields",
+	"UID",
+	"Group",
+	"Slices",
+	"Choice",
+])
+
+export type FieldModelType = z.infer<typeof FieldModelTypeSchema>
+
+// Field and slice types
+export const FieldOrSliceTypeSchema = z.union([
+	FieldModelTypeSchema,
+	SliceModelTypeSchema,
+	// Repeatable links are "meta" types like slices and shared slices
+	z.literal("Repeatable.Link"),
+])
+
+export type FieldOrSliceType = z.infer<typeof FieldOrSliceTypeSchema>