@prismicio/types-internal 3.17.0 → 4.0.0-canary.3fe5f1e

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

@@ -1,677 +0,0 @@
-import { either } from "fp-ts"
-import { pipe } from "fp-ts/lib/function"
-import * as t from "io-ts"
-
-import {
-	type StaticSlices,
-	CompositeSlice,
-	Group,
-	isCompositeSlice,
-	isLegacySlice,
-	isStaticSharedSlice,
-	NestableWidget,
-	SharedSlice,
-	Variation,
-	VariationFields,
-} from "../../../customtypes"
-import type {
-	FieldOrSliceType,
-	LegacyContentCtx,
-	WithTypes,
-} from "../../LegacyContentCtx"
-import {
-	ContentPath,
-	TraverseSliceContentFn,
-	TraverseSliceContentWithModelFn,
-	TraverseWidgetContentFn,
-	TraverseWidgetContentWithModelFn,
-} from "../../utils"
-import { hasContentType } from "../../utils"
-import {
-	isGroupContent,
-	traverseGroupContentWithModel,
-	traverseGroupItemsContentWithModel,
-} from "../GroupContent"
-import {
-	isNestableContent,
-	isRepeatableContent,
-	isTableContent,
-	traverseRepeatableContentWithModel,
-	traverseTableContentWithModel,
-} from "../nestable"
-import {
-	CompositeSliceContent,
-	traverseCompositeSliceContent,
-} from "./Slice/CompositeSliceContent"
-import {
-	SharedSliceContent,
-	traverseSharedSliceContent,
-} from "./Slice/SharedSliceContent"
-import {
-	SimpleSliceContent,
-	traverseSimpleSliceContent,
-} from "./Slice/SimpleSliceContent"
-import {
-	isCompositeSliceItemContent,
-	isSharedSliceItemContent,
-	isSimpleSliceItemContent,
-	SharedSliceItemContent,
-	SliceItemContent,
-	sliceItemContentWithDefaultValues,
-	SlicesItemLegacy,
-} from "./SliceItem"
-
-export const SlicesContentType = "SliceContentType"
-
-export const isSlicesContent = (u: unknown): u is SlicesContent =>
-	hasContentType(u) && u.__TYPE__ === SlicesContentType
-
-type SlicesLegacy = Array<unknown>
-
-export type SliceModel =
-	| VariationFields
-	| NestableWidget
-	| CompositeSlice
-	| Group
-
-export const SlicesLegacy = (ctx: LegacyContentCtx) => {
-	const codec = t.array(SlicesItemLegacy(ctx))
-	return new t.Type<SlicesContent, WithTypes<SlicesLegacy>, unknown>(
-		"SlicesLegacy",
-		isSlicesContent,
-		(items) => {
-			return pipe(
-				codec.decode(items),
-				either.map((parsedSlices) => {
-					return {
-						__TYPE__: SlicesContentType,
-						value: parsedSlices,
-					}
-				}),
-			)
-		},
-		(s: SlicesContent) => {
-			const result = codec.encode(s.value)
-
-			return {
-				content: result.map((s) => s.content),
-				types: result.reduce<Record<string, FieldOrSliceType>>(
-					(acc, s) => ({ ...acc, ...s.types }),
-					{ [ctx.keyOfType]: "Slices" },
-				),
-				keys: result.reduce<Record<string, string>>(
-					(acc, s) => ({ ...acc, ...s.keys }),
-					{},
-				),
-			}
-		},
-	)
-}
-
-export const SlicesContent = t.type({
-	__TYPE__: t.literal(SlicesContentType),
-	value: t.array(SliceItemContent),
-})
-
-export type SlicesContent = t.TypeOf<typeof SlicesContent>
-
-export function slicesContentWithDefaultValues(
-	codec: StaticSlices,
-	content: SlicesContent,
-): SlicesContent {
-	const choices = codec?.config?.choices
-
-	if (choices === undefined) return content
-
-	const updateSlicesValue = content.value.map((slice) => {
-		const sliceConfig = choices[slice.name]
-		if (sliceConfig) {
-			const updatedSliceWidget = sliceItemContentWithDefaultValues(
-				sliceConfig,
-				slice.widget,
-			)
-			return {
-				...slice,
-				widget: updatedSliceWidget,
-			}
-		}
-		return slice
-	})
-
-	return {
-		...content,
-		value: updateSlicesValue,
-	}
-}
-
-function findSliceModel(
-	slicesPath: ContentPath,
-	model: StaticSlices,
-	content: SliceItemContent,
-): SliceModel | undefined {
-	const defaultModel = model?.config?.choices?.[content.name]
-
-	// regular case for shared slices
-	const sharedSliceModel = (): VariationFields | undefined => {
-		if (isSharedSliceItemContent(content)) {
-			if (defaultModel && isStaticSharedSlice(defaultModel)) {
-				const variationDef = defaultModel.variations.find(
-					(v) => v.id === content.widget.variation,
-				)
-				return variationDef
-					? {
-							type: "SharedSlice",
-							sliceName: defaultModel.id,
-							variationId: variationDef.id,
-							fields: {
-								primary: variationDef.primary || {},
-								items: variationDef.items || {},
-							},
-					  }
-					: undefined
-			}
-		}
-		return
-	}
-
-	const migratedSliceModel = (): VariationFields | undefined => {
-		const legacyContentPath = ContentPath.append(
-			ContentPath.serialize(slicesPath),
-			content.name,
-		)
-
-		const migratedSliceModel = Object.values(model?.config?.choices || {}).find(
-			(sliceModel): sliceModel is SharedSlice => {
-				if (isStaticSharedSlice(sliceModel)) {
-					return !!sliceModel.legacyPaths?.[legacyContentPath]
-				}
-
-				return false
-			},
-		)
-		if (!migratedSliceModel) return
-
-		const migratedVariation = migratedSliceModel?.variations.find(
-			(v) => v.id === migratedSliceModel.legacyPaths?.[legacyContentPath],
-		)
-		if (!migratedVariation) return
-
-		return {
-			type: "SharedSlice",
-			sliceName: migratedSliceModel.id,
-			variationId: migratedVariation.id,
-			fields: {
-				primary: migratedVariation.primary || {},
-				items: migratedVariation.items || {},
-			},
-		}
-	}
-
-	const legacySliceModel = ():
-		| NestableWidget
-		| CompositeSlice
-		| Group
-		| undefined => {
-		if (!defaultModel) return
-
-		if (isCompositeSlice(defaultModel)) {
-			return {
-				type: "Slice",
-				"non-repeat": defaultModel["non-repeat"] || {},
-				repeat: defaultModel.repeat || {},
-			}
-		}
-		if (isLegacySlice(defaultModel)) {
-			return defaultModel
-		}
-
-		return
-	}
-	return sharedSliceModel() || migratedSliceModel() || legacySliceModel()
-}
-
-export function traverseSlices({
-	path,
-	key,
-	model,
-	content,
-}: {
-	path: ContentPath
-	key: string
-	content: SlicesContent
-	model?: StaticSlices | undefined
-}) {
-	return ({
-		transformWidget = ({ content }) => content,
-		transformSlice = ({ content }) => content,
-	}: {
-		transformWidget?: TraverseWidgetContentFn
-		transformSlice?: TraverseSliceContentFn
-	}): SlicesContent | undefined => {
-		const value = content.value.reduce<SlicesContent["value"]>(
-			(acc, sliceContent) => {
-				const sliceModel = model && findSliceModel(path, model, sliceContent)
-
-				const convertedSlice: SliceItemContent | undefined = (() => {
-					if (isSharedSliceItemContent(sliceContent))
-						return traverseSharedSliceContent({
-							path: path.concat({
-								key: sliceContent.key,
-								type: "SharedSlice",
-							}),
-							sliceKey: sliceContent.key,
-							sliceName: sliceContent.name,
-							model:
-								sliceModel?.type === "SharedSlice" ? sliceModel : undefined,
-							content: sliceContent,
-						})(transformWidget, transformSlice)
-
-					if (isCompositeSliceItemContent(sliceContent))
-						return traverseCompositeSliceContent({
-							path: path.concat({
-								key: sliceContent.key,
-								type: "Slice",
-							}),
-							sliceKey: sliceContent.key,
-							sliceName: sliceContent.name,
-							model:
-								sliceModel?.type === "Slice" ||
-								sliceModel?.type === "SharedSlice"
-									? sliceModel
-									: undefined,
-							content: sliceContent,
-						})(transformWidget, transformSlice)
-
-					if (isSimpleSliceItemContent(sliceContent))
-						return traverseSimpleSliceContent({
-							path: path.concat({
-								key: sliceContent.key,
-								type: "LegacySlice",
-							}),
-							sliceKey: sliceContent.key,
-							sliceName: sliceContent.name,
-							model:
-								sliceModel && sliceModel?.type !== "Slice"
-									? sliceModel
-									: undefined,
-							content: sliceContent,
-						})(transformWidget, transformSlice)
-
-					return
-				})()
-
-				return convertedSlice ? acc.concat(convertedSlice) : acc
-			},
-			[],
-		)
-
-		return transformWidget({
-			path,
-			key,
-			apiId: key,
-			model,
-			content: {
-				__TYPE__: content.__TYPE__,
-				value,
-			},
-		})
-	}
-}
-
-function buildVariationFields(
-	sharedSlice: SharedSlice,
-	variation: Variation,
-): VariationFields {
-	return {
-		type: "SharedSlice",
-		sliceName: sharedSlice.id,
-		variationId: variation.id,
-		fields: {
-			primary: variation.primary ?? {},
-			items: variation.items ?? {},
-		},
-	}
-}
-
-export function traverseSharedSliceContentWithModel({
-	path,
-	sliceKey,
-	sliceName,
-	model,
-	content,
-}: {
-	path: ContentPath
-	sliceKey: string
-	sliceName: string
-	model: VariationFields
-	content: SharedSliceItemContent | undefined
-}): (
-	transformWidget: TraverseWidgetContentWithModelFn,
-	transformSlice: TraverseSliceContentWithModelFn,
-) => SharedSliceItemContent | undefined {
-	return (transformWidget, transformSlice) => {
-		if (!content) {
-			return undefined
-		}
-
-		const primary = Object.entries(model.fields.primary ?? {}).reduce<
-			SharedSliceContent["primary"]
-		>((acc, [fieldKey, fieldModel]) => {
-			const fieldContent = content.widget.primary[fieldKey]
-
-			const fieldPath = path.concat([
-				{ key: "primary", type: "primary" },
-				{ key: fieldKey, type: "Widget" },
-			])
-
-			let transformedField
-			if (fieldModel.type === "Group") {
-				const groupContent = isGroupContent(fieldContent)
-					? fieldContent
-					: undefined
-				transformedField = traverseGroupContentWithModel({
-					path: fieldPath,
-					key: fieldKey,
-					model: fieldModel,
-					content: groupContent,
-				})(transformWidget)
-			} else if (
-				fieldModel.type === "Link" &&
-				fieldModel.config?.repeat === true
-			) {
-				const repeatableContent = isRepeatableContent(fieldContent)
-					? fieldContent
-					: undefined
-				transformedField = traverseRepeatableContentWithModel({
-					path: fieldPath,
-					key: fieldKey,
-					model: fieldModel,
-					content: repeatableContent,
-				})(transformWidget)
-			} else if (fieldModel.type === "Table") {
-				const tableContent = isTableContent(fieldContent)
-					? fieldContent
-					: undefined
-				transformedField = traverseTableContentWithModel({
-					path: fieldPath,
-					key: fieldKey,
-					model: fieldModel,
-					content: tableContent,
-				})(transformWidget)
-			} else {
-				const nestableContent = isNestableContent(fieldContent)
-					? fieldContent
-					: undefined
-				transformedField = transformWidget({
-					path: fieldPath,
-					key: fieldKey,
-					apiId: fieldKey,
-					model: fieldModel,
-					content: nestableContent,
-				})
-			}
-
-			if (!transformedField) return acc
-
-			return {
-				...acc,
-				[fieldKey]: transformedField,
-			}
-		}, {})
-
-		const items = traverseGroupItemsContentWithModel({
-			path: path.concat([{ key: "items", type: "items" }]),
-			model: model.fields.items ?? {},
-			content: content.widget.items,
-		})(transformWidget)
-
-		return transformSlice({
-			key: sliceKey,
-			apiId: sliceName,
-			path,
-			model,
-			content: {
-				...content,
-				widget: {
-					__TYPE__: "SharedSliceContent",
-					variation: content.widget.variation,
-					primary,
-					items,
-				},
-			},
-		})
-	}
-}
-
-function traverseCompositeSliceContentWithModel({
-	path,
-	sliceKey,
-	sliceName,
-	model,
-	content,
-}: {
-	path: ContentPath
-	sliceKey: string
-	sliceName: string
-	model: CompositeSlice | VariationFields
-	content: SliceItemContent | undefined
-}): (
-	transformWidget: TraverseWidgetContentWithModelFn,
-	transformSlice: TraverseSliceContentWithModelFn,
-) => SliceItemContent | undefined {
-	return (transformWidget, transformSlice) => {
-		if (!content || !isCompositeSliceItemContent(content)) {
-			return undefined
-		}
-
-		const nonRepeatModel =
-			model.type === "SharedSlice"
-				? model.fields.primary ?? {}
-				: model["non-repeat"] ?? {}
-		const repeatModel =
-			model.type === "SharedSlice"
-				? model.fields.items ?? {}
-				: model.repeat ?? {}
-
-		const nonRepeat = Object.entries(nonRepeatModel).reduce<
-			CompositeSliceContent["nonRepeat"]
-		>((acc, [fieldKey, fieldModel]) => {
-			const fieldContent = content.widget.nonRepeat[fieldKey]
-			const fieldPath = path.concat([
-				{ key: "non-repeat", type: "primary" },
-				{ key: fieldKey, type: "Widget" },
-			])
-
-			const nestableContent = isNestableContent(fieldContent)
-				? fieldContent
-				: undefined
-
-			const transformedField = transformWidget({
-				path: fieldPath,
-				key: fieldKey,
-				apiId: sliceName,
-				model: fieldModel,
-				content: nestableContent,
-			})
-
-			if (!transformedField || !isNestableContent(transformedField)) return acc
-
-			return {
-				...acc,
-				[fieldKey]: transformedField,
-			}
-		}, {})
-
-		const repeat = traverseGroupItemsContentWithModel({
-			path: path.concat([{ key: "repeat", type: "items" }]),
-			model: repeatModel,
-			content: content.widget.repeat,
-		})(transformWidget)
-
-		return transformSlice({
-			key: sliceKey,
-			apiId: sliceName,
-			path,
-			model: model.type === "SharedSlice" ? model : model,
-			content: {
-				...content,
-				widget: {
-					__TYPE__: content.widget.__TYPE__,
-					nonRepeat,
-					repeat,
-				},
-			},
-		})
-	}
-}
-
-export function traverseSlicesWithModel({
-	path,
-	key,
-	model,
-	content,
-}: {
-	path: ContentPath
-	key: string
-	model: StaticSlices
-	content: SlicesContent | undefined
-}): (args: {
-	transformWidget: TraverseWidgetContentWithModelFn
-	transformSlice: TraverseSliceContentWithModelFn
-}) => SlicesContent | undefined {
-	return ({ transformWidget, transformSlice }) => {
-		const choices = model.config?.choices ?? {}
-
-		const value = (content?.value ?? []).reduce<SlicesContent["value"]>(
-			(acc, sliceContent) => {
-				const sliceName = sliceContent.name
-				const sliceModel = choices[sliceName]
-
-				if (!sliceModel) {
-					return acc
-				}
-
-				const slicePath = path.concat({
-					key: sliceContent.key,
-					type: isStaticSharedSlice(sliceModel)
-						? "SharedSlice"
-						: isCompositeSlice(sliceModel)
-						? "Slice"
-						: "LegacySlice",
-				})
-
-				let convertedSlice: SliceItemContent | undefined
-
-				if (isStaticSharedSlice(sliceModel)) {
-					if (isSharedSliceItemContent(sliceContent)) {
-						const variation = sliceModel.variations.find(
-							(v) => v.id === sliceContent.widget.variation,
-						)
-						if (variation) {
-							const variationFields = buildVariationFields(
-								sliceModel,
-								variation,
-							)
-							convertedSlice = traverseSharedSliceContentWithModel({
-								path: slicePath,
-								sliceKey: sliceContent.key,
-								sliceName,
-								model: variationFields,
-								content: sliceContent,
-							})(transformWidget, transformSlice)
-						}
-					} else if (isCompositeSliceItemContent(sliceContent)) {
-						const defaultVariation = sliceModel.variations[0]
-						if (defaultVariation) {
-							const variationFields = buildVariationFields(
-								sliceModel,
-								defaultVariation,
-							)
-							convertedSlice = traverseCompositeSliceContentWithModel({
-								path: slicePath,
-								sliceKey: sliceContent.key,
-								sliceName,
-								model: variationFields,
-								content: sliceContent,
-							})(transformWidget, transformSlice)
-						}
-					}
-				} else if (isCompositeSlice(sliceModel)) {
-					if (isCompositeSliceItemContent(sliceContent)) {
-						convertedSlice = traverseCompositeSliceContentWithModel({
-							path: slicePath,
-							sliceKey: sliceContent.key,
-							sliceName,
-							model: sliceModel,
-							content: sliceContent,
-						})(transformWidget, transformSlice)
-					}
-				} else if (isLegacySlice(sliceModel)) {
-					if (isSimpleSliceItemContent(sliceContent)) {
-						let convertedWidget: SimpleSliceContent | undefined
-
-						if (isGroupContent(sliceContent.widget)) {
-							const groupModel =
-								sliceModel?.type === "Group" ? sliceModel : undefined
-
-							if (groupModel) {
-								convertedWidget = traverseGroupContentWithModel({
-									path: slicePath,
-									key: sliceContent.key,
-									model: groupModel,
-									content: sliceContent.widget,
-								})(transformWidget)
-							}
-						} else if (isNestableContent(sliceContent.widget)) {
-							const nestableModel =
-								sliceModel?.type !== "Group" ? sliceModel : undefined
-
-							if (nestableModel) {
-								convertedWidget = transformWidget({
-									key: sliceContent.key,
-									apiId: sliceName,
-									path: slicePath,
-									model: nestableModel,
-									content: sliceContent.widget,
-								})
-							}
-						}
-
-						convertedSlice =
-							convertedWidget &&
-							transformSlice({
-								key: sliceContent.key,
-								apiId: sliceName,
-								path: slicePath,
-								model: sliceModel,
-								content: {
-									...sliceContent,
-									widget: convertedWidget,
-								},
-							})
-					}
-				}
-
-				if (convertedSlice) {
-					acc.push(convertedSlice)
-				}
-
-				return acc
-			},
-			[],
-		)
-
-		return transformWidget({
-			path,
-			key,
-			apiId: key,
-			model,
-			content: content
-				? {
-						__TYPE__: content.__TYPE__,
-						value,
-				  }
-				: undefined,
-		})
-	}
-}

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

@@ -1,3 +0,0 @@
-export * from "./Slice"
-export * from "./SliceItem"
-export * from "./SlicesContent"

package/src/content/helpers.ts

@@ -1,25 +0,0 @@
-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 {
-	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])
-}

package/src/content/index.ts

@@ -1,4 +0,0 @@
-export * from "./Document"
-export * from "./fields"
-export * from "./LegacyContentCtx"
-export * from "./utils"