@measured/puck-plugin-heading-analyzer 0.19.0-canary.0ea6ce4 → 0.19.0-canary.1918ad70

package/dist/index.js

@@ -61,6 +61,26 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
 
 // ../tsup-config/react-import.js
 var import_react;
@@ -133,6 +153,42 @@ var require_classnames = __commonJS({
   }
 });
 
+// ../../node_modules/fast-deep-equal/index.js
+var require_fast_deep_equal = __commonJS({
+  "../../node_modules/fast-deep-equal/index.js"(exports2, module2) {
+    "use strict";
+    init_react_import();
+    module2.exports = function equal(a, b) {
+      if (a === b) return true;
+      if (a && b && typeof a == "object" && typeof b == "object") {
+        if (a.constructor !== b.constructor) return false;
+        var length, i, keys;
+        if (Array.isArray(a)) {
+          length = a.length;
+          if (length != b.length) return false;
+          for (i = length; i-- !== 0; )
+            if (!equal(a[i], b[i])) return false;
+          return true;
+        }
+        if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+        if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
+        if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
+        keys = Object.keys(a);
+        length = keys.length;
+        if (length !== Object.keys(b).length) return false;
+        for (i = length; i-- !== 0; )
+          if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
+        for (i = length; i-- !== 0; ) {
+          var key = keys[i];
+          if (!equal(a[key], b[key])) return false;
+        }
+        return true;
+      }
+      return a !== a && b !== b;
+    };
+  }
+});
+
 // index.ts
 var plugin_heading_analyzer_exports = {};
 __export(plugin_heading_analyzer_exports, {
@@ -143,7 +199,7 @@ init_react_import();
 
 // src/HeadingAnalyzer.tsx
 init_react_import();
-var import_react9 = 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();
@@ -304,122 +360,701 @@ var ChevronRight = createLucideIcon("ChevronRight", [
 
 // ../core/lib/use-breadcrumbs.ts
 init_react_import();
-var import_react8 = require("react");
+var import_react10 = require("react");
 
-// ../core/components/DropZone/context.tsx
+// ../core/store/index.ts
 init_react_import();
-var import_react7 = require("react");
 
-// ../core/components/Puck/context.tsx
+// ../core/reducer/index.ts
 init_react_import();
-var import_react6 = require("react");
 
-// ../core/lib/get-item.ts
+// ../core/reducer/reduce.ts
+init_react_import();
+
+// ../core/lib/insert.ts
+init_react_import();
+var insert = (list, index, item) => {
+  const result = Array.from(list || []);
+  result.splice(index, 0, item);
+  return result;
+};
+
+// ../core/lib/remove.ts
+init_react_import();
+var remove = (list, index) => {
+  const result = Array.from(list);
+  result.splice(index, 1);
+  return result;
+};
+
+// ../core/lib/setup-zone.ts
 init_react_import();
 
 // ../core/lib/root-droppable-id.ts
 init_react_import();
-var rootDroppableId = "default-zone";
+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;
+  }
+  const newData = __spreadProps(__spreadValues({}, data), {
+    zones: data.zones ? __spreadValues({}, data.zones) : {}
+  });
+  newData.zones[zoneKey] = newData.zones[zoneKey] || [];
+  return newData;
+};
+
+// ../core/lib/get-item.ts
 init_react_import();
+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/components/ViewportControls/default-viewports.ts
+// ../core/lib/generate-id.ts
 init_react_import();
-var defaultViewports = [
-  { width: 360, height: "auto", icon: "Smartphone", label: "Small" },
-  { width: 768, height: "auto", icon: "Tablet", label: "Medium" },
-  { width: 1280, height: "auto", icon: "Monitor", label: "Large" }
-];
 
-// ../core/lib/use-resolved-permissions.ts
+// ../../node_modules/uuid/dist/esm-node/index.js
 init_react_import();
-var import_react4 = require("react");
 
-// ../core/lib/flatten-data.ts
+// ../../node_modules/uuid/dist/esm-node/rng.js
 init_react_import();
+var import_crypto = __toESM(require("crypto"));
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    import_crypto.default.randomFillSync(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
 
-// ../core/lib/get-changed.ts
+// ../../node_modules/uuid/dist/esm-node/stringify.js
 init_react_import();
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
+}
 
-// ../core/lib/use-resolved-data.ts
+// ../../node_modules/uuid/dist/esm-node/v4.js
 init_react_import();
-var import_react5 = require("react");
 
-// ../core/lib/resolve-component-data.ts
+// ../../node_modules/uuid/dist/esm-node/native.js
+init_react_import();
+var import_crypto2 = __toESM(require("crypto"));
+var native_default = {
+  randomUUID: import_crypto2.default.randomUUID
+};
+
+// ../../node_modules/uuid/dist/esm-node/v4.js
+function v4(options, buf, offset) {
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = options.random || (options.rng || rng)();
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+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/apply-dynamic-props.ts
+// ../core/lib/for-each-slot.ts
 init_react_import();
 
-// ../core/lib/resolve-root-data.ts
+// ../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/components/Puck/context.tsx
-var import_jsx_runtime2 = require("react/jsx-runtime");
-var defaultAppState = {
-  data: { content: [], root: {} },
-  ui: {
-    leftSideBarVisible: true,
-    rightSideBarVisible: true,
-    arrayState: {},
-    itemSelector: null,
-    componentList: {},
-    isDragging: false,
-    previewMode: "edit",
-    viewports: {
-      current: {
-        width: defaultViewports[0].width,
-        height: defaultViewports[0].height || "auto"
+// ../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) => {
+  if (!zoneCompound) {
+    return [];
+  }
+  if (zoneCompound && zoneCompound.indexOf(":") > -1) {
+    return zoneCompound.split(":");
+  }
+  return [rootDroppableId, zoneCompound];
+};
+
+// ../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), {
+    props: Object.entries(data.props).reduce(
+      (acc, [propKey, propVal]) => {
+        if (isSlot(propVal)) {
+          return acc;
+        }
+        return __spreadProps(__spreadValues({}, acc), { [propKey]: propVal });
       },
-      options: [],
-      controlsVisible: true
+      { id: data.props.id }
+    )
+  });
+};
+
+// ../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";
+      }
+    );
+    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" })
     },
