@prismicio/types-internal 2.2.0-alpha.9 → 2.2.0-traverse.alpha-0

package/lib/_internal/utils.d.ts

@@ -0,0 +1,17 @@
+import type { SliceContent, WidgetContent } from "../content";
+import type { StaticSlice, StaticWidget } from "../customtypes";
+export declare type TraverseContentFn = <C extends WidgetContent | SliceContent, D extends StaticWidget | StaticSlice>({ path, key, apiId, model, content, }: {
+    path: ContentPath;
+    key: string;
+    apiId: string;
+    model?: D | undefined;
+    content: C;
+}) => C | undefined;
+export declare type ContentPathEntry = {
+    type: "CustomType" | WidgetContent["__TYPE__"] | SliceContent["__TYPE__"] | "GroupItem" | "primary" | "items";
+    key: string;
+};
+export declare type ContentPath = ReadonlyArray<ContentPathEntry>;
+export declare const ContentPath: {
+    serialize(path: ContentPath): string;
+};

package/lib/_internal/utils.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentPath = void 0;
+const PATH_SEPARATOR = "::";
+exports.ContentPath = {
+    serialize(path) {
+        return path.map((entry) => entry.key).join(PATH_SEPARATOR);
+    },
+};

package/lib/common/Asset.d.ts

@@ -1,11 +1,10 @@
-export declare type AssetId = string;
 export declare type Asset = {
-    id: AssetId;
+    id: string;
     last_modified: string;
     kind: "image" | "all";
     filename?: string;
     extension?: string;
-    size?: string;
+    size?: number;
     origin_url: string;
     url: string;
     width?: number;
@@ -14,4 +13,4 @@ export declare type Asset = {
     credits?: string;
     alt?: string;
 };
-export declare const getAssetOrThrow: (assets: Record<AssetId, Asset>) => (assetId: AssetId) => Asset;
+export declare const getAssetOrThrow: (assets: Record<Asset["id"], Asset | undefined>) => (assetId: Asset["id"]) => Asset;

package/lib/common/Embed.d.ts

@@ -12,5 +12,4 @@ export declare type Embed = {
     html?: string | null;
     title?: string | null;
 };
-export declare type EmbedUrl = string;
-export declare const getEmbedOrThrow: (embeds: Record<string, Embed>) => (embedUrl: string) => Embed;
+export declare const getEmbedOrThrow: (embeds: Record<string, Embed | undefined>) => (embedUrl: string) => Embed;

package/lib/common/UUID.d.ts

@@ -0,0 +1,7 @@
+import * as t from "io-ts";
+interface UUIDBrand {
+    readonly UUID: unique symbol;
+}
+export declare const UUID: t.BrandC<t.StringC, UUIDBrand>;
+export declare type UUID = t.TypeOf<typeof UUID>;
+export {};

package/lib/common/UUID.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UUID = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const uuid_1 = require("uuid");
+const function_1 = require("../validators/function");
+exports.UUID = (0, function_1.withCustomError)(t.brand(t.string, (s) => (0, uuid_1.validate)(s), "UUID"), () => "The value must be a valid UUID");

package/lib/common/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./Asset";
+export * from "./Embed";
 export * from "./WidgetKey";

package/lib/common/index.js

@@ -2,4 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 (0, tslib_1.__exportStar)(require("./Asset"), exports);
+(0, tslib_1.__exportStar)(require("./Embed"), exports);
 (0, tslib_1.__exportStar)(require("./WidgetKey"), exports);

package/lib/content/Document.d.ts

@@ -1,5 +1,8 @@
 import * as t from "io-ts";
+import { type TraverseContentFn, ContentPath } from "../_internal/utils";
 import { WidgetKey } from "../common";
+import { type StaticCustomType } from "../customtypes";
+import { SliceContent, WidgetContent } from "./fields";
 import { FieldOrSliceType, WithTypes } from "./LegacyContentCtx";
 export declare const Document: t.RecordC<t.Type<string, string, unknown>, t.UnionC<[t.ExactC<t.TypeC<{
     __TYPE__: t.LiteralC<"GroupContentType">;
@@ -2993,6 +2996,9 @@ export declare const DocumentLegacy: {
                     __TYPE__: "SeparatorContent";
                 }][];
             }[];
+        } | {
+            __TYPE__: "UIDContent";
+            value: string;
         } | {
             __TYPE__: "SliceContentType";
             value: {
@@ -4622,9 +4628,6 @@ export declare const DocumentLegacy: {
                     }[];
                 };
             }[];
