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

package/lib/content/Document.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectWidgets = exports.traverseDocument = exports.DocumentLegacy = exports.Document = void 0;
+exports.migrateDocument = exports.collectWidgets = exports.traverseDocument = exports.DocumentLegacy = exports.Document = void 0;
 const tslib_1 = require("tslib");
 const fp_ts_1 = require("fp-ts");
 const Either_1 = require("fp-ts/lib/Either");
@@ -72,7 +72,7 @@ function extractMetadata(data) {
         slugs,
     };
 }
-function parseLegacyDocument(legacyDoc) {
+function parseLegacyDocument(legacyDoc, customType) {
     const result = (0, function_1.pipe)(
     // ensure it's the right document format first
     t.record(common_1.WidgetKey, t.unknown).decode(legacyDoc), fp_ts_1.either.chain((doc) => {
@@ -81,7 +81,7 @@ function parseLegacyDocument(legacyDoc) {
         // parse the actual widgets
         return DocumentLegacyCodec(types).decode(widgets);
     }));
-    return (0, Either_1.isLeft)(result) ? undefined : result.right;
+    return (0, Either_1.isLeft)(result) ? undefined : migrateDocument(result.right, customType);
 }
 function encodeToLegacyDocument(document) {
     const encoded = DocumentLegacyCodec().encode(document);
@@ -100,41 +100,49 @@ exports.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
  */
-function traverseDocument(document, model) {
-    return (transform) => {
-        const fieldDefs = model &&
+function traverseDocument({ document, model, }) {
+    return ({ transformWidget = ({ content }) => content, transformSlice = ({ content }) => content, }) => {
+        const fieldModels = model &&
             (0, customtypes_1.flattenStaticWidgets)(model).reduce((acc, [key, def]) => ({ ...acc, [key]: def }), {});
         return Object.entries(document).reduce((acc, [key, content]) => {
-            const fieldDef = fieldDefs && fieldDefs[key];
-            const path = [{ key, type: content.__TYPE__ }];
-            const transformedWidgetContent = (() => {
+            const fieldModel = fieldModels && fieldModels[key];
+            const path = utils_1.ContentPath.make([
+                { key: model === null || model === void 0 ? void 0 : model.id, type: "CustomType" },
+                { key, type: "Widget" },
+            ]);
+            const transformedWidget = (() => {
                 switch (content.__TYPE__) {
                     case "SliceContentType":
                         return (0, fields_1.traverseSlices)({
                             path,
-                            model: (fieldDef === null || fieldDef === void 0 ? void 0 : fieldDef.type) === "Slices" || (fieldDef === null || fieldDef === void 0 ? void 0 : fieldDef.type) === "Choice"
-                                ? fieldDef
+                            key,
+                            model: (fieldModel === null || fieldModel === void 0 ? void 0 : fieldModel.type) === "Slices" || (fieldModel === null || fieldModel === void 0 ? void 0 : fieldModel.type) === "Choice"
+                                ? fieldModel
                                 : undefined,
                             content,
-                        })(transform);
+                        })(transformWidget, transformSlice);
                     case "GroupContentType":
                         return (0, fields_1.traverseGroupContent)({
                             path,
-                            model: (fieldDef === null || fieldDef === void 0 ? void 0 : fieldDef.type) === "Group" ? fieldDef : undefined,
+                            key,
+                            apiId: key,
+                            model: (fieldModel === null || fieldModel === void 0 ? void 0 : fieldModel.type) === "Group" ? fieldModel : undefined,
                             content,
-                        })(transform);
+                        })(transformWidget);
                     default:
-                        return content;
+                        return transformWidget({
+                            path,
+                            key,
+                            apiId: key,
+                            model: (fieldModel === null || fieldModel === void 0 ? void 0 : fieldModel.type) !== "Group" &&
+                                (fieldModel === null || fieldModel === void 0 ? void 0 : fieldModel.type) !== "Slices" &&
+                                (fieldModel === null || fieldModel === void 0 ? void 0 : fieldModel.type) !== "Choice"
+                                ? fieldModel
+                                : undefined,
+                            content,
+                        });
                 }
             })();
-            const transformedWidget = transformedWidgetContent &&
-                transform({
-                    path,
-                    key,
-                    apiId: key,
-                    model: fieldDef,
-                    content: transformedWidgetContent,
-                });
             return {
                 ...acc,
                 ...(transformedWidget ? { [key]: transformedWidget } : {}),
@@ -143,21 +151,108 @@ function traverseDocument(document, model) {
     };
 }
 exports.traverseDocument = traverseDocument;
-/**
- * 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
- */
+// /**
+//  * 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
+//  */
 function collectWidgets(document, is) {
     const collected = {};
-    traverseDocument(document)(({ content, path }) => {
-        const key = utils_1.ContentPath.serialize(path);
-        if (is(content, path))
-            collected[key] = content;
-        return content;
+    traverseDocument({ document })({
+        transformWidget: ({ content, path }) => {
+            const key = utils_1.ContentPath.serialize(path);
+            if (is(content, path))
+                collected[key] = content;
+            return content;
+        },
     });
     return collected;
 }
 exports.collectWidgets = collectWidgets;
+function migrateCompositeSlice(model, content) {
+    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]) => {
+                var _a;
+                return ((_a = model.fields.primary) === null || _a === void 0 ? void 0 : _a[fieldKey])
+                    ? { ...acc, [fieldKey]: fieldContent }
+                    : acc;
+            }, {}),
+            items: content.widget.repeat.map((groupItem) => {
+                return {
+                    __TYPE__: "GroupItemContent",
+                    value: groupItem.value.reduce((acc, [fieldKey, fieldContent]) => {
+                        var _a;
+                        return ((_a = model.fields.items) === null || _a === void 0 ? void 0 : _a[fieldKey])
+                            ? acc.concat([[fieldKey, fieldContent]])
+                            : acc;
+                    }, []),
+                };
+            }, []),
+        },
+    };
+}
+function migrateSimpleSlice(model, content) {
+    var _a;
+    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((acc, [fieldKey, fieldContent]) => {
+                            var _a;
+                            return ((_a = model.fields.items) === null || _a === void 0 ? void 0 : _a[fieldKey])
+                                ? acc.concat([[fieldKey, fieldContent]])
+                                : acc;
+                        }, []),
+                    };
+                }, []),
+            },
+        };
+    }
+    return {
+        key: content.key,
+        name: model.sliceName,
+        maybeLabel: content.maybeLabel,
+        widget: {
+            __TYPE__: "SharedSliceContent",
+            variation: model.variationId,
+            primary: ((_a = model.fields.primary) === null || _a === void 0 ? void 0 : _a[content.name])
+                ? { [content.key]: content.widget }
+                : {},
+            items: [],
+        },
+    };
+}
+function migrateDocument(document, model) {
+    const needsMigration = Object.values((0, customtypes_1.collectSharedSlices)(model)).some((slice) => Boolean(slice.legacyPaths));
+    if (!needsMigration)
+        return document;
+    return traverseDocument({
+        document,
+        model,
+    })({
+        transformSlice: ({ content, model }) => {
+            if ((0, fields_1.isCompositeSliceItemContent)(content) && (model === null || model === void 0 ? void 0 : model.type) === "SharedSlice")
+                return migrateCompositeSlice(model, content);
+            if ((0, fields_1.isSimpleSliceItemContent)(content) && (model === null || model === void 0 ? void 0 : model.type) === "SharedSlice")
+                return migrateSimpleSlice(model, content);
+            return content;
+        },
+    });
+}
+exports.migrateDocument = migrateDocument;

