payload 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/admin/components/views/LivePreview/PreviewContext/collisionDetection.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "customCollisionDetection", {
+    enumerable: true,
+    get: function() {
+        return customCollisionDetection;
+    }
+});
+const _core = require("@dnd-kit/core");
+const customCollisionDetection = ({ collisionRect, droppableContainers, ...args })=>{
+    const droppableContainer = droppableContainers.find(({ id })=>id === 'live-preview-area');
+    const rectIntersectionCollisions = (0, _core.rectIntersection)({
+        ...args,
+        collisionRect,
+        droppableContainers: [
+            droppableContainer
+        ]
+    });
+    // Collision detection algorithms return an array of collisions
+    if (rectIntersectionCollisions.length === 0) {
+        // The preview area is not intersecting, return early
+        return rectIntersectionCollisions;
+    }
+    // Compute whether the draggable element is completely contained within the preview area
+    const previewAreaRect = droppableContainer?.rect?.current;
+    const isContained = collisionRect.top >= previewAreaRect.top && collisionRect.left >= previewAreaRect.left && collisionRect.bottom <= previewAreaRect.bottom && collisionRect.right <= previewAreaRect.right;
+    if (isContained) {
+        return rectIntersectionCollisions;
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/admin/components/views/LivePreview/PreviewContext/context.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    LivePreviewContext: function() {
+        return LivePreviewContext;
+    },
+    useLivePreviewContext: function() {
+        return useLivePreviewContext;
+    }
+});
+const _react = require("react");
+const LivePreviewContext = (0, _react.createContext)({
+    breakpoint: undefined,
+    breakpoints: undefined,
+    deviceFrameRef: undefined,
+    iframeHasLoaded: false,
+    iframeRef: undefined,
+    setBreakpoint: ()=>{},
+    setHeight: ()=>{},
+    setIframeHasLoaded: ()=>{},
+    setSize: ()=>{},
+    setToolbarPosition: ()=>{},
+    setWidth: ()=>{},
+    setZoom: ()=>{},
+    size: {
+        height: 0,
+        width: 0
+    },
+    toolbarPosition: {
+        x: 0,
+        y: 0
+    },
+    zoom: 1
+});
+const useLivePreviewContext = ()=>(0, _react.useContext)(LivePreviewContext);
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/admin/components/views/LivePreview/PreviewContext/index.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LivePreviewProvider", {
+    enumerable: true,
+    get: function() {
+        return LivePreviewProvider;
+    }
+});
+const _core = require("@dnd-kit/core");
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _useResize = require("../../../../utilities/useResize");
+const _collisionDetection = require("./collisionDetection");
+const _context = require("./context");
+const _sizeReducer = require("./sizeReducer");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const LivePreviewProvider = (props)=>{
+    const { breakpoints, children } = props;
+    const iframeRef = _react.default.useRef(null);
+    const deviceFrameRef = _react.default.useRef(null);
+    const [iframeHasLoaded, setIframeHasLoaded] = _react.default.useState(false);
+    const [zoom, setZoom] = _react.default.useState(1);
+    const [position, setPosition] = _react.default.useState({
+        x: 0,
+        y: 0
+    });
+    const [size, setSize] = _react.default.useReducer(_sizeReducer.sizeReducer, {
+        height: 0,
+        width: 0
+    });
+    const [breakpoint, setBreakpoint] = _react.default.useState('responsive');
+    const foundBreakpoint = breakpoint && breakpoints.find((bp)=>bp.name === breakpoint);
+    let margin = '0';
+    if (foundBreakpoint && breakpoint !== 'responsive') {
+        margin = '0 auto';
+        if (typeof zoom === 'number' && typeof foundBreakpoint.width === 'number' && typeof foundBreakpoint.height === 'number') {
+            // keep it centered horizontally
+            margin = `0 ${foundBreakpoint.width / 2 / zoom}px`;
+        }
+    }
+    // The toolbar needs to freely drag and drop around the page
+    const handleDragEnd = (ev)=>{
+        // only update position if the toolbar is completely within the preview area
+        // otherwise reset it back to the previous position
+        // TODO: reset to the nearest edge of the preview area
+        if (ev.over && ev.over.id === 'live-preview-area') {
+            const newPos = {
+                x: position.x + ev.delta.x,
+                y: position.y + ev.delta.y
+            };
+            setPosition(newPos);
+        } else {
+        // reset
+        }
+    };
+    const setWidth = (0, _react.useCallback)((width)=>{
+        setSize({
+            type: 'width',
+            value: width
+        });
+    }, [
+        setSize
+    ]);
+    const setHeight = (0, _react.useCallback)((height)=>{
+        setSize({
+            type: 'height',
+            value: height
+        });
+    }, [
+        setSize
+    ]);
+    const { size: actualDeviceSize } = (0, _useResize.useResize)(deviceFrameRef);
+    (0, _react.useEffect)(()=>{
+        if (actualDeviceSize) {
+            setSize({
+                type: 'reset',
+                value: {
+                    height: Number(actualDeviceSize.height.toFixed(0)),
+                    width: Number(actualDeviceSize.width.toFixed(0))
+                }
+            });
+        }
+    }, [
+        actualDeviceSize
+    ]);
+    return /*#__PURE__*/ _react.default.createElement(_context.LivePreviewContext.Provider, {
+        value: {
+            breakpoint,
+            breakpoints,
+            deviceFrameRef,
+            iframeHasLoaded,
+            iframeRef,
+            setBreakpoint,
+            setHeight,
+            setIframeHasLoaded,
+            setSize,
+            setToolbarPosition: setPosition,
+            setWidth,
+            setZoom,
+            size,
+            toolbarPosition: position,
+            zoom
+        }
+    }, /*#__PURE__*/ _react.default.createElement(_core.DndContext, {
+        collisionDetection: _collisionDetection.customCollisionDetection,
+        onDragEnd: handleDragEnd
+    }, children));
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/admin/components/views/LivePreview/PreviewContext/index.tsx"],"sourcesContent":["import { DndContext } from '@dnd-kit/core'\nimport React, { useCallback, useEffect } from 'react'\n\nimport type { LivePreview } from '../../../../../exports/config'\nimport type { EditViewProps } from '../../types'\nimport type { usePopupWindow } from '../usePopupWindow'\n\nimport { useResize } from '../../../../utilities/useResize'\nimport { customCollisionDetection } from './collisionDetection'\nimport { LivePreviewContext } from './context'\nimport { sizeReducer } from './sizeReducer'\n\nexport type ToolbarProviderProps = EditViewProps & {\n  breakpoints?: LivePreview['breakpoints']\n  children: React.ReactNode\n  deviceSize?: {\n    height: number\n    width: number\n  }\n  popupState: ReturnType<typeof usePopupWindow>\n  url?: string\n}\n\nexport const LivePreviewProvider: React.FC<ToolbarProviderProps> = (props) => {\n  const { breakpoints, children } = props\n\n  const iframeRef = React.useRef<HTMLIFrameElement>(null)\n\n  const deviceFrameRef = React.useRef<HTMLDivElement>(null)\n\n  const [iframeHasLoaded, setIframeHasLoaded] = React.useState(false)\n\n  const [zoom, setZoom] = React.useState(1)\n\n  const [position, setPosition] = React.useState({ x: 0, y: 0 })\n\n  const [size, setSize] = React.useReducer(sizeReducer, { height: 0, width: 0 })\n\n  const [breakpoint, setBreakpoint] =\n    React.useState<LivePreview['breakpoints'][0]['name']>('responsive')\n\n  const foundBreakpoint = breakpoint && breakpoints.find((bp) => bp.name === breakpoint)\n\n  let margin = '0'\n\n  if (foundBreakpoint && breakpoint !== 'responsive') {\n    margin = '0 auto'\n\n    if (\n      typeof zoom === 'number' &&\n      typeof foundBreakpoint.width === 'number' &&\n      typeof foundBreakpoint.height === 'number'\n    ) {\n      // keep it centered horizontally\n      margin = `0 ${foundBreakpoint.width / 2 / zoom}px`\n    }\n  }\n\n  // The toolbar needs to freely drag and drop around the page\n  const handleDragEnd = (ev) => {\n    // only update position if the toolbar is completely within the preview area\n    // otherwise reset it back to the previous position\n    // TODO: reset to the nearest edge of the preview area\n    if (ev.over && ev.over.id === 'live-preview-area') {\n      const newPos = {\n        x: position.x + ev.delta.x,\n        y: position.y + ev.delta.y,\n      }\n\n      setPosition(newPos)\n    } else {\n      // reset\n    }\n  }\n\n  const setWidth = useCallback(\n    (width) => {\n      setSize({ type: 'width', value: width })\n    },\n    [setSize],\n  )\n\n  const setHeight = useCallback(\n    (height) => {\n      setSize({ type: 'height', value: height })\n    },\n    [setSize],\n  )\n\n  const { size: actualDeviceSize } = useResize(deviceFrameRef)\n\n  useEffect(() => {\n    if (actualDeviceSize) {\n      setSize({\n        type: 'reset',\n        value: {\n          height: Number(actualDeviceSize.height.toFixed(0)),\n          width: Number(actualDeviceSize.width.toFixed(0)),\n        },\n      })\n    }\n  }, [actualDeviceSize])\n\n  return (\n    <LivePreviewContext.Provider\n      value={{\n        breakpoint,\n        breakpoints,\n        deviceFrameRef,\n        iframeHasLoaded,\n        iframeRef,\n        setBreakpoint,\n        setHeight,\n        setIframeHasLoaded,\n        setSize,\n        setToolbarPosition: setPosition,\n        setWidth,\n        setZoom,\n        size,\n        toolbarPosition: position,\n        zoom,\n      }}\n    >\n      <DndContext collisionDetection={customCollisionDetection} onDragEnd={handleDragEnd}>\n        {children}\n      </DndContext>\n    </LivePreviewContext.Provider>\n  )\n}\n"],"names":["LivePreviewProvider","props","breakpoints","children","iframeRef","React","useRef","deviceFrameRef","iframeHasLoaded","setIframeHasLoaded","useState","zoom","setZoom","position","setPosition","x","y","size","setSize","useReducer","sizeReducer","height","width","breakpoint","setBreakpoint","foundBreakpoint","find","bp","name","margin","handleDragEnd","ev","over","id","newPos","delta","setWidth","useCallback","type","value","setHeight","actualDeviceSize","useResize","useEffect","Number","toFixed","LivePreviewContext","Provider","setToolbarPosition","toolbarPosition","DndContext","collisionDetection","customCollisionDetection","onDragEnd"],"mappings":";;;;+BAuBaA;;;eAAAA;;;sBAvBc;+DACmB;2BAMpB;oCACe;yBACN;6BACP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAarB,MAAMA,sBAAsD,CAACC;IAClE,MAAM,EAAEC,WAAW,EAAEC,QAAQ,EAAE,GAAGF;IAElC,MAAMG,YAAYC,cAAK,CAACC,MAAM,CAAoB;IAElD,MAAMC,iBAAiBF,cAAK,CAACC,MAAM,CAAiB;IAEpD,MAAM,CAACE,iBAAiBC,mBAAmB,GAAGJ,cAAK,CAACK,QAAQ,CAAC;IAE7D,MAAM,CAACC,MAAMC,QAAQ,GAAGP,cAAK,CAACK,QAAQ,CAAC;IAEvC,MAAM,CAACG,UAAUC,YAAY,GAAGT,cAAK,CAACK,QAAQ,CAAC;QAAEK,GAAG;QAAGC,GAAG;IAAE;IAE5D,MAAM,CAACC,MAAMC,QAAQ,GAAGb,cAAK,CAACc,UAAU,CAACC,wBAAW,EAAE;QAAEC,QAAQ;QAAGC,OAAO;IAAE;IAE5E,MAAM,CAACC,YAAYC,cAAc,GAC/BnB,cAAK,CAACK,QAAQ,CAAwC;IAExD,MAAMe,kBAAkBF,cAAcrB,YAAYwB,IAAI,CAAC,CAACC,KAAOA,GAAGC,IAAI,KAAKL;IAE3E,IAAIM,SAAS;IAEb,IAAIJ,mBAAmBF,eAAe,cAAc;QAClDM,SAAS;QAET,IACE,OAAOlB,SAAS,YAChB,OAAOc,gBAAgBH,KAAK,KAAK,YACjC,OAAOG,gBAAgBJ,MAAM,KAAK,UAClC;YACA,gCAAgC;YAChCQ,SAAS,CAAC,EAAE,EAAEJ,gBAAgBH,KAAK,GAAG,IAAIX,KAAK,EAAE,CAAC;QACpD;IACF;IAEA,4DAA4D;IAC5D,MAAMmB,gBAAgB,CAACC;QACrB,4EAA4E;QAC5E,mDAAmD;QACnD,sDAAsD;QACtD,IAAIA,GAAGC,IAAI,IAAID,GAAGC,IAAI,CAACC,EAAE,KAAK,qBAAqB;YACjD,MAAMC,SAAS;gBACbnB,GAAGF,SAASE,CAAC,GAAGgB,GAAGI,KAAK,CAACpB,CAAC;gBAC1BC,GAAGH,SAASG,CAAC,GAAGe,GAAGI,KAAK,CAACnB,CAAC;YAC5B;YAEAF,YAAYoB;QACd,OAAO;QACL,QAAQ;QACV;IACF;IAEA,MAAME,WAAWC,IAAAA,kBAAW,EAC1B,CAACf;QACCJ,QAAQ;YAAEoB,MAAM;YAASC,OAAOjB;QAAM;IACxC,GACA;QAACJ;KAAQ;IAGX,MAAMsB,YAAYH,IAAAA,kBAAW,EAC3B,CAAChB;QACCH,QAAQ;YAAEoB,MAAM;YAAUC,OAAOlB;QAAO;IAC1C,GACA;QAACH;KAAQ;IAGX,MAAM,EAAED,MAAMwB,gBAAgB,EAAE,GAAGC,IAAAA,oBAAS,EAACnC;IAE7CoC,IAAAA,gBAAS,EAAC;QACR,IAAIF,kBAAkB;YACpBvB,QAAQ;gBACNoB,MAAM;gBACNC,OAAO;oBACLlB,QAAQuB,OAAOH,iBAAiBpB,MAAM,CAACwB,OAAO,CAAC;oBAC/CvB,OAAOsB,OAAOH,iBAAiBnB,KAAK,CAACuB,OAAO,CAAC;gBAC/C;YACF;QACF;IACF,GAAG;QAACJ;KAAiB;IAErB,qBACE,6BAACK,2BAAkB,CAACC,QAAQ;QAC1BR,OAAO;YACLhB;YACArB;YACAK;YACAC;YACAJ;YACAoB;YACAgB;YACA/B;YACAS;YACA8B,oBAAoBlC;YACpBsB;YACAxB;YACAK;YACAgC,iBAAiBpC;YACjBF;QACF;qBAEA,6BAACuC,gBAAU;QAACC,oBAAoBC,4CAAwB;QAAEC,WAAWvB;OAClE3B;AAIT"}

package/dist/admin/components/views/LivePreview/PreviewContext/sizeReducer.js

@@ -0,0 +1,41 @@
+// export const sizeReducer: (state, action) => {
+//   switch (action.type) {
+//     case 'width':
+//       return { ...state, width: action.value }
+//     case 'height':
+//       return { ...state, height: action.value }
+//     default:
+//       return { ...state, ...(action?.value || {}) }
+//   }
+// },
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "sizeReducer", {
+    enumerable: true,
+    get: function() {
+        return sizeReducer;
+    }
+});
+const sizeReducer = (state, action)=>{
+    switch(action.type){
+        case 'width':
+            return {
+                ...state,
+                width: action.value
+            };
+        case 'height':
+            return {
+                ...state,
+                height: action.value
+            };
+        default:
+            return {
+                ...state,
+                ...action?.value || {}
+            };
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/admin/components/views/LivePreview/PreviewIFrame/index.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "IFrame", {
+    enumerable: true,
+    get: function() {
+        return IFrame;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _context = require("../PreviewContext/context");
+require("./index.scss");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const baseClass = 'live-preview-iframe';
+const IFrame = /*#__PURE__*/ (0, _react.forwardRef)((props, ref)=>{
+    const { setIframeHasLoaded, url } = props;
+    const { zoom } = (0, _context.useLivePreviewContext)();
+    return /*#__PURE__*/ _react.default.createElement("iframe", {
+        className: baseClass,
+        onLoad: ()=>{
+            setIframeHasLoaded(true);
+        },
+        ref: ref,
+        src: url,
+        style: {
+            transform: typeof zoom === 'number' ? `scale(${zoom}) ` : undefined
+        },
+        title: url
+    });
+});
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9hZG1pbi9jb21wb25lbnRzL3ZpZXdzL0xpdmVQcmV2aWV3L1ByZXZpZXdJRnJhbWUvaW5kZXgudHN4Il0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBSZWFjdCwgeyBmb3J3YXJkUmVmIH0gZnJvbSAncmVhY3QnXG5cbmltcG9ydCB7IHVzZUxpdmVQcmV2aWV3Q29udGV4dCB9IGZyb20gJy4uL1ByZXZpZXdDb250ZXh0L2NvbnRleHQnXG5pbXBvcnQgJy4vaW5kZXguc2NzcydcblxuY29uc3QgYmFzZUNsYXNzID0gJ2xpdmUtcHJldmlldy1pZnJhbWUnXG5cbmV4cG9ydCBjb25zdCBJRnJhbWU6IFJlYWN0LkZDPHtcbiAgcmVmOiBSZWFjdC5SZWY8SFRNTElGcmFtZUVsZW1lbnQ+XG4gIHNldElmcmFtZUhhc0xvYWRlZDogKHZhbHVlOiBib29sZWFuKSA9PiB2b2lkXG4gIHVybDogc3RyaW5nXG59PiA9IGZvcndhcmRSZWYoKHByb3BzLCByZWYpID0+IHtcbiAgY29uc3QgeyBzZXRJZnJhbWVIYXNMb2FkZWQsIHVybCB9ID0gcHJvcHNcblxuICBjb25zdCB7IHpvb20gfSA9IHVzZUxpdmVQcmV2aWV3Q29udGV4dCgpXG5cbiAgcmV0dXJuIChcbiAgICA8aWZyYW1lXG4gICAgICBjbGFzc05hbWU9e2Jhc2VDbGFzc31cbiAgICAgIG9uTG9hZD17KCkgPT4ge1xuICAgICAgICBzZXRJZnJhbWVIYXNMb2FkZWQodHJ1ZSlcbiAgICAgIH19XG4gICAgICByZWY9e3JlZn1cbiAgICAgIHNyYz17dXJsfVxuICAgICAgc3R5bGU9e3tcbiAgICAgICAgdHJhbnNmb3JtOiB0eXBlb2Ygem9vbSA9PT0gJ251bWJlcicgPyBgc2NhbGUoJHt6b29tfSkgYCA6IHVuZGVmaW5lZCxcbiAgICAgIH19XG4gICAgICB0aXRsZT17dXJsfVxuICAgIC8+XG4gIClcbn0pXG4iXSwibmFtZXMiOlsiSUZyYW1lIiwiYmFzZUNsYXNzIiwiZm9yd2FyZFJlZiIsInByb3BzIiwicmVmIiwic2V0SWZyYW1lSGFzTG9hZGVkIiwidXJsIiwiem9vbSIsInVzZUxpdmVQcmV2aWV3Q29udGV4dCIsImlmcmFtZSIsImNsYXNzTmFtZSIsIm9uTG9hZCIsInNyYyIsInN0eWxlIiwidHJhbnNmb3JtIiwidW5kZWZpbmVkIiwidGl0bGUiXSwibWFwcGluZ3MiOiI7Ozs7K0JBT2FBOzs7ZUFBQUE7OzsrREFQcUI7eUJBRUk7UUFDL0I7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFUCxNQUFNQyxZQUFZO0FBRVgsTUFBTUQsdUJBSVJFLElBQUFBLGlCQUFVLEVBQUMsQ0FBQ0MsT0FBT0M7SUFDdEIsTUFBTSxFQUFFQyxrQkFBa0IsRUFBRUMsR0FBRyxFQUFFLEdBQUdIO0lBRXBDLE1BQU0sRUFBRUksSUFBSSxFQUFFLEdBQUdDLElBQUFBLDhCQUFxQjtJQUV0QyxxQkFDRSw2QkFBQ0M7UUFDQ0MsV0FBV1Q7UUFDWFUsUUFBUTtZQUNOTixtQkFBbUI7UUFDckI7UUFDQUQsS0FBS0E7UUFDTFEsS0FBS047UUFDTE8sT0FBTztZQUNMQyxXQUFXLE9BQU9QLFNBQVMsV0FBVyxDQUFDLE1BQU0sRUFBRUEsS0FBSyxFQUFFLENBQUMsR0FBR1E7UUFDNUQ7UUFDQUMsT0FBT1Y7O0FBR2IifQ==

package/dist/admin/components/views/LivePreview/PreviewIFrame/index.scss

@@ -0,0 +1,8 @@
+@import '../../../../scss/styles.scss';
+
+.live-preview-iframe {
+  border: 0;
+  width: 100%;
+  height: 100%;
+  transform-origin: top left;
+}

package/dist/admin/components/views/LivePreview/PreviewWindow/index.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "PreviewWindow", {
+    enumerable: true,
+    get: function() {
+        return PreviewWindow;
+    }
+});
+const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
+const _context = require("../../../forms/Form/context");
+const _reduceFieldsToValues = /*#__PURE__*/ _interop_require_default(require("../../../forms/Form/reduceFieldsToValues"));
+const _PreviewContext = require("../PreviewContext");
+const _context1 = require("../PreviewContext/context");
+const _PreviewIFrame = require("../PreviewIFrame");
+const _Toolbar = require("../Toolbar");
+const _ToolbarArea = require("../ToolbarArea");
+require("./index.scss");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const baseClass = 'live-preview-window';
+const ResponsiveWindow = (props)=>{
+    const { children } = props;
+    const { breakpoint, breakpoints, deviceFrameRef, zoom } = (0, _context1.useLivePreviewContext)();
+    const foundBreakpoint = breakpoint && breakpoints.find((bp)=>bp.name === breakpoint);
+    let x = '0';
+    if (foundBreakpoint && breakpoint !== 'responsive') {
+        x = '-50%';
+        if (typeof zoom === 'number' && typeof foundBreakpoint.width === 'number' && typeof foundBreakpoint.height === 'number') {
+            // keep it centered horizontally
+            x = `${foundBreakpoint.width / 2}px`;
+        }
+    }
+    return /*#__PURE__*/ _react.default.createElement("div", {
+        className: `${baseClass}__responsive-window`,
+        ref: deviceFrameRef,
+        style: {
+            height: foundBreakpoint && typeof foundBreakpoint?.height === 'number' ? `${foundBreakpoint?.height / (typeof zoom === 'number' ? zoom : 1)}px` : typeof zoom === 'number' ? `${100 / zoom}%` : '100%',
+            transform: `translate3d(${x}, 0, 0)`,
+            width: foundBreakpoint && typeof foundBreakpoint?.width === 'number' ? `${foundBreakpoint?.width / (typeof zoom === 'number' ? zoom : 1)}px` : typeof zoom === 'number' ? `${100 / zoom}%` : '100%'
+        }
+    }, children);
+};
+const Preview = (props)=>{
+    const { popupState: { isPopupOpen, popupHasLoaded, popupRef }, url } = props;
+    const { iframeHasLoaded, iframeRef, setIframeHasLoaded } = (0, _context1.useLivePreviewContext)();
+    const { breakpoint, toolbarPosition } = (0, _context1.useLivePreviewContext)();
+    const [fields] = (0, _context.useAllFormFields)();
+    // The preview could either be an iframe embedded on the page
+    // Or it could be a separate popup window
+    // We need to transmit data to both accordingly
+    (0, _react.useEffect)(()=>{
+        if (fields && window && 'postMessage' in window) {
+            const values = (0, _reduceFieldsToValues.default)(fields);
+            const message = JSON.stringify({
+                data: values,
+                type: 'livePreview'
+            });
+            // external window
+            if (isPopupOpen) {
+                setIframeHasLoaded(false);
+                if (popupHasLoaded && popupRef.current) {
+                    popupRef.current.postMessage(message, url);
+                }
+            }
+            // embedded iframe
+            if (!isPopupOpen) {
+                if (iframeHasLoaded && iframeRef.current) {
+                    iframeRef.current.contentWindow?.postMessage(message, url);
+                }
+            }
+        }
+    }, [
+        fields,
+        url,
+        iframeHasLoaded,
+        isPopupOpen,
+        popupRef,
+        popupHasLoaded,
+        iframeRef,
+        setIframeHasLoaded
+    ]);
+    if (!isPopupOpen) {
+        return /*#__PURE__*/ _react.default.createElement("div", {
+            className: [
+                baseClass,
+                isPopupOpen && `${baseClass}--popup-open`,
+                breakpoint && breakpoint !== 'responsive' && `${baseClass}--has-breakpoint`
+            ].filter(Boolean).join(' ')
+        }, /*#__PURE__*/ _react.default.createElement(_ToolbarArea.ToolbarArea, null, /*#__PURE__*/ _react.default.createElement("div", {
+            className: `${baseClass}__wrapper`
+        }, /*#__PURE__*/ _react.default.createElement(ResponsiveWindow, null, /*#__PURE__*/ _react.default.createElement(_PreviewIFrame.IFrame, {
+            ref: iframeRef,
+            setIframeHasLoaded: setIframeHasLoaded,
+            url: url
+        }))), /*#__PURE__*/ _react.default.createElement(_Toolbar.LivePreviewToolbar, {
+            ...props,
+            iframeRef: iframeRef,
+            style: {
+                left: `${toolbarPosition.x}px`,
+                top: `${toolbarPosition.y}px`
+            },
+            url: url
+        })));
+    }
+};
+const PreviewWindow = (props)=>{
+    let url;
+    let breakpoints = [
+        {
+            name: 'responsive',
+            height: '100%',
+            label: 'Responsive',
+            width: '100%'
+        }
+    ];
+    if ('collection' in props) {
+        url = props?.collection.admin.livePreview.url;
+        breakpoints = breakpoints.concat(props?.collection.admin.livePreview.breakpoints);
+    }
+    if ('global' in props) {
+        url = props?.global.admin.livePreview.url;
+        breakpoints = breakpoints.concat(props?.global.admin.livePreview.breakpoints);
+    }
+    return /*#__PURE__*/ _react.default.createElement(_PreviewContext.LivePreviewProvider, {
+        ...props,
+        breakpoints: breakpoints,
+        url: url
+    }, /*#__PURE__*/ _react.default.createElement(Preview, props));
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../../src/admin/components/views/LivePreview/PreviewWindow/index.tsx"],"sourcesContent":["import React, { useEffect } from 'react'\n\nimport type { LivePreview } from '../../../../../exports/config'\nimport type { EditViewProps } from '../../types'\nimport type { usePopupWindow } from '../usePopupWindow'\n\nimport { useAllFormFields } from '../../../forms/Form/context'\nimport reduceFieldsToValues from '../../../forms/Form/reduceFieldsToValues'\nimport { LivePreviewProvider } from '../PreviewContext'\nimport { useLivePreviewContext } from '../PreviewContext/context'\nimport { IFrame } from '../PreviewIFrame'\nimport { LivePreviewToolbar } from '../Toolbar'\nimport { ToolbarArea } from '../ToolbarArea'\nimport './index.scss'\n\nconst baseClass = 'live-preview-window'\n\nconst ResponsiveWindow: React.FC<{\n  children: React.ReactNode\n}> = (props) => {\n  const { children } = props\n\n  const { breakpoint, breakpoints, deviceFrameRef, zoom } = useLivePreviewContext()\n\n  const foundBreakpoint = breakpoint && breakpoints.find((bp) => bp.name === breakpoint)\n\n  let x = '0'\n\n  if (foundBreakpoint && breakpoint !== 'responsive') {\n    x = '-50%'\n\n    if (\n      typeof zoom === 'number' &&\n      typeof foundBreakpoint.width === 'number' &&\n      typeof foundBreakpoint.height === 'number'\n    ) {\n      // keep it centered horizontally\n      x = `${foundBreakpoint.width / 2}px`\n    }\n  }\n\n  return (\n    <div\n      className={`${baseClass}__responsive-window`}\n      ref={deviceFrameRef}\n      style={{\n        height:\n          foundBreakpoint && typeof foundBreakpoint?.height === 'number'\n            ? `${foundBreakpoint?.height / (typeof zoom === 'number' ? zoom : 1)}px`\n            : typeof zoom === 'number'\n            ? `${100 / zoom}%`\n            : '100%',\n        transform: `translate3d(${x}, 0, 0)`,\n        width:\n          foundBreakpoint && typeof foundBreakpoint?.width === 'number'\n            ? `${foundBreakpoint?.width / (typeof zoom === 'number' ? zoom : 1)}px`\n            : typeof zoom === 'number'\n            ? `${100 / zoom}%`\n            : '100%',\n      }}\n    >\n      {children}\n    </div>\n  )\n}\n\nconst Preview: React.FC<\n  EditViewProps & {\n    popupState: ReturnType<typeof usePopupWindow>\n    url?: string\n  }\n> = (props) => {\n  const {\n    popupState: { isPopupOpen, popupHasLoaded, popupRef },\n    url,\n  } = props\n\n  const { iframeHasLoaded, iframeRef, setIframeHasLoaded } = useLivePreviewContext()\n\n  const { breakpoint, toolbarPosition } = useLivePreviewContext()\n\n  const [fields] = useAllFormFields()\n\n  // The preview could either be an iframe embedded on the page\n  // Or it could be a separate popup window\n  // We need to transmit data to both accordingly\n  useEffect(() => {\n    if (fields && window && 'postMessage' in window) {\n      const values = reduceFieldsToValues(fields)\n      const message = JSON.stringify({ data: values, type: 'livePreview' })\n\n      // external window\n      if (isPopupOpen) {\n        setIframeHasLoaded(false)\n\n        if (popupHasLoaded && popupRef.current) {\n          popupRef.current.postMessage(message, url)\n        }\n      }\n\n      // embedded iframe\n      if (!isPopupOpen) {\n        if (iframeHasLoaded && iframeRef.current) {\n          iframeRef.current.contentWindow?.postMessage(message, url)\n        }\n      }\n    }\n  }, [\n    fields,\n    url,\n    iframeHasLoaded,\n    isPopupOpen,\n    popupRef,\n    popupHasLoaded,\n    iframeRef,\n    setIframeHasLoaded,\n  ])\n\n  if (!isPopupOpen) {\n    return (\n      <div\n        className={[\n          baseClass,\n          isPopupOpen && `${baseClass}--popup-open`,\n          breakpoint && breakpoint !== 'responsive' && `${baseClass}--has-breakpoint`,\n        ]\n          .filter(Boolean)\n          .join(' ')}\n      >\n        <ToolbarArea>\n          <div className={`${baseClass}__wrapper`}>\n            <ResponsiveWindow>\n              <IFrame ref={iframeRef} setIframeHasLoaded={setIframeHasLoaded} url={url} />\n            </ResponsiveWindow>\n          </div>\n          <LivePreviewToolbar\n            {...props}\n            iframeRef={iframeRef}\n            style={{\n              left: `${toolbarPosition.x}px`,\n              top: `${toolbarPosition.y}px`,\n            }}\n            url={url}\n          />\n        </ToolbarArea>\n      </div>\n    )\n  }\n}\n\nexport const PreviewWindow: React.FC<\n  EditViewProps & {\n    popupState: ReturnType<typeof usePopupWindow>\n    url?: string\n  }\n> = (props) => {\n  let url\n\n  let breakpoints: LivePreview['breakpoints'] = [\n    {\n      name: 'responsive',\n      height: '100%',\n      label: 'Responsive',\n      width: '100%',\n    },\n  ]\n\n  if ('collection' in props) {\n    url = props?.collection.admin.livePreview.url\n    breakpoints = breakpoints.concat(props?.collection.admin.livePreview.breakpoints)\n  }\n\n  if ('global' in props) {\n    url = props?.global.admin.livePreview.url\n    breakpoints = breakpoints.concat(props?.global.admin.livePreview.breakpoints)\n  }\n\n  return (\n    <LivePreviewProvider {...props} breakpoints={breakpoints} url={url}>\n      <Preview {...props} />\n    </LivePreviewProvider>\n  )\n}\n"],"names":["PreviewWindow","baseClass","ResponsiveWindow","props","children","breakpoint","breakpoints","deviceFrameRef","zoom","useLivePreviewContext","foundBreakpoint","find","bp","name","x","width","height","div","className","ref","style","transform","Preview","popupState","isPopupOpen","popupHasLoaded","popupRef","url","iframeHasLoaded","iframeRef","setIframeHasLoaded","toolbarPosition","fields","useAllFormFields","useEffect","window","values","reduceFieldsToValues","message","JSON","stringify","data","type","current","postMessage","contentWindow","filter","Boolean","join","ToolbarArea","IFrame","LivePreviewToolbar","left","top","y","label","collection","admin","livePreview","concat","global","LivePreviewProvider"],"mappings":"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"}

package/dist/admin/components/views/LivePreview/PreviewWindow/index.scss

@@ -0,0 +1,26 @@
+@import '../../../../scss/styles.scss';
+
+.live-preview-window {
+  width: 60%;
+  position: sticky;
+  top: var(--doc-controls-height);
+  height: calc(100vh - var(--doc-controls-height));
+  overflow: hidden;
+
+  &--has-breakpoint {
+    padding-top: var(--base);
+
+    .live-preview-iframe {
+      border: 1px solid var(--theme-elevation-100);
+    }
+  }
+
+  &__wrapper {
+    height: 100%;
+    width: 100%;
+  }
+
+  @include mid-break {
+    width: 100%;
+  }
+}