@prismicio/types-internal 2.2.0-traverse.alpha-12 → 2.2.0

package/lib/import/validators/fields/ImportGroup.d.ts

@@ -0,0 +1,345 @@
+import * as t from "io-ts";
+export declare const ImportGroupValue: (groupCustomType?: ({
+    type: "Group";
+} & {
+    fieldset?: string | null | undefined;
+    icon?: string;
+    description?: string;
+    config?: {
+        label?: string | null | undefined;
+        repeat?: boolean;
+        fields?: {
+            [x: string]: ({
+                type: "Boolean";
+            } & {
+                config?: {
+                    label?: string | null | undefined;
+                    default_value?: boolean;
+                    placeholder_true?: string;
+                    placeholder_false?: string;
+                };
+            }) | ({
+                type: "Color";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                };
+            }) | ({
+                type: "Date";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default?: string;
+                };
+            }) | ({
+                type: "Embed";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    useAsTitle?: boolean;
+                };
+            }) | ({
+                type: "GeoPoint";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                };
+            }) | ({
+                type: "Image";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    constraint?: {
+                        width?: number | null;
+                        height?: number | null;
+                    };
+                    thumbnails?: readonly ({
+                        name: string;
+                    } & {
+                        width?: number | null;
+                        height?: number | null;
+                    })[];
+                };
+            }) | ({
+                type: "IntegrationFields";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    catalog?: string;
+                };
+            }) | ({
+                type: "Link";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    useAsTitle?: boolean;
+                    placeholder?: string;
+                    select?: "media" | "document" | "web" | null;
+                    customtypes?: readonly string[];
+                    masks?: readonly string[];
+                    tags?: readonly string[];
+                    allowTargetBlank?: boolean;
+                };
+            }) | ({
+                type: "Number";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    min?: number;
+                    max?: number;
+                    step?: number;
+                };
+            }) | ({
+                type: "Range";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    min?: number;
+                    max?: number;
+                    step?: number;
+                };
+            }) | ({
+                type: "StructuredText";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    useAsTitle?: boolean;
+                    single?: string;
+                    multi?: string;
+                    imageConstraint?: {
+                        width?: number | null;
+                        height?: number | null;
+                    };
+                    labels?: readonly string[];
+                    allowTargetBlank?: boolean;
+                };
+            }) | ({
+                type: "Select";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default_value?: string;
+                    options?: readonly string[];
+                };
+            }) | ({
+                type: "Separator";
+            } & {
+                config?: {
+                    label?: string | null | undefined;
+                };
+            }) | ({
+                type: "Text";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    useAsTitle?: boolean;
+                    placeholder?: string;
+                };
+            }) | ({
+                type: "Timestamp";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default?: string;
+                };
+            });
+        };
+    };
+}) | undefined) => t.Type<import("./RepeatableZoneItem").RepeatableZoneItem[], import("./RepeatableZoneItem").RepeatableZoneItem[], unknown>;
+export declare const ImportGroup: (groupCustomType?: ({
+    type: "Group";
+} & {
+    fieldset?: string | null | undefined;
+    icon?: string;
+    description?: string;
+    config?: {
+        label?: string | null | undefined;
+        repeat?: boolean;
+        fields?: {
+            [x: string]: ({
+                type: "Boolean";
+            } & {
+                config?: {
+                    label?: string | null | undefined;
+                    default_value?: boolean;
+                    placeholder_true?: string;
+                    placeholder_false?: string;
+                };
+            }) | ({
+                type: "Color";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                };
+            }) | ({
+                type: "Date";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default?: string;
+                };
+            }) | ({
+                type: "Embed";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    useAsTitle?: boolean;
+                };
+            }) | ({
+                type: "GeoPoint";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                };
+            }) | ({
+                type: "Image";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    constraint?: {
+                        width?: number | null;
+                        height?: number | null;
+                    };
+                    thumbnails?: readonly ({
+                        name: string;
+                    } & {
+                        width?: number | null;
+                        height?: number | null;
+                    })[];
+                };
+            }) | ({
+                type: "IntegrationFields";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    catalog?: string;
+                };
+            }) | ({
+                type: "Link";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    useAsTitle?: boolean;
+                    placeholder?: string;
+                    select?: "media" | "document" | "web" | null;
+                    customtypes?: readonly string[];
+                    masks?: readonly string[];
+                    tags?: readonly string[];
+                    allowTargetBlank?: boolean;
+                };
+            }) | ({
+                type: "Number";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    min?: number;
+                    max?: number;
+                    step?: number;
+                };
+            }) | ({
+                type: "Range";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    min?: number;
+                    max?: number;
+                    step?: number;
+                };
+            }) | ({
+                type: "StructuredText";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    useAsTitle?: boolean;
+                    single?: string;
+                    multi?: string;
+                    imageConstraint?: {
+                        width?: number | null;
+                        height?: number | null;
+                    };
+                    labels?: readonly string[];
+                    allowTargetBlank?: boolean;
+                };
+            }) | ({
+                type: "Select";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default_value?: string;
+                    options?: readonly string[];
+                };
+            }) | ({
+                type: "Separator";
+            } & {
+                config?: {
+                    label?: string | null | undefined;
+                };
+            }) | ({
+                type: "Text";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    useAsTitle?: boolean;
+                    placeholder?: string;
+                };
+            }) | ({
+                type: "Timestamp";
+            } & {
+                fieldset?: string | null | undefined;
+                config?: {
+                    label?: string | null | undefined;
+                    placeholder?: string;
+                    default?: string;
+                };
+            });
+        };
+    };
+}) | undefined) => t.Type<{
+    type: "Group";
+    value: import("./RepeatableZoneItem").RepeatableZoneItem[] | null;
+}, import("./RepeatableZoneItem").RepeatableZoneItem[] | undefined, unknown>;
+export declare type ImportGroup = t.TypeOf<ReturnType<typeof ImportGroup>>;

