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

package/src/index.ts

@@ -0,0 +1,78 @@
+// Common
+export type { Asset } from "./common/asset"
+export type { Embed } from "./common/embed"
+export type { HexaColorCode } from "./common/hexaColorCode"
+export type { NonEmptyString } from "./common/nonEmptyString"
+export type { WidgetKey } from "./common/widgetKey"
+
+// Content
+export type { BooleanContent } from "./content/boolean"
+export type { DocumentContent } from "./content/document"
+export type { EmbedContent } from "./content/embed"
+export type { EmptyContent } from "./content/empty"
+export type {
+	ColorContent,
+	DateContent,
+	NumberContent,
+	RangeContent,
+	SelectContent,
+	TextContent,
+	TimestampContent,
+	FieldContent,
+} from "./content/field"
+export type { GeoPointContent } from "./content/geopoint"
+export type { GroupContent, GroupItemContent } from "./content/group"
+export type { ImageContent } from "./content/image"
+export type { IntegrationFieldContent } from "./content/integrationField"
+export type { LinkContent } from "./content/link"
+export type { NestableContent } from "./content/nestable"
+export type { RepeatableContent } from "./content/repeatable"
+export type { RichTextContent } from "./content/richText"
+export type { SeparatorContent } from "./content/separator"
+export type {
+	SimpleSliceContent,
+	CompositeSliceContent,
+	SharedSliceContent,
+	SliceContent,
+} from "./content/slice"
+export type { SliceItemContent, SlicesContent } from "./content/slices"
+export type { TableContent } from "./content/table"
+export type { UIDContent } from "./content/uid"
+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 { DateModel } from "./model/date"
+export type { EmbedModel } from "./model/embed"
+export type { GeoPointModel } from "./model/geopoint"
+export type { GroupModel, NestedGroupModel } from "./model/group"
+export type { ImageModel } from "./model/image"
+export type { IntegrationFieldModel } from "./model/integrationField"
+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 { SelectModel } from "./model/select"
+export type { SeparatorModel } from "./model/separator"
+export type {
+	LegacySliceModel,
+	CompositeSliceModel,
+	SharedSliceModel,
+	SharedSliceRefModel,
+	StaticSliceModel,
+	DynamicSliceModel,
+	SlicesTypesModel,
+} from "./model/slice"
+export type { DynamicSlicesModel, StaticSlicesModel } from "./model/slices"
+export type { TableModel } from "./model/table"
+export type { TextModel } from "./model/text"
+export type { TimestampModel } from "./model/timestamp"
+export type { UIDModel } from "./model/uid"
+export type { StaticWidgetModel, DynamicWidgetModel, FieldType } from "./model/widget"
+
+// Legacy
+export { LegacyContentCtx, getFieldCtx, defaultCtx } from "./content/codec/legacyContentCtx"

package/src/io-ts.ts

