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

package/src/content/codec/field.ts

@@ -0,0 +1,96 @@
+import type { z } from "zod/mini"
+
+import {
+	ColorContentSchema,
+	DateContentSchema,
+	FieldContentType,
+	NumberContentSchema,
+	RangeContentSchema,
+	SelectContentSchema,
+	TextContentSchema,
+	TimestampContentSchema,
+} from "../field"
+import type {
+	ColorContent,
+	DateContent,
+	NumberContent,
+	RangeContent,
+	SelectContent,
+	TextContent,
+	TimestampContent,
+} from "../field"
+import type { StringLegacy } from "../legacy/field"
+import { StringLegacySchema } from "../legacy/field"
+import type { LegacyContentCtx, LegacyCodec } from "./legacyContentCtx"
+
+type LegacyFieldContent =
+	| TextContent
+	| ColorContent
+	| DateContent
+	| TimestampContent
+	| NumberContent
+	| RangeContent
+	| SelectContent
+
+function createFieldLegacyCodec<TContent extends LegacyFieldContent>(
+	ctx: LegacyContentCtx,
+	name: string,
+	type: TContent["type"],
+	schema: z.ZodMiniType<TContent>,
+): LegacyCodec<TContent, StringLegacy> {
+	return {
+		name,
+		is(input): input is TContent {
+			return schema.safeParse(input).success
+		},
+		toContent(input) {
+			const parsed = StringLegacySchema.safeParse(input)
+			if (!parsed.success) {
+				return parsed
+			}
+
+			return {
+				success: true,
+				data: {
+					__TYPE__: FieldContentType,
+					type,
+					value: parsed.data,
+				} as TContent,
+			}
+		},
+		fromContent(input) {
+			return {
+				content: input.value,
+				types: { [ctx.keyOfType]: type },
+				keys: {},
+			}
+		},
+	}
+}
+
+export const TextLegacyCodec = (ctx: LegacyContentCtx): LegacyCodec<TextContent, StringLegacy> =>
+	createFieldLegacyCodec(ctx, "TextLegacy", "Text", TextContentSchema)
+
+export const ColorLegacyCodec = (ctx: LegacyContentCtx): LegacyCodec<ColorContent, StringLegacy> =>
+	createFieldLegacyCodec(ctx, "ColorLegacy", "Color", ColorContentSchema)
+
+export const DateLegacyCodec = (ctx: LegacyContentCtx): LegacyCodec<DateContent, StringLegacy> =>
+	createFieldLegacyCodec(ctx, "DateLegacy", "Date", DateContentSchema)
+
+export const TimestampLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<TimestampContent, StringLegacy> =>
+	createFieldLegacyCodec(ctx, "TimestampLegacy", "Timestamp", TimestampContentSchema)
+
+export const NumberLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<NumberContent, StringLegacy> =>
+	createFieldLegacyCodec(ctx, "NumberLegacy", "Number", NumberContentSchema)
+
+export const RangeLegacyCodec = (ctx: LegacyContentCtx): LegacyCodec<RangeContent, StringLegacy> =>
+	createFieldLegacyCodec(ctx, "RangeLegacy", "Range", RangeContentSchema)
+
+export const SelectLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<SelectContent, StringLegacy> =>
+	createFieldLegacyCodec(ctx, "SelectLegacy", "Select", SelectContentSchema)

package/src/content/codec/geopoint.ts

@@ -0,0 +1,40 @@
+import { GeoPointContentSchema } from "../geopoint"
+import type { GeoPointContent } from "../geopoint"
+import { GeoPointLegacySchema } from "../legacy/geopoint"
+import type { GeoPointLegacy } from "../legacy/geopoint"
+import type { LegacyCodec, LegacyContentCtx } from "./legacyContentCtx"
+
+const GeoPointContentType = "GeoPointContent"
+
+export const GeoPointLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<GeoPointContent, GeoPointLegacy> => ({
+	name: "GeoPointLegacy",
+
+	is(input): input is GeoPointContent {
+		return GeoPointContentSchema.safeParse(input).success
+	},
+
+	toContent(input) {
+		const parsed = GeoPointLegacySchema.safeParse(input)
+		if (!parsed.success) {
+			return parsed
+		}
+
+		return {
+			success: true,
+			data: {
+				...parsed.data,
+				__TYPE__: GeoPointContentType,
+			},
+		}
+	},
+
+	fromContent(input) {
+		return {
+			content: { position: input.position },
+			types: { [ctx.keyOfType]: "GeoPoint" },
+			keys: {},
+		}
+	},
+})