package/lib/import/validators/fields/ImportGroup.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportGroup = exports.ImportGroupValue = void 0;
+const tslib_1 = require("tslib");
+const E = (0, tslib_1.__importStar)(require("fp-ts/Either"));
+const function_1 = require("fp-ts/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../validators");
+const function_2 = require("../../../validators/function");
+const ImportContent_1 = require("./ImportContent");
+const RepeatableZone_1 = require("./RepeatableZone");
+const ImportGroupValue = (groupCustomType) => {
+    var _a, _b;
+    const fieldsModel = (_b = (_a = groupCustomType === null || groupCustomType === void 0 ? void 0 : groupCustomType.config) === null || _a === void 0 ? void 0 : _a.fields) !== null && _b !== void 0 ? _b : {};
+    const groupArrayCodec = (0, RepeatableZone_1.RepeatableZone)(fieldsModel);
+    return (0, function_2.withCustomError)(new t.Type(groupArrayCodec.name, groupArrayCodec.is, (u, c) => (0, function_1.pipe)(groupArrayCodec.validate(u, c), E.chain((groups) => {
+        var _a;
+        if (((_a = groupCustomType === null || groupCustomType === void 0 ? void 0 : groupCustomType.config) === null || _a === void 0 ? void 0 : _a.repeat) === false &&
+            groups.length > 1) {
+            return t.failure(groups, c, "The custom type for this group field does not allow multiple group items");
+        }
+        return t.success(groups);
+    })), t.identity), () => "The group field value must be an array");
+};
+exports.ImportGroupValue = ImportGroupValue;
+const ImportGroup = (groupCustomType) => (0, ImportContent_1.ImportContent)("Group", (0, validators_1.EmptyArrayOrElse)((0, exports.ImportGroupValue)(groupCustomType)));
+exports.ImportGroup = ImportGroup;

package/lib/import/validators/fields/ImportSlices/SharedSlice/SharedSlice.d.ts

@@ -1,13 +1,15 @@
 import * as t from "io-ts";
 import type { SharedSlice as SharedSliceCustomType } from "../../../../../customtypes";
-import { SharedSliceContent, SharedSliceId } from "./fields";
+import { RepeatableZone } from "../../RepeatableZone";
+import { RepeatableZoneItem } from "../../RepeatableZoneItem";
+import { SharedSliceId } from "./fields";
 export declare type SharedSlice = {
     id: SharedSliceId | null | undefined;
     slice_type: string;
     name: string;
     variation: string;
-    primary: SharedSliceContent | null | undefined;
-    items: SharedSliceContent[] | null | undefined;
+    primary: RepeatableZoneItem | null | undefined;
+    items: RepeatableZone | null | undefined;
     slice_label: string | null | undefined;
     version: string | null | undefined;
 };

