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

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
+	},
+
+	toContent(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 []
+					}
+				}),
+			},
+		}
+	},
+
+	fromContent(input) {
+		const legacy: ReturnType<LegacyCodec<RepeatableContent, RepeatableLegacy>["fromContent"]> = {
+			content: [],
+			types: { [ctx.keyOfType]: `Repeatable.${fieldType}` },
+			keys: {},
+		}
+
+		for (const item of input.value) {
+			try {
+				switch (fieldType) {
+					case "Link":
+						const result = LinkLegacyCodec(ctx).fromContent(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,117 @@
+import type { RichTextLegacyBlock, RichTextLegacy } from "../legacy/richText"
+import {
+	RichTextLegacyBlockSchema,
+	RichTextLegacySchema,
+	RichTextNodeType,
+} from "../legacy/richText"
+import type { RichTextContentBlock, 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: RichTextLegacyBlock): RichTextContentBlock {
+	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: RichTextContentBlock): RichTextLegacyBlock {
+	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 RichTextLegacyBlockSchema.parse(block)
+}
+
+export const RichTextLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<RichTextContent, RichTextLegacy> => ({
+	name: "RichTextLegacy",
+
+	is(input): input is RichTextContent {
+		return RichTextContentSchema.safeParse(input).success
+	},
+
+	toContent(input) {
+		const parsed = RichTextLegacySchema.safeParse(input)
+		if (!parsed.success) {
+			return parsed
+		}
+
+		return {
+			success: true,
+			data: {
+				value: parsed.data.map((block) => blockLegacyToValue(block)),
+				__TYPE__: RichTextContentType,
+			},
+		}
+	},
+
+	fromContent(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
+	},
+
+	toContent(_input) {
+		return {
+			success: true,
+			data: {
+				__TYPE__: SeparatorContentType,
+			},
+		}
+	},
+
+	fromContent() {
+		return {
+			content: {},
+			types: { [ctx.keyOfType]: "Separator" },
+			keys: {},
+		}
+	},
+})

package/src/content/codec/slice.ts

@@ -0,0 +1,276 @@
+import { CompositeSliceLegacySchema, SharedSliceLegacySchema } from "../legacy/slice"
+import type {
+	CompositeSliceLegacy,
+	SharedSliceLegacy,
+	LegacySliceLegacy,
+	SliceLegacy,
+} from "../legacy/slice"
+import {
+	CompositeSliceContentSchema,
+	CompositeSliceContentType,
+	SharedSliceContentSchema,
+	SharedSliceContentType,
+	LegacySliceContentSchema,
+	SliceContentSchema,
+} from "../slice"
+import type {
+	CompositeSliceContent,
+	SharedSliceContent,
+	LegacySliceContent,
+	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 LegacySliceLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<LegacySliceContent, LegacySliceLegacy, true> => ({
+	name: "LegacySliceLegacy",
+
+	is(input): input is LegacySliceContent {
+		return LegacySliceContentSchema.safeParse(input).success
+	},
+
+	toContent(input) {
+		return NestableAndGroupLegacyCodec(ctx).toContent(input)
+	},
+
+	fromContent(input) {
+		return NestableAndGroupLegacyCodec(ctx).fromContent(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
+	},
+
+	toContent(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).toContent(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).toContent(item)
+			if (!result.success) continue
+
+			repeat.push(result.data)
+		}
+
+		return {
+			success: true,
+			data: {
+				__TYPE__: CompositeSliceContentType,
+				nonRepeat,
+				repeat,
+			},
+		}
+	},
+
+	fromContent(input) {
+		const legacy: ReturnType<
+			LegacyCodec<CompositeSliceContent, CompositeSliceLegacy>["fromContent"]
+		> = {
+			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).fromContent(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).fromContent(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
+	},
+
+	toContent(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).toContent(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).toContent(item)
+			if (!result.success) continue
+
+			items.push(result.data)
+		}
+
+		return {
+			success: true,
+			data: {
+				__TYPE__: SharedSliceContentType,
+				variation: parsed.data.variation,
+				primary,
+				items,
+			},
+		}
+	},
+
+	fromContent(input) {
+		const legacy: ReturnType<LegacyCodec<SharedSliceContent, SharedSliceLegacy>["fromContent"]> = {
+			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).fromContent(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).fromContent(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
+	},
+
+	toContent(input) {
+		switch (ctx.fieldType) {
+			case "Slice":
+				return CompositeSliceLegacyCodec(ctx).toContent(input)
+			case "SharedSlice":
+				return SharedSliceLegacyCodec(ctx).toContent(input)
+			default:
+				return LegacySliceLegacyCodec(ctx).toContent(input)
+		}
+	},
+
+	fromContent(input) {
+		switch (input.__TYPE__) {
+			case CompositeSliceContentType:
+				return CompositeSliceLegacyCodec(ctx).fromContent(input)
+			case SharedSliceContentType:
+				return SharedSliceLegacyCodec(ctx).fromContent(input)
+			default:
+				return LegacySliceLegacyCodec(ctx).fromContent(input)
+		}
+	},
+})

package/src/content/codec/slices.ts

@@ -0,0 +1,130 @@
+import { SliceItemLegacySchema, SlicesLegacySchema } from "../legacy/slices"
+import type { SliceItemLegacy, SlicesLegacy } from "../legacy/slices"
+import { SliceItemContentSchema, SlicesContentSchema, SlicesContentType } from "../slices"
+import type { SliceItemContent, SlicesContent } from "../slices"
+import { type LegacyContentCtx, type LegacyCodec, getFieldCtx } from "./legacyContentCtx"
+import { SliceLegacyCodec } from "./slice"
+
+// Item
+export const SliceItemLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<SliceItemContent, SliceItemLegacy> => ({
+	name: "SlicesItemLegacy",
+
+	is(input): input is SliceItemContent {
+		return SliceItemContentSchema.safeParse(input).success
+	},
+
+	toContent(input) {
+		const parsed = SliceItemLegacySchema.safeParse(input)
+		if (!parsed.success) {
+			return parsed
+		}
+
+		const sliceName = parsed.data.key.split("$")[0]
+		const itemCtx = getFieldCtx({
+			fieldKey: sliceName,
+			contentKey: parsed.data.key,
+			ctx,
+		})
+		const result = SliceLegacyCodec(itemCtx).toContent(parsed.data.value)
+
+		if (!result.success) {
+			return result
+		}
+
+		return {
+			success: true,
+			data: {
+				key: parsed.data.key,
+				name: sliceName,
+				maybeLabel: parsed.data.label || undefined,
+				widget: result.data,
+			},
+		}
+	},
+
+	fromContent(input) {
+		const itemCtx = getFieldCtx({
+			fieldKey: input.name,
+			contentKey: input.key,
+			ctx,
+		})
+		const result = SliceLegacyCodec(itemCtx).fromContent(input.widget)
+
+		if (!result) {
+			return {
+				content: {
+					key: input.key,
+					label: input.maybeLabel,
+					value: {},
+				},
+				types: {},
+				keys: {},
+			}
+		}
+
+		return {
+			content: {
+				key: input.key,
+				label: input.maybeLabel,
+				value: result.content,
+			},
+			types: result.types,
+			keys: result.keys,
+		}
+	},
+})
+
+// Slices
+export const SlicesLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<SlicesContent, SlicesLegacy> => ({
+	name: "SlicesLegacy",
+
+	is(input): input is SlicesContent {
+		return SlicesContentSchema.safeParse(input).success
+	},
+
+	toContent(input) {
+		const parsed = SlicesLegacySchema.safeParse(input)
+		if (!parsed.success) {
+			return parsed
+		}
+
+		const value: SlicesContent["value"] = []
+		for (let index = 0; index < parsed.data.length; index++) {
+			const item = parsed.data[index]
+			const result = SliceItemLegacyCodec(ctx).toContent(item)
+			if (!result.success) {
+				return result
+			}
+			value.push(result.data)
+		}
+
+		return {
+			success: true,
+			data: { __TYPE__: SlicesContentType, value },
+		}
+	},
+
+	fromContent(input) {
+		const legacy: ReturnType<LegacyCodec<SlicesContent, SlicesLegacy>["fromContent"]> = {
+			content: [],
+			types: { [ctx.keyOfType]: "Slices" },
+			keys: {},
+		}
+
+		for (let index = 0; index < input.value.length; index++) {
+			const item = input.value[index]
+			const result = SliceItemLegacyCodec(ctx).fromContent(item)
+			if (!result) continue
+
+			legacy.content.push(result.content)
+			legacy.types = { ...legacy.types, ...result.types }
+			legacy.keys = { ...legacy.keys, ...result.keys }
+		}
+
+		return legacy
+	},
+})

package/src/content/codec/table.ts

@@ -0,0 +1,65 @@
+import { TableLegacySchema } from "../legacy/table"
+import type { TableLegacy } from "../legacy/table"
+import { RichTextContentType } from "../richText"
+import { TableContentSchema, TableContentType } from "../table"
+import type { TableContent } from "../table"
+import type { LegacyContentCtx, LegacyCodec } from "./legacyContentCtx"
+import { blockLegacyToValue, blockValueToLegacy } from "./richText"
+
+export const TableLegacyCodec = (
+	ctx: LegacyContentCtx,
+): LegacyCodec<TableContent, TableLegacy> => ({
+	name: "TableLegacy",
+
+	is(input): input is TableContent {
+		return TableContentSchema.safeParse(input).success
+	},
+
+	toContent(input) {
+		const parsed = TableLegacySchema.safeParse(input)
+		if (!parsed.success) {
+			return parsed
+		}
+
+		return {
+			success: true,
+			data: {
+				__TYPE__: TableContentType,
+				content: parsed.data.content.map((row) => {
+					return {
+						...row,
+						content: row.content.map((cell) => {
+							return {
+								...cell,
+								content: {
+									__TYPE__: RichTextContentType,
+									value: cell.content.map((block) => blockLegacyToValue(block)),
+								},
+							}
+						}),
+					}
+				}),
+			},
+		}
+	},
+
+	fromContent(input) {
+		return {
+			content: {
+				content: input.content.map((row) => {
+					return {
+						...row,
+						content: row.content.map((cell) => {
+							return {
+								...cell,
+								content: cell.content.value.map((block) => blockValueToLegacy(block)),
+							}
+						}),
+					}
+				}),
+			},
+			types: { [ctx.keyOfType]: "Table" },
+			keys: {},
+		}
+	},
+})