@prismicio/types-internal/lib/content/fields/RepeatableContent.js

Prismic types for Custom Types and Prismic Data

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
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(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)(codecDecode.decode(items), fp_ts_1.either.map((items) => {
            const parsedItems = items.reduce((acc, item) => {
                let result;
                switch (fieldType) {
                    case "Link":
                        result = (0, nestable_1.LinkContentLegacy)(ctx).decode(item);
                        break;
                }
                if (!result)
                    return acc;
                if ((0, Either_1.isLeft)(result))
                    return acc;
                return [...acc, result.right];
            }, []);
            return {
                value: parsedItems,
                type: fieldType,
                __TYPE__: exports.RepeatableContentType,
            };
        }));
        return parsed;
    }, (r) => {
        const res = codecEncode.encode(r.value);
        const encodedItems = res.reduce((acc, item) => {
            let encoded;
            switch (item.__TYPE__) {
                case nestable_1.LinkContentType:
                    encoded = (0, nestable_1.LinkContentLegacy)(ctx).encode(item);
                    break;
            }
            if (!encoded)
                return acc;
            return [...acc, encoded];
        }, []);
        return {
            content: encodedItems.map((encodedItem) => encodedItem.content),
            types: { [ctx.keyOfType]: `Repeatable.${fieldType}` },
        };
    });
};
exports.RepeatableLegacy = RepeatableLegacy;
function traverseRepeatableContent({ path, key, apiId, model, content, }) {
    return (transform) => {
        const items = content.value.reduce((acc, fieldContent, index) => {
            const itemPath = path.concat([
                { key: index.toString(), type: "Widget" },
            ]);
            const transformedField = transform({
                path: itemPath,
                key: key,
                apiId: apiId,
                model: model,
                content: fieldContent,
            });
            // Can happen if the transform function returns undefined to filter out a field
            if (!transformedField)
                return acc;
            return acc.concat(transformedField);
        }, []);
        return transform({
            path,
            key,
            apiId,
            model,
            content: {
                __TYPE__: content.__TYPE__,
                type: content.type,
                value: items,
            },
        });
    };
}
exports.traverseRepeatableContent = traverseRepeatableContent;