package/lib/import/validators/fields/ImportSlices/SharedSlice/SharedSlice.js

@@ -6,7 +6,8 @@ const E = (0, tslib_1.__importStar)(require("fp-ts/Either"));
 const function_1 = require("fp-ts/function");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
 const validators_1 = require("../../../../../validators");
-const function_2 = require("../../../../../validators/function");
+const RepeatableZone_1 = require("../../RepeatableZone");
+const RepeatableZoneItem_1 = require("../../RepeatableZoneItem");
 const fields_1 = require("./fields");
 const SharedSliceShape = t.strict({
     id: fields_1.OptionalSharedSliceId,
@@ -43,9 +44,8 @@ t
     // We validate the 'primary' and 'items' content fields, for which we need the Variation custom type retrieved in the previous step
     t
         .partial({
-        primary: (0, fields_1.SharedSliceContent)(decoded.slice_type.slice_type, "primary", (_a = decoded.variation.data.primary) !== null && _a !== void 0 ? _a : {}),
-        // We need to use this wrapper codec instead of using t.array(SharedSliceContent) directly in order to get proper custom error messages
-        items: (0, function_2.withCustomError)(t.array((0, fields_1.SharedSliceContent)(decoded.slice_type.slice_type, "items", (_b = decoded.variation.data.items) !== null && _b !== void 0 ? _b : {})), () => "The value must be an array"),
+        primary: (0, RepeatableZoneItem_1.RepeatableZoneItem)((_a = decoded.variation.data.primary) !== null && _a !== void 0 ? _a : {}),
+        items: (0, RepeatableZone_1.RepeatableZone)((_b = decoded.variation.data.items) !== null && _b !== void 0 ? _b : {}),
     })
         .validate(u, c), E.map(({ primary, items }) => ({ ...decoded, primary, items })));
 }), E.map(({ id, slice_type, variation, primary, items, slice_label, version, }) => ({

package/lib/import/validators/fields/ImportSlices/SharedSlice/fields/index.d.ts

@@ -1,5 +1,4 @@
 export * from "./OptionalSharedSliceId";
-export * from "./SharedSliceContent";
 export * from "./SharedSliceId";
 export * from "./SharedSliceType";
 export * from "./SharedSliceVariation";

package/lib/import/validators/fields/ImportSlices/SharedSlice/fields/index.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 (0, tslib_1.__exportStar)(require("./OptionalSharedSliceId"), exports);
-(0, tslib_1.__exportStar)(require("./SharedSliceContent"), exports);
 (0, tslib_1.__exportStar)(require("./SharedSliceId"), exports);
 (0, tslib_1.__exportStar)(require("./SharedSliceType"), exports);
 (0, tslib_1.__exportStar)(require("./SharedSliceVariation"), exports);

package/lib/import/validators/fields/RepeatableZone.d.ts

@@ -0,0 +1,11 @@
+import * as t from "io-ts";
+import type { WidgetKey } from "../../../common";
+import type { NestableWidget } from "../../../customtypes";
+import { RepeatableZoneItem } from "./RepeatableZoneItem";
+export declare type RepeatableZone = t.TypeOf<ReturnType<typeof RepeatableZone>>;
+/**
+ * A custom type for a repeatable zone. This type of structure can be found 'items' field of a slice or in the group field.
+ *
+ * @param fieldModels a record of all nestable widgets that can be used in the zone
+ */
+export declare const RepeatableZone: (fieldModels: Record<WidgetKey, NestableWidget>) => t.ArrayC<t.Type<RepeatableZoneItem, RepeatableZoneItem, unknown>>;

package/lib/import/validators/fields/RepeatableZone.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepeatableZone = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const function_1 = require("../../../validators/function");
+const RepeatableZoneItem_1 = require("./RepeatableZoneItem");
+/**
+ * A custom type for a repeatable zone. This type of structure can be found 'items' field of a slice or in the group field.
+ *
+ * @param fieldModels a record of all nestable widgets that can be used in the zone
+ */
+const RepeatableZone = (fieldModels) => (0, function_1.withCustomError)(t.array((0, RepeatableZoneItem_1.RepeatableZoneItem)(fieldModels)), () => "The repeatable zone value must be an array");
+exports.RepeatableZone = RepeatableZone;

package/lib/import/validators/fields/RepeatableZoneItem.d.ts

@@ -0,0 +1,11 @@
+import * as t from "io-ts";
+import { WidgetKey } from "../../../common";
+import type { NestableWidget } from "../../../customtypes";
+import { ImportNestable } from "./nestable";
+export declare type RepeatableZoneItem = Record<WidgetKey, ImportNestable>;
+/**
+ * A custom type for an item of a repeatable zone. This type of structure can be found in the 'primary' and 'items' fields of a slice or in the group field.
+ *
+ * @param fieldModels a record of all nestable widgets that can be used in the zone
+ */
+export declare const RepeatableZoneItem: (fieldModels: Record<WidgetKey, NestableWidget>) => t.Type<RepeatableZoneItem, RepeatableZoneItem, unknown>;

package/lib/import/validators/fields/RepeatableZoneItem.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepeatableZoneItem = void 0;
+const tslib_1 = require("tslib");
+const E = (0, tslib_1.__importStar)(require("fp-ts/Either"));
+const function_1 = require("fp-ts/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const common_1 = require("../../../common");
+const function_2 = require("../../../validators/function");
+const nestable_1 = require("./nestable");
+/**
+ * A custom type for an item of a repeatable zone. This type of structure can be found in the 'primary' and 'items' fields of a slice or in the group field.
+ *
+ * @param fieldModels a record of all nestable widgets that can be used in the zone
+ */
+const RepeatableZoneItem = (fieldModels) => new t.Type("RepeatableZoneItem", (u) => t.record(common_1.WidgetKey, t.unknown).is(u) &&
+    Object.values(u).reduce((acc, value) => acc && nestable_1.ImportNestable.is(value), true), (u, c) => {
+    const codecEntries = Object.entries(fieldModels).map(([key, model]) => [key, nestable_1.ImportNestable.getCodec(model)]);
+    const groupCodec = (0, function_2.withCustomError)(t.partial({
+        ...Object.fromEntries(codecEntries),
+    }), () => "The value must be an object");
+    return (0, function_1.pipe)(groupCodec.validate(u, c), E.chain((decodedContent) => {
+        // Validate if all fields are present in the model
+        const keys = Object.keys(decodedContent);
+        const errors = keys.flatMap((key) => fieldModels[key]
+            ? []
+            : [
+                {
+                    value: decodedContent[key],
+                    context: c,
+                    message: `The field '${key}' is not defined in the custom type`,
+                },
+            ]);
+        return errors.length > 0
+            ? t.failures(errors)
+            : t.success(decodedContent); // We can never have a key with decoded value 'undefined' so we can ignore the type derived from t.partial
+    }));
+}, t.identity);
+exports.RepeatableZoneItem = RepeatableZoneItem;

package/lib/import/validators/fields/index.d.ts

@@ -1,2 +1,4 @@
 export * from "./nestable";
+export * from "./RepeatableZone";
+export * from "./RepeatableZoneItem";
 export * from "./UID";

package/lib/import/validators/fields/index.js

@@ -2,4 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 (0, tslib_1.__exportStar)(require("./nestable"), exports);
+(0, tslib_1.__exportStar)(require("./RepeatableZone"), exports);
+(0, tslib_1.__exportStar)(require("./RepeatableZoneItem"), exports);
 (0, tslib_1.__exportStar)(require("./UID"), exports);

package/lib/import/validators/fields/nestable/Nestable.d.ts

@@ -129,4 +129,64 @@ export declare const ImportNestable: {
             value: boolean | null;
         }>;
     };
+    getCodec: (field: NestableWidget) => import("io-ts").Type<{
+        type: "Boolean";
+        value: boolean | null;
+    }, boolean | undefined, unknown> | import("io-ts").Type<{
+        type: "Color";
+        value: `#${string}` | null;
+    }, string | undefined, unknown> | import("io-ts").Type<{
+        type: "Date";
+        value: Date | null;
+    }, Date | undefined, unknown> | import("io-ts").Type<{
+        type: "Embed";
+        value: {
+            embed_url: string;
+        } | null;
+    }, {
+        embed_url: string;
+    } | undefined, unknown> | import("io-ts").Type<{
+        type: "GeoPoint";
+        value: {
+            latitude: number;
+            longitude: number;
+        } | null;
+    }, {
+        latitude: number;
+        longitude: number;
+    } | undefined, unknown> | import("io-ts").Type<{
+        type: "Image";
+        value: import("./Image").ImageFieldWithThumbnails | null;
+    }, import("./Image").ImageFieldWithThumbnails | undefined, unknown> | import("io-ts").Type<{
+        type: "Link";
+        value: ({
+            link_type: "Web";
+            url: string;
+        } & {
+            target?: string;
+        }) | {
+            link_type: "Document";
+            id: string;
+        } | {
+            link_type: "Media";
+            id: string;
+        } | null;
+    }, {
+        link_type: "Document" | "Web" | "Media";
+    } | undefined, unknown> | import("io-ts").Type<{
+        type: "StructuredText";
+        value: import("./ImportRichText").ImportBlock[] | null;
+    }, import("./ImportRichText").ImportBlock[] | undefined, unknown> | import("io-ts").Type<{
+        type: "Number";
+        value: number | null;
+    }, number | undefined, unknown> | import("io-ts").Type<{
+        type: "Select";
+        value: string | null;
+    }, string | undefined, unknown> | import("io-ts").Type<{
+        type: "Text";
+        value: string | null;
+    }, string | undefined, unknown> | import("io-ts").Type<{
+        type: "Timestamp";
+        value: Date | null;
+    }, Date | undefined, unknown>;
 };

package/lib/import/validators/fields/nestable/Nestable.js

@@ -13,6 +13,36 @@ const Number_1 = require("./Number");
 const Select_1 = require("./Select");
 const Text_1 = require("./Text");
 const Timestamp_1 = require("./Timestamp");
+const getCodecOrThrow = (field) => {
+    switch (field.type) {
+        case "Boolean":
+            return Boolean_1.ImportBoolean;
+        case "Color":
+            return Color_1.ImportColor;
+        case "Number":
+            return (0, Number_1.ImportNumber)(field);
+        case "Select":
+            return (0, Select_1.ImportSelect)(field);
+        case "Text":
+            return Text_1.ImportText;
+        case "Date":
+            return Date_1.ImportDate;
+        case "Timestamp":
+            return Timestamp_1.ImportTimestamp;
+        case "Embed":
+            return Embed_1.ImportEmbed;
+        case "Link":
+            return Link_1.ImportLink;
+        case "Image":
+            return (0, Image_1.ImportImage)(field);
+        case "GeoPoint":
+            return GeoPoint_1.ImportGeoPoint;
+        case "StructuredText":
+            return (0, ImportRichText_1.ImportRichText)(field);
+        default:
+            throw new Error(`Unsupported type of nestable field ${field.type}`);
+    }
+};
 exports.ImportNestable = {
     is(u) {
         return (Boolean_1.ImportBoolean.is(u) ||
@@ -30,40 +60,12 @@ exports.ImportNestable = {
     },
     decode: (field) => {
         return (content) => {
-            const codec = (() => {
-                switch (field.type) {
-                    case "Boolean":
-                        return Boolean_1.ImportBoolean;
-                    case "Color":
-                        return Color_1.ImportColor;
-                    case "Number":
-                        return (0, Number_1.ImportNumber)(field);
-                    case "Select":
-                        return (0, Select_1.ImportSelect)(field);
-                    case "Text":
-                        return Text_1.ImportText;
-                    case "Date":
-                        return Date_1.ImportDate;
-                    case "Timestamp":
-                        return Timestamp_1.ImportTimestamp;
-                    case "Embed":
-                        return Embed_1.ImportEmbed;
-                    case "Link":
-                        return Link_1.ImportLink;
-                    case "Image":
-                        return (0, Image_1.ImportImage)(field);
-                    case "GeoPoint":
-                        return GeoPoint_1.ImportGeoPoint;
-                    case "StructuredText":
-                        return (0, ImportRichText_1.ImportRichText)(field);
-                    default:
-                        throw new Error(`Unsupported type of nestable field ${field.type}`);
-                }
-            })();
+            const codec = getCodecOrThrow(field);
             return {
                 codec,
                 result: codec.decode(content),
             };
         };
     },
+    getCodec: getCodecOrThrow,
 };