package/src/content/codec/group.ts

@@ -0,0 +1,163 @@
+import {
+	GroupContentSchema,
+	GroupContentType,
+	GroupItemContentSchema,
+	GroupItemContentType,
+	NestableAndGroupContentSchema,
+} from "../group"
+import type { GroupContent, GroupItemContent, NestableAndGroupContent } from "../group"
+import { GroupItemLegacySchema, GroupLegacySchema } from "../legacy/group"
+import type { GroupItemLegacy, GroupLegacy, NestableAndGroupLegacy } from "../legacy/group"
+import { type LegacyContentCtx, type LegacyCodec, getFieldCtx } from "./legacyContentCtx"
+import { NestableLegacyCodec } from "./nestable"
+
+export const GroupItemLegacyCodec = (
+	ctx: LegacyContentCtx,
+	index: number,
+): LegacyCodec<GroupItemContent, GroupItemLegacy> => ({
+	name: "GroupItemLegacy",
+
+	is(input): input is GroupItemContent {
+		return GroupItemContentSchema.safeParse(input).success
+	},
+
+	toContent(input) {
+		const parsed = GroupItemLegacySchema.safeParse(input)
+		if (!parsed.success) {
+			return parsed
+		}
+
+		const groupItemCtx = ctx.withContentKey(index.toString())
+
+		const value: GroupItemContent["value"] = []
+		for (const [key, legacy] of Object.entries(parsed.data)) {
+			const itemCtx = getFieldCtx({
+				fieldKey: key,
+				contentKey: key,
+				ctx: groupItemCtx,
+			})
+
+			const result = NestableAndGroupLegacyCodec(itemCtx).toContent(legacy)
+			if (result.success) {
+				value.push([key, result.data])
+			}
+		}
+
+		return {
+			success: true,
+			data: {
+				__TYPE__: GroupItemContentType,
+				key: groupItemCtx.fieldContentKey,
+				value,
+			},
+		}
+	},
+
+	fromContent(input) {
+		const groupItemCtx = ctx.withContentKey(index.toString())
+
+		const legacy: ReturnType<LegacyCodec<GroupItemContent, GroupItemLegacy>["fromContent"]> = {
+			content: {},
+			types: {},
+			keys: { [groupItemCtx.keyOfKey]: input.key },
+		}
+
+		for (const [key, content] of input.value) {
+			const itemCtx = getFieldCtx({ fieldKey: key, ctx })
+
+			const result = NestableAndGroupLegacyCodec(itemCtx).fromContent(content)
+			if (result) {
+				legacy.content[key] = result.content
+				legacy.types = { ...legacy.types, ...result.types }
+				legacy.keys = { ...legacy.keys, ...result.keys }
+			}
+		}
+
+		return legacy
+	},
+})
+
+export const GroupLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<GroupContent, GroupLegacy> => ({
+	name: "GroupLegacy",
+
+	is(input): input is GroupContent {
+		return GroupContentSchema.safeParse(input).success
+	},
+
+	toContent(input) {
+		const parsed = GroupLegacySchema.safeParse(input)
+		if (!parsed.success) {
+			return parsed
+		}
+
+		const value: GroupContent["value"] = []
+		for (let index = 0; index < parsed.data.length; index++) {
+			const item = parsed.data[index]
+
+			// Replace null items with empty GroupItemContent
+			if (!item) {
+				value.push({
+					__TYPE__: GroupItemContentType,
+					key: ctx.withContentKey(index.toString()).fieldContentKey,
+					value: [],
+				})
+				continue
+			}
+
+			const result = GroupItemLegacyCodec(ctx, index).toContent(item)
+			if (!result.success) {
+				return result
+			}
+
+			value.push(result.data)
+		}
+
+		return {
+			success: true,
+			data: { __TYPE__: GroupContentType, value },
+		}
+	},
+
+	fromContent(input) {
+		const legacy: ReturnType<LegacyCodec<GroupContent, GroupLegacy>["fromContent"]> = {
+			content: [],
+			types: { [ctx.keyOfType]: "Group" },
+			keys: {},
+		}
+
+		for (let index = 0; index < input.value.length; index++) {
+			const item = input.value[index]
+			const result = GroupItemLegacyCodec(ctx, index).fromContent(item)
+
+			legacy.content.push(result.content)
+			legacy.types = { ...legacy.types, ...result.types }
+			legacy.keys = { ...legacy.keys, ...result.keys }
+		}
+
+		return legacy
+	},
+})
+
+export const NestableAndGroupLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<NestableAndGroupContent, NestableAndGroupLegacy, true> => ({
+	name: "NestableAndGroupLegacy",
+
+	is(input): input is NestableAndGroupContent {
+		return NestableAndGroupContentSchema.safeParse(input).success
+	},
+
+	toContent(input) {
+		return ctx.fieldType === "Group"
+			? GroupLegacyCodec(ctx).toContent(input)
+			: NestableLegacyCodec(ctx).toContent(input)
+	},
+
+	fromContent(input) {
+		return input.__TYPE__ === GroupContentType
+			? GroupLegacyCodec(ctx).fromContent(input)
+			: NestableLegacyCodec(ctx).fromContent(input)
+	},
+})

