@prismicio/types-internal 3.4.0-alpha.13 → 3.4.0-alpha.14

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

@@ -9,6 +9,7 @@ import type {
 } from "../../../_internal/utils"
 import type { Link, NestableWidget } from "../../../customtypes"
 import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx"
+import { hasContentType } from "../../utils"
 import {
 	isLinkContent,
 	LinkContent,
@@ -16,15 +17,18 @@ import {
 	LinkContentType,
 } from "./LinkContent"
 
+const RepeatableContentType = "RepeatableContent" as const
+
 export const RepeatableContent = t.strict({
-	__TYPE__: t.literal("RepeatableContent"),
+	__TYPE__: t.literal(RepeatableContentType),
 	type: t.literal("Link"),
 	value: t.array(LinkContent),
 })
 
 export type RepeatableContent = t.TypeOf<typeof RepeatableContent>
 
-export const isRepeatableContent = RepeatableContent.is
+export const isRepeatableContent = (u: unknown): u is RepeatableContent =>
+	hasContentType(u) && u.__TYPE__ === RepeatableContentType
 
 export const RepeatableLegacy = (
 	ctx: LegacyContentCtx,

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>
+
+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>

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

@@ -4,14 +4,17 @@ import * as t from "io-ts"
 
 import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx"
 import { hasContentType } from "../../utils"
-import { TextBlock } from "./RichTextContent/TextBlock"
+import { RichTextContentType, TextBlock } 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 TableCellContent = t.strict({
+	__TYPE__: t.literal(RichTextContentType),
+	value: t.array(TextBlock),
+})
 
 export const TableDataCell = t.strict({
 	type: t.literal("tableCell"),
@@ -31,11 +34,11 @@ export const TableRow = t.strict({
 })
 export type TableRow = t.TypeOf<typeof TableRow>
 
-export const tableContentLegacyCodec = t.strict({
+const legacyReader = t.strict({
 	content: t.array(TableRow),
 })
 
-export type TableLegacy = t.TypeOf<typeof tableContentLegacyCodec>
+type TableLegacy = t.TypeOf<typeof legacyReader>
 
 export const TableLegacy = (ctx: LegacyContentCtx) =>
 	new t.Type<TableContent, WithTypes<TableLegacy>, unknown>(
@@ -43,7 +46,7 @@ export const TableLegacy = (ctx: LegacyContentCtx) =>
 		isTableContent,
 		(u) => {
 			return pipe(
-				tableContentLegacyCodec.decode(u),
+				legacyReader.decode(u),
 				either.map((t) =>
 					TableContent.encode({ ...t, __TYPE__: TableContentType }),
 				),
@@ -52,14 +55,14 @@ export const TableLegacy = (ctx: LegacyContentCtx) =>
 
 		(t: TableContent) => {
 			return {
-				content: tableContentLegacyCodec.encode(t),
+				content: legacyReader.encode(t),
 				types: { [ctx.keyOfType]: "Table" },
 			}
 		},
 	)
 
 export const TableContent = t.intersection([
-	tableContentLegacyCodec,
+	legacyReader,
 	t.strict({
 		__TYPE__: t.literal(TableContentType),
 	}),

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

@@ -28,12 +28,12 @@ export const NestableWidget = t.union([
 	RichText,
 	Select,
 	Separator,
+	Table,
 	Text,
 	Timestamp,
 	Link,
 	Image,
 	IntegrationField,
-	Table,
 ])
 
 export type NestableWidget = t.TypeOf<typeof NestableWidget>

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/content/fields/nestable/RichTextContent/Block.ts

@@ -1,35 +0,0 @@
-import * as t from "io-ts"
-
-import { EmbedBlock, EmbedBlockLegacy } from "./EmbedBlock"
-import { ImageBlock, ImageBlockLegacy } from "./ImageBlock"
-import { TableBlock, TableBlockLegacy } from "./TableBlock"
-import { TextBlock, TextBlockLegacy } from "./TextBlock"
-
-const legacyBlockCodec = t.union([
-	EmbedBlockLegacy,
-	ImageBlockLegacy,
-	TextBlockLegacy,
-	TableBlockLegacy,
-])
-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) ||
-		TableBlockLegacy.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 if (TableBlock.is(block)) return TableBlockLegacy.encode(block)
-			else return TextBlockLegacy.encode(block)
-		})() as BlockLegacy
-	},
-)
-
-export const Block = t.union([ImageBlock, EmbedBlock, TextBlock, TableBlock])
-export type Block = t.TypeOf<typeof Block>

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

@@ -1,81 +0,0 @@
-import { either } from "fp-ts"
-import { pipe } from "fp-ts/lib/function"
-import * as t from "io-ts"
-
-import { RichTextNodeType } from "../../../../customtypes/widgets/nestable"
-import { StringOrNull } from "../../../../validators"
-import {
-	EmbedContent,
-	EmbedContentLegacy,
-	EmbedContentType,
-	EmbedLegacy,
-} from "../EmbedContent"
-import type { Block } from "./Block"
-
-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>
-
-export 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
-}

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

@@ -1,42 +0,0 @@
-import * as t from "io-ts"
-
-import { RichTextNodeType } from "../../../../customtypes/widgets/nestable"
-import { StringOrNull } from "../../../../validators"
-import { nullable } from "../../../../validators/function"
-import { ImageContentView } from "../ImageContent"
-import { FilledLink, FilledLinkLegacy } from "../LinkContent"
-import type { Block } from "./Block"
-
-// 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>
-
-export const ImageBlockLegacy = ImageBlockCodec(FilledLinkLegacy)
-export type ImageBlockLegacy = t.TypeOf<typeof ImageBlockLegacy>
-
-export function checkImageBlock(block: Block): block is ImageBlock {
-	return block.type === RichTextNodeType.image
-}

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

@@ -1,36 +0,0 @@
-import { either } from "fp-ts"
-import { pipe } from "fp-ts/lib/function"
-import * as t from "io-ts"
-
-import { RichTextNodeType } from "../../../../customtypes/widgets/nestable"
-import { tableContentLegacyCodec, TableLegacy, TableRow } from "../TableContent"
-
-export const TableBlockLegacy = new t.Type<TableBlock, TableLegacy, unknown>(
-	"TableBlockLegacy",
-	(u): u is TableBlock => (u as TableBlock).type === "table",
-	(block: unknown) => {
-		return pipe(
-			tableContentLegacyCodec.decode(block),
-			either.map(
-				(parseBlock: TableLegacy): TableBlock => ({
-					type: RichTextNodeType.table,
-					content: parseBlock.content.map(TableRow.encode),
-				}),
-			),
-		)
-	},
-	(tableBlock: TableBlock): TableLegacy => {
-		return tableContentLegacyCodec.encode(tableBlock)
-	},
-)
-
-export type TableBlockLegacy = t.TypeOf<typeof TableBlockLegacy>
-
-export const TableBlock = t.exact(
-	t.type({
-		type: t.literal(RichTextNodeType.table),
-		content: t.array(TableRow),
-	}),
-)
-
-export type TableBlock = t.TypeOf<typeof TableBlock>

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

@@ -1,108 +0,0 @@
-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>