@prismicio/types-internal 4.0.0 → 4.1.0-canary.858108c

package/src/helpers/customTypeModel.ts

@@ -1,9 +1,12 @@
-import type { CustomTypeModel, StaticCustomTypeModel } from "../model/customType"
-import type { StaticSectionModel } from "../model/section"
+import type {
+	DynamicCustomTypeModel,
+	StaticCustomTypeModel,
+	StaticCustomTypeModelTab,
+} from "../model/customType"
 import type { SharedSliceModel, StaticSliceModel } from "../model/slice"
 
 export function toStatic(
-	customType: CustomTypeModel,
+	customType: DynamicCustomTypeModel,
 	sharedSlices: Map<string, SharedSliceModel> | Record<string, SharedSliceModel>,
 ): StaticCustomTypeModel {
 	const json: StaticCustomTypeModel["json"] = {}
@@ -45,7 +48,7 @@ export function toStatic(
 	return { ...customType, json }
 }
 
-export function flatten(customType: StaticCustomTypeModel): StaticSectionModel {
+export function flatten(customType: StaticCustomTypeModel): StaticCustomTypeModelTab {
 	return Object.values(customType.json).reduce((acc, fields) => ({ ...acc, ...fields }), {})
 }
 
@@ -67,3 +70,47 @@ export function collectSharedSlices(
 
 	return sharedSlices
 }
+
+export function filterMissingSharedSlices<
+	TCustomType extends StaticCustomTypeModel | DynamicCustomTypeModel,
+>(
+	customType: TCustomType,
+	sharedSlices: Map<string, SharedSliceModel> | Record<string, SharedSliceModel>,
+): TCustomType {
+	const json: TCustomType["json"] = {}
+
+	const sharedSlicesMap =
+		sharedSlices instanceof Map ? sharedSlices : new Map(Object.entries(sharedSlices))
+
+	for (const [tabKey, tab] of Object.entries(customType.json)) {
+		const tabJSON: typeof tab = {}
+		for (const [key, widget] of Object.entries(tab)) {
+			switch (widget.type) {
+				case "Slices":
+				case "Choice":
+					const choices: Required<typeof widget>["config"]["choices"] = {}
+					for (const [id, model] of Object.entries(widget.config?.choices || {})) {
+						if (model.type === "SharedSlice") {
+							if (sharedSlicesMap.get(id)) {
+								choices[id] = model
+							}
+						} else {
+							choices[id] = model
+						}
+					}
+
+					tabJSON[key] = {
+						...widget,
+						config: { ...widget.config, choices },
+					}
+					break
+				default:
+					tabJSON[key] = widget
+			}
+		}
+
+		json[tabKey] = tabJSON
+	}
+
+	return { ...customType, json }
+}

package/src/helpers/imageContent.ts

@@ -0,0 +1,84 @@
+import type { ImageContent, ImageContentView } from "../content/image"
+
+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
+}
+
+export function buildCropURL(args: {
+	origin: ImageContent["origin"]
+	croppedImage: CroppedImage
+}): 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: ImageContentView }): 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/helpers/traverseContent.ts

