@prismicio/types-internal 2.2.0-traverse.alpha-0 → 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,6 +1,6 @@
 import * as t from "io-ts";
-import type { ContentPath, TraverseContentFn } from "../../_internal/utils";
-import type { Group } from "../../customtypes";
+import type { ContentPath, TraverseWidgetContentFn } from "../../_internal/utils";
+import type { Group, NestableWidget } from "../../customtypes";
 import { LegacyContentCtx, WithTypes } from "../LegacyContentCtx";
 export declare const GroupItemContentType: "GroupItemContent";
 export declare const GroupItemContent: t.ExactC<t.TypeC<{
@@ -1438,9 +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 | undefined;
+}): (transform: TraverseWidgetContentFn) => GroupContent | undefined;
+export declare function traverseGroupItemsContent({ path, model, content, }: {
+    path: ContentPath;
+    content: Array<GroupItemContent>;
+    model?: Record<string, NestableWidget> | undefined;
+}): (transform: TraverseWidgetContentFn) => Array<GroupItemContent>;
 export {};

package/lib/content/fields/GroupContent.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.traverseGroupContent = exports.GroupContent = exports.isGroupContent = exports.GroupContentType = exports.GroupLegacy = exports.GroupItemLegacy = exports.GroupItemContent = exports.GroupItemContentType = void 0;
+exports.traverseGroupItemsContent = exports.traverseGroupContent = exports.GroupContent = exports.isGroupContent = exports.GroupContentType = exports.GroupLegacy = exports.GroupItemLegacy = exports.GroupItemContent = exports.GroupItemContentType = void 0;
 const tslib_1 = require("tslib");
 const fp_ts_1 = require("fp-ts");
 const Either_1 = require("fp-ts/lib/Either");
@@ -81,24 +81,44 @@ 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) => {
-        const groupItems = content.value.map((groupItem, index) => {
+        var _a;
+        const groupItems = traverseGroupItemsContent({
+            path,
+            model: (_a = model === null || model === void 0 ? void 0 : model.config) === null || _a === void 0 ? void 0 : _a.fields,
+            content: content.value,
+        })(transform);
+        return transform({
+            path,
+            key,
+            apiId,
+            model,
+            content: {
+                __TYPE__: content.__TYPE__,
+                value: groupItems,
+            },
+        });
+    };
+}
+exports.traverseGroupContent = traverseGroupContent;
+function traverseGroupItemsContent({ path, model, content, }) {
+    return (transform) => {
+        return content.map((groupItem, index) => {
+            const groupItemPath = path.concat([
+                { key: index.toString(), type: "GroupItem" },
+            ]);
             const groupItemFields = groupItem.value.reduce((acc, [fieldKey, fieldContent]) => {
-                var _a, _b;
-                const fieldDef = (_b = (_a = model === null || model === void 0 ? void 0 : model.config) === null || _a === void 0 ? void 0 : _a.fields) === null || _b === void 0 ? void 0 : _b[fieldKey];
+                const fieldDef = model === null || model === void 0 ? void 0 : model[fieldKey];
                 const transformedField = transform({
-                    path: path.concat([
-                        { key: index.toString(), type: "GroupItem" },
-                        { 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]]);
             }, []);
@@ -107,10 +127,6 @@ function traverseGroupContent({ path, model, content, }) {
                 value: groupItemFields,
             };
         });
-        return {
-            __TYPE__: content.__TYPE__,
-            value: groupItems,
-        };
     };
 }
-exports.traverseGroupContent = traverseGroupContent;
+exports.traverseGroupItemsContent = traverseGroupItemsContent;

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 | undefined;
+    content: CompositeSliceItemContent;
+    model?: VariationFields | CompositeSliceFields | undefined;
+}): (transformWidget: TraverseWidgetContentFn, transformSlice: TraverseSliceContentFn) => SharedSliceItemContent | CompositeSliceItemContent | undefined;

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

@@ -8,6 +8,7 @@ const function_1 = require("fp-ts/lib/function");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const LegacyContentCtx_1 = require("../../../LegacyContentCtx");
 const utils_1 = require("../../../utils");
+const GroupContent_1 = require("../../GroupContent");
 const nestable_1 = require("../../nestable");
 const RepeatableContent_1 = require("./RepeatableContent");
 exports.CompositeSliceContentType = "CompositeSliceContent";
@@ -79,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,
@@ -95,42 +100,34 @@ 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,
                 [fieldKey]: transformedField,
             };
         }, {});