-        } | {
-            __TYPE__: "UIDContent";
-            value: string;
         };
     }, WithTypes<{
         [x: string]: unknown;
@@ -4633,4 +4636,20 @@ export declare const DocumentLegacy: {
     parse: typeof parseLegacyDocument;
     encode: typeof encodeToLegacyDocument;
 };
+/**
+ *
+ * @param model: can be optional if we simply want to loop through the content without any consideration for the attached model
+ * @param document: The content we actually want to iterate on in an immutable fashion
+ * @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 declare function traverseDocument(document: Document, model?: StaticCustomType): (transform: TraverseContentFn) => Document;
+/**
+ * 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 declare function collectWidgets<W extends WidgetContent | SliceContent>(document: Document, is: (content: WidgetContent | SliceContent, path: ContentPath) => content is W): Record<string, W>;
 export {};

package/lib/content/Document.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DocumentLegacy = exports.Document = void 0;
+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");
 const function_1 = require("fp-ts/lib/function");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
+const utils_1 = require("../_internal/utils");
 const common_1 = require("../common");
+const customtypes_1 = require("../customtypes");
 const fields_1 = require("./fields");
 const LegacyContentCtx_1 = require("./LegacyContentCtx");
 exports.Document = t.record(common_1.WidgetKey, fields_1.WidgetContent);
@@ -91,3 +93,71 @@ exports.DocumentLegacy = {
     parse: parseLegacyDocument,
     encode: encodeToLegacyDocument,
 };
+/**
+ *
+ * @param model: can be optional if we simply want to loop through the content without any consideration for the attached model
+ * @param document: The content we actually want to iterate on in an immutable fashion
+ * @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 &&
+            (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 = (() => {
+                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
+                                : undefined,
+                            content,
+                        })(transform);
+                    case "GroupContentType":
+                        return (0, fields_1.traverseGroupContent)({
+                            path,
+                            model: (fieldDef === null || fieldDef === void 0 ? void 0 : fieldDef.type) === "Group" ? fieldDef : undefined,
+                            content,
+                        })(transform);
+                    default:
+                        return content;
+                }
+            })();
+            const transformedWidget = transformedWidgetContent &&
+                transform({
+                    path,
+                    key,
+                    apiId: key,
+                    model: fieldDef,
+                    content: transformedWidgetContent,
+                });
+            return {
+                ...acc,
+                ...(transformedWidget ? { [key]: transformedWidget } : {}),
+            };
+        }, {});
+    };
+}
+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
+ */
+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;
+    });
+    return collected;
+}
+exports.collectWidgets = collectWidgets;

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

@@ -1,4 +1,6 @@
 import * as t from "io-ts";
+import type { ContentPath, TraverseContentFn } from "../../_internal/utils";
+import type { Group } from "../../customtypes";
 import { LegacyContentCtx, WithTypes } from "../LegacyContentCtx";
 export declare const GroupItemContentType: "GroupItemContent";
 export declare const GroupItemContent: t.ExactC<t.TypeC<{
@@ -1436,4 +1438,9 @@ export declare const GroupContent: t.ExactC<t.TypeC<{
     }>>>;
 }>>;
 export declare type GroupContent = t.TypeOf<typeof GroupContent>;
+export declare function traverseGroupContent({ path, model, content, }: {
+    path: ContentPath;
+    content: GroupContent;
+    model?: Group | undefined;
+}): (transform: TraverseContentFn) => GroupContent | undefined;
 export {};

package/lib/content/fields/GroupContent.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GroupContent = exports.isGroupContent = exports.GroupContentType = exports.GroupLegacy = exports.GroupItemLegacy = exports.GroupItemContent = exports.GroupItemContentType = void 0;
+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,3 +81,36 @@ exports.GroupContent = t.strict({
     __TYPE__: t.literal(exports.GroupContentType),
     value: t.array(exports.GroupItemContent),
 });