@@ -0,0 +1,313 @@
+import * as t from "io-ts"
+import type { ZodMiniType } from "zod/mini"
+
+// Common
+import { AssetSchema } from "./common/asset"
+import { EmbedSchema } from "./common/embed"
+import { HexaColorCodeSchema } from "./common/hexaColorCode"
+import { NonEmptyStringSchema } from "./common/nonEmptyString"
+import { WidgetKeySchema } from "./common/widgetKey"
+// Content
+import { BooleanContentSchema } from "./content/boolean"
+import { BooleanLegacyCodec } from "./content/codec/boolean"
+import { DocumentLegacyCodec } from "./content/codec/document"
+import { EmbedLegacyCodec } from "./content/codec/embed"
+import { EmptyLegacyCodec } from "./content/codec/empty"
+import {
+	ColorLegacyCodec,
+	DateLegacyCodec,
+	NumberLegacyCodec,
+	RangeLegacyCodec,
+	SelectLegacyCodec,
+	TextLegacyCodec,
+	TimestampLegacyCodec,
+} from "./content/codec/field"
+import { GeoPointLegacyCodec } from "./content/codec/geopoint"
+import { GroupItemLegacyCodec, GroupLegacyCodec } from "./content/codec/group"
+import { ImageLegacyCodec } from "./content/codec/image"
+import { IntegrationFieldLegacyCodec } from "./content/codec/integrationField"
+import type { LegacyCodec } from "./content/codec/legacyContentCtx"
+import { LinkLegacyCodec } from "./content/codec/link"
+import { NestableLegacyCodec } from "./content/codec/nestable"
+import { RepeatableLegacyCodec } from "./content/codec/repeatable"
+import { RichTextLegacyCodec } from "./content/codec/richText"
+import { SeparatorLegacyCodec } from "./content/codec/separator"
+import {
+	CompositeSliceLegacyCodec,
+	SharedSliceLegacyCodec,
+	SimpleSliceLegacyCodec,
+	SliceLegacyCodec,
+} from "./content/codec/slice"
+import { SliceItemLegacyCodec, SlicesLegacyCodec } from "./content/codec/slices"
+import { TableLegacyCodec } from "./content/codec/table"
+import { UIDLegacyCodec } from "./content/codec/uid"
+import { WidgetLegacyCodec } from "./content/codec/widget"
+import { DocumentContentSchema } from "./content/document"
+import { EmbedContentSchema } from "./content/embed"
+import { EmptyContentSchema } from "./content/empty"
+import {
+	ColorContentSchema,
+	DateContentSchema,
+	NumberContentSchema,
+	RangeContentSchema,
+	SelectContentSchema,
+	TextContentSchema,
+	TimestampContentSchema,
+	FieldContentSchema,
+} from "./content/field"
+import { GeoPointContentSchema } from "./content/geopoint"
+import { GroupContentSchema, GroupItemContentSchema } from "./content/group"
+import { ImageContentSchema } from "./content/image"
+import { IntegrationFieldContentSchema } from "./content/integrationField"
+import { LinkContentSchema } from "./content/link"
+import { NestableContentSchema } from "./content/nestable"
+import { RepeatableContentSchema } from "./content/repeatable"
+import { RichTextContentSchema } from "./content/richText"
+import { SeparatorContentSchema } from "./content/separator"
+import {
+	SimpleSliceContentSchema,
+	CompositeSliceContentSchema,
+	SharedSliceContentSchema,
+	SliceContentSchema,
+} from "./content/slice"
+import { SliceItemContentSchema, SlicesContentSchema } from "./content/slices"
+import { TableContentSchema } from "./content/table"
+import { UIDContentSchema } from "./content/uid"
+import { WidgetContentSchema } from "./content/widget"
+// Model
+import { BooleanModelSchema } from "./model/boolean"
+import { ColorModelSchema } from "./model/color"
+import { StaticCustomTypeModelSchema, CustomTypeModelSchema } from "./model/customType"
+import { DateModelSchema } from "./model/date"
+import { EmbedModelSchema } from "./model/embed"
+import { GeoPointModelSchema } from "./model/geopoint"
+import { GroupModelSchema, NestedGroupModelSchema } from "./model/group"
+import { ImageModelSchema } from "./model/image"
+import { IntegrationFieldModelSchema } from "./model/integrationField"
+import { LinkModelSchema } from "./model/link"
+import { NestableModelSchema } from "./model/nestable"
+import { NumberModelSchema } from "./model/number"
+import { RangeModelSchema } from "./model/range"
+import { RichTextModelSchema } from "./model/richText"
+import { StaticSectionModelSchema, DynamicSectionModelSchema } from "./model/section"
+import { SelectModelSchema } from "./model/select"
+import { SeparatorModelSchema } from "./model/separator"
+import {
+	LegacySliceModelSchema,
+	CompositeSliceModelSchema,
+	SharedSliceModelSchema,
+	SharedSliceRefModelSchema,
+	StaticSliceModelSchema,
+	DynamicSliceModelSchema,
+} from "./model/slice"
+import { DynamicSlicesModelSchema, StaticSlicesModelSchema } from "./model/slices"
+import { TableModelSchema } from "./model/table"
+import { TextModelSchema } from "./model/text"
+import { TimestampModelSchema } from "./model/timestamp"
+import { UIDModelSchema } from "./model/uid"
+import { StaticWidgetModelSchema, DynamicWidgetModelSchema, FieldTypeSchema } from "./model/widget"
+
+// Common
+export const Asset = toIOTS(AssetSchema)
+export const Embed = toIOTS(EmbedSchema)
+export const HexaColorCode = toIOTS(HexaColorCodeSchema)
+export const NonEmptyString = toIOTS(NonEmptyStringSchema)
+export const WidgetKey = toIOTS(WidgetKeySchema)
+
+// Content
+export const BooleanContent = toIOTS(BooleanContentSchema)
+export const ColorContent = toIOTS(ColorContentSchema)
+export const DateContent = toIOTS(DateContentSchema)
+export const EmptyContent = toIOTS(EmptyContentSchema)
+export const GeoPointContent = toIOTS(GeoPointContentSchema)
+export const LinkContent = toIOTS(LinkContentSchema)
+export const NumberContent = toIOTS(NumberContentSchema)
+export const RangeContent = toIOTS(RangeContentSchema)
+export const SelectContent = toIOTS(SelectContentSchema)
+export const SeparatorContent = toIOTS(SeparatorContentSchema)
+export const SharedSliceContent = toIOTS(SharedSliceContentSchema)
+export const TextContent = toIOTS(TextContentSchema)
+export const TimestampContent = toIOTS(TimestampContentSchema)
+export const FieldContent = toIOTS(FieldContentSchema)
+export const UIDContent = toIOTS(UIDContentSchema)
+export const IntegrationFieldContent = toIOTS(IntegrationFieldContentSchema)
+export const EmbedContent = toIOTS(EmbedContentSchema)
+export const ImageContent = toIOTS(ImageContentSchema)
+export const RichTextContent = toIOTS(RichTextContentSchema)
+export const TableContent = toIOTS(TableContentSchema)
+export const RepeatableContent = toIOTS(RepeatableContentSchema)
+export const NestableContent = toIOTS(NestableContentSchema)
+export const GroupContent = toIOTS(GroupContentSchema)
+export const GroupItemContent = toIOTS(GroupItemContentSchema)
+export const CompositeSliceContent = toIOTS(CompositeSliceContentSchema)
+export const SimpleSliceContent = toIOTS(SimpleSliceContentSchema)
+export const SliceContent = toIOTS(SliceContentSchema)
+export const SliceItemContent = toIOTS(SliceItemContentSchema)
+export const SlicesContent = toIOTS(SlicesContentSchema)
+export const WidgetContent = toIOTS(WidgetContentSchema)
+export const DocumentContent = toIOTS(DocumentContentSchema)
+
+// Content legacy
+export const BooleanLegacy = toIOTSCodec(BooleanLegacyCodec)
+export const EmptyLegacy = toIOTSCodec(EmptyLegacyCodec)
+export const TextLegacy = toIOTSCodec(TextLegacyCodec)
+export const ColorLegacy = toIOTSCodec(ColorLegacyCodec)
+export const DateLegacy = toIOTSCodec(DateLegacyCodec)
+export const TimestampLegacy = toIOTSCodec(TimestampLegacyCodec)
+export const NumberLegacy = toIOTSCodec(NumberLegacyCodec)
+export const RangeLegacy = toIOTSCodec(RangeLegacyCodec)
+export const SelectLegacy = toIOTSCodec(SelectLegacyCodec)
+export const GeoPointLegacy = toIOTSCodec(GeoPointLegacyCodec)
+export const EmbedLegacy = toIOTSCodec(EmbedLegacyCodec)
+export const ImageLegacy = toIOTSCodec(ImageLegacyCodec)
+export const LinkLegacy = toIOTSCodec(LinkLegacyCodec)
+export const RepeatableLegacy = toIOTSCodec(RepeatableLegacyCodec)
+export const RichTextLegacy = toIOTSCodec(RichTextLegacyCodec)
+export const SeparatorLegacy = toIOTSCodec(SeparatorLegacyCodec)
+export const IntegrationFieldLegacy = toIOTSCodec(IntegrationFieldLegacyCodec)
+export const TableLegacy = toIOTSCodec(TableLegacyCodec)
+export const NestableLegacy = toIOTSCodec(NestableLegacyCodec)
+export const UIDLegacy = toIOTSCodec(UIDLegacyCodec)
+export const GroupItemLegacy = toIOTSCodec(GroupItemLegacyCodec)
+export const GroupLegacy = toIOTSCodec(GroupLegacyCodec)
+export const SimpleSliceLegacy = toIOTSCodec(SimpleSliceLegacyCodec)
+export const CompositeSliceLegacy = toIOTSCodec(CompositeSliceLegacyCodec)
+export const SharedSliceLegacy = toIOTSCodec(SharedSliceLegacyCodec)
+export const SliceLegacy = toIOTSCodec(SliceLegacyCodec)
+export const SliceItemLegacy = toIOTSCodec(SliceItemLegacyCodec)
+export const SlicesLegacy = toIOTSCodec(SlicesLegacyCodec)
+export const WidgetLegacy = toIOTSCodec(WidgetLegacyCodec)
+export const DocumentLegacy = toIOTSCodec(DocumentLegacyCodec)
+
+// Model
+export const BooleanModel = toIOTS(BooleanModelSchema)
+export const ColorModel = toIOTS(ColorModelSchema)
+export const DateModel = toIOTS(DateModelSchema)
+export const EmbedModel = toIOTS(EmbedModelSchema)
+export const GeoPointModel = toIOTS(GeoPointModelSchema)
+export const ImageModel = toIOTS(ImageModelSchema)
+export const IntegrationFieldModel = toIOTS(IntegrationFieldModelSchema)
+export const LinkModel = toIOTS(LinkModelSchema)
+export const NestableModel = toIOTS(NestableModelSchema)
+export const NumberModel = toIOTS(NumberModelSchema)
+export const RangeModel = toIOTS(RangeModelSchema)
+export const RichTextModel = toIOTS(RichTextModelSchema)
+export const SelectModel = toIOTS(SelectModelSchema)
+export const SeparatorModel = toIOTS(SeparatorModelSchema)
+export const SharedSliceModel = toIOTS(SharedSliceModelSchema)
+export const TableModel = toIOTS(TableModelSchema)
+export const TextModel = toIOTS(TextModelSchema)
+export const TimestampModel = toIOTS(TimestampModelSchema)
+export const UIDModel = toIOTS(UIDModelSchema)
+export const GroupModel = toIOTS(GroupModelSchema)
+export const NestedGroupModel = toIOTS(NestedGroupModelSchema)
+export const SharedSliceRefModel = toIOTS(SharedSliceRefModelSchema)
+export const CompositeSliceModel = toIOTS(CompositeSliceModelSchema)
+export const LegacySliceModel = toIOTS(LegacySliceModelSchema)
+export const DynamicSliceModel = toIOTS(DynamicSliceModelSchema)
+export const StaticSliceModel = toIOTS(StaticSliceModelSchema)
+export const DynamicSlicesModel = toIOTS(DynamicSlicesModelSchema)
+export const StaticSlicesModel = toIOTS(StaticSlicesModelSchema)
+export const StaticWidgetModel = toIOTS(StaticWidgetModelSchema)
+export const DynamicWidgetModel = toIOTS(DynamicWidgetModelSchema)
+export const FieldType = toIOTS(FieldTypeSchema)
+export const StaticSectionModel = toIOTS(StaticSectionModelSchema)
+export const DynamicSectionModel = toIOTS(DynamicSectionModelSchema)
+export const StaticCustomTypeModel = toIOTS(StaticCustomTypeModelSchema)
+export const CustomTypeModel = toIOTS(CustomTypeModelSchema)
+
+function toIOTS<T>(type: ZodMiniType<T>): t.Type<T> {
+	return new t.Type<T>(
+		"Type",
+		(input): input is T => type.safeParse(input).success,
+		(input, context) => {
+			const result = type.safeParse(input)
+			return result.success
+				? t.success(result.data)
+				: t.failure(
+						input,
+						context,
+						result.error.issues.map((issue) => formatIssue(issue, input)).join("\n"),
+					)
+		},
+		t.identity,
+	)
+}
+
+function toIOTSCodec<TArgs extends unknown[], A, LegacyRaw, AllowUndefined extends boolean>(
+	codecFactory: (...args: TArgs) => LegacyCodec<A, LegacyRaw, AllowUndefined>,
+): (
+	...args: TArgs
+) => t.Type<A, ReturnType<LegacyCodec<A, LegacyRaw, AllowUndefined>["encode"]>, unknown> {
+	return (...args: TArgs) => {
+		const codec = codecFactory(...args)
+		return new t.Type<A, ReturnType<LegacyCodec<A, LegacyRaw, AllowUndefined>["encode"]>, unknown>(
+			codec.name,
+			codec.is,
+			(input, context) => {
+				const result = codec.decode(input)
+				return result.success
+					? t.success(result.data)
+					: t.failure(
+							input,
+							context,
+							result.error.issues.map((issue) => formatIssue(issue, input)).join("\n"),
+						)
+			},
+			codec.encode,
+		)
+	}
+}
+
+interface ZodIssue {
+	code: string
+	message: string
+	path?: PropertyKey[]
+	expected?: string
+	values?: unknown[]
+	keys?: string[]
+}
+
+function resolveValue(input: unknown, path: PropertyKey[]): unknown {
+	let current = input
+	for (const key of path) {
+		if (current == null || typeof current !== "object") return undefined
+		current = (current as Record<PropertyKey, unknown>)[key]
+	}
+	return current
+}
+
+function formatValue(value: unknown): string {
+	if (value === null) return "null"
+	if (value === undefined) return "undefined"
+	if (typeof value === "string") return JSON.stringify(value)
+	return String(value)
+}
+
+function formatIssue(issue: ZodIssue, input: unknown): string {
+	if (issue.code === "custom" && issue.message !== "Invalid input") {
+		return issue.message
+	}
+
+	const value = resolveValue(input, issue.path ?? [])
+	const pathStr = issue.path?.length ? issue.path.join(".") : undefined
+
+	if (issue.code === "invalid_value" && issue.values) {
+		const expected = issue.values.map(formatValue).join(", ")
+		return pathStr
+			? `Invalid value ${formatValue(value)} at .${pathStr}: expected ${expected}`
+			: `Invalid value ${formatValue(value)}: expected ${expected}`
+	}
+
+	if (issue.code === "invalid_type" && issue.expected) {
+		return pathStr
+			? `Invalid value ${formatValue(value)} at .${pathStr}: expected ${issue.expected}`
+			: `Invalid value ${formatValue(value)}: expected ${issue.expected}`
+	}
+
+	if (issue.code === "unrecognized_keys" && issue.keys) {
+		return `Unrecognized key(s): ${issue.keys.join(", ")}`
+	}
+
+	return issue.message
+}

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, Variation } 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<Variation>(
+			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,
+		}
+	}, {})
+}