@prismicio/types-internal 3.9.0 → 3.10.0-alpha.0

package/lib/_internal/utils.d.ts

@@ -1,5 +1,5 @@
 import type { RepeatableContent, SharedSliceItemContent, SliceItemContent, WidgetContent } from "../content";
-import type { CompositeSlice, Group, NestableWidget, StaticSlices, UID, VariationFields } from "../customtypes";
+import type { CompositeSlice, Group, NestableWidget, NestedGroup, StaticSlices, UID, VariationFields } from "../customtypes";
 export declare type TraverseSliceContentFn = <S extends SliceItemContent | SharedSliceItemContent, D extends VariationFields | CompositeSlice | Group | NestableWidget>({ path, key, apiId, model, content, }: {
     path: ContentPath;
     key: string;
@@ -29,3 +29,8 @@ export declare const ContentPath: {
     }>): ContentPath;
 };
 export declare type SliceModel = VariationFields | NestableWidget | CompositeSlice | Group;
+export declare type OnFieldFn<T extends UID | NestableWidget | Group | NestedGroup> = (args: {
+    path: ReadonlyArray<string>;
+    key: string;
+    field: T;
+}) => T;

package/lib/content/Document.d.ts

@@ -4626,7 +4626,7 @@ declare function parseLegacyDocument(legacyDoc: unknown, customType: StaticCusto
 }): Document | undefined;
 declare function encodeToLegacyDocument(document: Document): DocumentLegacy;
 export declare const DocumentLegacy: {
-    _codec: (allTypes?: Map<string, "Boolean" | "Color" | "Date" | "Embed" | "GeoPoint" | "Image" | "IntegrationFields" | "Link" | "Number" | "Range" | "StructuredText" | "Select" | "Separator" | "Table" | "Text" | "Timestamp" | "Group" | "Slice" | "SharedSlice" | "Choice" | "Slices" | "UID" | "Repeatable.Link"> | undefined) => t.Type<{
+    _codec: (allTypes?: Map<string, "Boolean" | "Color" | "Date" | "Embed" | "GeoPoint" | "Image" | "IntegrationFields" | "Link" | "Number" | "Range" | "StructuredText" | "Select" | "Separator" | "Table" | "Text" | "Timestamp" | "Group" | "UID" | "Slice" | "SharedSlice" | "Choice" | "Slices" | "Repeatable.Link"> | undefined) => t.Type<{
         [x: string]: {
             type: string;
             __TYPE__: "EmptyContent";

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

@@ -1,18 +1,90 @@
 import * as t from "io-ts";
 import type { ContentPath, TraverseWidgetContentFn } from "../../_internal/utils";
-import type { Link, NestableWidget } from "../../customtypes";
+import { type Link, NestableFieldTypes, NestableWidget } from "../../customtypes";
 import type { LegacyContentCtx, WithTypes } from "../LegacyContentCtx";
+export declare const RepeatableContentType: "RepeatableContent";
+export declare const RepeatableFieldType: "Repeatable";
+export declare const RepeatableItemContent: t.ExactC<t.TypeC<{
+    __TYPE__: t.LiteralC<"LinkContent">;
+    value: t.UnionC<[t.IntersectionC<[t.ExactC<t.TypeC<{
+        __TYPE__: t.LiteralC<"ImageLink">;
+    }>>, t.UnionC<[t.IntersectionC<[t.IntersectionC<[t.ExactC<t.TypeC<{
+        kind: t.StringC;
+        id: t.StringC;
+        url: t.StringC;
+        height: t.StringC;
+        width: t.StringC;
+        size: t.StringC;
+        name: t.StringC;
+    }>>, t.ExactC<t.PartialC<{
+        date: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    }>>]>, t.ExactC<t.PartialC<{
+        text: t.StringC;
+    }>>]>, t.ExactC<t.TypeC<{
+        kind: t.LiteralC<"image">;
+        text: t.StringC;
+    }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+        __TYPE__: t.LiteralC<"FileLink">;
+    }>>, t.UnionC<[t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+        kind: t.StringC;
+        id: t.StringC;
+        url: t.StringC;
+        name: t.StringC;
+        size: t.StringC;
+    }>, t.PartialC<{
+        date: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+    }>]>>, t.ExactC<t.PartialC<{
+        text: t.StringC;
+    }>>]>, t.ExactC<t.TypeC<{
+        kind: t.LiteralC<"file">;
+        text: t.StringC;
+    }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+        __TYPE__: t.LiteralC<"DocumentLink">;
+    }>>, t.UnionC<[t.IntersectionC<[t.ExactC<t.TypeC<{
+        id: t.Type<string, string, unknown>;
+    }>>, t.ExactC<t.PartialC<{
+        text: t.StringC;
+    }>>]>, t.ExactC<t.TypeC<{
+        kind: t.LiteralC<"document">;
+        text: t.StringC;
+    }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+        __TYPE__: t.LiteralC<"ExternalLink">;
+    }>>, t.UnionC<[t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+        url: t.StringC;
+    }>, t.PartialC<{
+        kind: t.LiteralC<"web">;
+        target: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        preview: t.UnionC<[t.Type<{
+            title?: string;
+        }, {
+            title?: string;
+        }, unknown>, t.NullC, t.UndefinedC]>;
+    }>]>>, t.ExactC<t.PartialC<{
+        text: t.StringC;
+    }>>]>, t.ExactC<t.TypeC<{
+        kind: t.LiteralC<"web">;
+        text: t.StringC;
+    }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+        __TYPE__: t.LiteralC<"MediaLink">;
+    }>>, t.ExactC<t.TypeC<{
+        kind: t.LiteralC<"media">;
+        text: t.StringC;
+    }>>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+        __TYPE__: t.LiteralC<"AnyLink">;
+    }>>, t.ExactC<t.TypeC<{
+        text: t.StringC;
+    }>>]>]>;
+}>>;
+export declare type RepeatableItemContent = t.TypeOf<typeof RepeatableItemContent>;
 export declare const RepeatableContent: t.ExactC<t.TypeC<{
     __TYPE__: t.LiteralC<"RepeatableContent">;
-    type: t.LiteralC<"Link">;
-    value: t.ArrayC<t.IntersectionC<[t.ExactC<t.TypeC<{
-        key: t.Type<string, string, unknown>;
-    }>>, t.ExactC<t.TypeC<{
+    type: t.UnionC<[t.LiteralC<"Color">, t.LiteralC<"Boolean">, t.LiteralC<"Embed">, t.LiteralC<"GeoPoint">, t.LiteralC<"Date">, t.LiteralC<"Number">, t.LiteralC<"Range">, t.LiteralC<"StructuredText">, t.LiteralC<"Select">, t.LiteralC<"Separator">, t.LiteralC<"Text">, t.LiteralC<"Timestamp">, t.LiteralC<"Link">, t.LiteralC<"Image">, t.LiteralC<"IntegrationFields">]>;
+    value: t.ArrayC<t.ExactC<t.TypeC<{
         __TYPE__: t.LiteralC<"LinkContent">;
         value: t.UnionC<[t.IntersectionC<[t.ExactC<t.TypeC<{
             __TYPE__: t.LiteralC<"ImageLink">;
-        }>>, t.IntersectionC<[t.UnionC<[t.IntersectionC<[t.ExactC<t.TypeC<{
-            kind: t.Type<"image", "image", unknown>;
+        }>>, t.UnionC<[t.IntersectionC<[t.IntersectionC<[t.ExactC<t.TypeC<{
+            kind: t.StringC;
             id: t.StringC;
             url: t.StringC;
             height: t.StringC;
@@ -21,35 +93,38 @@ export declare const RepeatableContent: t.ExactC<t.TypeC<{
             name: t.StringC;
         }>>, t.ExactC<t.PartialC<{
             date: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
+        }>>]>, t.ExactC<t.PartialC<{
+            text: t.StringC;
         }>>]>, t.ExactC<t.TypeC<{
             kind: t.LiteralC<"image">;
-        }>>]>, t.ExactC<t.PartialC<{
             text: t.StringC;
         }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
             __TYPE__: t.LiteralC<"FileLink">;
-        }>>, t.IntersectionC<[t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
-            kind: t.Type<"file", "file", unknown>;
+        }>>, t.UnionC<[t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+            kind: t.StringC;
             id: t.StringC;
             url: t.StringC;
             name: t.StringC;
             size: t.StringC;
         }>, t.PartialC<{
             date: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
-        }>]>>, t.ExactC<t.TypeC<{
+        }>]>>, t.ExactC<t.PartialC<{
+            text: t.StringC;
+        }>>]>, t.ExactC<t.TypeC<{
             kind: t.LiteralC<"file">;
-        }>>]>, t.ExactC<t.PartialC<{
             text: t.StringC;
         }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
             __TYPE__: t.LiteralC<"DocumentLink">;
-        }>>, t.IntersectionC<[t.UnionC<[t.ExactC<t.TypeC<{
+        }>>, t.UnionC<[t.IntersectionC<[t.ExactC<t.TypeC<{
             id: t.Type<string, string, unknown>;
-        }>>, t.ExactC<t.TypeC<{
+        }>>, t.ExactC<t.PartialC<{
+            text: t.StringC;
+        }>>]>, t.ExactC<t.TypeC<{
             kind: t.LiteralC<"document">;
-        }>>]>, t.ExactC<t.PartialC<{
             text: t.StringC;
         }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
             __TYPE__: t.LiteralC<"ExternalLink">;
-        }>>, t.IntersectionC<[t.UnionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
+        }>>, t.UnionC<[t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
             url: t.StringC;
         }>, t.PartialC<{
             kind: t.LiteralC<"web">;
@@ -59,37 +134,33 @@ export declare const RepeatableContent: t.ExactC<t.TypeC<{
             }, {
                 title?: string;
             }, unknown>, t.NullC, t.UndefinedC]>;
-        }>]>>, t.ExactC<t.TypeC<{
+        }>]>>, t.ExactC<t.PartialC<{
+            text: t.StringC;
+        }>>]>, t.ExactC<t.TypeC<{
             kind: t.LiteralC<"web">;
-        }>>]>, t.ExactC<t.PartialC<{
             text: t.StringC;
         }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
             __TYPE__: t.LiteralC<"MediaLink">;
