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

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
+	},
+
+	decode(input) {
+		if (!ctx.fieldType) {
+			return UnsupportedNestableLegacySchema.safeParse(
+				input,
+			) as z.core.util.SafeParseError<NestableLegacy>
+		}
+
+		const empty = EmptyLegacyCodec(ctx).decode(input)
+		if (empty.success) {
+			return {
+				success: true,
+				data: empty.data,
+			}
+		}
+
+		switch (ctx.fieldType) {
+			case "Text":
+				return TextLegacyCodec(ctx).decode(input)
+			case "Color":
+				return ColorLegacyCodec(ctx).decode(input)
+			case "Date":
+				return DateLegacyCodec(ctx).decode(input)
+			case "Timestamp":
+				return TimestampLegacyCodec(ctx).decode(input)
+			case "Number":
+				return NumberLegacyCodec(ctx).decode(input)
+			case "Range":
+				return RangeLegacyCodec(ctx).decode(input)
+			case "Select":
+				return SelectLegacyCodec(ctx).decode(input)
+			case "GeoPoint":
+				return GeoPointLegacyCodec(ctx).decode(input)
+			case "StructuredText":
+				return RichTextLegacyCodec(ctx).decode(input)
+			case "Boolean":
+				return BooleanLegacyCodec(ctx).decode(input)
+			case "Embed":
+				return EmbedLegacyCodec(ctx).decode(input)
+			case "Image":
+				return ImageLegacyCodec(ctx).decode(input)
+			case "IntegrationFields":
+				return IntegrationFieldLegacyCodec(ctx).decode(input)
+			case "Link":
+				return LinkLegacyCodec(ctx).decode(input)
+			case "Separator":
+				return SeparatorLegacyCodec(ctx).decode(input)
+			case "Table":
+				return TableLegacyCodec(ctx).decode(input)
+			case "Repeatable.Link":
+				return RepeatableLegacyCodec(ctx, "Link").decode(input)
+			default:
+				return UnsupportedNestableLegacySchema.safeParse(
+					input,
+				) as z.core.util.SafeParseError<NestableLegacy>
+		}
+	},
+
+	encode(input) {
+		switch (input.__TYPE__) {
+			case FieldContentType: {
+				if (input.type === "Text") return TextLegacyCodec(ctx).encode(input)
+				if (input.type === "Color") return ColorLegacyCodec(ctx).encode(input)
+				if (input.type === "Range") return RangeLegacyCodec(ctx).encode(input)
+				if (input.type === "Date") return DateLegacyCodec(ctx).encode(input)
+				if (input.type === "Number") return NumberLegacyCodec(ctx).encode(input)
+				if (input.type === "Timestamp") return TimestampLegacyCodec(ctx).encode(input)
+				if (input.type === "Select") return SelectLegacyCodec(ctx).encode(input)
+				return undefined
+			}
+			case GeoPointContentType:
+				return GeoPointLegacyCodec(ctx).encode(input)
+			case RichTextContentType:
+				return RichTextLegacyCodec(ctx).encode(input)
+			case EmbedContentType:
+				return EmbedLegacyCodec(ctx).encode(input)
+			case BooleanContentType:
+				return BooleanLegacyCodec(ctx).encode(input)
+			case ImageContentType:
+				return ImageLegacyCodec(ctx).encode(input)
+			case IntegrationFieldContentType:
+				return IntegrationFieldLegacyCodec(ctx).encode(input)
+			case LinkContentType:
+				return LinkLegacyCodec(ctx).encode(input)
+			case SeparatorContentType:
+				return SeparatorLegacyCodec(ctx).encode(input)
+			case TableContentType:
+				return TableLegacyCodec(ctx).encode(input)
+			case RepeatableContentType:
+				return RepeatableLegacyCodec(ctx, input.type).encode(input)
+
+			case EmptyContentType:
+			default:
+				return undefined
+		}
+	},
+})

package/src/content/codec/repeatable.ts

