@measured/puck 0.21.0-canary.cf074bc6 → 0.21.0-canary.d5f934f0

package/dist/chunk-ODDSBBX3.mjs

@@ -0,0 +1,435 @@
+import {
+  __spreadProps,
+  __spreadValues,
+  init_react_import
+} from "./chunk-M6W7YEVX.mjs";
+
+// lib/data/walk-tree.ts
+init_react_import();
+
+// lib/data/map-fields.ts
+init_react_import();
+
+// lib/data/default-slots.ts
+init_react_import();
+var defaultSlots = (value, fields) => Object.keys(fields).reduce(
+  (acc, fieldName) => fields[fieldName].type === "slot" ? __spreadValues({ [fieldName]: [] }, acc) : acc,
+  value
+);
+
+// lib/data/map-fields.ts
+var isPromise = (v) => !!v && typeof v.then === "function";
+var flatten = (values) => values.reduce((acc, item) => __spreadValues(__spreadValues({}, acc), item), {});
+var containsPromise = (arr) => arr.some(isPromise);
+var walkField = ({
+  value,
+  fields,
+  mappers,
+  propKey = "",
+  propPath = "",
+  id = "",
+  config,
+  recurseSlots = false
+}) => {
+  var _a, _b, _c;
+  const fieldType = (_a = fields[propKey]) == null ? void 0 : _a.type;
+  const map = mappers[fieldType];
+  if (map && fieldType === "slot") {
+    const content = value || [];
+    const mappedContent = recurseSlots ? content.map((el) => {
+      var _a2;
+      const componentConfig = config.components[el.type];
+      if (!componentConfig) {
+        throw new Error(`Could not find component config for ${el.type}`);
+      }
+      const fields2 = (_a2 = componentConfig.fields) != null ? _a2 : {};
+      return walkField({
+        value: __spreadProps(__spreadValues({}, el), { props: defaultSlots(el.props, fields2) }),
+        fields: fields2,
+        mappers,
+        id: el.props.id,
+        config,
+        recurseSlots
+      });
+    }) : content;
+    if (containsPromise(mappedContent)) {
+      return Promise.all(mappedContent);
+    }
+    return map({
+      value: mappedContent,
+      parentId: id,
+      propName: propPath,
+      field: fields[propKey],
+      propPath
+    });
+  } else if (map && fields[propKey]) {
+    return map({
+      value,
+      parentId: id,
+      propName: propKey,
+      field: fields[propKey],
+      propPath
+    });
+  }
+  if (value && typeof value === "object") {
+    if (Array.isArray(value)) {
+      const arrayFields = ((_b = fields[propKey]) == null ? void 0 : _b.type) === "array" ? fields[propKey].arrayFields : null;
+      if (!arrayFields) return value;
+      const newValue = value.map(
+        (el, idx) => walkField({
+          value: el,
+          fields: arrayFields,
+          mappers,
+          propKey,
+          propPath: `${propPath}[${idx}]`,
+          id,
+          config,
+          recurseSlots
+        })
+      );
+      if (containsPromise(newValue)) {
+        return Promise.all(newValue);
+      }
+      return newValue;
+    } else if ("$$typeof" in value) {
+      return value;
+    } else {
+      const objectFields = ((_c = fields[propKey]) == null ? void 0 : _c.type) === "object" ? fields[propKey].objectFields : fields;
+      return walkObject({
+        value,
+        fields: objectFields,
+        mappers,
+        id,
+        getPropPath: (k) => `${propPath}.${k}`,
+        config,
+        recurseSlots
+      });
+    }
+  }
+  return value;
+};
+var walkObject = ({
+  value,
+  fields,
+  mappers,
+  id,
+  getPropPath,
+  config,
+  recurseSlots
+}) => {
+  const newProps = Object.entries(value).map(([k, v]) => {
+    const opts = {
+      value: v,
+      fields,
+      mappers,
+      propKey: k,
+      propPath: getPropPath(k),
+      id,
+      config,
+      recurseSlots
+    };
+    const newValue = walkField(opts);
+    if (isPromise(newValue)) {
+      return newValue.then((resolvedValue) => ({
+        [k]: resolvedValue
+      }));
+    }
+    return {
+      [k]: newValue
+    };
+  }, {});
+  if (containsPromise(newProps)) {
+    return Promise.all(newProps).then(flatten);
+  }
+  return flatten(newProps);
+};
+function mapFields(item, mappers, config, recurseSlots = false) {
+  var _a, _b, _c, _d, _e;
+  const itemType = "type" in item ? item.type : "root";
+  const componentConfig = itemType === "root" ? config.root : (_a = config.components) == null ? void 0 : _a[itemType];
+  const newProps = walkObject({
+    value: defaultSlots((_b = item.props) != null ? _b : {}, (_c = componentConfig == null ? void 0 : componentConfig.fields) != null ? _c : {}),
+    fields: (_d = componentConfig == null ? void 0 : componentConfig.fields) != null ? _d : {},
+    mappers,
+    id: item.props ? (_e = item.props.id) != null ? _e : "root" : "root",
+    getPropPath: (k) => k,
+    config,
+    recurseSlots
+  });
+  if (isPromise(newProps)) {
+    return newProps.then((resolvedProps) => __spreadProps(__spreadValues({}, item), {
+      props: resolvedProps
+    }));
+  }
+  return __spreadProps(__spreadValues({}, item), {
+    props: newProps
+  });
+}
+
+// lib/data/walk-tree.ts
+function walkTree(data, config, callbackFn) {
+  var _a, _b;
+  const walkItem = (item) => {
+    return mapFields(
+      item,
+      {
+        slot: ({ value, parentId, propName }) => {
+          var _a2;
+          const content = value;
+          return (_a2 = callbackFn(content, { parentId, propName })) != null ? _a2 : content;
+        }
+      },
+      config,
+      true
+    );
+  };
+  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)
+      }),
+      {}
+    )
+  };
+}
+
+// lib/root-droppable-id.ts
+init_react_import();
+var rootAreaId = "root";
+var rootZone = "default-zone";
+var rootDroppableId = `${rootAreaId}:${rootZone}`;
+
+// lib/data/flatten-node.ts
+init_react_import();
+import flat from "flat";
+
+// lib/data/strip-slots.ts
+init_react_import();
+var stripSlots = (data, config) => {
+  return mapFields(data, { slot: () => null }, config);
+};
+
+// lib/data/flatten-node.ts
+var { flatten: flatten2, unflatten } = flat;
+function isEmptyArrayOrObject(val) {
+  if (Array.isArray(val)) {
+    return val.length === 0;
+  }
+  if (val != null && Object.prototype.toString.call(val) === "[object Object]") {
+    return Object.keys(val).length === 0;
+  }
+  return false;
+}
+function stripEmptyObjects(props) {
+  const result = {};
+  for (const key in props) {
+    if (!Object.prototype.hasOwnProperty.call(props, key)) continue;
+    const val = props[key];
+    if (isEmptyArrayOrObject(val)) continue;
+    result[key] = val;
+  }
+  return result;
+}
+var flattenNode = (node, config) => {
+  return __spreadProps(__spreadValues({}, node), {
+    props: stripEmptyObjects(flatten2(stripSlots(node, config).props))
+  });
+};
+var expandNode = (node) => {
+  const props = unflatten(node.props);
+  return __spreadProps(__spreadValues({}, node), {
+    props
+  });
+};
+
+// lib/data/walk-app-state.ts
+init_react_import();
+
+// lib/data/for-related-zones.ts
+init_react_import();
+
+// 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];
+};
+
+// lib/data/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) {
+      cb(path, zoneCompound, content);
+    }
+  });
+}
+
+// lib/data/walk-app-state.ts
+function walkAppState(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;
+    const newProps = __spreadProps(__spreadValues({}, mapFields(
+      mappedItem,
+      {
+        slot: ({ value, parentId: parentId2, propPath }) => {
+          const content = value;
+          const zoneCompound = `${parentId2}:${propPath}`;
+          const [_2, newContent2] = processContent(
+            path,
+            zoneCompound,
+            content,
+            "slot",
+            parentId2
+          );
+          return newContent2;
+        }
+      },
+      config
+    ).props), {
+      id
+    });
+    processRelatedZones(item, id, path);
+    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: flattenNode(newItem, config),
+      path,
+      parentId,
+      zone
+    };
+    const finalData = __spreadProps(__spreadValues({}, newItem), { props: __spreadValues({}, newItem.props) });
+    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;
+  const zonesAlreadyProcessed = Object.keys(newZones);
+  Object.keys(zones || {}).forEach((zoneCompound) => {
+    const [parentId] = zoneCompound.split(":");
+    if (zonesAlreadyProcessed.includes(zoneCompound)) {
+      return;
+    }
+    const [_2, newContent2] = processContent(
+      [rootDroppableId],
+      zoneCompound,
+      zones[zoneCompound],
+      "dropzone",
+      parentId
+    );
+    newZones[zoneCompound] = newContent2;
+  }, newZones);
+  const processedRoot = processItem(
+    {
+      type: "root",
+      props: __spreadProps(__spreadValues({}, (_a = state.data.root.props) != null ? _a : state.data.root), { id: "root" })
+    },
+    [],
+    -1
+  );
+  const root = __spreadProps(__spreadValues({}, state.data.root), {
+    props: processedRoot.props
+  });
+  return __spreadProps(__spreadValues({}, state), {
+    data: {
+      root,
+      content: processedContent,
+      zones: __spreadValues(__spreadValues({}, state.data.zones), newZones)
+    },
+    indexes: {
+      nodes: __spreadValues(__spreadValues({}, state.indexes.nodes), newNodeIndex),
+      zones: __spreadValues(__spreadValues({}, state.indexes.zones), newZoneIndex)
+    }
+  });
+}
+
+// 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;
+};
+
+export {
+  rootAreaId,
+  rootZone,
+  rootDroppableId,
+  defaultSlots,
+  walkField,
+  mapFields,
+  expandNode,
+  walkAppState,
+  walkTree,
+  setupZone
+};