package/src/content/codec/image.ts

@@ -0,0 +1,50 @@
+import { ImageContentSchema, ImageContentType } from "../image"
+import type { ImageContent } from "../image"
+import type { ImageLegacy } from "../legacy/image"
+import { ImageLegacySchema } from "../legacy/image"
+import type { LegacyContentCtx, LegacyCodec } from "./legacyContentCtx"
+
+// Also used by content/codec/richText
+export function imageLegacyToContent(value: ImageLegacy): ImageContent {
+	return { ...value, __TYPE__: ImageContentType }
+}
+
+export const ImageLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<ImageContent, ImageLegacy> => ({
+	name: "ImageLegacy",
+
+	is(input): input is ImageContent {
+		return ImageContentSchema.safeParse(input).success
+	},
+
+	toContent(input) {
+		const parsed = ImageLegacySchema.safeParse(input)
+		if (!parsed.success) {
+			return parsed
+		}
+
+		return {
+			success: true,
+			data: imageLegacyToContent(parsed.data),
+		}
+	},
+
+	fromContent(input) {
+		return {
+			content: {
+				edit: input.edit,
+				height: input.height,
+				origin: input.origin,
+				width: input.width,
+				...(input.alt ? { alt: input.alt } : {}),
+				...(input.credits ? { credits: input.credits } : {}),
+				...(input.provider ? { provider: input.provider } : {}),
+				...(input.thumbnails ? { thumbnails: input.thumbnails } : {}),
+				...(input.url ? { url: input.url } : {}),
+			},
+			types: { [ctx.keyOfType]: "Image" },
+			keys: {},
+		}
+	},
+})

package/src/content/codec/integrationField.ts

@@ -0,0 +1,38 @@
+import { IntegrationFieldContentSchema, IntegrationFieldContentType } from "../integrationField"
+import type { IntegrationFieldContent } from "../integrationField"
+import { IntegrationFieldLegacySchema } from "../legacy/integrationField"
+import type { IntegrationFieldLegacy } from "../legacy/integrationField"
+import type { LegacyContentCtx, LegacyCodec } from "./legacyContentCtx"
+
+export const IntegrationFieldLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<IntegrationFieldContent, IntegrationFieldLegacy> => ({
+	name: "IntegrationFieldLegacy",
+
+	is(input): input is IntegrationFieldContent {
+		return IntegrationFieldContentSchema.safeParse(input).success
+	},
+
+	toContent(input) {
+		const parsed = IntegrationFieldLegacySchema.safeParse(input)
+		if (!parsed.success) {
+			return parsed
+		}
+
+		return {
+			success: true,
+			data: {
+				__TYPE__: IntegrationFieldContentType,
+				value: parsed.data,
+			},
+		}
+	},
+
+	fromContent(input) {
+		return {
+			content: input.value,
+			types: { [ctx.keyOfType]: "IntegrationFields" },
+			keys: {},
+		}
+	},
+})

