@prismicio/types-internal 3.4.0-alpha.2 → 3.4.0-alpha.4

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

@@ -0,0 +1,108 @@
+import { isLeft } from "fp-ts/lib/Either"
+import * as t from "io-ts"
+import { withFallback } from "io-ts-types"
+
+import {
+	RichTextNodeType,
+	RichTextNodeTypeCodec,
+} from "../../../../customtypes/widgets/nestable"
+import { refineType } from "../../../../validators/function"
+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 = spanCodec.encode(meta) as S
+				return [...acc, encoded]
+			}, [])
+		},
+	)
+}
+
+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>

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 "./Blocks"
+import { Block, BlockLegacy } from "./Block"
 
 export const RichTextContentType = "StructuredTextContent"
 export const isRichTextContent = (u: unknown): u is RichTextContent =>
@@ -19,7 +19,7 @@ export const RichTextContent = t.strict({
 })
 export type RichTextContent = t.TypeOf<typeof RichTextContent>
 
-export * from "./Blocks"
+export * from "./Block"
 
 export const RichTextLegacy = (ctx: LegacyContentCtx) =>
 	new t.Type<RichTextContent, WithTypes<RichTextLegacy>, unknown>(

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

@@ -4,7 +4,7 @@ import * as t from "io-ts"
 
 import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx"
 import { hasContentType } from "../../utils"
-import { TextBlock } from "./RichTextContent"
+import { TextBlock } from "./RichTextContent/TextBlock"
 
 export const TableContentType = "TableContent"
 
@@ -30,11 +30,11 @@ export const TableRow = t.strict({
 	content: t.array(t.union([TableHeaderCell, TableDataCell])),
 })
 
-const legacyReader = t.strict({
+export const tableContentLegacyCodec = t.strict({
 	content: t.array(TableRow),
 })
 
-type TableLegacy = t.TypeOf<typeof legacyReader>
+export type TableLegacy = t.TypeOf<typeof tableContentLegacyCodec>
 
 export const TableLegacy = (ctx: LegacyContentCtx) =>
 	new t.Type<TableContent, WithTypes<TableLegacy>, unknown>(
@@ -42,7 +42,7 @@ export const TableLegacy = (ctx: LegacyContentCtx) =>
 		isTableContent,
 		(u) => {
 			return pipe(
-				legacyReader.decode(u),
+				tableContentLegacyCodec.decode(u),
 				either.map((t) =>
 					TableContent.encode({ ...t, __TYPE__: TableContentType }),
 				),
@@ -51,14 +51,14 @@ export const TableLegacy = (ctx: LegacyContentCtx) =>
 
 		(t: TableContent) => {
 			return {
-				content: legacyReader.encode(t),
+				content: tableContentLegacyCodec.encode(t),
 				types: { [ctx.keyOfType]: "Table" },
 			}
 		},
 	)
 
 export const TableContent = t.intersection([
-	legacyReader,
+	tableContentLegacyCodec,
 	t.strict({
 		__TYPE__: t.literal(TableContentType),
 	}),

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

@@ -13,7 +13,6 @@ 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"
 
@@ -28,7 +27,6 @@ export const NestableWidget = t.union([
 	RichText,
 	Select,
 	Separator,
-	Table,
 	Text,
 	Timestamp,
 	Link,

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

@@ -29,6 +29,7 @@ export const RichTextNodeType = {
 	list: "list-item",
 	orderedList: "o-list-item",
 	rtl: "rtl",
+	table: "table",
 } as const
 
 export const RichTextNodeTypeCodec = t.keyof({
@@ -48,6 +49,7 @@ 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/content/fields/nestable/RichTextContent/Blocks.ts

@@ -1,238 +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 {
-	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>
-
-const TextBlockLegacy = TextBlockCodec(SpanLegacy)
-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>