-        }>>, t.IntersectionC<[t.ExactC<t.TypeC<{
+        }>>, t.ExactC<t.TypeC<{
             kind: t.LiteralC<"media">;
-        }>>, t.ExactC<t.PartialC<{
             text: t.StringC;
-        }>>]>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
+        }>>]>, t.IntersectionC<[t.ExactC<t.TypeC<{
             __TYPE__: t.LiteralC<"AnyLink">;
-        }>>, t.ExactC<t.IntersectionC<[t.TypeC<{
-            kind: t.LiteralC<"any">;
-        }>, t.PartialC<{
+        }>>, t.ExactC<t.TypeC<{
             text: t.StringC;
-        }>]>>]>]>;
-    }>>]>>;
+        }>>]>]>;
+    }>>>;
 }>>;
 export declare type RepeatableContent = t.TypeOf<typeof RepeatableContent>;
 export declare const isRepeatableContent: t.Is<{
     __TYPE__: "RepeatableContent";
-    type: "Link";
-    value: ({
-        key: string;
-    } & {
+    type: "Boolean" | "Color" | "Date" | "Embed" | "GeoPoint" | "Image" | "IntegrationFields" | "Link" | "Number" | "Range" | "StructuredText" | "Select" | "Separator" | "Text" | "Timestamp";
+    value: {
         __TYPE__: "LinkContent";
         value: ({
             __TYPE__: "ImageLink";
-        } & ((({
-            kind: "image";
+        } & (({
+            kind: string;
             id: string;
             url: string;
             height: string;
@@ -98,41 +169,43 @@ export declare const isRepeatableContent: t.Is<{
             name: string;
         } & {
             date?: string | null | undefined;
+        } & {
+            text?: string;
         }) | {
             kind: "image";
-        }) & {
-            text?: string;
+            text: string;
         })) | ({
             __TYPE__: "FileLink";
-        } & ((({
-            kind: "file";
+        } & (({
+            kind: string;
             id: string;
             url: string;
             name: string;
             size: string;
         } & {
             date?: string | null | undefined;
+        } & {
+            text?: string;
         }) | {
             kind: "file";
-        }) & {
-            text?: string;
+            text: string;
         })) | ({
             __TYPE__: "MediaLink";
         } & {
             kind: "media";
-        } & {
-            text?: string;
+            text: string;
         }) | ({
             __TYPE__: "DocumentLink";
         } & (({
             id: string;
-        } | {
-            kind: "document";
-        }) & {
+        } & {
             text?: string;
+        }) | {
+            kind: "document";
+            text: string;
         })) | ({
             __TYPE__: "ExternalLink";
-        } & ((({
+        } & (({
             url: string;
         } & {
             kind?: "web";
@@ -140,20 +213,19 @@ export declare const isRepeatableContent: t.Is<{
             preview?: {
                 title?: string;
             } | null | undefined;
+        } & {
+            text?: string;
         }) | {
             kind: "web";
-        }) & {
-            text?: string;
+            text: string;
         })) | ({
             __TYPE__: "AnyLink";
         } & {
-            kind: "any";
-        } & {
-            text?: string;
+            text: string;
         });
-    })[];
+    }[];
 }>;
-export declare const RepeatableLegacy: (ctx: LegacyContentCtx, fieldType: "Link") => t.Type<RepeatableContent, WithTypes<Array<unknown>>, unknown>;
+export declare const RepeatableLegacy: (ctx: LegacyContentCtx, fieldType: NestableFieldTypes) => t.Type<RepeatableContent, WithTypes<Array<unknown>>, unknown>;
 export declare type RepeatableCustomType = Link;
 export declare function traverseRepeatableContent({ path, key, apiId, model, content, }: {
     path: ContentPath;

package/lib/content/fields/RepeatableContent.js

@@ -1,21 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.traverseRepeatableContent = exports.RepeatableLegacy = exports.isRepeatableContent = exports.RepeatableContent = void 0;
+exports.traverseRepeatableContent = exports.RepeatableLegacy = exports.isRepeatableContent = exports.RepeatableContent = exports.RepeatableItemContent = exports.RepeatableFieldType = exports.RepeatableContentType = 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 customtypes_1 = require("../../customtypes");
 const nestable_1 = require("./nestable");
+exports.RepeatableContentType = "RepeatableContent";
+exports.RepeatableFieldType = "Repeatable";
+exports.RepeatableItemContent = nestable_1.LinkContent;
 exports.RepeatableContent = t.strict({
-    __TYPE__: t.literal("RepeatableContent"),
-    type: t.literal("Link"),
-    value: t.array(nestable_1.LinkContent),
+    __TYPE__: t.literal(exports.RepeatableContentType),
+    type: customtypes_1.NestableFieldTypes,
+    // TODO: How to ensure it's an array of only one type
+    value: t.array(exports.RepeatableItemContent),
 });
 exports.isRepeatableContent = exports.RepeatableContent.is;
 const RepeatableLegacy = (ctx, fieldType) => {
+    const codecDecode = t.array(t.unknown);
+    const codecEncode = t.array(exports.RepeatableItemContent);
     return new t.Type("RepeatableLegacy", exports.isRepeatableContent, (items) => {
-        const parsed = (0, function_1.pipe)(t.array(t.unknown).decode(items), fp_ts_1.either.map((items) => {
+        const parsed = (0, function_1.pipe)(codecDecode.decode(items), fp_ts_1.either.map((items) => {
             const parsedItems = items.reduce((acc, item) => {
                 let result;
                 switch (fieldType) {
@@ -32,12 +39,12 @@ const RepeatableLegacy = (ctx, fieldType) => {
             return {
                 value: parsedItems,
                 type: fieldType,
-                __TYPE__: "RepeatableContent",
+                __TYPE__: exports.RepeatableContentType,
             };
         }));
         return parsed;
     }, (r) => {
-        const res = t.array(nestable_1.LinkContent).encode(r.value);
+        const res = codecEncode.encode(r.value);
         const encodedItems = res.reduce((acc, item) => {
             let encoded;
             switch (item.__TYPE__) {
@@ -72,9 +79,6 @@ function traverseRepeatableContent({ path, key, apiId, model, content, }) {
             // Can happen if the transform function returns undefined to filter out a field
             if (!transformedField)
                 return acc;
-            // If the transformed field is not a link content, we don't include it
-            if (!(0, nestable_1.isLinkContent)(transformedField))
-                return acc;
             return acc.concat(transformedField);
         }, []);
         return transform({

package/lib/customtypes/CustomType.d.ts

@@ -1,5 +1,7 @@
 import { Either } from "fp-ts/lib/Either";
 import * as t from "io-ts";
+import type { OnFieldFn } from "../_internal/utils";
+import type { Group, NestableWidget, NestedGroup, UID } from "./widgets";
 import type { SharedSlice } from "./widgets/slices/SharedSlice";
 import type { DynamicWidget } from "./widgets/Widget";
 import type { StaticWidget } from "./widgets/Widget";
@@ -572,6 +574,15 @@ export declare const StaticCustomType: t.ExactC<t.IntersectionC<[t.TypeC<{
                     });
                 };
             };
+        }) | ({
+            type: "UID";
+        } & {
+            fieldset?: string | null | undefined;
+            config?: {
+                label?: string | null | undefined;
+                useAsTitle?: boolean;
+                placeholder?: string;
+            };
         }) | ({
             type: "Choice" | "Slices";
         } & {
@@ -2077,15 +2088,6 @@ export declare const StaticCustomType: t.ExactC<t.IntersectionC<[t.TypeC<{
                     });
                 };
             };
-        }) | ({
-            type: "UID";
-        } & {
-            fieldset?: string | null | undefined;
-            config?: {
-                label?: string | null | undefined;
-                useAsTitle?: boolean;
-                placeholder?: string;
-            };
         });
     }, unknown, unknown>>;
     status: t.BooleanC;
@@ -2655,6 +2657,15 @@ export declare const CustomType: t.ExactC<t.IntersectionC<[t.TypeC<{
                     });
                 };
             };
+        }) | ({
+            type: "UID";
+        } & {
+            fieldset?: string | null | undefined;
+            config?: {
+                label?: string | null | undefined;
+                useAsTitle?: boolean;
+                placeholder?: string;
+            };
         }) | ({
             type: "Choice" | "Slices";
         } & {
@@ -3407,15 +3418,6 @@ export declare const CustomType: t.ExactC<t.IntersectionC<[t.TypeC<{
                     };
                 };
             };
-        }) | ({
-            type: "UID";
-        } & {
-            fieldset?: string | null | undefined;
-            config?: {
-                label?: string | null | undefined;
-                useAsTitle?: boolean;
-                placeholder?: string;
-            };
         });
     }, unknown, unknown>>;
     status: t.BooleanC;
@@ -3437,4 +3439,8 @@ export declare function collectSharedSlices(customType: {
     customTypeId: string;
     fields: Record<string, StaticWidget>;
 }): Record<string, SharedSlice>;
+export declare function traverseCustomType<T extends CustomType | StaticCustomType>(args: {
+    customType: T;
+    onField: OnFieldFn<UID | NestableWidget | Group | NestedGroup>;
+}): T;
 export {};

package/lib/customtypes/CustomType.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.collectSharedSlices = exports.flattenCustomTypeFields = exports.filterMissingSharedSlices = exports.collectWidgets = exports.validateSlices = exports.toStatic = exports.flattenSections = exports.flattenWidgets = exports.CustomType = exports.StaticCustomType = exports.CustomTypeFormat = void 0;
+exports.traverseCustomType = exports.collectSharedSlices = exports.flattenCustomTypeFields = exports.filterMissingSharedSlices = exports.collectWidgets = exports.validateSlices = exports.toStatic = exports.flattenSections = exports.flattenWidgets = exports.CustomType = exports.StaticCustomType = exports.CustomTypeFormat = void 0;
 const tslib_1 = require("tslib");
 const Either_1 = require("fp-ts/lib/Either");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
@@ -163,3 +163,18 @@ function collectSharedSlices(customType) {
     }, {});
 }
 exports.collectSharedSlices = collectSharedSlices;
+function traverseCustomType(args) {
+    const { customType, onField } = args;
+    return {
+        ...customType,
+        json: Object.entries(customType.json).reduce((acc, [key, section]) => {
+            acc[key] = (0, Section_1.traverseSection)({
+                path: [key],
+                section,
+                onField,
+            });
+            return acc;
+        }, {}),
+    };
+}
+exports.traverseCustomType = traverseCustomType;

package/lib/customtypes/Section.d.ts

@@ -1,4 +1,6 @@
 import * as t from "io-ts";
+import type { OnFieldFn } from "../_internal/utils";
+import { Group, NestableWidget, NestedGroup, UID } from "./widgets";
 import type { SharedSlice } from "./widgets/slices";
 import { DynamicWidget, StaticWidget } from "./widgets/Widget";
 export declare function sectionReader<T extends StaticWidget | DynamicWidget>(codec: t.Type<T, unknown>): t.RecordC<t.Type<string, string, unknown>, t.Type<T, unknown, unknown>>;
@@ -556,6 +558,15 @@ export declare const StaticSection: t.RecordC<t.Type<string, string, unknown>, t
             });
         };
     };
+}) | ({
+    type: "UID";
+} & {
+    fieldset?: string | null | undefined;
+    config?: {
+        label?: string | null | undefined;
+        useAsTitle?: boolean;
+        placeholder?: string;
+    };
 }) | ({
     type: "Choice" | "Slices";
 } & {
@@ -2061,15 +2072,6 @@ export declare const StaticSection: t.RecordC<t.Type<string, string, unknown>, t
             });
         };
     };
