@prismicio/types-internal 3.16.2-alpha.0 → 3.16.2-alpha.2

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.traverseSlices = exports.slicesContentWithDefaultValues = exports.SlicesContent = exports.SlicesLegacy = exports.isSlicesContent = exports.SlicesContentType = void 0;
+exports.traverseSlicesWithModel = 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");
@@ -8,6 +8,8 @@ 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");
@@ -185,3 +187,278 @@ function traverseSlices({ path, key, model, content, }) {
     };
 }
 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,
+                },
+            },
+        });
+    };
+}
+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/utils.d.ts

@@ -26,6 +26,20 @@ export declare type TraverseWidgetContentFn<ContentTransformMode extends "preser
     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;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prismicio/types-internal",
-	"version": "3.16.2-alpha.0",
+	"version": "3.16.2-alpha.2",
 	"description": "Prismic types for Custom Types and Prismic Data",
 	"keywords": [
 		"typescript",
@@ -14,20 +14,6 @@
 	"author": "Prismic <contact@prismic.io> (https://prismic.io)",
 	"main": "lib/index.js",
 	"types": "lib/index.d.ts",
-	"exports": {
-		".": {
-			"types": "./lib/index.d.ts",
-			"default": "./lib/index.js"
-		},
-		"./lib/customtypes": {
-			"types": "./lib/customtypes/index.d.ts",
-			"default": "./lib/customtypes/index.js"
-		},
-		"./lib/content": {
-			"types": "./lib/content/index.d.ts",
-			"default": "./lib/content/index.js"
-		}
-	},
 	"files": [
 		"lib",
 		"src"

package/src/content/Document.ts

@@ -15,14 +15,21 @@ import {
 import {
 	groupContentWithDefaultValues,
 	isGroupContent,
+	isNestableContent,
+	isRepeatableContent,
 	isSlicesContent,
+	isTableContent,
 	migrateSliceItem,
 	NestableContentDefaultValue,
 	slicesContentWithDefaultValues,
 	traverseGroupContent,
+	traverseGroupContentWithModel,
 	traverseRepeatableContent,
+	traverseRepeatableContentWithModel,
 	traverseSlices,
+	traverseSlicesWithModel,
 	traverseTableContent,
+	traverseTableContentWithModel,
 	WidgetContent,
 	WidgetLegacy,
 } from "./fields"
@@ -35,7 +42,9 @@ import {
 import {
 	ContentPath,
 	TraverseSliceContentFn,
+	TraverseSliceContentWithModelFn,
 	TraverseWidgetContentFn,
+	TraverseWidgetContentWithModelFn,
 } from "./utils"
 
 export const Document = t.record(WidgetKey, WidgetContent)
@@ -407,3 +416,124 @@ export function migrateDocument(
 		transformSlice: migrateSliceItem,
 	})
 }
+
+export function traverseDocumentWithModel({
+	document,
+	customType,
+}: {
+	document: Document
+	customType:
+		| StaticCustomType
+		| {
+				customTypeId: string
+				fields: Record<string, StaticWidget>
+		  }
+}) {
+	const model = StaticCustomType.is(customType)
+		? simplifyCustomType(customType)
+		: customType
+
+	return ({
+		transformWidget,
+		transformSlice,
+	}: {
+		transformWidget: TraverseWidgetContentWithModelFn
+		transformSlice: TraverseSliceContentWithModelFn
+	}): Document => {
+		return Object.entries(model.fields).reduce<Document>(
+			(acc, [key, fieldModel]) => {
+				const content = document[key]
+
+				const path = ContentPath.make([
+					{ key: model.customTypeId, type: "CustomType" },
+					{ key, type: "Widget" },
+				])
+
+				const transformedWidget = (() => {
+					switch (fieldModel.type) {
+						case "Choice":
+						case "Slices": {
+							const slicesContent = isSlicesContent(content)
+								? content
+								: undefined
+							return traverseSlicesWithModel({
+								path,
+								key,
+								model: fieldModel,
+								content: slicesContent,
+							})({ transformWidget, transformSlice })
+						}
+						case "Group": {
+							const groupContent = isGroupContent(content) ? content : undefined
+							return traverseGroupContentWithModel({
+								path,
+								key,
+								model: fieldModel,
+								content: groupContent,
+							})(transformWidget)
+						}
+						case "Link": {
+							if (fieldModel.config?.repeat === true) {
+								const repeatableContent = isRepeatableContent(content)
+									? content
+									: undefined
+								return traverseRepeatableContentWithModel({
+									path,
+									key,
+									model: fieldModel,
+									content: repeatableContent,
+								})(transformWidget)
+							}
+							const nestableContent = isNestableContent(content)
+								? content
+								: undefined
+							return transformWidget({
+								path,
+								key,
+								apiId: key,
+								model: fieldModel,
+								content: nestableContent,
+							})
+						}
+						case "Table": {
+							const tableContent = isTableContent(content) ? content : undefined
+							return traverseTableContentWithModel({
+								path,
+								key,
+								model: fieldModel,
+								content: tableContent,
+							})(transformWidget)
+						}
+						case "UID": {
+							return transformWidget({
+								path,
+								key,
+								apiId: key,
+								model: fieldModel,
+								content,
+							})
+						}
+						default: {
+							const nestableContent = isNestableContent(content)
+								? content
+								: undefined
+							return transformWidget({
+								path,
+								key,
+								apiId: key,
+								model: fieldModel,
+								content: nestableContent,
+							})
+						}
+					}
+				})()
+
+				return {
+					...acc,
+					...(transformedWidget ? { [key]: transformedWidget } : {}),
+				}
+			},
+			{},
+		)
+	}
+}

package/src/content/fields/GroupContent.ts

@@ -6,6 +6,7 @@ import * as t from "io-ts"
 import {
 	type Group,
 	type NestableWidget,
+	type NestedGroup,
 	GroupFieldType,
 } from "../../customtypes"
 import {
@@ -14,7 +15,12 @@ import {
 	LegacyContentCtx,
 	WithTypes,
 } from "../LegacyContentCtx"
-import { ContentPath, hasContentType, TraverseWidgetContentFn } from "../utils"
+import {
+	ContentPath,
+	hasContentType,
+	TraverseWidgetContentFn,
+	TraverseWidgetContentWithModelFn,
+} from "../utils"
 import {
 	isNestableContent,
 	isRepeatableContent,
@@ -22,7 +28,9 @@ import {
 	NestableContent,
 	NestableLegacy,
 	traverseRepeatableContent,
+	traverseRepeatableContentWithModel,
 	traverseTableContent,
+	traverseTableContentWithModel,
 } from "./nestable"
 import { repeatableContentWithDefaultNestableContentValues } from "./withDefaultValues"
 
@@ -327,3 +335,132 @@ export function traverseGroupItemsContent({
 		})
 	}
 }
+
+export function traverseGroupContentWithModel({
+	path,
+	key,
+	model,
+	content,
+}: {
+	path: ContentPath
+	key: string
+	model: Group
+	content: GroupContent | undefined
+}): (transform: TraverseWidgetContentWithModelFn) => GroupContent | undefined {
+	return (transform) => {
+		const groupItems = traverseGroupItemsContentWithModel({
+			path,
+			model: model.config?.fields ?? {},
+			content: content?.value,
+		})(transform)
+
+		return transform({
+			path,
+			key,
+			apiId: key,
+			model,
+			content: content
+				? {
+						__TYPE__: content.__TYPE__,
+						value: groupItems,
+				  }
+				: undefined,
+		})
+	}
+}
+
+export function traverseGroupItemsContentWithModel({
+	path,
+	model,
+	content,
+}: {
+	path: ContentPath
+	model: Record<string, NestableWidget | Group | NestedGroup>
+	content: Array<GroupItemContent> | undefined
+}): (transform: TraverseWidgetContentWithModelFn) => Array<GroupItemContent> {
+	return (transform) => {
+		if (!content) return []
+
+		return content.map((groupItem) => {
+			const groupItemPath = path.concat([
+				{ key: groupItem.key, type: "GroupItem" },
+			])
+
+			const groupItemFields = Object.entries(model).reduce<
+				GroupItemContent["value"]
+			>((acc, [fieldKey, fieldModel]) => {
+				const fieldContent = groupItem.value.find(
+					([key]) => key === fieldKey,
+				)?.[1]
+
+				const fieldPath = groupItemPath.concat([
+					{ key: fieldKey, type: "Widget" },
+				])
+
+				let transformedField: NestableContent | GroupContent | undefined
+				if (fieldModel.type === "Group") {
+					const groupContent = isGroupContent(fieldContent)
+						? fieldContent
+						: undefined
+					transformedField = traverseGroupContentWithModel({
+						path: fieldPath,
+						key: fieldKey,
+						model: fieldModel,
+						content: groupContent,
+					})(transform)
+				} else if (
+					fieldModel.type === "Link" &&
+					fieldModel.config?.repeat === true
+				) {
+					const repeatableContent = isRepeatableContent(fieldContent)
+						? fieldContent
+						: undefined
+					transformedField = traverseRepeatableContentWithModel({
+						path: fieldPath,
+						key: fieldKey,
+						model: fieldModel,
+						content: repeatableContent,
+					})(transform)
+				} else if (fieldModel.type === "Table") {
+					const tableContent = isTableContent(fieldContent)
+						? fieldContent
+						: undefined
+					transformedField = traverseTableContentWithModel({
+						path: fieldPath,
+						key: fieldKey,
+						model: fieldModel,
+						content: tableContent,
+					})(transform)
+				} else {
+					const nestableContent = isNestableContent(fieldContent)
+						? fieldContent
+						: undefined
+					transformedField = transform({
+						path: fieldPath,
+						key: fieldKey,
+						apiId: fieldKey,
+						model: fieldModel,
+						content: nestableContent,
+					})
+				}
+
+				if (
+					!transformedField ||
+					!(
+						isNestableContent(transformedField) ||
+						isGroupContent(transformedField)
+					)
+				)
+					return acc
+
+				return acc.concat([[fieldKey, transformedField]])
+			}, [])
+
+			return {
+				__TYPE__: groupItem.__TYPE__,
+				key: groupItem.key,
+				value: groupItemFields,
+			}
+		})
+	}
+}