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

package/src/content/fields/slices/Slice/SharedSliceContent.ts

@@ -4,27 +4,17 @@ import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 import { withFallback } from "io-ts-types"
 
-import {
-	type SharedSlice,
-	type VariationFields,
-	GroupFieldType,
-} from "../../../../customtypes"
-import {
-	getFieldCtx,
-	LegacyContentCtx,
-	WithTypes,
-} from "../../../LegacyContentCtx"
-import {
+import { type SharedSlice, type VariationFields, GroupFieldType } from "../../../../customtypes"
+import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
+import { getFieldCtx } from "../../../LegacyContentCtx"
+import type {
 	ContentPath,
-	hasContentType,
 	TraverseSliceContentFn,
-	TraverseWidgetContentFn,
-} from "../../../utils"
+	TraverseWidgetContentFn} from "../../../utils";
 import {
-	isGroupContent,
-	traverseGroupContent,
-	traverseGroupItemsContent,
-} from "../../GroupContent"
+	hasContentType
+} from "../../../utils"
+import { isGroupContent, traverseGroupContent, traverseGroupItemsContent } from "../../GroupContent"
 import {
 	isNestableContent,
 	isRepeatableContent,
@@ -73,9 +63,7 @@ export const SharedSliceLegacy = (ctx: LegacyContentCtx) => {
 								ctx,
 								prefixes: ["variations", parsedSlice.variation],
 							})
-							const result = RepeatableWidgetsLegacy(itemsCtx).decode(
-								parsedSlice.items,
-							)
+							const result = RepeatableWidgetsLegacy(itemsCtx).decode(parsedSlice.items)
 							if (!result || isLeft(result)) return
 							return result.right
 						})() || []
