@prismicio/types-internal 3.11.2 → 3.12.0-alpha.1

package/lib/content/Document.d.ts

@@ -9,7 +9,10 @@ export declare const Document: t.RecordC<t.Type<string, string, unknown>, t.Unio
     __TYPE__: t.LiteralC<"EmptyContent">;
 }>>, t.ExactC<t.TypeC<{
     __TYPE__: t.LiteralC<"BooleanContent">;
-    value: t.BooleanC;
+    value: t.BooleanC; /**
+     * `DocumentLegacyCodec` handles decoding and encoding documents to the legacy
+     * format used by Prismic DB, therefore, this function itself is not "legacy".
+     */
 }>>, t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
     embed_url: t.StringC;
     type: t.StringC;
@@ -783,7 +786,10 @@ export declare const Document: t.RecordC<t.Type<string, string, unknown>, t.Unio
                 __TYPE__: t.LiteralC<"EmptyContent">;
             }>>, t.ExactC<t.TypeC<{
                 __TYPE__: t.LiteralC<"BooleanContent">;
-                value: t.BooleanC;
+                value: t.BooleanC; /**
+                 * `DocumentLegacyCodec` handles decoding and encoding documents to the legacy
+                 * format used by Prismic DB, therefore, this function itself is not "legacy".
+                 */
             }>>, t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
                 embed_url: t.StringC;
                 type: t.StringC;
