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

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

@@ -1,305 +0,0 @@
-import { either } from "fp-ts"
-import { isLeft } from "fp-ts/lib/Either"
-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 {
-	ContentPath,
-	hasContentType,
-	TraverseSliceContentFn,
-	TraverseWidgetContentFn,
-} from "../../../utils"
-import {
-	isGroupContent,
-	traverseGroupContent,
-	traverseGroupItemsContent,
-} from "../../GroupContent"
-import {
-	isNestableContent,
-	isRepeatableContent,
-	isTableContent,
-	traverseRepeatableContent,
-	traverseTableContent,
-} from "../../nestable"
-import {
-	repeatableContentWithDefaultNestableContentValues,
-	withDefaultSlicePrimaryContentValues,
-} from "../../withDefaultValues"
-import type { SharedSliceItemContent } from "../SliceItem"
-import { RepeatableWidgets, RepeatableWidgetsLegacy } from "./RepeatableContent"
-import {
-	isSlicePrimaryContent,
-	SlicePrimaryContent,
-	SlicePrimaryLegacy,
-} from "./SlicePrimaryContent"
-
-export const SharedSliceContentType = "SharedSliceContent"
-
-export const isSharedSliceContent = (u: unknown): u is SharedSliceContent =>
-	hasContentType(u) && u.__TYPE__ === SharedSliceContentType
-
-const legacyReader = t.exact(
-	t.type({
-		variation: t.string,
-		items: withFallback(t.array(t.unknown), []),
-		primary: withFallback(t.UnknownRecord, {}),
-	}),
-)
-type SharedSliceLegacy = t.TypeOf<typeof legacyReader>
-
-export const SharedSliceLegacy = (ctx: LegacyContentCtx) => {
-	return new t.Type<SharedSliceContent, WithTypes<SharedSliceLegacy>, unknown>(
-		"SharedSliceLegacy",
-		isSharedSliceContent,
-		(slice) => {
-			return pipe(
-				legacyReader.decode(slice),
-				either.map((parsedSlice) => {
-					const items =
-						(() => {
-							const itemsCtx = getFieldCtx({
-								fieldKey: "items",
-								ctx,
-								prefixes: ["variations", parsedSlice.variation],
-							})
-							const result = RepeatableWidgetsLegacy(itemsCtx).decode(
-								parsedSlice.items,
-							)
-							if (!result || isLeft(result)) return
-							return result.right
-						})() || []
-
-					const primary = Object.entries(parsedSlice.primary).reduce<
-						Record<string, SlicePrimaryContent>
-					>((acc, [key, value]) => {
-						const FieldCtx = getFieldCtx({
-							fieldKey: key,
-							ctx,
-							prefixes: ["variations", parsedSlice.variation, "primary"],
-						})
-
-						const result = SlicePrimaryLegacy(FieldCtx).decode(value)
-						if (!result) return acc
-
-						if (isLeft(result)) return acc
-						return { ...acc, [key]: result.right }
-					}, {})
-
-					return {
-						variation: parsedSlice.variation,
-						primary,
-						items,
-						__TYPE__: SharedSliceContentType,
-					}
-				}),
-			)
-		},
-		(s: SharedSliceContent) => {
-			const primary = Object.entries(s.primary).reduce<
-				WithTypes<Record<string, unknown>>
-			>(
-				(acc, [key, value]) => {
-					const FieldCtx = getFieldCtx({
-						fieldKey: key,
-						ctx,
-						prefixes: ["variations", s.variation, "primary"],
-					})
-
-					const result = SlicePrimaryLegacy(FieldCtx).encode(value)
-					if (!result) return acc
-
-					return {
-						content: { ...acc.content, [key]: result.content },
-						types: { ...acc.types, ...result.types },
-						keys: { ...acc.keys, ...result.keys },
-					}
-				},
-				{ content: {}, types: {}, keys: {} },
-			)
-
-			const items =
-				(() => {
-					const itemsCtx = getFieldCtx({
-						fieldKey: "items",
-						ctx,
-						prefixes: ["variations", s.variation],
-					})
-					const result = RepeatableWidgetsLegacy(itemsCtx).encode(s.items)
-					return result
-				})() || []
-
-			return {
-				content: {
-					primary: primary.content,
-					items: items.map((i) => i.content),
-					variation: s.variation,
-				},
-				types: {
-					[ctx.keyOfType]: "SharedSlice",
-					...primary.types,
-					...items.reduce((acc, i) => ({ ...acc, ...i.types }), {}),
-				},
-				keys: {
-					...primary.keys,
-					...items.reduce((acc, i) => ({ ...acc, ...i.keys }), {}),
-				},
-			}
-		},
-	)
-}
-
-export const SharedSliceContent = t.strict({
-	__TYPE__: t.literal(SharedSliceContentType),
-	variation: t.string,
-	primary: t.record(t.string, SlicePrimaryContent),
-	items: RepeatableWidgets,
-})
-export type SharedSliceContent = t.TypeOf<typeof SharedSliceContent>
-
-export function sharedSliceContentWithDefaultValues(
-	customType: SharedSlice,
-	content: SharedSliceContent,
-): SharedSliceContent {
-	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 updatedItemsContent = repeatableContentWithDefaultNestableContentValues(
-		itemsConfig,
-		content.items,
-	)
-
-	return {
-		...content,
-		primary: updatedPrimaryContent,
-		items: updatedItemsContent,
-	}
-}
-
-export function traverseSharedSliceContent({
-	path,
-	sliceKey,
-	sliceName,
-	model,
-	content,
-}: {
-	path: ContentPath
-	sliceKey: string
-	sliceName: string
-	content: SharedSliceItemContent
-	model?: VariationFields | undefined
-}) {
-	return (
-		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 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}]`,
-				)
-			}
-
-			return {
-				...acc,
-				[fieldKey]: transformedField,
-			}
-		}, {})
-
-		const items = traverseGroupItemsContent({
-			path: path.concat([{ key: "items", type: "items" }]),
-			model: model?.fields.items,
-			content: content.widget.items,
-		})(transformWidget)
-
-		return transformSlice({
-			key: sliceKey,
-			apiId: sliceName,
-			path,
-			model: model,
-			content: {
-				...content,
-				widget: {
-					__TYPE__: "SharedSliceContent",
-					variation: content.widget.variation,
-					primary,
-					items,
-				},
-			},
-		})
-	}
-}

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

@@ -1,180 +0,0 @@
-import * as t from "io-ts"
-
-import type {
-	Group,
-	NestableWidget,
-	VariationFields,
-} from "../../../../customtypes"
-import type { LegacyContentCtx } from "../../../LegacyContentCtx"
-import type {
-	ContentPath,
-	TraverseSliceContentFn,
-	TraverseWidgetContentFn,
-} from "../../../utils"
-import {
-	GroupContent,
-	GroupItemContent,
-	GroupLegacy,
-	isGroupContent,
-	traverseGroupContent,
-} from "../../GroupContent"
-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>
-
-export const isSimpleSliceContent = (u: unknown): u is SimpleSliceContent =>
-	isNestableContent(u) || isGroupContent(u)
-
-export const SimpleSliceLegacy = (ctx: LegacyContentCtx) => {
-	return {
-		decode: (() => {
-			if (ctx.fieldType === "Group") return GroupLegacy(ctx).decode.bind(null)
-			return NestableLegacy(ctx).decode.bind(null)
-		})(),
-
-		encode: (value: SimpleSliceContent) => {
-			switch (value.__TYPE__) {
-				case "GroupContentType":
-					return GroupLegacy(ctx).encode(value)
-				default:
-					return NestableLegacy(ctx).encode(value)
-			}
-		},
-	}
-}
-
-export function traverseSimpleSliceContent({
-	path,
-	sliceKey,
-	sliceName,
-	model,
-	content,
-}: {
-	path: ContentPath
-	sliceKey: string
-	sliceName: string
-	content: SimpleSliceItemContent
-	model?: VariationFields | Group | NestableWidget | undefined
-}) {
-	return (
-		transformWidget: TraverseWidgetContentFn,
-		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)
-
-			return (
-				convertedGroupWidget &&
-				transformSlice({
-					key: content.key,
-					apiId: content.name,
-					path,
-					model,
-					content: {
-						...content,
-						widget: convertedGroupWidget,
-					},
-				})
-			)
-		}
-
-		const convertedNestable: NestableContent | undefined = transformWidget({
-			key: content.key,
-			apiId: content.name,
-			path,
-			model: (() => {
-				if (model?.type === "SharedSlice")
-					return model.fields.primary?.[content.name]
-				if (model?.type !== "Group") return model
-				return
-			})(),
-			content: content.widget,
-		})
-
-		return (
-			convertedNestable &&
-			transformSlice({
-				key: sliceKey,
-				apiId: sliceName,
-				path,
-				model,
-				content: {
-					...content,
-					widget: convertedNestable,
-				},
-			})
-		)
-	}
-}
-
-export function migrateSimpleSlice(
-	model: VariationFields,
-	content: SimpleSliceItemContent,
-): SharedSliceItemContent {
-	const [, sliceUUID] = content.key.split("$")
-	const key = `${model.sliceName}$${sliceUUID}`
-
-	if (content.widget.__TYPE__ === "GroupContentType") {
-		return {
-			key,
-			name: model.sliceName,
-			maybeLabel: content.maybeLabel,
-			widget: {
-				__TYPE__: "SharedSliceContent",
-				variation: model.variationId,
-				primary: {},
-				items: content.widget.value.map((groupItem) => {
-					return {
-						__TYPE__: "GroupItemContent",
-						key: groupItem.key,
-						value: groupItem.value.reduce<GroupItemContent["value"]>(
-							(acc, [fieldKey, fieldContent]) => {
-								return model.fields.items?.[fieldKey]
-									? acc.concat([[fieldKey, fieldContent]])
-									: acc
-							},
-							[],
-						),
-					}
-				}, []),
-			},
-		}
-	}
-	return {
-		key,
-		name: model.sliceName,
-		maybeLabel: content.maybeLabel,
-		widget: {
-			__TYPE__: "SharedSliceContent",
-			variation: model.variationId,
-			primary: model.fields.primary?.[content.name]
-				? { [content.name]: content.widget }
-				: {},
-			items: [],
-		},
-	}
-}

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

@@ -1,40 +0,0 @@
-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"
-
-export const SlicePrimaryContent = t.union([NestableContent, GroupContent])
-
-export type SlicePrimaryContent = t.TypeOf<typeof SlicePrimaryContent>
-export type SlicePrimaryContentType = SlicePrimaryContent["__TYPE__"]
-
-export const SlicePrimaryLegacy = (ctx: LegacyContentCtx) => {
-	const groupCodec = GroupLegacy(ctx)
-	const nestableCodec = NestableLegacy(ctx)
-
-	return {
-		decode(value: unknown) {
-			if (ctx.fieldType === GroupFieldType) {
-				return groupCodec.decode(value)
-			}
-
-			return nestableCodec.decode(value)
-		},
-		encode(value: SlicePrimaryContent) {
-			if (isGroupContent(value)) {
-				return groupCodec.encode(value)
-			}
-
-			return nestableCodec.encode(value)
-		},
-	}
-}
-
-export const isSlicePrimaryContent = (u: unknown): u is SlicePrimaryContent =>
-	isNestableContent(u) || isGroupContent(u)

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

@@ -1,52 +0,0 @@
-import * as t from "io-ts"
-
-import type { LegacyContentCtx } from "../../../LegacyContentCtx"
-import {
-	CompositeSliceContent,
-	CompositeSliceLegacy,
-} from "./CompositeSliceContent"
-import { SharedSliceContent, SharedSliceLegacy } from "./SharedSliceContent"
-import { SimpleSliceContent, SimpleSliceLegacy } from "./SimpleSliceContent"
-
-export const SliceLegacy = (ctx: LegacyContentCtx) => {
-	return {
-		decode: (value: unknown) => {
-			const codec = (() => {
-				switch (ctx.fieldType) {
-					case "Slice":
-						return CompositeSliceLegacy(ctx)
-					case "SharedSlice":
-						return SharedSliceLegacy(ctx)
-					default:
-						return SimpleSliceLegacy(ctx)
-				}
-			})()
-
-			return codec.decode(value)
-		},
-
-		encode: (value: SliceContent) => {
-			switch (value.__TYPE__) {
-				case "SharedSliceContent":
-					return SharedSliceLegacy(ctx).encode(value)
-				case "CompositeSliceContent":
-					return CompositeSliceLegacy(ctx).encode(value)
-				default:
-					return SimpleSliceLegacy(ctx).encode(value)
-			}
-		},
-	}
-}
-
-export const SliceContent = t.union([
-	CompositeSliceContent,
-	SharedSliceContent,
-	SimpleSliceContent,
-])
-
-export type SliceContent = t.TypeOf<typeof SliceContent>
-
-export * from "./CompositeSliceContent"
-export * from "./SharedSliceContent"
-export * from "./SimpleSliceContent"
-export * from "./SlicePrimaryContent"