@prismicio/types-internal 2.2.1 → 2.3.0

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

@@ -0,0 +1,192 @@
+import type { NestableWidget } from "../../../../customtypes";
+import { ImportBoolean } from "./Boolean";
+import { ImportColor } from "./Color";
+import { ImportDate } from "./Date";
+import { ImportEmbed } from "./Embed";
+import { ImportGeoPoint } from "./GeoPoint";
+import { ImportImage } from "./Image";
+import { ImportRichText } from "./ImportRichText";
+import { ImportLink } from "./Link";
+import { ImportNumber } from "./Number";
+import { ImportSelect } from "./Select";
+import { ImportText } from "./Text";
+import { ImportTimestamp } from "./Timestamp";
+export declare type ImportNestable = ImportBoolean | ImportColor | ImportNumber | ImportSelect | ImportText | ImportDate | ImportTimestamp | ImportEmbed | ImportLink | ImportGeoPoint | ImportImage | ImportRichText;
+export declare const ImportNestable: {
+    is(u: unknown): u is ImportNestable;
+    decode: (field: NestableWidget) => (content: unknown) => {
+        codec: 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>;
+        result: import("fp-ts/lib/Either").Left<import("io-ts").Errors> | import("fp-ts/lib/Either").Right<{
+            type: "Timestamp";
+            value: Date | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Text";
+            value: string | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Select";
+            value: string | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Number";
+            value: number | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "StructuredText";
+            value: import("./ImportRichText").ImportBlock[] | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Link";
+            value: ({
+                link_type: "Web";
+                url: string;
+            } & {
+                target?: string;
+            }) | {
+                link_type: "Document";
+                id: string;
+            } | {
+                link_type: "Media";
+                id: string;
+            } | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Image";
+            value: import("./Image").ImageFieldWithThumbnails | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "GeoPoint";
+            value: {
+                latitude: number;
+                longitude: number;
+            } | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Embed";
+            value: {
+                embed_url: string;
+            } | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Date";
+            value: Date | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Color";
+            value: `#${string}` | null;
+        }> | import("fp-ts/lib/Either").Right<{
+            type: "Boolean";
+            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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportNestable = void 0;
+const Boolean_1 = require("./Boolean");
+const Color_1 = require("./Color");
+const Date_1 = require("./Date");
+const Embed_1 = require("./Embed");
+const GeoPoint_1 = require("./GeoPoint");
+const Image_1 = require("./Image");
+const ImportRichText_1 = require("./ImportRichText");
+const Link_1 = require("./Link");
+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) ||
+            Color_1.ImportColor.is(u) ||
+            (0, Number_1.ImportNumber)().is(u) ||
+            (0, Select_1.ImportSelect)().is(u) ||
+            Text_1.ImportText.is(u) ||
+            Date_1.ImportDate.is(u) ||
+            Timestamp_1.ImportTimestamp.is(u) ||
+            Embed_1.ImportEmbed.is(u) ||
+            Link_1.ImportLink.is(u) ||
+            GeoPoint_1.ImportGeoPoint.is(u) ||
+            (0, Image_1.ImportImage)().is(u) ||
+            (0, ImportRichText_1.ImportRichText)().is(u));
+    },
+    decode: (field) => {
+        return (content) => {
+            const codec = getCodecOrThrow(field);
+            return {
+                codec,
+                result: codec.decode(content),
+            };
+        };
+    },
+    getCodec: getCodecOrThrow,
+};

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

@@ -0,0 +1,17 @@
+import * as t from "io-ts";
+export declare const ImportNumber: (field?: ({
+    type: "Number";
+} & {
+    fieldset?: string | null | undefined;
+    config?: {
+        label?: string | null | undefined;
+        placeholder?: string;
+        min?: number;
+        max?: number;
+        step?: number;
+    };
+}) | undefined) => t.Type<{
+    type: "Number";
+    value: number | null;
+}, number | undefined, unknown>;
+export declare type ImportNumber = t.TypeOf<ReturnType<typeof ImportNumber>>;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportNumber = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../../validators");
+const ImportContent_1 = require("../ImportContent");
+const numberValue = (config) => validators_1.Number.pipe(new t.Type("ImportNumberValue", (u) => validators_1.Number.is(u), (n, c) => {
+    const min = config === null || config === void 0 ? void 0 : config.min;
+    const max = config === null || config === void 0 ? void 0 : config.max;
+    if ((min !== undefined && n < min) || (max !== undefined && n > max)) {
+        return t.failure(n, c, `The value must be between [${min !== undefined ? min : ""}, ${max !== undefined ? max : ""}]`);
+    }
+    return t.success(n);
+}, t.identity));
+const ImportNumber = (field) => (0, ImportContent_1.ImportContent)("Number", (0, validators_1.NullOrElse)(numberValue(field === null || field === void 0 ? void 0 : field.config)));
+exports.ImportNumber = ImportNumber;

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

