@measured/puck 0.19.0-canary.e829bea0 → 0.19.0-canary.eda38b34

package/dist/chunk-44RES7IE.mjs

@@ -0,0 +1,566 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  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
+import React from "react";
+var init_react_import = __esm({
+  "../tsup-config/react-import.js"() {
+    "use strict";
+  }
+});
+
+// lib/data/walk-tree.ts
+init_react_import();
+
+// lib/data/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";
+};
+var createIsSlotConfig = (config) => (itemType, propName, propValue) => {
+  var _a, _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 = (_a = configForComponent.fields) == null ? void 0 : _a[propName]) == null ? void 0 : _b.type) === "slot";
+};
+
+// lib/data/map-slots.ts
+init_react_import();
+function mapSlotsAsync(_0, _1) {
+  return __async(this, arguments, function* (item, map, recursive = true, isSlot2 = isSlot) {
+    const props = __spreadValues({}, 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];
+        const mappedContent = recursive ? yield Promise.all(
+          content.map((item2) => __async(this, null, function* () {
+            return yield mapSlotsAsync(item2, map, recursive, isSlot2);
+          }))
+        ) : content;
+        props[propKey] = yield map(mappedContent, propKey);
+      }
+    }
+    return __spreadProps(__spreadValues({}, item), { props });
+  });
+}
+function mapSlotsSync(item, map, isSlot2 = isSlot) {
+  var _a, _b;
+  const props = __spreadValues({}, 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];
+      const mappedContent = content.map((item2) => {
+        return mapSlotsSync(item2, map, isSlot2);
+      });
+      props[propKey] = (_b = map(mappedContent, (_a = props.id) != null ? _a : "root", propKey)) != null ? _b : mappedContent;
+    }
+  }
+  return __spreadProps(__spreadValues({}, item), { props });
+}
+
+// lib/data/walk-tree.ts
+function walkTree(data, config, callbackFn) {
+  var _a, _b;
+  const isSlot2 = createIsSlotConfig(config);
+  const walkItem = (item) => {
+    return mapSlotsSync(
+      item,
+      (content, parentId, propName) => callbackFn(content, { parentId, propName }),
+      isSlot2
+    );
+  };
+  if ("props" in data) {
+    return walkItem(data);
+  }
+  const _data = data;
+  const zones = (_a = _data.zones) != null ? _a : {};
+  const mappedContent = _data.content.map(walkItem);
+  return {
+    root: walkItem(_data.root),
+    content: (_b = callbackFn(mappedContent, {
+      parentId: "root",
+      propName: "default-zone"
+    })) != null ? _b : mappedContent,
+    zones: Object.keys(zones).reduce(
+      (acc, zoneCompound) => __spreadProps(__spreadValues({}, acc), {
+        [zoneCompound]: zones[zoneCompound].map(walkItem)
+      }),
+      {}
+    )
+  };
+}
+
+// components/ServerRender/index.tsx
+init_react_import();
+
+// lib/root-droppable-id.ts
+init_react_import();
+var rootAreaId = "root";
+var rootZone = "default-zone";
+var rootDroppableId = `${rootAreaId}:${rootZone}`;
+
+// lib/data/setup-zone.ts
+init_react_import();
+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;
+};
+
+// lib/use-slots.tsx
+init_react_import();
+import { useMemo } from "react";
+function useSlots(config, props, renderSlotEdit, renderSlotRender = renderSlotEdit, readOnly, forceReadOnly) {
+  const slotProps = useMemo(() => {
+    if (!(config == null ? void 0 : config.fields)) return props;
+    const slotProps2 = {};
+    const fieldKeys = Object.keys(config.fields);
+    for (let i = 0; i < fieldKeys.length; i++) {
+      const fieldKey = fieldKeys[i];
+      const field = config.fields[fieldKey];
+      if ((field == null ? void 0 : field.type) === "slot") {
+        const content = props[fieldKey] || [];
+        const render = (readOnly == null ? void 0 : readOnly[fieldKey]) || forceReadOnly ? renderSlotRender : renderSlotEdit;
+        const Slot = (dzProps) => render(__spreadProps(__spreadValues({
+          allow: field.allow,
+          disallow: field.disallow
+        }, dzProps), {
+          zone: fieldKey,
+          content
+        }));
+        slotProps2[fieldKey] = Slot;
+      }
+    }
+    return slotProps2;
+  }, [config, readOnly, forceReadOnly]);
+  return __spreadValues(__spreadValues({}, props), slotProps);
+}
+
+// components/SlotRender/server.tsx
+init_react_import();
+import { forwardRef } from "react";
+import { jsx } from "react/jsx-runtime";
+var SlotRenderPure = (props) => /* @__PURE__ */ jsx(SlotRender, __spreadValues({}, props));
+var Item = ({
+  config,
+  item,
+  metadata
+}) => {
+  const Component = config.components[item.type];
+  const props = useSlots(Component, item.props, (slotProps) => /* @__PURE__ */ jsx(SlotRenderPure, __spreadProps(__spreadValues({}, slotProps), { config, metadata })));
+  return /* @__PURE__ */ jsx(
+    Component.render,
+    __spreadProps(__spreadValues({}, props), {
+      puck: __spreadProps(__spreadValues({}, props.puck), {
+        renderDropZone: DropZoneRender,
+        metadata: metadata || {}
+      })
+    })
+  );
+};
+var SlotRender = forwardRef(
+  function SlotRenderInternal({ className, style, content, config, metadata }, ref) {
+    return /* @__PURE__ */ jsx("div", { className, style, ref, children: content.map((item) => {
+      if (!config.components[item.type]) {
+        return null;
+      }
+      return /* @__PURE__ */ jsx(
+        Item,
+        {
+          config,
+          item,
+          metadata
+        },
+        item.props.id
+      );
+    }) });
+  }
+);
+
+// components/ServerRender/index.tsx
+import { Fragment, jsx as jsx2 } from "react/jsx-runtime";
+function DropZoneRender({
+  zone,
+  data,
+  areaId = "root",
+  config,
+  metadata = {}
+}) {
+  let zoneCompound = rootDroppableId;
+  let content = (data == null ? void 0 : data.content) || [];
+  if (!data || !config) {
+    return null;
+  }
+  if (areaId !== rootAreaId && zone !== rootZone) {
+    zoneCompound = `${areaId}:${zone}`;
+    content = setupZone(data, zoneCompound).zones[zoneCompound];
+  }
+  return /* @__PURE__ */ jsx2(Fragment, { children: content.map((item) => {
+    const Component = config.components[item.type];
+    const props = __spreadProps(__spreadValues({}, item.props), {
+      puck: {
+        renderDropZone: ({ zone: zone2 }) => /* @__PURE__ */ jsx2(
+          DropZoneRender,
+          {
+            zone: zone2,
+            data,
+            areaId: item.props.id,
+            config,
+            metadata
+          }
+        ),
+        metadata
+      }
+    });
+    const propsWithSlots = useSlots(Component, props, (props2) => /* @__PURE__ */ jsx2(SlotRenderPure, __spreadProps(__spreadValues({}, props2), { config, metadata })));
+    if (Component) {
+      return /* @__PURE__ */ jsx2(Component.render, __spreadValues({}, propsWithSlots), item.props.id);
+    }
+    return null;
+  }) });
+}
+function Render({
+  config,
+  data,
+  metadata = {}
+}) {
+  var _a;
+  const rootProps = data.root.props || data.root;
+  const title = rootProps.title || "";
+  const props = __spreadProps(__spreadValues({}, rootProps), {
+    puck: {
+      renderDropZone: ({ zone }) => /* @__PURE__ */ jsx2(
+        DropZoneRender,
+        {
+          zone,
+          data,
+          config,
+          metadata
+        }
+      ),
+      isEditing: false,
+      dragRef: null,
+      metadata
+    },
+    title,
+    editMode: false,
+    id: "puck-root"
+  });
+  const propsWithSlots = useSlots(config.root, props, (props2) => /* @__PURE__ */ jsx2(SlotRenderPure, __spreadProps(__spreadValues({}, props2), { config, metadata })));
+  if ((_a = config.root) == null ? void 0 : _a.render) {
+    return /* @__PURE__ */ jsx2(config.root.render, __spreadProps(__spreadValues({}, propsWithSlots), { children: /* @__PURE__ */ jsx2(
+      DropZoneRender,
+      {
+        config,
+        data,
+        zone: rootZone,
+        metadata
+      }
+    ) }));
+  }
+  return /* @__PURE__ */ jsx2(
+    DropZoneRender,
+    {
+      config,
+      data,
+      zone: rootZone,
+      metadata
+    }
+  );
+}
+
+// lib/transform-props.ts
+init_react_import();
+
+// lib/data/default-data.ts
+init_react_import();
+var defaultData = (data) => __spreadProps(__spreadValues({}, data), {
+  root: data.root || {},
+  content: data.content || []
+});
+
+// lib/transform-props.ts
+function transformProps(data, propTransforms) {
+  const mapItem = (item) => {
+    if (propTransforms[item.type]) {
+      return __spreadProps(__spreadValues({}, item), {
+        props: propTransforms[item.type](item.props)
+      });
+    }
+    return item;
+  };
+  const defaultedData = defaultData(data);
+  const rootProps = defaultedData.root.props || defaultedData.root;
+  let newRoot = __spreadValues({}, defaultedData.root);
+  if (propTransforms["root"]) {
+    if (defaultedData.root.props) {
+      newRoot.props = propTransforms["root"](rootProps);
+    } else {
+      newRoot = propTransforms["root"](rootProps);
+    }
+  }
+  const afterPropTransforms = __spreadProps(__spreadValues({}, defaultedData), {
+    root: newRoot,
+    content: defaultedData.content.map(mapItem),
+    zones: Object.keys(data.zones || {}).reduce(
+      (acc, zoneKey) => __spreadProps(__spreadValues({}, acc), {
+        [zoneKey]: data.zones[zoneKey].map(mapItem)
+      }),
+      {}
+    )
+  });
+  return afterPropTransforms;
+}
+
+// lib/resolve-all-data.ts
+init_react_import();
+
+// lib/resolve-component-data.ts
+init_react_import();
+
+// 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]
+    });
+  }, {}) : {};
+};
+
+// lib/resolve-component-data.ts
+import fdeq from "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 && item.type !== "root" ? 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 && fdeq(item, oldItem)) {
+      return { node: resolved, didChange: false };
+    }
+    const changed = getChanged(item, oldItem);
+    if (onResolveStart) {
+      onResolveStart(item);
+    }
+    const { props: resolvedProps, readOnly = {} } = yield configForItem.resolveData(item, {
+      changed,
+      lastData: oldItem,
+      metadata: __spreadValues(__spreadValues({}, metadata), configForItem.metadata),
+      trigger
+    });
+    let resolvedItem = __spreadProps(__spreadValues({}, item), {
+      props: __spreadValues(__spreadValues({}, item.props), resolvedProps)
+    });
+    if (recursive) {
+      resolvedItem = yield mapSlotsAsync(
+        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;
+              })
+            )
+          );
+        }),
+        false,
+        createIsSlotConfig(config)
+      );
+    }
+    if (Object.keys(readOnly).length) {
+      resolvedItem.readOnly = readOnly;
+    }
+    cache.lastChange[id] = {
+      item,
+      resolved: resolvedItem
+    };
+    if (onResolveEnd) {
+      onResolveEnd(resolvedItem);
+    }
+    return { node: resolvedItem, didChange: !fdeq(item, resolvedItem) };
+  }
+  return { node: item, didChange: false };
+});
+
+// lib/data/to-component.ts
+init_react_import();
+var toComponent = (item) => {
+  return "type" in item ? item : __spreadProps(__spreadValues({}, item), {
+    props: __spreadProps(__spreadValues({}, item.props), { id: "root" }),
+    type: "root"
+  });
+};
+
+// lib/resolve-all-data.ts
+function resolveAllData(_0, _1) {
+  return __async(this, arguments, function* (data, config, metadata = {}, onResolveStart, onResolveEnd) {
+    var _a;
+    const defaultedData = defaultData(data);
+    const resolveNode = (_node) => __async(this, null, function* () {
+      const node = toComponent(_node);
+      onResolveStart == null ? void 0 : onResolveStart(node);
+      const resolved = (yield resolveComponentData(
+        node,
+        config,
+        metadata,
+        () => {
+        },
+        () => {
+        },
+        "force",
+        false
+      )).node;
+      const resolvedDeep = yield mapSlotsAsync(
+        resolved,
+        processContent,
+        false
+      );
+      onResolveEnd == null ? void 0 : onResolveEnd(toComponent(resolvedDeep));
+      return resolvedDeep;
+    });
+    const processContent = (content) => __async(this, null, function* () {
+      return Promise.all(content.map(resolveNode));
+    });
+    const processZones = () => __async(this, null, function* () {
+      var _a2;
+      const zones = (_a2 = data.zones) != null ? _a2 : {};
+      Object.entries(zones).forEach((_02) => __async(this, [_02], function* ([zoneKey, content]) {
+        zones[zoneKey] = yield Promise.all(content.map(resolveNode));
+      }));
+      return zones;
+    });
+    const dynamic = {
+      root: yield resolveNode(defaultedData.root),
+      content: yield processContent(defaultedData.content),
+      zones: yield processZones()
+    };
+    Object.keys((_a = defaultedData.zones) != null ? _a : {}).forEach((zoneKey) => __async(this, null, function* () {
+      const content = defaultedData.zones[zoneKey];
+      dynamic.zones[zoneKey] = yield processContent(content);
+    }), {});
+    return dynamic;
+  });
+}
+
+export {
+  __spreadValues,
+  __spreadProps,
+  __objRest,
+  __commonJS,
+  __toESM,
+  __async,
+  init_react_import,
+  isSlot,
+  createIsSlotConfig,
+  rootAreaId,
+  rootZone,
+  rootDroppableId,
+  walkTree,
+  setupZone,
+  getChanged,
+  resolveComponentData,
+  useSlots,
+  Render,
+  SlotRenderPure,
+  SlotRender,
+  transformProps,
+  resolveAllData
+};