-}) | ({
-    type: "UID";
-} & {
-    fieldset?: string | null | undefined;
-    config?: {
-        label?: string | null | undefined;
-        useAsTitle?: boolean;
-        placeholder?: string;
-    };
 }), unknown, unknown>>;
 export declare type StaticSection = t.TypeOf<typeof StaticSection>;
 export declare const DynamicSection: t.RecordC<t.Type<string, string, unknown>, t.Type<({
@@ -2626,6 +2628,15 @@ export declare const DynamicSection: t.RecordC<t.Type<string, string, unknown>,
             });
         };
     };
+}) | ({
+    type: "UID";
+} & {
+    fieldset?: string | null | undefined;
+    config?: {
+        label?: string | null | undefined;
+        useAsTitle?: boolean;
+        placeholder?: string;
+    };
 }) | ({
     type: "Choice" | "Slices";
 } & {
@@ -3378,17 +3389,13 @@ export declare const DynamicSection: t.RecordC<t.Type<string, string, unknown>,
             };
         };
     };
-}) | ({
-    type: "UID";
-} & {
-    fieldset?: string | null | undefined;
-    config?: {
-        label?: string | null | undefined;
-        useAsTitle?: boolean;
-        placeholder?: string;
-    };
 }), unknown, unknown>>;
 export declare type DynamicSection = t.TypeOf<typeof DynamicSection>;
 export declare const Sections: {
     toStatic(dynamic: DynamicSection, sharedSlices: Map<string, SharedSlice>): StaticSection;
 };
