@prismicio/types-internal 2.2.1 → 2.3.1

package/lib/content/Document.d.ts

@@ -3190,7 +3190,7 @@ declare function extractMetadata(data: {
     slugs: ReadonlyArray<string>;
     uid: string | undefined;
 };
-declare function parseLegacyDocument(legacyDoc: unknown, customType: {
+declare function parseLegacyDocument(legacyDoc: unknown, customType: StaticCustomType | {
     customTypeId: string;
     fields: Record<string, StaticWidget>;
 }): Document | undefined;
@@ -5743,12 +5743,18 @@ export declare const DocumentLegacy: {
     parse: typeof parseLegacyDocument;
     encode: typeof encodeToLegacyDocument;
 };
+export declare function fillDocumentWithDefaultValues(customType: StaticCustomType | {
+    customTypeId: string;
+    fields: Record<string, StaticWidget>;
+}, document: Document): Document;
 /**
- *
- * @param model: can be optional if we simply want to loop through the content without any consideration for the attached model
+ * @param model: Can be optional if we simply want to loop through the content
+ *   without any consideration for the attached model
  * @param document: The content we actually want to iterate on in an immutable fashion
- * @param transform: A user function that provides a way to transform any kind of content wherever it is in a structured Prismic object content.
- * @returns a transformed document with the user's transformation applied with the transform function
+ * @param transform: A user function that provides a way to transform any kind
+ *   of content wherever it is in a structured Prismic object content.
+ * @returns A transformed document with the user's transformation applied with
+ *   the transform function
  */
 export declare function traverseDocument({ document, customType, }: {
     document: Document;

package/lib/content/Document.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.migrateDocument = exports.collectWidgets = exports.traverseDocument = exports.DocumentLegacy = exports.Document = void 0;
+exports.migrateDocument = exports.collectWidgets = exports.traverseDocument = exports.fillDocumentWithDefaultValues = exports.DocumentLegacy = exports.Document = void 0;
 const tslib_1 = require("tslib");
 const fp_ts_1 = require("fp-ts");
 const Either_1 = require("fp-ts/lib/Either");
@@ -93,12 +93,52 @@ exports.DocumentLegacy = {
     parse: parseLegacyDocument,
     encode: encodeToLegacyDocument,
 };
+function simplifyCustomType(customType) {
+    return {
+        customTypeId: customType === null || customType === void 0 ? void 0 : customType.id,
+        fields: Object.fromEntries((0, customtypes_1.flattenSections)(customType)),
+    };
+}
+function fillDocumentWithDefaultValues(customType, document) {
+    const { fields } = customType && customtypes_1.StaticCustomType.is(customType)
+        ? simplifyCustomType(customType)
+        : customType;
+    return Object.entries(fields).reduce((updatedDocument, [fieldKey, fieldDef]) => {
+        const fieldContent = document[fieldKey];
+        const updatedField = (() => {
+            switch (fieldDef.type) {
+                case "Group":
+                    return (0, fields_1.isGroupContent)(fieldContent)
+                        ? (0, fields_1.groupContentWithDefaultValues)(fieldDef, fieldContent)
+                        : fieldContent;
+                case "Choice":
+                case "Slices":
+                    return (0, fields_1.isSlicesContent)(fieldContent)
+                        ? (0, fields_1.slicesContentWithDefaultValues)(fieldDef, fieldContent)
+                        : fieldContent;
+                default:
+                    return fieldContent === undefined && customtypes_1.NestableWidget.is(fieldDef)
+                        ? (0, fields_1.NestableContentDefaultValue)(fieldDef)
+                        : fieldContent;
+            }
+        })();
+        return updatedField
+            ? {
+                ...updatedDocument,
+                [fieldKey]: updatedField,
+            }
+            : updatedDocument;
+    }, document);
+}
+exports.fillDocumentWithDefaultValues = fillDocumentWithDefaultValues;
 /**
- *
- * @param model: can be optional if we simply want to loop through the content without any consideration for the attached model
+ * @param model: Can be optional if we simply want to loop through the content
+ *   without any consideration for the attached model
  * @param document: The content we actually want to iterate on in an immutable fashion
- * @param transform: A user function that provides a way to transform any kind of content wherever it is in a structured Prismic object content.
- * @returns a transformed document with the user's transformation applied with the transform function
+ * @param transform: A user function that provides a way to transform any kind
+ *   of content wherever it is in a structured Prismic object content.
+ * @returns A transformed document with the user's transformation applied with
+ *   the transform function
  */
 function traverseDocument({ document, customType, }) {
     const model = customType && customtypes_1.StaticCustomType.is(customType)
@@ -154,12 +194,6 @@ function traverseDocument({ document, customType, }) {
     };
 }
 exports.traverseDocument = traverseDocument;
-function simplifyCustomType(customType) {
-    return {
-        customTypeId: customType === null || customType === void 0 ? void 0 : customType.id,
-        fields: Object.fromEntries((0, customtypes_1.flattenSections)(customType)),
-    };
-}
 // /**
 //  * The goal is to be able to collect all widgets or slices of a given type at any level of nesting inside a prismic content
 //  *

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

@@ -1760,6 +1760,7 @@ export declare const GroupContent: t.ExactC<t.TypeC<{
     }>>>;
 }>>;
 export declare type GroupContent = t.TypeOf<typeof GroupContent>;
+export declare function groupContentWithDefaultValues(customType: Group, content: GroupContent): GroupContent;
 export declare function traverseGroupContent({ path, key, apiId, model, content, }: {
     path: ContentPath;
     key: string;

package/lib/content/fields/GroupContent.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.traverseGroupItemsContent = exports.traverseGroupContent = exports.GroupContent = exports.isGroupContent = exports.GroupContentType = exports.GroupLegacy = exports.GroupItemLegacy = exports.GroupItemContent = exports.GroupItemContentType = void 0;
+exports.traverseGroupItemsContent = exports.traverseGroupContent = exports.groupContentWithDefaultValues = exports.GroupContent = exports.isGroupContent = exports.GroupContentType = exports.GroupLegacy = exports.GroupItemLegacy = exports.GroupItemContent = exports.GroupItemContentType = void 0;
 const tslib_1 = require("tslib");
 const fp_ts_1 = require("fp-ts");
 const Either_1 = require("fp-ts/lib/Either");
@@ -9,6 +9,7 @@ const t = (0, tslib_1.__importStar)(require("io-ts"));
 const LegacyContentCtx_1 = require("../LegacyContentCtx");
 const utils_1 = require("../utils");
 const nestable_1 = require("./nestable");
+const withDefaultValues_1 = require("./withDefaultValues");
 exports.GroupItemContentType = "GroupItemContent";
 exports.GroupItemContent = t.strict({
     __TYPE__: t.literal(exports.GroupItemContentType),
@@ -81,6 +82,17 @@ exports.GroupContent = t.strict({
     __TYPE__: t.literal(exports.GroupContentType),
     value: t.array(exports.GroupItemContent),
 });
+function groupContentWithDefaultValues(customType, content) {
+    var _a;
+    const fields = (_a = customType.config) === null || _a === void 0 ? void 0 : _a.fields;
+    if (!fields)
+        return content;
+    return {
+        ...content,
+        value: (0, withDefaultValues_1.repeatableContentWithDefaultNestableContentValues)(fields, content.value),
+    };
+}
+exports.groupContentWithDefaultValues = groupContentWithDefaultValues;
 function traverseGroupContent({ path, key, apiId, model, content, }) {
     return (transform) => {
         var _a;

package/lib/content/fields/nestable/BooleanContent.d.ts

@@ -1,4 +1,5 @@
 import * as t from "io-ts";
+import type { BooleanField } from "../../../customtypes";
 import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx";
 export declare const BooleanContentType = "BooleanContent";
 export declare const isBooleanContent: (u: unknown) => u is {
@@ -14,3 +15,4 @@ export declare const BooleanContent: t.ExactC<t.TypeC<{
     value: t.BooleanC;
 }>>;
 export declare type BooleanContent = t.TypeOf<typeof BooleanContent>;
+export declare const BooleanContentDefaultValue: (field: BooleanField) => BooleanContent | undefined;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BooleanContent = exports.BooleanLegacy = exports.isBooleanContent = exports.BooleanContentType = void 0;
+exports.BooleanContentDefaultValue = exports.BooleanContent = exports.BooleanLegacy = exports.isBooleanContent = exports.BooleanContentType = void 0;
 const tslib_1 = require("tslib");
 const fp_ts_1 = require("fp-ts");
 const function_1 = require("fp-ts/lib/function");
@@ -22,3 +22,13 @@ exports.BooleanContent = t.strict({
     __TYPE__: t.literal(exports.BooleanContentType),
     value: t.boolean,
 });
+const BooleanContentDefaultValue = (field) => {
+    var _a;
+    return ((_a = field.config) === null || _a === void 0 ? void 0 : _a.default_value) !== undefined
+        ? {
+            __TYPE__: exports.BooleanContentType,
+            value: field.config.default_value || false,
+        }
+        : undefined;
+};
+exports.BooleanContentDefaultValue = BooleanContentDefaultValue;

package/lib/content/fields/nestable/FieldContent/SelectContent.d.ts

@@ -1,4 +1,5 @@
 import * as t from "io-ts";
+import { Select } from "../../../../customtypes/widgets";
 import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
 export declare const isSelectContent: (u: unknown) => u is {
     type: "Select";
@@ -16,3 +17,4 @@ export declare const SelectContent: t.ExactC<t.TypeC<{
     __TYPE__: t.LiteralC<"FieldContent">;
 }>>;
 export declare type SelectContent = t.TypeOf<typeof SelectContent>;
+export declare const SelectContentDefaultValue: (field: Select) => SelectContent | undefined;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SelectContent = exports.SelectLegacy = exports.isSelectContent = void 0;
+exports.SelectContentDefaultValue = exports.SelectContent = exports.SelectLegacy = exports.isSelectContent = void 0;
 const tslib_1 = require("tslib");
 const fp_ts_1 = require("fp-ts");
 const function_1 = require("fp-ts/lib/function");
@@ -32,3 +32,14 @@ exports.SelectContent = t.strict({
     value: TrimmedString_1.default,
     __TYPE__: t.literal(common_1.FieldContentType),
 });
+const SelectContentDefaultValue = (field) => {
+    var _a;
+    return ((_a = field.config) === null || _a === void 0 ? void 0 : _a.default_value)
+        ? {
+            __TYPE__: common_1.FieldContentType,
+            type: widgets_1.SelectFieldType,
+            value: field.config.default_value || "",
+        }
+        : undefined;
+};
+exports.SelectContentDefaultValue = SelectContentDefaultValue;

package/lib/content/fields/nestable/NestableContent.d.ts

@@ -1,4 +1,5 @@
 import * as t from "io-ts";
+import type { NestableWidget } from "../../../customtypes";
 import type { LegacyContentCtx } from "../../LegacyContentCtx";
 export declare const NestableContent: t.UnionC<[t.ExactC<t.TypeC<{
     type: t.StringC;
@@ -395,6 +396,7 @@ export declare const NestableContent: t.UnionC<[t.ExactC<t.TypeC<{
 }>>]>;
 export declare type NestableContent = t.TypeOf<typeof NestableContent>;
 export declare type NestableContentType = NestableContent["__TYPE__"];
+export declare const NestableContentDefaultValue: (widgetDef: NestableWidget) => NestableContent | undefined;
 export declare const isNestableContent: (u: unknown) => u is {
     type: string;
     __TYPE__: "EmptyContent";

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NestableLegacy = exports.isNestableContent = exports.NestableContent = void 0;
+exports.NestableLegacy = exports.isNestableContent = exports.NestableContentDefaultValue = exports.NestableContent = void 0;
 const tslib_1 = require("tslib");
 const Either_1 = require("fp-ts/lib/Either");
 const t = (0, tslib_1.__importStar)(require("io-ts"));
@@ -33,6 +33,17 @@ exports.NestableContent = t.union([
     RichTextContent_1.RichTextContent,
     SeparatorContent_1.SeparatorContent,
 ]);
+const NestableContentDefaultValue = (widgetDef) => {
+    switch (widgetDef.type) {
+        case "Boolean":
+            return (0, BooleanContent_1.BooleanContentDefaultValue)(widgetDef);
+        case "Select":
+            return (0, FieldContent_1.SelectContentDefaultValue)(widgetDef);
+        default:
+            return undefined;
+    }
+};
+exports.NestableContentDefaultValue = NestableContentDefaultValue;
 const isNestableContent = (u) => (0, FieldContent_1.isTextContent)(u) ||
     (0, FieldContent_1.isColorContent)(u) ||
     (0, FieldContent_1.isDateContent)(u) ||

package/lib/content/fields/slices/Slice/CompositeSliceContent.d.ts

@@ -2070,6 +2070,7 @@ export declare const CompositeSliceContent: t.ExactC<t.TypeC<{
     }>>>;
 }>>;
 export declare type CompositeSliceContent = t.TypeOf<typeof CompositeSliceContent>;
+export declare function compositeSliceContentWithDefaultValues(customType: CompositeSlice, content: CompositeSliceContent): CompositeSliceContent;
 export declare function traverseCompositeSliceContent({ path, sliceKey, sliceName, model, content, }: {
     path: ContentPath;
     sliceKey: string;

package/lib/content/fields/slices/Slice/CompositeSliceContent.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.migrateCompositeSlice = exports.traverseCompositeSliceContent = exports.CompositeSliceContent = exports.CompositeSliceLegacy = exports.isCompositeSliceContent = exports.CompositeSliceContentType = void 0;
+exports.migrateCompositeSlice = exports.traverseCompositeSliceContent = exports.compositeSliceContentWithDefaultValues = exports.CompositeSliceContent = exports.CompositeSliceLegacy = exports.isCompositeSliceContent = exports.CompositeSliceContentType = void 0;
 const tslib_1 = require("tslib");
 const fp_ts_1 = require("fp-ts");
 const Either_1 = require("fp-ts/lib/Either");
@@ -10,6 +10,7 @@ const LegacyContentCtx_1 = require("../../../LegacyContentCtx");
 const utils_1 = require("../../../utils");
 const GroupContent_1 = require("../../GroupContent");
 const nestable_1 = require("../../nestable");
+const withDefaultValues_1 = require("../../withDefaultValues");
 const RepeatableContent_1 = require("./RepeatableContent");
 exports.CompositeSliceContentType = "CompositeSliceContent";
 const isCompositeSliceContent = (u) => (0, utils_1.hasContentType)(u) && u.__TYPE__ === exports.CompositeSliceContentType;
@@ -80,6 +81,17 @@ exports.CompositeSliceContent = t.strict({
     nonRepeat: t.record(t.string, nestable_1.NestableContent),
     repeat: RepeatableContent_1.RepeatableWidgets,
 });
+function compositeSliceContentWithDefaultValues(customType, content) {
+    var _a, _b;
+    const updatedNonRepeatContent = (0, withDefaultValues_1.withDefaultNestableContentValues)((_a = customType["non-repeat"]) !== null && _a !== void 0 ? _a : {}, content.nonRepeat);
+    const updatedRepeatContent = (0, withDefaultValues_1.repeatableContentWithDefaultNestableContentValues)((_b = customType.repeat) !== null && _b !== void 0 ? _b : {}, content.repeat);
+    return {
+        ...content,
+        nonRepeat: updatedNonRepeatContent,
+        repeat: updatedRepeatContent,
+    };
+}
+exports.compositeSliceContentWithDefaultValues = compositeSliceContentWithDefaultValues;
 function traverseCompositeSliceContent({ path, sliceKey, sliceName, model, content, }) {
     return (transformWidget, transformSlice) => {
         const primary = Object.entries(content.widget.nonRepeat).reduce((acc, [fieldKey, fieldContent]) => {

package/lib/content/fields/slices/Slice/SharedSliceContent.d.ts

@@ -1,6 +1,6 @@
 import * as t from "io-ts";
 import type { ContentPath, TraverseSliceContentFn, TraverseWidgetContentFn } from "../../../../_internal/utils";
-import type { VariationFields } from "../../../../customtypes";
+import type { SharedSlice, VariationFields } from "../../../../customtypes";
 import { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx";
 import type { SharedSliceItemContent } from "../SliceItem";
 export declare const SharedSliceContentType = "SharedSliceContent";
@@ -2074,6 +2074,7 @@ export declare const SharedSliceContent: t.ExactC<t.TypeC<{
     }>>>;
 }>>;
 export declare type SharedSliceContent = t.TypeOf<typeof SharedSliceContent>;
+export declare function sharedSliceContentWithDefaultValues(customType: SharedSlice, content: SharedSliceContent): SharedSliceContent;
 export declare function traverseSharedSliceContent({ path, sliceKey, sliceName, model, content, }: {
     path: ContentPath;
     sliceKey: string;

package/lib/content/fields/slices/Slice/SharedSliceContent.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.traverseSharedSliceContent = exports.SharedSliceContent = exports.SharedSliceLegacy = exports.isSharedSliceContent = exports.SharedSliceContentType = void 0;
+exports.traverseSharedSliceContent = exports.sharedSliceContentWithDefaultValues = exports.SharedSliceContent = exports.SharedSliceLegacy = exports.isSharedSliceContent = exports.SharedSliceContentType = void 0;
 const tslib_1 = require("tslib");
 const fp_ts_1 = require("fp-ts");
 const Either_1 = require("fp-ts/lib/Either");
@@ -11,6 +11,7 @@ const LegacyContentCtx_1 = require("../../../LegacyContentCtx");
 const utils_1 = require("../../../utils");
 const GroupContent_1 = require("../../GroupContent");
 const nestable_1 = require("../../nestable");
+const withDefaultValues_1 = require("../../withDefaultValues");
 const RepeatableContent_1 = require("./RepeatableContent");
 exports.SharedSliceContentType = "SharedSliceContent";
 const isSharedSliceContent = (u) => (0, utils_1.hasContentType)(u) && u.__TYPE__ === exports.SharedSliceContentType;
@@ -97,6 +98,20 @@ exports.SharedSliceContent = t.strict({
     primary: t.record(t.string, nestable_1.NestableContent),
     items: RepeatableContent_1.RepeatableWidgets,
 });
+function sharedSliceContentWithDefaultValues(customType, content) {
+    var _a, _b;
+    const variationConfig = customType.variations.find((v) => v.id === content.variation);
+    const primaryConfig = (_a = variationConfig === null || variationConfig === void 0 ? void 0 : variationConfig.primary) !== null && _a !== void 0 ? _a : {};
+    const itemsConfig = (_b = variationConfig === null || variationConfig === void 0 ? void 0 : variationConfig.items) !== null && _b !== void 0 ? _b : {};
+    const updatedPrimaryContent = (0, withDefaultValues_1.withDefaultNestableContentValues)(primaryConfig, content.primary);
+    const updatedItemsContent = (0, withDefaultValues_1.repeatableContentWithDefaultNestableContentValues)(itemsConfig, content.items);
+    return {
+        ...content,
+        primary: updatedPrimaryContent,
+        items: updatedItemsContent,
+    };
+}
+exports.sharedSliceContentWithDefaultValues = sharedSliceContentWithDefaultValues;
 function traverseSharedSliceContent({ path, sliceKey, sliceName, model, content, }) {
     return (transformWidget, transformSlice) => {
         const primary = Object.entries(content.widget.primary).reduce((acc, [fieldKey, fieldContent]) => {

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

@@ -1,6 +1,8 @@
 import * as t from "io-ts";
 import type { TraverseSliceContentFn } from "../../../_internal/utils";
+import type { StaticSlice } from "../../../customtypes";
 import { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx";
+import { SliceContent } from "./Slice";
 import { CompositeSliceContent } from "./Slice/CompositeSliceContent";
 import { SharedSliceContent } from "./Slice/SharedSliceContent";
 import { SimpleSliceContent } from "./Slice/SimpleSliceContent";
@@ -2396,6 +2398,7 @@ export declare type SimpleSliceItemContent = Omit<SliceItemContent, "widget"> &
     widget: SimpleSliceContent;
 };
 export declare function isSimpleSliceItemContent(item: SliceItemContent): item is SimpleSliceItemContent;
+export declare function sliceItemContentWithDefaultValues(customType: StaticSlice, content: SliceContent): SliceContent;
 export declare const SlicesItemLegacy: (ctx: LegacyContentCtx) => t.Type<{
     key: string;
     name: string;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.migrateSliceItem = exports.SlicesItemLegacy = exports.isSimpleSliceItemContent = exports.isCompositeSliceItemContent = exports.isSharedSliceItemContent = exports.SliceItemContent = void 0;
+exports.migrateSliceItem = exports.SlicesItemLegacy = exports.sliceItemContentWithDefaultValues = exports.isSimpleSliceItemContent = exports.isCompositeSliceItemContent = exports.isSharedSliceItemContent = exports.SliceItemContent = void 0;
 const tslib_1 = require("tslib");
 const fp_ts_1 = require("fp-ts");
 const Either_1 = require("fp-ts/lib/Either");
@@ -10,6 +10,7 @@ const function_2 = require("../../../validators/function");
 const LegacyContentCtx_1 = require("../../LegacyContentCtx");
 const GroupContent_1 = require("../GroupContent");
 const nestable_1 = require("../nestable");
+const withDefaultValues_1 = require("../withDefaultValues");
 const Slice_1 = require("./Slice");
 const CompositeSliceContent_1 = require("./Slice/CompositeSliceContent");
 const SharedSliceContent_1 = require("./Slice/SharedSliceContent");
@@ -32,6 +33,28 @@ function isSimpleSliceItemContent(item) {
     return (0, GroupContent_1.isGroupContent)(item.widget) || (0, nestable_1.isNestableContent)(item.widget);
 }
 exports.isSimpleSliceItemContent = isSimpleSliceItemContent;
+function sliceItemContentWithDefaultValues(customType, content) {
+    var _a;
+    if (customType.type === "SharedSlice" && (0, SharedSliceContent_1.isSharedSliceContent)(content)) {
+        return (0, Slice_1.sharedSliceContentWithDefaultValues)(customType, content);
+    }
+    if (customType.type === "Slice" && (0, CompositeSliceContent_1.isCompositeSliceContent)(content)) {
+        return (0, Slice_1.compositeSliceContentWithDefaultValues)(customType, content);
+    }
+    if (customType.type === "Group" &&
+        (0, GroupContent_1.isGroupContent)(content) &&
+        ((_a = customType.config) === null || _a === void 0 ? void 0 : _a.fields)) {
+        const updateGroupFieldValue = (0, withDefaultValues_1.repeatableContentWithDefaultNestableContentValues)(customType.config.fields, content.value);
+        return {
+            ...content,
+            value: updateGroupFieldValue,
+        };
+    }
+    // Note - SimpleSliceContent can also be a NestableContent, but in that case we have no default value to fill, because the content is already there.
+    // There is no key specified in custom type that does not have a value provided like in other cases.
+    return content;
+}
+exports.sliceItemContentWithDefaultValues = sliceItemContentWithDefaultValues;
 const itemLegacyReader = t.exact(t.intersection([
     t.type({
         key: t.string,

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

@@ -6199,6 +6199,7 @@ export declare const SlicesContent: t.TypeC<{
     }>>;
 }>;
 export declare type SlicesContent = t.TypeOf<typeof SlicesContent>;
+export declare function slicesContentWithDefaultValues(codec: StaticSlices, content: SlicesContent): SlicesContent;
 export declare function traverseSlices({ path, key, model, content, }: {
     path: ContentPath;
     key: string;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.traverseSlices = exports.SlicesContent = exports.SlicesLegacy = exports.isSlicesContent = exports.SlicesContentType = void 0;
+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");
@@ -37,6 +37,28 @@ 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];

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

@@ -0,0 +1,6 @@
+import type { NestableWidget } from "../../customtypes";
+import type { NestableContent } from "./nestable";
+export declare function withDefaultNestableContentValues(customType: Record<string, NestableWidget>, content: Record<string, NestableContent>): Record<string, NestableContent>;
+export declare function repeatableContentWithDefaultNestableContentValues<T extends {
+    value: [string, NestableContent][];
+}>(fields: Record<string, NestableWidget>, content: T[]): T[];

package/lib/content/fields/withDefaultValues.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repeatableContentWithDefaultNestableContentValues = exports.withDefaultNestableContentValues = void 0;
+const nestable_1 = require("./nestable");
+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]) => {
+            if (!contentItem.value.find(([_key]) => _key === key)) {
+                const defaultValue = (0, nestable_1.NestableContentDefaultValue)(fieldDef);
+                return {
+                    ...updatedContentItem,
+                    value: [
+                        ...updatedContentItem.value,
+                        ...(defaultValue ? [[key, defaultValue]] : []),
+                    ],
+                };
+            }
+            return updatedContentItem;
+        }, contentItem);
+    });
+}
+exports.repeatableContentWithDefaultNestableContentValues = repeatableContentWithDefaultNestableContentValues;

package/lib/import/converters/Document.d.ts

@@ -0,0 +1,4 @@
+import type { Asset, Embed } from "../../common";
+import type { Document } from "../../content";
+import type { ImportDocument } from "../validators";
+export declare function convertImportToContent(document: ImportDocument, assets: Record<Asset["id"], Asset | undefined>, embeds: Record<string, Embed | undefined>): Document;

package/lib/import/converters/Document.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertImportToContent = void 0;
+const fields_1 = require("./fields");
+function convertImportToContent(document, assets, embeds) {
+    return Object.entries(document).reduce((acc, [fieldKey, fieldValue]) => {
+        const newFieldValue = convertWidget(fieldValue, assets, embeds);
+        return newFieldValue ? { ...acc, [fieldKey]: newFieldValue } : acc;
+    }, {});
+}
+exports.convertImportToContent = convertImportToContent;
+function convertWidget(field, assets, embeds) {
+    switch (field.type) {
+        case "Slices":
+            return (0, fields_1.importSlicesConverter)(field.value, assets, embeds);
+        case "Group":
+            return (0, fields_1.importGroupConverter)(field.value, assets, embeds);
+        default:
+            return (0, fields_1.convertNestableWidget)(field, assets, embeds);
+    }
+}

package/lib/import/converters/fields/Group.d.ts

@@ -0,0 +1,4 @@
+import type { Asset, Embed } from "../../../common";
+import type { GroupContent } from "../../../content";
+import type { ImportGroup } from "../../validators/fields/ImportGroup";
+export declare const importGroupConverter: (field: ImportGroup["value"], assets: Record<Asset["id"], Asset | undefined>, embeds: Record<string, Embed | undefined>) => GroupContent | undefined;

package/lib/import/converters/fields/Group.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importGroupConverter = void 0;
+const content_1 = require("../../../content");
+const RepeatableZone_1 = require("./RepeatableZone");
+const importGroupConverter = (field, assets, embeds) => {
+    if (field === null)
+        return;
+    return {
+        __TYPE__: content_1.GroupContentType,
+        value: (0, RepeatableZone_1.repeatableZoneConverter)(field, assets, embeds),
+    };
+};
+exports.importGroupConverter = importGroupConverter;