-    field: { focus: null }
+    [],
+    -1
+  );
+  const root = __spreadProps(__spreadValues({}, state.data.root), {
+    props: processedRoot.props
+  });
+  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/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 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(state, action, config) {
+  const id = action.id || generateId(action.componentType);
+  const emptyComponentData = {
+    type: action.componentType,
+    props: __spreadProps(__spreadValues({}, config.components[action.componentType].defaultProps || {}), {
+      id
+    })
+  };
+  const [parentId] = action.destinationZone.split(":");
+  const idsInPath = getIdsForParent(action.destinationZone, state);
+  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;
+      } else if (idsInPath.indexOf(childItem.props.id) > -1) {
+        return childItem;
+      }
+      return null;
+    }
+  );
+}
+var moveAction = (state, action, appStore) => {
+  if (action.sourceZone === action.destinationZone && action.sourceIndex === action.destinationIndex) {
+    return state;
   }
+  const item = getItem(
+    { zone: action.sourceZone, index: action.sourceIndex },
+    state
+  );
+  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
+        );
+      } 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;
+    }
+  );
 };
-var defaultContext = {
-  state: defaultAppState,
-  dispatch: () => null,
-  config: { components: {} },
-  componentState: {},
-  setComponentState: () => {
-  },
-  resolveData: () => {
-  },
-  plugins: [],
-  overrides: {},
-  history: {},
-  viewports: defaultViewports,
-  zoomConfig: {
-    autoZoom: 1,
-    rootHeight: 0,
-    zoom: 1
-  },
-  setZoomConfig: () => null,
-  status: "LOADING",
-  setStatus: () => null,
-  iframe: {},
-  globalPermissions: {},
-  getPermissions: () => ({}),
-  refreshPermissions: () => null,
-  metadata: {}
-};
-var appContext = (0, import_react6.createContext)(defaultContext);
-function useAppContext() {
-  const mainContext = (0, import_react6.useContext)(appContext);
-  return __spreadProps(__spreadValues({}, mainContext), {
-    // Helpers
-    setUi: (ui, recordHistory) => {
-      return mainContext.dispatch({
-        type: "setUi",
-        ui,
-        recordHistory
+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);
+  }
+  return __spreadValues(__spreadValues({}, state), action.state(state));
+};
+function reduce(state, action, appStore) {
+  if (action.type === "set") {
+    return setAction(state, action, appStore);
+  }
+  if (action.type === "insert") {
+    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 },
+      state
+    );
+    const idsInPath = getIdsForParent(action.sourceZone, state);
+    const newItem = __spreadProps(__spreadValues({}, item), {
+      props: __spreadProps(__spreadValues({}, item.props), {
+        id: generateId(item.type)
+      })
+    });
+    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;
+      }
+    );
+    return __spreadProps(__spreadValues({}, modified), {
+      ui: __spreadProps(__spreadValues({}, modified.ui), {
+        itemSelector: {
+          index: action.sourceIndex + 1,
+          zone: action.sourceZone
+        }
+      })
+    });
+  }
+  if (action.type === "reorder") {
+    return moveAction(
+      state,
+      {
+        type: "move",
+        sourceIndex: action.sourceIndex,
+        sourceZone: action.destinationZone,
+        destinationIndex: action.destinationIndex,
+        destinationZone: action.destinationZone
+      },
+      appStore
+    );
+  }
+  if (action.type === "move") {
+    return moveAction(state, action, appStore);
+  }
+  if (action.type === "remove") {
+    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.type === "registerZone") {
+    if (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 __spreadProps(__spreadValues({}, state), { data: setupZone(state.data, action.zone) });
+  }
+  if (action.type === "unregisterZone") {
+    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];
+    }
+    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") {
+      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 walkTree(
+      __spreadProps(__spreadValues({}, state), {
+        data: __spreadValues(__spreadValues({}, state.data), action.data(state.data))
+      }),
+      appStore.config
+    );
+  }
+  if (action.type === "setUi") {
+    if (typeof action.ui === "object") {
+      return __spreadProps(__spreadValues({}, state), {
+        ui: __spreadValues(__spreadValues({}, state.ui), action.ui)
+      });
+    }
+    return __spreadProps(__spreadValues({}, state), {
+      ui: __spreadValues(__spreadValues({}, state.ui), action.ui(state.ui))
+    });
+  }
+  return state;
+}
+
+// ../core/reducer/actions.tsx
+init_react_import();
+
+// ../core/reducer/index.ts
+function storeInterceptor(reducer, record, onAction) {
+  return (state, action) => {
+    const newAppState = reducer(state, action);
+    const isValidType = ![
+      "registerZone",
+      "unregisterZone",
+      "setData",
+      "setUi",
+      "set"
+    ].includes(action.type);
+    if (typeof action.recordHistory !== "undefined" ? action.recordHistory : isValidType) {
+      if (record) record(newAppState);
+    }
+    onAction == null ? void 0 : onAction(action, newAppState, state);
+    return newAppState;
+  };
+}
+function createReducer({
+  record,
+  onAction,
+  appStore
+}) {
+  return storeInterceptor(
+    (state, action) => {
+      const result = reduce(state, action, appStore);
+      return result;
+    },
+    record,
+    onAction
+  );
 }
 
