@measured/puck-plugin-heading-analyzer 0.19.0-canary.c33636f → 0.19.0-canary.d9be813b

package/dist/index.js

@@ -199,7 +199,7 @@ init_react_import();
 
 // src/HeadingAnalyzer.tsx
 init_react_import();
-var import_react12 = require("react");
+var import_react11 = require("react");
 
 // css-module:/home/runner/work/puck/puck/packages/plugin-heading-analyzer/src/HeadingAnalyzer.module.css#css-module
 init_react_import();
@@ -360,7 +360,7 @@ var ChevronRight = createLucideIcon("ChevronRight", [
 
 // ../core/lib/use-breadcrumbs.ts
 init_react_import();
-var import_react11 = require("react");
+var import_react10 = require("react");
 
 // ../core/store/index.ts
 init_react_import();
@@ -368,7 +368,7 @@ init_react_import();
 // ../core/reducer/index.ts
 init_react_import();
 
-// ../core/reducer/data.ts
+// ../core/reducer/reduce.ts
 init_react_import();
 
 // ../core/lib/reorder.ts
@@ -380,16 +380,10 @@ var reorder = (list, startIndex, endIndex) => {
   return result;
 };
 
-// ../core/lib/root-droppable-id.ts
-init_react_import();
-var rootAreaId = "root";
-var rootZone = "default-zone";
-var rootDroppableId = `${rootAreaId}:${rootZone}`;
-
 // ../core/lib/insert.ts
 init_react_import();
 var insert = (list, index, item) => {
-  const result = Array.from(list);
+  const result = Array.from(list || []);
   result.splice(index, 0, item);
   return result;
 };
@@ -404,6 +398,14 @@ var remove = (list, index) => {
 
 // ../core/lib/setup-zone.ts
 init_react_import();
+
+// ../core/lib/root-droppable-id.ts
+init_react_import();
+var rootAreaId = "root";
+var rootZone = "default-zone";
+var rootDroppableId = `${rootAreaId}:${rootZone}`;
+
+// ../core/lib/setup-zone.ts
 var setupZone = (data, zoneKey) => {
   if (zoneKey === rootDroppableId) {
     return data;
@@ -415,29 +417,14 @@ var setupZone = (data, zoneKey) => {
   return newData;
 };
 
-// ../core/lib/replace.ts
-init_react_import();
-var replace = (list, index, newItem) => {
-  const result = Array.from(list);
-  result.splice(index, 1);
-  result.splice(index, 0, newItem);
-  return result;
-};
-
 // ../core/lib/get-item.ts
 init_react_import();
-function getItem(selector, data, dynamicProps = {}) {
-  if (!selector.zone || selector.zone === rootDroppableId) {
-    const item2 = data.content[selector.index];
-    return (item2 == null ? void 0 : item2.props) ? __spreadProps(__spreadValues({}, item2), { props: dynamicProps[item2.props.id] || item2.props }) : void 0;
-  }
-  const item = setupZone(data, selector.zone).zones[selector.zone][selector.index];
-  return (item == null ? void 0 : item.props) ? __spreadProps(__spreadValues({}, item), { props: dynamicProps[item.props.id] || item.props }) : void 0;
+function getItem(selector, state) {
+  var _a, _b;
+  const zone = (_a = state.indexes.zones) == null ? void 0 : _a[selector.zone || rootDroppableId];
+  return zone ? (_b = state.indexes.nodes[zone.contentIds[selector.index]]) == null ? void 0 : _b.data : void 0;
 }
 
-// ../core/lib/reduce-related-zones.ts
-init_react_import();
-
 // ../core/lib/generate-id.ts
 init_react_import();
 
@@ -500,6 +487,43 @@ var v4_default = v4;
 // ../core/lib/generate-id.ts
 var generateId = (type) => type ? `${type}-${v4_default()}` : v4_default();
 
+// ../core/lib/walk-tree.ts
+init_react_import();
+
+// ../core/lib/for-each-slot.ts
+init_react_import();
+
+// ../core/lib/is-slot.ts
+init_react_import();
+var isSlot = (prop) => {
+  var _a, _b;
+  return Array.isArray(prop) && typeof ((_a = prop[0]) == null ? void 0 : _a.type) === "string" && typeof ((_b = prop[0]) == null ? void 0 : _b.props) === "object";
+};
+
+// ../core/lib/for-each-slot.ts
+var forEachSlot = (_0, _1, ..._2) => __async(void 0, [_0, _1, ..._2], function* (item, cb, recursive = false, isSlot2 = isSlot) {
+  const props = item.props || {};
+  const propKeys = Object.keys(props);
+  for (let i = 0; i < propKeys.length; i++) {
+    const propKey = propKeys[i];
+    const itemType = "type" in item ? item.type : "root";
+    if (isSlot2(itemType, propKey, props[propKey])) {
+      const content = props[propKey];
+      yield cb(props.id, propKey, content);
+      if (recursive) {
+        content.forEach(
+          (childItem) => __async(void 0, null, function* () {
+            return yield forEachSlot(childItem, cb, true, isSlot2);
+          })
+        );
+      }
+    }
+  }
+});
+
+// ../core/lib/for-related-zones.ts
+init_react_import();
+
 // ../core/lib/get-zone-id.ts
 init_react_import();
 var getZoneId = (zoneCompound) => {
@@ -512,302 +536,496 @@ var getZoneId = (zoneCompound) => {
   return [rootDroppableId, zoneCompound];
 };
 
-// ../core/lib/reduce-related-zones.ts
-function reduceRelatedZones(item, data, fn) {
+// ../core/lib/for-related-zones.ts
+function forRelatedZones(item, data, cb, path = []) {
+  Object.entries(data.zones || {}).forEach(([zoneCompound, content]) => {
+    const [parentId] = getZoneId(zoneCompound);
+    if (parentId === item.props.id) {
+      const newPath = [...path, zoneCompound];
+      content.forEach((item2) => forRelatedZones(item2, data, cb, newPath));
+      cb(path, zoneCompound, content);
+    }
+  });
+}
+
+// ../core/lib/strip-slots.ts
+init_react_import();
+var stripSlots = (data) => {
   return __spreadProps(__spreadValues({}, data), {
-    zones: Object.keys(data.zones || {}).reduce(
-      (acc, key) => {
-        const [parentId] = getZoneId(key);
-        if (parentId === item.props.id) {
-          const zones = data.zones;
-          return fn(acc, key, zones[key]);
+    props: Object.entries(data.props).reduce(
+      (acc, [propKey, propVal]) => {
+        if (isSlot(propVal)) {
+          return acc;
         }
-        return __spreadProps(__spreadValues({}, acc), { [key]: data.zones[key] });
+        return __spreadProps(__spreadValues({}, acc), { [propKey]: propVal });
       },
-      {}
+      { id: data.props.id }
     )
   });
-}
-var findRelatedByZoneId = (zoneId, data) => {
-  const [zoneParentId] = getZoneId(zoneId);
-  return (data.zones[zoneId] || []).reduce(
-    (acc, zoneItem) => {
-      const related = findRelatedByItem(zoneItem, data);
-      if (zoneItem.props.id === zoneParentId) {
-        return __spreadProps(__spreadValues(__spreadValues({}, acc), related), { [zoneId]: zoneItem });
-      }
-      return __spreadValues(__spreadValues({}, acc), related);
-    },
-    {}
-  );
 };
-var findRelatedByItem = (item, data) => {
-  return Object.keys(data.zones || {}).reduce(
-    (acc, zoneId) => {
-      const [zoneParentId] = getZoneId(zoneId);
-      if (item.props.id === zoneParentId) {
-        const related = findRelatedByZoneId(zoneId, data);
-        return __spreadProps(__spreadValues(__spreadValues({}, acc), related), {
-          [zoneId]: data.zones[zoneId]
-        });
+
+// ../core/lib/walk-tree.ts
+function walkTree(state, config, mapContent = (content) => content, mapNodeOrSkip = (item) => item) {
+  var _a;
+  let newZones = {};
+  const newZoneIndex = {};
+  const newNodeIndex = {};
+  const processContent = (path, zoneCompound, content, zoneType, newId) => {
+    var _a2;
+    const [parentId] = zoneCompound.split(":");
+    const mappedContent = ((_a2 = mapContent(content, zoneCompound, zoneType)) != null ? _a2 : content) || [];
+    const [_2, zone] = zoneCompound.split(":");
+    const newZoneCompound = `${newId || parentId}:${zone}`;
+    const newContent2 = mappedContent.map(
+      (zoneChild, index) => processItem(zoneChild, [...path, newZoneCompound], index)
+    );
+    newZoneIndex[newZoneCompound] = {
+      contentIds: newContent2.map((item) => item.props.id),
+      type: zoneType
+    };
+    return [newZoneCompound, newContent2];
+  };
+  const processRelatedZones = (item, newId, initialPath) => {
+    forRelatedZones(
+      item,
+      state.data,
+      (relatedPath, relatedZoneCompound, relatedContent) => {
+        const [zoneCompound, newContent2] = processContent(
+          relatedPath,
+          relatedZoneCompound,
+          relatedContent,
+          "dropzone",
+          newId
+        );
+        newZones[zoneCompound] = newContent2;
+      },
+      initialPath
+    );
+  };
+  const processItem = (item, path, index) => {
+    const mappedItem = mapNodeOrSkip(item, path, index);
+    if (!mappedItem) return item;
+    const id = mappedItem.props.id;
+    processRelatedZones(item, id, path);
+    const newProps = __spreadValues({}, mappedItem.props);
+    forEachSlot(
+      mappedItem,
+      (parentId2, slotId, content) => {
+        const zoneCompound = `${parentId2}:${slotId}`;
+        const [_2, newContent2] = processContent(
+          path,
+          zoneCompound,
+          content,
+          "slot",
+          parentId2
+        );
+        newProps[slotId] = newContent2;
+      },
+      false,
+      (itemType, propName, propValue) => {
+        var _a2, _b;
+        const configForComponent = itemType === "root" ? config == null ? void 0 : config.root : config == null ? void 0 : config.components[itemType];
+        if (!configForComponent) return isSlot(propValue);
+        return ((_b = (_a2 = configForComponent.fields) == null ? void 0 : _a2[propName]) == null ? void 0 : _b.type) === "slot";
       }
-      return acc;
+    );
+    const newItem = __spreadProps(__spreadValues({}, item), { props: newProps });
+    const thisZoneCompound = path[path.length - 1];
+    const [parentId, zone] = thisZoneCompound ? thisZoneCompound.split(":") : [null, ""];
+    newNodeIndex[id] = {
+      data: newItem,
+      flatData: stripSlots(newItem),
+      path,
+      parentId,
+      zone
+    };
+    const finalData = newItem;
+    if (newProps.id === "root") {
+      delete finalData["type"];
+      delete finalData.props["id"];
+    }
+    return finalData;
+  };
+  const zones = state.data.zones || {};
+  const [_, newContent] = processContent(
+    [],
+    rootDroppableId,
+    state.data.content,
+    "root"
+  );
+  const processedContent = newContent;
+  Object.keys(zones || {}).forEach((zoneCompound) => {
+    const [parentId] = zoneCompound.split(":");
+    const [_2, newContent2] = processContent(
+      [rootDroppableId],
+      zoneCompound,
+      zones[zoneCompound],
+      "dropzone",
+      parentId
+    );
+    newZones[zoneCompound] = newContent2;
+  }, newZones);
+  const processedRoot = processItem(
+    {
+      type: "root",
+      props: __spreadProps(__spreadValues({}, (_a = state.data.root.props) != null ? _a : state.data.root), { id: "root" })
     },
-    {}
+    [],
+    -1
   );
-};
-var removeRelatedZones = (item, data) => {
-  const newData = __spreadValues({}, data);
-  const related = findRelatedByItem(item, data);
-  Object.keys(related).forEach((key) => {
-    delete newData.zones[key];
+  const root = __spreadProps(__spreadValues({}, state.data.root), {
+    props: processedRoot.props
   });
-  return newData;
-};
-function duplicateRelatedZones(item, data, newId) {
-  return reduceRelatedZones(item, data, (acc, key, zone) => {
-    const dupedZone = zone.map((zoneItem) => __spreadProps(__spreadValues({}, zoneItem), {
-      props: __spreadProps(__spreadValues({}, zoneItem.props), { id: generateId(zoneItem.type) })
-    }));
-    const dupeOfDupes = dupedZone.reduce(
-      (dupeOfDupes2, item2, index) => __spreadValues(__spreadValues({}, dupeOfDupes2), duplicateRelatedZones(zone[index], data, item2.props.id).zones),
-      acc
-    );
-    const [_, zoneId] = getZoneId(key);
-    return __spreadProps(__spreadValues({}, dupeOfDupes), {
-      [key]: zone,
-      [`${newId}:${zoneId}`]: dupedZone
-    });
+  return __spreadProps(__spreadValues({}, state), {
+    data: {
+      root,
+      // root: state.data.root, // TODO changing root causes it's entire subtree to re-render. Let's keep this disabled until the performance issues are resolved in #644.
+      content: processedContent,
+      zones: __spreadValues(__spreadValues({}, state.data.zones), newZones)
+    },
+    indexes: {
+      nodes: __spreadValues(__spreadValues({}, state.indexes.nodes), newNodeIndex),
+      zones: __spreadValues(__spreadValues({}, state.indexes.zones), newZoneIndex)
+    }
   });
 }
 
-// ../core/reducer/data.ts
-var zoneCache = {};
-var replaceAction = (data, action) => {
-  if (action.destinationZone === rootDroppableId) {
-    return __spreadProps(__spreadValues({}, data), {
-      content: replace(data.content, action.destinationIndex, action.data)
+// ../core/lib/deindex.ts
+init_react_import();
+var deindex = (state, componentData) => {
+  let zones = __spreadValues({}, state.indexes.zones);
+  let nodes = __spreadValues({}, state.indexes.nodes);
+  const dindexRelatedZones = (item) => {
+    forRelatedZones(item, state.data, (_path, zoneCompound, content) => {
+      content.forEach((subItem) => {
+        dindexChildren(subItem);
+        delete nodes[subItem.props.id];
+      });
+      delete zones[zoneCompound];
     });
-  }
-  const newData = setupZone(data, action.destinationZone);
-  return __spreadProps(__spreadValues({}, newData), {
-    zones: __spreadProps(__spreadValues({}, newData.zones), {
-      [action.destinationZone]: replace(
-        newData.zones[action.destinationZone],
-        action.destinationIndex,
-        action.data
-      )
-    })
-  });
+  };
+  const dindexChildren = (item) => {
+    forEachSlot(
+      item,
+      (parentId, slotId, content) => {
+        const zoneCompound = `${parentId}:${slotId}`;
+        delete zones[zoneCompound];
+        content.forEach((item2) => {
+          dindexRelatedZones(item2);
+          delete nodes[item2.props.id];
+        });
+      },
+      true
+    );
+  };
+  dindexRelatedZones(componentData);
+  dindexChildren(componentData);
+  delete nodes[componentData.props.id];
+  return { nodes, zones };
+};
+
+// ../core/reducer/reduce.ts
+var zoneCache = {};
+var getIdsForParent = (zoneCompound, state) => {
+  const [parentId] = zoneCompound.split(":");
+  const node = state.indexes.nodes[parentId];
+  return ((node == null ? void 0 : node.path) || []).map((p) => p.split(":")[0]);
 };
-function insertAction(data, action, config) {
+function insertAction(state, action, config) {
+  const id = action.id || generateId(action.componentType);
   const emptyComponentData = {
     type: action.componentType,
     props: __spreadProps(__spreadValues({}, config.components[action.componentType].defaultProps || {}), {
-      id: action.id || generateId(action.componentType)
+      id
     })
   };
-  if (action.destinationZone === rootDroppableId) {
-    return __spreadProps(__spreadValues({}, data), {
-      content: insert(
-        data.content,
-        action.destinationIndex,
-        emptyComponentData
-      )
-    });
-  }
-  const newData = setupZone(data, action.destinationZone);
-  return __spreadProps(__spreadValues({}, data), {
-    zones: __spreadProps(__spreadValues({}, newData.zones), {
-      [action.destinationZone]: insert(
-        newData.zones[action.destinationZone],
-        action.destinationIndex,
-        emptyComponentData
-      )
-    })
-  });
+  const [parentId] = action.destinationZone.split(":");
+  return walkTree(
+    state,
+    config,
+    (content, zoneCompound) => {
+      if (zoneCompound === action.destinationZone) {
+        return insert(
+          content || [],
+          action.destinationIndex,
+          emptyComponentData
+        );
+      }
+      return content;
+    },
+    (childItem) => {
+      if (childItem.props.id === id || childItem.props.id === parentId) {
+        return childItem;
+      }
+      return null;
+    }
+  );
 }
-var reorderAction = (data, action) => {
-  if (action.destinationZone === rootDroppableId) {
-    return __spreadProps(__spreadValues({}, data), {
-      content: reorder(
-        data.content,
-        action.sourceIndex,
-        action.destinationIndex
-      )
-    });
+var reorderAction = (state, action, appStore) => {
+  return walkTree(
+    state,
+    appStore.config,
+    (content, zoneCompound) => {
+      if (zoneCompound === action.destinationZone) {
+        return reorder(
+          content || [],
+          action.sourceIndex,
+          action.destinationIndex
+        );
+      }
+      return content;
+    },
+    (childItem, path, index) => {
+      const zoneCompound = path[path.length - 1];
+      if (index === action.sourceIndex && zoneCompound === action.destinationZone || index === action.destinationIndex && zoneCompound === action.destinationZone) {
+        return childItem;
+      }
+      return null;
+    }
+  );
+};
+var replaceAction = (state, action, appStore) => {
+  const [parentId] = action.destinationZone.split(":");
+  const idsInPath = getIdsForParent(action.destinationZone, state);
+  return walkTree(
+    state,
+    appStore.config,
+    (content) => content,
+    (childItem, path) => {
+      const pathIds = path.map((p) => p.split(":")[0]);
+      if (childItem.props.id === action.data.props.id) {
+        return action.data;
+      } else if (childItem.props.id === parentId) {
+        return childItem;
+      } else if (idsInPath.indexOf(childItem.props.id) > -1) {
+        return childItem;
+      } else if (pathIds.indexOf(action.data.props.id) > -1) {
+        return childItem;
+      }
+      return null;
+    }
+  );
+};
+var setAction = (state, action, appStore) => {
+  if (typeof action.state === "object") {
+    const newState = __spreadValues(__spreadValues({}, state), action.state);
+    if (action.state.indexes) {
+      console.warn(
+        "`set` is expensive and may cause unnecessary re-renders. Consider using a more atomic action instead."
+      );
+      return newState;
+    }
+    return walkTree(newState, appStore.config);
   }
-  const newData = setupZone(data, action.destinationZone);
-  return __spreadProps(__spreadValues({}, data), {
-    zones: __spreadProps(__spreadValues({}, newData.zones), {
-      [action.destinationZone]: reorder(
-        newData.zones[action.destinationZone],
-        action.sourceIndex,
-        action.destinationIndex
-      )
-    })
-  });
+  return __spreadValues(__spreadValues({}, state), action.state(state));
 };
-function reduceData(data, action, config) {
+function reduce(state, action, appStore) {
+  if (action.type === "set") {
+    return setAction(state, action, appStore);
+  }
   if (action.type === "insert") {
-    return insertAction(data, action, config);
+    return insertAction(state, action, appStore.config);
+  }
+  if (action.type === "replace") {
+    return replaceAction(state, action, appStore);
+  }
+  if (action.type === "replaceRoot") {
+    return walkTree(
+      state,
+      appStore.config,
+      (content) => content,
+      (childItem) => {
+        if (childItem.props.id === "root") {
+          return __spreadProps(__spreadValues({}, childItem), {
+            props: __spreadValues(__spreadValues({}, childItem.props), action.root.props),
+            readOnly: action.root.readOnly
+          });
+        }
+        return childItem;
+      }
+    );
   }
   if (action.type === "duplicate") {
     const item = getItem(
       { index: action.sourceIndex, zone: action.sourceZone },
-      data
+      state
     );
+    const idsInPath = getIdsForParent(action.sourceZone, state);
     const newItem = __spreadProps(__spreadValues({}, item), {
       props: __spreadProps(__spreadValues({}, item.props), {
         id: generateId(item.type)
       })
     });
-    const dataWithRelatedDuplicated = duplicateRelatedZones(
-      item,
-      data,
-      newItem.props.id
+    const modified = walkTree(
+      state,
+      appStore.config,
+      (content, zoneCompound) => {
+        if (zoneCompound === action.sourceZone) {
+          return insert(content, action.sourceIndex + 1, item);
+        }
+        return content;
+      },
+      (childItem, path, index) => {
+        const zoneCompound = path[path.length - 1];
+        const parents = path.map((p) => p.split(":")[0]);
+        if (parents.indexOf(newItem.props.id) > -1) {
+          return __spreadProps(__spreadValues({}, childItem), {
+            props: __spreadProps(__spreadValues({}, childItem.props), {
+              id: generateId(childItem.type)
+            })
+          });
+        }
+        if (zoneCompound === action.sourceZone && index === action.sourceIndex + 1) {
+          return newItem;
+        }
+        const [sourceZoneParent] = action.sourceZone.split(":");
+        if (sourceZoneParent === childItem.props.id || idsInPath.indexOf(childItem.props.id) > -1) {
+          return childItem;
+        }
+        return null;
+      }
     );
-    if (action.sourceZone === rootDroppableId) {
-      return __spreadProps(__spreadValues({}, dataWithRelatedDuplicated), {
-        content: insert(data.content, action.sourceIndex + 1, newItem)
-      });
-    }
-    return __spreadProps(__spreadValues({}, dataWithRelatedDuplicated), {
-      zones: __spreadProps(__spreadValues({}, dataWithRelatedDuplicated.zones), {
-        [action.sourceZone]: insert(
-          dataWithRelatedDuplicated.zones[action.sourceZone],
-          action.sourceIndex + 1,
-          newItem
-        )
+    return __spreadProps(__spreadValues({}, modified), {
+      ui: __spreadProps(__spreadValues({}, modified.ui), {
+        itemSelector: {
+          index: action.sourceIndex + 1,
+          zone: action.sourceZone
+        }
       })
     });
   }
   if (action.type === "reorder") {
-    return reorderAction(data, action);
+    return reorderAction(state, action, appStore);
   }
   if (action.type === "move") {
     if (action.sourceZone === action.destinationZone && action.sourceIndex === action.destinationIndex) {
-      return data;
+      return state;
     }
-    const newData = setupZone(
-      setupZone(data, action.sourceZone),
-      action.destinationZone
-    );
     const item = getItem(
       { zone: action.sourceZone, index: action.sourceIndex },
-      newData
+      state
     );
-    if (action.sourceZone === action.destinationZone) {
-      return reorderAction(data, __spreadProps(__spreadValues({}, action), { type: "reorder" }));
-    }
-    if (action.sourceZone === rootDroppableId) {
-      return __spreadProps(__spreadValues({}, newData), {
-        content: remove(newData.content, action.sourceIndex),
-        zones: __spreadProps(__spreadValues({}, newData.zones), {
-          [action.destinationZone]: insert(
-            newData.zones[action.destinationZone],
+    if (!item) return state;
+    const idsInSourcePath = getIdsForParent(action.sourceZone, state);
+    const idsInDestinationPath = getIdsForParent(action.destinationZone, state);
+    return walkTree(
+      state,
+      appStore.config,
+      (content, zoneCompound) => {
+        if (zoneCompound === action.sourceZone && zoneCompound === action.destinationZone) {
+          return insert(
+            remove(content, action.sourceIndex),
             action.destinationIndex,
             item
-          )
-        })
-      });
-    }
-    if (action.destinationZone === rootDroppableId) {
-      return __spreadProps(__spreadValues({}, newData), {
-        content: insert(newData.content, action.destinationIndex, item),
-        zones: __spreadProps(__spreadValues({}, newData.zones), {
-          [action.sourceZone]: remove(
-            newData.zones[action.sourceZone],
-            action.sourceIndex
-          )
-        })
-      });
-    }
-    return __spreadProps(__spreadValues({}, newData), {
-      zones: __spreadProps(__spreadValues({}, newData.zones), {
-        [action.sourceZone]: remove(
-          newData.zones[action.sourceZone],
-          action.sourceIndex
-        ),
-        [action.destinationZone]: insert(
-          newData.zones[action.destinationZone],
-          action.destinationIndex,
-          item
-        )
-      })
-    });
-  }
-  if (action.type === "replace") {
-    return replaceAction(data, action);
+          );
+        } else if (zoneCompound === action.sourceZone) {
+          return remove(content, action.sourceIndex);
+        } else if (zoneCompound === action.destinationZone) {
+          return insert(content, action.destinationIndex, item);
+        }
+        return content;
+      },
+      (childItem) => {
+        const [sourceZoneParent] = action.sourceZone.split(":");
+        const [destinationZoneParent] = action.destinationZone.split(":");
+        const childId = childItem.props.id;
+        if (sourceZoneParent === childId || destinationZoneParent === childId || item.props.id === childId || idsInSourcePath.indexOf(childId) > -1 || idsInDestinationPath.indexOf(childId) > -1) {
+          return childItem;
+        }
+        return null;
+      }
+    );
   }
   if (action.type === "remove") {
-    const item = getItem({ index: action.index, zone: action.zone }, data);
-    const dataWithRelatedRemoved = setupZone(
-      removeRelatedZones(item, data),
-      action.zone
+    const item = getItem({ index: action.index, zone: action.zone }, state);
+    let deindexed = deindex(state, item);
+    const [parentId] = action.zone.split(":");
+    return walkTree(
+      __spreadProps(__spreadValues({}, state), { indexes: deindexed }),
+      appStore.config,
+      (content, zoneCompound) => {
+        if (zoneCompound === action.zone) {
+          return remove(content, action.index);
+        }
+        return content;
+      },
+      (childItem, path) => {
+        const parentIds = path.map((p) => p.split(":")[0]);
+        if (childItem.props.id === parentId || childItem.props.id === item.props.id || parentIds.indexOf(item.props.id) > -1) {
+          return childItem;
+        }
+        return null;
+      }
     );
-    if (action.zone === rootDroppableId) {
-      return __spreadProps(__spreadValues({}, dataWithRelatedRemoved), {
-        content: remove(data.content, action.index)
-      });
-    }
-    return __spreadProps(__spreadValues({}, dataWithRelatedRemoved), {
-      zones: __spreadProps(__spreadValues({}, dataWithRelatedRemoved.zones), {
-        [action.zone]: remove(
-          dataWithRelatedRemoved.zones[action.zone],
-          action.index
-        )
-      })
-    });
   }
   if (action.type === "registerZone") {
     if (zoneCache[action.zone]) {
-      return __spreadProps(__spreadValues({}, data), {
-        zones: __spreadProps(__spreadValues({}, data.zones), {
-          [action.zone]: zoneCache[action.zone]
+      return __spreadProps(__spreadValues({}, state), {
+        data: __spreadProps(__spreadValues({}, state.data), {
+          zones: __spreadProps(__spreadValues({}, state.data.zones), {
+            [action.zone]: zoneCache[action.zone]
+          })
+        }),
+        indexes: __spreadProps(__spreadValues({}, state.indexes), {
+          zones: __spreadProps(__spreadValues({}, state.indexes.zones), {
+            [action.zone]: __spreadProps(__spreadValues({}, state.indexes.zones[action.zone]), {
+              contentIds: zoneCache[action.zone].map((item) => item.props.id),
+              type: "dropzone"
+            })
+          })
         })
       });
     }
-    return setupZone(data, action.zone);
+    return __spreadProps(__spreadValues({}, state), { data: setupZone(state.data, action.zone) });
   }
   if (action.type === "unregisterZone") {
-    const _zones = __spreadValues({}, data.zones || {});
+    const _zones = __spreadValues({}, state.data.zones || {});
+    const zoneIndex = __spreadValues({}, state.indexes.zones || {});
     if (_zones[action.zone]) {
       zoneCache[action.zone] = _zones[action.zone];
       delete _zones[action.zone];
     }
-    return __spreadProps(__spreadValues({}, data), { zones: _zones });
+    delete zoneIndex[action.zone];
+    return __spreadProps(__spreadValues({}, state), {
+      data: __spreadProps(__spreadValues({}, state.data), {
+        zones: _zones
+      }),
+      indexes: __spreadProps(__spreadValues({}, state.indexes), {
+        zones: zoneIndex
+      })
+    });
   }
   if (action.type === "setData") {
     if (typeof action.data === "object") {
-      return __spreadValues(__spreadValues({}, data), action.data);
+      console.warn(
+        "`setData` is expensive and may cause unnecessary re-renders. Consider using a more atomic action instead."
+      );
+      return walkTree(
+        __spreadProps(__spreadValues({}, state), {
+          data: __spreadValues(__spreadValues({}, state.data), action.data)
+        }),
+        appStore.config
+      );
     }
-    return __spreadValues(__spreadValues({}, data), action.data(data));
+    return walkTree(
+      __spreadProps(__spreadValues({}, state), {
+        data: __spreadValues(__spreadValues({}, state.data), action.data(state.data))
+      }),
+      appStore.config
+    );
   }
-  return data;
-}
-
-// ../core/reducer/state.ts
-init_react_import();
-var reduceUi = (ui, action) => {
   if (action.type === "setUi") {
     if (typeof action.ui === "object") {
-      return __spreadValues(__spreadValues({}, ui), action.ui);
+      return __spreadProps(__spreadValues({}, state), {
+        ui: __spreadValues(__spreadValues({}, state.ui), action.ui)
+      });
     }
-    return __spreadValues(__spreadValues({}, ui), action.ui(ui));
-  }
-  if (action.type === "duplicate") {
-    return __spreadProps(__spreadValues({}, ui), {
-      itemSelector: { index: action.sourceIndex + 1, zone: action.sourceZone }
-    });
-  }
-  if (action.type === "remove") {
-    return __spreadProps(__spreadValues({}, ui), {
-      itemSelector: null
+    return __spreadProps(__spreadValues({}, state), {
+      ui: __spreadValues(__spreadValues({}, state.ui), action.ui(state.ui))
     });
   }
-  return ui;
-};
+  return state;
+}
 
 // ../core/reducer/actions.tsx
 init_react_import();
@@ -830,25 +1048,17 @@ function storeInterceptor(reducer, record, onAction) {
     return newAppState;
   };
 }
-var setAction = (state, action) => {
-  if (typeof action.state === "object") {
-    return __spreadValues(__spreadValues({}, state), action.state);
-  }
-  return __spreadValues(__spreadValues({}, state), action.state(state));
-};
 function createReducer({
   config,
   record,
-  onAction
+  onAction,
+  appStore
 }) {
   return storeInterceptor(
     (state, action) => {
-      const data = reduceData(state.data, action, config);
-      const ui = reduceUi(state.ui, action);
-      if (action.type === "set") {
-        return setAction(state, action);
-      }
-      return { data, ui };
+      const result = reduce(state, action, appStore);
+      console.log(action.type, state, result);
+      return result;
     },
     record,
     onAction
@@ -868,11 +1078,11 @@ init_react_import();
 var createStoreImpl = (createState) => {
   let state;
   const listeners = /* @__PURE__ */ new Set();
-  const setState = (partial, replace2) => {
+  const setState = (partial, replace) => {
     const nextState = typeof partial === "function" ? partial(state) : partial;
     if (!Object.is(nextState, state)) {
       const previousState = state;
-      state = (replace2 != null ? replace2 : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
+      state = (replace != null ? replace : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
       listeners.forEach((listener) => listener(state, previousState));
     }
   };
@@ -936,208 +1146,8 @@ var subscribeWithSelectorImpl = (fn) => (set, get, api) => {
 };
 var subscribeWithSelector = subscribeWithSelectorImpl;
 
-// ../core/lib/resolve-data.ts
-init_react_import();
-
-// ../core/lib/resolve-component-data.ts
-init_react_import();
-
-// ../core/lib/get-changed.ts
-init_react_import();
-var getChanged = (newItem, oldItem) => {
-  return newItem ? Object.keys(newItem.props || {}).reduce((acc, item) => {
-    const newItemProps = (newItem == null ? void 0 : newItem.props) || {};
-    const oldItemProps = (oldItem == null ? void 0 : oldItem.props) || {};
-    return __spreadProps(__spreadValues({}, acc), {
-      [item]: oldItemProps[item] !== newItemProps[item]
-    });
-  }, {}) : {};
-};
-
-// ../core/lib/resolve-component-data.ts
-var cache = { lastChange: {} };
-var resolveComponentData = (_0, _1, ..._2) => __async(void 0, [_0, _1, ..._2], function* (item, config, metadata = {}, onResolveStart, onResolveEnd) {
-  const configForItem = config.components[item.type];
-  if (configForItem.resolveData) {
-    const { item: oldItem = null, resolved = {} } = cache.lastChange[item.props.id] || {};
-    if (item && item === oldItem) {
-      return resolved;
-    }
-    const changed = getChanged(item, oldItem);
-    if (onResolveStart) {
-      onResolveStart(item);
-    }
-    const { props: resolvedProps, readOnly = {} } = yield configForItem.resolveData(item, {
-      changed,
-      lastData: oldItem,
-      metadata
-    });
-    const resolvedItem = __spreadProps(__spreadValues({}, item), {
-      props: __spreadValues(__spreadValues({}, item.props), resolvedProps)
-    });
-    if (Object.keys(readOnly).length) {
-      resolvedItem.readOnly = readOnly;
-    }
-    cache.lastChange[item.props.id] = {
-      item,
-      resolved: resolvedItem
-    };
-    if (onResolveEnd) {
-      onResolveEnd(resolvedItem);
-    }
-    return resolvedItem;
-  }
-  return item;
-});
-
-// ../core/lib/apply-dynamic-props.ts
-init_react_import();
-var applyDynamicProps = (data, dynamicProps, rootData) => {
-  return __spreadProps(__spreadValues({}, data), {
-    root: rootData ? __spreadValues(__spreadValues({}, data.root), rootData ? rootData : {}) : data.root,
-    content: data.content.map((item) => {
-      return dynamicProps[item.props.id] ? __spreadValues(__spreadValues({}, item), dynamicProps[item.props.id]) : item;
-    }),
-    zones: Object.keys(data.zones || {}).reduce((acc, zoneKey) => {
-      return __spreadProps(__spreadValues({}, acc), {
-        [zoneKey]: data.zones[zoneKey].map((item) => {
-          return dynamicProps[item.props.id] ? __spreadValues(__spreadValues({}, item), dynamicProps[item.props.id]) : item;
-        })
-      });
-    }, {})
-  });
-};
-
-// ../core/lib/resolve-root-data.ts
-init_react_import();
-var cache2 = {};
-function resolveRootData(data, config, metadata) {
-  return __async(this, null, function* () {
-    var _a, _b, _c, _d, _e;
-    if (((_a = config.root) == null ? void 0 : _a.resolveData) && data.root.props) {
-      if (((_b = cache2.lastChange) == null ? void 0 : _b.original) === data.root) {
-        return cache2.lastChange.resolved;
-      }
-      const changed = getChanged(data.root, (_c = cache2.lastChange) == null ? void 0 : _c.original);
-      const rootWithProps = data.root;
-      const resolvedRoot = yield (_e = config.root) == null ? void 0 : _e.resolveData(rootWithProps, {
-        changed,
-        lastData: ((_d = cache2.lastChange) == null ? void 0 : _d.original) || {},
-        metadata: metadata || {}
-      });
-      cache2.lastChange = {
-        original: data.root,
-        resolved: resolvedRoot
-      };
-      return __spreadProps(__spreadValues(__spreadValues({}, data.root), resolvedRoot), {
-        props: __spreadValues(__spreadValues({}, data.root.props), resolvedRoot.props)
-      });
-    }
-    return data.root;
-  });
-}
-
-// ../core/lib/flatten-data.ts
-init_react_import();
-var flattenData = (data) => {
-  return Object.keys(data.zones || {}).reduce(
-    (acc, zone) => [...acc, ...data.zones[zone]],
-    data.content
-  );
-};
-
-// ../core/lib/resolve-data.ts
-var import_fast_deep_equal = __toESM(require_fast_deep_equal());
-var resolveData = (newAppState, appStoreData) => {
-  const {
-    state: appState,
-    config,
-    dispatch,
-    resolveDataRuns,
-    setComponentLoading,
-    unsetComponentLoading,
-    metadata,
-    permissions
-  } = appStoreData;
-  const deferredSetStates = {};
-  const _setComponentLoading = (id, loading, defer = 0) => {
-    if (deferredSetStates[id]) {
-      clearTimeout(deferredSetStates[id]);
-      delete deferredSetStates[id];
-    }
-    deferredSetStates[id] = setTimeout(() => {
-      if (loading) {
-        setComponentLoading(id);
-      } else {
-        unsetComponentLoading(id);
-      }
-      delete deferredSetStates[id];
-    }, defer);
-  };
-  const runResolvers = () => __async(void 0, null, function* () {
-    const newData = newAppState.data;
-    const flatContent = flattenData(newData).filter(
-      (item) => {
-        var _a;
-        return !!((_a = config.components[item.type]) == null ? void 0 : _a.resolveData);
-      }
-    );
-    const applyIfChange = (dynamicDataMap, dynamicRoot) => {
-      const processed = applyDynamicProps(
-        __spreadValues({}, appState.data),
-        dynamicDataMap,
-        dynamicRoot
-      );
-      const processedAppState = __spreadProps(__spreadValues({}, appState), { data: processed });
-      const containsChanges = !(0, import_fast_deep_equal.default)(appState, processedAppState);
-      if (containsChanges) {
-        dispatch({
-          type: "set",
-          state: (prev) => __spreadProps(__spreadValues({}, prev), {
-            data: applyDynamicProps(prev.data, dynamicDataMap, dynamicRoot),
-            ui: resolveDataRuns > 0 ? __spreadValues(__spreadValues({}, prev.ui), newAppState.ui) : prev.ui
-          }),
-          recordHistory: resolveDataRuns > 0
-        });
-      }
-    };
-    const promises = [];
-    promises.push(
-      (() => __async(void 0, null, function* () {
-        _setComponentLoading("puck-root", true, 50);
-        const dynamicRoot = yield resolveRootData(newData, config, metadata);
-        applyIfChange({}, dynamicRoot);
-        _setComponentLoading("puck-root", false);
-      }))()
-    );
-    flatContent.forEach((item) => {
-      promises.push(
-        (() => __async(void 0, null, function* () {
-          permissions.resolvePermissions({ item }, true);
-          const dynamicData = yield resolveComponentData(
-            item,
-            config,
-            metadata,
-            (item2) => {
-              _setComponentLoading(item2.props.id, true, 50);
-            },
-            (item2) => {
-              deferredSetStates[item2.props.id];
-              _setComponentLoading(item2.props.id, false);
-            }
-          );
-          const dynamicDataMap = { [item.props.id]: dynamicData };
-          applyIfChange(dynamicDataMap);
-        }))()
-      );
-    });
-    yield Promise.all(promises);
-  });
-  return runResolvers();
-};
-
 // ../core/store/index.ts
-var import_react10 = require("react");
+var import_react9 = require("react");
 
 // ../core/store/slices/history.ts
 init_react_import();
@@ -1253,31 +1263,14 @@ var createHistorySlice = (set, get) => {
 
 // ../core/store/slices/nodes.ts
 init_react_import();
-var import_fast_deep_equal2 = __toESM(require_fast_deep_equal());
-var import_react7 = require("react");
-var partialDeepEqual = (newItem, existingItem) => {
-  const filteredExistingItem = Object.keys(newItem).reduce(
-    (acc, key) => __spreadProps(__spreadValues({}, acc), { [key]: existingItem[key] }),
-    {}
-  );
-  return (0, import_fast_deep_equal2.default)(newItem, filteredExistingItem);
-};
 var createNodesSlice = (set, get) => ({
   nodes: {},
   registerNode: (id, node) => {
     const s = get().nodes;
-    if (s.nodes[id] && partialDeepEqual(node, s.nodes[id])) {
-      return;
-    }
     const emptyNode = {
       id,
       methods: { sync: () => null },
-      data: { props: { id }, type: "unknown" },
-      parentId: "",
-      zone: "",
-      path: [],
-      element: null,
-      index: -1
+      element: null
     };
     const existingNode = s.nodes[id];
     set({
@@ -1307,36 +1300,66 @@ var createNodesSlice = (set, get) => ({
 
 // ../core/store/slices/permissions.ts
 init_react_import();
-var import_react8 = require("react");
+var import_react7 = require("react");
+
+// ../core/lib/flatten-data.ts
+init_react_import();
+var flattenData = (state, config) => {
+  const data = [];
+  walkTree(
+    state,
+    config,
+    (content) => content,
+    (item) => {
+      data.push(item);
+      return null;
+    }
+  );
+  return data;
+};
+
+// ../core/lib/get-changed.ts
+init_react_import();
+var getChanged = (newItem, oldItem) => {
+  return newItem ? Object.keys(newItem.props || {}).reduce((acc, item) => {
+    const newItemProps = (newItem == null ? void 0 : newItem.props) || {};
+    const oldItemProps = (oldItem == null ? void 0 : oldItem.props) || {};
+    return __spreadProps(__spreadValues({}, acc), {
+      [item]: oldItemProps[item] !== newItemProps[item]
+    });
+  }, {}) : {};
+};
+
+// ../core/store/slices/permissions.ts
 var createPermissionsSlice = (set, get) => {
   const resolvePermissions = (..._0) => __async(void 0, [..._0], function* (params = {}, force) {
-    const { state, permissions } = get();
-    const { cache: cache3, globalPermissions } = permissions;
+    const { state, permissions, config } = get();
+    const { cache: cache2, globalPermissions } = permissions;
     const resolveDataForItem = (item2, force2 = false) => __async(void 0, null, function* () {
       var _a, _b, _c;
       const {
-        config,
+        config: config2,
         state: appState,
         setComponentLoading,
         unsetComponentLoading
       } = get();
-      const componentConfig = item2.type === "root" ? config.root : config.components[item2.type];
+      const componentConfig = item2.type === "root" ? config2.root : config2.components[item2.type];
       if (!componentConfig) {
         return;
       }
       const initialPermissions = __spreadValues(__spreadValues({}, globalPermissions), componentConfig.permissions);
       if (componentConfig.resolvePermissions) {
-        const changed = getChanged(item2, (_a = cache3[item2.props.id]) == null ? void 0 : _a.lastData);
+        const changed = getChanged(item2, (_a = cache2[item2.props.id]) == null ? void 0 : _a.lastData);
         if (Object.values(changed).some((el) => el === true) || force2) {
           setComponentLoading(item2.props.id);
           const resolvedPermissions = yield componentConfig.resolvePermissions(
             item2,
             {
               changed,
-              lastPermissions: ((_b = cache3[item2.props.id]) == null ? void 0 : _b.lastPermissions) || null,
+              lastPermissions: ((_b = cache2[item2.props.id]) == null ? void 0 : _b.lastPermissions) || null,
               permissions: initialPermissions,
               appState,
-              lastData: ((_c = cache3[item2.props.id]) == null ? void 0 : _c.lastData) || null
+              lastData: ((_c = cache2[item2.props.id]) == null ? void 0 : _c.lastData) || null
             }
           );
           const latest = get().permissions;
@@ -1372,14 +1395,14 @@ var createPermissionsSlice = (set, get) => {
     if (item) {
       yield resolveDataForItem(item, force);
     } else if (type) {
-      flattenData(state.data).filter((item2) => item2.type === type).map((item2) => __async(void 0, null, function* () {
+      flattenData(state, config).filter((item2) => item2.type === type).map((item2) => __async(void 0, null, function* () {
         yield resolveDataForItem(item2, force);
       }));
     } else if (root) {
       resolveDataForRoot(force);
     } else {
       resolveDataForRoot(force);
-      flattenData(state.data).map((item2) => __async(void 0, null, function* () {
+      flattenData(state, config).map((item2) => __async(void 0, null, function* () {
         yield resolveDataForItem(item2, force);
       }));
     }
@@ -1421,8 +1444,8 @@ var createPermissionsSlice = (set, get) => {
 
 // ../core/store/slices/fields.ts
 init_react_import();
-var import_react9 = require("react");
-var createFieldsStore = (_set, _get) => {
+var import_react8 = require("react");
+var createFieldsSlice = (_set, _get) => {
   return {
     fields: {},
     loading: false,
@@ -1430,6 +1453,106 @@ var createFieldsStore = (_set, _get) => {
   };
 };
 
+// ../core/lib/resolve-component-data.ts
+init_react_import();
+
+// ../core/lib/map-slots.ts
+init_react_import();
+function mapSlots(item, map, recursive = true, isSlot2) {
+  return __async(this, null, function* () {
+    const props = __spreadValues({}, item.props);
+    yield forEachSlot(
+      item,
+      (_parentId, propName, content) => __async(this, null, function* () {
+        const mappedContent = recursive ? yield Promise.all(
+          content.map((item2) => __async(this, null, function* () {
+            return yield mapSlots(item2, map, recursive, isSlot2);
+          }))
+        ) : content;
+        props[propName] = yield map(mappedContent, propName);
+      }),
+      false,
+      isSlot2
+    );
+    return __spreadProps(__spreadValues({}, item), { props });
+  });
+}
+
+// ../core/lib/resolve-component-data.ts
+var import_fast_deep_equal = __toESM(require_fast_deep_equal());
+var cache = { lastChange: {} };
+var resolveComponentData = (_0, _1, ..._2) => __async(void 0, [_0, _1, ..._2], function* (item, config, metadata = {}, onResolveStart, onResolveEnd, trigger = "replace", recursive = true) {
+  const configForItem = "type" in item ? config.components[item.type] : config.root;
+  if ((configForItem == null ? void 0 : configForItem.resolveData) && item.props) {
+    const id = "id" in item.props ? item.props.id : "root";
+    const { item: oldItem = null, resolved = {} } = cache.lastChange[id] || {};
+    if (item && item === oldItem) {
+      return resolved;
+    }
+    const changed = getChanged(item, oldItem);
+    if (onResolveStart) {
+      onResolveStart(item);
+    }
+    const { props: resolvedProps, readOnly = {} } = yield configForItem.resolveData(item, {
+      changed,
+      lastData: oldItem,
+      metadata,
+      trigger
+    });
+    let resolvedItem = __spreadProps(__spreadValues({}, item), {
+      props: __spreadValues(__spreadValues({}, item.props), resolvedProps)
+    });
+    if (recursive) {
+      resolvedItem = yield mapSlots(resolvedItem, (content) => __async(void 0, null, function* () {
+        return Promise.all(
+          content.map(
+            (childItem) => __async(void 0, null, function* () {
+              return (yield resolveComponentData(
+                childItem,
+                config,
+                metadata,
+                onResolveStart,
+                onResolveEnd,
+                trigger,
+                false
+              )).node;
+            })
+          )
+        );
+      }));
+    }
+    if (Object.keys(readOnly).length) {
+      resolvedItem.readOnly = readOnly;
+    }
+    cache.lastChange[id] = {
+      item,
+      resolved: resolvedItem
+    };
+    if (onResolveEnd) {
+      onResolveEnd(resolvedItem);
+    }
+    return { node: resolvedItem, didChange: !(0, import_fast_deep_equal.default)(item, resolvedItem) };
+  }
+  return { node: item, didChange: false };
+});
+
+// ../core/lib/to-root.ts
+init_react_import();
+var toRoot = (item) => {
+  if ("type" in item && item.type !== "root") {
+    throw new Error("Converting non-root item to root.");
+  }
+  const { readOnly } = item;
+  if (item.props) {
+    if ("id" in item.props) {
+      const _a = item.props, { id } = _a, props = __objRest(_a, ["id"]);
+      return { props, readOnly };
+    }
+    return { props: item.props, readOnly };
+  }
+  return { props: {}, readOnly };
+};
+
 // ../core/store/index.ts
 var defaultAppState = {
   data: { content: [], root: {}, zones: {} },
@@ -1450,6 +1573,10 @@ var defaultAppState = {
       controlsVisible: true
     },
     field: { focus: null }
+  },
+  indexes: {
+    nodes: {},
+    zones: {}
   }
 };
 var defaultPageFields = {
@@ -1472,7 +1599,7 @@ var createAppStore = (initialAppStore) => create()(
     iframe: {},
     metadata: {}
   }, initialAppStore), {
-    fields: createFieldsStore(set, get),
+    fields: createFieldsSlice(set, get),
     history: createHistorySlice(set, get),
     nodes: createNodesSlice(set, get),
     permissions: createPermissionsSlice(set, get),
@@ -1485,65 +1612,153 @@ var createAppStore = (initialAppStore) => create()(
     dispatch: (action) => set((s) => {
       var _a, _b;
       const { record } = get().history;
-      const dispatch = createReducer({ config: s.config, record });
+      const dispatch = createReducer({
+        config: s.config,
+        record,
+        appStore: s
+      });
       const state = dispatch(s.state, action);
-      const selectedItem = state.ui.itemSelector ? getItem(state.ui.itemSelector, state.data) : null;
+      const selectedItem = state.ui.itemSelector ? getItem(state.ui.itemSelector, state) : null;
       (_b = (_a = get()).onAction) == null ? void 0 : _b.call(_a, action, state, get().state);
       return __spreadProps(__spreadValues({}, s), { state, selectedItem });
     }),
     setZoomConfig: (zoomConfig) => set({ zoomConfig }),
     setStatus: (status) => set({ status }),
     setComponentState: (componentState) => set({ componentState }),
-    setComponentLoading: (id) => {
-      var _a;
-      const { setComponentState, componentState } = get();
-      setComponentState(__spreadProps(__spreadValues({}, componentState), {
-        [id]: __spreadProps(__spreadValues({}, componentState[id]), {
-          loadingCount: (((_a = componentState[id]) == null ? void 0 : _a.loadingCount) || 0) + 1
+    pendingComponentLoads: {},
+    setComponentLoading: (id, loading = true, defer = 0) => {
+      const { setComponentState, pendingComponentLoads } = get();
+      const thisPendingComponentLoads = __spreadValues({}, pendingComponentLoads);
+      const setLoading = () => {
+        var _a;
+        const { componentState } = get();
+        setComponentState(__spreadProps(__spreadValues({}, componentState), {
+          [id]: __spreadProps(__spreadValues({}, componentState[id]), {
+            loadingCount: (((_a = componentState[id]) == null ? void 0 : _a.loadingCount) || 0) + 1
+          })
+        }));
+      };
+      const unsetLoading = () => {
+        var _a;
+        const { componentState } = get();
+        setComponentState(__spreadProps(__spreadValues({}, componentState), {
+          [id]: __spreadProps(__spreadValues({}, componentState[id]), {
+            loadingCount: Math.max(
+              (((_a = componentState[id]) == null ? void 0 : _a.loadingCount) || 0) - 1,
+              0
+            )
+          })
+        }));
+      };
+      if (thisPendingComponentLoads[id]) {
+        clearTimeout(thisPendingComponentLoads[id]);
+        delete thisPendingComponentLoads[id];
+        set({ pendingComponentLoads: thisPendingComponentLoads });
+      }
+      const timeout = setTimeout(() => {
+        if (loading) {
+          setLoading();
+        } else {
+          unsetLoading();
+        }
+        delete thisPendingComponentLoads[id];
+        set({ pendingComponentLoads: thisPendingComponentLoads });
+      }, defer);
+      set({
+        pendingComponentLoads: __spreadProps(__spreadValues({}, thisPendingComponentLoads), {
+          [id]: timeout
         })
-      }));
+      });
     },
     unsetComponentLoading: (id) => {
-      var _a;
-      const { setComponentState, componentState } = get();
-      setComponentState(__spreadProps(__spreadValues({}, componentState), {
-        [id]: __spreadProps(__spreadValues({}, componentState[id]), {
-          loadingCount: Math.max(
-            (((_a = componentState[id]) == null ? void 0 : _a.loadingCount) || 0) - 1,
-            0
-          )
-        })
-      }));
+      const { setComponentLoading } = get();
+      setComponentLoading(id, false);
     },
     // Helper
     setUi: (ui, recordHistory) => set((s) => {
       const dispatch = createReducer({
         config: s.config,
         record: () => {
-        }
+        },
+        appStore: s
       });
       const state = dispatch(s.state, {
         type: "setUi",
         ui,
         recordHistory
       });
-      const selectedItem = state.ui.itemSelector ? getItem(state.ui.itemSelector, state.data) : null;
+      const selectedItem = state.ui.itemSelector ? getItem(state.ui.itemSelector, state) : null;
       return __spreadProps(__spreadValues({}, s), { state, selectedItem });
     }),
-    resolveDataRuns: 0,
-    resolveData: (newAppState) => set((s) => {
-      resolveData(newAppState, get());
-      return __spreadProps(__spreadValues({}, s), { resolveDataRuns: s.resolveDataRuns + 1 });
+    // resolveDataRuns: 0,
+    // resolveData: (newAppState) =>
+    //   set((s) => {
+    //     resolveData(newAppState, get);
+    //     return { ...s, resolveDataRuns: s.resolveDataRuns + 1 };
+    //   }),
+    resolveComponentData: (componentData, trigger) => __async(void 0, null, function* () {
+      const { config, metadata, setComponentLoading } = get();
+      return yield resolveComponentData(
+        componentData,
+        config,
+        metadata,
+        (item) => setComponentLoading(
+          "id" in item.props ? item.props.id : "root",
+          true,
+          50
+        ),
+        (item) => setComponentLoading(
+          "id" in item.props ? item.props.id : "root",
+          false,
+          0
+        ),
+        trigger
+      );
+    }),
+    resolveAndCommitData: () => __async(void 0, null, function* () {
+      const { config, state, dispatch, resolveComponentData: resolveComponentData2 } = get();
+      walkTree(
+        state,
+        config,
+        (content) => content,
+        (childItem) => {
+          resolveComponentData2(childItem, "load").then((resolved) => {
+            const { state: state2 } = get();
+            const node = state2.indexes.nodes[resolved.node.props.id];
+            if (node && resolved.didChange) {
+              if (resolved.node.props.id === "root") {
+                dispatch({
+                  type: "replaceRoot",
+                  root: toRoot(resolved.node)
+                });
+              } else {
+                const zoneCompound = `${node.parentId}:${node.zone}`;
+                const parentZone = state2.indexes.zones[zoneCompound];
+                const index = parentZone.contentIds.indexOf(
+                  resolved.node.props.id
+                );
+                dispatch({
+                  type: "replace",
+                  data: resolved.node,
+                  destinationIndex: index,
+                  destinationZone: zoneCompound
+                });
+              }
+            }
+          });
+          return childItem;
+        }
+      );
     })
   }))
 );
-var appStoreContext = (0, import_react10.createContext)(createAppStore());
+var appStoreContext = (0, import_react9.createContext)(createAppStore());
 function useAppStore(selector) {
-  const context = (0, import_react10.useContext)(appStoreContext);
+  const context = (0, import_react9.useContext)(appStoreContext);
   return useStore(context, selector);
 }
 function useAppStoreApi() {
-  return (0, import_react10.useContext)(appStoreContext);
+  return (0, import_react9.useContext)(appStoreContext);
 }
 
 // ../core/lib/use-breadcrumbs.ts
@@ -1555,12 +1770,12 @@ var useBreadcrumbs = (renderCount) => {
   const config = useAppStore((s) => s.config);
   const path = useAppStore((s) => {
     var _a;
-    return (_a = s.nodes.nodes[selectedId]) == null ? void 0 : _a.path;
+    return (_a = s.state.indexes.nodes[selectedId]) == null ? void 0 : _a.path;
   });
   const appStore = useAppStoreApi();
-  return (0, import_react11.useMemo)(() => {
+  return (0, import_react10.useMemo)(() => {
     const breadcrumbs = (path == null ? void 0 : path.map((zoneCompound) => {
-      var _a, _b;
+      var _a, _b, _c;
       const [componentId] = zoneCompound.split(":");
       if (componentId === "root") {
         return {
@@ -1568,12 +1783,15 @@ var useBreadcrumbs = (renderCount) => {
           selector: null
         };
       }
-      const node = appStore.getState().nodes.nodes[componentId];
-      const label = node ? (_b = (_a = config.components[node.data.type]) == null ? void 0 : _a.label) != null ? _b : node.data.type : "Component";
+      const node = appStore.getState().state.indexes.nodes[componentId];
+      const parentId = node.path[node.path.length - 1];
+      const contentIds = ((_a = appStore.getState().state.indexes.zones[parentId]) == null ? void 0 : _a.contentIds) || [];
+      const index = contentIds.indexOf(componentId);
+      const label = node ? (_c = (_b = config.components[node.data.type]) == null ? void 0 : _b.label) != null ? _c : node.data.type : "Component";
       return {
         label,
         selector: node ? {
-          index: node.index,
+          index,
           zone: node.path[node.path.length - 1]
         } : null
       };
@@ -1594,6 +1812,9 @@ init_react_import();
 // ../core/lib/filter.ts
 init_react_import();
 
+// ../core/lib/replace.ts
+init_react_import();
+
 // css-module:/home/runner/work/puck/puck/packages/core/components/Loader/styles.module.css#css-module
 init_react_import();
 var styles_module_default3 = { "Loader": "_Loader_nacdm_13", "loader-animation": "_loader-animation_nacdm_1" };
@@ -1774,8 +1995,8 @@ function buildHierarchy(frame) {
 var usePuck = (0, import_puck.createUsePuck)();
 var HeadingAnalyzer = () => {
   const data = usePuck((s) => s.appState.data);
-  const [hierarchy, setHierarchy] = (0, import_react12.useState)([]);
-  (0, import_react12.useEffect)(() => {
+  const [hierarchy, setHierarchy] = (0, import_react11.useState)([]);
+  (0, import_react11.useEffect)(() => {
     const frame = getFrame();
     const entry = frame == null ? void 0 : frame.querySelector(`[data-puck-entry]`);
     if (!entry) return;