@prismicio/types-internal 2.2.0-traverse.alpha-1 → 2.2.0-traverse.alpha-3

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Span = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const function_1 = require("../../../../../../validators/function");
+const spans_1 = require("./spans");
+const SpanType = (0, function_1.withCustomError)(t.union([spans_1.HyperlinkSpanType, spans_1.TextSpanType]), () => `Span 'type' field must be specified and have one of the following values: ${Object.keys(spans_1.TextSpanType.keys).join(", ")} or ${spans_1.HyperlinkSpanType.value}`);
+const SpanTypeValidator = (0, function_1.withCustomError)(t.type({
+    type: SpanType,
+}), () => "Span must be an object");
+const SpanShape = t.union([spans_1.HyperlinkSpan, spans_1.TextSpan]);
+exports.Span = SpanTypeValidator.pipe(new t.Type("Span", (u) => SpanShape.is(u), (u, c) => {
+    if (spans_1.HyperlinkSpanType.is(u.type)) {
+        return spans_1.HyperlinkSpan.validate(u, c);
+    }
+    else {
+        return spans_1.TextSpan.validate(u, c);
+    }
+}, t.identity));

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

@@ -0,0 +1,4 @@
+export * from "./ImportBlockType";
+export * from "./ImportEmbedBlock";
+export * from "./ImportImageBlock";
+export * from "./ImportTextBlock";

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./ImportBlockType"), exports);
+(0, tslib_1.__exportStar)(require("./ImportEmbedBlock"), exports);
+(0, tslib_1.__exportStar)(require("./ImportImageBlock"), exports);
+(0, tslib_1.__exportStar)(require("./ImportTextBlock"), exports);

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

@@ -0,0 +1,24 @@
+import * as t from "io-ts";
+export declare const HyperlinkSpanType: t.LiteralC<"hyperlink">;
+export declare type HyperlinkSpanType = t.TypeOf<typeof HyperlinkSpanType>;
+export declare const HyperlinkSpan: t.ExactC<t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"hyperlink">;
+}>, t.TypeC<{
+    start: t.NumberC;
+    end: t.NumberC;
+}>, t.TypeC<{
+    data: 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>;
+}>]>>;

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HyperlinkSpan = exports.HyperlinkSpanType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const function_1 = require("../../../../../../../validators/function");
+const Link_1 = require("../../../Link");
+const SpanLocation_1 = require("./SpanLocation");
+exports.HyperlinkSpanType = t.literal("hyperlink");
+exports.HyperlinkSpan = t.exact(t.intersection([
+    t.type({
+        type: exports.HyperlinkSpanType,
+    }),
+    SpanLocation_1.SpanLocation,
+    (0, function_1.withCustomError)(t.type({
+        data: Link_1.Link,
+    }), () => "Hyperlink span must contain a 'data' field with link data"),
+]));

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