package/src/content/{LegacyContentCtx.ts → codec/legacyContentCtx.ts}

@@ -1,13 +1,6 @@
-import * as t from "io-ts"
-import { v4 as uuid } from "uuid"
+import type { z } from "zod/mini"
 
-import { FieldType, SlicesTypes } from "../customtypes/widgets"
-
-export const FieldOrSliceType = t.union([
-	t.union([FieldType, SlicesTypes]),
-	t.literal("Repeatable.Link"),
-])
-export type FieldOrSliceType = t.TypeOf<typeof FieldOrSliceType>
+import type { FieldOrSliceType } from "../../model/widget"
 
 interface LegacyContentCtxParams {
 	fieldKey: string
@@ -46,19 +39,15 @@ export class LegacyContentCtx {
 		this.allTypes = allTypes || new Map<string, FieldOrSliceType>()
 		this.allKeys = allKeys || new Map<string, string>()
 
-		const prefixedKey = Array.of(this.fieldPath, [this.fieldKey])
-			.flat()
-			.join(".")
+		const prefixedKey = Array.of(this.fieldPath, [this.fieldKey]).flat().join(".")
 
-		const prefixedContentKey = Array.of(this.contentPath, [this.contentKey])
-			.flat()
-			.join(".")
+		const prefixedContentKey = Array.of(this.contentPath, [this.contentKey]).flat().join(".")
 
 		this.prefixedKey = prefixedKey
 		this.keyOfType = `${prefixedKey}_TYPE`
 		this.keyOfKey = `${prefixedContentKey}_KEY`
 		this.fieldType = this.allTypes.get(this.prefixedKey)
-		this.fieldContentKey = this.allKeys.get(prefixedContentKey) ?? uuid()
+		this.fieldContentKey = this.allKeys.get(prefixedContentKey) ?? crypto.randomUUID()
 	}
 
 	withContentKey(contentKey: string): LegacyContentCtx {
@@ -109,8 +98,19 @@ export function defaultCtx(
 	})
 }
 