-        const items = content.repeat.map((itemBlock) => {
-            const itemBlockFields = itemBlock.value.reduce((acc, [fieldKey, fieldContent]) => {
-                var _a;
-                const fieldDef = (_a = model === null || model === void 0 ? void 0 : model.repeat) === null || _a === void 0 ? void 0 : _a[fieldKey];
-                const transformedField = transform({
-                    path: path.concat([
-                        { key: "repeat", type: "items" },
-                        { key: fieldKey, type: fieldContent.__TYPE__ },
-                    ]),
-                    key: fieldKey,
-                    apiId: sliceName,
-                    model: fieldDef,
-                    content: fieldContent,
-                });
-                // Can happen if the transform function returns undefined to filter out a field
-                if (!transformedField)
-                    return acc;
-                return acc.concat([[fieldKey, transformedField]]);
-            }, []);
-            return {
-                __TYPE__: itemBlock.__TYPE__,
-                value: itemBlockFields,
-            };
+        const items = (0, GroupContent_1.traverseGroupItemsContent)({
+            path: path.concat([{ key: "repeat", type: "items" }]),
+            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,
+                },
+            },
         });
-        return {
-            __TYPE__: content.__TYPE__,
-            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 | undefined;
+    content: SharedSliceItemContent;
+    model?: VariationFields | undefined;
+}): (transformWidget: TraverseWidgetContentFn, transformSlice: TraverseSliceContentFn) => SharedSliceItemContent | undefined;

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

@@ -9,6 +9,7 @@ const t = (0, tslib_1.__importStar)(require("io-ts"));
 const io_ts_types_1 = require("io-ts-types");
 const LegacyContentCtx_1 = require("../../../LegacyContentCtx");
 const utils_1 = require("../../../utils");
+const GroupContent_1 = require("../../GroupContent");
 const nestable_1 = require("../../nestable");
 const RepeatableContent_1 = require("./RepeatableContent");
 exports.SharedSliceContentType = "SharedSliceContent";
@@ -96,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,
@@ -113,43 +113,33 @@ 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,
                 [fieldKey]: transformedField,
             };
         }, {});
-        const items = content.items.map((itemBlock) => {
-            const itemBlockFields = itemBlock.value.reduce((acc, [fieldKey, fieldContent]) => {
-                var _a;
-                const fieldDef = variationDef && ((_a = variationDef.items) === null || _a === void 0 ? void 0 : _a[fieldKey]);
-                const transformedField = transform({
-                    path: path.concat([
-                        { key: "items", type: "items" },
-                        { key: fieldKey, type: fieldContent.__TYPE__ },
-                    ]),
-                    key: fieldKey,
-                    apiId: sliceName,
-                    model: fieldDef,
-                    content: fieldContent,
-                });
-                // Can happen if the transform function returns undefined to filter out a field
-                if (!transformedField)
-                    return acc;
-                return acc.concat([[fieldKey, transformedField]]);
-            }, []);
-            return {
-                __TYPE__: itemBlock.__TYPE__,
-                value: itemBlockFields,
-            };
+        const items = (0, GroupContent_1.traverseGroupItemsContent)({
+            path: path.concat([{ key: "items", type: "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,
+                },
+            },
         });
-        return {
-            __TYPE__: content.__TYPE__,
-            variation: content.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;