@@ -0,0 +1,16 @@
+import * as t from "io-ts";
+export declare const ImportSelect: (field?: ({
+    type: "Select";
+} & {
+    fieldset?: string | null | undefined;
+    config?: {
+        label?: string | null | undefined;
+        placeholder?: string;
+        default_value?: string;
+        options?: readonly string[];
+    };
+}) | undefined) => t.Type<{
+    type: "Select";
+    value: string | null;
+}, string | undefined, unknown>;
+export declare type ImportSelect = t.TypeOf<ReturnType<typeof ImportSelect>>;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportSelect = void 0;
+const tslib_1 = require("tslib");
+const t = (0, tslib_1.__importStar)(require("io-ts"));
+const validators_1 = require("../../../../validators");
+const ImportContent_1 = require("../ImportContent");
+const selectValue = (config) => validators_1.String.pipe(new t.Type("ImportSelectValue", (u) => validators_1.String.is(u), (s, c) => {
+    var _a;
+    if (!(config === null || config === void 0 ? void 0 : config.options)) {
+        return t.failure(s, c, "The value must be defined in the custom type's configuration of the field");
+    }
+    if (!config.options.includes(s)) {
+        return t.failure(s, c, `The value must be one of these: ${(_a = config.options) === null || _a === void 0 ? void 0 : _a.join(",")}`);
+    }
+    return t.success(s);
+}, t.identity));
+const ImportSelect = (field) => (0, ImportContent_1.ImportContent)("Select", (0, validators_1.NullOrElse)(selectValue(field === null || field === void 0 ? void 0 : field.config)));
+exports.ImportSelect = ImportSelect;

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

@@ -0,0 +1,6 @@
+import type { TypeOf } from "io-ts";
+export declare const ImportText: import("io-ts").Type<{
+    type: "Text";
+    value: string | null;
+}, string | undefined, unknown>;
+export declare type ImportText = TypeOf<typeof ImportText>;

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportText = void 0;
+const validators_1 = require("../../../../validators");
+const ImportContent_1 = require("../ImportContent");
+exports.ImportText = (0, ImportContent_1.ImportContent)("Text", (0, validators_1.NullOrElse)(validators_1.String));

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

@@ -0,0 +1,7 @@
+import * as t from "io-ts";
+export declare const TIMESTAMP_INPUT_REGEX: RegExp;
+export declare const ImportTimestamp: t.Type<{
+    type: "Timestamp";
+    value: Date | null;
+}, Date | undefined, unknown>;
+export declare type ImportTimestamp = t.TypeOf<typeof ImportTimestamp>;

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportTimestamp = exports.TIMESTAMP_INPUT_REGEX = void 0;
+const tslib_1 = require("tslib");
+const Either_1 = 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 ImportContent_1 = require("../ImportContent");
+exports.TIMESTAMP_INPUT_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:(?:[+-]{1}\d{2}:?\d{2})|Z)$/;
+const timestampValue = new t.Type("ImportTimestampValue", (u) => u instanceof Date, (u, c) => (0, function_1.pipe)(validators_1.String.validate(u, c), (0, Either_1.chain)((s) => {
+    const date = new Date(s);
+    const isInvalidDate = isNaN(date.getTime());
+    if (isInvalidDate || !exports.TIMESTAMP_INPUT_REGEX.test(s)) {
+        return t.failure(u, c, "The value must be a DateTime in the format YYYY-MM-DDTHH:MM:SS+0000");
+    }
+    return t.success(date);
+})), t.identity);
+exports.ImportTimestamp = (0, ImportContent_1.ImportContent)("Timestamp", (0, validators_1.NullOrElse)(timestampValue));

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

