@prismicio/types-internal 2.2.0-alpha.21 → 2.2.0-alpha.23

package/lib/import/converters/fields/nestable/Image.d.ts

@@ -1,6 +1,28 @@
 import type { Asset } from "../../../../common";
-import type { ImageContent, ImageContentView } from "../../../../content";
+import type { ImageContent } from "../../../../content";
 import type { ImageField, ImportImage } from "../../../validators";
 import type { ImportImageBlock } from "../../../validators/fields/nestable/ImportRichText/blocks";
-export declare function convertImageView<Input extends ImageField | ImportImageBlock>(inputImage: Input, image: Asset): ImageContentView;
+export declare function convertImageView<Input extends ImageField | ImportImageBlock>(inputImage: Input, image: Asset): {
+    origin: {
+        id: string;
+        url: string;
+        width: number;
+        height: number;
+    };
+    width: number;
+    height: number;
+    edit: {
+        zoom: number;
+        crop: {
+            x: number;
+            y: number;
+        };
+        background: string;
+    };
+} & {
+    url?: string;
+    credits?: string | null;
+    alt?: string | null;
+    provider?: string | null | undefined;
+};
 export declare const imageConverter: (imageField: ImportImage["value"], assets: Record<Asset["id"], Asset | undefined>) => ImageContent | undefined;

package/lib/import/converters/fields/nestable/Image.js