@@ -106,9 +94,7 @@ export const SharedSliceLegacy = (ctx: LegacyContentCtx) => {
 			)
 		},
 		(s: SharedSliceContent) => {
-			const primary = Object.entries(s.primary).reduce<
-				WithTypes<Record<string, unknown>>
-			>(
+			const primary = Object.entries(s.primary).reduce<WithTypes<Record<string, unknown>>>(
 				(acc, [key, value]) => {
 					const FieldCtx = getFieldCtx({
 						fieldKey: key,
@@ -171,17 +157,12 @@ export function sharedSliceContentWithDefaultValues(
 	customType: SharedSlice,
 	content: SharedSliceContent,
 ): SharedSliceContent {
-	const variationConfig = customType.variations.find(
-		(v) => v.id === content.variation,
-	)
+	const variationConfig = customType.variations.find((v) => v.id === content.variation)
 
 	const primaryConfig = variationConfig?.primary ?? {}
 	const itemsConfig = variationConfig?.items ?? {}
 
-	const updatedPrimaryContent = withDefaultSlicePrimaryContentValues(
-		primaryConfig,
-		content.primary,
-	)
+	const updatedPrimaryContent = withDefaultSlicePrimaryContentValues(primaryConfig, content.primary)
 	const updatedItemsContent = repeatableContentWithDefaultNestableContentValues(
 		itemsConfig,
 		content.items,
@@ -211,74 +192,75 @@ export function traverseSharedSliceContent({
 		transformWidget: TraverseWidgetContentFn,
 		transformSlice: TraverseSliceContentFn,
 	): SharedSliceItemContent | undefined => {
-		const primary = Object.entries(content.widget.primary).reduce<
-			SharedSliceContent["primary"]
-		>((acc, [fieldKey, fieldContent]) => {
-			const fieldDef = model?.fields?.primary?.[fieldKey]
+		const primary = Object.entries(content.widget.primary).reduce<SharedSliceContent["primary"]>(
+			(acc, [fieldKey, fieldContent]) => {
+				const fieldDef = model?.fields?.primary?.[fieldKey]
 
-			const transformedField = (() => {
-				if (isGroupContent(fieldContent)) {
-					return traverseGroupContent({
-						path: path.concat([
-							{ key: "primary", type: "primary" },
-							{ key: fieldKey, type: "Widget" },
-						]),
-						key: fieldKey,
-						apiId: fieldKey,
-						content: fieldContent,
-						model: fieldDef?.type === GroupFieldType ? fieldDef : undefined,
-					})(transformWidget)
-				} else if (isRepeatableContent(fieldContent)) {
-					return traverseRepeatableContent({
-						path: path.concat([
-							{ key: "primary", type: "primary" },
-							{ key: fieldKey, type: "Widget" },
-						]),
-						key: fieldKey,
-						apiId: fieldKey,
-						content: fieldContent,
-						model: fieldDef?.type === "Link" ? fieldDef : undefined,
-					})(transformWidget)
-				} else if (isTableContent(fieldContent)) {
-					return traverseTableContent({
-						path: path.concat([
-							{ key: "primary", type: "primary" },
-							{ key: fieldKey, type: "Widget" },
-						]),
-						key: fieldKey,
-						apiId: fieldKey,
-						content: fieldContent,
-						model: fieldDef?.type === "Table" ? fieldDef : undefined,
-					})(transformWidget)
-				} else if (isNestableContent(fieldContent)) {
-					return transformWidget({
-						path: path.concat([
-							{ key: "primary", type: "primary" },
-							{ key: fieldKey, type: "Widget" },
-						]),
-						key: fieldKey,
-						apiId: fieldKey,
-						model: fieldDef,
-						content: fieldContent,
-					})
-				} else {
-					return undefined
-				}
-			})()
+				const transformedField = (() => {
+					if (isGroupContent(fieldContent)) {
+						return traverseGroupContent({
+							path: path.concat([
+								{ key: "primary", type: "primary" },
+								{ key: fieldKey, type: "Widget" },
+							]),
+							key: fieldKey,
+							apiId: fieldKey,
+							content: fieldContent,
+							model: fieldDef?.type === GroupFieldType ? fieldDef : undefined,
+						})(transformWidget)
+					} else if (isRepeatableContent(fieldContent)) {
+						return traverseRepeatableContent({
+							path: path.concat([
+								{ key: "primary", type: "primary" },
+								{ key: fieldKey, type: "Widget" },
+							]),
+							key: fieldKey,
+							apiId: fieldKey,
+							content: fieldContent,
+							model: fieldDef?.type === "Link" ? fieldDef : undefined,
+						})(transformWidget)
+					} else if (isTableContent(fieldContent)) {
+						return traverseTableContent({
+							path: path.concat([
+								{ key: "primary", type: "primary" },
+								{ key: fieldKey, type: "Widget" },
+							]),
+							key: fieldKey,
+							apiId: fieldKey,
+							content: fieldContent,
+							model: fieldDef?.type === "Table" ? fieldDef : undefined,
+						})(transformWidget)
+					} else if (isNestableContent(fieldContent)) {
+						return transformWidget({
+							path: path.concat([
+								{ key: "primary", type: "primary" },
+								{ key: fieldKey, type: "Widget" },
+							]),
+							key: fieldKey,
+							apiId: fieldKey,
+							model: fieldDef,
+							content: fieldContent,
+						})
+					} else {
+						return undefined
+					}
+				})()
 
-			// Can happen if the transform function returns undefined to filter out a field
-			if (!transformedField) return acc
-			if (!isSlicePrimaryContent(transformedField)) {
-				console.warn(
-					`Warn: Non nestable or group content with key [${fieldKey}] detected in a shared slice [${sliceName}] with key [${sliceKey}]`,
-				)
-			}
+				// Can happen if the transform function returns undefined to filter out a field
+				if (!transformedField) return acc
+				if (!isSlicePrimaryContent(transformedField)) {
+					console.warn(
+						`Warn: Non nestable or group content with key [${fieldKey}] detected in a shared slice [${sliceName}] with key [${sliceKey}]`,
+					)
+				}
 
-			return {
-				...acc,
-				[fieldKey]: transformedField,
-			}
-		}, {})
+				return {
+					...acc,
+					[fieldKey]: transformedField,
+				}
+			},
+			{},
+		)
 
 		const items = traverseGroupItemsContent({
 			path: path.concat([{ key: "items", type: "items" }]),

package/src/content/fields/slices/Slice/SimpleSliceContent.ts

@@ -1,32 +1,18 @@
 import * as t from "io-ts"
 
-import type {
-	Group,
-	NestableWidget,
-	VariationFields,
-} from "../../../../customtypes"
+import type { Group, NestableWidget, VariationFields } from "../../../../customtypes"
 import type { LegacyContentCtx } from "../../../LegacyContentCtx"
+import type { ContentPath, TraverseSliceContentFn, TraverseWidgetContentFn } from "../../../utils"
 import type {
-	ContentPath,
-	TraverseSliceContentFn,
-	TraverseWidgetContentFn,
-} from "../../../utils"
+	GroupItemContent} from "../../GroupContent";
 import {
 	GroupContent,
-	GroupItemContent,
 	GroupLegacy,
 	isGroupContent,
 	traverseGroupContent,
 } from "../../GroupContent"
-import {
-	isNestableContent,
-	NestableContent,
-	NestableLegacy,
-} from "../../nestable"
-import type {
-	SharedSliceItemContent,
-	SimpleSliceItemContent,
-} from "../SliceItem"
+import { isNestableContent, NestableContent, NestableLegacy } from "../../nestable"
+import type { SharedSliceItemContent, SimpleSliceItemContent } from "../SliceItem"
 
 export const SimpleSliceContent = t.union([NestableContent, GroupContent])
 export type SimpleSliceContent = t.TypeOf<typeof SimpleSliceContent>
@@ -70,22 +56,21 @@ export function traverseSimpleSliceContent({
 		transformSlice: TraverseSliceContentFn,
 	): SharedSliceItemContent | SimpleSliceItemContent | undefined => {
 		if (isGroupContent(content.widget)) {
-			const convertedGroupWidget: GroupContent | undefined =
-				traverseGroupContent({
-					path,
-					key: content.key,
-					apiId: content.name,
-					model: (() => {
-						if (model?.type === "Group") return model
-						if (model?.type === "SharedSlice")
-							return {
-								type: "Group",
-								config: { fields: model.fields.items || {} },
-							}
-						return
-					})(),
-					content: content.widget,
-				})(transformWidget)
+			const convertedGroupWidget: GroupContent | undefined = traverseGroupContent({
+				path,
+				key: content.key,
+				apiId: content.name,
+				model: (() => {
+					if (model?.type === "Group") return model
+					if (model?.type === "SharedSlice")
+						return {
+							type: "Group",
+							config: { fields: model.fields.items || {} },
+						}
+					return
+				})(),
+				content: content.widget,
+			})(transformWidget)
 
 			return (
 				convertedGroupWidget &&
@@ -107,8 +92,7 @@ export function traverseSimpleSliceContent({
 			apiId: content.name,
 			path,
 			model: (() => {
-				if (model?.type === "SharedSlice")
-					return model.fields.primary?.[content.name]
+				if (model?.type === "SharedSlice") return model.fields.primary?.[content.name]
 				if (model?.type !== "Group") return model
 				return
 			})(),
@@ -153,9 +137,7 @@ export function migrateSimpleSlice(
 						key: groupItem.key,
 						value: groupItem.value.reduce<GroupItemContent["value"]>(
 							(acc, [fieldKey, fieldContent]) => {
-								return model.fields.items?.[fieldKey]
-									? acc.concat([[fieldKey, fieldContent]])
-									: acc
+								return model.fields.items?.[fieldKey] ? acc.concat([[fieldKey, fieldContent]]) : acc
 							},
 							[],
 						),
@@ -171,9 +153,7 @@ export function migrateSimpleSlice(
 		widget: {
 			__TYPE__: "SharedSliceContent",
 			variation: model.variationId,
-			primary: model.fields.primary?.[content.name]
-				? { [content.name]: content.widget }
-				: {},
+			primary: model.fields.primary?.[content.name] ? { [content.name]: content.widget } : {},
 			items: [],
 		},
 	}

package/src/content/fields/slices/Slice/SlicePrimaryContent.ts

@@ -3,11 +3,7 @@ import * as t from "io-ts"
 import { GroupFieldType } from "../../../../customtypes"
 import type { LegacyContentCtx } from "../../../LegacyContentCtx"
 import { GroupContent, GroupLegacy, isGroupContent } from "../../GroupContent"
-import {
-	isNestableContent,
-	NestableContent,
-	NestableLegacy,
-} from "../../nestable"
+import { isNestableContent, NestableContent, NestableLegacy } from "../../nestable"
 
 export const SlicePrimaryContent = t.union([NestableContent, GroupContent])
 

package/src/content/fields/slices/Slice/index.ts

@@ -1,10 +1,7 @@
 import * as t from "io-ts"
 
 import type { LegacyContentCtx } from "../../../LegacyContentCtx"
-import {
-	CompositeSliceContent,
-	CompositeSliceLegacy,
-} from "./CompositeSliceContent"
+import { CompositeSliceContent, CompositeSliceLegacy } from "./CompositeSliceContent"
 import { SharedSliceContent, SharedSliceLegacy } from "./SharedSliceContent"
 import { SimpleSliceContent, SimpleSliceLegacy } from "./SimpleSliceContent"
 
@@ -38,11 +35,7 @@ export const SliceLegacy = (ctx: LegacyContentCtx) => {
 	}
 }
 
-export const SliceContent = t.union([
-	CompositeSliceContent,
-	SharedSliceContent,
-	SimpleSliceContent,
-])
+export const SliceContent = t.union([CompositeSliceContent, SharedSliceContent, SimpleSliceContent])
 
 export type SliceContent = t.TypeOf<typeof SliceContent>
 

package/src/content/fields/slices/SliceItem.ts

@@ -5,11 +5,8 @@ import * as t from "io-ts"
 
 import type { StaticSlice } from "../../../customtypes"
 import { nullable } from "../../../validators/function"
-import {
-	getFieldCtx,
-	LegacyContentCtx,
-	WithTypes,
-} from "../../LegacyContentCtx"
+import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx";
+import { getFieldCtx } from "../../LegacyContentCtx"
 import type { TraverseSliceContentFn } from "../../utils"
 import { isGroupContent } from "../GroupContent"
 import { isNestableContent } from "../nestable"
@@ -20,19 +17,19 @@ import {
 	SliceContent,
 	SliceLegacy,
 } from "./Slice"
+import type {
+	CompositeSliceContent} from "./Slice/CompositeSliceContent";
 import {
-	CompositeSliceContent,
 	isCompositeSliceContent,
 	migrateCompositeSlice,
 } from "./Slice/CompositeSliceContent"
-import {
-	isSharedSliceContent,
-	SharedSliceContent,
-} from "./Slice/SharedSliceContent"
+import type { SharedSliceContent } from "./Slice/SharedSliceContent";
+import { isSharedSliceContent } from "./Slice/SharedSliceContent"
+import type {
+	SimpleSliceContent} from "./Slice/SimpleSliceContent";
 import {
 	isSimpleSliceContent,
-	migrateSimpleSlice,
-	SimpleSliceContent,
+	migrateSimpleSlice
 } from "./Slice/SimpleSliceContent"
 
 export const SliceItemContent = t.type({
@@ -45,9 +42,7 @@ export type SliceItemContent = t.TypeOf<typeof SliceItemContent>
 export type SharedSliceItemContent = Omit<SliceItemContent, "widget"> & {
 	widget: SharedSliceContent
 }
-export function isSharedSliceItemContent(
-	item: SliceItemContent,
-): item is SharedSliceItemContent {
+export function isSharedSliceItemContent(item: SliceItemContent): item is SharedSliceItemContent {
 	return isSharedSliceContent(item.widget)
 }
 
@@ -62,9 +57,7 @@ export function isCompositeSliceItemContent(
 export type SimpleSliceItemContent = Omit<SliceItemContent, "widget"> & {
 	widget: SimpleSliceContent
 }
-export function isSimpleSliceItemContent(
-	item: SliceItemContent,
-): item is SimpleSliceItemContent {
+export function isSimpleSliceItemContent(item: SliceItemContent): item is SimpleSliceItemContent {
 	return isGroupContent(item.widget) || isNestableContent(item.widget)
 }
 
@@ -80,16 +73,11 @@ export function sliceItemContentWithDefaultValues(
 		return compositeSliceContentWithDefaultValues(customType, content)
 	}
 
-	if (
-		customType.type === "Group" &&
-		isGroupContent(content) &&
-		customType.config?.fields
-	) {
-		const updateGroupFieldValue =
-			repeatableContentWithDefaultNestableContentValues(
-				customType.config.fields,
-				content.value,
-			)
+	if (customType.type === "Group" && isGroupContent(content) && customType.config?.fields) {
+		const updateGroupFieldValue = repeatableContentWithDefaultNestableContentValues(
+			customType.config.fields,
+			content.value,
+		)
 
 		return {
 			...content,
@@ -130,10 +118,7 @@ export const SlicesItemLegacy = (ctx: LegacyContentCtx) => {
 				itemLegacyReader.decode(sliceItem),
 				either.chain((parsedSlice) => {
 					const stopIdx = parsedSlice.key.indexOf("$")
-					const sliceName = parsedSlice.key.substring(
-						0,
-						stopIdx > 0 ? stopIdx : undefined,
-					)
+					const sliceName = parsedSlice.key.substring(0, stopIdx > 0 ? stopIdx : undefined)
 					const itemCtx = getFieldCtx({
 						fieldKey: sliceName,
 						contentKey: parsedSlice.key,
@@ -172,10 +157,7 @@ export const SlicesItemLegacy = (ctx: LegacyContentCtx) => {
 	)
 }
 
-export const migrateSliceItem: TraverseSliceContentFn = ({
-	model,
-	content,
-}) => {
+export const migrateSliceItem: TraverseSliceContentFn = ({ model, content }) => {
 	if (isCompositeSliceItemContent(content) && model?.type === "SharedSlice")
 		return migrateCompositeSlice(model, content)
 	if (isSimpleSliceItemContent(content) && model?.type === "SharedSlice")