+function traverseGroupContent({ path, model, content, }) {
+    return (transform) => {
+        const groupItems = content.value.map((groupItem, index) => {
+            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 transformedField = transform({
+                    path: path.concat([
+                        { key: index.toString(), type: "GroupItem" },
+                        { key: fieldKey, type: fieldContent.__TYPE__ },
+                    ]),
+                    key: fieldKey,
+                    apiId: fieldKey,
+                    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__: groupItem.__TYPE__,
+                value: groupItemFields,
+            };
+        });
+        return {
+            __TYPE__: content.__TYPE__,
+            value: groupItems,
+        };
+    };
+}
+exports.traverseGroupContent = traverseGroupContent;

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

@@ -2977,6 +2977,9 @@ export declare const isWidgetContent: (u: unknown) => u is {
             __TYPE__: "SeparatorContent";
         }][];
     }[];
+} | {
+    __TYPE__: "UIDContent";
+    value: string;
 } | {
     __TYPE__: "SliceContentType";
     value: {
@@ -4606,9 +4609,6 @@ export declare const isWidgetContent: (u: unknown) => u is {
             }[];
         };
     }[];
-} | {
-    __TYPE__: "UIDContent";
-    value: string;
 };
 export declare type WidgetContent = t.TypeOf<typeof WidgetContent>;
 export declare type ContentType = WidgetContent["__TYPE__"];
@@ -5151,6 +5151,9 @@ export declare const WidgetLegacy: (ctx: LegacyContentCtx) => {
                 __TYPE__: "SeparatorContent";
             }][];
         }[];
+    }> | import("fp-ts/lib/Either").Right<{
+        __TYPE__: "UIDContent";
+        value: string;
     }> | import("fp-ts/lib/Either").Right<{
         __TYPE__: "SliceContentType";
         value: {
@@ -6780,9 +6783,6 @@ export declare const WidgetLegacy: (ctx: LegacyContentCtx) => {
                 }[];
             };
         }[];
-    }> | import("fp-ts/lib/Either").Right<{
-        __TYPE__: "UIDContent";
-        value: string;
     }> | undefined;
     encode(value: WidgetContent): import("../LegacyContentCtx").WithTypes<unknown> | undefined;
 };

package/lib/content/fields/nestable/NestableContent.d.ts

@@ -1,4 +1,5 @@
 import * as t from "io-ts";
+import type { NestableWidget } from "../../../customtypes";
 import type { LegacyContentCtx } from "../../LegacyContentCtx";
 export declare const NestableContent: t.UnionC<[t.ExactC<t.TypeC<{
     type: t.StringC;
@@ -840,3 +841,4 @@ export declare const NestableLegacy: (ctx: LegacyContentCtx) => {
     }> | undefined;
     encode(value: NestableContent): import("../../LegacyContentCtx").WithTypes<unknown> | undefined;
 };
+export declare function isValidStaticNestableContent(content: NestableContent, model?: NestableWidget): boolean;

package/lib/content/fields/nestable/NestableContent.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NestableLegacy = exports.isNestableContent = exports.NestableContent = void 0;
+exports.isValidStaticNestableContent = exports.NestableLegacy = exports.isNestableContent = exports.NestableContent = void 0;
 const tslib_1 = require("tslib");
 const Either_1 = require("fp-ts/lib/Either");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
@@ -140,3 +140,31 @@ const NestableLegacy = (ctx) => {
     };
 };
 exports.NestableLegacy = NestableLegacy;
+function isValidStaticNestableContent(content, model) {
+    if (!model)
+        return false;
+    switch (content.__TYPE__) {
+        // special case for no content so we can consider it valid no matter its model
+        case "EmptyContent":
+            return true;
+        case "BooleanContent":
+            return model.type === "Boolean";
+        case "EmbedContent":
+            return model.type === "Embed";
+        case "FieldContent":
+            return content.type === model.type;
+        case "GeoPointContent":
+            return model.type === "GeoPoint";
+        case "ImageContent":
+            return model.type === "Image";
+        case "IntegrationFieldsContent":
+            return model.type === "IntegrationFields";
+        case "LinkContent":
+            return model.type === "Link";
+        case "StructuredTextContent":
+            return model.type === "StructuredText";
+        case "SeparatorContent":
+            return model.type === "Separator";
+    }
+}
+exports.isValidStaticNestableContent = isValidStaticNestableContent;

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