@@ -1544,12 +1550,16 @@ export declare const Document: t.RecordC<t.Type<string, string, unknown>, t.Unio
             }>>]>>;
             repeat: t.ArrayC<t.ExactC<t.TypeC<{
                 __TYPE__: t.LiteralC<"GroupItemContent">;
+                key: t.StringC;
                 value: t.ArrayC<t.TupleC<[t.StringC, t.UnionC<[t.UnionC<[t.ExactC<t.TypeC<{
                     type: t.StringC;
                     __TYPE__: t.LiteralC<"EmptyContent">;
                 }>>, t.ExactC<t.TypeC<{
                     __TYPE__: t.LiteralC<"BooleanContent">;
-                    value: t.BooleanC;
+                    value: t.BooleanC; /**
+                     * `DocumentLegacyCodec` handles decoding and encoding documents to the legacy
+                     * format used by Prismic DB, therefore, this function itself is not "legacy".
+                     */
                 }>>, t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
                     embed_url: t.StringC;
                     type: t.StringC;
@@ -2317,7 +2327,10 @@ export declare const Document: t.RecordC<t.Type<string, string, unknown>, t.Unio
                 __TYPE__: t.LiteralC<"EmptyContent">;
             }>>, t.ExactC<t.TypeC<{
                 __TYPE__: t.LiteralC<"BooleanContent">;
-                value: t.BooleanC;
+                value: t.BooleanC; /**
+                 * `DocumentLegacyCodec` handles decoding and encoding documents to the legacy
+                 * format used by Prismic DB, therefore, this function itself is not "legacy".
+                 */
             }>>, t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
                 embed_url: t.StringC;
                 type: t.StringC;
@@ -3078,12 +3091,16 @@ export declare const Document: t.RecordC<t.Type<string, string, unknown>, t.Unio
             }>>]>, t.Type<import("./fields").GroupContent, import("./fields").GroupContent, unknown>]>>;
             items: t.ArrayC<t.ExactC<t.TypeC<{
                 __TYPE__: t.LiteralC<"GroupItemContent">;
+                key: t.StringC;
                 value: t.ArrayC<t.TupleC<[t.StringC, t.UnionC<[t.UnionC<[t.ExactC<t.TypeC<{
                     type: t.StringC;
                     __TYPE__: t.LiteralC<"EmptyContent">;
                 }>>, t.ExactC<t.TypeC<{
                     __TYPE__: t.LiteralC<"BooleanContent">;
-                    value: t.BooleanC;
+                    value: t.BooleanC; /**
+                     * `DocumentLegacyCodec` handles decoding and encoding documents to the legacy
+                     * format used by Prismic DB, therefore, this function itself is not "legacy".
+                     */
                 }>>, t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
                     embed_url: t.StringC;
                     type: t.StringC;
@@ -3848,7 +3865,10 @@ export declare const Document: t.RecordC<t.Type<string, string, unknown>, t.Unio
             __TYPE__: t.LiteralC<"EmptyContent">;
         }>>, t.ExactC<t.TypeC<{
             __TYPE__: t.LiteralC<"BooleanContent">;
-            value: t.BooleanC;
+            value: t.BooleanC; /**
+             * `DocumentLegacyCodec` handles decoding and encoding documents to the legacy
+             * format used by Prismic DB, therefore, this function itself is not "legacy".
+             */
         }>>, t.IntersectionC<[t.ExactC<t.IntersectionC<[t.TypeC<{
             embed_url: t.StringC;
             type: t.StringC;
@@ -4617,6 +4637,7 @@ declare function extractMetadata(data: {
 }): {
     types: Map<string, FieldOrSliceType>;
     widgets: Partial<Record<WidgetKey, unknown>>;
+    keys: Map<string, string>;
     slugs: ReadonlyArray<string>;
     uid: string | undefined;
 };
@@ -4626,7 +4647,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" | "UID" | "Slice" | "SharedSlice" | "Choice" | "Slices" | "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, allKeys?: Map<string, string> | undefined) => t.Type<{
         [x: string]: {
             type: string;
             __TYPE__: "EmptyContent";
@@ -6410,6 +6431,7 @@ export declare const DocumentLegacy: {
                     };
                     repeat: {
                         __TYPE__: "GroupItemContent";
+                        key: string;
                         value: [string, {
                             type: string;
                             __TYPE__: "EmptyContent";
@@ -7598,6 +7620,7 @@ export declare const DocumentLegacy: {
                     };
                     items: {
                         __TYPE__: "GroupItemContent";
+                        key: string;
                         value: [string, {
                             type: string;
                             __TYPE__: "EmptyContent";
@@ -10010,6 +10033,7 @@ export declare function migrateDocument(document: Document, customType: StaticCu
                 };
                 repeat: {
                     __TYPE__: "GroupItemContent";
+                    key: string;
                     value: [string, {
                         type: string;
                         __TYPE__: "EmptyContent";
@@ -11198,6 +11222,7 @@ export declare function migrateDocument(document: Document, customType: StaticCu
                 };
                 items: {
                     __TYPE__: "GroupItemContent";
+                    key: string;
                     value: [string, {
                         type: string;
                         __TYPE__: "EmptyContent";

package/lib/content/Document.js

@@ -17,11 +17,11 @@ const legacyDocReader = t.record(common_1.WidgetKey, t.unknown);
  * `DocumentLegacyCodec` handles decoding and encoding documents to the legacy
  * format used by Prismic DB, therefore, this function itself is not "legacy".
  */
-const DocumentLegacyCodec = (allTypes) => {
+const DocumentLegacyCodec = (allTypes, allKeys) => {
     return new t.Type("Document", (u) => !!u && typeof u === "object", (doc) => {
         return (0, function_1.pipe)(legacyDocReader.decode(doc), fp_ts_1.either.map((parsedDoc) => {
             return Object.entries(parsedDoc).reduce((acc, [widgetKey, widgetValue]) => {
-                const widgetCtx = (0, LegacyContentCtx_1.defaultCtx)(widgetKey, allTypes);
+                const widgetCtx = (0, LegacyContentCtx_1.defaultCtx)(widgetKey, allTypes, allKeys);
                 const parsedW = (0, fields_1.WidgetLegacy)(widgetCtx).decode(widgetValue);
                 if (!parsedW || (0, Either_1.isLeft)(parsedW))
                     return acc;
@@ -37,13 +37,14 @@ const DocumentLegacyCodec = (allTypes) => {
             return {
                 content: { ...acc.content, [key]: result.content },
                 types: { ...acc.types, ...result.types },
+                keys: { ...acc.keys, ...result.keys },
             };
-        }, { content: {}, types: {} });
+        }, { content: {}, types: {}, keys: {} });
     });
 };
 function extractMetadata(data) {
     const fields = Object.entries(data);
-    const { types, widgets } = fields.reduce((acc, [k, v]) => {
+    const { types, widgets, keys } = fields.reduce((acc, [k, v]) => {
         if (k.endsWith("_TYPE")) {
             const decodedValue = LegacyContentCtx_1.FieldOrSliceType.decode(v);
             if ((0, Either_1.isRight)(decodedValue)) {
@@ -53,7 +54,18 @@ function extractMetadata(data) {
                 };
             }
         }
-        if (!k.endsWith("_POSITION") && !k.endsWith("_TYPE")) {
+        if (k.endsWith("_KEY")) {
+            const decodedValue = t.string.decode(v);
+            if ((0, Either_1.isRight)(decodedValue)) {
+                return {
+                    ...acc,
+                    keys: acc.keys.set(k.substring(0, k.length - 4), decodedValue.right),
+                };
+            }
+        }
+        if (!k.endsWith("_POSITION") &&
+            !k.endsWith("_TYPE") &&
+            !k.endsWith("_KEY")) {
             return {
                 ...acc,
                 widgets: {
@@ -66,12 +78,14 @@ function extractMetadata(data) {
     }, {
         types: new Map(),
         widgets: {},
+        keys: new Map(),
     });
     const slugs = data["slugs_INTERNAL"] || [];
     const uid = data["uid"];
     return {
         widgets,
         types,
+        keys,
         uid,
         slugs,
     };
@@ -81,15 +95,15 @@ function parseLegacyDocument(legacyDoc, customType) {
     // ensure it's the right document format first
     t.record(common_1.WidgetKey, t.unknown).decode(legacyDoc), fp_ts_1.either.chain((doc) => {
         // extract all metadata, meaning all _TYPES keys from legacy format + the widgets as unknown
-        const { types, widgets } = extractMetadata(doc);
+        const { types, widgets, keys } = extractMetadata(doc);
         // parse the actual widgets
-        return DocumentLegacyCodec(types).decode(widgets);
+        return DocumentLegacyCodec(types, keys).decode(widgets);
     }));
     return (0, Either_1.isLeft)(result) ? undefined : migrateDocument(result.right, customType);
 }
 function encodeToLegacyDocument(document) {
     const encoded = DocumentLegacyCodec().encode(document);
-    return { ...encoded.content, ...encoded.types };
+    return { ...encoded.content, ...encoded.types, ...encoded.keys };
 }
 exports.DocumentLegacy = {
     _codec: DocumentLegacyCodec,

package/lib/content/LegacyContentCtx.d.ts

@@ -25,18 +25,40 @@ export declare const FieldOrSliceType: t.UnionC<[t.UnionC<[t.KeyofC<{
     SharedSlice: null;
 }>]>, t.LiteralC<"Repeatable.Link">]>;
 export declare type FieldOrSliceType = t.TypeOf<typeof FieldOrSliceType>;
+interface LegacyContentCtxParams {
+    fieldKey: string;
+    contentKey?: string;
+    fieldPath?: Array<string>;
+    contentPath?: Array<string>;
+    allTypes?: Map<string, FieldOrSliceType>;
+    allKeys?: Map<string, string>;
+}
 export declare class LegacyContentCtx {
     fieldKey: string;
     prefixedKey: string;
     keyOfType: string;
+    keyOfKey: string;
     fieldPath: Array<string>;
     fieldType?: FieldOrSliceType | undefined;
     allTypes: Map<string, FieldOrSliceType>;
-    constructor(fieldKey: string, fieldPath?: Array<string>, allTypes?: Map<string, FieldOrSliceType>);
+    allKeys: Map<string, string>;
+    contentKey: string;
+    contentPath: Array<string>;
+    fieldContentKey: string;
+    constructor({ fieldKey, contentKey, contentPath, fieldPath, allTypes, allKeys, }: LegacyContentCtxParams);
+    withContentKey(contentKey: string): LegacyContentCtx;
+}
+interface GetFieldCtxParams {
+    fieldKey: string;
+    contentKey?: string;
+    ctx: LegacyContentCtx;
+    prefixes?: Array<string>;
 }
-export declare function getFieldCtx(fieldKey: string, ctx: LegacyContentCtx, prefixes?: Array<string>): LegacyContentCtx;
-export declare function defaultCtx(key: string, allTypes?: Map<string, FieldOrSliceType>): LegacyContentCtx;
+export declare function getFieldCtx({ fieldKey, contentKey: contentKeyParam, ctx, prefixes, }: GetFieldCtxParams): LegacyContentCtx;
+export declare function defaultCtx(key: string, allTypes?: Map<string, FieldOrSliceType>, allKeys?: Map<string, string>): LegacyContentCtx;
 export declare type WithTypes<T> = {
+    keys: Record<string, string>;
     types: Record<string, FieldOrSliceType>;
     content: T;
 };
+export {};

package/lib/content/LegacyContentCtx.js

@@ -3,13 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultCtx = exports.getFieldCtx = exports.LegacyContentCtx = exports.FieldOrSliceType = void 0;
 const tslib_1 = require("tslib");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
+const uuid_1 = require("uuid");
 const widgets_1 = require("../customtypes/widgets");
 exports.FieldOrSliceType = t.union([
     t.union([widgets_1.FieldType, widgets_1.SlicesTypes]),
     t.literal("Repeatable.Link"),
 ]);
 class LegacyContentCtx {
-    constructor(fieldKey, fieldPath, allTypes) {
+    constructor({ fieldKey, contentKey, contentPath, fieldPath, allTypes, allKeys, }) {
+        var _a;
         Object.defineProperty(this, "fieldKey", {
             enumerable: true,
             configurable: true,
@@ -28,6 +30,12 @@ class LegacyContentCtx {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "keyOfKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "fieldPath", {
             enumerable: true,
             configurable: true,
@@ -46,23 +54,77 @@ class LegacyContentCtx {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "allKeys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "contentKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "contentPath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "fieldContentKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.fieldKey = fieldKey;
+        this.contentKey = contentKey || fieldKey;
         this.fieldPath = fieldPath || [];
+        this.contentPath = contentPath || [];
         this.allTypes = allTypes || new Map();
+        this.allKeys = allKeys || new Map();
         const prefixedKey = Array.of(this.fieldPath, [this.fieldKey])
             .flat()
             .join(".");
+        const prefixedContentKey = Array.of(this.contentPath, [this.contentKey])
+            .flat()
+            .join(".");
         this.prefixedKey = prefixedKey;
         this.keyOfType = `${prefixedKey}_TYPE`;
+        this.keyOfKey = `${prefixedContentKey}_KEY`;
         this.fieldType = this.allTypes.get(this.prefixedKey);
+        this.fieldContentKey = (_a = this.allKeys.get(prefixedContentKey)) !== null && _a !== void 0 ? _a : (0, uuid_1.v4)();
+    }
+    withContentKey(contentKey) {
+        return new LegacyContentCtx({
+            ...this,
+            contentPath: [...this.contentPath, this.contentKey],
+            contentKey,
+        });
     }
 }
 exports.LegacyContentCtx = LegacyContentCtx;
-function getFieldCtx(fieldKey, ctx, prefixes) {
-    return new LegacyContentCtx(fieldKey, [...ctx.fieldPath, ctx.fieldKey, ...(prefixes || [])], ctx.allTypes);
+function getFieldCtx({ fieldKey, contentKey: contentKeyParam, ctx, prefixes, }) {
+    const contentKey = contentKeyParam || fieldKey;
+    return new LegacyContentCtx({
+        fieldKey,
+        contentKey,
+        contentPath: [...ctx.contentPath, ctx.contentKey, ...(prefixes || [])],
+        fieldPath: [...ctx.fieldPath, ctx.fieldKey, ...(prefixes || [])],
+        allTypes: ctx.allTypes,
+        allKeys: ctx.allKeys,
+    });
 }
 exports.getFieldCtx = getFieldCtx;
-function defaultCtx(key, allTypes = new Map()) {
-    return new LegacyContentCtx(key, [], allTypes);
+function defaultCtx(key, allTypes = new Map(), allKeys = new Map()) {
+    return new LegacyContentCtx({
+        fieldKey: key,
+        contentKey: key,
+        contentPath: [],
+        fieldPath: [],
+        allTypes,
+        allKeys,
+    });
 }
 exports.defaultCtx = defaultCtx;

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

@@ -8,6 +8,7 @@ export declare const GroupContentType: "GroupContentType";
 export declare const GroupItemContent: t.Type<GroupItemContent>;
 export declare type GroupItemContent = {
     __TYPE__: typeof GroupItemContentType;
+    key: string;
     value: [string, NestableContent | GroupContent][];
 };
 export declare const GroupContent: t.Type<GroupContent>;
@@ -18,10 +19,11 @@ export declare type GroupContent = {
 export declare const isGroupContent: (u: unknown) => u is GroupContent;
 export declare const GroupContentDefaultValue: GroupContent;
 declare const itemLegacyReader: t.RecordC<t.StringC, t.UnknownC>;
-declare type GroupItemLegacy = t.TypeOf<typeof itemLegacyReader>;
-export declare const GroupItemLegacy: (ctx: LegacyContentCtx) => t.Type<GroupItemContent, WithTypes<{
+export declare type GroupItemLegacy = t.TypeOf<typeof itemLegacyReader>;
+export declare const GroupItemLegacy: (ctx: LegacyContentCtx, index: number) => t.Type<GroupItemContent, WithTypes<{
     [x: string]: unknown;
 }>, unknown>;
+export declare function arrayWithIndexCodec<T, O>(f: (index: number) => t.Type<T, O, unknown>): t.Type<Array<T>, O[], unknown>;
 declare type GroupLegacy = Array<GroupItemLegacy>;
 export declare const GroupLegacy: (ctx: LegacyContentCtx) => t.Type<GroupContent, WithTypes<GroupLegacy>, unknown>;
 export declare function groupContentWithDefaultValues(customType: Group, content: GroupContent): GroupContent;

package/lib/content/fields/GroupContent.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.traverseGroupItemsContent = exports.traverseGroupContent = exports.groupContentWithDefaultValues = exports.GroupLegacy = exports.GroupItemLegacy = exports.GroupContentDefaultValue = exports.isGroupContent = exports.GroupContent = exports.GroupItemContent = exports.GroupContentType = exports.GroupItemContentType = void 0;
+exports.traverseGroupItemsContent = exports.traverseGroupContent = exports.groupContentWithDefaultValues = exports.GroupLegacy = exports.arrayWithIndexCodec = exports.GroupItemLegacy = exports.GroupContentDefaultValue = exports.isGroupContent = exports.GroupContent = exports.GroupItemContent = exports.GroupContentType = exports.GroupItemContentType = void 0;
 const tslib_1 = require("tslib");
 const fp_ts_1 = require("fp-ts");
 const Either_1 = require("fp-ts/lib/Either");
@@ -15,6 +15,7 @@ exports.GroupItemContentType = "GroupItemContent";
 exports.GroupContentType = "GroupContentType";
 exports.GroupItemContent = t.recursion("GroupItemContent", () => t.strict({
     __TYPE__: t.literal(exports.GroupItemContentType),
+    key: t.string,
     value: t.array(t.tuple([t.string, t.union([nestable_1.NestableContent, exports.GroupContent])])),
 }));
 exports.GroupContent = t.recursion("GroupContent", () => t.strict({
@@ -28,11 +29,16 @@ exports.GroupContentDefaultValue = {
     value: [],
 };
 const itemLegacyReader = t.record(t.string, t.unknown);
-const GroupItemLegacy = (ctx) => {
+const GroupItemLegacy = (ctx, index) => {
     return new t.Type("GroupItemLegacy", (u) => (0, utils_1.hasContentType)(u) && u.__TYPE__ === exports.GroupItemContentType, (u) => {
         const parsed = (0, function_1.pipe)(itemLegacyReader.decode(u), fp_ts_1.either.map((items) => {
+            const groupItemCtx = ctx.withContentKey(`${index}`);
             const parsedItems = Object.entries(items).reduce((acc, [itemKey, itemValue]) => {
-                const itemCtx = (0, LegacyContentCtx_1.getFieldCtx)(itemKey, ctx);
+                const itemCtx = (0, LegacyContentCtx_1.getFieldCtx)({
+                    fieldKey: itemKey,
+                    contentKey: itemKey,
+                    ctx: groupItemCtx,
+                });
                 const result = itemCtx.fieldType === customtypes_1.GroupFieldType
                     ? (0, exports.GroupLegacy)(itemCtx).decode(itemValue)
                     : (0, nestable_1.NestableLegacy)(itemCtx).decode(itemValue);
@@ -45,12 +51,14 @@ const GroupItemLegacy = (ctx) => {
             return {
                 value: parsedItems,
                 __TYPE__: exports.GroupItemContentType,
+                key: groupItemCtx.fieldContentKey,
             };
         }));
         return parsed;
     }, (item) => {
+        const groupItemCtx = ctx.withContentKey(`${index}`);
         return item.value.reduce((acc, [key, value]) => {
-            const itemCtx = (0, LegacyContentCtx_1.getFieldCtx)(key, ctx);
+            const itemCtx = (0, LegacyContentCtx_1.getFieldCtx)({ fieldKey: key, ctx });
             const encoded = (0, exports.isGroupContent)(value)
                 ? (0, exports.GroupLegacy)(itemCtx).encode(value)
                 : (0, nestable_1.NestableLegacy)(itemCtx).encode(value);
@@ -59,34 +67,48 @@ const GroupItemLegacy = (ctx) => {
             return {
                 content: { ...acc.content, [key]: encoded.content },
                 types: { ...acc.types, ...encoded.types },
+                keys: { ...acc.keys, ...encoded.keys },
             };
-        }, { content: {}, types: {} });
+        }, { content: {}, types: {}, keys: { [groupItemCtx.keyOfKey]: item.key } });
     });
 };
 exports.GroupItemLegacy = GroupItemLegacy;
+function arrayWithIndexCodec(f) {
+    return new t.Type("ArrayWithIndexCodec", (u) => Array.isArray(u), (items) => (0, function_1.pipe)(t.array(t.unknown).decode(items), fp_ts_1.either.chain((validItems) => {
+        const decodedItems = validItems.map((item, index) => {
+            return f(index).decode(item);
+        });
+        return fp_ts_1.array.sequence(fp_ts_1.either.Applicative)(decodedItems);
+    })), (items) => items.map((item, index) => f(index).encode(item)));
+}
+exports.arrayWithIndexCodec = arrayWithIndexCodec;
 const GroupLegacy = (ctx) => {
-    const codecDecode = t.array(t.union([t.null, (0, exports.GroupItemLegacy)(ctx)]));
-    const codecEncode = t.array((0, exports.GroupItemLegacy)(ctx));
+    const codecDecode = arrayWithIndexCodec((index) => t.union([(0, exports.GroupItemLegacy)(ctx, index), t.null]));
+    const codecEncode = (items) => items.map((item, index) => (0, exports.GroupItemLegacy)(ctx, index).encode(item));
     return new t.Type("GroupLegacy", exports.isGroupContent, (items) => {
         return (0, function_1.pipe)(codecDecode.decode(items), fp_ts_1.either.map((parsedItems) => {
+            const value = parsedItems.map((i, index) => {
+                if (i === null) {
+                    const key = ctx.withContentKey(`${index}`).fieldContentKey;
+                    return { __TYPE__: exports.GroupItemContentType, key, value: [] };
+                }
+                return i;
+            });
             return {
-                value: parsedItems.map((i) => {
-                    if (i === null) {
-                        return { __TYPE__: exports.GroupItemContentType, value: [] };
-                    }
-                    else
-                        return i;
-                }),
+                value,
                 __TYPE__: exports.GroupContentType,
             };
         }));
     }, (g) => {
-        const res = codecEncode.encode(g.value);
+        const res = codecEncode(g.value);
         return {
             content: res.map((block) => block.content),
             types: res.reduce((acc, block) => {
                 return { ...acc, ...block.types };
             }, { [ctx.keyOfType]: customtypes_1.GroupFieldType }),
+            keys: res.reduce((acc, block) => {
+                return { ...acc, ...block.keys };
+            }, {}),
         };
     });
 };
@@ -125,9 +147,9 @@ function traverseGroupContent({ path, key, apiId, model, content, }) {
 exports.traverseGroupContent = traverseGroupContent;
 function traverseGroupItemsContent({ path, model, content, }) {
     return (transform) => {
-        return content.map((groupItem, index) => {
+        return content.map((groupItem) => {
             const groupItemPath = path.concat([
-                { key: index.toString(), type: "GroupItem" },
+                { key: groupItem.key, type: "GroupItem" },
             ]);
             const groupItemFields = groupItem.value.reduce((acc, [fieldKey, fieldContent]) => {
                 const fieldDef = model === null || model === void 0 ? void 0 : model[fieldKey];
@@ -177,6 +199,7 @@ function traverseGroupItemsContent({ path, model, content, }) {
             }, []);
             return {
                 __TYPE__: groupItem.__TYPE__,
+                key: groupItem.key,
                 value: groupItemFields,
             };
         });

package/lib/content/fields/UIDContent.js

@@ -15,6 +15,7 @@ const UIDLegacy = (ctx) => new t.Type("UIDLegacy", exports.isUIDContent, (u) =>
     return {
         content: uid.value,
         types: { [ctx.keyOfType]: "UID" },
+        keys: {},
     };
 });
 exports.UIDLegacy = UIDLegacy;

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

@@ -1541,6 +1541,7 @@ export declare const WidgetContent: t.UnionC<[t.Type<GroupContent, GroupContent,
             }>>]>>;
             repeat: t.ArrayC<t.ExactC<t.TypeC<{
                 __TYPE__: t.LiteralC<"GroupItemContent">;
+                key: t.StringC;
                 value: t.ArrayC<t.TupleC<[t.StringC, t.UnionC<[t.UnionC<[t.ExactC<t.TypeC<{
                     type: t.StringC;
                     __TYPE__: t.LiteralC<"EmptyContent">;
@@ -3075,6 +3076,7 @@ export declare const WidgetContent: t.UnionC<[t.Type<GroupContent, GroupContent,
             }>>]>, t.Type<GroupContent, GroupContent, unknown>]>>;
             items: t.ArrayC<t.ExactC<t.TypeC<{
                 __TYPE__: t.LiteralC<"GroupItemContent">;
+                key: t.StringC;
                 value: t.ArrayC<t.TupleC<[t.StringC, t.UnionC<[t.UnionC<[t.ExactC<t.TypeC<{
                     type: t.StringC;
                     __TYPE__: t.LiteralC<"EmptyContent">;
@@ -6389,6 +6391,7 @@ export declare const isWidgetContent: (u: unknown) => u is {
             };
             repeat: {
                 __TYPE__: "GroupItemContent";
+                key: string;
                 value: [string, {
                     type: string;
                     __TYPE__: "EmptyContent";
@@ -7577,6 +7580,7 @@ export declare const isWidgetContent: (u: unknown) => u is {
             };
             items: {
                 __TYPE__: "GroupItemContent";
+                key: string;
                 value: [string, {
                     type: string;
                     __TYPE__: "EmptyContent";
@@ -9957,6 +9961,7 @@ export declare const WidgetLegacy: (ctx: LegacyContentCtx) => {
                 };
                 repeat: {
                     __TYPE__: "GroupItemContent";
+                    key: string;
                     value: [string, {
                         type: string;
                         __TYPE__: "EmptyContent";
@@ -11145,6 +11150,7 @@ export declare const WidgetLegacy: (ctx: LegacyContentCtx) => {
                 };
                 items: {
                     __TYPE__: "GroupItemContent";
+                    key: string;
                     value: [string, {
                         type: string;
                         __TYPE__: "EmptyContent";

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

@@ -15,6 +15,7 @@ const BooleanLegacy = (ctx) => new t.Type("BooleanLegacy", exports.isBooleanCont
     return {
         content: b.value,
         types: { [ctx.keyOfType]: "Boolean" },
+        keys: {},
     };
 });
 exports.BooleanLegacy = BooleanLegacy;

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

@@ -43,6 +43,7 @@ const EmbedLegacy = (ctx) => new t.Type("EmbedLegacy", exports.isEmbedContent, (
          **/
         content: embed.all,
         types: { [ctx.keyOfType]: "Embed" },
+        keys: {},
     };
 });
 exports.EmbedLegacy = EmbedLegacy;

package/lib/content/fields/nestable/FieldContent/ColorContent.js

@@ -24,6 +24,7 @@ const ColorLegacy = (ctx) => new t.Type("ColorLegacy", exports.isColorContent, (
     return {
         content: b.value,
         types: { [ctx.keyOfType]: widgets_1.ColorFieldType },
+        keys: {},
     };
 });
 exports.ColorLegacy = ColorLegacy;

package/lib/content/fields/nestable/FieldContent/DateContent.js

@@ -24,6 +24,7 @@ const DateLegacy = (ctx) => new t.Type("DateLegacy", exports.isDateContent, (u)
     return {
         content: b.value,
         types: { [ctx.keyOfType]: widgets_1.DateFieldType },
+        keys: {},
     };
 });
 exports.DateLegacy = DateLegacy;

package/lib/content/fields/nestable/FieldContent/NumberContent.js

@@ -24,6 +24,7 @@ const NumberLegacy = (ctx) => new t.Type("NumberLegacy", exports.isNumberContent
     return {
         content: b.value,
         types: { [ctx.keyOfType]: widgets_1.NumberFieldType },
+        keys: {},
     };
 });
 exports.NumberLegacy = NumberLegacy;

package/lib/content/fields/nestable/FieldContent/RangeContent.js

@@ -24,6 +24,7 @@ const RangeLegacy = (ctx) => new t.Type("RangeLegacy", exports.isRangeContent, (
     return {
         content: b.value,
         types: { [ctx.keyOfType]: widgets_1.RangeFieldType },
+        keys: {},
     };
 });
 exports.RangeLegacy = RangeLegacy;

package/lib/content/fields/nestable/FieldContent/SelectContent.js

@@ -24,6 +24,7 @@ const SelectLegacy = (ctx) => new t.Type("SelectLegacy", exports.isSelectContent
     return {
         content: b.value,
         types: { [ctx.keyOfType]: widgets_1.SelectFieldType },
+        keys: {},
     };
 });
 exports.SelectLegacy = SelectLegacy;

package/lib/content/fields/nestable/FieldContent/TextContent.js

@@ -24,6 +24,7 @@ const TextLegacy = (ctx) => new t.Type("TextLegacy", exports.isTextContent, (u)
     return {
         content: b.value,
         types: { [ctx.keyOfType]: widgets_1.TextFieldType },
+        keys: {},
     };
 });
 exports.TextLegacy = TextLegacy;

package/lib/content/fields/nestable/FieldContent/TimestampContent.js

@@ -24,6 +24,7 @@ const TimestampLegacy = (ctx) => new t.Type("TimestampLegacy", exports.isTimesta
     return {
         content: b.value,
         types: { [ctx.keyOfType]: widgets_1.TimestampFieldType },
+        keys: {},
     };
 });
 exports.TimestampLegacy = TimestampLegacy;