@@ -4,40 +4,39 @@ exports.imageConverter = exports.convertImageView = void 0;
 const common_1 = require("../../../../common");
 const Objects_1 = require("../../../../utils/Objects");
 function convertImageView(inputImage, image) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
     // We can do that because anyway all properties being read
     const imageField = {
         ...inputImage,
-        edit: "edit" in inputImage
-            ? inputImage.edit
-            : {
-                x: 0,
-                y: 0,
-                zoom: 1,
-            },
-        dimensions: "dimensions" in inputImage ? inputImage.dimensions : {},
+        edit: {
+            x: 0,
+            y: 0,
+            zoom: 1,
+            ...inputImage.edit,
+        },
+        dimensions: (_a = inputImage.dimensions) !== null && _a !== void 0 ? _a : {},
     };
     return (0, Objects_1.withOptionals)({
         origin: {
             id: image.id,
             url: image.origin_url,
             // All images returned form Asset API should have width and height properties.
-            width: (_a = image.width) !== null && _a !== void 0 ? _a : 0,
-            height: (_b = image.height) !== null && _b !== void 0 ? _b : 0,
+            width: (_b = image.width) !== null && _b !== void 0 ? _b : 0,
+            height: (_c = image.height) !== null && _c !== void 0 ? _c : 0,
         },
         // All images returned form Asset API should have width and height properties.
         // Image width and height will be only applied if there are no constraints and user didn't overwrite it
-        width: (_e = (_d = (_c = imageField === null || imageField === void 0 ? void 0 : imageField.dimensions) === null || _c === void 0 ? void 0 : _c.width) !== null && _d !== void 0 ? _d : image.width) !== null && _e !== void 0 ? _e : 0,
-        height: (_h = (_g = (_f = imageField === null || imageField === void 0 ? void 0 : imageField.dimensions) === null || _f === void 0 ? void 0 : _f.height) !== null && _g !== void 0 ? _g : image.height) !== null && _h !== void 0 ? _h : 0,
+        width: (_f = (_e = (_d = imageField === null || imageField === void 0 ? void 0 : imageField.dimensions) === null || _d === void 0 ? void 0 : _d.width) !== null && _e !== void 0 ? _e : image.width) !== null && _f !== void 0 ? _f : 0,
+        height: (_j = (_h = (_g = imageField === null || imageField === void 0 ? void 0 : imageField.dimensions) === null || _g === void 0 ? void 0 : _g.height) !== null && _h !== void 0 ? _h : image.height) !== null && _j !== void 0 ? _j : 0,
         // If edit is not provided, we crop constraint width and height from the left upper corner.
         // WARN: If constraints are greater than image dimensions cut outside the image (background will fill extra space).
         edit: {
-            zoom: (_k = (_j = imageField.edit) === null || _j === void 0 ? void 0 : _j.zoom) !== null && _k !== void 0 ? _k : 1,
+            zoom: (_l = (_k = imageField.edit) === null || _k === void 0 ? void 0 : _k.zoom) !== null && _l !== void 0 ? _l : 1,
             crop: {
-                x: (_m = (_l = imageField.edit) === null || _l === void 0 ? void 0 : _l.x) !== null && _m !== void 0 ? _m : 0,
-                y: (_p = (_o = imageField.edit) === null || _o === void 0 ? void 0 : _o.y) !== null && _p !== void 0 ? _p : 0,
+                x: (_o = (_m = imageField.edit) === null || _m === void 0 ? void 0 : _m.x) !== null && _o !== void 0 ? _o : 0,
+                y: (_q = (_p = imageField.edit) === null || _p === void 0 ? void 0 : _p.y) !== null && _q !== void 0 ? _q : 0,
             },
-            background: (_r = (_q = imageField.edit) === null || _q === void 0 ? void 0 : _q.background) !== null && _r !== void 0 ? _r : (image.extension === "png" ? "transparent" : "#ffffff"),
+            background: (_s = (_r = imageField.edit) === null || _r === void 0 ? void 0 : _r.background) !== null && _s !== void 0 ? _s : (image.extension === "png" ? "transparent" : "#ffffff"),
         },
         url: image.url,
     }, [

package/lib/import/converters/fields/nestable/RichText/textBlock.js

@@ -7,28 +7,35 @@ function textBlockConverter(block, assets) {
         type: block.type,
         content: {
             text: block.text,
-            ...block.spans ? { spans: spansConverter(block.spans, assets) } : {}
+            ...(() => {
+                if (block.spans) {
+                    const convertedSpans = spansConverter(block.spans, assets);
+                    if (!convertedSpans)
+                        return {};
+                    return { spans: convertedSpans };
+                }
+                return {};
+            })(),
         },
-        ...block.direction ? { direction: block.direction } : {},
+        ...(block.direction ? { direction: block.direction } : {}),
     };
 }
 exports.textBlockConverter = textBlockConverter;
 function spansConverter(spans, assets) {
-    return spans.map(span => {
-        var _a;
-        if (span.type === 'hyperlink') {
-            const { __TYPE__, ...data } = ((_a = (0, Link_1.linkConverter)(span.data, assets)) === null || _a === void 0 ? void 0 : _a.value) || {};
-            return {
-                type: span.type,
-                start: span.start,
-                end: span.end,
-                data: data
-            };
-        }
+    return spans.map((span) => {
         return {
             type: span.type,
             start: span.start,
-            end: span.end
+            end: span.end,
+            ...(() => {
+                if (span.type === "hyperlink") {
+                    const convertedLinkContent = (0, Link_1.linkConverter)(span.data, assets);
+                    if (!convertedLinkContent)
+                        return {};
+                    return { data: convertedLinkContent === null || convertedLinkContent === void 0 ? void 0 : convertedLinkContent.value };
+                }
+                return {};
+            })(),
         };
     });
 }

package/lib/import/validators/fields/nestable/ImportRichText/blocks/ImportImageBlock.d.ts

@@ -1,8 +1,22 @@
 import * as t from "io-ts";
 export declare const ImportImageBlockType: t.LiteralC<"image">;
 export declare type ImportImageBlockType = t.TypeOf<typeof ImportImageBlockType>;
-export declare const ImportImageBlock: t.ExactC<t.TypeC<{
+export declare const ImportImageBlock: t.ExactC<t.IntersectionC<[t.TypeC<{
     type: t.LiteralC<"image">;
+}>, t.IntersectionC<[t.TypeC<{
     id: t.StringC;
-}>>;
+}>, t.PartialC<{
+    dimensions: t.PartialC<{
+        width: t.NumberC;
+        height: t.NumberC;
+    }>;
+    edit: t.PartialC<{
+        x: t.NumberC;
+        y: t.NumberC;
+        zoom: t.NumberC;
+        background: t.StringC;
+    }>;
+    copyright: t.UnionC<[t.StringC, t.NullC]>;
+    alt: t.UnionC<[t.StringC, t.NullC]>;
+}>]>]>>;
 export declare type ImportImageBlock = t.TypeOf<typeof ImportImageBlock>;

package/lib/import/validators/fields/nestable/ImportRichText/blocks/ImportImageBlock.js

@@ -3,9 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImportImageBlock = exports.ImportImageBlockType = void 0;
 const tslib_1 = require("tslib");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
-const validators_1 = require("../../../../../../validators");
+const validators_1 = require("../../Image/validators");
 exports.ImportImageBlockType = t.literal("image");
-exports.ImportImageBlock = t.strict({
-    type: exports.ImportImageBlockType,
-    id: validators_1.String,
-});
+exports.ImportImageBlock = t.exact(t.intersection([
+    t.type({
+        type: exports.ImportImageBlockType,
+    }),
+    validators_1.ImportImageView,
+]));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prismicio/types-internal",
-	"version": "2.2.0-alpha.21",
+	"version": "2.2.0-alpha.23",
 	"description": "Prismic types for Custom Types and Prismic Data",
 	"keywords": [
 		"typescript",

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

@@ -1,5 +1,5 @@
 import { either } from "fp-ts"
-import { isLeft, isRight } from "fp-ts/lib/Either"
+import { isRight } from "fp-ts/lib/Either"
 import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
@@ -18,66 +18,54 @@ import {
 import { ImageContentView } from "../ImageContent"
 import { Link, LinkLegacy } from "../LinkContent"
 
-export const Meta = t.exact(
-	t.intersection([
-		t.partial({
-			data: t.unknown,
-		}),
-		t.type({
-			start: t.number,
-			end: t.number,
-			type: t.union([RichTextNodeTypeCodec, t.literal("label")]),
-		}),
-	]),
-)
-export type Meta = t.TypeOf<typeof Meta>
-
-// export alias for code clarity
-export const Span = Meta
-export type Span = Meta
-
-export const ValidatedMetas = (linkCodec: LinkCodec) =>
-	new t.Type<Meta[], Meta[], unknown>(
-		"ValidatedMetas",
-		(metas): metas is Meta[] => Array.isArray(metas) && metas.every(Meta.is),
-		(metas: unknown, c) => {
-			if (Array.isArray(metas)) {
-				const res = metas
-					.reduce<Array<Meta>>((acc, maybeMeta) => {
-						const maybeDecodedMeta = Meta.decode(maybeMeta)
-						if (isRight(maybeDecodedMeta)) {
-							const meta = maybeDecodedMeta.right
-							// if it's an hyperlink it should have data validated as link otherwise we don't care and keep the meta
-							if (meta.data && meta.type === "hyperlink") {
-								const decoded = linkCodec.decode(meta.data)
-								if (isLeft(decoded)) return acc
-
-								return [...acc, { ...meta, data: decoded.right }]
-							} else if (meta.type !== "hyperlink") {
-								return [...acc, meta]
-							}
-						}
-						return acc
+const SpanFn = (linkCodec: typeof Link | typeof LinkLegacy) =>
+	t.exact(
+		t.intersection([
+			t.partial({
+				data: linkCodec,
+			}),
+			t.type({
+				start: t.number,
+				end: t.number,
+				type: t.union([RichTextNodeTypeCodec, t.literal("label")]),
+			}),
+		]),
+	)
+
+export const Span = SpanFn(Link)
+export type Span = t.TypeOf<typeof Span>
+
+export const SpanLegacy = SpanFn(LinkLegacy)
+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)
+						return isRight(decodedSpan) ? [...acc, decodedSpan.right] : acc
 					}, [])
-					.sort((m1: Meta, m2: Meta) => m1.start - m2.start)
+					.sort((m1: S, m2: S) => m1.start - m2.start)
 				return t.success(res)
-			} else return t.failure(metas, c)
+			} else return t.failure(spans, c)
 		},
 		(m) => {
-			return m.reduce<Array<Meta>>((acc, meta) => {
-				if (meta.type === "hyperlink" && meta.data) {
-					// since the Span data are typed as unknown we have to redecode for type safety and then encode to either new format or legacy.
-					const decoded = linkCodec.decode(meta.data)
-					if (isLeft(decoded)) return acc
-
-					return [...acc, { ...meta, data: linkCodec.encode(decoded.right) }]
-				}
-				return [...acc, Meta.encode(meta)]
+			return m.reduce<Array<S>>((acc, meta) => {
+				return [...acc, spanCodec.encode(meta)]
 			}, [])
 		},
 	)
+}
 
-const ImageBlockCodec = (linkCodec: LinkCodec) =>
+const ImageBlockCodec = (linkCodec: typeof Link | typeof LinkLegacy) =>
 	t.exact(
 		t.intersection([
 			t.type({
@@ -169,8 +157,9 @@ export function checkEmbedBlock(block: Block): block is EmbedBlock {
 	return block.type === RichTextNodeType.embed
 }
 
-type LinkCodec = typeof Link | typeof LinkLegacy
-const TextBlockCodec = (linkCodec: LinkCodec) =>
+const TextBlockCodec = <C extends typeof Span | typeof SpanLegacy>(
+	spanCodec: C,
+) =>
 	t.exact(
 		t.intersection([
 			t.type({
@@ -184,7 +173,7 @@ const TextBlockCodec = (linkCodec: LinkCodec) =>
 						text: t.string,
 					}),
 					t.partial({
-						spans: ValidatedMetas(linkCodec),
+						spans: ValidatedSpans(spanCodec),
 					}),
 				]),
 			}),
@@ -195,10 +184,11 @@ const TextBlockCodec = (linkCodec: LinkCodec) =>
 		]),
 	)
 
-export const TextBlock = TextBlockCodec(Link)
+/* 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(LinkLegacy)
+const TextBlockLegacy = TextBlockCodec(SpanLegacy)
 type TextBlockLegacy = t.TypeOf<typeof TextBlockLegacy>
 
 const legacyBlockCodec = t.union([

package/src/import/converters/fields/nestable/Image.ts

@@ -3,24 +3,22 @@ import { getAssetOrThrow } from "../../../../common"
 import type { ImageContent, ImageContentView } from "../../../../content"
 import { withOptionals } from "../../../../utils/Objects"
 import type { ImageField, ImportImage } from "../../../validators"
-import type { ImportImageBlock } from "../../../validators/fields/nestable/ImportRichText/blocks";
+import type { ImportImageBlock } from "../../../validators/fields/nestable/ImportRichText/blocks"
 
 export function convertImageView<Input extends ImageField | ImportImageBlock>(
 	inputImage: Input,
 	image: Asset,
-): ImageContentView {
+) {
 	// We can do that because anyway all properties being read
 	const imageField: ImageField = {
 		...inputImage,
-		edit:
-			"edit" in inputImage
-				? inputImage.edit
-				: {
-						x: 0,
-						y: 0,
-						zoom: 1,
-				  },
-		dimensions: "dimensions" in inputImage ? inputImage.dimensions : {},
+		edit: {
+			x: 0,
+			y: 0,
+			zoom: 1,
+			...inputImage.edit,
+		},
+		dimensions: inputImage.dimensions ?? {},
 	}
 	return withOptionals<ImageContentView>(
 		{

package/src/import/converters/fields/nestable/RichText/embedBlock.ts

@@ -1,14 +1,17 @@
 import type { Embed } from "../../../../../common"
-import type { EmbedBlock } from "../../../../../content";
-import type { ImportEmbedBlock } from "../../../../validators/fields/nestable/ImportRichText/blocks";
-import { embedConverter } from "../Embed";
+import type { EmbedBlock } from "../../../../../content"
+import type { ImportEmbedBlock } from "../../../../validators/fields/nestable/ImportRichText/blocks"
+import { embedConverter } from "../Embed"
 
-export function embedBlockConverter(block: ImportEmbedBlock, 	embeds: Record<string, Embed | undefined>): EmbedBlock {
-  const embedData = embedConverter(block.oembed, embeds)
-  
-  if (!embedData) throw new Error("Failed to convert embed data")
-  return {
-    type: block.type,
-    data: embedData,
-  }
+export function embedBlockConverter(
+	block: ImportEmbedBlock,
+	embeds: Record<string, Embed | undefined>,
+): EmbedBlock {
+	const embedData = embedConverter(block.oembed, embeds)
+
+	if (!embedData) throw new Error("Failed to convert embed data")
+	return {
+		type: block.type,
+		data: embedData,
+	}
 }

package/src/import/converters/fields/nestable/RichText/imageBlock.ts

@@ -1,14 +1,17 @@
-import { Asset, getAssetOrThrow } from "../../../../../common";
-import type { ImageBlock } from "../../../../../content";
-import type { ImportImageBlock } from "../../../../validators/fields/nestable/ImportRichText/blocks";
-import { convertImageView } from "../Image";
+import { Asset, getAssetOrThrow } from "../../../../../common"
+import type { ImageBlock } from "../../../../../content"
+import type { ImportImageBlock } from "../../../../validators/fields/nestable/ImportRichText/blocks"
+import { convertImageView } from "../Image"
 
-export function imageBlockConverter(block: ImportImageBlock, 	assets: Record<Asset["id"], Asset | undefined>): ImageBlock {
-  return {
-    type: block.type,
-    data: convertImageView<ImportImageBlock>(
-      block,
-      getAssetOrThrow(assets)(block.id)
-    ),
-  }
+export function imageBlockConverter(
+	block: ImportImageBlock,
+	assets: Record<Asset["id"], Asset | undefined>,
+): ImageBlock {
+	return {
+		type: block.type,
+		data: convertImageView<ImportImageBlock>(
+			block,
+			getAssetOrThrow(assets)(block.id),
+		),
+	}
 }

package/src/import/converters/fields/nestable/RichText/index.ts

@@ -15,9 +15,9 @@ export const richTextConverter = (
 	return {
 		__TYPE__: RichTextContentType,
 		value: richTextField.map((block) => {
-      if (block.type === "image") return imageBlockConverter(block, assets)
-      else if (block.type === "embed") return embedBlockConverter(block, embeds)
-	    return textBlockConverter(block, assets)
-    }),
+			if (block.type === "image") return imageBlockConverter(block, assets)
+			else if (block.type === "embed") return embedBlockConverter(block, embeds)
+			return textBlockConverter(block, assets)
+		}),
 	}
 }

package/src/import/converters/fields/nestable/RichText/textBlock.ts

@@ -3,33 +3,46 @@ import type { TextBlock } from "../../../../../content"
 import type { ImportTextBlock } from "../../../../validators/fields/nestable/ImportRichText/blocks"
 import { linkConverter } from "../Link"
 
-export function textBlockConverter(block: ImportTextBlock, assets: Record<Asset["id"], Asset | undefined>): TextBlock {
-  return {
-    type: block.type,
-    content: {
-      text: block.text,
-      ...block.spans ? { spans: spansConverter(block.spans, assets) }: {}
-    },
-    ...block.direction ? { direction: block.direction } : {},
-  }
+export function textBlockConverter(
+	block: ImportTextBlock,
+	assets: Record<Asset["id"], Asset | undefined>,
+): TextBlock {
+	return {
+		type: block.type,
+		content: {
+			text: block.text,
+			...(() => {
+				if (block.spans) {
+					const convertedSpans = spansConverter(block.spans, assets)
+					if (!convertedSpans) return {}
+
+					return { spans: convertedSpans }
+				}
+				return {}
+			})(),
+		},
+		...(block.direction ? { direction: block.direction } : {}),
+	}
 }
 
-function spansConverter(spans: NonNullable<ImportTextBlock['spans']>, assets: Record<Asset["id"], Asset | undefined>): TextBlock['content']['spans'] {
-  return spans.map(span => {
-    if (span.type === 'hyperlink') {
-      const { __TYPE__, ...data } = linkConverter(span.data, assets)?.value || {}
-      return {
-        type: span.type,
-        start: span.start,
-        end: span.end,
-        data: data
-      }
-    }
+function spansConverter(
+	spans: NonNullable<ImportTextBlock["spans"]>,
+	assets: Record<Asset["id"], Asset | undefined>,
+): TextBlock["content"]["spans"] {
+	return spans.map((span) => {
+		return {
+			type: span.type,
+			start: span.start,
+			end: span.end,
+			...(() => {
+				if (span.type === "hyperlink") {
+					const convertedLinkContent = linkConverter(span.data, assets)
+					if (!convertedLinkContent) return {}
 
-    return {
-      type: span.type,
-      start: span.start,
-      end: span.end
-    }
-  })
+					return { data: convertedLinkContent?.value }
+				}
+				return {}
+			})(),
+		}
+	})
 }

package/src/import/validators/fields/nestable/ImportRichText/blocks/ImportImageBlock.ts

@@ -1,13 +1,17 @@
 import * as t from "io-ts"
 
-import { String } from "../../../../../../validators"
+import { ImportImageView } from "../../Image/validators"
 
 export const ImportImageBlockType = t.literal("image")
 export type ImportImageBlockType = t.TypeOf<typeof ImportImageBlockType>
 
-export const ImportImageBlock = t.strict({
-	type: ImportImageBlockType,
-	id: String,
-})
+export const ImportImageBlock = t.exact(
+	t.intersection([
+		t.type({
+			type: ImportImageBlockType,
+		}),
+		ImportImageView,
+	]),
+)
 
 export type ImportImageBlock = t.TypeOf<typeof ImportImageBlock>

package/lib/import/converters/fields/nestable/GeooPoint.d.ts

@@ -1,3 +0,0 @@
-import type { GeoPointContent } from "../../../../content";
-import type { ImportGeoPoint } from "../../../validators";
-export declare const geopointConverter: (field: ImportGeoPoint["value"]) => GeoPointContent | undefined;

package/lib/import/converters/fields/nestable/GeooPoint.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.geopointConverter = void 0;
-const geopointConverter = (field) => {
-    if (field === null)
-        return;
-    return {
-        position: {
-            lat: field.latitude,
-            lng: field.longitude,
-        },
-        __TYPE__: "GeoPointContent",
-    };
-};
-exports.geopointConverter = geopointConverter;

package/lib/import/converters/fields/nestable/RichText.d.ts

@@ -1,4 +0,0 @@
-import type { Asset, Embed } from "../../../../common";
-import type { RichTextContent } from "../../../../content";
-import type { ImportRichText } from "../../../validators";
-export declare const richTextConverter: (richTextField: ImportRichText["value"], assets: Record<Asset["id"], Asset | undefined>, embeds: Record<string, Embed | undefined>) => RichTextContent | undefined;

package/lib/import/converters/fields/nestable/RichText.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.richTextConverter = void 0;
-const content_1 = require("../../../../content");
-const Embed_1 = require("./Embed");
-const Image_1 = require("./Image");
-const Link_1 = require("./Link");
-const richTextBlockConverter = (importBlock, assets, embeds) => {
-    var _a, _b, _c;
-    if (importBlock.type === "image") {
-        return {
-            type: importBlock.type,
-            data: (0, Image_1.imageBlockConverter)(importBlock, assets),
-        };
-    }
-    else if (importBlock.type === "embed") {
-        const embedData = (0, Embed_1.embedConverter)(importBlock.oembed, embeds);
-        if (!embedData)
-            throw new Error("Failed to convert embed data");
-        return {
-            type: importBlock.type,
-            data: embedData,
-        };
-    }
-    else {
-        // Text block
-        return {
-            type: importBlock.type,
-            direction: (_a = importBlock.direction) !== null && _a !== void 0 ? _a : "ltr",
-            content: {
-                text: importBlock.text,
-                spans: (_c = (_b = importBlock.spans) === null || _b === void 0 ? void 0 : _b.map((span) => {
-                    const linkData = span.type === "hyperlink"
-                        ? (0, Link_1.linkConverter)(span.data, assets)
-                        : undefined;
-                    return {
-                        type: span.type,
-                        start: span.start,
-                        end: span.end,
-                        data: linkData,
-                    };
-                })) !== null && _c !== void 0 ? _c : [],
-            },
-        };
-    }
-};
-const richTextConverter = (richTextField, assets, embeds) => {
-    if (richTextField === null)
-        return;
-    return {
-        __TYPE__: content_1.RichTextContentType,
-        value: richTextField.map((block) => richTextBlockConverter(block, assets, embeds)),
-    };
-};
-exports.richTextConverter = richTextConverter;