+// ../core/components/ViewportControls/default-viewports.ts
+init_react_import();
+var defaultViewports = [
+  { width: 360, height: "auto", icon: "Smartphone", label: "Small" },
+  { width: 768, height: "auto", icon: "Tablet", label: "Medium" },
+  { width: 1280, height: "auto", icon: "Monitor", label: "Large" }
+];
+
 // ../../node_modules/zustand/esm/vanilla.mjs
 init_react_import();
 var createStoreImpl = (createState) => {
@@ -445,94 +1080,707 @@ var createStoreImpl = (createState) => {
 };
 var createStore = (createState) => createState ? createStoreImpl(createState) : createStoreImpl;
 
-// ../core/components/DropZone/context.tsx
-var import_jsx_runtime3 = require("react/jsx-runtime");
-var dropZoneContext = (0, import_react7.createContext)(null);
-var ZoneStoreContext = (0, import_react7.createContext)(
-  createStore(() => ({
-    zoneDepthIndex: {},
-    nextZoneDepthIndex: {},
-    areaDepthIndex: {},
-    nextAreaDepthIndex: {},
-    draggedItem: null,
-    previewIndex: {}
+// ../../node_modules/zustand/esm/react.mjs
+init_react_import();
+var import_react4 = __toESM(require("react"), 1);
+var identity = (arg) => arg;
+function useStore(api, selector = identity) {
+  const slice = import_react4.default.useSyncExternalStore(
+    api.subscribe,
+    () => selector(api.getState()),
+    () => selector(api.getInitialState())
+  );
+  import_react4.default.useDebugValue(slice);
+  return slice;
+}
+var createImpl = (createState) => {
+  const api = createStore(createState);
+  const useBoundStore = (selector) => useStore(api, selector);
+  Object.assign(useBoundStore, api);
+  return useBoundStore;
+};
+var create = (createState) => createState ? createImpl(createState) : createImpl;
+
+// ../../node_modules/zustand/esm/middleware.mjs
+init_react_import();
+var subscribeWithSelectorImpl = (fn) => (set, get, api) => {
+  const origSubscribe = api.subscribe;
+  api.subscribe = (selector, optListener, options) => {
+    let listener = selector;
+    if (optListener) {
+      const equalityFn = (options == null ? void 0 : options.equalityFn) || Object.is;
+      let currentSlice = selector(api.getState());
+      listener = (state) => {
+        const nextSlice = selector(state);
+        if (!equalityFn(currentSlice, nextSlice)) {
+          const previousSlice = currentSlice;
+          optListener(currentSlice = nextSlice, previousSlice);
+        }
+      };
+      if (options == null ? void 0 : options.fireImmediately) {
+        optListener(currentSlice, currentSlice);
+      }
+    }
+    return origSubscribe(listener);
+  };
+  const initialState = fn(set, get, api);
+  return initialState;
+};
+var subscribeWithSelector = subscribeWithSelectorImpl;
+
+// ../core/store/index.ts
+var import_react9 = require("react");
+
+// ../core/store/slices/history.ts
+init_react_import();
+var import_react6 = require("react");
+
+// ../core/lib/use-hotkey.ts
+init_react_import();
+var import_react5 = require("react");
+var useHotkeyStore = create()(
+  subscribeWithSelector((set) => ({
+    held: {},
+    hold: (key) => set((s) => s.held[key] ? s : { held: __spreadProps(__spreadValues({}, s.held), { [key]: true }) }),
+    release: (key) => set((s) => s.held[key] ? { held: __spreadProps(__spreadValues({}, s.held), { [key]: false }) } : s),
+    reset: (held = {}) => set(() => ({ held })),
+    triggers: {}
   }))
 );
 
-// ../core/lib/get-zone-id.ts
+// ../core/store/slices/history.ts
+var EMPTY_HISTORY_INDEX = 0;
+function debounce(func, timeout = 300) {
+  let timer;
+  return (...args) => {
+    clearTimeout(timer);
+    timer = setTimeout(() => {
+      func(...args);
+    }, timeout);
+  };
+}
+var tidyState = (state) => {
+  return __spreadProps(__spreadValues({}, state), {
+    ui: __spreadProps(__spreadValues({}, state.ui), {
+      field: {
+        focus: null
+      }
+    })
+  });
+};
+var createHistorySlice = (set, get) => {
+  const record = debounce((state) => {
+    const { histories, index } = get().history;
+    const history = {
+      state,
+      id: generateId("history")
+    };
+    const newHistories = [...histories.slice(0, index + 1), history];
+    set({
+      history: __spreadProps(__spreadValues({}, get().history), {
+        histories: newHistories,
+        index: newHistories.length - 1
+      })
+    });
+  }, 250);
+  return {
+    initialAppState: {},
+    index: EMPTY_HISTORY_INDEX,
+    histories: [],
+    hasPast: () => get().history.index > EMPTY_HISTORY_INDEX,
+    hasFuture: () => get().history.index < get().history.histories.length - 1,
+    prevHistory: () => {
+      const { history } = get();
+      return history.hasPast() ? history.histories[history.index - 1] : null;
+    },
+    nextHistory: () => {
+      const s = get().history;
+      return s.hasFuture() ? s.histories[s.index + 1] : null;
+    },
+    currentHistory: () => get().history.histories[get().history.index],
+    back: () => {
+      var _a;
+      const { history, dispatch } = get();
+      if (history.hasPast()) {
+        const state = tidyState(
+          ((_a = history.prevHistory()) == null ? void 0 : _a.state) || history.initialAppState
+        );
+        dispatch({
+          type: "set",
+          state
+        });
+        set({ history: __spreadProps(__spreadValues({}, history), { index: history.index - 1 }) });
+      }
+    },
+    forward: () => {
+      var _a;
+      const { history, dispatch } = get();
+      if (history.hasFuture()) {
+        const state = (_a = history.nextHistory()) == null ? void 0 : _a.state;
+        dispatch({ type: "set", state: state ? tidyState(state) : {} });
+        set({ history: __spreadProps(__spreadValues({}, history), { index: history.index + 1 }) });
+      }
+    },
+    setHistories: (histories) => {
+      var _a;
+      const { dispatch, history } = get();
+      dispatch({
+        type: "set",
+        state: ((_a = history.histories[history.histories.length - 1]) == null ? void 0 : _a.state) || history.initialAppState
+      });
+      set({ history: __spreadProps(__spreadValues({}, history), { histories, index: histories.length - 1 }) });
+    },
+    setHistoryIndex: (index) => {
+      var _a;
+      const { dispatch, history } = get();
+      dispatch({
+        type: "set",
+        state: ((_a = history.histories[history.index]) == null ? void 0 : _a.state) || history.initialAppState
+      });
+      set({ history: __spreadProps(__spreadValues({}, history), { index }) });
+    },
+    record
+  };
+};
+
+// ../core/store/slices/nodes.ts
 init_react_import();
-var getZoneId = (zoneCompound) => {
-  if (!zoneCompound) {
-    return [];
-  }
-  if (zoneCompound && zoneCompound.indexOf(":") > -1) {
-    return zoneCompound.split(":");
+var createNodesSlice = (set, get) => ({
+  nodes: {},
+  registerNode: (id, node) => {
+    const s = get().nodes;
+    const emptyNode = {
+      id,
+      methods: { sync: () => null },
+      element: null
+    };
+    const existingNode = s.nodes[id];
+    set({
+      nodes: __spreadProps(__spreadValues({}, s), {
+        nodes: __spreadProps(__spreadValues({}, s.nodes), {
+          [id]: __spreadProps(__spreadValues(__spreadValues(__spreadValues({}, emptyNode), existingNode), node), {
+            id
+          })
+        })
+      })
+    });
+  },
+  unregisterNode: (id) => {
+    const s = get().nodes;
+    const existingNode = s.nodes[id];
+    if (existingNode) {
+      const newNodes = __spreadValues({}, s.nodes);
+      delete newNodes[id];
+      set({
+        nodes: __spreadProps(__spreadValues({}, s), {
+          nodes: newNodes
+        })
+      });
+    }
   }
-  return [rootDroppableId, zoneCompound];
+});
+
+// ../core/store/slices/permissions.ts
+init_react_import();
+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/use-breadcrumbs.ts
-var convertPathDataToBreadcrumbs = (selectedItem, pathData, data) => {
-  const id = selectedItem ? selectedItem == null ? void 0 : selectedItem.props.id : "";
-  const currentPathData = pathData && id && pathData[id] ? __spreadValues({}, pathData[id]) : { label: "Page", path: [] };
-  if (!id) {
-    return [];
-  }
-  return currentPathData == null ? void 0 : currentPathData.path.reduce((acc, zoneCompound) => {
-    const [area] = getZoneId(zoneCompound);
-    if (area === rootDroppableId) {
-      return [
-        {
-          label: "Page",
-          selector: null
+// ../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, config } = get();
+    const { cache: cache2, globalPermissions } = permissions;
+    const resolveDataForItem = (item2, force2 = false) => __async(void 0, null, function* () {
+      var _a, _b, _c;
+      const {
+        config: config2,
+        state: appState,
+        setComponentLoading,
+        unsetComponentLoading
+      } = get();
+      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 = 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 = cache2[item2.props.id]) == null ? void 0 : _b.lastPermissions) || null,
+              permissions: initialPermissions,
+              appState,
+              lastData: ((_c = cache2[item2.props.id]) == null ? void 0 : _c.lastData) || null
+            }
+          );
+          const latest = get().permissions;
+          set({
+            permissions: __spreadProps(__spreadValues({}, latest), {
+              cache: __spreadProps(__spreadValues({}, latest.cache), {
+                [item2.props.id]: {
+                  lastData: item2,
+                  lastPermissions: resolvedPermissions
+                }
+              }),
+              resolvedPermissions: __spreadProps(__spreadValues({}, latest.resolvedPermissions), {
+                [item2.props.id]: resolvedPermissions
+              })
+            })
+          });
+          unsetComponentLoading(item2.props.id);
         }
-      ];
+      }
+    });
+    const resolveDataForRoot = (force2 = false) => {
+      const { state: appState } = get();
+      resolveDataForItem(
+        // Shim the root data in by conforming to component data shape
+        {
+          type: "root",
+          props: __spreadProps(__spreadValues({}, appState.data.root.props), { id: "puck-root" })
+        },
+        force2
+      );
+    };
+    const { item, type, root } = params;
+    if (item) {
+      yield resolveDataForItem(item, force);
+    } else if (type) {
+      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, config).map((item2) => __async(void 0, null, function* () {
+        yield resolveDataForItem(item2, force);
+      }));
     }
-    const parentZoneCompound = acc.length > 0 ? acc[acc.length - 1].zoneCompound : rootDroppableId;
-    let parentZone = data.content;
-    if (parentZoneCompound && parentZoneCompound !== rootDroppableId) {
-      parentZone = data.zones[parentZoneCompound];
+  });
+  const refreshPermissions = (params) => resolvePermissions(params, true);
+  return {
+    cache: {},
+    globalPermissions: {
+      drag: true,
+      edit: true,
+      delete: true,
+      duplicate: true,
+      insert: true
+    },
+    resolvedPermissions: {},
+    getPermissions: ({ item, type, root } = {}) => {
+      const { config, permissions } = get();
+      const { globalPermissions, resolvedPermissions } = permissions;
+      if (item) {
+        const componentConfig = config.components[item.type];
+        const initialPermissions = __spreadValues(__spreadValues({}, globalPermissions), componentConfig == null ? void 0 : componentConfig.permissions);
+        const resolvedForItem = resolvedPermissions[item.props.id];
+        return resolvedForItem ? __spreadValues(__spreadValues({}, globalPermissions), resolvedForItem) : initialPermissions;
+      } else if (type) {
+        const componentConfig = config.components[type];
+        return __spreadValues(__spreadValues({}, globalPermissions), componentConfig == null ? void 0 : componentConfig.permissions);
+      } else if (root) {
+        const rootConfig = config.root;
+        const initialPermissions = __spreadValues(__spreadValues({}, globalPermissions), rootConfig == null ? void 0 : rootConfig.permissions);
+        const resolvedForItem = resolvedPermissions["puck-root"];
+        return resolvedForItem ? __spreadValues(__spreadValues({}, globalPermissions), resolvedForItem) : initialPermissions;
+      }
+      return globalPermissions;
+    },
+    resolvePermissions,
+    refreshPermissions
+  };
+};
+
+// ../core/store/slices/fields.ts
+init_react_import();
+var import_react8 = require("react");
+var createFieldsSlice = (_set, _get) => {
+  return {
+    fields: {},
+    loading: false,
+    lastResolvedData: {}
+  };
+};
+
+// ../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;
     }
-    if (!parentZone) {
-      return acc;
+    const changed = getChanged(item, oldItem);
+    if (onResolveStart) {
+      onResolveStart(item);
     }
-    const itemIndex = parentZone.findIndex(
-      (queryItem) => queryItem.props.id === area
-    );
-    const item = parentZone[itemIndex];
-    if (!item) {
-      return acc;
+    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;
+            })
+          )
+        );
+      }));
     }