@@ -0,0 +1,68 @@
+import { LinkLegacySchema } from "../legacy/link"
+import { RepeatableLegacySchema } from "../legacy/repeatable"
+import type { RepeatableLegacy } from "../legacy/repeatable"
+import { RepeatableContentSchema, RepeatableContentType } from "../repeatable"
+import type { RepeatableContent } from "../repeatable"
+import type { LegacyCodec, LegacyContentCtx } from "./legacyContentCtx"
+import { LinkLegacyCodec, linkLegacyToContent } from "./link"
+
+export const RepeatableLegacyCodec = (
+	ctx: LegacyContentCtx,
+	fieldType: "Link",
+): LegacyCodec<RepeatableContent, RepeatableLegacy> => ({
+	name: "RepeatableLegacy",
+
+	is(input): input is RepeatableContent {
+		return RepeatableContentSchema.safeParse(input).success
+	},
+
+	decode(input) {
+		const parsed = RepeatableLegacySchema.safeParse(input)
+		if (!parsed.success) {
+			return parsed
+		}
+
+		return {
+			success: true,
+			data: {
+				__TYPE__: RepeatableContentType,
+				type: fieldType,
+				value: parsed.data.flatMap((item) => {
+					try {
+						switch (fieldType) {
+							case "Link":
+								return [linkLegacyToContent(LinkLegacySchema.parse(item))]
+							default:
+								return []
+						}
+					} catch {
+						return []
+					}
+				}),
+			},
+		}
+	},
+
+	encode(input) {
+		const legacy: ReturnType<LegacyCodec<RepeatableContent, RepeatableLegacy>["encode"]> = {
+			content: [],
+			types: { [ctx.keyOfType]: `Repeatable.${fieldType}` },
+			keys: {},
+		}
+
+		for (const item of input.value) {
+			try {
+				switch (fieldType) {
+					case "Link":
+						const result = LinkLegacyCodec(ctx).encode(item)
+						legacy.content.push(result.content)
+						legacy.keys = { ...legacy.keys, ...result.keys }
+						break
+				}
+			} catch {
+				// noop, continue
+			}
+		}
+		return legacy
+	},
+})

package/src/content/codec/richText.ts

@@ -0,0 +1,113 @@
+import type { BlockLegacy, RichTextLegacy } from "../legacy/richText"
+import { BlockLegacySchema, RichTextLegacySchema, RichTextNodeType } from "../legacy/richText"
+import type { BlockValue, RichTextContent } from "../richText"
+import { RichTextContentSchema, RichTextContentType } from "../richText"
+import { embedLegacyToContent, embedContentToLegacy } from "./embed"
+import { imageLegacyToContent } from "./image"
+import type { LegacyCodec, LegacyContentCtx } from "./legacyContentCtx"
+import { linkLegacyToValue, linkValueToLegacy } from "./link"
+
+// Also used by content/codec/table
+export function blockLegacyToValue(block: BlockLegacy): BlockValue {
+	if (block.type === RichTextNodeType.embed) {
+		return {
+			...block,
+			data: embedLegacyToContent(block.data),
+		}
+	}
+
+	if (block.type === RichTextNodeType.image) {
+		return {
+			...block,
+			data: {
+				...imageLegacyToContent(block.data),
+				...(block.data.linkTo ? { linkTo: linkLegacyToValue(block.data.linkTo) } : {}),
+			},
+		}
+	}
+
+	return {
+		...block,
+		content: {
+			...block.content,
+			spans: block.content.spans?.map((span) => {
+				if (span.type === RichTextNodeType.hyperlink) {
+					return { ...span, data: linkLegacyToValue(span.data) }
+				}
+
+				return span
+			}),
+		},
+	}
+}
+
+// Also used by content/codec/table
+export function blockValueToLegacy(block: BlockValue): BlockLegacy {
+	if (block.type === RichTextNodeType.embed) {
+		return {
+			...block,
+			data: embedContentToLegacy(block.data),
+		}
+	}
+
+	if (block.type === RichTextNodeType.image) {
+		return {
+			...block,
+			data: {
+				...block.data,
+				...(block.data.linkTo ? { linkTo: linkValueToLegacy(block.data.linkTo) } : {}),
+			},
+		}
+	}
+
+	if ("content" in block) {
+		return {
+			...block,
+			content: {
+				...block.content,
+				spans: block.content.spans?.map((span) => {
+					if (span.type === RichTextNodeType.hyperlink) {
+						return { ...span, data: linkValueToLegacy(span.data) }
+					}
+
+					return span
+				}),
+			},
+		}
+	}
+
+	return BlockLegacySchema.parse(block)
+}
+
+export const RichTextLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<RichTextContent, RichTextLegacy> => ({
+	name: "RichTextLegacy",
+
+	is(input): input is RichTextContent {
+		return RichTextContentSchema.safeParse(input).success
+	},
+
+	decode(input) {
+		const parsed = RichTextLegacySchema.safeParse(input)
+		if (!parsed.success) {
+			return parsed
+		}
+
+		return {
+			success: true,
+			data: {
+				value: parsed.data.map((block) => blockLegacyToValue(block)),
+				__TYPE__: RichTextContentType,
+			},
+		}
+	},
+
+	encode(input) {
+		return {
+			content: input.value.map((block) => blockValueToLegacy(block)),
+			types: { [ctx.keyOfType]: "StructuredText" },
+			keys: {},
+		}
+	},
+})

package/src/content/codec/separator.ts