@@ -0,0 +1,14 @@
+export * from "./Boolean";
+export * from "./Color";
+export * from "./Date";
+export { ImportEmbed } from "./Embed";
+export * from "./GeoPoint";
+export * from "./Image";
+export * from "./Image/index";
+export * from "./ImportRichText";
+export * from "./Link";
+export * from "./Nestable";
+export * from "./Number";
+export * from "./Select";
+export * from "./Text";
+export * from "./Timestamp";

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImportEmbed = void 0;
+const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./Boolean"), exports);
+(0, tslib_1.__exportStar)(require("./Color"), exports);
+(0, tslib_1.__exportStar)(require("./Date"), exports);
+var Embed_1 = require("./Embed");
+Object.defineProperty(exports, "ImportEmbed", { enumerable: true, get: function () { return Embed_1.ImportEmbed; } });
+(0, tslib_1.__exportStar)(require("./GeoPoint"), exports);
+(0, tslib_1.__exportStar)(require("./Image"), exports);
+(0, tslib_1.__exportStar)(require("./Image/index"), exports);
+(0, tslib_1.__exportStar)(require("./ImportRichText"), exports);
+(0, tslib_1.__exportStar)(require("./Link"), exports);
+(0, tslib_1.__exportStar)(require("./Nestable"), exports);
+(0, tslib_1.__exportStar)(require("./Number"), exports);
+(0, tslib_1.__exportStar)(require("./Select"), exports);
+(0, tslib_1.__exportStar)(require("./Text"), exports);
+(0, tslib_1.__exportStar)(require("./Timestamp"), exports);

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

@@ -0,0 +1,2 @@
+export * from "./Document";
+export * from "./fields";

package/lib/import/validators/index.js