package/lib/content/fields/GroupContent.d.ts

@@ -1,5 +1,5 @@
 import * as t from "io-ts";
-import type { ContentPath, TraverseContentFn } from "../../_internal/utils";
+import type { ContentPath, TraverseWidgetContentFn } from "../../_internal/utils";
 import type { Group, NestableWidget } from "../../customtypes";
 import { LegacyContentCtx, WithTypes } from "../LegacyContentCtx";
 export declare const GroupItemContentType: "GroupItemContent";
@@ -1438,14 +1438,16 @@ export declare const GroupContent: t.ExactC<t.TypeC<{
     }>>>;
 }>>;
 export declare type GroupContent = t.TypeOf<typeof GroupContent>;
-export declare function traverseGroupContent({ path, model, content, }: {
+export declare function traverseGroupContent({ path, key, apiId, model, content, }: {
     path: ContentPath;
+    key: string;
+    apiId: string;
     content: GroupContent;
     model?: Group | undefined;
-}): (transform: TraverseContentFn) => GroupContent;
+}): (transform: TraverseWidgetContentFn) => GroupContent | undefined;
 export declare function traverseGroupItemsContent({ path, model, content, }: {
     path: ContentPath;
     content: Array<GroupItemContent>;
     model?: Record<string, NestableWidget> | undefined;
-}): (transform: TraverseContentFn) => Array<GroupItemContent>;
+}): (transform: TraverseWidgetContentFn) => Array<GroupItemContent>;
 export {};

