@prismicio/types-internal 3.17.0-pr.145.680cd65 → 3.17.2

package/lib/content/fields/slices/SlicesContent.js

@@ -0,0 +1,465 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traverseSlicesWithModel = exports.traverseSharedSliceContentWithModel = exports.traverseSlices = exports.slicesContentWithDefaultValues = exports.SlicesContent = exports.SlicesLegacy = exports.isSlicesContent = exports.SlicesContentType = void 0;
+const tslib_1 = require("tslib");
+const fp_ts_1 = require("fp-ts");
+const function_1 = require("fp-ts/lib/function");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const customtypes_1 = require("../../../customtypes");
+const utils_1 = require("../../utils");
+const utils_2 = require("../../utils");
+const GroupContent_1 = require("../GroupContent");
+const nestable_1 = require("../nestable");
+const CompositeSliceContent_1 = require("./Slice/CompositeSliceContent");
+const SharedSliceContent_1 = require("./Slice/SharedSliceContent");
+const SimpleSliceContent_1 = require("./Slice/SimpleSliceContent");
+const SliceItem_1 = require("./SliceItem");
+exports.SlicesContentType = "SliceContentType";
+const isSlicesContent = (u) => (0, utils_2.hasContentType)(u) && u.__TYPE__ === exports.SlicesContentType;
+exports.isSlicesContent = isSlicesContent;
+const SlicesLegacy = (ctx) => {
+    const codec = t.array((0, SliceItem_1.SlicesItemLegacy)(ctx));
+    return new t.Type("SlicesLegacy", exports.isSlicesContent, (items) => {
+        return (0, function_1.pipe)(codec.decode(items), fp_ts_1.either.map((parsedSlices) => {
+            return {
+                __TYPE__: exports.SlicesContentType,
+                value: parsedSlices,
+            };
+        }));
+    }, (s) => {
+        const result = codec.encode(s.value);
+        return {
+            content: result.map((s) => s.content),
+            types: result.reduce((acc, s) => ({ ...acc, ...s.types }), { [ctx.keyOfType]: "Slices" }),
+            keys: result.reduce((acc, s) => ({ ...acc, ...s.keys }), {}),
+        };
+    });
+};
+exports.SlicesLegacy = SlicesLegacy;
+exports.SlicesContent = t.type({
+    __TYPE__: t.literal(exports.SlicesContentType),
+    value: t.array(SliceItem_1.SliceItemContent),
+});
+function slicesContentWithDefaultValues(codec, content) {
+    var _a;
+    const choices = (_a = codec === null || codec === void 0 ? void 0 : codec.config) === null || _a === void 0 ? void 0 : _a.choices;
+    if (choices === undefined)
+        return content;
+    const updateSlicesValue = content.value.map((slice) => {
+        const sliceConfig = choices[slice.name];
+        if (sliceConfig) {
+            const updatedSliceWidget = (0, SliceItem_1.sliceItemContentWithDefaultValues)(sliceConfig, slice.widget);
+            return {
+                ...slice,
+                widget: updatedSliceWidget,
+            };
+        }
+        return slice;
+    });
+    return {
+        ...content,
+        value: updateSlicesValue,
+    };
+}
+exports.slicesContentWithDefaultValues = slicesContentWithDefaultValues;
+function findSliceModel(slicesPath, model, content) {
+    var _a, _b;
+    const defaultModel = (_b = (_a = model === null || model === void 0 ? void 0 : model.config) === null || _a === void 0 ? void 0 : _a.choices) === null || _b === void 0 ? void 0 : _b[content.name];
+    // regular case for shared slices
+    const sharedSliceModel = () => {
+        if ((0, SliceItem_1.isSharedSliceItemContent)(content)) {
+            if (defaultModel && (0, customtypes_1.isStaticSharedSlice)(defaultModel)) {
+                const variationDef = defaultModel.variations.find((v) => v.id === content.widget.variation);
+                return variationDef
+                    ? {
+                        type: "SharedSlice",
+                        sliceName: defaultModel.id,
+                        variationId: variationDef.id,
+                        fields: {
+                            primary: variationDef.primary || {},
+                            items: variationDef.items || {},
+                        },
+                    }
+                    : undefined;
+            }
+        }
+        return;
+    };
+    const migratedSliceModel = () => {
+        var _a;
+        const legacyContentPath = utils_1.ContentPath.append(utils_1.ContentPath.serialize(slicesPath), content.name);
+        const migratedSliceModel = Object.values(((_a = model === null || model === void 0 ? void 0 : model.config) === null || _a === void 0 ? void 0 : _a.choices) || {}).find((sliceModel) => {
+            var _a;
+            if ((0, customtypes_1.isStaticSharedSlice)(sliceModel)) {
+                return !!((_a = sliceModel.legacyPaths) === null || _a === void 0 ? void 0 : _a[legacyContentPath]);
+            }
+            return false;
+        });
+        if (!migratedSliceModel)
+            return;
+        const migratedVariation = migratedSliceModel === null || migratedSliceModel === void 0 ? void 0 : migratedSliceModel.variations.find((v) => { var _a; return v.id === ((_a = migratedSliceModel.legacyPaths) === null || _a === void 0 ? void 0 : _a[legacyContentPath]); });
+        if (!migratedVariation)
+            return;
+        return {
+            type: "SharedSlice",
+            sliceName: migratedSliceModel.id,
+            variationId: migratedVariation.id,
+            fields: {
+                primary: migratedVariation.primary || {},
+                items: migratedVariation.items || {},
+            },
+        };
+    };
+    const legacySliceModel = () => {
+        if (!defaultModel)
+            return;
+        if ((0, customtypes_1.isCompositeSlice)(defaultModel)) {
+            return {
+                type: "Slice",
+                "non-repeat": defaultModel["non-repeat"] || {},
+                repeat: defaultModel.repeat || {},
+            };
+        }
+        if ((0, customtypes_1.isLegacySlice)(defaultModel)) {
+            return defaultModel;
+        }
+        return;
+    };
+    return sharedSliceModel() || migratedSliceModel() || legacySliceModel();
+}
+function traverseSlices({ path, key, model, content, }) {
+    return ({ transformWidget = ({ content }) => content, transformSlice = ({ content }) => content, }) => {
+        const value = content.value.reduce((acc, sliceContent) => {
+            const sliceModel = model && findSliceModel(path, model, sliceContent);
+            const convertedSlice = (() => {
+                if ((0, SliceItem_1.isSharedSliceItemContent)(sliceContent))
+                    return (0, SharedSliceContent_1.traverseSharedSliceContent)({
+                        path: path.concat({
+                            key: sliceContent.key,
+                            type: "SharedSlice",
+                        }),
+                        sliceKey: sliceContent.key,
+                        sliceName: sliceContent.name,
+                        model: (sliceModel === null || sliceModel === void 0 ? void 0 : sliceModel.type) === "SharedSlice" ? sliceModel : undefined,
+                        content: sliceContent,
+                    })(transformWidget, transformSlice);
+                if ((0, SliceItem_1.isCompositeSliceItemContent)(sliceContent))
+                    return (0, CompositeSliceContent_1.traverseCompositeSliceContent)({
+                        path: path.concat({
+                            key: sliceContent.key,
+                            type: "Slice",
+                        }),
+                        sliceKey: sliceContent.key,
+                        sliceName: sliceContent.name,
+                        model: (sliceModel === null || sliceModel === void 0 ? void 0 : sliceModel.type) === "Slice" ||
+                            (sliceModel === null || sliceModel === void 0 ? void 0 : sliceModel.type) === "SharedSlice"
+                            ? sliceModel
+                            : undefined,
+                        content: sliceContent,
+                    })(transformWidget, transformSlice);
+                if ((0, SliceItem_1.isSimpleSliceItemContent)(sliceContent))
+                    return (0, SimpleSliceContent_1.traverseSimpleSliceContent)({
+                        path: path.concat({
+                            key: sliceContent.key,
+                            type: "LegacySlice",
+                        }),
+                        sliceKey: sliceContent.key,
+                        sliceName: sliceContent.name,
+                        model: sliceModel && (sliceModel === null || sliceModel === void 0 ? void 0 : sliceModel.type) !== "Slice"
+                            ? sliceModel
+                            : undefined,
+                        content: sliceContent,
+                    })(transformWidget, transformSlice);
+                return;
+            })();
+            return convertedSlice ? acc.concat(convertedSlice) : acc;
+        }, []);
+        return transformWidget({
+            path,
+            key,
+            apiId: key,
+            model,
+            content: {
+                __TYPE__: content.__TYPE__,
+                value,
+            },
+        });
+    };
+}
+exports.traverseSlices = traverseSlices;
+function buildVariationFields(sharedSlice, variation) {
+    var _a, _b;
+    return {
+        type: "SharedSlice",
+        sliceName: sharedSlice.id,
+        variationId: variation.id,
+        fields: {
+            primary: (_a = variation.primary) !== null && _a !== void 0 ? _a : {},
+            items: (_b = variation.items) !== null && _b !== void 0 ? _b : {},
+        },
+    };
+}
+function traverseSharedSliceContentWithModel({ path, sliceKey, sliceName, model, content, }) {
+    return (transformWidget, transformSlice) => {
+        var _a, _b;
+        if (!content) {
+            return undefined;
+        }
+        const primary = Object.entries((_a = model.fields.primary) !== null && _a !== void 0 ? _a : {}).reduce((acc, [fieldKey, fieldModel]) => {
+            var _a;
+            const fieldContent = content.widget.primary[fieldKey];
+            const fieldPath = path.concat([
+                { key: "primary", type: "primary" },
+                { key: fieldKey, type: "Widget" },
+            ]);
+            let transformedField;
+            if (fieldModel.type === "Group") {
+                const groupContent = (0, GroupContent_1.isGroupContent)(fieldContent)
+                    ? fieldContent
+                    : undefined;
+                transformedField = (0, GroupContent_1.traverseGroupContentWithModel)({
+                    path: fieldPath,
+                    key: fieldKey,
+                    model: fieldModel,
+                    content: groupContent,
+                })(transformWidget);
+            }
+            else if (fieldModel.type === "Link" &&
+                ((_a = fieldModel.config) === null || _a === void 0 ? void 0 : _a.repeat) === true) {
+                const repeatableContent = (0, nestable_1.isRepeatableContent)(fieldContent)
+                    ? fieldContent
+                    : undefined;
+                transformedField = (0, nestable_1.traverseRepeatableContentWithModel)({
+                    path: fieldPath,
+                    key: fieldKey,
+                    model: fieldModel,
+                    content: repeatableContent,
+                })(transformWidget);
+            }
+            else if (fieldModel.type === "Table") {
+                const tableContent = (0, nestable_1.isTableContent)(fieldContent)
+                    ? fieldContent
+                    : undefined;
+                transformedField = (0, nestable_1.traverseTableContentWithModel)({
+                    path: fieldPath,
+                    key: fieldKey,
+                    model: fieldModel,
+                    content: tableContent,
+                })(transformWidget);
+            }
+            else {
+                const nestableContent = (0, nestable_1.isNestableContent)(fieldContent)
+                    ? fieldContent
+                    : undefined;
+                transformedField = transformWidget({
+                    path: fieldPath,
+                    key: fieldKey,
+                    apiId: fieldKey,
+                    model: fieldModel,
+                    content: nestableContent,
+                });
+            }
+            if (!transformedField)
+                return acc;
+            return {
+                ...acc,
+                [fieldKey]: transformedField,
+            };
+        }, {});
+        const items = (0, GroupContent_1.traverseGroupItemsContentWithModel)({
+            path: path.concat([{ key: "items", type: "items" }]),
+            model: (_b = model.fields.items) !== null && _b !== void 0 ? _b : {},
+            content: content.widget.items,
+        })(transformWidget);
+        return transformSlice({
+            key: sliceKey,
+            apiId: sliceName,
+            path,
+            model,
+            content: {
+                ...content,
+                widget: {
+                    __TYPE__: "SharedSliceContent",
+                    variation: content.widget.variation,
+                    primary,
+                    items,
+                },
+            },
+        });
+    };
+}
+exports.traverseSharedSliceContentWithModel = traverseSharedSliceContentWithModel;
+function traverseCompositeSliceContentWithModel({ path, sliceKey, sliceName, model, content, }) {
+    return (transformWidget, transformSlice) => {
+        var _a, _b, _c, _d;
+        if (!content || !(0, SliceItem_1.isCompositeSliceItemContent)(content)) {
+            return undefined;
+        }
+        const nonRepeatModel = model.type === "SharedSlice"
+            ? (_a = model.fields.primary) !== null && _a !== void 0 ? _a : {}
+            : (_b = model["non-repeat"]) !== null && _b !== void 0 ? _b : {};
+        const repeatModel = model.type === "SharedSlice"
+            ? (_c = model.fields.items) !== null && _c !== void 0 ? _c : {}
+            : (_d = model.repeat) !== null && _d !== void 0 ? _d : {};
+        const nonRepeat = Object.entries(nonRepeatModel).reduce((acc, [fieldKey, fieldModel]) => {
+            const fieldContent = content.widget.nonRepeat[fieldKey];
+            const fieldPath = path.concat([
+                { key: "non-repeat", type: "primary" },
+                { key: fieldKey, type: "Widget" },
+            ]);
+            const nestableContent = (0, nestable_1.isNestableContent)(fieldContent)
+                ? fieldContent
+                : undefined;
+            const transformedField = transformWidget({
+                path: fieldPath,
+                key: fieldKey,
+                apiId: sliceName,
+                model: fieldModel,
+                content: nestableContent,
+            });
+            if (!transformedField || !(0, nestable_1.isNestableContent)(transformedField))
+                return acc;
+            return {
+                ...acc,
+                [fieldKey]: transformedField,
+            };
+        }, {});
+        const repeat = (0, GroupContent_1.traverseGroupItemsContentWithModel)({
+            path: path.concat([{ key: "repeat", type: "items" }]),
+            model: repeatModel,
+            content: content.widget.repeat,
+        })(transformWidget);
+        return transformSlice({
+            key: sliceKey,
+            apiId: sliceName,
+            path,
+            model: model.type === "SharedSlice" ? model : model,
+            content: {
+                ...content,
+                widget: {
+                    __TYPE__: content.widget.__TYPE__,
+                    nonRepeat,
+                    repeat,
+                },
+            },
+        });
+    };
+}
+function traverseSlicesWithModel({ path, key, model, content, }) {
+    return ({ transformWidget, transformSlice }) => {
+        var _a, _b, _c;
+        const choices = (_b = (_a = model.config) === null || _a === void 0 ? void 0 : _a.choices) !== null && _b !== void 0 ? _b : {};
+        const value = ((_c = content === null || content === void 0 ? void 0 : content.value) !== null && _c !== void 0 ? _c : []).reduce((acc, sliceContent) => {
+            const sliceName = sliceContent.name;
+            const sliceModel = choices[sliceName];
+            if (!sliceModel) {
+                return acc;
+            }
+            const slicePath = path.concat({
+                key: sliceContent.key,
+                type: (0, customtypes_1.isStaticSharedSlice)(sliceModel)
+                    ? "SharedSlice"
+                    : (0, customtypes_1.isCompositeSlice)(sliceModel)
+                        ? "Slice"
+                        : "LegacySlice",
+            });
+            let convertedSlice;
+            if ((0, customtypes_1.isStaticSharedSlice)(sliceModel)) {
+                if ((0, SliceItem_1.isSharedSliceItemContent)(sliceContent)) {
+                    const variation = sliceModel.variations.find((v) => v.id === sliceContent.widget.variation);
+                    if (variation) {
+                        const variationFields = buildVariationFields(sliceModel, variation);
+                        convertedSlice = traverseSharedSliceContentWithModel({
+                            path: slicePath,
+                            sliceKey: sliceContent.key,
+                            sliceName,
+                            model: variationFields,
+                            content: sliceContent,
+                        })(transformWidget, transformSlice);
+                    }
+                }
+                else if ((0, SliceItem_1.isCompositeSliceItemContent)(sliceContent)) {
+                    const defaultVariation = sliceModel.variations[0];
+                    if (defaultVariation) {
+                        const variationFields = buildVariationFields(sliceModel, defaultVariation);
+                        convertedSlice = traverseCompositeSliceContentWithModel({
+                            path: slicePath,
+                            sliceKey: sliceContent.key,
+                            sliceName,
+                            model: variationFields,
+                            content: sliceContent,
+                        })(transformWidget, transformSlice);
+                    }
+                }
+            }
+            else if ((0, customtypes_1.isCompositeSlice)(sliceModel)) {
+                if ((0, SliceItem_1.isCompositeSliceItemContent)(sliceContent)) {
+                    convertedSlice = traverseCompositeSliceContentWithModel({
+                        path: slicePath,
+                        sliceKey: sliceContent.key,
+                        sliceName,
+                        model: sliceModel,
+                        content: sliceContent,
+                    })(transformWidget, transformSlice);
+                }
+            }
+            else if ((0, customtypes_1.isLegacySlice)(sliceModel)) {
+                if ((0, SliceItem_1.isSimpleSliceItemContent)(sliceContent)) {
+                    let convertedWidget;
+                    if ((0, GroupContent_1.isGroupContent)(sliceContent.widget)) {
+                        const groupModel = (sliceModel === null || sliceModel === void 0 ? void 0 : sliceModel.type) === "Group" ? sliceModel : undefined;
+                        if (groupModel) {
+                            convertedWidget = (0, GroupContent_1.traverseGroupContentWithModel)({
+                                path: slicePath,
+                                key: sliceContent.key,
+                                model: groupModel,
+                                content: sliceContent.widget,
+                            })(transformWidget);
+                        }
+                    }
+                    else if ((0, nestable_1.isNestableContent)(sliceContent.widget)) {
+                        const nestableModel = (sliceModel === null || sliceModel === void 0 ? void 0 : sliceModel.type) !== "Group" ? sliceModel : undefined;
+                        if (nestableModel) {
+                            convertedWidget = transformWidget({
+                                key: sliceContent.key,
+                                apiId: sliceName,
+                                path: slicePath,
+                                model: nestableModel,
+                                content: sliceContent.widget,
+                            });
+                        }
+                    }
+                    convertedSlice =
+                        convertedWidget &&
+                            transformSlice({
+                                key: sliceContent.key,
+                                apiId: sliceName,
+                                path: slicePath,
+                                model: sliceModel,
+                                content: {
+                                    ...sliceContent,
+                                    widget: convertedWidget,
+                                },
+                            });
+                }
+            }
+            if (convertedSlice) {
+                acc.push(convertedSlice);
+            }
+            return acc;
+        }, []);
+        return transformWidget({
+            path,
+            key,
+            apiId: key,
+            model,
+            content: content
+                ? {
+                    __TYPE__: content.__TYPE__,
+                    value,
+                }
+                : undefined,
+        });
+    };
+}
+exports.traverseSlicesWithModel = traverseSlicesWithModel;

