@prismicio/types-internal 3.4.0-alpha.8 → 3.5.0

package/src/content/fields/nestable/RichTextContent/Blocks.ts

@@ -0,0 +1,238 @@
+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 {
+	RichTextNodeType,
+	RichTextNodeTypeCodec,
+} from "../../../../customtypes/widgets/nestable"
+import { StringOrNull } from "../../../../validators"
+import { nullable, refineType } from "../../../../validators/function"
+import {
+	EmbedContent,
+	EmbedContentLegacy,
+	EmbedContentType,
+	EmbedLegacy,
+} from "../EmbedContent"
+import { ImageContentView } from "../ImageContent"
+import { FilledLink, FilledLinkLegacy } from "../LinkContent"
+
+const linkSpan = (linkCodec: typeof FilledLink | typeof FilledLinkLegacy) =>
+	t.strict({
+		data: linkCodec,
+		start: t.number,
+		end: t.number,
+		type: t.literal(RichTextNodeType.hyperlink),
+	})
+
+const labelSpan = t.strict({
+	data: withFallback(t.string, ""),
+	start: t.number,
+	end: t.number,
+	type: t.literal("label"),
+})
+
+const basicSpan = t.strict({
+	start: t.number,
+	end: t.number,
+	type: t.keyof({
+		[RichTextNodeType.strong]: null,
+		[RichTextNodeType.em]: null,
+		"list-item": null, // legacy case that should not happen, we shouldn't support this in new page builder or migration API
+	}),
+})
+
+export const Span = t.union([linkSpan(FilledLink), labelSpan, basicSpan])
+export type Span = t.TypeOf<typeof Span>
+
+export const SpanLegacy = t.union([
+	linkSpan(FilledLinkLegacy),
+	labelSpan,
+	basicSpan,
+])
+export type SpanLegacy = t.TypeOf<typeof SpanLegacy>
+
+export const ValidatedSpans = <C extends typeof Span | typeof SpanLegacy>(
+	spanCodec: C,
+) => {
+	type S = t.TypeOf<C>
+
+	return new t.Type<S[], S[], unknown>(
+		"ValidatedSpans",
+		(spans): spans is S[] => Array.isArray(spans) && spans.every(spanCodec.is),
+		(spans: unknown, c) => {
+			if (Array.isArray(spans)) {
+				const res = spans
+					.reduce<Array<S>>((acc, maybeSpan) => {
+						const decodedSpan = spanCodec.decode(maybeSpan)
+						if (isLeft(decodedSpan)) return acc
+						return [...acc, decodedSpan.right]
+					}, [])
+					.sort((m1: S, m2: S) => m1.start - m2.start)
+				return t.success(res)
+			} else return t.failure(spans, c)
+		},
+		(m) => {
+			return m.reduce<Array<S>>((acc, meta) => {
+				const encoded = <S>spanCodec.encode(meta)
+				return [...acc, encoded]
+			}, [])
+		},
+	)
+}
+
+// We allow any codec here and let TypeScript infer the resulting codec.
+// Typing it more precisely creates conflicts.
+//
+// Using `t.Mixed` rather than `t.Type<A, O>` causes `data.linkTo` to be
+// typed as `any`. It seems to be an issue with the `nullable` helper.
+const ImageBlockCodec = <A, O>(linkCodec: t.Type<A, O>) =>
+	t.exact(
+		t.intersection([
+			t.type({
+				type: t.literal(RichTextNodeType.image),
+				data: t.intersection([
+					ImageContentView,
+					t.partial({
+						linkTo: nullable(linkCodec),
+					}),
+				]),
+			}),
+			t.partial({
+				label: StringOrNull,
+				direction: StringOrNull,
+			}),
+		]),
+	)
+
+export const ImageBlock = ImageBlockCodec(FilledLink)
+export type ImageBlock = t.TypeOf<typeof ImageBlock>
+
+const ImageBlockLegacy = ImageBlockCodec(FilledLinkLegacy)
+type ImageBlockLegacy = t.TypeOf<typeof ImageBlockLegacy>
+
+export function checkImageBlock(block: Block): block is ImageBlock {
+	return block.type === RichTextNodeType.image
+}
+
+const embedBlockLegacyCodec = t.exact(
+	t.intersection([
+		t.type({
+			type: t.literal(RichTextNodeType.embed),
+			data: t.unknown,
+		}),
+		t.partial({
+			label: StringOrNull,
+			direction: StringOrNull,
+		}),
+	]),
+)
+
+type EmbedBlockLegacy = t.TypeOf<typeof embedBlockLegacyCodec>
+
+const EmbedBlockLegacy = new t.Type<EmbedBlock, EmbedBlockLegacy, unknown>(
+	"EmbedBlockLegacy",
+	(u): u is EmbedBlock => (u as EmbedBlock).type === "embed",
+	(block) =>
+		pipe(
+			embedBlockLegacyCodec.decode(block),
+			either.chain((decodedBlock) => {
+				return either.map<EmbedLegacy, [EmbedBlockLegacy, EmbedLegacy]>(
+					(decodedData: EmbedLegacy) => {
+						return [decodedBlock, decodedData]
+					},
+				)(EmbedContentLegacy.decode(decodedBlock.data))
+			}),
+			either.map(([block, parsedData]) => {
+				return EmbedBlock.encode({
+					...block,
+					data: {
+						...parsedData,
+						__TYPE__: EmbedContentType,
+						all: block.data,
+					},
+				})
+			}),
+		),
+	(embedBlock: EmbedBlock): EmbedBlockLegacy => {
+		return {
+			...embedBlockLegacyCodec.encode(embedBlock),
+			data: EmbedContentLegacy.encode(embedBlock.data),
+		}
+	},
+)
+export const EmbedBlock = t.exact(
+	t.intersection([
+		t.type({
+			type: t.literal(RichTextNodeType.embed),
+			data: EmbedContent,
+		}),
+		t.partial({
+			label: StringOrNull,
+			direction: StringOrNull,
+		}),
+	]),
+)
+export type EmbedBlock = t.TypeOf<typeof EmbedBlock>
+export function checkEmbedBlock(block: Block): block is EmbedBlock {
+	return block.type === RichTextNodeType.embed
+}
+
+const TextBlockCodec = <C extends typeof Span | typeof SpanLegacy>(
+	spanCodec: C,
+) =>
+	t.exact(
+		t.intersection([
+			t.type({
+				type: refineType(
+					RichTextNodeTypeCodec,
+					`string which isn't ${RichTextNodeType.image} ${RichTextNodeType.embed}`,
+					(s) => s !== RichTextNodeType.image && s !== RichTextNodeType.embed,
+				),
+				content: t.intersection([
+					t.type({
+						text: t.string,
+					}),
+					t.partial({
+						spans: ValidatedSpans(spanCodec),
+					}),
+				]),
+			}),
+			t.partial({
+				label: t.string,
+				direction: t.string,
+			}),
+		]),
+	)
+
+/* These Text block will decode codec A and encode from codec B to A */
+export const TextBlock = TextBlockCodec(Span)
+export type TextBlock = t.TypeOf<typeof TextBlock>
+
+export const TextBlockLegacy = TextBlockCodec(SpanLegacy)
+export type TextBlockLegacy = t.TypeOf<typeof TextBlockLegacy>
+
+const legacyBlockCodec = t.union([
+	EmbedBlockLegacy,
+	ImageBlockLegacy,
+	TextBlockLegacy,
+])
+type BlockLegacy = t.TypeOf<typeof legacyBlockCodec>
+
+export const BlockLegacy = new t.Type<Block, BlockLegacy, unknown>(
+	"BlockLegacy",
+	(u): u is Block =>
+		EmbedBlockLegacy.is(u) || ImageBlockLegacy.is(u) || TextBlockLegacy.is(u),
+	(legacyBlock) => legacyBlockCodec.decode(legacyBlock),
+	(block: Block) => {
+		return (() => {
+			if (ImageBlock.is(block)) return ImageBlockLegacy.encode(block)
+			else if (EmbedBlock.is(block)) return EmbedBlockLegacy.encode(block)
+			else return TextBlockLegacy.encode(block)
+		})() as BlockLegacy
+	},
+)
+export const Block = t.union([ImageBlock, EmbedBlock, TextBlock])
+export type Block = t.TypeOf<typeof Block>