package/lib/content/fields/GroupContent.js

@@ -81,7 +81,7 @@ exports.GroupContent = t.strict({
     __TYPE__: t.literal(exports.GroupContentType),
     value: t.array(exports.GroupItemContent),
 });
-function traverseGroupContent({ path, model, content, }) {
+function traverseGroupContent({ path, key, apiId, model, content, }) {
     return (transform) => {
         var _a;
         const groupItems = traverseGroupItemsContent({
@@ -89,10 +89,16 @@ function traverseGroupContent({ path, model, content, }) {
             model: (_a = model === null || model === void 0 ? void 0 : model.config) === null || _a === void 0 ? void 0 : _a.fields,
             content: content.value,
         })(transform);
-        return {
-            __TYPE__: content.__TYPE__,
-            value: groupItems,
-        };
+        return transform({
+            path,
+            key,
+            apiId,
+            model,
+            content: {
+                __TYPE__: content.__TYPE__,
+                value: groupItems,
+            },
+        });
     };
 }
 exports.traverseGroupContent = traverseGroupContent;
@@ -105,16 +111,14 @@ function traverseGroupItemsContent({ path, model, content, }) {
             const groupItemFields = groupItem.value.reduce((acc, [fieldKey, fieldContent]) => {
                 const fieldDef = model === null || model === void 0 ? void 0 : model[fieldKey];
                 const transformedField = transform({
-                    path: groupItemPath.concat([
-                        { key: fieldKey, type: fieldContent.__TYPE__ },
-                    ]),
+                    path: groupItemPath.concat([{ key: fieldKey, type: "Widget" }]),
                     key: fieldKey,
                     apiId: fieldKey,
                     model: fieldDef,
                     content: fieldContent,
                 });
                 // Can happen if the transform function returns undefined to filter out a field
-                if (!transformedField)
+                if (!transformedField || !(0, nestable_1.isNestableContent)(transformedField))
                     return acc;
                 return acc.concat([[fieldKey, transformedField]]);
             }, []);

package/lib/content/fields/slices/Slice/CompositeSliceContent.d.ts

@@ -1,7 +1,8 @@
 import * as t from "io-ts";
-import type { ContentPath, TraverseContentFn } from "../../../../_internal/utils";
-import type { CompositeSlice } from "../../../../customtypes";
+import type { ContentPath, TraverseSliceContentFn, TraverseWidgetContentFn } from "../../../../_internal/utils";
+import type { CompositeSliceFields, VariationFields } from "../../../../customtypes";
 import { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
+import type { CompositeSliceItemContent, SharedSliceItemContent } from "../SliceItem";
 export declare const CompositeSliceContentType = "CompositeSliceContent";
 export declare const isCompositeSliceContent: (u: unknown) => u is {
     __TYPE__: "CompositeSliceContent";
@@ -1701,9 +1702,10 @@ export declare const CompositeSliceContent: t.ExactC<t.TypeC<{
     }>>>;
 }>>;
 export declare type CompositeSliceContent = t.TypeOf<typeof CompositeSliceContent>;
-export declare function traverseCompositeSliceContent({ path, sliceName, model, content, }: {
+export declare function traverseCompositeSliceContent({ path, sliceKey, sliceName, model, content, }: {
     path: ContentPath;
+    sliceKey: string;
     sliceName: string;
-    content: CompositeSliceContent;
-    model?: CompositeSlice | undefined;
-}): (transform: TraverseContentFn) => CompositeSliceContent;
+    content: CompositeSliceItemContent;
+    model?: VariationFields | CompositeSliceFields | undefined;
+}): (transformWidget: TraverseWidgetContentFn, transformSlice: TraverseSliceContentFn) => SharedSliceItemContent | CompositeSliceItemContent | undefined;

package/lib/content/fields/slices/Slice/CompositeSliceContent.js

@@ -80,15 +80,19 @@ exports.CompositeSliceContent = t.strict({
     nonRepeat: t.record(t.string, nestable_1.NestableContent),
     repeat: RepeatableContent_1.RepeatableWidgets,
 });
-function traverseCompositeSliceContent({ path, sliceName, model, content, }) {
-    return (transform) => {
-        const primary = Object.entries(content.nonRepeat).reduce((acc, [fieldKey, fieldContent]) => {
-            var _a;
-            const fieldDef = (_a = model === null || model === void 0 ? void 0 : model["non-repeat"]) === null || _a === void 0 ? void 0 : _a[fieldKey];
-            const transformedField = transform({
+function traverseCompositeSliceContent({ path, sliceKey, sliceName, model, content, }) {
+    return (transformWidget, transformSlice) => {
+        const primary = Object.entries(content.widget.nonRepeat).reduce((acc, [fieldKey, fieldContent]) => {
+            const fieldDef = (() => {
+                var _a, _b, _c, _d;
+                return (model === null || model === void 0 ? void 0 : model.type) === "SharedSlice"
+                    ? (_b = (_a = model === null || model === void 0 ? void 0 : model.fields) === null || _a === void 0 ? void 0 : _a.primary) === null || _b === void 0 ? void 0 : _b[fieldKey]
+                    : (_d = (_c = model === null || model === void 0 ? void 0 : model.fields) === null || _c === void 0 ? void 0 : _c.repeat) === null || _d === void 0 ? void 0 : _d[fieldKey];
+            })();
+            const transformedField = transformWidget({
                 path: path.concat([
                     { key: "non-repeat", type: "primary" },
-                    { key: fieldKey, type: fieldContent.__TYPE__ },
+                    { key: fieldKey, type: "Widget" },
                 ]),
                 key: fieldKey,
                 apiId: sliceName,
@@ -96,7 +100,7 @@ function traverseCompositeSliceContent({ path, sliceName, model, content, }) {
                 content: fieldContent,
             });
             // Can happen if the transform function returns undefined to filter out a field
-            if (!transformedField)
+            if (!transformedField || !(0, nestable_1.isNestableContent)(transformedField))
                 return acc;
             return {
                 ...acc,
@@ -105,14 +109,25 @@ function traverseCompositeSliceContent({ path, sliceName, model, content, }) {
         }, {});
         const items = (0, GroupContent_1.traverseGroupItemsContent)({
             path: path.concat([{ key: "repeat", type: "items" }]),
-            model: model === null || model === void 0 ? void 0 : model.repeat,
-            content: content.repeat,
-        })(transform);
-        return {
-            __TYPE__: content.__TYPE__,
-            repeat: items,
-            nonRepeat: primary,
-        };
+            model: (model === null || model === void 0 ? void 0 : model.type) === "SharedSlice"
+                ? model === null || model === void 0 ? void 0 : model.fields.items
+                : model === null || model === void 0 ? void 0 : model.fields.repeat,
+            content: content.widget.repeat,
+        })(transformWidget);
+        return transformSlice({
+            key: sliceKey,
+            apiId: sliceName,
+            path,
+            model,
+            content: {
+                ...content,
+                widget: {
+                    __TYPE__: "CompositeSliceContent",
+                    repeat: items,
+                    nonRepeat: primary,
+                },
+            },
+        });
     };
 }
 exports.traverseCompositeSliceContent = traverseCompositeSliceContent;

package/lib/content/fields/slices/Slice/SharedSliceContent.d.ts

@@ -1,7 +1,8 @@
 import * as t from "io-ts";
-import type { ContentPath, TraverseContentFn } from "../../../../_internal/utils";
-import type { SharedSlice } from "../../../../customtypes";
+import type { ContentPath, TraverseSliceContentFn, TraverseWidgetContentFn } from "../../../../_internal/utils";
+import type { VariationFields } from "../../../../customtypes";
 import { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
+import type { SharedSliceItemContent } from "../SliceItem";
 export declare const SharedSliceContentType = "SharedSliceContent";
 export declare const isSharedSliceContent: (u: unknown) => u is {
     __TYPE__: "SharedSliceContent";
@@ -1705,9 +1706,10 @@ export declare const SharedSliceContent: t.ExactC<t.TypeC<{
     }>>>;
 }>>;
 export declare type SharedSliceContent = t.TypeOf<typeof SharedSliceContent>;
-export declare function traverseSharedSliceContent({ path, sliceName, model, content, }: {
+export declare function traverseSharedSliceContent({ path, sliceKey, sliceName, model, content, }: {
     path: ContentPath;
+    sliceKey: string;
     sliceName: string;
-    content: SharedSliceContent;
-    model?: SharedSlice | undefined;
-}): (transform: TraverseContentFn) => SharedSliceContent;
+    content: SharedSliceItemContent;
+    model?: VariationFields | undefined;
+}): (transformWidget: TraverseWidgetContentFn, transformSlice: TraverseSliceContentFn) => SharedSliceItemContent | undefined;

package/lib/content/fields/slices/Slice/SharedSliceContent.js

@@ -97,16 +97,15 @@ exports.SharedSliceContent = t.strict({
     primary: t.record(t.string, nestable_1.NestableContent),
     items: RepeatableContent_1.RepeatableWidgets,
 });
-function traverseSharedSliceContent({ path, sliceName, model, content, }) {
-    return (transform) => {
-        const variationDef = model === null || model === void 0 ? void 0 : model.variations.find((v) => v.id === content.variation);
-        const primary = Object.entries(content.primary).reduce((acc, [fieldKey, fieldContent]) => {
-            var _a;
-            const fieldDef = variationDef && ((_a = variationDef.primary) === null || _a === void 0 ? void 0 : _a[fieldKey]);
-            const transformedField = transform({
+function traverseSharedSliceContent({ path, sliceKey, sliceName, model, content, }) {
+    return (transformWidget, transformSlice) => {
+        const primary = Object.entries(content.widget.primary).reduce((acc, [fieldKey, fieldContent]) => {
+            var _a, _b;
+            const fieldDef = (_b = (_a = model === null || model === void 0 ? void 0 : model.fields) === null || _a === void 0 ? void 0 : _a.primary) === null || _b === void 0 ? void 0 : _b[fieldKey];
+            const transformedField = transformWidget({
                 path: path.concat([
                     { key: "primary", type: "primary" },
-                    { key: fieldKey, type: fieldContent.__TYPE__ },
+                    { key: fieldKey, type: "Widget" },
                 ]),
                 key: fieldKey,
                 apiId: sliceName,
@@ -114,7 +113,7 @@ function traverseSharedSliceContent({ path, sliceName, model, content, }) {
                 content: fieldContent,
             });
             // Can happen if the transform function returns undefined to filter out a field
-            if (!transformedField)
+            if (!transformedField || !(0, nestable_1.isNestableContent)(transformedField))
                 return acc;
             return {
                 ...acc,
@@ -123,15 +122,24 @@ function traverseSharedSliceContent({ path, sliceName, model, content, }) {
         }, {});
         const items = (0, GroupContent_1.traverseGroupItemsContent)({
             path: path.concat([{ key: "items", type: "items" }]),
-            model: variationDef === null || variationDef === void 0 ? void 0 : variationDef.items,
-            content: content.items,
-        })(transform);
-        return {
-            __TYPE__: content.__TYPE__,
-            variation: content.variation,
-            primary,
-            items,
-        };
+            model: model === null || model === void 0 ? void 0 : model.fields.items,
+            content: content.widget.items,
+        })(transformWidget);
+        return transformSlice({
+            key: sliceKey,
+            apiId: sliceName,
+            path,
+            model: model,
+            content: {
+                ...content,
+                widget: {
+                    __TYPE__: "SharedSliceContent",
+                    variation: content.widget.variation,
+                    primary,
+                    items,
+                },
+            },
+        });
     };
 }
 exports.traverseSharedSliceContent = traverseSharedSliceContent;

package/lib/content/fields/slices/Slice/SimpleSliceContent.d.ts

@@ -1,5 +1,8 @@
 import * as t from "io-ts";
+import type { ContentPath, TraverseSliceContentFn, TraverseWidgetContentFn } from "../../../../_internal/utils";
+import type { Group, NestableWidget, VariationFields } from "../../../../customtypes";
 import type { LegacyContentCtx } from "../../../LegacyContentCtx";
+import type { SharedSliceItemContent, SimpleSliceItemContent } from "../SliceItem";
 export declare const SimpleSliceContent: t.UnionC<[t.UnionC<[t.ExactC<t.TypeC<{
     type: t.StringC;
     __TYPE__: t.LiteralC<"EmptyContent">;
@@ -1689,3 +1692,10 @@ export declare const SimpleSliceLegacy: (ctx: LegacyContentCtx) => {
     }>);
     encode: (value: SimpleSliceContent) => import("../../../LegacyContentCtx").WithTypes<unknown> | undefined;
 };
+export declare function traverseSimpleSliceContent({ path, sliceKey, sliceName, model, content, }: {
+    path: ContentPath;
+    sliceKey: string;
+    sliceName: string;
+    content: SimpleSliceItemContent;
+    model?: VariationFields | Group | NestableWidget | undefined;
+}): (transformWidget: TraverseWidgetContentFn, transformSlice: TraverseSliceContentFn) => SharedSliceItemContent | SimpleSliceItemContent | undefined;

package/lib/content/fields/slices/Slice/SimpleSliceContent.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimpleSliceLegacy = exports.isSimpleSliceContent = exports.SimpleSliceContent = void 0;
+exports.traverseSimpleSliceContent = exports.SimpleSliceLegacy = exports.isSimpleSliceContent = exports.SimpleSliceContent = void 0;
 const tslib_1 = require("tslib");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const GroupContent_1 = require("../../GroupContent");
@@ -26,3 +26,62 @@ const SimpleSliceLegacy = (ctx) => {
     };
 };
 exports.SimpleSliceLegacy = SimpleSliceLegacy;
+function traverseSimpleSliceContent({ path, sliceKey, sliceName, model, content, }) {
+    return (transformWidget, transformSlice) => {
+        if ((0, GroupContent_1.isGroupContent)(content.widget)) {
+            const convertedGroupWidget = (0, GroupContent_1.traverseGroupContent)({
+                path,
+                key: content.key,
+                apiId: content.name,
+                model: (() => {
+                    if ((model === null || model === void 0 ? void 0 : model.type) === "Group")
+                        return model;
+                    if ((model === null || model === void 0 ? void 0 : model.type) === "SharedSlice")
+                        return {
+                            type: "Group",
+                            config: { fields: model.fields.items || {} },
+                        };
+                    return;
+                })(),
+                content: content.widget,
+            })(transformWidget);
+            return (convertedGroupWidget &&
+                transformSlice({
+                    key: content.key,
+                    apiId: content.name,
+                    path,
+                    model,
+                    content: {
+                        ...content,
+                        widget: convertedGroupWidget,
+                    },
+                }));
+        }
+        const convertedNestable = transformWidget({
+            key: content.key,
+            apiId: content.name,
+            path,
+            model: (() => {
+                var _a;
+                if ((model === null || model === void 0 ? void 0 : model.type) === "SharedSlice")
+                    return (_a = model.fields.primary) === null || _a === void 0 ? void 0 : _a[content.name];
+                if ((model === null || model === void 0 ? void 0 : model.type) !== "Group")
+                    return model;
+                return;
+            })(),
+            content: content.widget,
+        });
+        return (convertedNestable &&
+            transformSlice({
+                key: sliceKey,
+                apiId: sliceName,
+                path,
+                model,
+                content: {
+                    ...content,
+                    widget: convertedNestable,
+                },
+            }));
+    };
+}
+exports.traverseSimpleSliceContent = traverseSimpleSliceContent;

package/lib/content/fields/slices/SliceItem.d.ts

@@ -1,5 +1,8 @@
 import * as t from "io-ts";
 import { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx";
+import { CompositeSliceContent } from "./Slice/CompositeSliceContent";
+import { SharedSliceContent } from "./Slice/SharedSliceContent";
+import { SimpleSliceContent } from "./Slice/SimpleSliceContent";
 export declare const SliceItemContent: t.TypeC<{
     key: t.StringC;
     name: t.StringC;
@@ -1828,6 +1831,18 @@ export declare const SliceItemContent: t.TypeC<{
     }>>]>]>;
 }>;
 export declare type SliceItemContent = t.TypeOf<typeof SliceItemContent>;
+export declare type SharedSliceItemContent = Omit<SliceItemContent, "widget"> & {
+    widget: SharedSliceContent;
+};
+export declare function isSharedSliceItemContent(item: SliceItemContent): item is SharedSliceItemContent;
+export declare type CompositeSliceItemContent = Omit<SliceItemContent, "widget"> & {
+    widget: CompositeSliceContent;
+};
+export declare function isCompositeSliceItemContent(item: SliceItemContent): item is CompositeSliceItemContent;
+export declare type SimpleSliceItemContent = Omit<SliceItemContent, "widget"> & {
+    widget: SimpleSliceContent;
+};
+export declare function isSimpleSliceItemContent(item: SliceItemContent): item is SimpleSliceItemContent;
 export declare const SlicesItemLegacy: (ctx: LegacyContentCtx) => t.Type<{
     key: string;
     name: string;

package/lib/content/fields/slices/SliceItem.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SlicesItemLegacy = exports.SliceItemContent = void 0;
+exports.SlicesItemLegacy = exports.isSimpleSliceItemContent = exports.isCompositeSliceItemContent = exports.isSharedSliceItemContent = exports.SliceItemContent = void 0;
 const tslib_1 = require("tslib");
 const fp_ts_1 = require("fp-ts");
 const Either_1 = require("fp-ts/lib/Either");
@@ -8,6 +8,8 @@ const function_1 = require("fp-ts/lib/function");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const function_2 = require("../../../validators/function");
 const LegacyContentCtx_1 = require("../../LegacyContentCtx");
+const GroupContent_1 = require("../GroupContent");
+const nestable_1 = require("../nestable");
 const Slice_1 = require("./Slice");
 const CompositeSliceContent_1 = require("./Slice/CompositeSliceContent");
 const SharedSliceContent_1 = require("./Slice/SharedSliceContent");
@@ -18,6 +20,18 @@ exports.SliceItemContent = t.type({
     maybeLabel: t.union([t.string, t.undefined]),
     widget: Slice_1.SliceContent,
 });
+function isSharedSliceItemContent(item) {
+    return (0, SharedSliceContent_1.isSharedSliceContent)(item.widget);
+}
+exports.isSharedSliceItemContent = isSharedSliceItemContent;
+function isCompositeSliceItemContent(item) {
+    return (0, CompositeSliceContent_1.isCompositeSliceContent)(item.widget);
+}
+exports.isCompositeSliceItemContent = isCompositeSliceItemContent;
+function isSimpleSliceItemContent(item) {
+    return (0, GroupContent_1.isGroupContent)(item.widget) || (0, nestable_1.isNestableContent)(item.widget);
+}
+exports.isSimpleSliceItemContent = isSimpleSliceItemContent;
 const itemLegacyReader = t.exact(t.intersection([
     t.type({
         key: t.string,