@@ -0,0 +1,5 @@
+import * as t from "io-ts";
+export declare const SpanLocation: t.TypeC<{
+    start: t.NumberC;
+    end: t.NumberC;
+}>;

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-1",
+	"version": "2.2.0-traverse.alpha-3",
 	"description": "Prismic types for Custom Types and Prismic Data",
 	"keywords": [
 		"typescript",

package/src/_internal/utils.ts

@@ -1,9 +1,41 @@
-import type { SliceContent, WidgetContent } from "../content"
-import type { StaticSlice, StaticWidget } from "../customtypes"
+import type {
+	SharedSliceItemContent,
+	SliceItemContent,
+	WidgetContent,
+} from "../content"
+import type {
+	CompositeSliceFields,
+	Group,
+	NestableWidget,
+	StaticSlices,
+	UID,
+	VariationFields,
+} from "../customtypes"
 
-export type TraverseContentFn = <
-	C extends WidgetContent | SliceContent,
-	D extends StaticWidget | StaticSlice,
+export type PickOnly<T, K extends keyof T> = Pick<T, K> & {
+	[P in Exclude<keyof T, K>]?: never
+}
+
+export type TraverseSliceContentFn = <
+	S extends SliceItemContent | SharedSliceItemContent,
+	D extends VariationFields | CompositeSliceFields | Group | NestableWidget,
+>({
+	path,
+	key,
+	apiId,
+	model,
+	content,
+}: {
+	path: ContentPath
+	key: string
+	apiId: string
+	model?: D | undefined
+	content: S
+}) => S | SharedSliceItemContent | undefined
+
+export type TraverseWidgetContentFn = <
+	C extends WidgetContent,
+	D extends NestableWidget | StaticSlices | Group | UID,
 >({
 	path,
 	key,
@@ -21,8 +53,10 @@ export type TraverseContentFn = <
 export type ContentPathEntry = {
 	type:
 		| "CustomType"
-		| WidgetContent["__TYPE__"]
-		| SliceContent["__TYPE__"]
+		| "Widget"
+		| "SharedSlice"
+		| "Slice"
+		| "LegacySlice"
 		| "GroupItem"
 		| "primary"
 		| "items"
@@ -36,4 +70,26 @@ export const ContentPath = {
 	serialize(path: ContentPath): string {
 		return path.map((entry) => entry.key).join(PATH_SEPARATOR)
 	},
+	current(path: ContentPath): ContentPathEntry | undefined {
+		return path[path.length - 1]
+	},
+	append(path: string, strElement: string): string {
+		return path + PATH_SEPARATOR + strElement
+	},
+	make(
+		entries: Array<{
+			key?: ContentPathEntry["key"] | undefined
+			type: ContentPathEntry["type"]
+		}>,
+	): ContentPath {
+		return entries.reduce<ContentPath>((acc, { key, type }) => {
+			return key ? acc.concat({ key, type }) : acc
+		}, [])
+	},
 }
+
+export type SliceModel =
+	| VariationFields
+	| NestableWidget
+	| CompositeSliceFields
+	| Group

package/src/content/Document.ts

@@ -3,15 +3,18 @@ import { isLeft, isRight } from "fp-ts/lib/Either"
 import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
-import { type TraverseContentFn, ContentPath } from "../_internal/utils"
-import { WidgetKey } from "../common"
 import {
-	type StaticCustomType,
-	type StaticWidget,
-	flattenStaticWidgets,
-} from "../customtypes"
+	ContentPath,
+	TraverseSliceContentFn,
+	TraverseWidgetContentFn,
+} from "../_internal/utils"
+import { WidgetKey } from "../common"
+import { type StaticWidget, collectSharedSlices } from "../customtypes"
 import {
-	SliceContent,
+	isCompositeSliceItemContent,
+	isSimpleSliceItemContent,
+	migrateCompositeSlice,
+	migrateSimpleSlice,
 	traverseGroupContent,
 	traverseSlices,
 	WidgetContent,
@@ -119,7 +122,13 @@ function extractMetadata(data: { [p: string]: unknown }): {
 	}
 }
 
-function parseLegacyDocument(legacyDoc: unknown): Document | undefined {
+function parseLegacyDocument(
+	legacyDoc: unknown,
+	customType: {
+		customTypeId: string
+		fields: Record<string, StaticWidget>
+	},
+): Document | undefined {
 	const result = pipe(
 		// ensure it's the right document format first
 		t.record(WidgetKey, t.unknown).decode(legacyDoc),
@@ -131,7 +140,7 @@ function parseLegacyDocument(legacyDoc: unknown): Document | undefined {
 		}),
 	)
 
-	return isLeft(result) ? undefined : result.right
+	return isLeft(result) ? undefined : migrateDocument(result.right, customType)
 }
 
 function encodeToLegacyDocument(document: Document): DocumentLegacy {
@@ -153,50 +162,74 @@ export const DocumentLegacy = {
  * @param transform: A user function that provides a way to transform any kind of content wherever it is in a structured Prismic object content.
  * @returns a transformed document with the user's transformation applied with the transform function
  */
-export function traverseDocument(document: Document, model?: StaticCustomType) {
-	return (transform: TraverseContentFn): Document => {
-		const fieldDefs =
+export function traverseDocument({
+	document,
+	model,
+}: {
+	document: Document
+	model?: {
+		customTypeId: string
+		fields: Record<string, StaticWidget>
+	}
+}) {
+	return ({
+		transformWidget = ({ content }) => content,
+		transformSlice = ({ content }) => content,
+	}: {
+		transformWidget?: TraverseWidgetContentFn
+		transformSlice?: TraverseSliceContentFn
+	}): Document => {
+		const fieldModels =
 			model &&
-			flattenStaticWidgets(model).reduce<Record<string, StaticWidget>>(
+			Object.entries(model.fields).reduce<Record<string, StaticWidget>>(
 				(acc, [key, def]) => ({ ...acc, [key]: def }),
 				{},
 			)
 
 		return Object.entries(document).reduce((acc, [key, content]) => {
-			const fieldDef = fieldDefs && fieldDefs[key]
+			const fieldModel = fieldModels && fieldModels[key]
 
-			const path = [{ key, type: content.__TYPE__ }]
-			const transformedWidgetContent = (() => {
+			const path = ContentPath.make([
+				{ key: model?.customTypeId, type: "CustomType" },
+				{ key, type: "Widget" },
+			])
+
+			const transformedWidget = (() => {
 				switch (content.__TYPE__) {
 					case "SliceContentType":
 						return traverseSlices({
 							path,
+							key,
 							model:
-								fieldDef?.type === "Slices" || fieldDef?.type === "Choice"
-									? fieldDef
+								fieldModel?.type === "Slices" || fieldModel?.type === "Choice"
+									? fieldModel
 									: undefined,
 							content,
-						})(transform)
+						})(transformWidget, transformSlice)
 					case "GroupContentType":
 						return traverseGroupContent({
 							path,
-							model: fieldDef?.type === "Group" ? fieldDef : undefined,
+							key,
+							apiId: key,
+							model: fieldModel?.type === "Group" ? fieldModel : undefined,
 							content,
-						})(transform)
+						})(transformWidget)
 					default:
-						return content
+						return transformWidget({
+							path,
+							key,
+							apiId: key,
+							model:
+								fieldModel?.type !== "Group" &&
+								fieldModel?.type !== "Slices" &&
+								fieldModel?.type !== "Choice"
+									? fieldModel
+									: undefined,
+							content,
+						})
 				}
 			})()
 
-			const transformedWidget =
-				transformedWidgetContent &&
-				transform({
-					path,
-					key,
-					apiId: key,
-					model: fieldDef,
-					content: transformedWidgetContent,
-				})
 			return {
 				...acc,
 				...(transformedWidget ? { [key]: transformedWidget } : {}),
@@ -205,26 +238,52 @@ export function traverseDocument(document: Document, model?: StaticCustomType) {
 	}
 }
 
-/**
- * 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
- *
- * @param document parsed prismic content
- * @param is typeguard to match specifically the type of widget we want to collect
- * @returns a record containing the path of the widget as key and the typed collected content as value
- */
-export function collectWidgets<W extends WidgetContent | SliceContent>(
+// /**
+//  * 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
+//  *
+//  * @param document parsed prismic content
+//  * @param is typeguard to match specifically the type of widget we want to collect
+//  * @returns a record containing the path of the widget as key and the typed collected content as value
+//  */
+export function collectWidgets<W extends WidgetContent>(
 	document: Document,
-	is: (
-		content: WidgetContent | SliceContent,
-		path: ContentPath,
-	) => content is W,
+	is: (content: WidgetContent, path: ContentPath) => content is W,
 ): Record<string, W> {
 	const collected: Record<string, W> = {}
 
-	traverseDocument(document)(({ content, path }) => {
-		const key = ContentPath.serialize(path)
-		if (is(content, path)) collected[key] = content
-		return content
+	traverseDocument({ document })({
+		transformWidget: ({ content, path }) => {
+			const key = ContentPath.serialize(path)
+			if (is(content, path)) collected[key] = content
+			return content
+		},
 	})
 	return collected
 }
+
+export function migrateDocument(
+	document: Document,
+	customType: {
+		customTypeId: string
+		fields: Record<string, StaticWidget>
+	},
+) {
+	const needsMigration = Object.values(collectSharedSlices(customType)).some(
+		(slice) => Boolean(slice.legacyPaths),
+	)
+
+	if (!needsMigration) return document
+
+	return traverseDocument({
+		document,
+		model: customType,
+	})({
+		transformSlice: ({ content, model }) => {
+			if (isCompositeSliceItemContent(content) && model?.type === "SharedSlice")
+				return migrateCompositeSlice(model, content)
+			if (isSimpleSliceItemContent(content) && model?.type === "SharedSlice")
+				return migrateSimpleSlice(model, content)
+			return content
+		},
+	})
+}