package/src/content/fields/nestable/RichTextContent/index.ts

@@ -4,7 +4,7 @@ import * as t from "io-ts"
 
 import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx"
 import { hasContentType } from "../../../utils"
-import { Block, BlockLegacy } from "./Block"
+import { Block, BlockLegacy } from "./Blocks"
 
 export const RichTextContentType = "StructuredTextContent"
 export const isRichTextContent = (u: unknown): u is RichTextContent =>
@@ -19,6 +19,8 @@ export const RichTextContent = t.strict({
 })
 export type RichTextContent = t.TypeOf<typeof RichTextContent>
 
+export * from "./Blocks"
+
 export const RichTextLegacy = (ctx: LegacyContentCtx) =>
 	new t.Type<RichTextContent, WithTypes<RichTextLegacy>, unknown>(
 		"RichTextLegacy",
@@ -37,9 +39,3 @@ export const RichTextLegacy = (ctx: LegacyContentCtx) =>
 			}
 		},
 	)
-
-export * from "./Block"
-export * from "./EmbedBlock"
-export * from "./ImageBlock"
-export * from "./TableBlock"
-export * from "./TextBlock"

package/src/content/fields/nestable/TableContent.ts

@@ -2,16 +2,38 @@ import { either } from "fp-ts"
 import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