package/dist/chunk-PRRLVCLF.mjs

@@ -0,0 +1,33 @@
+import {
+  List,
+  ListOrdered
+} from "./chunk-IDHXWXYL.mjs";
+import {
+  init_react_import
+} from "./chunk-M6W7YEVX.mjs";
+
+// components/RichTextMenu/controls/ListSelect/use-options.ts
+init_react_import();
+import { useMemo } from "react";
+var optionNodes = {
+  ul: { label: "Bullet list", icon: List },
+  ol: { label: "Numbered list", icon: ListOrdered }
+};
+var useListOptions = (fieldOptions) => {
+  let blockOptions = [];
+  if ((fieldOptions == null ? void 0 : fieldOptions.listItem) !== false) {
+    blockOptions = ["ul", "ol"];
+  }
+  return useMemo(
+    () => blockOptions.map((item) => ({
+      value: item,
+      label: optionNodes[item].label,
+      icon: optionNodes[item].icon
+    })),
+    [blockOptions]
+  );
+};
+
+export {
+  useListOptions
+};

package/dist/chunk-QV3IXRNS.mjs

@@ -0,0 +1,134 @@
+import {
+  mapFields
+} from "./chunk-ODDSBBX3.mjs";
+import {
+  __async,
+  __spreadProps,
+  __spreadValues,
+  init_react_import
+} from "./chunk-M6W7YEVX.mjs";
+
+// 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" },
+  { width: "100%", height: "auto", icon: "FullWidth", label: "Full-width" }
+];
+
+// lib/resolve-component-data.ts
+init_react_import();
+
+// lib/get-changed.ts
+init_react_import();
+import { deepEqual } from "fast-equals";
+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]: !deepEqual(oldItemProps[item], newItemProps[item])
+    });
+  }, {}) : {};
+};
+
+// lib/resolve-component-data.ts
+import { deepEqual as deepEqual2 } from "fast-equals";
+var cache = { lastChange: {} };
+var resolveComponentData = (_0, _1, ..._2) => __async(null, [_0, _1, ..._2], function* (item, config, metadata = {}, onResolveStart, onResolveEnd, trigger = "replace") {
+  const configForItem = "type" in item && item.type !== "root" ? config.components[item.type] : config.root;
+  const resolvedItem = __spreadValues({}, item);
+  const shouldRunResolver = (configForItem == null ? void 0 : configForItem.resolveData) && item.props;
+  const id = "id" in item.props ? item.props.id : "root";
+  if (shouldRunResolver) {
+    const { item: oldItem = null, resolved = {} } = cache.lastChange[id] || {};
+    if (trigger !== "force" && item && deepEqual2(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
+    });
+    resolvedItem.props = __spreadValues(__spreadValues({}, item.props), resolvedProps);
+    if (Object.keys(readOnly).length) {
+      resolvedItem.readOnly = readOnly;
+    }
+  }
+  let itemWithResolvedChildren = yield mapFields(
+    resolvedItem,
+    {
+      slot: (_02) => __async(null, [_02], function* ({ value }) {
+        const content = value;
+        return yield Promise.all(
+          content.map(
+            (childItem) => __async(null, null, function* () {
+              return (yield resolveComponentData(
+                childItem,
+                config,
+                metadata,
+                onResolveStart,
+                onResolveEnd,
+                trigger
+              )).node;
+            })
+          )
+        );
+      })
+    },
+    config
+  );
+  if (shouldRunResolver && onResolveEnd) {
+    onResolveEnd(resolvedItem);
+  }
+  cache.lastChange[id] = {
+    item,
+    resolved: itemWithResolvedChildren
+  };
+  return {
+    node: itemWithResolvedChildren,
+    didChange: !deepEqual2(item, itemWithResolvedChildren)
+  };
+});
+
+// store/default-app-state.ts
+init_react_import();
+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 },
+    plugin: { current: null }
+  },
+  indexes: {
+    nodes: {},
+    zones: {}
+  }
+};
+
+export {
+  defaultViewports,
+  getChanged,
+  resolveComponentData,
+  defaultAppState
+};