package/lib/content/fields/slices/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Slice";
+export * from "./SliceItem";
+export * from "./SlicesContent";

package/lib/content/fields/slices/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./Slice"), exports);
+(0, tslib_1.__exportStar)(require("./SliceItem"), exports);
+(0, tslib_1.__exportStar)(require("./SlicesContent"), exports);

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

@@ -0,0 +1,9 @@
+import { type NestableWidget, type SlicePrimaryWidget, Group } from "../../customtypes";
+import { GroupContent } from "./GroupContent";
+import type { NestableContent } from "./nestable";
+import type { SlicePrimaryContent } from "./slices/Slice/SlicePrimaryContent";
+export declare function withDefaultSlicePrimaryContentValues(customType: Record<string, SlicePrimaryWidget>, content: Partial<Record<string, SlicePrimaryContent>>): Record<string, SlicePrimaryContent>;
+export declare function withDefaultNestableContentValues(customType: Record<string, NestableWidget>, content: Record<string, NestableContent>): Record<string, NestableContent>;
+export declare function repeatableContentWithDefaultNestableContentValues<T extends {
+    value: [string, GroupContent | NestableContent][];
+}>(fields: Record<string, Group | NestableWidget>, content: T[]): T[];

package/lib/content/fields/withDefaultValues.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repeatableContentWithDefaultNestableContentValues = exports.withDefaultNestableContentValues = exports.withDefaultSlicePrimaryContentValues = void 0;
+const customtypes_1 = require("../../customtypes");
+const GroupContent_1 = require("./GroupContent");
+const nestable_1 = require("./nestable");
+function withDefaultSlicePrimaryContentValues(customType, content) {
+    const updatedContent = content;
+    for (const [widgetKey, widgetDef] of Object.entries(customType)) {
+        const widgetContent = content[widgetKey];
+        if (widgetContent === undefined) {
+            if (widgetDef.type === customtypes_1.GroupFieldType) {
+                updatedContent[widgetKey] = (0, GroupContent_1.groupContentWithDefaultValues)(widgetDef, GroupContent_1.GroupContentDefaultValue);
+            }
+            else {
+                const defaultValue = (0, nestable_1.NestableContentDefaultValue)(widgetDef);
+                if (defaultValue) {
+                    updatedContent[widgetKey] = defaultValue;
+                }
+            }
+            continue;
+        }
+        if (widgetDef.type === customtypes_1.GroupFieldType && (0, GroupContent_1.isGroupContent)(widgetContent)) {
+            updatedContent[widgetKey] = (0, GroupContent_1.groupContentWithDefaultValues)(widgetDef, widgetContent);
+        }
+    }
+    return updatedContent;
+}
+exports.withDefaultSlicePrimaryContentValues = withDefaultSlicePrimaryContentValues;
+function withDefaultNestableContentValues(customType, content) {
+    return Object.entries(customType).reduce((updatedContent, [widgetKey, widgetDef]) => {
+        if (content[widgetKey] === undefined) {
+            const defaultValue = (0, nestable_1.NestableContentDefaultValue)(widgetDef);
+            return defaultValue !== undefined
+                ? {
+                    ...updatedContent,
+                    [widgetKey]: defaultValue,
+                }
+                : updatedContent;
+        }
+        return updatedContent;
+    }, content);
+}
+exports.withDefaultNestableContentValues = withDefaultNestableContentValues;
+function repeatableContentWithDefaultNestableContentValues(fields, content) {
+    const groupKeys = Object.entries(fields);
+    return content.map((contentItem) => {
+        return groupKeys.reduce((updatedContentItem, [key, fieldDef]) => {
+            var _a;
+            const maybeContentItemValue = contentItem.value.find(([_key]) => _key === key);
+            if (fieldDef.type === "Group") {
+                const defaultValue = (0, GroupContent_1.groupContentWithDefaultValues)(fieldDef, (_a = maybeContentItemValue === null || maybeContentItemValue === void 0 ? void 0 : maybeContentItemValue[1]) !== null && _a !== void 0 ? _a : {
+                    __TYPE__: GroupContent_1.GroupContentType,
+                    value: [],
+                });
+                return {
+                    ...updatedContentItem,
+                    value: [
+                        // Since there was default content for the group, we need to remove the old one
+                        ...updatedContentItem.value.filter(([_key]) => _key !== key),
+                        ...(defaultValue ? [[key, defaultValue]] : []),
+                    ],
+                };
+            }
+            else if (!maybeContentItemValue) {
+                const defaultValue = (0, nestable_1.NestableContentDefaultValue)(fieldDef);
+                return {
+                    ...updatedContentItem,
+                    value: [
+                        ...updatedContentItem.value,
+                        ...(defaultValue ? [[key, defaultValue]] : []),
+                    ],
+                };
+            }
+            return updatedContentItem;
+        }, contentItem);
+    });
+}
+exports.repeatableContentWithDefaultNestableContentValues = repeatableContentWithDefaultNestableContentValues;