@@ -0,0 +1,5 @@
+"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);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prismicio/types-internal",
-	"version": "2.2.1",
+	"version": "2.3.0",
 	"description": "Prismic types for Custom Types and Prismic Data",
 	"keywords": [
 		"typescript",

package/src/content/Document.ts

@@ -13,10 +13,16 @@ import {
 	type StaticWidget,
 	collectSharedSlices,
 	flattenSections,
+	NestableWidget,
 	StaticCustomType,
 } from "../customtypes"
 import {
+	groupContentWithDefaultValues,
+	isGroupContent,
+	isSlicesContent,
 	migrateSliceItem,
+	NestableContentDefaultValue,
+	slicesContentWithDefaultValues,
 	traverseGroupContent,
 	traverseSlices,
 	WidgetContent,
@@ -157,12 +163,70 @@ export const DocumentLegacy = {
 	encode: encodeToLegacyDocument,
 }
 
+function simplifyCustomType(customType: StaticCustomType): {
+	customTypeId: string
+	fields: Record<string, StaticWidget>
+} {
+	return {
+		customTypeId: customType?.id,
+		fields: Object.fromEntries(flattenSections(customType)),
+	}
+}
+
+export function fillDocumentWithDefaultValues(
+	customType:
+		| StaticCustomType
+		| {
+				customTypeId: string
+				fields: Record<string, StaticWidget>
+		  },
+	document: Document,
+): Document {
+	const { fields } =
+		customType && StaticCustomType.is(customType)
+			? simplifyCustomType(customType)
+			: customType
+
+	return Object.entries(fields).reduce<Document>(
+		(updatedDocument, [fieldKey, fieldDef]) => {
+			const fieldContent = document[fieldKey]
+
+			const updatedField = (() => {
+				switch (fieldDef.type) {
+					case "Group":
+						return isGroupContent(fieldContent)
+							? groupContentWithDefaultValues(fieldDef, fieldContent)
+							: fieldContent
+					case "Choice":
+					case "Slices":
+						return isSlicesContent(fieldContent)
+							? slicesContentWithDefaultValues(fieldDef, fieldContent)
+							: fieldContent
+					default:
+						return fieldContent === undefined && NestableWidget.is(fieldDef)
+							? NestableContentDefaultValue(fieldDef)
+							: fieldContent
+				}
+			})()
+
+			return updatedField
+				? {
+						...updatedDocument,
+						[fieldKey]: updatedField,
+				  }
+				: updatedDocument
+		},
+		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 function traverseDocument({
 	document,
@@ -247,16 +311,6 @@ export function traverseDocument({
 	}
 }
 
-function simplifyCustomType(customType: StaticCustomType): {
-	customTypeId: string
-	fields: Record<string, StaticWidget>
-} {
-	return {
-		customTypeId: customType?.id,
-		fields: Object.fromEntries(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/src/content/fields/GroupContent.ts

@@ -16,6 +16,7 @@ import {
 } from "../LegacyContentCtx"
 import { hasContentType } from "../utils"
 import { isNestableContent, NestableContent, NestableLegacy } from "./nestable"
+import { repeatableContentWithDefaultNestableContentValues } from "./withDefaultValues"
 
 export const GroupItemContentType = "GroupItemContent" as const
 
@@ -123,6 +124,21 @@ export const GroupContent = t.strict({
 })
 export type GroupContent = t.TypeOf<typeof GroupContent>
 
+export function groupContentWithDefaultValues(
+	customType: Group,
+	content: GroupContent,
+): GroupContent {
+	const fields = customType.config?.fields
+	if (!fields) return content
+	return {
+		...content,
+		value: repeatableContentWithDefaultNestableContentValues(
+			fields,
+			content.value,
+		),
+	}
+}
+
 export function traverseGroupContent({
 	path,
 	key,

package/src/content/fields/nestable/BooleanContent.ts

@@ -2,6 +2,7 @@ import { either } from "fp-ts"
 import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
+import type { BooleanField } from "../../../customtypes"
 import type { LegacyContentCtx, WithTypes } from "../../LegacyContentCtx"
 import { hasContentType } from "../../utils"
 
@@ -38,3 +39,13 @@ export const BooleanContent = t.strict({
 })
 
 export type BooleanContent = t.TypeOf<typeof BooleanContent>
+
+export const BooleanContentDefaultValue = (
+	field: BooleanField,
+): BooleanContent | undefined =>
+	field.config?.default_value !== undefined
+		? {
+				__TYPE__: BooleanContentType,
+				value: field.config.default_value || false,
+		  }
+		: undefined

package/src/content/fields/nestable/FieldContent/SelectContent.ts

@@ -2,7 +2,7 @@ import { either } from "fp-ts"
 import { pipe } from "fp-ts/lib/function"
 import * as t from "io-ts"
 
-import { SelectFieldType } from "../../../../customtypes/widgets"
+import { Select, SelectFieldType } from "../../../../customtypes/widgets"
 import TrimmedString from "../../../../validators/TrimmedString"
 import type { LegacyContentCtx, WithTypes } from "../../../LegacyContentCtx"
 import { hasContentType, hasFieldContentType } from "../../../utils"
@@ -46,3 +46,14 @@ export const SelectContent = t.strict({
 })
 
 export type SelectContent = t.TypeOf<typeof SelectContent>
+
+export const SelectContentDefaultValue = (
+	field: Select,
+): SelectContent | undefined =>
+	field.config?.default_value
+		? {
+				__TYPE__: FieldContentType,
+				type: SelectFieldType,
+				value: field.config.default_value || "",
+		  }
+		: undefined

package/src/content/fields/nestable/NestableContent.ts

@@ -1,10 +1,12 @@
 import { isRight } from "fp-ts/lib/Either"
 import * as t from "io-ts"
 
+import type { NestableWidget } from "../../../customtypes"
 import type { LegacyContentCtx } from "../../LegacyContentCtx"
 import { EmptyContent, EmptyLegacy, isEmptyContent } from "../EmptyContent"
 import {
 	BooleanContent,
+	BooleanContentDefaultValue,
 	BooleanContentType,
 	BooleanLegacy,
 	isBooleanContent,
@@ -32,6 +34,7 @@ import {
 	RangeContent,
 	RangeLegacy,
 	SelectContent,
+	SelectContentDefaultValue,
 	SelectLegacy,
 	TextContent,
 	TextLegacy,
@@ -97,6 +100,19 @@ export const NestableContent = t.union([
 export type NestableContent = t.TypeOf<typeof NestableContent>
 export type NestableContentType = NestableContent["__TYPE__"]
 
+export const NestableContentDefaultValue = (
+	widgetDef: NestableWidget,
+): NestableContent | undefined => {
+	switch (widgetDef.type) {
+		case "Boolean":
+			return BooleanContentDefaultValue(widgetDef)
+		case "Select":
+			return SelectContentDefaultValue(widgetDef)
+		default:
+			return undefined
+	}
+}
+
 export const isNestableContent = (u: unknown): u is NestableContent =>
 	isTextContent(u) ||
 	isColorContent(u) ||