@@ -0,0 +1,33 @@
+import type { SeparatorLegacy } from "../legacy/separator"
+import { SeparatorContentSchema } from "../separator"
+import type { SeparatorContent } from "../separator"
+import type { LegacyContentCtx, LegacyCodec } from "./legacyContentCtx"
+
+const SeparatorContentType = "SeparatorContent"
+
+export const SeparatorLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<SeparatorContent, SeparatorLegacy> => ({
+	name: "SeparatorLegacy",
+
+	is(input): input is SeparatorContent {
+		return SeparatorContentSchema.safeParse(input).success
+	},
+
+	decode(_input) {
+		return {
+			success: true,
+			data: {
+				__TYPE__: SeparatorContentType,
+			},
+		}
+	},
+
+	encode() {
+		return {
+			content: {},
+			types: { [ctx.keyOfType]: "Separator" },
+			keys: {},
+		}
+	},
+})

package/src/content/codec/slice.ts

@@ -0,0 +1,274 @@
+import { CompositeSliceLegacySchema, SharedSliceLegacySchema } from "../legacy/slice"
+import type {
+	CompositeSliceLegacy,
+	SharedSliceLegacy,
+	SimpleSliceLegacy,
+	SliceLegacy,
+} from "../legacy/slice"
+import {
+	CompositeSliceContentSchema,
+	CompositeSliceContentType,
+	SharedSliceContentSchema,
+	SharedSliceContentType,
+	SimpleSliceContentSchema,
+	SliceContentSchema,
+} from "../slice"
+import type {
+	CompositeSliceContent,
+	SharedSliceContent,
+	SimpleSliceContent,
+	SliceContent,
+} from "../slice"
+import { GroupItemLegacyCodec, NestableAndGroupLegacyCodec } from "./group"
+import { getFieldCtx, type LegacyCodec, type LegacyContentCtx } from "./legacyContentCtx"
+import { NestableLegacyCodec } from "./nestable"
+
+// Simple (before 2020)
+export const SimpleSliceLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<SimpleSliceContent, SimpleSliceLegacy, true> => ({
+	name: "SimpleSliceLegacy",
+
+	is(input): input is SimpleSliceContent {
+		return SimpleSliceContentSchema.safeParse(input).success
+	},
+
+	decode(input) {
+		return NestableAndGroupLegacyCodec(ctx).decode(input)
+	},
+
+	encode(input) {
+		return NestableAndGroupLegacyCodec(ctx).encode(input)
+	},
+})
+
+// Composite (2020 to 2021)
+export const CompositeSliceLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<CompositeSliceContent, CompositeSliceLegacy> => ({
+	name: "CompositeSliceLegacy",
+
+	is(input): input is CompositeSliceContent {
+		return CompositeSliceContentSchema.safeParse(input).success
+	},
+
+	decode(input) {
+		const parsed = CompositeSliceLegacySchema.safeParse(input)
+		if (!parsed.success) {
+			return parsed
+		}
+
+		const nonRepeat: CompositeSliceContent["nonRepeat"] = {}
+		for (const [key, legacy] of Object.entries(parsed.data["non-repeat"] || {})) {
+			const fieldCtx = getFieldCtx({
+				fieldKey: key,
+				ctx,
+				prefixes: ["non-repeat"],
+			})
+
+			const result = NestableLegacyCodec(fieldCtx).decode(legacy)
+			if (!result.success) continue
+
+			nonRepeat[key] = result.data
+		}
+
+		const repeat: CompositeSliceContent["repeat"] = []
+		for (let index = 0; index < (parsed.data.repeat?.length || 0); index++) {
+			const item = parsed.data.repeat?.[index]
+			const itemCtx = getFieldCtx({ fieldKey: "repeat", ctx })
+
+			const result = GroupItemLegacyCodec(itemCtx, index).decode(item)
+			if (!result.success) continue
+
+			repeat.push(result.data)
+		}
+
+		return {
+			success: true,
+			data: {
+				__TYPE__: CompositeSliceContentType,
+				nonRepeat,
+				repeat,
+			},
+		}
+	},
+
+	encode(input) {
+		const legacy: ReturnType<LegacyCodec<CompositeSliceContent, CompositeSliceLegacy>["encode"]> = {
+			content: {
+				"non-repeat": {},
+				repeat: [],
+			},
+			types: {
+				[ctx.keyOfType]: "Slice",
+			},
+			keys: {},
+		}
+
+		// Non-repeat
+		for (const [key, content] of Object.entries(input.nonRepeat)) {
+			const fieldCtx = getFieldCtx({
+				fieldKey: key,
+				ctx,
+				prefixes: ["non-repeat"],
+			})
+
+			const result = NestableLegacyCodec(fieldCtx).encode(content)
+			if (!result) continue
+
+			legacy.content["non-repeat"]![key] = result.content
+			legacy.types = { ...legacy.types, ...result.types }
+			legacy.keys = { ...legacy.keys, ...result.keys }
+		}
+
+		// Repeat
+		const repeatCtx = getFieldCtx({ fieldKey: "repeat", ctx })
+		for (let index = 0; index < input.repeat.length; index++) {
+			const item = input.repeat[index]
+			const result = GroupItemLegacyCodec(repeatCtx, index).encode(item)
+
+			legacy.content.repeat!.push(result.content)
+			legacy.types = { ...legacy.types, ...result.types }
+			legacy.keys = { ...legacy.keys, ...result.keys }
+		}
+
+		return legacy
+	},
+})
+
+// Shared (2021 to present)
+export const SharedSliceLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<SharedSliceContent, SharedSliceLegacy> => ({
+	name: "SharedSliceLegacy",
+
+	is(input): input is SharedSliceContent {
+		return SharedSliceContentSchema.safeParse(input).success
+	},
+
+	decode(input) {
+		const parsed = SharedSliceLegacySchema.safeParse(input)
+		if (!parsed.success) {
+			return parsed
+		}
+
+		const primary: SharedSliceContent["primary"] = {}
+		for (const [key, legacy] of Object.entries(parsed.data["primary"])) {
+			const fieldCtx = getFieldCtx({
+				fieldKey: key,
+				ctx,
+				prefixes: ["variations", parsed.data.variation, "primary"],
+			})
+
+			const result = NestableAndGroupLegacyCodec(fieldCtx).decode(legacy)
+			if (!result.success) continue
+
+			primary[key] = result.data
+		}
+
+		const items: SharedSliceContent["items"] = []
+		for (let index = 0; index < parsed.data.items.length; index++) {
+			const item = parsed.data.items[index]
+			const itemCtx = getFieldCtx({
+				fieldKey: "items",
+				ctx,
+				prefixes: ["variations", parsed.data.variation],
+			})
+
+			const result = GroupItemLegacyCodec(itemCtx, index).decode(item)
+			if (!result.success) continue
+
+			items.push(result.data)
+		}
+
+		return {
+			success: true,
+			data: {
+				__TYPE__: SharedSliceContentType,
+				variation: parsed.data.variation,
+				primary,
+				items,
+			},
+		}
+	},
+
+	encode(input) {
+		const legacy: ReturnType<LegacyCodec<SharedSliceContent, SharedSliceLegacy>["encode"]> = {
+			content: {
+				primary: {},
+				items: [],
+				variation: input.variation,
+			},
+			types: {
+				[ctx.keyOfType]: "SharedSlice",
+			},
+			keys: {},
+		}
+
+		// Primary
+		for (const [key, content] of Object.entries(input.primary)) {
+			const fieldCtx = getFieldCtx({
+				fieldKey: key,
+				ctx,
+				prefixes: ["variations", input.variation, "primary"],
+			})
+
+			const result = NestableAndGroupLegacyCodec(fieldCtx).encode(content)
+			if (!result) continue
+
+			legacy.content.primary[key] = result.content
+			legacy.types = { ...legacy.types, ...result.types }
+			legacy.keys = { ...legacy.keys, ...result.keys }
+		}
+
+		// Items
+		const repeatCtx = getFieldCtx({
+			fieldKey: "items",
+			ctx,
+			prefixes: ["variations", input.variation],
+		})
+		for (let index = 0; index < input.items.length; index++) {
+			const item = input.items[index]
+			const result = GroupItemLegacyCodec(repeatCtx, index).encode(item)
+
+			legacy.content.items.push(result.content)
+			legacy.types = { ...legacy.types, ...result.types }
+			legacy.keys = { ...legacy.keys, ...result.keys }
+		}
+
+		return legacy
+	},
+})
+
+// All
+export const SliceLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<SliceContent, SliceLegacy, true> => ({
+	name: "SliceLegacy",
+
+	is(input): input is SliceContent {
+		return SliceContentSchema.safeParse(input).success
+	},
+
+	decode(input) {
+		switch (ctx.fieldType) {
+			case "Slice":
+				return CompositeSliceLegacyCodec(ctx).decode(input)
+			case "SharedSlice":
+				return SharedSliceLegacyCodec(ctx).decode(input)
+			default:
+				return SimpleSliceLegacyCodec(ctx).decode(input)
+		}
+	},
+
+	encode(input) {
+		switch (input.__TYPE__) {
+			case CompositeSliceContentType:
+				return CompositeSliceLegacyCodec(ctx).encode(input)
+			case SharedSliceContentType:
+				return SharedSliceLegacyCodec(ctx).encode(input)
+			default:
+				return SimpleSliceLegacyCodec(ctx).encode(input)
+		}
+	},
+})