@makeswift/runtime 0.27.1 → 0.27.3

package/dist/cjs/state/react-builder-preview.js

@@ -0,0 +1,610 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var react_builder_preview_exports = {};
+__export(react_builder_preview_exports, {
+  configureStore: () => configureStore,
+  createBox: () => import_box_models.createBox,
+  getBox: () => import_box_models.getBox,
+  initialize: () => initialize,
+  messageChannelMiddleware: () => messageChannelMiddleware,
+  parse: () => import_box_models.parse,
+  propControllerHandlesMiddleware: () => propControllerHandlesMiddleware,
+  reducer: () => reducer,
+  startMeasuringElements: () => startMeasuringElements
+});
+module.exports = __toCommonJS(react_builder_preview_exports);
+var import_toolkit = require("@reduxjs/toolkit");
+var import_deepEqual = __toESM(require("../utils/deepEqual"));
+var Documents = __toESM(require("./modules/read-write-documents"));
+var ElementTrees = __toESM(require("./modules/element-trees"));
+var ReactComponents = __toESM(require("./modules/react-components"));
+var BoxModels = __toESM(require("./modules/box-models"));
+var ComponentsMeta = __toESM(require("./modules/components-meta"));
+var PropControllers = __toESM(require("./modules/prop-controllers"));
+var PropControllerHandles = __toESM(require("./modules/prop-controller-handles"));
+var IsInBuilder = __toESM(require("./modules/is-in-builder"));
+var IsPreview = __toESM(require("./modules/is-preview"));
+var BuilderEditMode = __toESM(require("./modules/builder-edit-mode"));
+var Pointer = __toESM(require("./modules/pointer"));
+var ElementImperativeHandles = __toESM(require("./modules/element-imperative-handles"));
+var Breakpoints = __toESM(require("./modules/breakpoints"));
+var import_setup_teardown = require("./mixins/setup-teardown");
+var ReactPage = __toESM(require("./react-page"));
+var import_actions = require("./actions");
+var import_toolkit2 = require("./toolkit");
+var import_instances = require("../prop-controllers/instances");
+var import_builder = require("../builder");
+var import_box_models = require("./modules/box-models");
+const reducer = (0, import_toolkit.combineReducers)({
+  documents: Documents.reducer,
+  elementTrees: ElementTrees.reducer,
+  reactComponents: ReactComponents.reducer,
+  boxModels: BoxModels.reducer,
+  componentsMeta: ComponentsMeta.reducer,
+  propControllers: PropControllers.reducer,
+  propControllerHandles: PropControllerHandles.reducer,
+  isInBuilder: IsInBuilder.reducer,
+  isPreview: IsPreview.reducer,
+  builderEditMode: BuilderEditMode.reducer,
+  pointer: Pointer.reducer,
+  elementImperativeHandles: ElementImperativeHandles.reducer,
+  breakpoints: Breakpoints.reducer
+});
+function getDocumentsStateSlice(state) {
+  return state.documents;
+}
+function getBoxModelsStateSlice(state) {
+  return state.boxModels;
+}
+function getMeasurables(state) {
+  return BoxModels.getMeasurables(getBoxModelsStateSlice(state));
+}
+function getBoxModels(state) {
+  return BoxModels.getBoxModels(getBoxModelsStateSlice(state));
+}
+function getBoxModel(state, documentKey, elementKey) {
+  return BoxModels.getBoxModel(getBoxModelsStateSlice(state), documentKey, elementKey);
+}
+function getComponentsMetaStateSlice(state) {
+  return state.componentsMeta;
+}
+function getComponentsMeta(state) {
+  return ComponentsMeta.getComponentsMeta(getComponentsMetaStateSlice(state));
+}
+function getPropControllersStateSlice(state) {
+  return state.propControllers;
+}
+function getComponentPropControllerDescriptors(state, componentType) {
+  return PropControllers.getComponentPropControllerDescriptors(
+    getPropControllersStateSlice(state),
+    componentType
+  );
+}
+function getPropControllerHandlesStateSlice(state) {
+  return state.propControllerHandles;
+}
+function getPointer(state) {
+  return Pointer.getPointer(state.pointer);
+}
+function getElementImperativeHandles(state) {
+  return ElementImperativeHandles.getElementImperativeHandles(state.elementImperativeHandles);
+}
+function getElementImperativeHandlesContainingElement(state, element) {
+  const elementImperativeHandles = getElementImperativeHandles(state);
+  const filteredElementImperativeHandles = /* @__PURE__ */ new Map();
+  for (const [documentKey, byElementKey] of elementImperativeHandles) {
+    const filteredByElementKey = /* @__PURE__ */ new Map();
+    for (const [elementKey, elementImperativeHandle] of byElementKey) {
+      const handleElement = elementImperativeHandle.getDomNode();
+      if (handleElement?.contains(element)) {
+        filteredByElementKey.set(elementKey, elementImperativeHandle);
+      }
+    }
+    if (filteredByElementKey.size > 0) {
+      filteredElementImperativeHandles.set(documentKey, filteredByElementKey);
+    }
+  }
+  return filteredElementImperativeHandles;
+}
+function measureElements() {
+  return (dispatch, getState) => {
+    const measurables = getMeasurables(getState());
+    const currentBoxModels = getBoxModels(getState());
+    const measuredBoxModels = /* @__PURE__ */ new Map();
+    measurables.forEach((documentMeasurables, documentKey) => {
+      const measuredDocumentBoxModels = /* @__PURE__ */ new Map();
+      documentMeasurables.forEach((measurable, elementKey) => {
+        const boxModel = BoxModels.measure(measurable);
+        if (boxModel != null)
+          measuredDocumentBoxModels.set(elementKey, boxModel);
+      });
+      if (measuredDocumentBoxModels.size > 0) {
+        measuredBoxModels.set(documentKey, measuredDocumentBoxModels);
+      }
+    });
+    const changedBoxModels = /* @__PURE__ */ new Map();
+    currentBoxModels.forEach((currentDocumentBoxModels, documentKey) => {
+      const changedDocumentBoxModels = /* @__PURE__ */ new Map();
+      currentDocumentBoxModels.forEach((_boxModel, elementKey) => {
+        if (!measuredBoxModels.get(documentKey)?.has(elementKey)) {
+          changedDocumentBoxModels.set(elementKey, null);
+        }
+        if (changedDocumentBoxModels.size > 0) {
+          changedBoxModels.set(documentKey, changedDocumentBoxModels);
+        }
+      });
+    });
+    measuredBoxModels.forEach((measuredDocumentBoxModels, documentKey) => {
+      const changedDocumentBoxModels = /* @__PURE__ */ new Map();
+      measuredDocumentBoxModels.forEach((measuredBoxModel, elementKey) => {
+        const currentBoxModel = getBoxModel(getState(), documentKey, elementKey);
+        if (currentBoxModel == null || !(0, import_deepEqual.default)(currentBoxModel, measuredBoxModel)) {
+          changedDocumentBoxModels.set(elementKey, measuredBoxModel);
+        }
+      });
+      if (changedDocumentBoxModels.size > 0) {
+        changedBoxModels.set(documentKey, changedDocumentBoxModels);
+      }
+    });
+    if (changedBoxModels.size > 0)
+      dispatch((0, import_actions.changeElementBoxModels)(changedBoxModels));
+  };
+}
+function startMeasuringElements() {
+  return (dispatch) => {
+    let animationFrameHandle = requestAnimationFrame(handleAnimationFrameRequest);
+    return () => {
+      cancelAnimationFrame(animationFrameHandle);
+    };
+    function handleAnimationFrameRequest() {
+      dispatch(measureElements());
+      animationFrameHandle = requestAnimationFrame(handleAnimationFrameRequest);
+    }
+  };
+}
+function getElementSize(element) {
+  return {
+    offsetWidth: element.offsetWidth,
+    offsetHeight: element.offsetHeight,
+    clientWidth: element.clientWidth,
+    clientHeight: element.clientHeight,
+    scrollWidth: element.scrollWidth,
+    scrollHeight: element.scrollHeight,
+    scrollTop: element.scrollTop,
+    scrollLeft: element.scrollLeft
+  };
+}
+function lockDocumentScroll() {
+  return (dispatch) => {
+    const lastDocumentOverflow = window.document.documentElement.style.overflow;
+    window.document.documentElement.style.overflow = "hidden";
+    window.document.documentElement.addEventListener("wheel", handleWheelEvent);
+    return () => {
+      window.document.documentElement.style.overflow = lastDocumentOverflow;
+      window.document.documentElement.removeEventListener("wheel", handleWheelEvent);
+    };
+    function handleWheelEvent({ deltaX, deltaY }) {
+      dispatch((0, import_actions.handleWheel)({ deltaX, deltaY }));
+    }
+  };
+}
+function startHandlingPointerMoveEvent() {
+  return (dispatch) => {
+    window.document.documentElement.addEventListener("pointermove", handlePointerMoveEvent);
+    return () => {
+      window.document.documentElement.removeEventListener("pointermove", handlePointerMoveEvent);
+    };
+    function handlePointerMoveEvent({ clientX, clientY }) {
+      dispatch((0, import_actions.handlePointerMove)({ clientX, clientY }));
+    }
+  };
+}
+function startHandlingFocusEvents() {
+  return (_dispatch, getState) => {
+    window.addEventListener("focusin", handleFocusIn);
+    window.addEventListener("focusout", handleFocusOut);
+    return () => {
+      window.removeEventListener("focusin", handleFocusIn);
+      window.removeEventListener("focusout", handleFocusOut);
+    };
+    function handleFocusIn(event) {
+      if (ReactPage.getBuilderEditMode(getState()) === BuilderEditMode.BuilderEditMode.INTERACT) {
+        return;
+      }
+      if (!(event.target instanceof window.HTMLElement) || !event.target.isContentEditable) {
+        window.parent.focus();
+      }
+    }
+    function handleFocusOut(event) {
+      if (ReactPage.getBuilderEditMode(getState()) === BuilderEditMode.BuilderEditMode.INTERACT) {
+        return;
+      }
+      if (!(event.relatedTarget instanceof window.HTMLElement) || !event.relatedTarget.isContentEditable) {
+        window.parent.focus();
+      }
+    }
+  };
+}
+function startMeasuringDocumentElement() {
+  return (dispatch) => {
+    let animationFrameHandle = requestAnimationFrame(handleAnimationFrameRequest);
+    let lastSize;
+    return () => {
+      cancelAnimationFrame(animationFrameHandle);
+    };
+    function handleAnimationFrameRequest() {
+      const nextSize = getElementSize(window.document.documentElement);
+      if (!(0, import_deepEqual.default)(lastSize, nextSize)) {
+        lastSize = nextSize;
+        dispatch((0, import_actions.changeDocumentElementSize)(nextSize));
+      }
+      animationFrameHandle = requestAnimationFrame(handleAnimationFrameRequest);
+    }
+  };
+}
+function elementKeysFromElementFromPoint(elementFromPoint) {
+  return (_dispatch, getState) => {
+    if (elementFromPoint == null)
+      return null;
+    const elementImperativeHandles = getElementImperativeHandlesContainingElement(
+      getState(),
+      elementFromPoint
+    );
+    const ascendingDepthDocumentKeys = ReactPage.getDocumentKeysSortedByDepth(getState());
+    const descendingDepthDocumentKeys = ascendingDepthDocumentKeys.slice().reverse();
+    let currentElement = elementFromPoint;
+    let keys = null;
+    while (currentElement != null) {
+      for (const documentKey of descendingDepthDocumentKeys) {
+        const byElementKey = elementImperativeHandles.get(documentKey);
+        if (byElementKey == null)
+          continue;
+        for (const [elementKey, elementImperativeHandle] of byElementKey) {
+          if (elementImperativeHandle.getDomNode() === currentElement) {
+            return { documentKey, elementKey };
+          }
+        }
+      }
+      currentElement = currentElement.parentElement;
+    }
+    return keys;
+  };
+}
+function startPollingElementFromPoint() {
+  return (dispatch, getState) => {
+    let lastElementFromPoint = null;
+    let animationFrameRequestId = requestAnimationFrame(handleAnimationFrameRequest);
+    return () => {
+      cancelAnimationFrame(animationFrameRequestId);
+    };
+    function handleAnimationFrameRequest() {
+      const pointer = getPointer(getState());
+      const elementFromPoint = pointer == null ? null : document.elementFromPoint(pointer.x, pointer.y);
+      if (elementFromPoint !== lastElementFromPoint) {
+        lastElementFromPoint = elementFromPoint;
+        const keys = dispatch(elementKeysFromElementFromPoint(elementFromPoint));
+        dispatch((0, import_actions.elementFromPointChange)(keys));
+      }
+      animationFrameRequestId = requestAnimationFrame(handleAnimationFrameRequest);
+    }
+  };
+}
+function registerBuilderComponents() {
+  return (dispatch, getState) => {
+    const state = getState();
+    const componentsMeta = getComponentsMeta(state);
+    componentsMeta.forEach((meta, type) => {
+      const descriptors = getComponentPropControllerDescriptors(state, type);
+      if (descriptors != null) {
+        const [serializedControls, transferables] = (0, import_builder.serializeControls)(descriptors);
+        dispatch((0, import_actions.registerBuilderComponent)({ type, meta, serializedControls }, transferables));
+      }
+    });
+    return () => {
+      componentsMeta.forEach((_, type) => {
+        dispatch((0, import_actions.unregisterBuilderComponent)({ type }));
+      });
+    };
+  };
+}
+function registerBuilderDocuments() {
+  return (dispatch, getState) => {
+    const documents = Documents.getDocuments(getDocumentsStateSlice(getState()));
+    documents.forEach((document2) => {
+      dispatch((0, import_actions.registerBuilderDocument)(document2));
+    });
+    return () => {
+      documents.forEach((_document, documentKey) => {
+        dispatch((0, import_actions.unregisterBuilderDocument)(documentKey));
+      });
+    };
+  };
+}
+function initialize(channel) {
+  return (dispatch, getState) => {
+    const unregisterBuilderDocuments = dispatch(registerBuilderDocuments());
+    const stopMeasuringElements = dispatch(startMeasuringElements());
+    const stopMeasuringDocumentElement = dispatch(startMeasuringDocumentElement());
+    const stopHandlingFocusEvent = dispatch(startHandlingFocusEvents());
+    const unlockDocumentScroll = dispatch(lockDocumentScroll());
+    const stopHandlingPointerMoveEvent = dispatch(startHandlingPointerMoveEvent());
+    const stopPollingElementFromPoint = dispatch(startPollingElementFromPoint());
+    const unregisterBuilderComponents = dispatch(registerBuilderComponents());
+    const breakpoints = ReactPage.getBreakpoints(getState());
+    dispatch((0, import_actions.setBreakpoints)(breakpoints));
+    dispatch((0, import_actions.setIsInBuilder)(true));
+    channel.dispatchBuffered();
+    return () => {
+      unregisterBuilderDocuments();
+      stopMeasuringElements();
+      stopMeasuringDocumentElement();
+      stopHandlingFocusEvent();
+      unlockDocumentScroll();
+      stopHandlingPointerMoveEvent();
+      stopPollingElementFromPoint();
+      unregisterBuilderComponents();
+      dispatch((0, import_actions.setIsInBuilder)(false));
+    };
+  };
+}
+function measureBoxModelsMiddleware() {
+  return (0, import_toolkit2.actionMiddleware)(({ dispatch }) => (next) => {
+    return (action) => {
+      switch (action.type) {
+        case import_actions.ActionTypes.REGISTER_COMPONENT_HANDLE: {
+          if (BoxModels.isMeasurable(action.payload.componentHandle)) {
+            dispatch(
+              (0, import_actions.registerMeasurable)(
+                action.payload.documentKey,
+                action.payload.elementKey,
+                action.payload.componentHandle
+              )
+            );
+          }
+          break;
+        }
+        case import_actions.ActionTypes.UNREGISTER_COMPONENT_HANDLE:
+          dispatch((0, import_actions.unregisterMeasurable)(action.payload.documentKey, action.payload.elementKey));
+          break;
+      }
+      return next(action);
+    };
+  });
+}
+function messageChannelMiddleware(channel) {
+  return (0, import_toolkit2.actionMiddleware)(({ dispatch }) => (next) => {
+    if (typeof window === "undefined")
+      return (action) => next(action);
+    let cleanUp = () => {
+    };
+    return (action) => {
+      switch (action.type) {
+        case import_actions.ActionTypes.CHANGE_ELEMENT_BOX_MODELS:
+        case import_actions.ActionTypes.MOUNT_COMPONENT:
+        case import_actions.ActionTypes.UNMOUNT_COMPONENT:
+        case import_actions.ActionTypes.CHANGE_DOCUMENT_ELEMENT_SIZE:
+        case import_actions.ActionTypes.MESSAGE_BUILDER_PROP_CONTROLLER:
+        case import_actions.ActionTypes.HANDLE_WHEEL:
+        case import_actions.ActionTypes.HANDLE_POINTER_MOVE:
+        case import_actions.ActionTypes.ELEMENT_FROM_POINT_CHANGE:
+        case import_actions.ActionTypes.SET_LOCALE:
+        case import_actions.ActionTypes.SET_BREAKPOINTS:
+        case import_actions.ActionTypes.REGISTER_BUILDER_DOCUMENT:
+        case import_actions.ActionTypes.UNREGISTER_BUILDER_DOCUMENT:
+          channel.postMessage(action);
+          break;
+        case import_actions.ActionTypes.REGISTER_BUILDER_COMPONENT: {
+          const { transferables, ...forwardedAction } = action;
+          channel.postMessage(forwardedAction, transferables);
+          break;
+        }
+        case import_actions.ActionTypes.UNREGISTER_BUILDER_COMPONENT:
+          channel.postMessage(action);
+          break;
+        case import_actions.ActionTypes.CHANGE_DOCUMENT_ELEMENT_SCROLL_TOP:
+          window.document.documentElement.scrollTop = action.payload.scrollTop;
+          break;
+        case import_actions.ActionTypes.SCROLL_DOCUMENT_ELEMENT:
+          window.document.documentElement.scrollTop += action.payload.scrollTopDelta;
+          break;
+        case import_actions.ActionTypes.SET_BUILDER_EDIT_MODE:
+          channel.postMessage(action);
+          window.getSelection()?.removeAllRanges();
+          break;
+        case import_actions.ActionTypes.INIT:
+          cleanUp = dispatch(initialize(channel));
+          break;
+        case import_actions.ActionTypes.CLEAN_UP:
+          cleanUp();
+          break;
+      }
+      return next(action);
+    };
+  });
+}
+function createAndRegisterPropControllers(documentKey, elementKey) {
+  return (dispatch, getState) => {
+    const descriptors = ReactPage.getElementPropControllerDescriptors(
+      getState(),
+      documentKey,
+      elementKey
+    );
+    if (descriptors == null)
+      return null;
+    const propControllers = Object.entries(descriptors).reduce(
+      (acc, [propName, descriptor]) => {
+        const propController = (0, import_instances.createPropController)(
+          descriptor,
+          (message) => dispatch((0, import_actions.messageBuilderPropController)(documentKey, elementKey, propName, message))
+        );
+        return { ...acc, [propName]: propController };
+      },
+      {}
+    );
+    dispatch((0, import_actions.registerPropControllers)(documentKey, elementKey, propControllers));
+    return propControllers;
+  };
+}
+function propControllerHandlesMiddleware() {
+  return (0, import_toolkit2.actionMiddleware)(({ dispatch, getState }) => (next) => {
+    return (action) => {
+      switch (action.type) {
+        case import_actions.ActionTypes.REGISTER_COMPONENT_HANDLE: {
+          const { documentKey, elementKey, componentHandle } = action.payload;
+          const element = ReactPage.getElement(getState(), documentKey, elementKey);
+          const propControllers = dispatch(
+            createAndRegisterPropControllers(documentKey, elementKey)
+          );
+          if (element != null && !ReactPage.isElementReference(element) && PropControllerHandles.isPropControllersHandle(componentHandle)) {
+            dispatch((0, import_actions.registerPropControllersHandle)(documentKey, elementKey, componentHandle));
+            componentHandle.setPropControllers(propControllers);
+          }
+          break;
+        }
+        case import_actions.ActionTypes.UNREGISTER_COMPONENT_HANDLE: {
+          const { documentKey, elementKey } = action.payload;
+          const handle = PropControllerHandles.getPropControllersHandle(
+            getPropControllerHandlesStateSlice(getState()),
+            documentKey,
+            elementKey
+          );
+          handle?.setPropControllers(null);
+          dispatch((0, import_actions.unregisterPropControllers)(documentKey, elementKey));
+          break;
+        }
+        case import_actions.ActionTypes.MESSAGE_HOST_PROP_CONTROLLER: {
+          const propController = PropControllerHandles.getPropController(
+            getPropControllerHandlesStateSlice(getState()),
+            action.payload.documentKey,
+            action.payload.elementKey,
+            action.payload.propName
+          );
+          if (propController)
+            propController.recv(action.payload.message);
+        }
+      }
+      return next(action);
+    };
+  });
+}
+function makeswiftApiClientSyncMiddleware(client) {
+  return (0, import_toolkit2.actionMiddleware)(() => (next) => {
+    return (action) => {
+      client.makeswiftApiClient.dispatch(action);
+      return next(action);
+    };
+  });
+}
+class MessageChannel {
+  channel = null;
+  bufferedMessages = [];
+  postMessage(message, transferables) {
+    if (this.channel) {
+      this.channel.postMessage(message, transferables ?? []);
+    } else {
+      this.bufferedMessages.push([message, transferables]);
+    }
+  }
+  setup(onMessage) {
+    const channel = new window.MessageChannel();
+    channel.port1.onmessage = onMessage;
+    window.parent.postMessage(channel.port2, "*", [channel.port2]);
+    this.channel = channel.port1;
+  }
+  dispatchBuffered() {
+    console.assert(this.channel != null, "channel is not setup");
+    this.bufferedMessages.forEach(([message, transferables]) => {
+      this.channel?.postMessage(message, transferables ?? []);
+    });
+    this.bufferedMessages = [];
+  }
+  teardown() {
+    if (this.channel) {
+      this.channel.onmessage = null;
+      this.channel.close();
+    }
+  }
+}
+function setupMessageChannel(channel) {
+  return (dispatch) => {
+    channel.setup((event) => dispatch(event.data));
+  };
+}
+function configureStore({
+  preloadedState,
+  client
+}) {
+  const initialState = {
+    ...preloadedState,
+    isPreview: IsPreview.getInitialState(true)
+  };
+  const channel = new MessageChannel();
+  const store = (0, import_toolkit.configureStore)({
+    reducer,
+    preloadedState: initialState,
+    middleware: (getDefaultMiddleware) => getDefaultMiddleware(import_toolkit2.middlewareOptions).concat(
+      ReactPage.elementTreeMiddleware(),
+      measureBoxModelsMiddleware(),
+      messageChannelMiddleware(channel),
+      propControllerHandlesMiddleware(),
+      makeswiftApiClientSyncMiddleware(client)
+    ),
+    enhancers: (getDefaultEnhancers) => getDefaultEnhancers().concat(
+      (0, import_setup_teardown.withSetupTeardown)(
+        () => {
+          const dispatch = store.dispatch;
+          dispatch(setupMessageChannel(channel));
+        },
+        () => channel.teardown()
+      )
+    ),
+    devTools: (0, import_toolkit2.devToolsConfig)({
+      name: `Host store (${(/* @__PURE__ */ new Date()).toISOString()})`,
+      actionsDenylist: [
+        import_actions.ActionTypes.BUILDER_POINTER_MOVE,
+        import_actions.ActionTypes.HANDLE_POINTER_MOVE,
+        import_actions.ActionTypes.ELEMENT_FROM_POINT_CHANGE
+      ]
+    })
+  });
+  return store;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  configureStore,
+  createBox,
+  getBox,
+  initialize,
+  messageChannelMiddleware,
+  parse,
+  propControllerHandlesMiddleware,
+  reducer,
+  startMeasuringElements
+});
+//# sourceMappingURL=react-builder-preview.js.map