@@ -332,7 +332,10 @@ export function traverseLegacySliceContent(
 		}
 	} else {
 		if (model?.type === "SharedSlice") {
-			legacySliceModel = model.fields.primary?.[content.name]
+			const primaryModel = model.fields.primary?.[content.name]
+			if (primaryModel?.type !== "Group") {
+				legacySliceModel = primaryModel
+			}
 		} else if (model?.type !== "Group") {
 			legacySliceModel = model
 		}

package/src/helpers/withDefaultContent.ts

@@ -0,0 +1,180 @@
+import { BooleanContentType } from "../content/boolean"
+import type { DocumentContent } from "../content/document"
+import { FieldContentType, SelectFieldType } from "../content/field"
+import type { GroupContent, GroupItemContent } from "../content/group"
+import { GroupContentType } from "../content/group"
+import type { SliceContent } from "../content/slice"
+import { CompositeSliceContentType, SharedSliceContentType } from "../content/slice"
+import type { SlicesContent } from "../content/slices"
+import { SlicesContentType } from "../content/slices"
+import type { WidgetContent } from "../content/widget"
+import type { StaticCustomTypeModel } from "../model/customType"
+import type { GroupModel } from "../model/group"
+import type { NestableModel } from "../model/nestable"
+import type { StaticSliceModel } from "../model/slice"
+import type { StaticWidgetModel } from "../model/widget"
+import * as customTypeModel from "./customTypeModel"
+
+export function document(content: DocumentContent, model: StaticCustomTypeModel): DocumentContent {
+	return record(content, customTypeModel.flatten(model))
+}
+
+export function slice(content: SliceContent, model: StaticSliceModel | undefined): SliceContent {
+	if (!model) {
+		return content
+	}
+
+	if (model.type === "SharedSlice") {
+		if (content.__TYPE__ !== SharedSliceContentType) {
+			return content
+		}
+
+		const variation = model.variations.find((variation) => variation.id === content.variation)
+		if (!variation) {
+			return content
+		}
+
+		return {
+			...content,
+			primary: record(content.primary, variation?.primary),
+			items: items(content.items, variation?.items),
+		}
+	}
+
+	if (model.type === "Slice") {
+		if (content.__TYPE__ !== CompositeSliceContentType) {
+			return content
+		}
+
+		return {
+			...content,
+			nonRepeat: record(content.nonRepeat, model["non-repeat"]),
+			repeat: items(content.repeat, model.repeat),
+		}
+	}
+
+	if (
+		content.__TYPE__ === SharedSliceContentType ||
+		content.__TYPE__ === CompositeSliceContentType
+	) {
+		return content
+	}
+
+	return widget(content, model)
+}
+
+export function widget<TContent extends WidgetContent | undefined>(
+	content: TContent,
+	model: StaticWidgetModel | undefined,
+): TContent {
+	if (!model) {
+		return content
+	}
+
+	if (
+		(model.type === "Slices" || model.type === "Choice") &&
+		content?.__TYPE__ === SlicesContentType
+	) {
+		if (!model.config?.choices) return content
+
+		const value: SlicesContent["value"] = []
+		for (const sliceItem of content.value) {
+			value.push({
+				...sliceItem,
+				widget: slice(sliceItem.widget, model.config.choices[sliceItem.name]),
+			})
+		}
+
+		return { ...content, value }
+	}
+
+	if (model.type === "Group") {
+		if (content?.__TYPE__ !== GroupContentType) {
+			return <TContent>{
+				__TYPE__: GroupContentType,
+				value: items([], model.config?.fields),
+			}
+		}
+
+		return { ...content, value: items(content.value, model.config?.fields) }
+	}
+
+	if (model.type === "Boolean" && !content) {
+		if (model.config?.default_value === undefined) {
+			return <TContent>undefined
+		}
+
+		return <TContent>{
+			__TYPE__: BooleanContentType,
+			value: model.config.default_value,
+		}
+	}
+
+	if (model.type === "Select" && !content) {
+		if (!model.config?.default_value) {
+			return <TContent>undefined
+		}
+
+		return <TContent>{
+			__TYPE__: FieldContentType,
+			type: SelectFieldType,
+			value: model.config.default_value,
+		}
+	}
+
+	return content
+}
+
+export function items(
+	items: GroupContent["value"],
+	fields: Record<string, GroupModel | NestableModel> | undefined,
+): GroupContent["value"] {
+	if (!fields) {
+		return items
+	}
+
+	const itemsWithDefaults: GroupContent["value"] = []
+	for (const item of items) {
+		const itemValue: GroupItemContent["value"] = []
+
+		const missingFields = { ...fields }
+		for (const [key, value] of item.value) {
+			delete missingFields[key]
+			itemValue.push([key, widget(value, fields[key])])
+		}
+		for (const [key, field] of Object.entries(missingFields)) {
+			const content = widget(undefined, field)
+			if (content) {
+				itemValue.push([key, content])
+			}
+		}
+
+		itemsWithDefaults.push({ ...item, value: itemValue })
+	}
+
+	return itemsWithDefaults
+}
+
+function record<TContent extends WidgetContent>(
+	record: Record<string, TContent>,
+	fields: Record<string, StaticWidgetModel> | undefined,
+): Record<string, TContent> {
+	if (!fields) {
+		return record
+	}
+
+	const missingFields = { ...fields }
+	const recordWithDefaults: Record<string, TContent> = {}
+	for (const [key, value] of Object.entries(record)) {
+		delete missingFields[key]
+		recordWithDefaults[key] = widget(value, fields[key])
+	}
+	for (const [key, field] of Object.entries(missingFields)) {
+		const content = widget(undefined, field)
+		if (content) {
+			recordWithDefaults[key] = content
+		}
+	}
+
+	return recordWithDefaults
+}

package/src/index.ts

@@ -22,12 +22,21 @@ export type {
 } from "./content/field"
 export type { GeoPointContent } from "./content/geopoint"
 export type { GroupContent, GroupItemContent } from "./content/group"
-export type { ImageContent } from "./content/image"
+export type { ImageContent, ImageContentView } from "./content/image"
 export type { IntegrationFieldContent } from "./content/integrationField"
-export type { LinkContent } from "./content/link"
+export type { EmptyLinkContent, FilledLinkContent, LinkContent } from "./content/link"
 export type { NestableContent } from "./content/nestable"
 export type { RepeatableContent } from "./content/repeatable"
-export type { RichTextContent, RichTextContentBlock, RichTextContentSpan } from "./content/richText"
+export type {
+	RichTextContent,
+	RichTextContentBlock,
+	RichTextContentTextBlock,
+	RichTextContentImageBlock,
+	RichTextContentEmbedBlock,
+	RichTextContentSpan,
+	RichTextNodeTypes,
+} from "./content/richText"
+export { RichTextNodeType } from "./content/richText"
 export type { SeparatorContent } from "./content/separator"
 export type {
 	LegacySliceContent,
@@ -49,7 +58,13 @@ export type { WidgetContent } from "./content/widget"
 // Model
 export type { BooleanModel } from "./model/boolean"
 export type { ColorModel } from "./model/color"
-export type { StaticCustomTypeModel, CustomTypeModel } from "./model/customType"
+export type {
+	StaticCustomTypeModel,
+	DynamicCustomTypeModel,
+	CustomTypeModel,
+	StaticCustomTypeModelTab,
+	DynamicCustomTypeModelTab,
+} from "./model/customType"
 export type { DateModel } from "./model/date"
 export type { EmbedModel } from "./model/embed"
 export type { GeoPointModel } from "./model/geopoint"
@@ -60,8 +75,8 @@ export type { LinkModel } from "./model/link"
 export type { NestableModel } from "./model/nestable"
 export type { NumberModel } from "./model/number"
 export type { RangeModel } from "./model/range"
-export type { RichTextModel } from "./model/richText"
-export type { StaticSectionModel, DynamicSectionModel } from "./model/section"
+export type { RichTextModel, RichTextModelNodeTypes } from "./model/richText"
+export { RichTextModelNodeType } from "./model/richText"
 export type { SelectModel } from "./model/select"
 export type { SeparatorModel } from "./model/separator"
 export type {
@@ -69,7 +84,8 @@ export type {
 	CompositeSliceModel,
 	SharedSliceModel,
 	SharedSliceRefModel,
-	SharedSliceVariationContentModel as SharedSliceVariationModel,
+	SharedSliceModelVariation,
+	SharedSliceVariationContentModel,
 	StaticSliceModel,
 	DynamicSliceModel,
 	SliceContentModel,
@@ -91,6 +107,8 @@ export * as contentPath from "./helpers/contentPath"
 export * as customTypeModel from "./helpers/customTypeModel"
 export * as documentContent from "./helpers/documentContent"
 export * as sliceContent from "./helpers/sliceContent"
+export * as withDefaultContent from "./helpers/withDefaultContent"
+export * as imageContent from "./helpers/imageContent"
 export {
 	traverseDocumentContent,
 	traverseSlicesContent,

package/src/io-ts.ts

@@ -60,9 +60,16 @@ import {
 	GroupContentSchema as rawGroupContentSchema,
 	GroupItemContentSchema as rawGroupItemContentSchema,
 } from "./content/group"
-import { ImageContentSchema as rawImageContentSchema } from "./content/image"
+import {
+	ImageContentSchema as rawImageContentSchema,
+	ImageContentViewSchema as rawImageContentViewSchema,
+} from "./content/image"
 import { IntegrationFieldContentSchema as rawIntegrationFieldContentSchema } from "./content/integrationField"
-import { LinkContentSchema as rawLinkContentSchema } from "./content/link"
+import {
+	EmptyLinkContentSchema as rawEmptyLinkContentSchema,
+	FilledLinkContentSchema as rawFilledLinkContentSchema,
+	LinkContentSchema as rawLinkContentSchema,
+} from "./content/link"
 import { NestableContentSchema as rawNestableContentSchema } from "./content/nestable"
 import { RepeatableContentSchema as rawRepeatableContentSchema } from "./content/repeatable"
 import {
@@ -92,7 +99,9 @@ import { BooleanModelSchema as rawBooleanModelSchema } from "./model/boolean"
 import { ColorModelSchema as rawColorModelSchema } from "./model/color"
 import {
 	StaticCustomTypeModelSchema as rawStaticCustomTypeModelSchema,
-	CustomTypeModelSchema as rawCustomTypeModelSchema,
+	DynamicCustomTypeModelSchema as rawDynamicCustomTypeModelSchema,
+	StaticCustomTypeModelTabSchema as rawStaticCustomTypeModelTabSchema,
+	DynamicCustomTypeModelTabSchema as rawDynamicCustomTypeModelTabSchema,
 } from "./model/customType"
 import { DateModelSchema as rawDateModelSchema } from "./model/date"
 import { EmbedModelSchema as rawEmbedModelSchema } from "./model/embed"
@@ -108,16 +117,13 @@ import { NestableModelSchema as rawNestableModelSchema } from "./model/nestable"
 import { NumberModelSchema as rawNumberModelSchema } from "./model/number"
 import { RangeModelSchema as rawRangeModelSchema } from "./model/range"
 import { RichTextModelSchema as rawRichTextModelSchema } from "./model/richText"
-import {
-	StaticSectionModelSchema as rawStaticSectionModelSchema,
-	DynamicSectionModelSchema as rawDynamicSectionModelSchema,
-} from "./model/section"
 import { SelectModelSchema as rawSelectModelSchema } from "./model/select"
 import { SeparatorModelSchema as rawSeparatorModelSchema } from "./model/separator"
 import {
 	LegacySliceModelSchema as rawLegacySliceModelSchema,
 	CompositeSliceModelSchema as rawCompositeSliceModelSchema,
 	SharedSliceModelSchema as rawSharedSliceModelSchema,
+	SharedSliceModelVariationSchema as rawSharedSliceModelVariationSchema,
 	SharedSliceRefModelSchema as rawSharedSliceRefModelSchema,
 	StaticSliceModelSchema as rawStaticSliceModelSchema,
 	DynamicSliceModelSchema as rawDynamicSliceModelSchema,
@@ -149,6 +155,8 @@ export const ColorContentSchema = toIOTS(rawColorContentSchema)
 export const DateContentSchema = toIOTS(rawDateContentSchema)
 export const EmptyContentSchema = toIOTS(rawEmptyContentSchema)
 export const GeoPointContentSchema = toIOTS(rawGeoPointContentSchema)
+export const FilledLinkContentSchema = toIOTS(rawFilledLinkContentSchema)
+export const EmptyLinkContentSchema = toIOTS(rawEmptyLinkContentSchema)
 export const LinkContentSchema = toIOTS(rawLinkContentSchema)
 export const NumberContentSchema = toIOTS(rawNumberContentSchema)
 export const RangeContentSchema = toIOTS(rawRangeContentSchema)
@@ -161,6 +169,7 @@ export const FieldContentSchema = toIOTS(rawFieldContentSchema)
 export const UIDContentSchema = toIOTS(rawUIDContentSchema)
 export const IntegrationFieldContentSchema = toIOTS(rawIntegrationFieldContentSchema)
 export const EmbedContentSchema = toIOTS(rawEmbedContentSchema)
+export const ImageContentViewSchema = toIOTS(rawImageContentViewSchema)
 export const ImageContentSchema = toIOTS(rawImageContentSchema)
 export const RichTextContentSchema = toIOTS(rawRichTextContentSchema)
 export const RichTextContentBlockSchema = toIOTS(rawRichTextContentBlockSchema)
@@ -235,6 +244,7 @@ export const TimestampModelSchema = toIOTS(rawTimestampModelSchema)
 export const UIDModelSchema = toIOTS(rawUIDModelSchema)
 export const GroupModelSchema = toIOTS(rawGroupModelSchema)
 export const NestedGroupModelSchema = toIOTS(rawNestedGroupModelSchema)
+export const SharedSliceModelVariationSchema = toIOTS(rawSharedSliceModelVariationSchema)
 export const SharedSliceRefModelSchema = toIOTS(rawSharedSliceRefModelSchema)
 export const CompositeSliceModelSchema = toIOTS(rawCompositeSliceModelSchema)
 export const LegacySliceModelSchema = toIOTS(rawLegacySliceModelSchema)
@@ -245,10 +255,12 @@ export const DynamicSlicesModelSchema = toIOTS(rawDynamicSlicesModelSchema)
 export const StaticSlicesModelSchema = toIOTS(rawStaticSlicesModelSchema)
 export const StaticWidgetModelSchema = toIOTS(rawStaticWidgetModelSchema)
 export const DynamicWidgetModelSchema = toIOTS(rawDynamicWidgetModelSchema)
-export const StaticSectionModelSchema = toIOTS(rawStaticSectionModelSchema)
-export const DynamicSectionModelSchema = toIOTS(rawDynamicSectionModelSchema)
+export const StaticCustomTypeModelTabSchema = toIOTS(rawStaticCustomTypeModelTabSchema)
+export const DynamicCustomTypeModelTabSchema = toIOTS(rawDynamicCustomTypeModelTabSchema)
 export const StaticCustomTypeModelSchema = toIOTS(rawStaticCustomTypeModelSchema)
-export const CustomTypeModelSchema = toIOTS(rawCustomTypeModelSchema)
+export const DynamicCustomTypeModelSchema = toIOTS(rawDynamicCustomTypeModelSchema)
+/** @deprecated Use DynamicCustomTypeModelSchema instead */
+export const CustomTypeModelSchema = DynamicCustomTypeModelSchema
 
 function toIOTS<T>(type: ZodMiniType<T>): t.Type<T> {
 	return new t.Type<T>(

package/src/model/customType.ts

@@ -1,8 +1,16 @@
 import { z } from "zod/mini"
 
-import { DynamicSectionModelSchema, StaticSectionModelSchema } from "./section"
+import { WidgetKeySchema } from "../common/widgetKey"
+import { DynamicWidgetModelSchema, StaticWidgetModelSchema } from "./widget"
 
-// CustomTypeFormat - "page" | "custom"
+// Tab
+export const StaticCustomTypeModelTabSchema = z.record(WidgetKeySchema, StaticWidgetModelSchema)
+export type StaticCustomTypeModelTab = z.infer<typeof StaticCustomTypeModelTabSchema>
+
+export const DynamicCustomTypeModelTabSchema = z.record(WidgetKeySchema, DynamicWidgetModelSchema)
+export type DynamicCustomTypeModelTab = z.infer<typeof DynamicCustomTypeModelTabSchema>
+
+// Custom types
 export const CustomTypeFormatSchema = z.enum(["page", "custom"])
 export type CustomTypeFormat = z.infer<typeof CustomTypeFormatSchema>
 
@@ -17,10 +25,13 @@ const createCustomTypeSchema = <T extends z.ZodMiniType>(sectionSchema: T) =>
 		format: z._default(CustomTypeFormatSchema, "custom"),
 	})
 
-// StaticCustomType - uses StaticSection (with full SharedSlice definitions)
-export const StaticCustomTypeModelSchema = createCustomTypeSchema(StaticSectionModelSchema)
+export const StaticCustomTypeModelSchema = createCustomTypeSchema(StaticCustomTypeModelTabSchema)
 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>
+export const DynamicCustomTypeModelSchema = createCustomTypeSchema(DynamicCustomTypeModelTabSchema)
+export type DynamicCustomTypeModel = z.infer<typeof DynamicCustomTypeModelSchema>
+
+/** @deprecated Use DynamicCustomTypeModelSchema instead */
+export const CustomTypeModelSchema = DynamicCustomTypeModelSchema
+/** @deprecated Use DynamicCustomTypeModel instead */
+export type CustomTypeModel = DynamicCustomTypeModel

package/src/model/diff/sharedSlice.ts

@@ -1,4 +1,4 @@
-import type { SharedSliceModel, SharedSliceVariation } from "../slice"
+import type { SharedSliceModel, SharedSliceModelVariation } from "../slice"
 import { type DiffChange, DiffOperation } from "./changes"
 import { isNotEmpty, toRecord, zipObjects } from "./utils"
 import { type VariationDiff, VariationComparator } from "./variation"
@@ -41,7 +41,7 @@ export const SliceComparator = {
 
 		const diffMeta = compareSliceMeta(sliceA, sliceB)
 
-		const zippedSlices = zipObjects<SharedSliceVariation>(
+		const zippedSlices = zipObjects<SharedSliceModelVariation>(
 			sliceA && toRecord(sliceA.variations, (v) => v.id),
 			sliceB && toRecord(sliceB.variations, (v) => v.id),
 		)

package/src/model/diff/variation.ts

@@ -1,7 +1,7 @@
 import type { GroupModel } from "../group"
 import { GroupFieldType } from "../group"
 import type { NestableModel } from "../nestable"
-import type { SharedSliceVariation } from "../slice"
+import type { SharedSliceModelVariation } from "../slice"
 import { type DiffChange, DiffOperation } from "./changes"
 import { isNotEmpty, zipObjects } from "./utils"
 import type {
@@ -10,9 +10,9 @@ import type {
 	SlicePrimaryWidgetDiff,
 } from "./widgets"
 
-export type VariationMetadata = Omit<SharedSliceVariation, "primary" | "items">
+export type VariationMetadata = Omit<SharedSliceModelVariation, "primary" | "items">
 export type VariationDiff = DiffChange<
-	SharedSliceVariation,
+	SharedSliceModelVariation,
 	Partial<VariationMetadata> & {
 		primary?: Record<string, SlicePrimaryWidgetDiff>
 		items?: Record<string, NestableWidgetDiff>
@@ -20,8 +20,8 @@ export type VariationDiff = DiffChange<
 >
 
 function compareVariationMeta(
-	variationA?: SharedSliceVariation,
-	variationB?: SharedSliceVariation,
+	variationA?: SharedSliceModelVariation,
+	variationB?: SharedSliceModelVariation,
 ): Partial<VariationMetadata> {
 	const zippedVariations = zipObjects(variationA, variationB)
 
@@ -119,8 +119,8 @@ function compareWidgets<TWidget extends NestableModel | GroupModel>(
 
 export const VariationComparator = {
 	compare(
-		variationA?: SharedSliceVariation,
-		variationB?: SharedSliceVariation,
+		variationA?: SharedSliceModelVariation,
+		variationB?: SharedSliceModelVariation,
 	): VariationDiff | undefined {
 		if (variationA && !variationB)
 			return {

package/src/model/richText.ts

@@ -6,7 +6,7 @@ export const RichTextFieldType = "StructuredText"
 
 export const DEFAULT_OPTION = "paragraph"
 
-export const RichTextNodeType = {
+export const RichTextModelNodeType = {
 	heading1: "heading1",
 	heading2: "heading2",
 	heading3: "heading3",
@@ -25,7 +25,10 @@ export const RichTextNodeType = {
 	rtl: "rtl",
 } as const
 
-const VALID_NODE_TYPES = Object.values(RichTextNodeType)
+export type RichTextModelNodeTypes =
+	(typeof RichTextModelNodeType)[keyof typeof RichTextModelNodeType]
+
+const VALID_NODE_TYPES = Object.values(RichTextModelNodeType)
 
 /**
  * RichTextOptions parses comma-separated node types, filters invalid ones,

package/src/model/slice.ts

@@ -1,7 +1,7 @@
 import { z } from "zod/mini"
 
 import { WidgetKeySchema } from "../common/widgetKey"
-import type { NestedGroupModel } from "./group"
+import type { GroupModel, NestedGroupModel } from "./group"
 import { GroupModelSchema, NestedGroupModelSchema } from "./group"
 import type { NestableModel } from "./nestable"
 import { NestableModelSchema } from "./nestable"
@@ -40,7 +40,7 @@ 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 SharedSliceVariationSchema = z.object({
+export const SharedSliceModelVariationSchema = z.object({
 	id: z.string(),
 	name: z.string(),
 	description: z.string(),
@@ -51,21 +51,19 @@ export const SharedSliceVariationSchema = z.object({
 	primary: z.optional(
 		z.record(
 			z.string(),
-			z.union([NestableModelSchema, GroupModelSchema]) as z.ZodMiniType<
-				NestableModel | NestedGroupModel
-			>,
+			z.union([NestableModelSchema, GroupModelSchema]) as z.ZodMiniType<NestableModel | GroupModel>,
 		),
 	),
 	items: z.optional(z.record(z.string(), NestableModelSchema)),
 })
 
-export type SharedSliceVariation = z.infer<typeof SharedSliceVariationSchema>
+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(SharedSliceVariationSchema),
+	variations: z.array(SharedSliceModelVariationSchema),
 	description: z.optional(z.string()),
 	legacyPaths: z.optional(z.record(z.string(), z.string())),
 })
@@ -84,7 +82,7 @@ export const SharedSliceVariationContentModelSchema = z.object({
 	type: z.literal(SharedSliceType),
 	sliceName: z.string(),
 	variationID: z.string(),
-	fields: z.pick(SharedSliceVariationSchema, { primary: true, items: true }),
+	fields: z.pick(SharedSliceModelVariationSchema, { primary: true, items: true }),
 })
 
 export type SharedSliceVariationContentModel = z.infer<