@prismicio/types-internal 3.17.0-pr.145.680cd65 → 3.17.2

package/src/content/helpers.ts

@@ -1,4 +1,5 @@
 import * as t from "io-ts"
+import { v4 as uuid, validate as validateUuid } from "uuid"
 
 type WithContentType = { __TYPE__: string }
 export function hasContentType(obj: unknown): obj is WithContentType {
@@ -6,16 +7,13 @@ export function hasContentType(obj: unknown): obj is WithContentType {
 }
 
 const isUuid = (input: unknown): input is string =>
-	typeof input === "string" &&
-	/^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i.test(
-		input,
-	)
+	typeof input === "string" && validateUuid(input)
 
 const uuidWithFallback = new t.Type<string, string, unknown>(
 	"UUID",
 	isUuid,
 	(u, c) => {
-		if (typeof u === "undefined") return t.success(crypto.randomUUID())
+		if (typeof u === "undefined") return t.success(uuid())
 		if (isUuid(u)) return t.success(u)
 		return t.failure(u, c)
 	},

package/src/content/utils.ts

@@ -8,13 +8,12 @@ import type {
 	UID,
 	VariationFields,
 } from "../customtypes"
-import type {
-	SharedSliceItemContent,
-	SliceItemContent,
-	WidgetContent} from "./fields";
 import {
 	FieldContentType,
-	FieldType
+	FieldType,
+	SharedSliceItemContent,
+	SliceItemContent,
+	WidgetContent,
 } from "./fields"
 export { hasContentType, withKey } from "./helpers"
 import { hasContentType } from "./helpers"
@@ -49,7 +48,10 @@ export type TraverseSliceContentFn = <
 
 export type TraverseWidgetContentFn<
 	ContentTransformMode extends "preserve" | "widen" = "preserve",
-> = <C extends WidgetContent, D extends NestableWidget | StaticSlices | Group | UID>({
+> = <
+	C extends WidgetContent,
+	D extends NestableWidget | StaticSlices | Group | UID,
+>({
 	path,
 	key,
 	apiId,
@@ -61,11 +63,16 @@ export type TraverseWidgetContentFn<
 	apiId: string
 	model?: D | undefined
 	content: C
-}) => ([ContentTransformMode] extends ["preserve"] ? C : WidgetContent) | undefined
+}) =>
+	| ([ContentTransformMode] extends ["preserve"] ? C : WidgetContent)
+	| undefined
 
 export type TraverseWidgetContentWithModelFn<
 	ContentTransformMode extends "preserve" | "widen" = "preserve",
-> = <C extends WidgetContent | undefined, D extends NestableWidget | StaticSlices | Group | UID>({
+> = <
+	C extends WidgetContent | undefined,
+	D extends NestableWidget | StaticSlices | Group | UID,
+>({
 	path,
 	key,
 	apiId,
@@ -77,7 +84,9 @@ export type TraverseWidgetContentWithModelFn<
 	apiId: string
 	model: D
 	content: C
-}) => ([ContentTransformMode] extends ["preserve"] ? C : WidgetContent) | undefined
+}) =>
+	| ([ContentTransformMode] extends ["preserve"] ? C : WidgetContent)
+	| undefined
 
 export type TraverseSliceContentWithModelFn = <
 	S extends SliceItemContent | SharedSliceItemContent | undefined,

package/src/customtypes/CustomType.ts

@@ -1,11 +1,15 @@
-import type { Either} from "fp-ts/lib/Either";
-import { left, right } from "fp-ts/lib/Either"
+import { Either, left, right } from "fp-ts/lib/Either"
 import * as t from "io-ts"
 import { withFallback } from "io-ts-types/lib/withFallback"
 
 import type { Fields } from "../utils"
 import { StringOrNull } from "../validators"
-import { DynamicSection, Sections, StaticSection, traverseSection } from "./Section"
+import {
+	DynamicSection,
+	Sections,
+	StaticSection,
+	traverseSection,
+} from "./Section"
 import type { Group, NestableWidget, NestedGroup, UID } from "./widgets"
 import type { SharedSlice } from "./widgets/slices/SharedSlice"
 import type { DynamicSlice } from "./widgets/slices/Slice"
@@ -36,7 +40,9 @@ ${slicesMsg.join("\n")}
 	}
 }
 