-    return [
-      ...acc,
-      {
-        label: item.type.toString(),
-        selector: {
-          index: itemIndex,
-          zone: parentZoneCompound
-        },
-        zoneCompound
-      }
-    ];
-  }, []);
+    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: {} },
+  ui: {
+    leftSideBarVisible: true,
+    rightSideBarVisible: true,
+    arrayState: {},
+    itemSelector: null,
+    componentList: {},
+    isDragging: false,
+    previewMode: "edit",
+    viewports: {
+      current: {
+        width: defaultViewports[0].width,
+        height: defaultViewports[0].height || "auto"
+      },
+      options: [],
+      controlsVisible: true
+    },
+    field: { focus: null }
+  },
+  indexes: {
+    nodes: {},
+    zones: {}
+  }
+};
+var defaultPageFields = {
+  title: { type: "text" }
+};
+var createAppStore = (initialAppStore) => create()(
+  subscribeWithSelector((set, get) => __spreadProps(__spreadValues({
+    state: defaultAppState,
+    config: { components: {} },
+    componentState: {},
+    plugins: [],
+    overrides: {},
+    viewports: defaultViewports,
+    zoomConfig: {
+      autoZoom: 1,
+      rootHeight: 0,
+      zoom: 1
+    },
+    status: "LOADING",
+    iframe: {},
+    metadata: {}
+  }, initialAppStore), {
+    fields: createFieldsSlice(set, get),
+    history: createHistorySlice(set, get),
+    nodes: createNodesSlice(set, get),
+    permissions: createPermissionsSlice(set, get),
+    getComponentConfig: (type) => {
+      var _a;
+      const { config, selectedItem } = get();
+      const rootFields = ((_a = config.root) == null ? void 0 : _a.fields) || defaultPageFields;
+      return type && type !== "root" ? config.components[type] : selectedItem ? config.components[selectedItem.type] : __spreadProps(__spreadValues({}, config.root), { fields: rootFields });
+    },
+    dispatch: (action) => set((s) => {
+      var _a, _b;
+      const { record } = get().history;
+      const dispatch = createReducer({
+        record,
+        appStore: s
+      });
+      const state = dispatch(s.state, action);
+      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 }),
+    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) => {
+      const { setComponentLoading } = get();
+      setComponentLoading(id, false);
+    },
+    // Helper
+    setUi: (ui, recordHistory) => set((s) => {
+      const dispatch = createReducer({
+        record: () => {
+        },
+        appStore: s
+      });
+      const state = dispatch(s.state, {
+        type: "setUi",
+        ui,
+        recordHistory
+      });
+      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 { ...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_react9.createContext)(createAppStore());
+function useAppStore(selector) {
+  const context = (0, import_react9.useContext)(appStoreContext);
+  return useStore(context, selector);
+}
+function useAppStoreApi() {
+  return (0, import_react9.useContext)(appStoreContext);
+}
+
+// ../core/lib/use-breadcrumbs.ts
 var useBreadcrumbs = (renderCount) => {
-  const {
-    state: { data },
-    selectedItem
-  } = useAppContext();
-  const dzContext = (0, import_react8.useContext)(dropZoneContext);
-  return (0, import_react8.useMemo)(() => {
-    const breadcrumbs = convertPathDataToBreadcrumbs(
-      selectedItem,
-      dzContext == null ? void 0 : dzContext.pathData,
-      data
-    );
+  const selectedId = useAppStore((s) => {
+    var _a;
+    return (_a = s.selectedItem) == null ? void 0 : _a.props.id;
+  });
+  const config = useAppStore((s) => s.config);
+  const path = useAppStore((s) => {
+    var _a;
+    return (_a = s.state.indexes.nodes[selectedId]) == null ? void 0 : _a.path;
+  });
+  const appStore = useAppStoreApi();
+  return (0, import_react10.useMemo)(() => {
+    const breadcrumbs = (path == null ? void 0 : path.map((zoneCompound) => {
+      var _a, _b, _c;
+      const [componentId] = zoneCompound.split(":");
+      if (componentId === "root") {
+        return {
+          label: "Page",
+          selector: null
+        };
+      }
+      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,
+          zone: node.path[node.path.length - 1]
+        } : null
+      };
+    })) || [];
     if (renderCount) {
       return breadcrumbs.slice(breadcrumbs.length - renderCount);
     }
     return breadcrumbs;
-  }, [selectedItem, dzContext == null ? void 0 : dzContext.pathData, renderCount]);
+  }, [path, renderCount]);
 };
 
 // ../core/components/Loader/index.tsx
@@ -555,7 +1803,7 @@ init_react_import();
 var styles_module_default3 = { "Loader": "_Loader_nacdm_13", "loader-animation": "_loader-animation_nacdm_1" };
 
 // ../core/components/Loader/index.tsx
-var import_jsx_runtime4 = require("react/jsx-runtime");
+var import_jsx_runtime2 = require("react/jsx-runtime");
 var getClassName2 = get_class_name_factory_default("Loader", styles_module_default3);
 var Loader = (_a) => {
   var _b = _a, {
@@ -565,7 +1813,7 @@ var Loader = (_a) => {
     "color",
     "size"
   ]);
-  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
     "span",
     __spreadValues({
       className: getClassName2(),
@@ -580,7 +1828,7 @@ var Loader = (_a) => {
 };
 
 // ../core/components/SidebarSection/index.tsx
-var import_jsx_runtime5 = require("react/jsx-runtime");
+var import_jsx_runtime3 = require("react/jsx-runtime");
 var getClassName3 = get_class_name_factory_default("SidebarSection", styles_module_default);
 var SidebarSection = ({
   children,
@@ -591,17 +1839,17 @@ var SidebarSection = ({
   noPadding,
   isLoading
 }) => {
-  const { setUi } = useAppContext();
+  const setUi = useAppStore((s) => s.setUi);
   const breadcrumbs = useBreadcrumbs(1);
-  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
     "div",
     {
       className: getClassName3({ noBorderTop, noPadding }),
       style: { background },
       children: [
-        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { className: getClassName3("title"), children: /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { className: getClassName3("breadcrumbs"), children: [
-          showBreadcrumbs ? breadcrumbs.map((breadcrumb, i) => /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { className: getClassName3("breadcrumb"), children: [
-            /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: getClassName3("title"), children: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: getClassName3("breadcrumbs"), children: [
+          showBreadcrumbs ? breadcrumbs.map((breadcrumb, i) => /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: getClassName3("breadcrumb"), children: [
+            /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
               "button",
               {
                 type: "button",
@@ -610,12 +1858,12 @@ var SidebarSection = ({
                 children: breadcrumb.label
               }
             ),
-            /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(ChevronRight, { size: 16 })
+            /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(ChevronRight, { size: 16 })
           ] }, i)) : null,
-          /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { className: getClassName3("heading"), children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Heading, { rank: "2", size: "xs", children: title }) })
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: getClassName3("heading"), children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Heading, { rank: "2", size: "xs", children: title }) })
         ] }) }),
-        /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { className: getClassName3("content"), children }),
-        isLoading && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { className: getClassName3("loadingOverlay"), children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Loader, { size: 32 }) })
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: getClassName3("content"), children }),
+        isLoading && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: getClassName3("loadingOverlay"), children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(Loader, { size: 32 }) })
       ]
     }
   );