+export declare function traverseSection<T extends DynamicSection | StaticSection>(args: {
+    path: ReadonlyArray<string>;
+    section: T;
+    onField: OnFieldFn<UID | NestableWidget | Group | NestedGroup>;
+}): T;

package/lib/customtypes/Section.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Sections = exports.DynamicSection = exports.StaticSection = exports.sectionReader = void 0;
+exports.traverseSection = exports.Sections = exports.DynamicSection = exports.StaticSection = exports.sectionReader = void 0;
 const tslib_1 = require("tslib");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const common_1 = require("../common");
+const widgets_1 = require("./widgets");
 const Widget_1 = require("./widgets/Widget");
 function sectionReader(codec) {
     return t.record(common_1.WidgetKey, codec); // WidgetId -> Widget Data
@@ -19,3 +20,57 @@ exports.Sections = {
         return section;
     },
 };
+function traverseSection(args) {
+    const { path: prevPath, section, onField } = args;
+    return Object.entries(section).reduce((acc, [key, prevModel]) => {
+        const path = prevPath.concat(key);
+        let model;
+        switch (prevModel.type) {
+            case "Choice":
+            case "Slices":
+                model = (0, widgets_1.traverseSlices)({
+                    path,
+                    slices: prevModel,
+                    onField: onField,
+                });
+                break;
+            case "Group":
+                model = onField({
+                    path,
+                    key,
+                    field: (0, widgets_1.traverseGroup)({
+                        path,
+                        group: prevModel,
+                        onField: onField,
+                    }),
+                });
+                break;
+            case "Boolean":
+            case "Color":
+            case "Date":
+            case "Embed":
+            case "GeoPoint":
+            case "Image":
+            case "IntegrationFields":
+            case "Link":
+            case "Number":
+            case "Range":
+            case "Select":
+            case "Separator":
+            case "StructuredText":
+            case "Table":
+            case "Text":
+            case "Timestamp":
+            case "UID":
+                model = onField({
+                    path,
+                    key,
+                    field: prevModel,
+                });
+                break;
+        }
+        acc[key] = model;
+        return acc;
+    }, {});
+}
+exports.traverseSection = traverseSection;

package/lib/customtypes/widgets/Group.d.ts

@@ -1,4 +1,6 @@
 import * as t from "io-ts";
+import type { OnFieldFn } from "../../_internal/utils";
+import { NestableWidget } from "./nestable/NestableWidget";
 export declare const GroupFieldType = "Group";
 export declare const NestedGroupConfig: t.ExactC<t.PartialC<{
     label: t.UnionC<[t.Type<string, string, unknown>, t.NullC, t.UndefinedC]>;
@@ -1182,3 +1184,13 @@ export declare const Group: t.ExactC<t.IntersectionC<[t.TypeC<{
     }>>;
 }>]>>;
 export declare type Group = t.TypeOf<typeof Group>;
+export declare function traverseNestedGroup(args: {
+    path: ReadonlyArray<string>;
+    group: NestedGroup;
+    onField: OnFieldFn<NestableWidget>;
+}): NestedGroup;
+export declare function traverseGroup(args: {
+    path: ReadonlyArray<string>;
+    group: Group;
+    onField: OnFieldFn<NestableWidget | NestedGroup>;
+}): Group;