package/dist/index.css

@@ -1092,27 +1092,25 @@ textarea._Input-input_4xor1_26 {
 }
 
 /* css-module:/home/runner/work/puck/puck/packages/core/components/Drawer/styles.module.css/#css-module-data */
-._Drawer_fkqfo_1 {
+._Drawer_pl7z0_1 {
   display: flex;
   flex-direction: column;
   font-family: var(--puck-font-family);
   gap: 12px;
 }
-._Drawer-draggable_fkqfo_8 {
+._Drawer-draggable_pl7z0_8 {
   position: relative;
 }
-._Drawer-draggableBg_fkqfo_12 {
+._Drawer-draggableBg_pl7z0_12 {
   position: absolute;
   top: 0;
   right: 0;
   bottom: 0;
   left: 0;
   pointer-events: none;
+  z-index: -1;
 }
-._Drawer-draggableFg_fkqfo_21 {
-  z-index: 1;
-}
-._DrawerItem-draggable_fkqfo_25 {
+._DrawerItem-draggable_pl7z0_22 {
   background: var(--puck-color-white);
   cursor: grab;
   padding: 12px;
@@ -1124,27 +1122,27 @@ textarea._Input-input_4xor1_26 {
   align-items: center;
   transition: background-color 50ms ease-in, color 50ms ease-in;
 }
-._DrawerItem--disabled_fkqfo_38 ._DrawerItem-draggable_fkqfo_25 {
+._DrawerItem--disabled_pl7z0_35 ._DrawerItem-draggable_pl7z0_22 {
   background: var(--puck-color-grey-11);
   color: var(--puck-color-grey-05);
   cursor: not-allowed;
 }
-._DrawerItem_fkqfo_25:focus-visible {
+._DrawerItem_pl7z0_22:focus-visible {
   outline: 0;
 }
-._Drawer_fkqfo_1:not(._Drawer--isDraggingFrom_fkqfo_48) ._DrawerItem_fkqfo_25:focus-visible ._DrawerItem-draggable_fkqfo_25 {
+._Drawer_pl7z0_1:not(._Drawer--isDraggingFrom_pl7z0_45) ._DrawerItem_pl7z0_22:focus-visible ._DrawerItem-draggable_pl7z0_22 {
   border-radius: 4px;
   outline: 2px solid var(--puck-color-azure-05);
   outline-offset: 2px;
 }
 @media (hover: hover) and (pointer: fine) {
-  ._Drawer_fkqfo_1:not(._Drawer--isDraggingFrom_fkqfo_48) ._DrawerItem_fkqfo_25:not(._DrawerItem--disabled_fkqfo_38) ._DrawerItem-draggable_fkqfo_25:hover {
+  ._Drawer_pl7z0_1:not(._Drawer--isDraggingFrom_pl7z0_45) ._DrawerItem_pl7z0_22:not(._DrawerItem--disabled_pl7z0_35) ._DrawerItem-draggable_pl7z0_22:hover {
     background-color: var(--puck-color-azure-12);
     color: var(--puck-color-azure-04);
     transition: none;
   }
 }
-._DrawerItem-name_fkqfo_66 {
+._DrawerItem-name_pl7z0_63 {
   overflow-x: hidden;
   text-overflow: ellipsis;
   white-space: nowrap;
@@ -1236,7 +1234,7 @@ textarea._Input-input_4xor1_26 {
 [data-puck-disabled] {
   cursor: pointer;
 }
-[data-puck-dragging]:not([data-dnd-dragging]) {
+[data-dnd-placeholder] {
   background: var(--puck-color-azure-06) !important;
   border: none !important;
   color: #00000000 !important;
@@ -1244,9 +1242,9 @@ textarea._Input-input_4xor1_26 {
   outline: none !important;
   transition: none !important;
 }
-[data-puck-dragging]:not([data-dnd-dragging]) *,
-[data-puck-dragging]:not([data-dnd-dragging])::after,
-[data-puck-dragging]:not([data-dnd-dragging])::before {
+[data-dnd-placeholder] *,
+[data-dnd-placeholder]::after,
+[data-dnd-placeholder]::before {
   opacity: 0 !important;
 }
 [data-dnd-dragging][data-puck-component] {

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-import { H as History, P as Permissions, C as ComponentData, a as Config, U as UserGenerics, F as Fields, b as PuckAction, R as RootDataWithProps, c as ResolveDataTrigger, d as Plugin, O as Overrides, V as Viewports, I as IframeConfig, e as UiState, f as ComponentConfig, A as AppState, M as Metadata, g as Field, h as FieldProps, D as DropZoneProps, i as Data, j as OnAction, k as InitialHistory, l as RootData, m as Content, n as ItemSelector } from './resolve-all-data-BFRAghCj.mjs';
-export { X as Adaptor, Q as ArrayField, v as ArrayState, a7 as AsFieldProps, B as BaseData, G as BaseField, E as ComponentDataMap, _ as CustomField, a4 as DefaultComponentProps, a1 as DefaultRootFieldProps, a3 as DefaultRootProps, a2 as DefaultRootRenderProps, o as Direction, p as DragAxis, Z as ExternalField, Y as ExternalFieldWithAdaptor, a9 as ExtractPropsFromConfig, aa as ExtractRootPropsFromConfig, t as FieldRenderFunctions, u as ItemWithId, z as MappedItem, N as NumberField, W as ObjectField, s as OverrideKey, w as PuckComponent, a0 as PuckContext, L as RadioField, x as RootConfig, y as RootDataWithoutProps, K as SelectField, S as Slot, $ as SlotField, T as TextField, J as TextareaField, q as Viewport, a8 as WithChildren, a5 as WithId, a6 as WithPuckProps, r as overrideKeys, ac as resolveAllData, ab as transformProps } from './resolve-all-data-BFRAghCj.mjs';
+import { H as History, P as Permissions, C as ComponentData, a as Config, U as UserGenerics, F as Fields, b as PuckAction, R as RootDataWithProps, c as ResolveDataTrigger, d as Plugin, O as Overrides, V as Viewports, I as IframeConfig, e as UiState, f as ComponentConfig, A as AppState, M as Metadata, g as Field, h as FieldProps, D as DropZoneProps, i as Data, j as OnAction, k as InitialHistory, l as ItemSelector } from './walk-tree-CM-cu7GU.mjs';
+export { Z as Adaptor, X as ArrayField, t as ArrayState, aa as AsFieldProps, B as BaseData, K as BaseField, G as ComponentDataMap, z as ComponentDataOptionalId, J as Content, a1 as CustomField, a0 as CustomFieldRender, a7 as DefaultComponentProps, a4 as DefaultRootFieldProps, a6 as DefaultRootProps, a5 as DefaultRootRenderProps, m as Direction, n as DragAxis, $ as ExternalField, _ as ExternalFieldWithAdaptor, ac as ExtractPropsFromConfig, ad as ExtractRootPropsFromConfig, r as FieldRenderFunctions, s as ItemWithId, E as MappedItem, N as NumberField, Y as ObjectField, q as OverrideKey, u as PuckComponent, a3 as PuckContext, W as RadioField, v as RootConfig, y as RootData, x as RootDataWithoutProps, Q as SelectField, S as Slot, a2 as SlotField, T as TextField, L as TextareaField, o as Viewport, ab as WithChildren, a8 as WithId, a9 as WithPuckProps, p as overrideKeys, af as resolveAllData, ae as transformProps, w as walkTree } from './walk-tree-CM-cu7GU.mjs';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import * as react from 'react';
 import react__default, { ReactNode, SyntheticEvent, ReactElement } from 'react';
@@ -60,6 +60,7 @@ type FieldsSlice = {
     fields: Fields | Partial<Fields>;
     loading: boolean;
     lastResolvedData: Partial<ComponentOrRootData>;
+    id: string | undefined;
 };
 
 type Status = "LOADING" | "MOUNTED" | "READY";
@@ -248,18 +249,12 @@ declare function Render<UserConfig extends Config = Config, G extends UserGeneri
 
 declare function migrate(data: Data, config?: Config): Data;
 
-type MapSlotOptions = {
-    parentId: string;
-    propName: string;
-};
-declare function mapSlotsPublic<T extends ComponentData | RootData>(item: T, config: Config, map: (data: Content, options: MapSlotOptions) => Content): T;
-
 type WithGet<T> = T & {
     get: () => T;
 };
 type UsePuckData<UserConfig extends Config = Config, G extends UserGenerics<UserConfig> = UserGenerics<UserConfig>> = {
     appState: AppState;
-    config: Config;
+    config: UserConfig;
     dispatch: AppStore["dispatch"];
     getPermissions: GetPermissions<UserConfig>;
     refreshPermissions: RefreshPermissions<UserConfig>;
@@ -292,4 +287,4 @@ type UsePuckStore<UserConfig extends Config = Config> = WithGet<PuckApi<UserConf
 declare function createUsePuck<UserConfig extends Config = Config>(): <T = PuckApi<UserConfig>>(selector: (state: UsePuckStore<UserConfig>) => T) => T;
 declare function usePuck<UserConfig extends Config = Config>(): UsePuckStore<UserConfig>;
 
-export { Action, ActionBar, AppState, AutoField, Button, ComponentConfig, ComponentData, Config, Content, Data, Drawer, DropZone, Field, FieldLabel, FieldProps, Fields, Group, History, IconButton, IframeConfig, InitialHistory, Label, Metadata, OnAction, Overrides, Permissions, Plugin, Puck, PuckAction, type PuckApi, Render, ResolveDataTrigger, RootData, RootDataWithProps, UiState, type UsePuckData, UserGenerics, Viewports, createUsePuck, mapSlotsPublic as mapSlots, migrate, renderContext, usePuck };
+export { Action, ActionBar, AppState, AutoField, Button, ComponentConfig, ComponentData, Config, Data, Drawer, DropZone, Field, FieldLabel, FieldProps, Fields, Group, History, IconButton, IframeConfig, InitialHistory, Label, Metadata, OnAction, Overrides, Permissions, Plugin, Puck, PuckAction, type PuckApi, Render, ResolveDataTrigger, RootDataWithProps, UiState, type UsePuckData, UserGenerics, Viewports, createUsePuck, migrate, renderContext, usePuck };