@prismicio/types-internal 2.2.0-traverse.alpha-2 → 2.2.0-traverse.alpha-4

package/lib/import/validators/fields/nestable/ImportRichText/blocks/spans/SpanLocation.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpanLocation = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../../../../../validators");
+exports.SpanLocation = t.type({
+    start: validators_1.Number,
+    end: validators_1.Number,
+});

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

@@ -0,0 +1,17 @@
+import * as t from "io-ts";
+export declare const TextSpanType: t.KeyofC<{
+    strong: null;
+    em: null;
+    label: null;
+}>;
+export declare const TextSpan: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.KeyofC<{
+        strong: null;
+        em: null;
+        label: null;
+    }>;
+}>, t.TypeC<{
+    start: t.NumberC;
+    end: t.NumberC;
+}>]>>;
+export declare type TextSpan = t.TypeOf<typeof TextSpan>;

package/lib/import/validators/fields/nestable/ImportRichText/blocks/spans/TextSpan.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TextSpan = exports.TextSpanType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const SpanLocation_1 = require("./SpanLocation");
+const TextSpanTypes = {
+    Strong: "strong",
+    Em: "em",
+    Label: "label",
+};
+exports.TextSpanType = t.keyof({
+    [TextSpanTypes.Strong]: null,
+    [TextSpanTypes.Em]: null,
+    [TextSpanTypes.Label]: null,
+});
+exports.TextSpan = t.exact(t.intersection([
+    t.type({
+        type: exports.TextSpanType,
+    }),
+    SpanLocation_1.SpanLocation,
+]));

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

@@ -0,0 +1,2 @@
+export * from "./HyperlinkSpan";
+export * from "./TextSpan";

package/lib/import/validators/fields/nestable/ImportRichText/blocks/spans/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./HyperlinkSpan"), exports);
+(0, tslib_1.__exportStar)(require("./TextSpan"), exports);

package/lib/import/validators/fields/nestable/ImportRichText/index.d.ts

@@ -0,0 +1,2 @@
+export { ImportBlock } from "./ImportBlock";
+export { ImportRichText } from "./ImportRichText";

package/lib/import/validators/fields/nestable/ImportRichText/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportRichText = exports.ImportBlock = void 0;
+var ImportBlock_1 = require("./ImportBlock");
+Object.defineProperty(exports, "ImportBlock", { enumerable: true, get: function () { return ImportBlock_1.ImportBlock; } });
+var ImportRichText_1 = require("./ImportRichText");
+Object.defineProperty(exports, "ImportRichText", { enumerable: true, get: function () { return ImportRichText_1.ImportRichText; } });

package/lib/import/validators/fields/nestable/Link.d.ts

@@ -1,22 +1,37 @@
 import type { TypeOf } from "io-ts";
 import * as t from "io-ts";
-declare const WebLink: t.IntersectionC<[t.TypeC<{
+declare const WebLink: t.ExactC<t.IntersectionC<[t.TypeC<{
     link_type: t.LiteralC<"Web">;
     url: t.StringC;
 }>, t.PartialC<{
     target: t.StringC;
-}>]>;
+}>]>>;
 export declare type WebLink = t.TypeOf<typeof WebLink>;
-declare const DocumentLink: t.TypeC<{
+declare const DocumentLink: t.ExactC<t.TypeC<{
     link_type: t.LiteralC<"Document">;
     id: t.Type<string, string, unknown>;
-}>;
+}>>;
 export declare type DocumentLink = t.TypeOf<typeof DocumentLink>;
-declare const MediaLink: t.TypeC<{
+declare const MediaLink: t.ExactC<t.TypeC<{
     link_type: t.LiteralC<"Media">;
     id: t.StringC;
-}>;
+}>>;
 export declare type MediaLink = t.TypeOf<typeof MediaLink>;
