@prismicio/types-internal 3.11.0 → 3.11.1

package/lib/customtypes/CustomType.js

@@ -165,16 +165,17 @@ function collectSharedSlices(customType) {
 exports.collectSharedSlices = collectSharedSlices;
 function traverseCustomType(args) {
     const { customType, onField } = args;
+    const json = {};
+    for (const [key, section] of Object.entries(customType.json)) {
+        json[key] = (0, Section_1.traverseSection)({
+            path: [key],
+            section,
+            onField,
+        });
+    }
     return {
         ...customType,
-        json: Object.entries(customType.json).reduce((acc, [key, section]) => {
-            acc[key] = (0, Section_1.traverseSection)({
-                path: [key],
-                section,
-                onField,
-            });
-            return acc;
-        }, {}),
+        json,
     };
 }
 exports.traverseCustomType = traverseCustomType;

package/lib/customtypes/Section.js

@@ -21,9 +21,10 @@ exports.Sections = {
     },
 };
 function traverseSection(args) {
-    const { path: prevPath, section, onField } = args;
-    return Object.entries(section).reduce((acc, [key, prevModel]) => {
-        const path = prevPath.concat(key);
+    const { path: prevPath, section: prevSection, onField } = args;
+    const section = { ...prevSection };
+    for (const [key, prevModel] of Object.entries(prevSection)) {
+        const path = [...prevPath, key];
         let model;
         switch (prevModel.type) {
             case "Choice":
@@ -53,8 +54,8 @@ function traverseSection(args) {
                 });
                 break;
         }
-        acc[key] = model;
-        return acc;
-    }, {});
+        section[key] = model;
+    }
+    return section;
 }
 exports.traverseSection = traverseSection;

package/lib/customtypes/widgets/Group.js