@@ -629,18 +1877,18 @@ init_react_import();
 var styles_module_default4 = { "OutlineList": "_OutlineList_w4lzv_1", "OutlineListItem": "_OutlineListItem_w4lzv_25", "OutlineListItem--clickable": "_OutlineListItem--clickable_w4lzv_45" };
 
 // ../core/components/OutlineList/index.tsx
-var import_jsx_runtime6 = require("react/jsx-runtime");
+var import_jsx_runtime4 = require("react/jsx-runtime");
 var getClassName4 = get_class_name_factory_default("OutlineList", styles_module_default4);
 var getClassNameItem = get_class_name_factory_default("OutlineListItem", styles_module_default4);
 var OutlineList = ({ children }) => {
-  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("ul", { className: getClassName4(), children });
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("ul", { className: getClassName4(), children });
 };
-OutlineList.Clickable = ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("div", { className: getClassNameItem({ clickable: true }), children });
+OutlineList.Clickable = ({ children }) => /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { className: getClassNameItem({ clickable: true }), children });
 OutlineList.Item = ({
   children,
   onClick
 }) => {
-  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
     "li",
     {
       className: getClassNameItem({ clickable: !!onClick }),
@@ -674,7 +1922,7 @@ var getFrame = () => {
 
 // src/HeadingAnalyzer.tsx
 var import_react_from_json = __toESM(require("react-from-json"));
-var import_jsx_runtime7 = require("react/jsx-runtime");
+var import_jsx_runtime5 = require("react/jsx-runtime");
 var getClassName5 = get_class_name_factory_default("HeadingAnalyzer", HeadingAnalyzer_module_default);
 var getClassNameItem2 = get_class_name_factory_default("HeadingAnalyzerItem", HeadingAnalyzer_module_default);
 var ReactFromJSON = import_react_from_json.default.default || import_react_from_json.default;
@@ -682,6 +1930,9 @@ var getOutline = ({ frame } = {}) => {
   const headings = (frame == null ? void 0 : frame.querySelectorAll("h1,h2,h3,h4,h5,h6")) || [];
   const _outline = [];
   headings.forEach((item, i) => {
+    if (item.closest("[data-dnd-dragging]")) {
+      return;
+    }
     _outline.push({
       rank: parseInt(item.tagName.split("H")[1]),
       text: item.textContent,
@@ -724,10 +1975,11 @@ function buildHierarchy(frame) {
   }
   return root.children;
 }
+var usePuck = (0, import_puck.createUsePuck)();
 var HeadingAnalyzer = () => {
-  const { appState } = (0, import_puck.usePuck)();
-  const [hierarchy, setHierarchy] = (0, import_react9.useState)([]);
-  (0, import_react9.useEffect)(() => {
+  const data = usePuck((s) => s.appState.data);
+  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;
@@ -739,9 +1991,9 @@ var HeadingAnalyzer = () => {
     return () => {
       observer.disconnect();
     };
-  }, [appState.data]);
-  return /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("div", { className: getClassName5(), children: [
-    /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(
+  }, [data]);
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("div", { className: getClassName5(), children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(
       "small",
       {
         className: getClassName5("cssWarning"),
@@ -753,19 +2005,19 @@ var HeadingAnalyzer = () => {
         children: [
           "Heading analyzer styles not loaded. Please review the",
           " ",
-          /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("a", { href: "https://github.com/measuredco/puck/blob/main/packages/plugin-heading-analyzer/README.md", children: "README" }),
+          /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("a", { href: "https://github.com/measuredco/puck/blob/main/packages/plugin-heading-analyzer/README.md", children: "README" }),
           "."
         ]
       }
     ),
-    hierarchy.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("div", { children: "No headings." }),
-    /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(OutlineList, { children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+    hierarchy.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { children: "No headings." }),
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(OutlineList, { children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
       ReactFromJSON,
       {
         mapping: {
-          Root: (props) => /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_jsx_runtime7.Fragment, { children: props.children }),
-          OutlineListItem: (props) => /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(OutlineList.Item, { children: [
-            /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(OutlineList.Clickable, { children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(
+          Root: (props) => /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_jsx_runtime5.Fragment, { children: props.children }),
+          OutlineListItem: (props) => /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(OutlineList.Item, { children: [
+            /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(OutlineList.Clickable, { children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
               "small",
               {
                 className: getClassNameItem2({ missing: props.missing }),
@@ -783,14 +2035,14 @@ var HeadingAnalyzer = () => {
                     }, 2e3);
                   }
                 },
-                children: props.missing ? /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_jsx_runtime7.Fragment, { children: [
-                  /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("b", { children: [
+                children: props.missing ? /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_jsx_runtime5.Fragment, { children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("b", { children: [
                     "H",
                     props.rank
                   ] }),
                   ": Missing"
-                ] }) : /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_jsx_runtime7.Fragment, { children: [
-                  /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)("b", { children: [
+                ] }) : /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_jsx_runtime5.Fragment, { children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)("b", { children: [
                     "H",
                     props.rank
                   ] }),
@@ -799,7 +2051,7 @@ var HeadingAnalyzer = () => {
                 ] })
               }
             ) }),
-            /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(OutlineList, { children: props.children })
+            /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(OutlineList, { children: props.children })
           ] })
         },
         entry: {
@@ -821,9 +2073,9 @@ var HeadingAnalyzer = () => {
 };
 var headingAnalyzer = {
   overrides: {
-    fields: ({ children, itemSelector }) => /* @__PURE__ */ (0, import_jsx_runtime7.jsxs)(import_jsx_runtime7.Fragment, { children: [
+    fields: ({ children, itemSelector }) => /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(import_jsx_runtime5.Fragment, { children: [
       children,
-      /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("div", { style: { display: itemSelector ? "none" : "block" }, children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(SidebarSection, { title: "Heading Outline", children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(HeadingAnalyzer, {}) }) })
+      /* @__PURE__ */ (0, import_jsx_runtime5.jsx)("div", { style: { display: itemSelector ? "none" : "block" }, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(SidebarSection, { title: "Heading Outline", children: /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(HeadingAnalyzer, {}) }) })
     ] })
   }
 };