@measured/puck 0.21.0-canary.16a3eee1 → 0.21.0-canary.17395b2c

package/dist/chunk-72SA22GI.mjs

@@ -0,0 +1,134 @@
+import {
+  mapFields
+} from "./chunk-NLUHDYVR.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-CSSRLPHM.mjs

@@ -0,0 +1,11 @@
+import {
+  init_react_import
+} from "./chunk-M6W7YEVX.mjs";
+
+// css-module:/home/runner/work/puck/puck/packages/core/components/RichTextEditor/styles.module.css#css-module
+init_react_import();
+var styles_module_default = { "RichTextEditor": "_RichTextEditor_1elol_1", "RichTextEditor--editor": "_RichTextEditor--editor_1elol_50", "RichTextEditor--disabled": "_RichTextEditor--disabled_1elol_106", "RichTextEditor--isActive": "_RichTextEditor--isActive_1elol_110", "RichTextEditor-menu": "_RichTextEditor-menu_1elol_116" };
+
+export {
+  styles_module_default
+};

package/dist/chunk-M4QBB3JM.mjs

@@ -0,0 +1,111 @@
+import {
+  styles_module_default
+} from "./chunk-CSSRLPHM.mjs";
+import {
+  LoadedRichTextMenuInner
+} from "./chunk-V7333LON.mjs";
+import {
+  useAppStore,
+  useAppStoreApi
+} from "./chunk-UUOBSXZR.mjs";
+import {
+  get_class_name_factory_default
+} from "./chunk-Y2EFNT5P.mjs";
+import {
+  __spreadValues,
+  init_react_import
+} from "./chunk-M6W7YEVX.mjs";
+
+// components/RichTextEditor/components/EditorInner.tsx
+init_react_import();
+import {
+  memo,
+  useCallback
+} from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var getClassName = get_class_name_factory_default("RichTextEditor", styles_module_default);
+var EditorInner = memo(
+  ({
+    children,
+    menu,
+    readOnly = false,
+    field,
+    inline = false,
+    editor,
+    id
+  }) => {
+    const { initialHeight } = field;
+    const isActive = useAppStore(
+      (s) => {
+        var _a;
+        return ((_a = s.currentRichText) == null ? void 0 : _a.id) === id && inline === s.currentRichText.inline;
+      }
+    );
+    const appStoreApi = useAppStoreApi();
+    const handleHotkeyCapture = useCallback(
+      (event) => {
+        var _a, _b;
+        if ((event.metaKey || event.ctrlKey) && event.key.toLowerCase() === "i") {
+          event.stopPropagation();
+          event.preventDefault();
+          (_b = editor == null ? void 0 : (_a = editor.commands).toggleItalic) == null ? void 0 : _b.call(_a);
+        }
+      },
+      [editor]
+    );
+    const handleBlur = useCallback(
+      (e) => {
+        var _a, _b;
+        const targetInMenu = !!((_b = (_a = e.relatedTarget) == null ? void 0 : _a.closest) == null ? void 0 : _b.call(
+          _a,
+          "[data-puck-rte-menu]"
+        ));
+        if (e.relatedTarget && !targetInMenu) {
+          appStoreApi.setState({
+            currentRichText: null
+          });
+        } else {
+          e.stopPropagation();
+        }
+      },
+      [appStoreApi]
+    );
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: getClassName({
+          editor: !inline,
+          inline,
+          isActive,
+          disabled: readOnly
+        }),
+        style: inline ? {} : { height: initialHeight != null ? initialHeight : 192, overflowY: "auto" },
+        onKeyDownCapture: handleHotkeyCapture,
+        onBlur: handleBlur,
+        children: [
+          !inline && /* @__PURE__ */ jsx("div", { className: getClassName("menu"), children: menu }),
+          children
+        ]
+      }
+    );
+  }
+);
+EditorInner.displayName = "EditorInner";
+
+// components/RichTextMenu/index.tsx
+init_react_import();
+import { lazy, Suspense } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var LoadedRichTextMenuFull = lazy(
+  () => import("./full-GZ4L3XCF.mjs").then((m) => ({
+    default: m.LoadedRichTextMenuFull
+  }))
+);
+var LoadedRichTextMenu = (props) => {
+  return /* @__PURE__ */ jsx2(Suspense, { fallback: /* @__PURE__ */ jsx2(LoadedRichTextMenuInner, __spreadValues({}, props)), children: /* @__PURE__ */ jsx2(LoadedRichTextMenuFull, __spreadValues({}, props)) });
+};
+
+export {
+  EditorInner,
+  LoadedRichTextMenu
+};

package/dist/chunk-M6W7YEVX.mjs

@@ -0,0 +1,95 @@
+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";
+  }
+});
+
+export {
+  __spreadValues,
+  __spreadProps,
+  __objRest,
+  __commonJS,
+  __toESM,
+  __async,
+  init_react_import
+};

package/dist/chunk-MLTVJA2A.mjs

@@ -0,0 +1,63 @@
+import {
+  Heading1,
+  Heading2,
+  Heading3,
+  Heading4,
+  Heading5,
+  Heading6
+} from "./chunk-UUOBSXZR.mjs";
+import {
+  init_react_import
+} from "./chunk-M6W7YEVX.mjs";
+
+// components/RichTextMenu/controls/HeadingSelect/use-options.ts
+init_react_import();
+import { useMemo } from "react";
+var optionNodes = {
+  h1: { label: "Heading 1", icon: Heading1 },
+  h2: { label: "Heading 2", icon: Heading2 },
+  h3: { label: "Heading 3", icon: Heading3 },
+  h4: { label: "Heading 4", icon: Heading4 },
+  h5: { label: "Heading 5", icon: Heading5 },
+  h6: { label: "Heading 6", icon: Heading6 }
+};
+var useHeadingOptions = (fieldOptions) => {
+  var _a;
+  let blockOptions = [];
+  if ((fieldOptions == null ? void 0 : fieldOptions.heading) !== false) {
+    if (!((_a = fieldOptions == null ? void 0 : fieldOptions.heading) == null ? void 0 : _a.levels)) {
+      blockOptions = ["h1", "h2", "h3", "h4", "h5", "h6"];
+    } else {
+      if (fieldOptions == null ? void 0 : fieldOptions.heading.levels.includes(1)) {
+        blockOptions.push("h1");
+      }
+      if (fieldOptions == null ? void 0 : fieldOptions.heading.levels.includes(2)) {
+        blockOptions.push("h2");
+      }
+      if (fieldOptions == null ? void 0 : fieldOptions.heading.levels.includes(3)) {
+        blockOptions.push("h3");
+      }
+      if (fieldOptions == null ? void 0 : fieldOptions.heading.levels.includes(4)) {
+        blockOptions.push("h4");
+      }
+      if (fieldOptions == null ? void 0 : fieldOptions.heading.levels.includes(5)) {
+        blockOptions.push("h5");
+      }
+      if (fieldOptions == null ? void 0 : fieldOptions.heading.levels.includes(6)) {
+        blockOptions.push("h6");
+      }
+    }
+  }
+  return useMemo(
+    () => blockOptions.map((item) => ({
+      value: item,
+      label: optionNodes[item].label,
+      icon: optionNodes[item].icon
+    })),
+    [blockOptions]
+  );
+};
+
+export {
+  useHeadingOptions
+};