-function customTypeReader<T extends StaticSection | DynamicSection>(codec: t.Type<T, unknown>) {
+function customTypeReader<T extends StaticSection | DynamicSection>(
+	codec: t.Type<T, unknown>,
+) {
 	return t.exact(
 		t.intersection([
 			t.type({
@@ -59,20 +65,32 @@ export type StaticCustomType = t.TypeOf<typeof StaticCustomType>
 export const CustomType = customTypeReader(DynamicSection)
 export type CustomType = t.TypeOf<typeof CustomType>
 
-export function flattenWidgets(customType: CustomType): Array<[string, DynamicWidget]> {
+export function flattenWidgets(
+	customType: CustomType,
+): Array<[string, DynamicWidget]> {
 	return Object.entries(customType.json).reduce(
-		(acc: Array<[string, DynamicWidget]>, [, section]: [string, DynamicSection]) => {
-			const sectionWidgets: Array<[string, DynamicWidget]> = Object.entries(section)
+		(
+			acc: Array<[string, DynamicWidget]>,
+			[, section]: [string, DynamicSection],
+		) => {
+			const sectionWidgets: Array<[string, DynamicWidget]> =
+				Object.entries(section)
 			return acc.concat(sectionWidgets)
 		},
 		[],
 	)
 }
 
-export function flattenSections(customType: StaticCustomType): Array<[string, StaticWidget]> {
+export function flattenSections(
+	customType: StaticCustomType,
+): Array<[string, StaticWidget]> {
 	return Object.entries(customType.json).reduce(
-		(acc: Array<[string, StaticWidget]>, [, section]: [string, StaticSection]) => {
-			const sectionWidgets: Array<[string, StaticWidget]> = Object.entries(section)
+		(
+			acc: Array<[string, StaticWidget]>,
+			[, section]: [string, StaticSection],
+		) => {
+			const sectionWidgets: Array<[string, StaticWidget]> =
+				Object.entries(section)
 			return acc.concat(sectionWidgets)
 		},
 		[],
@@ -84,19 +102,28 @@ function _retrieveSharedSlicesRef(customType: CustomType): Array<string> {
 		([, widget]: [string, DynamicWidget]) => widget.type === "Slices",
 	) as Array<[string, DynamicSlices]>
 
-	const allSharedRefs = slicezones.reduce((acc: Array<string>, [, slicezone]) => {
-		const sharedRefs = Object.entries(
-			slicezone.config && slicezone.config.choices ? slicezone.config.choices : {},
-		)
-			.filter(([, slice]: [string, DynamicSlice]) => slice.type === "SharedSlice")
-			.map(([key]) => key)
-		return acc.concat(sharedRefs)
-	}, [])
+	const allSharedRefs = slicezones.reduce(
+		(acc: Array<string>, [, slicezone]) => {
+			const sharedRefs = Object.entries(
+				slicezone.config && slicezone.config.choices
+					? slicezone.config.choices
+					: {},
+			)
+				.filter(
+					([, slice]: [string, DynamicSlice]) => slice.type === "SharedSlice",
+				)
+				.map(([key]) => key)
+			return acc.concat(sharedRefs)
+		},
+		[],
+	)
 
 	return allSharedRefs
 }
 
-function _mapSharedSlicesRefs<A>(customType: CustomType): (mapFn: (ref: string) => A) => Array<A> {
+function _mapSharedSlicesRefs<A>(
+	customType: CustomType,
+): (mapFn: (ref: string) => A) => Array<A> {
 	const refs = _retrieveSharedSlicesRef(customType)
 
 	return function (mapFn: (ref: string) => A): Array<A> {
@@ -109,7 +136,10 @@ export function toStatic(
 	sharedSlices: Map<string, SharedSlice>,
 ): StaticCustomType {
 	const json = Object.entries(customType.json).reduce(
-		(acc: { [key: string]: StaticSection }, [sectionKey, dynSection]: [string, DynamicSection]) => {
+		(
+			acc: { [key: string]: StaticSection },
+			[sectionKey, dynSection]: [string, DynamicSection],
+		) => {
 			return {
 				...acc,
 				[sectionKey]: Sections.toStatic(dynSection, sharedSlices),
@@ -125,14 +155,17 @@ export function validateSlices(
 	customType: CustomType,
 	sharedSlices: Map<string, SharedSlice>,
 ): Either<CustomTypeSlicesError, CustomType> {
-	const missingSlices = _mapSharedSlicesRefs<string | undefined>(customType)((ref: string) => {
-		const slice: SharedSlice | undefined = sharedSlices.get(ref)
-		const isMissing = !slice
-		if (isMissing) return ref
-		return
-	}).filter(Boolean) as Array<string>
-
-	if (missingSlices.length > 0) return left(new CustomTypeSlicesError(missingSlices))
+	const missingSlices = _mapSharedSlicesRefs<string | undefined>(customType)(
+		(ref: string) => {
+			const slice: SharedSlice | undefined = sharedSlices.get(ref)
+			const isMissing = !slice
+			if (isMissing) return ref
+			return
+		},
+	).filter(Boolean) as Array<string>
+
+	if (missingSlices.length > 0)
+		return left(new CustomTypeSlicesError(missingSlices))
 	else return right(customType)
 }
 
@@ -142,13 +175,16 @@ export function collectWidgets(
 ): CustomType {
 	const json = Object.entries(customType.json).reduce(
 		(acc, [sectionId, section]: [string, DynamicSection]) => {
-			const updatedSection = Object.entries(section).reduce((acc, [ref, widget]) => {
-				const updatedWidget = f(ref, widget)
-				if (updatedWidget) {
-					return { ...acc, [ref]: updatedWidget }
-				}
-				return acc
-			}, {})
+			const updatedSection = Object.entries(section).reduce(
+				(acc, [ref, widget]) => {
+					const updatedWidget = f(ref, widget)
+					if (updatedWidget) {
+						return { ...acc, [ref]: updatedWidget }
+					}
+					return acc
+				},
+				{},
+			)
 			return { ...acc, [sectionId]: updatedSection }
 		},
 		{},
@@ -167,7 +203,8 @@ export function filterMissingSharedSlices(
 
 			const choices = Object.entries(widget.config.choices).reduce(
 				(acc, [sliceId, sliceValue]: [string, DynamicSlice]) => {
-					if (sliceValue.type === "SharedSlice" && !sharedSlices.get(sliceId)) return acc
+					if (sliceValue.type === "SharedSlice" && !sharedSlices.get(sliceId))
+						return acc
 					return { ...acc, [sliceId]: sliceValue }
 				},
 				{},
@@ -216,13 +253,15 @@ export function collectSharedSlices(customType: {
 	}, {})
 }
 
-export function traverseCustomType<T extends CustomType | StaticCustomType>(args: {
+export function traverseCustomType<
+	T extends CustomType | StaticCustomType,
+>(args: {
 	customType: T
 	onField: Fields.OnFieldFn<UID | NestableWidget | Group | NestedGroup>
 }): T {
 	const { customType, onField } = args
 
-	let json: Record<string, (typeof customType.json)[string]> | undefined
+	let json: Record<string, typeof customType.json[string]> | undefined
 	for (const [key, section] of Object.entries(customType.json)) {
 		const newSection = traverseSection({
 			path: [key],

package/src/customtypes/Section.ts

@@ -2,12 +2,20 @@ import * as t from "io-ts"
 
 import { WidgetKey } from "../common"
 import type { Fields } from "../utils"
-import type { Group, NestableWidget, NestedGroup, UID } from "./widgets";
-import { traverseGroup, traverseSlices } from "./widgets"
+import {
+	Group,
+	NestableWidget,
+	NestedGroup,
+	traverseGroup,
+	traverseSlices,
+	UID,
+} from "./widgets"
 import type { SharedSlice } from "./widgets/slices"
 import { DynamicWidget, StaticWidget, Widgets } from "./widgets/Widget"
 
-export function sectionReader<T extends StaticWidget | DynamicWidget>(codec: t.Type<T, unknown>) {
+export function sectionReader<T extends StaticWidget | DynamicWidget>(
+	codec: t.Type<T, unknown>,
+) {
 	return t.record(WidgetKey, codec) // WidgetId -> Widget Data
 }
 
@@ -18,9 +26,15 @@ export const DynamicSection = sectionReader(DynamicWidget)
 export type DynamicSection = t.TypeOf<typeof DynamicSection>
 
 export const Sections = {
-	toStatic(dynamic: DynamicSection, sharedSlices: Map<string, SharedSlice>): StaticSection {
+	toStatic(
+		dynamic: DynamicSection,
+		sharedSlices: Map<string, SharedSlice>,
+	): StaticSection {
 		const section = Object.entries(dynamic).reduce(
-			(acc: { [key: string]: StaticWidget }, [widgetKey, widget]: [string, DynamicWidget]) => {
+			(
+				acc: { [key: string]: StaticWidget },
+				[widgetKey, widget]: [string, DynamicWidget],
+			) => {
 				return { ...acc, [widgetKey]: Widgets.toStatic(widget, sharedSlices) }
 			},
 			{},
@@ -29,7 +43,9 @@ export const Sections = {
 	},
 }
 
-export function traverseSection<T extends DynamicSection | StaticSection>(args: {
+export function traverseSection<
+	T extends DynamicSection | StaticSection,
+>(args: {
 	path: ReadonlyArray<string>
 	section: T
 	onField: Fields.OnFieldFn<UID | NestableWidget | Group | NestedGroup>
@@ -46,7 +62,9 @@ export function traverseSection<T extends DynamicSection | StaticSection>(args:
 				model = traverseSlices({
 					path,
 					slices: prevModel,
-					onField: onField as Fields.OnFieldFn<NestableWidget | Group | NestedGroup>,
+					onField: onField as Fields.OnFieldFn<
+						NestableWidget | Group | NestedGroup
+					>,
 				})
 				break
 			case "Group":

package/src/customtypes/diff/SharedSlice.ts

@@ -1,8 +1,7 @@
 import { Arrays, Objects } from "../../utils"
 import type { SharedSlice, Variation } from "../widgets/slices"
 import { type DiffChange, DiffOperation } from "./Changes"
-import type { VariationDiff } from "./Variation";
-import { VariationComparator } from "./Variation"
+import { VariationComparator, VariationDiff } from "./Variation"
 
 export type SliceMetadata = Omit<SharedSlice, "variations">
 export type SliceDiff = DiffChange<
@@ -14,7 +13,10 @@ export type SliceDiff = DiffChange<
 	>
 >
 
-function compareSliceMeta(sliceA?: SharedSlice, sliceB?: SharedSlice): Partial<SliceMetadata> {
+function compareSliceMeta(
+	sliceA?: SharedSlice,
+	sliceB?: SharedSlice,
+): Partial<SliceMetadata> {
 	const zippedSlices = Objects.zipObjects(sliceA, sliceB)
 
 	return Object.entries(zippedSlices).reduce((acc, [key, value]) => {
@@ -59,7 +61,9 @@ export const SliceComparator = {
 
 		const diffSlice = {
 			...diffMeta,
-			...(Objects.isNotEmpty(diffVariations) ? { variations: diffVariations } : {}),
+			...(Objects.isNotEmpty(diffVariations)
+				? { variations: diffVariations }
+				: {}),
 		}
 
 		if (Objects.isNotEmpty(diffSlice)) {

package/src/customtypes/diff/Variation.ts

@@ -1,6 +1,5 @@
 import { Objects } from "../../utils"
-import type { Group} from "../widgets/Group";
-import { GroupFieldType } from "../widgets/Group"
+import { Group, GroupFieldType } from "../widgets/Group"
 import type { NestableWidget } from "../widgets/nestable"
 import type { SlicePrimaryWidget } from "../widgets/slices"
 import type { Variation } from "../widgets/slices"
@@ -38,23 +37,56 @@ function compareWidgets<TWidget extends NestableWidget | Group>(
 	widgetsA?: { [key: string]: TWidget },
 	widgetsB?: { [key: string]: TWidget },
 ):
-	| Record<string, SlicePrimaryWidget extends TWidget ? SlicePrimaryWidgetDiff : NestableWidgetDiff>
+	| Record<
+			string,
+			SlicePrimaryWidget extends TWidget
+				? SlicePrimaryWidgetDiff
+				: NestableWidgetDiff
+	  >
 	| undefined {
 	const zippedWidgets = Objects.zipObjects(widgetsA, widgetsB)
 
-	const diffWidgets = Object.entries(zippedWidgets).reduce((acc, [widgetKey, widgetValue]) => {
-		if (JSON.stringify(widgetValue?.left) === JSON.stringify(widgetValue?.right)) return acc
+	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
+			const changes = (() => {
+				if (!widgetValue?.left && !widgetValue?.right) return
 
-			if (widgetValue?.left && !widgetValue.right) {
-				return {
-					op: DiffOperation.Removed,
+				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?.left && widgetValue?.right) {
 				if (widgetValue.right?.type === GroupFieldType) {
 					const group: GroupWidgetWithFieldsDiff = {
 						...widgetValue.right,
@@ -63,63 +95,45 @@ function compareWidgets<TWidget extends NestableWidget | Group>(
 							fields: {},
 						},
 					}
-					// On added groups, this basically marks all fields in the group as added
-					group.config.fields = compareWidgets(undefined, 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.Added,
+						op: DiffOperation.Updated,
 						value: group,
 					}
 				}
 
 				return {
-					op: DiffOperation.Added,
+					op: DiffOperation.Updated,
 					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,
-				}
-			}
+			if (!changes) return acc
 
 			return {
-				op: DiffOperation.Updated,
-				value: widgetValue.right,
+				...acc,
+				[widgetKey]: changes,
 			}
-		})()
-
-		if (!changes) return acc
-
-		return {
-			...acc,
-			[widgetKey]: changes,
-		}
-	}, {})
+		},
+		{},
+	)
 
 	return Objects.isNotEmpty(diffWidgets) ? diffWidgets : undefined
 }
 
 export const VariationComparator = {
-	compare(variationA?: Variation, variationB?: Variation): VariationDiff | undefined {
+	compare(
+		variationA?: Variation,
+		variationB?: Variation,
+	): VariationDiff | undefined {
 		if (variationA && !variationB)
 			return {
 				op: DiffOperation.Removed,

package/src/customtypes/diff/Widgets.ts

@@ -9,6 +9,9 @@ export type GroupWidgetWithFieldsDiff = Omit<Group, "config"> & {
 		fields?: Record<string, GroupWidgetDiff | NestableWidgetDiff>
 	}
 }
-export type GroupWidgetDiff = DiffChange<GroupWidgetWithFieldsDiff, GroupWidgetWithFieldsDiff>
+export type GroupWidgetDiff = DiffChange<
+	GroupWidgetWithFieldsDiff,
+	GroupWidgetWithFieldsDiff
+>
 
 export type SlicePrimaryWidgetDiff = NestableWidgetDiff | GroupWidgetDiff

package/src/customtypes/widgets/Group.ts

@@ -41,7 +41,9 @@ export type NestedGroupConfig = t.TypeOf<typeof NestedGroupConfig>
 export const NestedGroup = createGroup(NestableWidget)
 export type NestedGroup = t.TypeOf<typeof NestedGroup>
 
-export const GroupConfig = createGroupConfig(t.union([NestableWidget, NestedGroup]))
+export const GroupConfig = createGroupConfig(
+	t.union([NestableWidget, NestedGroup]),
+)
 export type GroupConfig = t.TypeOf<typeof GroupConfig>
 
 export const Group = createGroup(t.union([NestableWidget, NestedGroup]))

package/src/customtypes/widgets/Widget.ts

@@ -30,7 +30,9 @@ import {
 } from "./slices/Slices"
 import { UID, UIDFieldType } from "./UID"
 
-export function widgetReader<T extends StaticSlices | DynamicSlices>(codec: t.Type<T, unknown>) {
+export function widgetReader<T extends StaticSlices | DynamicSlices>(
+	codec: t.Type<T, unknown>,
+) {
 	return t.union([UID, NestableWidget, Group, codec])
 }
 
@@ -66,7 +68,10 @@ export const FieldType = t.keyof({
 export type FieldType = t.TypeOf<typeof FieldType>
 
 export const Widgets = {
-	toStatic(widget: DynamicWidget, sharedSlices: Map<string, SharedSlice>): StaticWidget {
+	toStatic(
+		widget: DynamicWidget,
+		sharedSlices: Map<string, SharedSlice>,
+	): StaticWidget {
 		switch (widget.type) {
 			case "Choice":
 			case "Slices":