@prismicio/types-internal 3.10.2-alpha.2 → 3.10.2-alpha.3

package/lib/content/Document.js

@@ -107,43 +107,32 @@ function fillDocumentWithDefaultValues(customType, document) {
     const { fields } = customType && customtypes_1.StaticCustomType.is(customType)
         ? simplifyCustomType(customType)
         : customType;
-    // Create a shallow copy of the original document
-    const result = { ...document };
-    // Process fields from the custom type
-    const fieldKeys = Object.keys(fields);
-    for (let i = 0; i < fieldKeys.length; i++) {
-        const fieldKey = fieldKeys[i];
-        if (!fieldKey)
-            continue;
-        const fieldDef = fields[fieldKey];
-        if (!fieldDef)
-            continue;
+    return Object.entries(fields).reduce((updatedDocument, [fieldKey, fieldDef]) => {
         const fieldContent = document[fieldKey];
-        let updatedField;
-        switch (fieldDef.type) {
-            case "Group":
-                updatedField = (0, fields_1.isGroupContent)(fieldContent)
-                    ? (0, fields_1.groupContentWithDefaultValues)(fieldDef, fieldContent)
-                    : fieldContent;
-                break;
-            case "Choice":
-            case "Slices":
-                updatedField = (0, fields_1.isSlicesContent)(fieldContent)
-                    ? (0, fields_1.slicesContentWithDefaultValues)(fieldDef, fieldContent)
-                    : fieldContent;
-                break;
-            default:
-                updatedField =
-                    fieldContent === undefined && customtypes_1.NestableWidget.is(fieldDef)
+        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;
-                break;
-        }
-        if (updatedField) {
-            result[fieldKey] = updatedField;
-        }
-    }
-    return result;
+            }
+        })();
+        return updatedField
+            ? {
+                ...updatedDocument,
+                [fieldKey]: updatedField,
+            }
+            : updatedDocument;
+    }, document);
 }
 exports.fillDocumentWithDefaultValues = fillDocumentWithDefaultValues;
 /**

package/lib/customtypes/CustomType.js

@@ -165,34 +165,21 @@ function collectSharedSlices(customType) {
 exports.collectSharedSlices = collectSharedSlices;
 function traverseCustomType(args) {
     const { customType, onField } = args;
-    // Create a new result object directly
-    const result = Object.create(null);
-    // Copy all properties directly
-    result.id = customType.id;
-    result.label = customType.label;
-    result.repeatable = customType.repeatable;
-    result.status = customType.status;
-    // Copy optional properties
-    if (customType.format !== undefined)
-        result.format = customType.format;
-    // Process JSON sections
-    const newJson = Object.create(null);
+    const result = { ...customType };
+    const newJson = {};
     const keys = Object.keys(customType.json);
-    const keyCount = keys.length;
-    for (let i = 0; i < keyCount; i++) {
+    for (let i = 0; i < keys.length; i++) {
         const key = keys[i];
-        if (!key)
-            continue;
-        const section = customType.json[key];
-        if (!section)
-            continue;
-        // Create path array directly
-        const newPath = [key];
-        newJson[key] = (0, Section_1.traverseSection)({
-            path: newPath,
-            section,
-            onField,
-        });
+        if (key) {
+            const section = customType.json[key];
+            if (section) {
+                newJson[key] = (0, Section_1.traverseSection)({
+                    path: [key],
+                    section,
+                    onField,
+                });
+            }
+        }
     }
     result.json = newJson;
     return result;

package/lib/customtypes/Section.js

@@ -22,53 +22,46 @@ exports.Sections = {
 };
 function traverseSection(args) {
     const { path: prevPath, section, onField } = args;
-    const result = Object.create(null);
+    const result = {};
     const keys = Object.keys(section);
-    const keyCount = keys.length;
-    for (let i = 0; i < keyCount; i++) {
+    for (let i = 0; i < keys.length; i++) {
         const key = keys[i];
-        if (!key)
-            continue;
-        const prevModel = section[key];
-        if (!prevModel)
-            continue;
-        // Create path array directly
-        const pathLength = prevPath.length;
-        const newPath = new Array(pathLength + 1);
-        for (let j = 0; j < pathLength; j++) {
-            newPath[j] = prevPath[j];
+        if (key) {
+            const prevModel = section[key];
+            if (prevModel) {
+                const path = [...prevPath, key];
+                let model;
+                switch (prevModel.type) {
+                    case "Choice":
+                    case "Slices":
+                        model = (0, widgets_1.traverseSlices)({
+                            path,
+                            slices: prevModel,
+                            onField: onField,
+                        });
+                        break;
+                    case "Group":
+                        model = onField({
+                            path,
+                            key,
+                            field: (0, widgets_1.traverseGroup)({
+                                path,
+                                group: prevModel,
+                                onField: onField,
+                            }),
+                        });
+                        break;
+                    default:
+                        model = onField({
+                            path,
+                            key,
+                            field: prevModel,
+                        });
+                        break;
+                }
+                result[key] = model;
+            }
         }
-        newPath[pathLength] = key;
-        let model;
-        switch (prevModel.type) {
-            case "Choice":
-            case "Slices":
-                model = (0, widgets_1.traverseSlices)({
-                    path: newPath,
-                    slices: prevModel,
-                    onField: onField,
-                });
-                break;
-            case "Group":
-                model = onField({
-                    path: newPath,
-                    key,
-                    field: (0, widgets_1.traverseGroup)({
-                        path: newPath,
-                        group: prevModel,
-                        onField: onField,
-                    }),
-                });
-                break;
-            default:
-                model = onField({
-                    path: newPath,
-                    key,
-                    field: prevModel,
-                });
-                break;
-        }
-        result[key] = model;
     }
     return result;
 }

package/lib/customtypes/widgets/Group.js

@@ -34,119 +34,81 @@ exports.Group = createGroup(t.union([NestableWidget_1.NestableWidget, exports.Ne
 function traverseNestedGroup(args) {
     var _a;
     const { path: prevPath, group, onField } = args;
-    // If no fields, return the group as is to avoid unnecessary object creation
-    if (!((_a = group.config) === null || _a === void 0 ? void 0 : _a.fields)) {
-        return group;
-    }
-    // Create result object only once with direct property assignment
-    const result = Object.create(null);
-    result.type = group.type;
-    // Copy non-config properties directly
-    if (group.fieldset !== undefined)
-        result.fieldset = group.fieldset;
-    if (group.icon !== undefined)
-        result.icon = group.icon;
-    if (group.description !== undefined)
-        result.description = group.description;
-    // Create config object
-    const config = Object.create(null);
-    if (group.config.label !== undefined)
-        config.label = group.config.label;
-    if (group.config.repeat !== undefined)
-        config.repeat = group.config.repeat;
-    // Process fields
-    const fields = Object.create(null);
-    const fieldEntries = group.config.fields;
-    const keys = Object.keys(fieldEntries);
-    const keyCount = keys.length;
-    for (let i = 0; i < keyCount; i++) {
-        const key = keys[i];
-        if (!key)
-            continue;
-        const model = fieldEntries[key];
-        if (!model)
-            continue;
-        // Create new path array directly
-        const pathLength = prevPath.length;
-        const newPath = new Array(pathLength + 1);
-        for (let j = 0; j < pathLength; j++) {
-            newPath[j] = prevPath[j];
+    let fields = undefined;
+    if ((_a = group.config) === null || _a === void 0 ? void 0 : _a.fields) {
+        fields = {};
+        const fieldEntries = group.config.fields;
+        const keys = Object.keys(fieldEntries);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (key) {
+                const model = fieldEntries[key];
+                if (model) {
+                    // Create new path array instead of using concat
+                    const newPath = [...prevPath, key];
+                    fields[key] = onField({
+                        path: newPath,
+                        key,
+                        field: model,
+                    });
+                }
+            }
         }
-        newPath[pathLength] = key;
-        fields[key] = onField({
-            path: newPath,
-            key,
-            field: model,
-        });
     }
-    config.fields = fields;
-    result.config = config;
-    return result;
+    return {
+        ...group,
+        ...(group.config && {
+            config: {
+                ...group.config,
+                ...(fields && { fields }),
+            },
+        }),
+    };
 }
 exports.traverseNestedGroup = traverseNestedGroup;
 function traverseGroup(args) {
     var _a;
     const { path: prevPath, group, onField } = args;
-    // If no fields, return the group as is to avoid unnecessary object creation
-    if (!((_a = group.config) === null || _a === void 0 ? void 0 : _a.fields)) {
-        return group;
-    }
-    // Create result object only once with direct property assignment
-    const result = Object.create(null);
-    result.type = group.type;
-    // Copy non-config properties directly
-    if (group.fieldset !== undefined)
-        result.fieldset = group.fieldset;
-    if (group.icon !== undefined)
-        result.icon = group.icon;
-    if (group.description !== undefined)
-        result.description = group.description;
-    // Create config object
-    const config = Object.create(null);
-    if (group.config.label !== undefined)
-        config.label = group.config.label;
-    if (group.config.repeat !== undefined)
-        config.repeat = group.config.repeat;
-    // Process fields
-    const fields = Object.create(null);
-    const fieldEntries = group.config.fields;
-    const keys = Object.keys(fieldEntries);
-    const keyCount = keys.length;
-    for (let i = 0; i < keyCount; i++) {
-        const key = keys[i];
-        if (!key)
-            continue;
-        const prevField = fieldEntries[key];
-        if (!prevField)
-            continue;
-        // Create new path array directly
-        const pathLength = prevPath.length;
-        const newPath = new Array(pathLength + 1);
-        for (let j = 0; j < pathLength; j++) {
-            newPath[j] = prevPath[j];
-        }
-        newPath[pathLength] = key;
-        let field;
-        switch (prevField.type) {
-            case "Group":
-                field = traverseNestedGroup({
+    let fields = undefined;
+    if ((_a = group.config) === null || _a === void 0 ? void 0 : _a.fields) {
+        fields = {};
+        const fieldEntries = group.config.fields;
+        const keys = Object.keys(fieldEntries);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (key) {
+                const prevField = fieldEntries[key];
+                // Create new path array instead of using concat
+                const newPath = [...prevPath, key];
+                let field;
+                switch (prevField.type) {
+                    case "Group":
+                        field = traverseNestedGroup({
+                            path: newPath,
+                            group: prevField,
+                            onField: onField,
+                        });
+                        break;
+                    default:
+                        field = prevField;
+                        break;
+                }
+                fields[key] = onField({
                     path: newPath,
-                    group: prevField,
-                    onField: onField,
+                    key,
+                    field,
                 });
-                break;
-            default:
-                field = prevField;
-                break;
+            }
         }
-        fields[key] = onField({
-            path: newPath,
-            key,
-            field,
-        });
     }
-    config.fields = fields;
-    result.config = config;
-    return result;
+    return {
+        ...group,
+        ...(group.config && {
+            config: {
+                ...group.config,
+                ...(fields && { fields }),
+            },
+        }),
+    };
 }
 exports.traverseGroup = traverseGroup;

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

@@ -49,88 +49,55 @@ function isDynamicSharedSlice(slice) {
 exports.isDynamicSharedSlice = isDynamicSharedSlice;
 function traverseVariation(args) {
     const { path: prevPath, variation, onField } = args;
-    // If no primary or items, return the variation as is
-    if (!variation.primary && !variation.items) {
-        return variation;
-    }
-    // Create result object directly
-    const result = Object.create(null);
-    // Copy all basic properties
-    result.id = variation.id;
-    result.name = variation.name;
-    result.description = variation.description;
-    result.imageUrl = variation.imageUrl;
-    result.docURL = variation.docURL;
-    result.version = variation.version;
-    // Copy optional properties if they exist
-    if (variation.display !== undefined)
-        result.display = variation.display;
-    // Process primary fields if they exist
+    const result = { ...variation };
     if (variation.primary) {
-        const primary = Object.create(null);
+        const primary = {};
         const keys = Object.keys(variation.primary);
-        const keyCount = keys.length;
-        for (let i = 0; i < keyCount; i++) {
+        for (let i = 0; i < keys.length; i++) {
             const key = keys[i];
-            if (!key)
-                continue;
-            const prevField = variation.primary[key];
-            if (!prevField)
-                continue;
-            // Create path array directly
-            const pathLength = prevPath.length;
-            const newPath = new Array(pathLength + 2);
-            for (let j = 0; j < pathLength; j++) {
-                newPath[j] = prevPath[j];
-            }
-            newPath[pathLength] = "primary";
-            newPath[pathLength + 1] = key;
-            let field;
-            switch (prevField.type) {
-                case "Group":
-                    field = (0, Group_1.traverseGroup)({
-                        path: newPath,
-                        group: prevField,
-                        onField: onField,
+            if (key) {
+                const prevField = variation.primary[key];
+                if (prevField) {
+                    const path = [...prevPath, "primary", key];
+                    let field;
+                    switch (prevField.type) {
+                        case "Group":
+                            field = (0, Group_1.traverseGroup)({
+                                path,
+                                group: prevField,
+                                onField: onField,
+                            });
+                            break;
+                        default:
+                            field = prevField;
+                            break;
+                    }
+                    primary[key] = onField({
+                        path,
+                        key,
+                        field,
                     });
-                    break;
-                default:
-                    field = prevField;
-                    break;
+                }
             }
-            primary[key] = onField({
-                path: newPath,
-                key,
-                field,
-            });
         }
         result.primary = primary;
     }
-    // Process items fields if they exist
     if (variation.items) {
-        const items = Object.create(null);
+        const items = {};
         const keys = Object.keys(variation.items);
-        const keyCount = keys.length;
-        for (let i = 0; i < keyCount; i++) {
+        for (let i = 0; i < keys.length; i++) {
             const key = keys[i];
-            if (!key)
-                continue;
-            const field = variation.items[key];
-            if (!field)
-                continue;
-            // Create path array directly
-            const pathLength = prevPath.length;
-            const newPath = new Array(pathLength + 2);
-            for (let j = 0; j < pathLength; j++) {
-                newPath[j] = prevPath[j];
+            if (key) {
+                const field = variation.items[key];
+                if (field) {
+                    const path = [...prevPath, "items", key];
+                    items[key] = onField({
+                        path,
+                        key,
+                        field,
+                    });
+                }
             }
-            newPath[pathLength] = "items";
-            newPath[pathLength + 1] = key;
-            items[key] = onField({
-                path: newPath,
-                key,
-                field,
-            });
         }
         result.items = items;
     }
@@ -139,36 +106,18 @@ function traverseVariation(args) {
 exports.traverseVariation = traverseVariation;
 function traverseSharedSlice(args) {
     const { path: prevPath, slice, onField } = args;
-    // Create the result object directly
-    const result = Object.create(null);
-    // Copy all base properties
-    result.id = slice.id;
-    result.type = slice.type;
-    result.name = slice.name;
-    // Copy optional properties
-    if (slice.description !== undefined)
-        result.description = slice.description;
-    if (slice.legacyPaths !== undefined)
-        result.legacyPaths = slice.legacyPaths;
-    // Process variations
-    const variationCount = slice.variations.length;
-    const variations = new Array(variationCount);
-    for (let i = 0; i < variationCount; i++) {
+    const result = { ...slice };
+    const variations = [];
+    for (let i = 0; i < slice.variations.length; i++) {
         const variation = slice.variations[i];
-        if (!variation)
-            continue;
-        // Create path array directly
-        const pathLength = prevPath.length;
-        const newPath = new Array(pathLength + 1);
-        for (let j = 0; j < pathLength; j++) {
-            newPath[j] = prevPath[j];
+        if (variation) {
+            const path = [...prevPath, variation.id];
+            variations.push(traverseVariation({
+                path,
+                variation,
+                onField,
+            }));
         }
-        newPath[pathLength] = variation.id;
-        variations[i] = traverseVariation({
-            path: newPath,
-            variation,
-            onField,
-        });
     }
     result.variations = variations;
     return result;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@prismicio/types-internal",
-	"version": "3.10.2-alpha.2",
+	"version": "3.10.2-alpha.3",
 	"description": "Prismic types for Custom Types and Prismic Data",
 	"keywords": [
 		"typescript",

package/src/content/Document.ts

@@ -195,47 +195,37 @@ export function fillDocumentWithDefaultValues(
 			? simplifyCustomType(customType)
 			: customType
 
-	// Create a shallow copy of the original document
-	const result = { ...document }
-
-	// Process fields from the custom type
-	const fieldKeys = Object.keys(fields)
-	for (let i = 0; i < fieldKeys.length; i++) {
-		const fieldKey = fieldKeys[i]
-		if (!fieldKey) continue
-
-		const fieldDef = fields[fieldKey]
-		if (!fieldDef) continue
-
-		const fieldContent = document[fieldKey]
-		let updatedField
-
-		switch (fieldDef.type) {
-			case "Group":
-				updatedField = isGroupContent(fieldContent)
-					? groupContentWithDefaultValues(fieldDef, fieldContent)
-					: fieldContent
-				break
-			case "Choice":
-			case "Slices":
-				updatedField = isSlicesContent(fieldContent)
-					? slicesContentWithDefaultValues(fieldDef, fieldContent)
-					: fieldContent
-				break
-			default:
-				updatedField =
-					fieldContent === undefined && NestableWidget.is(fieldDef)
-						? NestableContentDefaultValue(fieldDef)
-						: fieldContent
-				break
-		}
-
-		if (updatedField) {
-			result[fieldKey] = updatedField
-		}
-	}
-
-	return result
+	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

package/src/customtypes/CustomType.ts

@@ -260,39 +260,22 @@ export function traverseCustomType<
 	onField: OnFieldFn<UID | NestableWidget | Group | NestedGroup>
 }): T {
 	const { customType, onField } = args
+	const result = { ...customType } as T
+	const newJson: Record<string, typeof customType.json[string]> = {}
 
-	// Create a new result object directly
-	const result = Object.create(null) as T
-
-	// Copy all properties directly
-	result.id = customType.id
-	result.label = customType.label
-	result.repeatable = customType.repeatable
-	result.status = customType.status
-
-	// Copy optional properties
-	if (customType.format !== undefined) result.format = customType.format
-
-	// Process JSON sections
-	const newJson = Object.create(null)
 	const keys = Object.keys(customType.json)
-	const keyCount = keys.length
-
-	for (let i = 0; i < keyCount; i++) {
+	for (let i = 0; i < keys.length; i++) {
 		const key = keys[i]
-		if (!key) continue
-
-		const section = customType.json[key]
-		if (!section) continue
-
-		// Create path array directly
-		const newPath = [key]
-
-		newJson[key] = traverseSection({
-			path: newPath,
-			section,
-			onField,
-		})
+		if (key) {
+			const section = customType.json[key]
+			if (section) {
+				newJson[key] = traverseSection({
+					path: [key],
+					section,
+					onField,
+				})
+			}
+		}
 	}
 
 	result.json = newJson

package/src/customtypes/Section.ts

@@ -51,58 +51,51 @@ export function traverseSection<
 	onField: OnFieldFn<UID | NestableWidget | Group | NestedGroup>
 }): T {
 	const { path: prevPath, section, onField } = args
-	const result = Object.create(null) as T
+	const result = {} as T
 
 	const keys = Object.keys(section)
-	const keyCount = keys.length
-
-	for (let i = 0; i < keyCount; i++) {
+	for (let i = 0; i < keys.length; i++) {
 		const key = keys[i]
-		if (!key) continue
+		if (key) {
+			const prevModel = section[key]
+			if (prevModel) {
+				const path = [...prevPath, key]
+				let model
 
-		const prevModel = section[key]
-		if (!prevModel) continue
+				switch (prevModel.type) {
+					case "Choice":
+					case "Slices":
+						model = traverseSlices({
+							path,
+							slices: prevModel,
+							onField: onField as OnFieldFn<
+								NestableWidget | Group | NestedGroup
+							>,
+						})
+						break
+					case "Group":
+						model = onField({
+							path,
+							key,
+							field: traverseGroup({
+								path,
+								group: prevModel,
+								onField: onField as OnFieldFn<NestableWidget | NestedGroup>,
+							}),
+						})
+						break
+					default:
+						model = onField({
+							path,
+							key,
+							field: prevModel,
+						})
+						break
+				}
 
-		// Create path array directly
-		const pathLength = prevPath.length
-		const newPath = new Array(pathLength + 1)
-		for (let j = 0; j < pathLength; j++) {
-			newPath[j] = prevPath[j]
+				result[key] = model as any
+			}
 		}
-		newPath[pathLength] = key
-
-		let model
-
-		switch (prevModel.type) {
-			case "Choice":
-			case "Slices":
-				model = traverseSlices({
-					path: newPath,
-					slices: prevModel,
-					onField: onField as OnFieldFn<NestableWidget | Group | NestedGroup>,
-				})
-				break
-			case "Group":
-				model = onField({
-					path: newPath,
-					key,
-					field: traverseGroup({
-						path: newPath,
-						group: prevModel,
-						onField: onField as OnFieldFn<NestableWidget | NestedGroup>,
-					}),
-				})
-				break
-			default:
-				model = onField({
-					path: newPath,
-					key,
-					field: prevModel,
-				})
-				break
-		}
-
-		result[key] = model
 	}
 
 	return result

package/src/customtypes/widgets/Group.ts

@@ -55,58 +55,39 @@ export function traverseNestedGroup(args: {
 	onField: OnFieldFn<NestableWidget>
 }): NestedGroup {
 	const { path: prevPath, group, onField } = args
-
-	// If no fields, return the group as is to avoid unnecessary object creation
-	if (!group.config?.fields) {
-		return group
-	}
-
-	// Create result object only once with direct property assignment
-	const result = Object.create(null)
-	result.type = group.type
-
-	// Copy non-config properties directly
-	if (group.fieldset !== undefined) result.fieldset = group.fieldset
-	if (group.icon !== undefined) result.icon = group.icon
-	if (group.description !== undefined) result.description = group.description
-
-	// Create config object
-	const config = Object.create(null)
-	if (group.config.label !== undefined) config.label = group.config.label
-	if (group.config.repeat !== undefined) config.repeat = group.config.repeat
-
-	// Process fields
-	const fields = Object.create(null)
-	const fieldEntries = group.config.fields
-	const keys = Object.keys(fieldEntries)
-	const keyCount = keys.length
-
-	for (let i = 0; i < keyCount; i++) {
-		const key = keys[i]
-		if (!key) continue
-
-		const model = fieldEntries[key]
-		if (!model) continue
-
-		// Create new path array directly
-		const pathLength = prevPath.length
-		const newPath = new Array(pathLength + 1)
-		for (let j = 0; j < pathLength; j++) {
-			newPath[j] = prevPath[j]
+	let fields: Record<string, NestableWidget> | undefined = undefined
+
+	if (group.config?.fields) {
+		fields = {}
+		const fieldEntries = group.config.fields
+		const keys = Object.keys(fieldEntries)
+
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i]
+			if (key) {
+				const model = fieldEntries[key]
+				if (model) {
+					// Create new path array instead of using concat
+					const newPath = [...prevPath, key]
+					fields[key] = onField({
+						path: newPath,
+						key,
+						field: model,
+					})
+				}
+			}
 		}
-		newPath[pathLength] = key
-
-		fields[key] = onField({
-			path: newPath,
-			key,
-			field: model,
-		})
 	}
 
-	config.fields = fields
-	result.config = config
-
-	return result
+	return {
+		...group,
+		...(group.config && {
+			config: {
+				...group.config,
+				...(fields && { fields }),
+			},
+		}),
+	}
 }
 
 export function traverseGroup(args: {
@@ -115,71 +96,51 @@ export function traverseGroup(args: {
 	onField: OnFieldFn<NestableWidget | NestedGroup>
 }): Group {
 	const { path: prevPath, group, onField } = args
-
-	// If no fields, return the group as is to avoid unnecessary object creation
-	if (!group.config?.fields) {
-		return group
-	}
-
-	// Create result object only once with direct property assignment
-	const result = Object.create(null)
-	result.type = group.type
-
-	// Copy non-config properties directly
-	if (group.fieldset !== undefined) result.fieldset = group.fieldset
-	if (group.icon !== undefined) result.icon = group.icon
-	if (group.description !== undefined) result.description = group.description
-
-	// Create config object
-	const config = Object.create(null)
-	if (group.config.label !== undefined) config.label = group.config.label
-	if (group.config.repeat !== undefined) config.repeat = group.config.repeat
-
-	// Process fields
-	const fields = Object.create(null)
-	const fieldEntries = group.config.fields
-	const keys = Object.keys(fieldEntries)
-	const keyCount = keys.length
-
-	for (let i = 0; i < keyCount; i++) {
-		const key = keys[i]
-		if (!key) continue
-
-		const prevField = fieldEntries[key]
-		if (!prevField) continue
-
-		// Create new path array directly
-		const pathLength = prevPath.length
-		const newPath = new Array(pathLength + 1)
-		for (let j = 0; j < pathLength; j++) {
-			newPath[j] = prevPath[j]
-		}
-		newPath[pathLength] = key
-
-		let field
-
-		switch (prevField.type) {
-			case "Group":
-				field = traverseNestedGroup({
+	let fields: Record<string, NestableWidget | NestedGroup> | undefined =
+		undefined
+
+	if (group.config?.fields) {
+		fields = {}
+		const fieldEntries = group.config.fields
+		const keys = Object.keys(fieldEntries)
+
+		for (let i = 0; i < keys.length; i++) {
+			const key = keys[i]
+			if (key) {
+				const prevField = fieldEntries[key] as NestableWidget | NestedGroup
+				// Create new path array instead of using concat
+				const newPath = [...prevPath, key] as ReadonlyArray<string>
+				let field
+
+				switch (prevField.type) {
+					case "Group":
+						field = traverseNestedGroup({
+							path: newPath,
+							group: prevField,
+							onField: onField as OnFieldFn<NestableWidget>,
+						})
+						break
+					default:
+						field = prevField
+						break
+				}
+
+				fields[key] = onField({
 					path: newPath,
-					group: prevField,
-					onField: onField as OnFieldFn<NestableWidget>,
+					key,
+					field,
 				})
-				break
-			default:
-				field = prevField
-				break
+			}
 		}
-
-		fields[key] = onField({
-			path: newPath,
-			key,
-			field,
-		})
 	}
 
-	config.fields = fields
-	result.config = config
-
-	return result
+	return {
+		...group,
+		...(group.config && {
+			config: {
+				...group.config,
+				...(fields && { fields }),
+			},
+		}),
+	}
 }

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

@@ -78,100 +78,62 @@ export function traverseVariation(args: {
 	onField: OnFieldFn<NestableWidget | Group | NestedGroup>
 }): Variation {
 	const { path: prevPath, variation, onField } = args
+	const result = { ...variation }
 
-	// If no primary or items, return the variation as is
-	if (!variation.primary && !variation.items) {
-		return variation
-	}
-
-	// Create result object directly
-	const result = Object.create(null)
-
-	// Copy all basic properties
-	result.id = variation.id
-	result.name = variation.name
-	result.description = variation.description
-	result.imageUrl = variation.imageUrl
-	result.docURL = variation.docURL
-	result.version = variation.version
-
-	// Copy optional properties if they exist
-	if (variation.display !== undefined) result.display = variation.display
-
-	// Process primary fields if they exist
 	if (variation.primary) {
-		const primary = Object.create(null)
+		const primary: Record<string, NestableWidget | Group> = {}
 		const keys = Object.keys(variation.primary)
-		const keyCount = keys.length
 
-		for (let i = 0; i < keyCount; i++) {
+		for (let i = 0; i < keys.length; i++) {
 			const key = keys[i]
-			if (!key) continue
-
-			const prevField = variation.primary[key]
-			if (!prevField) continue
-
-			// Create path array directly
-			const pathLength = prevPath.length
-			const newPath = new Array(pathLength + 2)
-			for (let j = 0; j < pathLength; j++) {
-				newPath[j] = prevPath[j]
-			}
-			newPath[pathLength] = "primary"
-			newPath[pathLength + 1] = key
-
-			let field
-
-			switch (prevField.type) {
-				case "Group":
-					field = traverseGroup({
-						path: newPath,
-						group: prevField,
-						onField: onField as OnFieldFn<NestableWidget | NestedGroup>,
+			if (key) {
+				const prevField = variation.primary[key]
+				if (prevField) {
+					const path = [...prevPath, "primary", key]
+					let field
+
+					switch (prevField.type) {
+						case "Group":
+							field = traverseGroup({
+								path,
+								group: prevField,
+								onField: onField as OnFieldFn<NestableWidget | NestedGroup>,
+							})
+							break
+						default:
+							field = prevField
+							break
+					}
+
+					primary[key] = onField({
+						path,
+						key,
+						field,
 					})
-					break
-				default:
-					field = prevField
-					break
+				}
 			}
-
-			primary[key] = onField({
-				path: newPath,
-				key,
-				field,
-			})
 		}
 
 		result.primary = primary
 	}
 
-	// Process items fields if they exist
 	if (variation.items) {
-		const items = Object.create(null)
+		const items: Record<string, NestableWidget> = {}
 		const keys = Object.keys(variation.items)
-		const keyCount = keys.length
 
-		for (let i = 0; i < keyCount; i++) {
+		for (let i = 0; i < keys.length; i++) {
 			const key = keys[i]
-			if (!key) continue
-
-			const field = variation.items[key]
-			if (!field) continue
-
-			// Create path array directly
-			const pathLength = prevPath.length
-			const newPath = new Array(pathLength + 2)
-			for (let j = 0; j < pathLength; j++) {
-				newPath[j] = prevPath[j]
+			if (key) {
+				const field = variation.items[key]
+				if (field) {
+					const path = [...prevPath, "items", key]
+					items[key] = (onField as OnFieldFn<NestableWidget>)({
+						path,
+						key,
+						field,
+					})
+				}
 			}
-			newPath[pathLength] = "items"
-			newPath[pathLength + 1] = key
-
-			items[key] = (onField as OnFieldFn<NestableWidget>)({
-				path: newPath,
-				key,
-				field,
-			})
 		}
 
 		result.items = items
@@ -186,40 +148,21 @@ export function traverseSharedSlice(args: {
 	onField: OnFieldFn<NestableWidget | Group | NestedGroup>
 }): SharedSlice {
 	const { path: prevPath, slice, onField } = args
+	const result = { ...slice }
+	const variations: Variation[] = []
 
-	// Create the result object directly
-	const result = Object.create(null)
-
-	// Copy all base properties
-	result.id = slice.id
-	result.type = slice.type
-	result.name = slice.name
-
-	// Copy optional properties
-	if (slice.description !== undefined) result.description = slice.description
-	if (slice.legacyPaths !== undefined) result.legacyPaths = slice.legacyPaths
-
-	// Process variations
-	const variationCount = slice.variations.length
-	const variations = new Array(variationCount)
-
-	for (let i = 0; i < variationCount; i++) {
+	for (let i = 0; i < slice.variations.length; i++) {
 		const variation = slice.variations[i]
-		if (!variation) continue
-
-		// Create path array directly
-		const pathLength = prevPath.length
-		const newPath = new Array(pathLength + 1)
-		for (let j = 0; j < pathLength; j++) {
-			newPath[j] = prevPath[j]
+		if (variation) {
+			const path = [...prevPath, variation.id]
+			variations.push(
+				traverseVariation({
+					path,
+					variation,
+					onField,
+				}),
+			)
 		}
-		newPath[pathLength] = variation.id
-
-		variations[i] = traverseVariation({
-			path: newPath,
-			variation,
-			onField,
-		})
 	}
 
 	result.variations = variations as ReadonlyArray<Variation>