package/dist/chunk-V5I7CVLT.mjs

@@ -0,0 +1,103 @@
+import {
+  __spreadValues,
+  init_react_import
+} from "./chunk-M6W7YEVX.mjs";
+
+// components/RichTextEditor/extension.ts
+init_react_import();
+import { Extension } from "@tiptap/core";
+import { Blockquote } from "@tiptap/extension-blockquote";
+import { Bold } from "@tiptap/extension-bold";
+import { Code } from "@tiptap/extension-code";
+import { CodeBlock } from "@tiptap/extension-code-block";
+import { Document } from "@tiptap/extension-document";
+import { HardBreak } from "@tiptap/extension-hard-break";
+import { Heading } from "@tiptap/extension-heading";
+import { HorizontalRule } from "@tiptap/extension-horizontal-rule";
+import { Italic } from "@tiptap/extension-italic";
+import { Link } from "@tiptap/extension-link";
+import {
+  BulletList,
+  ListItem,
+  ListKeymap,
+  OrderedList
+} from "@tiptap/extension-list";
+import { Paragraph } from "@tiptap/extension-paragraph";
+import { Strike } from "@tiptap/extension-strike";
+import { Text } from "@tiptap/extension-text";
+import TextAlign from "@tiptap/extension-text-align";
+import { Underline } from "@tiptap/extension-underline";
+var defaultPuckRichTextOptions = {
+  textAlign: {
+    types: ["heading", "paragraph"]
+  }
+};
+var PuckRichText = Extension.create({
+  name: "puckRichText",
+  addExtensions() {
+    const extensions = [];
+    const options = __spreadValues(__spreadValues({}, this.options), defaultPuckRichTextOptions);
+    if (options.bold !== false) {
+      extensions.push(Bold.configure(options.bold));
+    }
+    if (options.blockquote !== false) {
+      extensions.push(Blockquote.configure(options.blockquote));
+    }
+    if (options.bulletList !== false) {
+      extensions.push(BulletList.configure(options.bulletList));
+    }
+    if (options.code !== false) {
+      extensions.push(Code.configure(options.code));
+    }
+    if (options.codeBlock !== false) {
+      extensions.push(CodeBlock.configure(options.codeBlock));
+    }
+    if (options.document !== false) {
+      extensions.push(Document.configure(options.document));
+    }
+    if (options.hardBreak !== false) {
+      extensions.push(HardBreak.configure(options.hardBreak));
+    }
+    if (options.heading !== false) {
+      extensions.push(Heading.configure(options.heading));
+    }
+    if (options.horizontalRule !== false) {
+      extensions.push(HorizontalRule.configure(options.horizontalRule));
+    }
+    if (options.italic !== false) {
+      extensions.push(Italic.configure(options.italic));
+    }
+    if (options.listItem !== false) {
+      extensions.push(ListItem.configure(options.listItem));
+    }
+    if (options.listKeymap !== false) {
+      extensions.push(ListKeymap.configure(options == null ? void 0 : options.listKeymap));
+    }
+    if (options.link !== false) {
+      extensions.push(Link.configure(options == null ? void 0 : options.link));
+    }
+    if (options.orderedList !== false) {
+      extensions.push(OrderedList.configure(options.orderedList));
+    }
+    if (options.paragraph !== false) {
+      extensions.push(Paragraph.configure(options.paragraph));
+    }
+    if (options.strike !== false) {
+      extensions.push(Strike.configure(options.strike));
+    }
+    if (options.text !== false) {
+      extensions.push(Text.configure(options.text));
+    }
+    if (options.textAlign !== false) {
+      extensions.push(TextAlign.configure(options.textAlign));
+    }
+    if (options.underline !== false) {
+      extensions.push(Underline.configure(options == null ? void 0 : options.underline));
+    }
+    return extensions;
+  }
+});
+
+export {
+  PuckRichText
+};