package/lib/content/helpers.d.ts

@@ -0,0 +1,9 @@
+import * as t from "io-ts";
+declare type WithContentType = {
+    __TYPE__: string;
+};
+export declare function hasContentType(obj: unknown): obj is WithContentType;
+export declare function withKey<C extends t.Mixed>(codec: C): t.IntersectionC<[t.ExactC<t.TypeC<{
+    key: t.Type<string, string, unknown>;
+}>>, C]>;
+export {};

package/lib/content/helpers.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withKey = exports.hasContentType = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const uuid_1 = require("uuid");
+function hasContentType(obj) {
+    return typeof obj === "object" && obj !== null && "__TYPE__" in obj;
+}
+exports.hasContentType = hasContentType;
+const isUuid = (input) => typeof input === "string" && (0, uuid_1.validate)(input);
+const uuidWithFallback = new t.Type("UUID", isUuid, (u, c) => {
+    if (typeof u === "undefined")
+        return t.success((0, uuid_1.v4)());
+    if (isUuid(u))
+        return t.success(u);
+    return t.failure(u, c);
+}, t.identity);
+function withKey(codec) {
+    return t.intersection([t.strict({ key: uuidWithFallback }), codec]);
+}
+exports.withKey = withKey;

package/lib/content/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Document";
+export * from "./fields";
+export * from "./LegacyContentCtx";
+export * from "./utils";

