@prismicio/types-internal 3.17.0-alpha.2 → 3.17.0-pr.144.0c8207f

package/src/content/utils.ts

@@ -1,6 +1,4 @@
 import { isRight } from "fp-ts/lib/Either"
-import * as t from "io-ts"
-import { v4 as uuid, validate as validateUuid } from "uuid"
 
 import type {
 	CompositeSlice,
@@ -10,15 +8,18 @@ import type {
 	UID,
 	VariationFields,
 } from "../customtypes"
-import {
-	FieldContentType,
-	FieldType,
+import type {
 	SharedSliceItemContent,
 	SliceItemContent,
-	WidgetContent,
+	WidgetContent} from "./fields";
+import {
+	FieldContentType,
+	FieldType
 } from "./fields"
+export { hasContentType, withKey } from "./helpers"
+import { hasContentType } from "./helpers"
 
-type WithFieldType = WithContentType & { type: FieldType }
+type WithFieldType = { __TYPE__: string; type: FieldType }
 export function hasFieldContentType(obj: unknown): obj is WithFieldType {
 	return (
 		hasContentType(obj) &&
@@ -29,29 +30,6 @@ export function hasFieldContentType(obj: unknown): obj is WithFieldType {
 	)
 }
 
-type WithContentType = { __TYPE__: string }
-export function hasContentType(obj: unknown): obj is WithContentType {
-	return typeof obj === "object" && obj !== null && "__TYPE__" in obj
-}
-
-const isUuid = (input: unknown): input is string =>
-	typeof input === "string" && validateUuid(input)
-
-const uuidWithFallback = new t.Type<string, string, unknown>(
-	"UUID",
-	isUuid,
-	(u, c) => {
-		if (typeof u === "undefined") return t.success(uuid())
-		if (isUuid(u)) return t.success(u)
-		return t.failure(u, c)
-	},
-	t.identity,
-)
-
-export function withKey<C extends t.Mixed>(codec: C) {
-	return t.intersection([t.strict({ key: uuidWithFallback }), codec])
-}
-
 export type TraverseSliceContentFn = <
 	S extends SliceItemContent | SharedSliceItemContent,
 	D extends VariationFields | CompositeSlice | Group | NestableWidget,
@@ -71,10 +49,7 @@ 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,
@@ -86,9 +61,40 @@ 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>({
+	path,
+	key,
+	apiId,
+	model,
+	content,
+}: {
+	path: ContentPath
+	key: string
+	apiId: string
+	model: D
+	content: C
+}) => ([ContentTransformMode] extends ["preserve"] ? C : WidgetContent) | undefined
+
+export type TraverseSliceContentWithModelFn = <
+	S extends SliceItemContent | SharedSliceItemContent | undefined,
+	D extends VariationFields | CompositeSlice | Group | NestableWidget,
+>({
+	path,
+	key,
+	apiId,
+	model,
+	content,
+}: {
+	path: ContentPath
+	key: string
+	apiId: string
+	model: D
+	content: S
+}) => S | SharedSliceItemContent | undefined
 
 export type ContentPathEntry = {
 	type:

package/src/customtypes/CustomType.ts

@@ -1,15 +1,11 @@
-import { Either, left, right } from "fp-ts/lib/Either"
+import type { Either} from "fp-ts/lib/Either";
+import { 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"
@@ -40,9 +36,7 @@ ${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({
@@ -54,7 +48,6 @@ function customTypeReader<T extends StaticSection | DynamicSection>(
 			}),
 			t.partial({
 				format: withFallback(t.keyof(CustomTypeFormat), "custom"),
-				route: StringOrNull,
 			}),
 		]),
 	)
@@ -66,32 +59,20 @@ 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)
 		},
 		[],
@@ -103,28 +84,19 @@ 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> {
@@ -137,10 +109,7 @@ 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),
@@ -156,17 +125,14 @@ 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)
 }
 
@@ -176,16 +142,13 @@ 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 }
 		},
 		{},
@@ -204,8 +167,7 @@ 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 }
 				},
 				{},
@@ -254,15 +216,13 @@ 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,20 +2,12 @@ import * as t from "io-ts"
 
 import { WidgetKey } from "../common"
 import type { Fields } from "../utils"
-import {
-	Group,
-	NestableWidget,
-	NestedGroup,
-	traverseGroup,
-	traverseSlices,
-	UID,
-} from "./widgets"
+import type { Group, NestableWidget, NestedGroup, UID } from "./widgets";
+import { traverseGroup, traverseSlices } 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
 }
 
@@ -26,15 +18,9 @@ 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) }
 			},
 			{},
@@ -43,9 +29,7 @@ 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>
@@ -62,9 +46,7 @@ export function traverseSection<
 				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,7 +1,8 @@
 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 { VariationDiff } from "./Variation";
+import { VariationComparator } from "./Variation"
 
 export type SliceMetadata = Omit<SharedSlice, "variations">
 export type SliceDiff = DiffChange<
@@ -13,10 +14,7 @@ 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]) => {
@@ -61,9 +59,7 @@ 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,5 +1,6 @@
 import { Objects } from "../../utils"
-import { Group, GroupFieldType } from "../widgets/Group"
+import type { Group} from "../widgets/Group";
+import { GroupFieldType } from "../widgets/Group"
 import type { NestableWidget } from "../widgets/nestable"
 import type { SlicePrimaryWidget } from "../widgets/slices"
 import type { Variation } from "../widgets/slices"
@@ -37,56 +38,23 @@ 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) {
-					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) {
+				return {
+					op: DiffOperation.Removed,
 				}
+			}
 
+			if (!widgetValue?.left && widgetValue?.right) {
 				if (widgetValue.right?.type === GroupFieldType) {
 					const group: GroupWidgetWithFieldsDiff = {
 						...widgetValue.right,
@@ -95,45 +63,63 @@ function compareWidgets<TWidget extends NestableWidget | Group>(
 							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,
-						) || {}
+					// 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.Updated,
+						op: DiffOperation.Added,
 						value: group,
 					}
 				}
 
 				return {
-					op: DiffOperation.Updated,
+					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,
+					) || {}
 
-			if (!changes) return acc
+				return {
+					op: DiffOperation.Updated,
+					value: group,
+				}
+			}
 
 			return {
-				...acc,
-				[widgetKey]: changes,
+				op: DiffOperation.Updated,
+				value: widgetValue.right,
 			}
-		},
-		{},
-	)
+		})()
+
+		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,9 +9,6 @@ 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,9 +41,7 @@ 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,9 +30,7 @@ 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])
 }
 
@@ -68,10 +66,7 @@ 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":