+import type {
+	ContentPath,
+	TraverseWidgetContentFn,
+} from "../../../_internal/utils"
+import { type NestableWidget, TableCell } from "../../../customtypes"
 import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx"
 import { hasContentType } from "../../utils"
-import { TextBlock } from "./RichTextContent/TextBlock"
+import {
+	RichTextContentType,
+	TextBlock,
+	TextBlockLegacy,
+} from "./RichTextContent"
 
 export const TableContentType = "TableContent"
 
 export const isTableContent = (u: unknown): u is TableContent =>
 	hasContentType(u) && u.__TYPE__ === TableContentType
 
-const TableCellContent = t.array(TextBlock)
+const TableCellLegacy = t.array(TextBlockLegacy)
+type TableCellLegacy = t.TypeOf<typeof TableCellLegacy>
+
+export const TableCellContent = t.strict({
+	__TYPE__: t.literal(RichTextContentType),
+	value: t.array(TextBlock),
+})
+export type TableCellContent = t.TypeOf<typeof TableCellContent>
+
+const TableDataCellLegacy = t.strict({
+	type: t.literal("tableCell"),
+	content: TableCellLegacy,
+})
+type TableDataCellLegacy = t.TypeOf<typeof TableDataCellLegacy>
 
 export const TableDataCell = t.strict({
 	type: t.literal("tableCell"),
@@ -25,17 +47,28 @@ export const TableHeaderCell = t.strict({
 })
 export type TableHeaderCell = t.TypeOf<typeof TableHeaderCell>
 
+const TableHeaderCellLegacy = t.strict({
+	type: t.literal("tableHeader"),
+	content: TableCellLegacy,
+})
+type TableHeaderCellLegacy = t.TypeOf<typeof TableHeaderCellLegacy>
+
 export const TableRow = t.strict({
 	type: t.literal("tableRow"),
 	content: t.array(t.union([TableHeaderCell, TableDataCell])),
 })
 export type TableRow = t.TypeOf<typeof TableRow>
 
-export const tableContentLegacyCodec = t.strict({
-	content: t.array(TableRow),
+const TableRowLegacy = t.strict({
+	type: t.literal("tableRow"),
+	content: t.array(t.union([TableHeaderCellLegacy, TableDataCellLegacy])),
 })
+type TableRowLegacy = t.TypeOf<typeof TableRowLegacy>
 
-export type TableLegacy = t.TypeOf<typeof tableContentLegacyCodec>
+const legacyReader = t.strict({
+	content: t.array(TableRowLegacy),
+})
+type TableLegacy = t.TypeOf<typeof legacyReader>
 
 export const TableLegacy = (ctx: LegacyContentCtx) =>
 	new t.Type<TableContent, WithTypes<TableLegacy>, unknown>(
@@ -43,25 +76,109 @@ export const TableLegacy = (ctx: LegacyContentCtx) =>
 		isTableContent,
 		(u) => {
 			return pipe(
-				tableContentLegacyCodec.decode(u),
+				legacyReader.decode(u),
 				either.map((t) =>
-					TableContent.encode({ ...t, __TYPE__: TableContentType }),
+					TableContent.encode({
+						content: t.content.map((row) => {
+							return {
+								...row,
+								content: row.content.map((cell) => {
+									return {
+										...cell,
+										content: {
+											__TYPE__: RichTextContentType,
+											value: cell.content,
+										},
+									}
+								}),
+							}
+						}),
+						__TYPE__: TableContentType,
+					}),
 				),
 			)
 		},
 
 		(t: TableContent) => {
 			return {
-				content: tableContentLegacyCodec.encode(t),
+				content: legacyReader.encode({
+					content: t.content.map((row) => {
+						return {
+							...row,
+							content: row.content.map((cell) => {
+								return {
+									...cell,
+									content: cell.content.value,
+								}
+							}),
+						}
+					}),
+				}),
 				types: { [ctx.keyOfType]: "Table" },
 			}
 		},
 	)
 
-export const TableContent = t.intersection([
-	tableContentLegacyCodec,
-	t.strict({
-		__TYPE__: t.literal(TableContentType),
-	}),
-])
+export const TableContent = t.strict({
+	__TYPE__: t.literal(TableContentType),
+	content: t.array(TableRow),
+})
 export type TableContent = t.TypeOf<typeof TableContent>
+
+export function traverseTableContent({
+	path,
+	key,
+	apiId,
+	model,
+	content,
+}: {
+	path: ContentPath
+	key: string
+	apiId: string
+	content: TableContent
+	model?: NestableWidget | undefined
+}) {
+	return (transform: TraverseWidgetContentFn): TableContent | undefined => {
+		const tableContent = content.content.map((row, rowIndex) => ({
+			...row,
+			content: row.content.map((cell, cellIndex) => {
+				const itemPath = path.concat([
+					{
+						key: [rowIndex.toString(), cellIndex.toString()].join(","),
+						type: "Widget",
+					},
+				])
+
+				const cellContent = transform({
+					path: itemPath,
+					key,
+					apiId,
+					model: TableCell, // Table cell content config is fixed.
+					content: {
+						__TYPE__: cell.content.__TYPE__,
+						value: cell.content.value,
+					},
+				}) || {
+					__TYPE__: RichTextContentType,
+					value: [],
+				} // Return an empty table cell if the transform function filters out rich text (returns undefined)
+
+				return {
+					...cell,
+					content: cellContent,
+				}
+			}),
+		}))
+
+		return transform({
+			path,
+			key,
+			apiId,
+			model,
+			content: {
+				__TYPE__: content.__TYPE__,
+				content: tableContent,
+			},
+		})
+	}
+}

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

@@ -28,7 +28,9 @@ import {
 import {
 	isNestableContent,
 	isRepeatableContent,
+	isTableContent,
 	traverseRepeatableContent,
+	traverseTableContent,
 } from "../../nestable"
 import {
 	repeatableContentWithDefaultNestableContentValues,
@@ -230,6 +232,17 @@ export function traverseSharedSliceContent({
 						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([

package/src/customtypes/widgets/nestable/NestableWidget.ts

@@ -13,6 +13,7 @@ import { Range } from "./Range"
 import { RichText } from "./RichText"
 import { Select } from "./Select"
 import { Separator } from "./Separator"
+import { Table } from "./Table"
 import { Text } from "./Text"
 import { Timestamp } from "./Timestamp"
 
@@ -27,6 +28,7 @@ export const NestableWidget = t.union([
 	RichText,
 	Select,
 	Separator,
+	Table,
 	Text,
 	Timestamp,
 	Link,

package/src/customtypes/widgets/nestable/RichText.ts

@@ -29,7 +29,6 @@ export const RichTextNodeType = {
 	list: "list-item",
 	orderedList: "o-list-item",
 	rtl: "rtl",
-	table: "table",
 } as const
 
 export const RichTextNodeTypeCodec = t.keyof({
@@ -49,7 +48,6 @@ export const RichTextNodeTypeCodec = t.keyof({
 	[RichTextNodeType.list]: null,
 	[RichTextNodeType.orderedList]: null,
 	[RichTextNodeType.rtl]: null,
-	[RichTextNodeType.table]: null,
 })
 
 const RichTextOptions = new t.Type<string, string, unknown>(

package/src/customtypes/widgets/nestable/Table.ts

@@ -1,6 +1,7 @@
 import * as t from "io-ts"
 
 import { StringOrNull } from "../../../validators"
+import { RichTextNodeType } from "./RichText"
 
 export const TableFieldType = "Table"
 
@@ -23,3 +24,15 @@ export const Table = t.exact(
 	]),
 )
 export type Table = t.TypeOf<typeof Table>
+
+export const TableCell = {
+	type: "StructuredText" as const,
+	config: {
+		multi: [
+			RichTextNodeType.paragraph,
+			RichTextNodeType.strong,
+			RichTextNodeType.em,
+			RichTextNodeType.hyperlink,
+		].join(","),
+	},
+}