+export declare const Link: t.Type<({
+    link_type: "Web";
+    url: string;
+} & {
+    target?: string;
+}) | {
+    link_type: "Document";
+    id: string;
+} | {
+    link_type: "Media";
+    id: string;
+}, {
+    link_type: "Document" | "Web" | "Media";
+}, unknown>;
+export declare type Link = TypeOf<typeof Link>;
 export declare const ImportLink: t.Type<{
     type: "Link";
     value: ({

package/lib/import/validators/fields/nestable/Link.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ImportLink = void 0;
+exports.ImportLink = exports.Link = void 0;
 const tslib_1 = require("tslib");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const DocumentId_1 = require("../../../../utils/DocumentId");
@@ -10,7 +10,7 @@ const ImportContent_1 = require("../ImportContent");
 const LinkTypeValidator = t.type({
     link_type: (0, function_1.withCustomError)(t.union([t.literal("Web"), t.literal("Document"), t.literal("Media")]), () => "The value must be `Web`, `Document` or `Media`"),
 });
-const WebLink = t.intersection([
+const WebLink = t.exact(t.intersection([
     t.type({
         link_type: t.literal("Web"),
         url: validators_1.String,
@@ -18,18 +18,18 @@ const WebLink = t.intersection([
     t.partial({
         target: validators_1.String,
     }),
-]);
-const DocumentLink = t.type({
+]));
+const DocumentLink = t.strict({
     link_type: t.literal("Document"),
     id: DocumentId_1.DocumentId,
 });
-const MediaLink = t.type({
+const MediaLink = t.strict({
     link_type: t.literal("Media"),
     id: validators_1.String,
 });
-const Link = LinkTypeValidator.pipe(t.union([WebLink, DocumentLink, MediaLink]));
+exports.Link = LinkTypeValidator.pipe(t.union([WebLink, DocumentLink, MediaLink]));
 // This is the default value for the link
-const AnyLink = t.type({
+const AnyLink = t.strict({
     link_type: t.literal("Any"),
 });
-exports.ImportLink = (0, ImportContent_1.ImportContent)("Link", (0, validators_1.DefaultOrElse)(AnyLink)(Link));
+exports.ImportLink = (0, ImportContent_1.ImportContent)("Link", (0, validators_1.DefaultOrElse)(AnyLink)(exports.Link));

package/lib/import/validators/fields/nestable/Nestable.d.ts

@@ -5,12 +5,13 @@ import { ImportDate } from "./Date";
 import { ImportEmbed } from "./Embed";
 import { ImportGeoPoint } from "./GeoPoint";
 import { ImportImage } from "./Image";
+import { ImportRichText } from "./ImportRichText";
 import { ImportLink } from "./Link";
 import { ImportNumber } from "./Number";
 import { ImportSelect } from "./Select";
 import { ImportText } from "./Text";
 import { ImportTimestamp } from "./Timestamp";
-export declare type ImportNestable = ImportBoolean | ImportColor | ImportNumber | ImportSelect | ImportText | ImportDate | ImportTimestamp | ImportEmbed | ImportLink | ImportGeoPoint | ImportImage;
+export declare type ImportNestable = ImportBoolean | ImportColor | ImportNumber | ImportSelect | ImportText | ImportDate | ImportTimestamp | ImportEmbed | ImportLink | ImportGeoPoint | ImportImage | ImportRichText;
 export declare const ImportNestable: {
     is(u: unknown): u is ImportNestable;
     decode: (field: NestableWidget) => (content: unknown) => {
@@ -59,6 +60,9 @@ export declare const ImportNestable: {
         }, {
             link_type: "Document" | "Web" | "Media";
         } | undefined, unknown> | import("io-ts").Type<{
+            type: "StructuredText";
+            value: import("./ImportRichText").ImportBlock[] | null;
+        }, unknown[] | undefined, unknown> | import("io-ts").Type<{
             type: "Number";
             value: number | null;
         }, number | undefined, unknown> | import("io-ts").Type<{
@@ -83,6 +87,9 @@ export declare const ImportNestable: {
         }> | import("fp-ts/lib/Either").Right<{
             type: "Number";
             value: number | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "StructuredText";
+            value: import("./ImportRichText").ImportBlock[] | null;
         }> | import("fp-ts/lib/Either").Right<{
             type: "Link";
             value: ({

package/lib/import/validators/fields/nestable/Nestable.js

@@ -7,6 +7,7 @@ const Date_1 = require("./Date");
 const Embed_1 = require("./Embed");
 const GeoPoint_1 = require("./GeoPoint");
 const Image_1 = require("./Image");
+const ImportRichText_1 = require("./ImportRichText");
 const Link_1 = require("./Link");
 const Number_1 = require("./Number");
 const Select_1 = require("./Select");
@@ -24,7 +25,8 @@ exports.ImportNestable = {
             Embed_1.ImportEmbed.is(u) ||
             Link_1.ImportLink.is(u) ||
             GeoPoint_1.ImportGeoPoint.is(u) ||
-            (0, Image_1.ImportImage)().is(u));
+            (0, Image_1.ImportImage)().is(u) ||
+            (0, ImportRichText_1.ImportRichText)().is(u));
     },
     decode: (field) => {
         return (content) => {
@@ -52,6 +54,8 @@ exports.ImportNestable = {
                         return (0, Image_1.ImportImage)(field);
                     case "GeoPoint":
                         return GeoPoint_1.ImportGeoPoint;
+                    case "StructuredText":
+                        return (0, ImportRichText_1.ImportRichText)(field);
                     default:
                         throw new Error(`Unsupported type of nestable field ${field.type}`);
                 }

package/lib/import/validators/fields/nestable/index.d.ts

@@ -1,10 +1,11 @@
 export * from "./Boolean";
 export * from "./Color";
 export * from "./Date";
-export * from "./Embed";
+export { ImportEmbed } from "./Embed";
 export * from "./GeoPoint";
 export * from "./Image";
 export * from "./Image/index";
+export * from "./ImportRichText";
 export * from "./Link";
 export * from "./Nestable";
 export * from "./Number";

package/lib/import/validators/fields/nestable/index.js

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportEmbed = void 0;
 const tslib_1 = require("tslib");
 (0, tslib_1.__exportStar)(require("./Boolean"), exports);
 (0, tslib_1.__exportStar)(require("./Color"), exports);
 (0, tslib_1.__exportStar)(require("./Date"), exports);
-(0, tslib_1.__exportStar)(require("./Embed"), exports);
+var Embed_1 = require("./Embed");
+Object.defineProperty(exports, "ImportEmbed", { enumerable: true, get: function () { return Embed_1.ImportEmbed; } });
 (0, tslib_1.__exportStar)(require("./GeoPoint"), exports);
 (0, tslib_1.__exportStar)(require("./Image"), exports);
 (0, tslib_1.__exportStar)(require("./Image/index"), exports);
+(0, tslib_1.__exportStar)(require("./ImportRichText"), exports);
 (0, tslib_1.__exportStar)(require("./Link"), exports);
 (0, tslib_1.__exportStar)(require("./Nestable"), exports);
 (0, tslib_1.__exportStar)(require("./Number"), exports);

package/package.json

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

package/src/content/Document.ts

@@ -14,15 +14,12 @@ import {
 	collectSharedSlices,
 	flattenStaticWidgets,
 	StaticCustomType,
-	VariationFields,
 } from "../customtypes"
 import {
-	CompositeSliceItemContent,
-	GroupItemContent,
 	isCompositeSliceItemContent,
 	isSimpleSliceItemContent,
-	SharedSliceItemContent,
-	SimpleSliceItemContent,
+	migrateCompositeSlice,
+	migrateSimpleSlice,
 	traverseGroupContent,
 	traverseSlices,
 	WidgetContent,
@@ -132,7 +129,10 @@ function extractMetadata(data: { [p: string]: unknown }): {
 
 function parseLegacyDocument(
 	legacyDoc: unknown,
-	customType: StaticCustomType,
+	customType: {
+		customTypeId: string
+		fields: Record<string, StaticWidget>
+	},
 ): Document | undefined {
 	const result = pipe(
 		// ensure it's the right document format first
@@ -169,11 +169,21 @@ export const DocumentLegacy = {
  */
 export function traverseDocument({
 	document,
-	model,
+	customType,
 }: {
 	document: Document
-	model?: StaticCustomType
+	customType?:
+		| StaticCustomType
+		| {
+				customTypeId: string
+				fields: Record<string, StaticWidget>
+		  }
+		| undefined
 }) {
+	const model =
+		customType && StaticCustomType.is(customType)
+			? simplifyCustomType(customType)
+			: customType
 	return ({
 		transformWidget = ({ content }) => content,
 		transformSlice = ({ content }) => content,
@@ -183,7 +193,7 @@ export function traverseDocument({
 	}): Document => {
 		const fieldModels =
 			model &&
-			flattenStaticWidgets(model).reduce<Record<string, StaticWidget>>(
+			Object.entries(model.fields).reduce<Record<string, StaticWidget>>(
 				(acc, [key, def]) => ({ ...acc, [key]: def }),
 				{},
 			)
@@ -192,7 +202,7 @@ export function traverseDocument({
 			const fieldModel = fieldModels && fieldModels[key]
 
 			const path = ContentPath.make([
-				{ key: model?.id, type: "CustomType" },
+				{ key: model?.customTypeId, type: "CustomType" },
 				{ key, type: "Widget" },
 			])
 
@@ -240,6 +250,16 @@ export function traverseDocument({
 	}
 }
 
+function simplifyCustomType(customType: StaticCustomType): {
+	customTypeId: string
+	fields: Record<string, StaticWidget>
+} {
+	return {
+		customTypeId: customType?.id,
+		fields: Object.fromEntries(flattenStaticWidgets(customType)),
+	}
+}
+
 // /**
 //  * The goal is to be able to collect all widgets or slices of a given type at any level of nesting inside a prismic content
 //  *
@@ -263,87 +283,18 @@ export function collectWidgets<W extends WidgetContent>(
 	return collected
 }
 
-function migrateCompositeSlice(
-	model: VariationFields,
-	content: CompositeSliceItemContent,
-): SharedSliceItemContent {
-	return {
-		key: content.key,
-		name: model.sliceName,
-		maybeLabel: content.maybeLabel,
-		widget: {
-			__TYPE__: "SharedSliceContent",
-			variation: model.variationId,
-			primary: Object.entries(content.widget.nonRepeat).reduce(
-				(acc, [fieldKey, fieldContent]) => {
-					return model.fields.primary?.[fieldKey]
-						? { ...acc, [fieldKey]: fieldContent }
-						: acc
-				},
-				{},
-			),
-			items: content.widget.repeat.map((groupItem) => {
-				return {
-					__TYPE__: "GroupItemContent",
-					value: groupItem.value.reduce<GroupItemContent["value"]>(
-						(acc, [fieldKey, fieldContent]) => {
-							return model.fields.items?.[fieldKey]
-								? acc.concat([[fieldKey, fieldContent]])
-								: acc
-						},
-						[],
-					),
-				}
-			}, []),
-		},
-	}
-}
-
-function migrateSimpleSlice(
-	model: VariationFields,
-	content: SimpleSliceItemContent,
-): SharedSliceItemContent {
-	if (content.widget.__TYPE__ === "GroupContentType") {
-		return {
-			key: content.key,
-			name: model.sliceName,
-			maybeLabel: content.maybeLabel,
-			widget: {
-				__TYPE__: "SharedSliceContent",
-				variation: model.variationId,
-				primary: {},
-				items: content.widget.value.map((groupItem) => {
-					return {
-						__TYPE__: "GroupItemContent",
-						value: groupItem.value.reduce<GroupItemContent["value"]>(
-							(acc, [fieldKey, fieldContent]) => {
-								return model.fields.items?.[fieldKey]
-									? acc.concat([[fieldKey, fieldContent]])
-									: acc
-							},
-							[],
-						),
-					}
-				}, []),
-			},
-		}
-	}
-	return {
-		key: content.key,
-		name: model.sliceName,
-		maybeLabel: content.maybeLabel,
-		widget: {
-			__TYPE__: "SharedSliceContent",
-			variation: model.variationId,
-			primary: model.fields.primary?.[content.name]
-				? { [content.key]: content.widget }
-				: {},
-			items: [],
-		},
-	}
-}
-
-export function migrateDocument(document: Document, model: StaticCustomType) {
+export function migrateDocument(
+	document: Document,
+	customType:
+		| StaticCustomType
+		| {
+				customTypeId: string
+				fields: Record<string, StaticWidget>
+		  },
+) {
+	const model = StaticCustomType.is(customType)
+		? simplifyCustomType(customType)
+		: customType
 	const needsMigration = Object.values(collectSharedSlices(model)).some(
 		(slice) => Boolean(slice.legacyPaths),
 	)
@@ -352,7 +303,7 @@ export function migrateDocument(document: Document, model: StaticCustomType) {
 
 	return traverseDocument({
 		document,
-		model,
+		customType,
 	})({
 		transformSlice: ({ content, model }) => {
 			if (isCompositeSliceItemContent(content) && model?.type === "SharedSlice")

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

@@ -18,7 +18,7 @@ import {
 	WithTypes,
 } from "../../../LegacyContentCtx"
 import { hasContentType } from "../../../utils"
-import { traverseGroupItemsContent } from "../../GroupContent"
+import { GroupItemContent, traverseGroupItemsContent } from "../../GroupContent"
 import {
 	isNestableContent,
 	NestableContent,
@@ -205,3 +205,39 @@ export function traverseCompositeSliceContent({
 		})
 	}
 }
+
+export function migrateCompositeSlice(
+	model: VariationFields,
+	content: CompositeSliceItemContent,
+): SharedSliceItemContent {
+	return {
+		key: content.key,
+		name: model.sliceName,
+		maybeLabel: content.maybeLabel,
+		widget: {
+			__TYPE__: "SharedSliceContent",
+			variation: model.variationId,
+			primary: Object.entries(content.widget.nonRepeat).reduce(
+				(acc, [fieldKey, fieldContent]) => {
+					return model.fields.primary?.[fieldKey]
+						? { ...acc, [fieldKey]: fieldContent }
+						: acc
+				},
+				{},
+			),
+			items: content.widget.repeat.map((groupItem) => {
+				return {
+					__TYPE__: "GroupItemContent",
+					value: groupItem.value.reduce<GroupItemContent["value"]>(
+						(acc, [fieldKey, fieldContent]) => {
+							return model.fields.items?.[fieldKey]
+								? acc.concat([[fieldKey, fieldContent]])
+								: acc
+						},
+						[],
+					),
+				}
+			}, []),
+		},
+	}
+}

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

@@ -13,6 +13,7 @@ import type {
 import type { LegacyContentCtx } from "../../../LegacyContentCtx"
 import {
 	GroupContent,
+	GroupItemContent,
 	GroupLegacy,
 	isGroupContent,
 	traverseGroupContent,
@@ -129,3 +130,47 @@ export function traverseSimpleSliceContent({
 		)
 	}
 }
+
+export function migrateSimpleSlice(
+	model: VariationFields,
+	content: SimpleSliceItemContent,
+): SharedSliceItemContent {
+	if (content.widget.__TYPE__ === "GroupContentType") {
+		return {
+			key: content.key,
+			name: model.sliceName,
+			maybeLabel: content.maybeLabel,
+			widget: {
+				__TYPE__: "SharedSliceContent",
+				variation: model.variationId,
+				primary: {},
+				items: content.widget.value.map((groupItem) => {
+					return {
+						__TYPE__: "GroupItemContent",
+						value: groupItem.value.reduce<GroupItemContent["value"]>(
+							(acc, [fieldKey, fieldContent]) => {
+								return model.fields.items?.[fieldKey]
+									? acc.concat([[fieldKey, fieldContent]])
+									: acc
+							},
+							[],
+						),
+					}
+				}, []),
+			},
+		}
+	}
+	return {
+		key: content.key,
+		name: model.sliceName,
+		maybeLabel: content.maybeLabel,
+		widget: {
+			__TYPE__: "SharedSliceContent",
+			variation: model.variationId,
+			primary: model.fields.primary?.[content.name]
+				? { [content.key]: content.widget }
+				: {},
+			items: [],
+		},
+	}
+}

package/src/customtypes/CustomType.ts

@@ -215,7 +215,7 @@ export function filterMissingSharedSlices(
 
 export function flattenCustomTypeFields(
 	customType: StaticCustomType,
-): Partial<Record<string, StaticWidget>> {
+): Record<string, StaticWidget> {
 	return Object.values(customType.json).reduce(
 		(acc, tab) => ({
 			...acc,
@@ -225,10 +225,11 @@ export function flattenCustomTypeFields(
 	)
 }
 
-export function collectSharedSlices(
-	customType: StaticCustomType,
-): Record<string, SharedSlice> {
-	return flattenStaticWidgets(customType).reduce((acc, [, w]) => {
+export function collectSharedSlices(customType: {
+	customTypeId: string
+	fields: Record<string, StaticWidget>
+}): Record<string, SharedSlice> {
+	return Object.entries(customType.fields).reduce((acc, [, w]) => {
 		if (w.type === "Slices" || w.type === "Choice") {
 			return {
 				...acc,

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

@@ -1,11 +1,28 @@
 import type { Asset } from "../../../../common"
 import { getAssetOrThrow } from "../../../../common"
-import type { ImageContent } from "../../../../content"
+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"
 
-function convertImage(imageField: ImageField, image: Asset) {
-	return withOptionals<Omit<ImageContent, "__TYPE__" | "thumbnails">>(
+function convertImage<Input extends ImageField | ImportImageBlock>(
+	inputImage: Input,
+	image: Asset,
+) {
+	// 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 : {},
+	}
+	return withOptionals<ImageContentView>(
 		{
 			origin: {
 				id: image.id,
@@ -57,6 +74,16 @@ function convertThumbnails(
 	)
 }
 
+export const imageBlockConverter = (
+	imageBlock: ImportImageBlock,
+	assets: Record<Asset["id"], Asset | undefined>,
+): ImageContentView => {
+	return convertImage<ImportImageBlock>(
+		imageBlock,
+		getAssetOrThrow(assets)(imageBlock.id),
+	)
+}
+
 // All assets from `imageField` must be present in `assets`
 // If not then function will throw an error
 export const imageConverter = (
@@ -66,7 +93,10 @@ export const imageConverter = (
 	if (!imageField) return
 
 	return {
-		...convertImage(imageField, getAssetOrThrow(assets)(imageField.id)),
+		...convertImage<ImageField>(
+			imageField,
+			getAssetOrThrow(assets)(imageField.id),
+		),
 		thumbnails: convertThumbnails(imageField, assets),
 		__TYPE__: "ImageContent" as const,
 	}

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

@@ -11,6 +11,7 @@ import {
 	imageConverter,
 	linkConverter,
 	numberConverter,
+	richTextConverter,
 	selectConverter,
 	textConverter,
 	timestampConverter,
@@ -44,6 +45,8 @@ export function convertNestableWidget(
 			return linkConverter(field.value, assets)
 		case "Image":
 			return imageConverter(field.value, assets)
+		case "StructuredText":
+			return richTextConverter(field.value, assets, embeds)
 		default:
 			throw new Error(
 				`Unsupported type of nestable converter ${JSON.stringify(field)}`,