@@ -34,61 +34,59 @@ exports.Group = createGroup(t.union([NestableWidget_1.NestableWidget, exports.Ne
 function traverseNestedGroup(args) {
     var _a;
     const { path: prevPath, group, onField } = args;
-    const fields = ((_a = group.config) === null || _a === void 0 ? void 0 : _a.fields) &&
-        Object.entries(group.config.fields).reduce((acc, [key, model]) => {
-            const path = prevPath.concat(key);
-            acc[key] = onField({
-                path,
-                key,
-                field: model,
-            });
-            return acc;
-        }, {});
+    if (!((_a = group.config) === null || _a === void 0 ? void 0 : _a.fields))
+        return group;
+    const fields = {};
+    for (const [key, prevField] of Object.entries(group.config.fields)) {
+        const path = [...prevPath, key];
+        fields[key] = onField({
+            path,
+            key,
+            field: prevField,
+        });
+    }
     return {
         ...group,
-        ...(group.config && {
-            config: {
-                ...group.config,
-                ...(fields && { fields }),
-            },
-        }),
+        config: {
+            ...group.config,
+            fields,
+        },
     };
 }
 exports.traverseNestedGroup = traverseNestedGroup;
 function traverseGroup(args) {
     var _a;
     const { path: prevPath, group, onField } = args;
-    const fields = ((_a = group.config) === null || _a === void 0 ? void 0 : _a.fields) &&
-        Object.entries(group.config.fields).reduce((acc, [key, prevField]) => {
-            const path = prevPath.concat(key);
-            let field;
-            switch (prevField.type) {
-                case "Group":
-                    field = traverseNestedGroup({
-                        path,
-                        group: prevField,
-                        onField: onField,
-                    });
-                    break;
-                default:
-                    field = prevField;
-                    break;
-            }
-            acc[key] = onField({
-                path,
-                key,
-                field,
-            });
-            return acc;
-        }, {});
+    if (!((_a = group.config) === null || _a === void 0 ? void 0 : _a.fields))
+        return group;
+    const fields = {};
+    for (const [key, prevField] of Object.entries(group.config.fields)) {
+        const path = [...prevPath, key];
+        let field;
+        switch (prevField.type) {
+            case "Group":
+                field = traverseNestedGroup({
+                    path,
+                    group: prevField,
+                    onField: onField,
+                });
+                break;
+            default:
+                field = prevField;
+                break;
+        }
+        fields[key] = onField({
+            path,
+            key,
+            field,
+        });
+    }
     return {
         ...group,
-        ...(group.config && {
-            config: {
-                ...group.config,
-                ...(fields && { fields }),
-            },
-        }),
+        config: {
+            ...group.config,
+            fields,
+        },
     };
 }
 exports.traverseGroup = traverseGroup;

package/lib/customtypes/widgets/slices/CompositeSlice.js

@@ -29,27 +29,22 @@ function isCompositeSlice(slice) {
 }
 exports.isCompositeSlice = isCompositeSlice;
 function traverseCompositeSlice(args) {
+    var _a, _b;
     const { path: prevPath, slice, onField } = args;
-    const nonRepeat = slice["non-repeat"] &&
-        Object.entries(slice["non-repeat"]).reduce((acc, [key, field]) => {
-            const path = prevPath.concat("non-repeat", key);
-            acc[key] = onField({ path, key, field });
-            return acc;
-        }, {});
-    const repeat = slice.repeat &&
-        Object.entries(slice.repeat).reduce((acc, [key, field]) => {
-            const path = prevPath.concat("repeat", key);
-            acc[key] = onField({ path, key, field });
-            return acc;
-        }, {});
+    const nonRepeat = {};
+    for (const [key, field] of Object.entries((_a = slice["non-repeat"]) !== null && _a !== void 0 ? _a : {})) {
+        const path = [...prevPath, "non-repeat", key];
+        nonRepeat[key] = onField({ path, key, field });
+    }
+    const repeat = {};
+    for (const [key, field] of Object.entries((_b = slice.repeat) !== null && _b !== void 0 ? _b : {})) {
+        const path = [...prevPath, "repeat", key];
+        repeat[key] = onField({ path, key, field });
+    }
     return {
         ...slice,
-        ...(nonRepeat && {
-            "non-repeat": nonRepeat,
-        }),
-        ...(repeat && {
-            repeat,
-        }),
+        ...(slice["non-repeat"] && { "non-repeat": nonRepeat }),
+        ...(slice.repeat && { repeat }),
     };
 }
 exports.traverseCompositeSlice = traverseCompositeSlice;

package/lib/customtypes/widgets/slices/SharedSlice.js

@@ -48,59 +48,52 @@ function isDynamicSharedSlice(slice) {
 }
 exports.isDynamicSharedSlice = isDynamicSharedSlice;
 function traverseVariation(args) {
+    var _a, _b;
     const { path: prevPath, variation, onField } = args;
-    return {
-        ...variation,
-        ...(variation.primary && {
-            primary: Object.entries(variation.primary).reduce((acc, [key, prevField]) => {
-                const path = prevPath.concat("primary", key);
-                let field;
-                switch (prevField.type) {
-                    case "Group":
-                        field = (0, Group_1.traverseGroup)({
-                            path,
-                            group: prevField,
-                            onField: onField,
-                        });
-                        break;
-                    default:
-                        field = prevField;
-                        break;
-                }
-                acc[key] = onField({
-                    path,
-                    key,
-                    field,
-                });
-                return acc;
-            }, {}),
-        }),
-        ...(variation.items && {
-            items: Object.entries(variation.items).reduce((acc, [key, field]) => {
-                const path = prevPath.concat("items", key);
-                acc[key] = onField({
+    const primary = {};
+    for (const [key, prevField] of Object.entries((_a = variation.primary) !== null && _a !== void 0 ? _a : {})) {
+        const path = [...prevPath, "primary", key];
+        let field;
+        switch (prevField.type) {
+            case "Group":
+                field = (0, Group_1.traverseGroup)({
                     path,
-                    key,
-                    field,
+                    group: prevField,
+                    onField: onField,
                 });
-                return acc;
-            }, {}),
-        }),
+                break;
+            default:
+                field = prevField;
+                break;
+        }
+        primary[key] = onField({ path, key, field });
+    }
+    const items = {};
+    for (const [key, field] of Object.entries((_b = variation.items) !== null && _b !== void 0 ? _b : {})) {
+        const path = [...prevPath, "items", key];
+        items[key] = onField({ path, key, field });
+    }
+    return {
+        ...variation,
+        ...(variation.primary && { primary }),
+        ...(variation.items && { items }),
     };
 }
 exports.traverseVariation = traverseVariation;
 function traverseSharedSlice(args) {
     const { path: prevPath, slice, onField } = args;
+    const variations = [];
+    for (const variation of slice.variations) {
+        const path = [...prevPath, variation.id];
+        variations.push(traverseVariation({
+            path,
+            variation,
+            onField,
+        }));
+    }
     return {
         ...slice,
-        variations: slice.variations.map((variation) => {
-            const path = prevPath.concat(variation.id);
-            return traverseVariation({
-                path,
-                variation,
-                onField,
-            });
-        }),
+        variations,
     };
 }
 exports.traverseSharedSlice = traverseSharedSlice;

package/lib/customtypes/widgets/slices/Slices.js

@@ -82,59 +82,58 @@ exports.Slices = {
 function traverseSlices(args) {
     var _a;
     const { path: prevPath, slices, onField } = args;
-    const choices = ((_a = slices.config) === null || _a === void 0 ? void 0 : _a.choices) &&
-        Object.entries(slices.config.choices).reduce((acc, [key, prevModel]) => {
-            const path = prevPath.concat(key);
-            let model;
-            switch (prevModel.type) {
-                case "Slice":
-                    model = (0, CompositeSlice_1.traverseCompositeSlice)({
+    if (!((_a = slices.config) === null || _a === void 0 ? void 0 : _a.choices))
+        return slices;
+    const choices = {};
+    for (const [key, prevModel] of Object.entries(slices.config.choices)) {
+        const path = [...prevPath, key];
+        let model;
+        switch (prevModel.type) {
+            case "Slice":
+                model = (0, CompositeSlice_1.traverseCompositeSlice)({
+                    path,
+                    slice: prevModel,
+                    onField: onField,
+                });
+                break;
+            case "SharedSlice":
+                if ("variations" in prevModel)
+                    model = (0, SharedSlice_1.traverseSharedSlice)({
                         path,
                         slice: prevModel,
-                        onField: onField,
-                    });
-                    break;
-                case "SharedSlice":
-                    if ("variations" in prevModel)
-                        model = (0, SharedSlice_1.traverseSharedSlice)({
-                            path,
-                            slice: prevModel,
-                            onField,
-                        });
-                    else
-                        model = prevModel;
-                    break;
-                // Group and other fields are technically possible because of legacy slices.
-                case "Group":
-                    model = onField({
-                        path,
-                        key,
-                        field: (0, Group_1.traverseNestedGroup)({
-                            path,
-                            group: prevModel,
-                            onField: onField,
-                        }),
+                        onField,
                     });
-                    break;
-                default:
-                    model = onField({
+                else
+                    model = prevModel;
+                break;
+            // Group and other fields are technically possible because of legacy slices.
+            case "Group":
+                model = onField({
+                    path,
+                    key,
+                    field: (0, Group_1.traverseNestedGroup)({
                         path,
-                        key,
-                        field: prevModel,
-                    });
-                    break;
-            }
-            acc[key] = model;
-            return acc;
-        }, {});
+                        group: prevModel,
+                        onField: onField,
+                    }),
+                });
+                break;
+            default:
+                model = onField({
+                    path,
+                    key,
+                    field: prevModel,
+                });
+                break;
+        }
+        choices[key] = model;
+    }
     return {
         ...slices,
-        ...(slices.config && {
-            config: {
-                ...slices.config,
-                ...(choices && { choices }),
-            },
-        }),
+        config: {
+            ...slices.config,
+            choices,
+        },
     };
 }
 exports.traverseSlices = traverseSlices;

package/package.json

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

package/src/customtypes/CustomType.ts

@@ -260,17 +260,18 @@ export function traverseCustomType<
 	onField: OnFieldFn<UID | NestableWidget | Group | NestedGroup>
 }): T {
 	const { customType, onField } = args
+
+	const json: Record<string, typeof customType.json[string]> = {}
+	for (const [key, section] of Object.entries(customType.json)) {
+		json[key] = traverseSection({
+			path: [key],
+			section,
+			onField,
+		})
+	}
+
 	return {
 		...customType,
-		json: Object.entries(customType.json).reduce<
-			Record<string, typeof customType.json[string]>
-		>((acc, [key, section]) => {
-			acc[key] = traverseSection({
-				path: [key],
-				section,
-				onField,
-			})
-			return acc
-		}, {}),
+		json,
 	}
 }

package/src/customtypes/Section.ts

@@ -50,9 +50,11 @@ export function traverseSection<
 	section: T
 	onField: OnFieldFn<UID | NestableWidget | Group | NestedGroup>
 }): T {
-	const { path: prevPath, section, onField } = args
-	return Object.entries(section).reduce((acc, [key, prevModel]) => {
-		const path = prevPath.concat(key)
+	const { path: prevPath, section: prevSection, onField } = args
+
+	const section = { ...prevSection }
+	for (const [key, prevModel] of Object.entries(prevSection)) {
+		const path = [...prevPath, key]
 		let model
 		switch (prevModel.type) {
 			case "Choice":
@@ -82,7 +84,7 @@ export function traverseSection<
 				})
 				break
 		}
-		acc[key] = model
-		return acc
-	}, {} as T)
+		section[key] = model
+	}
+	return section
 }

package/src/customtypes/widgets/Group.ts

@@ -55,28 +55,25 @@ export function traverseNestedGroup(args: {
 	onField: OnFieldFn<NestableWidget>
 }): NestedGroup {
 	const { path: prevPath, group, onField } = args
-	const fields =
-		group.config?.fields &&
-		Object.entries(group.config.fields).reduce<Record<string, NestableWidget>>(
-			(acc, [key, model]) => {
-				const path = prevPath.concat(key)
-				acc[key] = onField({
-					path,
-					key,
-					field: model,
-				})
-				return acc
-			},
-			{},
-		)
+
+	if (!group.config?.fields) return group
+
+	const fields: Record<string, NestableWidget> = {}
+	for (const [key, prevField] of Object.entries(group.config.fields)) {
+		const path = [...prevPath, key]
+		fields[key] = onField({
+			path,
+			key,
+			field: prevField,
+		})
+	}
+
 	return {
 		...group,
-		...(group.config && {
-			config: {
-				...group.config,
-				...(fields && { fields }),
-			},
-		}),
+		config: {
+			...group.config,
+			fields,
+		},
 	}
 }
 
@@ -86,39 +83,37 @@ export function traverseGroup(args: {
 	onField: OnFieldFn<NestableWidget | NestedGroup>
 }): Group {
 	const { path: prevPath, group, onField } = args
-	const fields =
-		group.config?.fields &&
-		Object.entries(group.config.fields).reduce<
-			Record<string, NestableWidget | NestedGroup>
-		>((acc, [key, prevField]) => {
-			const path = prevPath.concat(key)
-			let field
-			switch (prevField.type) {
-				case "Group":
-					field = traverseNestedGroup({
-						path,
-						group: prevField,
-						onField: onField as OnFieldFn<NestableWidget>,
-					})
-					break
-				default:
-					field = prevField
-					break
-			}
-			acc[key] = onField({
-				path,
-				key,
-				field,
-			})
-			return acc
-		}, {})
+
+	if (!group.config?.fields) return group
+
+	const fields: Record<string, NestableWidget | NestedGroup> = {}
+	for (const [key, prevField] of Object.entries(group.config.fields)) {
+		const path = [...prevPath, key]
+		let field
+		switch (prevField.type) {
+			case "Group":
+				field = traverseNestedGroup({
+					path,
+					group: prevField,
+					onField: onField as OnFieldFn<NestableWidget>,
+				})
+				break
+			default:
+				field = prevField
+				break
+		}
+		fields[key] = onField({
+			path,
+			key,
+			field,
+		})
+	}
+
 	return {
 		...group,
-		...(group.config && {
-			config: {
-				...group.config,
-				...(fields && { fields }),
-			},
-		}),
+		config: {
+			...group.config,
+			fields,
+		},
 	}
 }

package/src/customtypes/widgets/slices/CompositeSlice.ts

@@ -45,33 +45,22 @@ export function traverseCompositeSlice(args: {
 	onField: OnFieldFn<NestableWidget>
 }): CompositeSlice {
 	const { path: prevPath, slice, onField } = args
-	const nonRepeat =
-		slice["non-repeat"] &&
-		Object.entries(slice["non-repeat"]).reduce<Record<string, NestableWidget>>(
-			(acc, [key, field]) => {
-				const path = prevPath.concat("non-repeat", key)
-				acc[key] = onField({ path, key, field })
-				return acc
-			},
-			{},
-		)
-	const repeat =
-		slice.repeat &&
-		Object.entries(slice.repeat).reduce<Record<string, NestableWidget>>(
-			(acc, [key, field]) => {
-				const path = prevPath.concat("repeat", key)
-				acc[key] = onField({ path, key, field })
-				return acc
-			},
-			{},
-		)
+
+	const nonRepeat: Record<string, NestableWidget> = {}
+	for (const [key, field] of Object.entries(slice["non-repeat"] ?? {})) {
+		const path = [...prevPath, "non-repeat", key]
+		nonRepeat[key] = onField({ path, key, field })
+	}
+
+	const repeat: Record<string, NestableWidget> = {}
+	for (const [key, field] of Object.entries(slice.repeat ?? {})) {
+		const path = [...prevPath, "repeat", key]
+		repeat[key] = onField({ path, key, field })
+	}
+
 	return {
 		...slice,
-		...(nonRepeat && {
-			"non-repeat": nonRepeat,
-		}),
-		...(repeat && {
-			repeat,
-		}),
+		...(slice["non-repeat"] && { "non-repeat": nonRepeat }),
+		...(slice.repeat && { repeat }),
 	}
 }