@prismicio/types-internal/lib/customtypes/widgets/slices/Slices.js

Prismic types for Custom Types and Prismic Data

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.traverseSlices = exports.Slices = exports.DynamicSlices = exports.StaticSlices = exports.slicesReader = exports.DynamicSlicesConfig = exports.StaticSlicesConfig = exports.slicesConfigReader = exports.SlicesLabels = exports.SlicesFieldType = exports.LegacySlicesFieldType = void 0;
const tslib_1 = require("tslib");
const t = (0, tslib_1.__importStar)(require("io-ts"));
const common_1 = require("../../../common");
const validators_1 = require("../../../validators");
const Group_1 = require("../Group");
const CompositeSlice_1 = require("./CompositeSlice");
const LegacySlice_1 = require("./LegacySlice");
const SharedSlice_1 = require("./SharedSlice");
const SharedSliceRef_1 = require("./SharedSliceRef");
exports.LegacySlicesFieldType = "Choice";
exports.SlicesFieldType = "Slices";
exports.SlicesLabels = t.union([
    t.record(t.string, t.readonlyArray(t.exact(t.intersection([
        t.type({
            name: t.string,
        }),
        t.partial({
            display: t.string,
        }),
    ])))),
    t.null,
]);
function slicesConfigReader(codec) {
    return t.exact(t.partial({
        label: validators_1.StringOrNull,
        labels: exports.SlicesLabels,
        choices: t.record(common_1.WidgetKey, t.union([LegacySlice_1.LegacySlice, CompositeSlice_1.CompositeSlice, codec])),
    }));
}
exports.slicesConfigReader = slicesConfigReader;
exports.StaticSlicesConfig = slicesConfigReader(SharedSlice_1.SharedSlice);
exports.DynamicSlicesConfig = slicesConfigReader(SharedSliceRef_1.SharedSliceRef);
const SlicesConfig = {
    toStatic(config, sharedSlices) {
        const choices = Object.entries(config.choices || {}).reduce((acc, [ref, slice]) => {
            if (slice.type === "SharedSlice") {
                const sharedSlice = sharedSlices.get(ref);
                if (sharedSlice)
                    return { ...acc, [ref]: sharedSlice };
                else
                    return acc;
            }
            else {
                return { ...acc, [ref]: slice };
            }
        }, {});
        return { ...config, choices };
    },
};
function slicesReader(codec) {
    return t.exact(t.intersection([
        t.type({
            type: t.keyof({
                [exports.SlicesFieldType]: null,
                [exports.LegacySlicesFieldType]: null,
            }),
        }),
        t.partial({
            fieldset: validators_1.StringOrNull,
            config: codec,
        }),
    ]));
}
exports.slicesReader = slicesReader;
exports.StaticSlices = slicesReader(exports.StaticSlicesConfig);
exports.DynamicSlices = slicesReader(exports.DynamicSlicesConfig);
exports.Slices = {
    toStatic(slices, sharedSlices) {
        if (!slices.config)
            return slices;
        else {
            return {
                ...slices,
                config: SlicesConfig.toStatic(slices.config, sharedSlices),
            };
        }
    },
};
function traverseSlices(args) {
    var _a;
    const { path: prevPath, slices, onField } = args;
    if (!((_a = slices.config) === null || _a === void 0 ? void 0 : _a.choices))
        return slices;
    let choices;
    for (const [key, prevModel] of Object.entries(slices.config.choices)) {
        const path = [...prevPath, key];
        let model;
        switch (prevModel.type) {
            case "Slice":
                model = (0, CompositeSlice_1.traverseCompositeSlice)({
                    path,
                    slice: prevModel,
                    onField: onField,
                });
                break;
            case "SharedSlice":
                if ("variations" in prevModel)
                    model = (0, SharedSlice_1.traverseSharedSlice)({
                        path,
                        slice: prevModel,
                        onField,
                    });
                else
                    model = prevModel;
                break;
            // Group and other fields are technically possible because of legacy slices.
            case "Group":
                model = onField({
                    path,
                    key,
                    field: (0, Group_1.traverseNestedGroup)({
                        path,
                        group: prevModel,
                        onField: onField,
                    }),
                });
                break;
            default:
                model = onField({
                    path,
                    key,
                    field: prevModel,
                });
                break;
        }
        if (model !== prevModel) {
            if (!choices)
                choices = { ...slices.config.choices };
            choices[key] = model;
        }
    }
    // returns the traversed model instead of a new one if it didn't change
    return choices
        ? {
            ...slices,
            config: {
                ...slices.config,
                choices,
            },
        }
        : slices;
}
exports.traverseSlices = traverseSlices;