@@ -1,4 +1,6 @@
 import * as t from "io-ts";
+import type { ContentPath, TraverseContentFn } from "../../../../_internal/utils";
+import type { CompositeSlice } from "../../../../customtypes";
 import { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
 export declare const CompositeSliceContentType = "CompositeSliceContent";
 export declare const isCompositeSliceContent: (u: unknown) => u is {
@@ -1699,3 +1701,9 @@ export declare const CompositeSliceContent: t.ExactC<t.TypeC<{
     }>>>;
 }>>;
 export declare type CompositeSliceContent = t.TypeOf<typeof CompositeSliceContent>;
+export declare function traverseCompositeSliceContent({ path, sliceName, model, content, }: {
+    path: ContentPath;
+    sliceName: string;
+    content: CompositeSliceContent;
+    model?: CompositeSlice | undefined;
+}): (transform: TraverseContentFn) => CompositeSliceContent | undefined;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompositeSliceContent = exports.CompositeSliceLegacy = exports.isCompositeSliceContent = exports.CompositeSliceContentType = void 0;
+exports.traverseCompositeSliceContent = exports.CompositeSliceContent = exports.CompositeSliceLegacy = exports.isCompositeSliceContent = exports.CompositeSliceContentType = void 0;
 const tslib_1 = require("tslib");
 const fp_ts_1 = require("fp-ts");
 const Either_1 = require("fp-ts/lib/Either");
@@ -79,3 +79,58 @@ 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({
+                path: path.concat([
+                    { key: "non-repeat", type: "primary" },
+                    { 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,
+                [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,
+            };
+        });
+        return {
+            __TYPE__: content.__TYPE__,
+            repeat: items,
+            nonRepeat: primary,
+        };
+    };
+}
+exports.traverseCompositeSliceContent = traverseCompositeSliceContent;

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

@@ -14,5 +14,4 @@ const RepeatableWidgetsBlock = t.strict({
     __TYPE__: t.literal(GroupContent_1.GroupItemContentType),
     value: t.array(RepeatableWidget),
 });
-t.array(RepeatableWidget);
 exports.RepeatableWidgets = t.array(RepeatableWidgetsBlock);

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

@@ -1,4 +1,6 @@
 import * as t from "io-ts";
+import type { ContentPath, TraverseContentFn } from "../../../../_internal/utils";
+import type { SharedSlice } from "../../../../customtypes";
 import { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
 export declare const SharedSliceContentType = "SharedSliceContent";
 export declare const isSharedSliceContent: (u: unknown) => u is {
@@ -1703,3 +1705,9 @@ export declare const SharedSliceContent: t.ExactC<t.TypeC<{
     }>>>;
 }>>;
 export declare type SharedSliceContent = t.TypeOf<typeof SharedSliceContent>;
+export declare function traverseSharedSliceContent({ path, sliceName, model, content, }: {
+    path: ContentPath;
+    sliceName: string;
+    content: SharedSliceContent;
+    model?: SharedSlice | undefined;
+}): (transform: TraverseContentFn) => SharedSliceContent | undefined;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SharedSliceContent = exports.SharedSliceLegacy = exports.isSharedSliceContent = exports.SharedSliceContentType = void 0;
+exports.traverseSharedSliceContent = exports.SharedSliceContent = exports.SharedSliceLegacy = exports.isSharedSliceContent = exports.SharedSliceContentType = void 0;
 const tslib_1 = require("tslib");
 const fp_ts_1 = require("fp-ts");
 const Either_1 = require("fp-ts/lib/Either");
@@ -96,3 +96,60 @@ 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({
+                path: path.concat([
+                    { key: "primary", type: "primary" },
+                    { 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,
+                [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,
+            };
+        });
+        return {
+            __TYPE__: content.__TYPE__,
+            variation: content.variation,
+            primary,
+            items,
+        };
+    };
+}
+exports.traverseSharedSliceContent = traverseSharedSliceContent;

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

@@ -1,4 +1,6 @@
 import * as t from "io-ts";
+import type { ContentPath, TraverseContentFn } from "../../../_internal/utils";
+import { type StaticSlices } from "../../../customtypes";
 import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx";
 export declare const SlicesContentType = "SliceContentType";
 export declare const isSlicesContent: (u: unknown) => u is {
@@ -5093,4 +5095,9 @@ export declare const SlicesContent: t.TypeC<{
     }>>;
 }>;
 export declare type SlicesContent = t.TypeOf<typeof SlicesContent>;
+export declare function traverseSlices({ path, model, content, }: {
+    path: ContentPath;
+    content: SlicesContent;
+    model?: StaticSlices | undefined;
+}): (transform: TraverseContentFn) => SlicesContent | undefined;
 export {};

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

@@ -1,11 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SlicesContent = exports.SlicesLegacy = exports.isSlicesContent = exports.SlicesContentType = void 0;
+exports.traverseSlices = exports.SlicesContent = exports.SlicesLegacy = exports.isSlicesContent = exports.SlicesContentType = void 0;
 const tslib_1 = require("tslib");
 const fp_ts_1 = require("fp-ts");
 const function_1 = require("fp-ts/lib/function");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
+const customtypes_1 = require("../../../customtypes");
 const utils_1 = require("../../utils");
+const GroupContent_1 = require("../GroupContent");
+const CompositeSliceContent_1 = require("./Slice/CompositeSliceContent");
+const SharedSliceContent_1 = require("./Slice/SharedSliceContent");
 const SliceItem_1 = require("./SliceItem");
 exports.SlicesContentType = "SliceContentType";
 const isSlicesContent = (u) => (0, utils_1.hasContentType)(u) && u.__TYPE__ === exports.SlicesContentType;
@@ -32,3 +36,68 @@ exports.SlicesContent = t.type({
     __TYPE__: t.literal(exports.SlicesContentType),
     value: t.array(SliceItem_1.SliceItemContent),
 });
+function traverseSlices({ path, model, content, }) {
+    return (transform) => {
+        const value = content.value.reduce((acc, sliceContent) => {
+            var _a, _b;
+            const sliceModel = (_b = (_a = model === null || model === void 0 ? void 0 : model.config) === null || _a === void 0 ? void 0 : _a.choices) === null || _b === void 0 ? void 0 : _b[sliceContent.name];
+            const slicePath = path.concat({
+                key: sliceContent.key,
+                type: sliceContent.widget.__TYPE__,
+            });
+            const convertedSliceWidget = (() => {
+                switch (sliceContent.widget.__TYPE__) {
+                    case "SharedSliceContent":
+                        return (0, SharedSliceContent_1.traverseSharedSliceContent)({
+                            path: slicePath,
+                            sliceName: sliceContent.name,
+                            model: sliceModel && (0, customtypes_1.isStaticSharedSlice)(sliceModel)
+                                ? sliceModel
+                                : undefined,
+                            content: sliceContent.widget,
+                        })(transform);
+                    case "CompositeSliceContent":
+                        return (0, CompositeSliceContent_1.traverseCompositeSliceContent)({
+                            path: slicePath,
+                            sliceName: sliceContent.name,
+                            model: sliceModel && (0, customtypes_1.isCompositeSlice)(sliceModel)
+                                ? sliceModel
+                                : undefined,
+                            content: sliceContent.widget,
+                        })(transform);
+                    case "GroupContentType":
+                        return (0, GroupContent_1.traverseGroupContent)({
+                            path: slicePath,
+                            model: sliceModel &&
+                                (0, customtypes_1.isLegacySlice)(sliceModel) &&
+                                sliceModel.type === "Group"
+                                ? sliceModel
+                                : undefined,
+                            content: sliceContent.widget,
+                        })(transform);
+                    default:
+                        return sliceContent.widget;
+                }
+            })();
+            if (!convertedSliceWidget)
+                return acc;
+            const convertedSlice = transform({
+                key: sliceContent.key,
+                apiId: sliceContent.name,
+                path: slicePath,
+                model: sliceModel,
+                content: convertedSliceWidget,
+            });
+            const convertedSliceParent = convertedSlice && {
+                ...sliceContent,
+                widget: convertedSlice,
+            };
+            return convertedSliceParent ? acc.concat(convertedSliceParent) : acc;
+        }, []);
+        return {
+            __TYPE__: content.__TYPE__,
+            value,
+        };
+    };
+}
+exports.traverseSlices = traverseSlices;