package/lib/content/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./Document"), exports);
+(0, tslib_1.__exportStar)(require("./fields"), exports);
+(0, tslib_1.__exportStar)(require("./LegacyContentCtx"), exports);
+(0, tslib_1.__exportStar)(require("./utils"), exports);

package/lib/content/utils.d.ts

@@ -0,0 +1,50 @@
+import type { CompositeSlice, Group, NestableWidget, StaticSlices, UID, VariationFields } from "../customtypes";
+import { FieldType, SharedSliceItemContent, SliceItemContent, WidgetContent } from "./fields";
+export { hasContentType, withKey } from "./helpers";
+declare type WithFieldType = {
+    __TYPE__: string;
+    type: FieldType;
+};
+export declare function hasFieldContentType(obj: unknown): obj is WithFieldType;
+export declare type TraverseSliceContentFn = <S extends SliceItemContent | SharedSliceItemContent, D extends VariationFields | CompositeSlice | Group | NestableWidget>({ path, key, apiId, model, content, }: {
+    path: ContentPath;
+    key: string;
+    apiId: string;
+    model?: D | undefined;
+    content: S;
+}) => S | SharedSliceItemContent | undefined;
+export declare type TraverseWidgetContentFn<ContentTransformMode extends "preserve" | "widen" = "preserve"> = <C extends WidgetContent, D extends NestableWidget | StaticSlices | Group | UID>({ path, key, apiId, model, content, }: {
+    path: ContentPath;
+    key: string;
+    apiId: string;
+    model?: D | undefined;
+    content: C;
+}) => ([ContentTransformMode] extends ["preserve"] ? C : WidgetContent) | undefined;
+export declare type TraverseWidgetContentWithModelFn<ContentTransformMode extends "preserve" | "widen" = "preserve"> = <C extends WidgetContent | undefined, D extends NestableWidget | StaticSlices | Group | UID>({ path, key, apiId, model, content, }: {
+    path: ContentPath;
+    key: string;
+    apiId: string;
+    model: D;
+    content: C;
+}) => ([ContentTransformMode] extends ["preserve"] ? C : WidgetContent) | undefined;
+export declare type TraverseSliceContentWithModelFn = <S extends SliceItemContent | SharedSliceItemContent | undefined, D extends VariationFields | CompositeSlice | Group | NestableWidget>({ path, key, apiId, model, content, }: {
+    path: ContentPath;
+    key: string;
+    apiId: string;
+    model: D;
+    content: S;
+}) => S | SharedSliceItemContent | undefined;
+export declare type ContentPathEntry = {
+    type: "CustomType" | "Widget" | "SharedSlice" | "Slice" | "LegacySlice" | "GroupItem" | "primary" | "items" | "RepeatableItem";
+    key: string;
+};
+export declare type ContentPath = ReadonlyArray<ContentPathEntry>;
+export declare const ContentPath: {
+    serialize(path: ContentPath): string;
+    current(path: ContentPath): ContentPathEntry | undefined;
+    append(path: string, strElement: string): string;
+    make(entries: Array<{
+        key?: ContentPathEntry["key"] | undefined;
+        type: ContentPathEntry["type"];
+    }>): ContentPath;
+};