-export type WithTypes<T> = {
+type WithTypes<T> = {
 	keys: Record<string, string>
 	types: Record<string, FieldOrSliceType>
 	content: T
 }
+
+export type LegacyCodec<A, LegacyRaw, AllowUndefined extends boolean = false> = {
+	name: string
+	is(input: unknown): input is A
+	toContent(
+		input: unknown,
+	): z.core.util.SafeParseSuccess<A> | z.core.util.SafeParseError<LegacyRaw | unknown>
+	fromContent(
+		value: A,
+	): AllowUndefined extends false ? WithTypes<LegacyRaw> : WithTypes<LegacyRaw> | undefined
+}

package/src/content/codec/link.ts

@@ -0,0 +1,103 @@
+import type {
+	EmptyLinkValueLegacy,
+	FilledLinkValueLegacy,
+	LinkValueLegacy,
+	LinkLegacy,
+} from "../legacy/link"
+import { LinkKind, LinkType, LinkLegacySchema } from "../legacy/link"
+import { LinkContentSchema, LinkContentType } from "../link"
+import type {
+	EmptyLinkValueContent,
+	FilledLinkValueContent,
+	LinkContent,
+	LinkValueContent,
+} from "../link"
+import type { LegacyContentCtx, LegacyCodec } from "./legacyContentCtx"
+
+// Also used by content/codec/richText
+export function linkLegacyToValue(value: FilledLinkValueLegacy): FilledLinkValueContent
+export function linkLegacyToValue(value: EmptyLinkValueLegacy): EmptyLinkValueContent
+export function linkLegacyToValue(value: LinkValueLegacy): LinkValueContent
+export function linkLegacyToValue(
+	value: Omit<LinkLegacy, "text" | "variant" | "key">,
+): Omit<LinkContent["value"], "text" | "variant"> {
+	let content: Omit<LinkContent["value"], "text" | "variant">
+	switch (value.kind) {
+		case LinkKind.Image:
+			content = { __TYPE__: LinkType.Image, ...value }
+			break
+		case LinkKind.File:
+			content = { __TYPE__: LinkType.File, ...value }
+			break
+		case LinkKind.Document:
+			content = { __TYPE__: LinkType.Document, ...value }
+			break
+		case LinkKind.External:
+			content = { __TYPE__: LinkType.External, ...value }
+			break
+		case LinkKind.Media:
+			content = { __TYPE__: LinkType.Media, ...value }
+			break
+		case LinkKind.Any:
+		default:
+			content = { __TYPE__: LinkType.Any, ...value }
+			break
+	}
+
+	return content
+}
+
+// Also used by content/codec/repeatable
+export function linkLegacyToContent({ key, text, variant, ...legacy }: LinkLegacy): LinkContent {
+	return {
+		__TYPE__: LinkContentType,
+		key,
+		value: {
+			...(text ? { text } : {}),
+			...(variant ? { variant } : {}),
+			...linkLegacyToValue(legacy),
+		},
+	}
+}
+
+// Also used by content/codec/richText
+export function linkValueToLegacy(value: FilledLinkValueContent): FilledLinkValueLegacy
+export function linkValueToLegacy(value: EmptyLinkValueContent): EmptyLinkValueLegacy
+export function linkValueToLegacy(value: LinkValueContent): LinkValueLegacy {
+	const { __TYPE__, ...legacy } = value
+	return legacy
+}
+
+function linkContentToLegacy({ key, value }: LinkContent): LinkLegacy {
+	const { __TYPE__, ...legacy } = value
+
+	return { key, ...legacy }
+}
+
+export const LinkLegacyCodec = (ctx: LegacyContentCtx): LegacyCodec<LinkContent, LinkLegacy> => ({
+	name: "LinkLegacy",
+
+	is(input): input is LinkContent {
+		return LinkContentSchema.safeParse(input).success
+	},
+
+	toContent(input) {
+		const parsed = LinkLegacySchema.safeParse(input)
+		if (!parsed.success) {
+			return parsed
+		}
+
+		return {
+			success: true,
+			data: linkLegacyToContent(parsed.data),
+		}
+	},
+
+	fromContent(input) {
+		return {
+			content: linkContentToLegacy(input),
+			types: { [ctx.keyOfType]: "Link" },
+			keys: {},
+		}
+	},
+})

package/src/content/codec/nestable.ts

@@ -0,0 +1,146 @@
+import { z } from "zod/mini"
+
+import { BooleanContentType } from "../boolean"
+import { EmbedContentType } from "../embed"
+import { EmptyContentType } from "../empty"
+import { FieldContentType } from "../field"
+import { GeoPointContentType } from "../geopoint"
+import { ImageContentType } from "../image"
+import { IntegrationFieldContentType } from "../integrationField"
+import type { NestableLegacy } from "../legacy/nestable"
+import { LinkContentType } from "../link"
+import type { NestableContent } from "../nestable"
+import { NestableContentSchema } from "../nestable"
+import { RepeatableContentType } from "../repeatable"
+import { RichTextContentType } from "../richText"
+import { SeparatorContentType } from "../separator"
+import { TableContentType } from "../table"
+import { BooleanLegacyCodec } from "./boolean"
+import { EmbedLegacyCodec } from "./embed"
+import { EmptyLegacyCodec } from "./empty"
+import {
+	ColorLegacyCodec,
+	DateLegacyCodec,
+	NumberLegacyCodec,
+	RangeLegacyCodec,
+	SelectLegacyCodec,
+	TextLegacyCodec,
+	TimestampLegacyCodec,
+} from "./field"
+import { GeoPointLegacyCodec } from "./geopoint"
+import { ImageLegacyCodec } from "./image"
+import { IntegrationFieldLegacyCodec } from "./integrationField"
+import type { LegacyCodec, LegacyContentCtx } from "./legacyContentCtx"
+import { LinkLegacyCodec } from "./link"
+import { RepeatableLegacyCodec } from "./repeatable"
+import { RichTextLegacyCodec } from "./richText"
+import { SeparatorLegacyCodec } from "./separator"
+import { TableLegacyCodec } from "./table"
+
+const UnsupportedNestableLegacySchema = z.never()
+
+export const NestableLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<NestableContent, NestableLegacy, true> => ({
+	name: "NestableLegacy",
+
+	is(input): input is NestableContent {
+		return NestableContentSchema.safeParse(input).success
+	},
+
+	toContent(input) {
+		if (!ctx.fieldType) {
+			return UnsupportedNestableLegacySchema.safeParse(
+				input,
+			) as z.core.util.SafeParseError<NestableLegacy>
+		}
+
+		const empty = EmptyLegacyCodec(ctx).toContent(input)
+		if (empty.success) {
+			return {
+				success: true,
+				data: empty.data,
+			}
+		}
+
+		switch (ctx.fieldType) {
+			case "Text":
+				return TextLegacyCodec(ctx).toContent(input)
+			case "Color":
+				return ColorLegacyCodec(ctx).toContent(input)
+			case "Date":
+				return DateLegacyCodec(ctx).toContent(input)
+			case "Timestamp":
+				return TimestampLegacyCodec(ctx).toContent(input)
+			case "Number":
+				return NumberLegacyCodec(ctx).toContent(input)
+			case "Range":
+				return RangeLegacyCodec(ctx).toContent(input)
+			case "Select":
+				return SelectLegacyCodec(ctx).toContent(input)
+			case "GeoPoint":
+				return GeoPointLegacyCodec(ctx).toContent(input)
+			case "StructuredText":
+				return RichTextLegacyCodec(ctx).toContent(input)
+			case "Boolean":
+				return BooleanLegacyCodec(ctx).toContent(input)
+			case "Embed":
+				return EmbedLegacyCodec(ctx).toContent(input)
+			case "Image":
+				return ImageLegacyCodec(ctx).toContent(input)
+			case "IntegrationFields":
+				return IntegrationFieldLegacyCodec(ctx).toContent(input)
+			case "Link":
+				return LinkLegacyCodec(ctx).toContent(input)
+			case "Separator":
+				return SeparatorLegacyCodec(ctx).toContent(input)
+			case "Table":
+				return TableLegacyCodec(ctx).toContent(input)
+			case "Repeatable.Link":
+				return RepeatableLegacyCodec(ctx, "Link").toContent(input)
+			default:
+				return UnsupportedNestableLegacySchema.safeParse(
+					input,
+				) as z.core.util.SafeParseError<NestableLegacy>
+		}
+	},
+
+	fromContent(input) {
+		switch (input.__TYPE__) {
+			case FieldContentType: {
+				if (input.type === "Text") return TextLegacyCodec(ctx).fromContent(input)
+				if (input.type === "Color") return ColorLegacyCodec(ctx).fromContent(input)
+				if (input.type === "Range") return RangeLegacyCodec(ctx).fromContent(input)
+				if (input.type === "Date") return DateLegacyCodec(ctx).fromContent(input)
+				if (input.type === "Number") return NumberLegacyCodec(ctx).fromContent(input)
+				if (input.type === "Timestamp") return TimestampLegacyCodec(ctx).fromContent(input)
+				if (input.type === "Select") return SelectLegacyCodec(ctx).fromContent(input)
+				return undefined
+			}
+			case GeoPointContentType:
+				return GeoPointLegacyCodec(ctx).fromContent(input)
+			case RichTextContentType:
+				return RichTextLegacyCodec(ctx).fromContent(input)
+			case EmbedContentType:
+				return EmbedLegacyCodec(ctx).fromContent(input)
+			case BooleanContentType:
+				return BooleanLegacyCodec(ctx).fromContent(input)
+			case ImageContentType:
+				return ImageLegacyCodec(ctx).fromContent(input)
+			case IntegrationFieldContentType:
+				return IntegrationFieldLegacyCodec(ctx).fromContent(input)
+			case LinkContentType:
+				return LinkLegacyCodec(ctx).fromContent(input)
+			case SeparatorContentType:
+				return SeparatorLegacyCodec(ctx).fromContent(input)
+			case TableContentType:
+				return TableLegacyCodec(ctx).fromContent(input)
+			case RepeatableContentType:
+				return RepeatableLegacyCodec(ctx, input.type).fromContent(input)
+
+			case EmptyContentType:
+			default:
+				return undefined
+		}
+	},
+})