@dotcms/uve 0.0.1-beta.15 → 0.0.1-beta.17

package/internal.cjs.js

@@ -1,652 +1,136 @@
 'use strict';
 
+var constants = require('./constants.cjs.js');
 var types = require('./types.cjs.js');
 
 /**
- * Actions received from the dotcms editor
- *
- * @export
- * @enum {number}
- */
-exports.__DOTCMS_UVE_EVENT__ = void 0;
-(function (__DOTCMS_UVE_EVENT__) {
-  /**
-   * Request to page to reload
-   */
-  __DOTCMS_UVE_EVENT__["UVE_RELOAD_PAGE"] = "uve-reload-page";
-  /**
-   * Request the bounds for the elements
-   */
-  __DOTCMS_UVE_EVENT__["UVE_REQUEST_BOUNDS"] = "uve-request-bounds";
-  /**
-   * Received pong from the editor
-   */
-  __DOTCMS_UVE_EVENT__["UVE_EDITOR_PONG"] = "uve-editor-pong";
-  /**
-   * Received scroll event trigger from the editor
-   */
-  __DOTCMS_UVE_EVENT__["UVE_SCROLL_INSIDE_IFRAME"] = "uve-scroll-inside-iframe";
-  /**
-   * TODO:
-   * Set the page data - This is used to catch the "changes" event.
-   * We must to re-check the name late.
-   */
-  __DOTCMS_UVE_EVENT__["UVE_SET_PAGE_DATA"] = "uve-set-page-data";
-  /**
-   * Copy contentlet inline editing success
-   */
-  __DOTCMS_UVE_EVENT__["UVE_COPY_CONTENTLET_INLINE_EDITING_SUCCESS"] = "uve-copy-contentlet-inline-editing-success";
-})(exports.__DOTCMS_UVE_EVENT__ || (exports.__DOTCMS_UVE_EVENT__ = {}));
-
-/**
- * Calculates the bounding information for each page element within the given containers.
- *
- * @export
- * @param {HTMLDivElement[]} containers - An array of HTMLDivElement representing the containers.
- * @return {DotCMSContainerBound[]} An array of objects containing the bounding information for each page element.
- * @example
- * ```ts
- * const containers = document.querySelectorAll('.container');
- * const bounds = getDotCMSPageBounds(containers);
- * console.log(bounds);
- * ```
+ * Sets the bounds of the containers in the editor.
+ * Retrieves the containers from the DOM and sends their position data to the editor.
+ * @private
+ * @memberof DotCMSPageEditor
  */
-function getDotCMSPageBounds(containers) {
-  return containers.map(container => {
-    const containerRect = container.getBoundingClientRect();
-    const contentlets = Array.from(container.querySelectorAll('[data-dot-object="contentlet"]'));
-    return {
-      x: containerRect.x,
-      y: containerRect.y,
-      width: containerRect.width,
-      height: containerRect.height,
-      payload: JSON.stringify({
-        container: getDotCMSContainerData(container)
-      }),
-      contentlets: getDotCMSContentletsBound(containerRect, contentlets)
-    };
+function setBounds(bounds) {
+  constants.sendMessageToUVE({
+    action: types.DotCMSUVEAction.SET_BOUNDS,
+    payload: bounds
   });
 }
 /**
- * Calculates the bounding information for each contentlet inside a container.
+ * Validates the structure of a Block Editor block.
+ *
+ * This function checks that:
+ * 1. The blocks parameter is a valid object
+ * 2. The block has a 'doc' type
+ * 3. The block has a valid content array that is not empty
  *
- * @export
- * @param {DOMRect} containerRect - The bounding rectangle of the container.
- * @param {HTMLDivElement[]} contentlets - An array of HTMLDivElement representing the contentlets.
- * @return {DotCMSContentletBound[]} An array of objects containing the bounding information for each contentlet.
- * @example
- * ```ts
- * const containerRect = container.getBoundingClientRect();
- * const contentlets = container.querySelectorAll('.contentlet');
- * const bounds = getDotCMSContentletsBound(containerRect, contentlets);
- * console.log(bounds); // Element bounds within the container
- * ```
+ * @param {Block} blocks - The blocks structure to validate
+ * @returns {BlockEditorState} Object containing validation state and any error message
+ * @property {boolean} BlockEditorState.isValid - Whether the blocks structure is valid
+ * @property {string | null} BlockEditorState.error - Error message if invalid, null if valid
  */
-function getDotCMSContentletsBound(containerRect, contentlets) {
-  return contentlets.map(contentlet => {
-    const contentletRect = contentlet.getBoundingClientRect();
+const isValidBlocks = blocks => {
+  if (!blocks) {
     return {
-      x: 0,
-      y: contentletRect.y - containerRect.y,
-      width: contentletRect.width,
-      height: contentletRect.height,
-      payload: JSON.stringify({
-        container: contentlet.dataset?.['dotContainer'] ? JSON.parse(contentlet.dataset?.['dotContainer']) : getClosestDotCMSContainerData(contentlet),
-        contentlet: {
-          identifier: contentlet.dataset?.['dotIdentifier'],
-          title: contentlet.dataset?.['dotTitle'],
-          inode: contentlet.dataset?.['dotInode'],
-          contentType: contentlet.dataset?.['dotType']
-        }
-      })
+      error: `Error: Blocks object is not defined`
     };
-  });
-}
-/**
- * Get container data from VTLS.
- *
- * @export
- * @param {HTMLElement} container - The container element.
- * @return {object} An object containing the container data.
- * @example
- * ```ts
- * const container = document.querySelector('.container');
- * const data = getContainerData(container);
- * console.log(data);
- * ```
- */
-function getDotCMSContainerData(container) {
-  return {
-    acceptTypes: container.dataset?.['dotAcceptTypes'] || '',
-    identifier: container.dataset?.['dotIdentifier'] || '',
-    maxContentlets: container.dataset?.['maxContentlets'] || '',
-    uuid: container.dataset?.['dotUuid'] || ''
-  };
-}
-/**
- * Get the closest container data from the contentlet.
- *
- * @export
- * @param {Element} element - The contentlet element.
- * @return {object | null} An object containing the closest container data or null if no container is found.
- * @example
- * ```ts
- * const contentlet = document.querySelector('.contentlet');
- * const data = getClosestDotCMSContainerData(contentlet);
- * console.log(data);
- * ```
- */
-function getClosestDotCMSContainerData(element) {
-  // Find the closest ancestor element with data-dot-object="container" attribute
-  const container = element.closest('[data-dot-object="container"]');
-  // If a container element is found
-  if (container) {
-    // Return the dataset of the container element
-    return getDotCMSContainerData(container);
-  } else {
-    // If no container element is found, return null
-    console.warn('No container found for the contentlet');
-    return null;
   }
-}
-/**
- * Find the closest contentlet element based on HTMLElement.
- *
- * @export
- * @param {HTMLElement | null} element - The starting element.
- * @return {HTMLElement | null} The closest contentlet element or null if not found.
- * @example
- * const element = document.querySelector('.some-element');
- * const contentlet = findDotCMSElement(element);
- * console.log(contentlet);
- */
-function findDotCMSElement(element) {
-  if (!element) return null;
-  if (element?.dataset?.['dotObject'] === 'contentlet' || element?.dataset?.['dotObject'] === 'container' && element.children.length === 0) {
-    return element;
+  if (typeof blocks !== 'object') {
+    return {
+      error: `Error: Blocks must be an object, but received: ${typeof blocks}`
+    };
   }
-  return findDotCMSElement(element?.['parentElement']);
-}
-/**
- * Find VTL data within a target element.
- *
- * @export
- * @param {HTMLElement} target - The target element to search within.
- * @return {Array<{ inode: string, name: string }> | null} An array of objects containing VTL data or null if none found.
- * @example
- * ```ts
- * const target = document.querySelector('.target-element');
- * const vtlData = findDotCMSVTLData(target);
- * console.log(vtlData);
- * ```
- */
-function findDotCMSVTLData(target) {
-  const vltElements = target.querySelectorAll('[data-dot-object="vtl-file"]');
-  if (!vltElements.length) {
-    return null;
+  if (blocks.type !== 'doc') {
+    return {
+      error: `Error: Invalid block type. Expected 'doc' but received: '${blocks.type}'`
+    };
   }
-  return Array.from(vltElements).map(vltElement => {
+  if (!blocks.content) {
     return {
-      inode: vltElement.dataset?.['dotInode'],
-      name: vltElement.dataset?.['dotUrl']
+      error: 'Error: Blocks content is missing'
     };
-  });
-}
-/**
- * Check if the scroll position is at the bottom of the page.
- *
- * @export
- * @return {boolean} True if the scroll position is at the bottom, otherwise false.
- * @example
- * ```ts
- * if (dotCMSScrollIsInBottom()) {
- *     console.log('Scrolled to the bottom');
- * }
- * ```
- */
-function computeScrollIsInBottom() {
-  const documentHeight = document.documentElement.scrollHeight;
-  const viewportHeight = window.innerHeight;
-  const scrollY = window.scrollY;
-  return scrollY + viewportHeight >= documentHeight;
-}
-/**
- *
- *
- * Combine classes into a single string.
- *
- * @param {string[]} classes
- * @returns {string} Combined classes
- */
-const combineClasses = classes => classes.filter(Boolean).join(' ');
-/**
- *
- *
- * Calculates and returns the CSS Grid positioning classes for a column based on its configuration.
- * Uses a 12-column grid system where columns are positioned using grid-column-start and grid-column-end.
- *
- * @example
- * ```typescript
- * const classes = getColumnPositionClasses({
- *   leftOffset: 1, // Starts at the first column
- *   width: 6      // Spans 6 columns
- * });
- * // Returns: { startClass: 'col-start-1', endClass: 'col-end-7' }
- * ```
- *
- * @param {DotPageAssetLayoutColumn} column - Column configuration object
- * @param {number} column.leftOffset - Starting position (0-based) in the grid
- * @param {number} column.width - Number of columns to span
- * @returns {{ startClass: string, endClass: string }} Object containing CSS class names for grid positioning
- */
-const getColumnPositionClasses = column => {
-  const {
-    leftOffset,
-    width
-  } = column;
-  const startClass = `${START_CLASS}${leftOffset}`;
-  const endClass = `${END_CLASS}${leftOffset + width}`;
-  return {
-    startClass,
-    endClass
-  };
-};
-/**
- *
- *
- * Helper function that returns an object containing the dotCMS data attributes.
- * @param {DotCMSContentlet} contentlet - The contentlet to get the attributes for
- * @param {string} container - The container to get the attributes for
- * @returns {DotContentletAttributes} The dotCMS data attributes
- */
-function getDotContentletAttributes(contentlet, container) {
-  return {
-    'data-dot-identifier': contentlet?.identifier,
-    'data-dot-basetype': contentlet?.baseType,
-    'data-dot-title': contentlet?.['widgetTitle'] || contentlet?.title,
-    'data-dot-inode': contentlet?.inode,
-    'data-dot-type': contentlet?.contentType,
-    'data-dot-container': container,
-    'data-dot-on-number-of-pages': contentlet?.['onNumberOfPages']
-  };
-}
-/**
- *
- *
- * Retrieves container data from a DotCMS page asset using the container reference.
- * This function processes the container information and returns a standardized format
- * for container editing.
- *
- * @param {DotCMSPageAsset} dotCMSPageAsset - The page asset containing all containers data
- * @param {DotCMSColumnContainer} columContainer - The container reference from the layout
- * @throws {Error} When page asset is invalid or container is not found
- * @returns {EditableContainerData} Formatted container data for editing
- *
- * @example
- * const containerData = getContainersData(pageAsset, containerRef);
- * // Returns: { uuid: '123', identifier: 'cont1', acceptTypes: 'type1,type2', maxContentlets: 5 }
- */
-const getContainersData = (dotCMSPageAsset, columContainer) => {
-  const {
-    identifier,
-    uuid
-  } = columContainer;
-  const dotContainer = dotCMSPageAsset.containers[identifier];
-  if (!dotContainer) {
-    return null;
   }
-  const {
-    containerStructures,
-    container
-  } = dotContainer;
-  const acceptTypes = containerStructures?.map(structure => structure.contentTypeVar).join(',') ?? '';
-  const variantId = container?.parentPermissionable?.variantId;
-  const maxContentlets = container?.maxContentlets ?? 0;
-  const path = container?.path;
-  return {
-    uuid,
-    variantId,
-    acceptTypes,
-    maxContentlets,
-    identifier: path ?? identifier
-  };
-};
-/**
- *
- *
- * Retrieves the contentlets (content items) associated with a specific container.
- * Handles different UUID formats and provides warning for missing contentlets.
- *
- * @param {DotCMSPageAsset} dotCMSPageAsset - The page asset containing all containers data
- * @param {DotCMSColumnContainer} columContainer - The container reference from the layout
- * @returns {DotCMSContentlet[]} Array of contentlets in the container
- *
- * @example
- * const contentlets = getContentletsInContainer(pageAsset, containerRef);
- * // Returns: [{ identifier: 'cont1', ... }, { identifier: 'cont2', ... }]
- */
-const getContentletsInContainer = (dotCMSPageAsset, columContainer) => {
-  const {
-    identifier,
-    uuid
-  } = columContainer;
-  const {
-    contentlets
-  } = dotCMSPageAsset.containers[identifier];
-  const contentletsInContainer = contentlets[`uuid-${uuid}`] || contentlets[`uuid-dotParser_${uuid}`] || [];
-  if (!contentletsInContainer) {
-    console.warn(`We couldn't find the contentlets for the container with the identifier ${identifier} and the uuid ${uuid} becareful by adding content to this container.\nWe recommend to change the container in the layout and add the content again.`);
+  if (!Array.isArray(blocks.content)) {
+    return {
+      error: `Error: Blocks content must be an array, but received: ${typeof blocks.content}`
+    };
   }
-  return contentletsInContainer;
-};
-/**
- *
- *
- * Generates the required DotCMS data attributes for a container element.
- * These attributes are used by DotCMS for container identification and functionality.
- *
- * @param {EditableContainerData} params - Container data including uuid, identifier, acceptTypes, and maxContentlets
- * @returns {DotContainerAttributes} Object containing all necessary data attributes
- *
- * @example
- * const attributes = getDotContainerAttributes({
- *   uuid: '123',
- *   identifier: 'cont1',
- *   acceptTypes: 'type1,type2',
- *   maxContentlets: 5
- * });
- * // Returns: { 'data-dot-object': 'container', 'data-dot-identifier': 'cont1', ... }
- */
-function getDotContainerAttributes({
-  uuid,
-  identifier,
-  acceptTypes,
-  maxContentlets
-}) {
-  return {
-    'data-dot-object': 'container',
-    'data-dot-accept-types': acceptTypes,
-    'data-dot-identifier': identifier,
-    'data-max-contentlets': maxContentlets.toString(),
-    'data-dot-uuid': uuid
-  };
-}
-
-/**
- * Subscribes to content changes in the UVE editor
- *
- * @param {UVEEventHandler} callback - Function to be called when content changes are detected
- * @returns {Object} Object containing unsubscribe function and event type
- * @returns {Function} .unsubscribe - Function to remove the event listener
- * @returns {UVEEventType} .event - The event type being subscribed to
- * @internal
- */
-function onContentChanges(callback) {
-  const messageCallback = event => {
-    if (event.data.name === exports.__DOTCMS_UVE_EVENT__.UVE_SET_PAGE_DATA) {
-      callback(event.data.payload);
+  if (blocks.content.length === 0) {
+    return {
+      error: 'Error: Blocks content is empty. At least one block is required.'
+    };
+  }
+  // Validate each block in the content array
+  for (let i = 0; i < blocks.content.length; i++) {
+    const block = blocks.content[i];
+    if (!block.type) {
+      return {
+        error: `Error: Block at index ${i} is missing required 'type' property`
+      };
     }
-  };
-  window.addEventListener('message', messageCallback);
-  return {
-    unsubscribe: () => {
-      window.removeEventListener('message', messageCallback);
-    },
-    event: types.UVEEventType.CONTENT_CHANGES
-  };
-}
-/**
- * Subscribes to page reload events in the UVE editor
- *
- * @param {UVEEventHandler} callback - Function to be called when page reload is triggered
- * @returns {Object} Object containing unsubscribe function and event type
- * @returns {Function} .unsubscribe - Function to remove the event listener
- * @returns {UVEEventType} .event - The event type being subscribed to
- * @internal
- */
-function onPageReload(callback) {
-  const messageCallback = event => {
-    if (event.data.name === exports.__DOTCMS_UVE_EVENT__.UVE_RELOAD_PAGE) {
-      callback();
+    if (typeof block.type !== 'string') {
+      return {
+        error: `Error: Block type at index ${i} must be a string, but received: ${typeof block.type}`
+      };
     }
-  };
-  window.addEventListener('message', messageCallback);
-  return {
-    unsubscribe: () => {
-      window.removeEventListener('message', messageCallback);
-    },
-    event: types.UVEEventType.PAGE_RELOAD
-  };
-}
-/**
- * Subscribes to request bounds events in the UVE editor
- *
- * @param {UVEEventHandler} callback - Function to be called when bounds are requested
- * @returns {Object} Object containing unsubscribe function and event type
- * @returns {Function} .unsubscribe - Function to remove the event listener
- * @returns {UVEEventType} .event - The event type being subscribed to
- * @internal
- */
-function onRequestBounds(callback) {
-  const messageCallback = event => {
-    if (event.data.name === exports.__DOTCMS_UVE_EVENT__.UVE_REQUEST_BOUNDS) {
-      const containers = Array.from(document.querySelectorAll('[data-dot-object="container"]'));
-      const positionData = getDotCMSPageBounds(containers);
-      callback(positionData);
+    // Validate block attributes if present
+    if (block.attrs && typeof block.attrs !== 'object') {
+      return {
+        error: `Error: Block attributes at index ${i} must be an object, but received: ${typeof block.attrs}`
+      };
     }
-  };
-  window.addEventListener('message', messageCallback);
-  return {
-    unsubscribe: () => {
-      window.removeEventListener('message', messageCallback);
-    },
-    event: types.UVEEventType.REQUEST_BOUNDS
-  };
-}
-/**
- * Subscribes to iframe scroll events in the UVE editor
- *
- * @param {UVEEventHandler} callback - Function to be called when iframe scroll occurs
- * @returns {Object} Object containing unsubscribe function and event type
- * @returns {Function} .unsubscribe - Function to remove the event listener
- * @returns {UVEEventType} .event - The event type being subscribed to
- * @internal
- */
-function onIframeScroll(callback) {
-  const messageCallback = event => {
-    if (event.data.name === exports.__DOTCMS_UVE_EVENT__.UVE_SCROLL_INSIDE_IFRAME) {
-      const direction = event.data.direction;
-      callback(direction);
+    // Validate nested content if present
+    if (block.content) {
+      if (!Array.isArray(block.content)) {
+        return {
+          error: `Error: Block content at index ${i} must be an array, but received: ${typeof block.content}`
+        };
+      }
+      // Recursively validate nested blocks
+      const nestedValidation = isValidBlocks({
+        type: 'doc',
+        content: block.content
+      });
+      if (nestedValidation.error) {
+        return {
+          error: `Error in nested block at index ${i}: ${nestedValidation.error}`
+        };
+      }
     }
-  };
-  window.addEventListener('message', messageCallback);
-  return {
-    unsubscribe: () => {
-      window.removeEventListener('message', messageCallback);
-    },
-    event: types.UVEEventType.IFRAME_SCROLL
-  };
-}
-/**
- * Subscribes to contentlet hover events in the UVE editor
- *
- * @param {UVEEventHandler} callback - Function to be called when a contentlet is hovered
- * @returns {Object} Object containing unsubscribe function and event type
- * @returns {Function} .unsubscribe - Function to remove the event listener
- * @returns {UVEEventType} .event - The event type being subscribed to
- * @internal
- */
-function onContentletHovered(callback) {
-  const pointerMoveCallback = event => {
-    const foundElement = findDotCMSElement(event.target);
-    if (!foundElement) return;
-    const {
-      x,
-      y,
-      width,
-      height
-    } = foundElement.getBoundingClientRect();
-    const isContainer = foundElement.dataset?.['dotObject'] === 'container';
-    const contentletForEmptyContainer = {
-      identifier: 'TEMP_EMPTY_CONTENTLET',
-      title: 'TEMP_EMPTY_CONTENTLET',
-      contentType: 'TEMP_EMPTY_CONTENTLET_TYPE',
-      inode: 'TEMPY_EMPTY_CONTENTLET_INODE',
-      widgetTitle: 'TEMP_EMPTY_CONTENTLET',
-      baseType: 'TEMP_EMPTY_CONTENTLET',
-      onNumberOfPages: 1
-    };
-    const contentlet = {
-      identifier: foundElement.dataset?.['dotIdentifier'],
-      title: foundElement.dataset?.['dotTitle'],
-      inode: foundElement.dataset?.['dotInode'],
-      contentType: foundElement.dataset?.['dotType'],
-      baseType: foundElement.dataset?.['dotBasetype'],
-      widgetTitle: foundElement.dataset?.['dotWidgetTitle'],
-      onNumberOfPages: foundElement.dataset?.['dotOnNumberOfPages']
-    };
-    const vtlFiles = findDotCMSVTLData(foundElement);
-    const contentletPayload = {
-      container:
-      // Here extract dot-container from contentlet if it is Headless
-      // or search in parent container if it is VTL
-      foundElement.dataset?.['dotContainer'] ? JSON.parse(foundElement.dataset?.['dotContainer']) : getClosestDotCMSContainerData(foundElement),
-      contentlet: isContainer ? contentletForEmptyContainer : contentlet,
-      vtlFiles
-    };
-    const contentletHoveredPayload = {
-      x,
-      y,
-      width,
-      height,
-      payload: contentletPayload
-    };
-    callback(contentletHoveredPayload);
-  };
-  document.addEventListener('pointermove', pointerMoveCallback);
-  return {
-    unsubscribe: () => {
-      document.removeEventListener('pointermove', pointerMoveCallback);
-    },
-    event: types.UVEEventType.CONTENTLET_HOVERED
-  };
-}
-
-/**
- * Events that can be subscribed to in the UVE
- *
- * @internal
- * @type {Record<UVEEventType, UVEEventSubscriber>}
- */
-const __UVE_EVENTS__ = {
-  [types.UVEEventType.CONTENT_CHANGES]: callback => {
-    return onContentChanges(callback);
-  },
-  [types.UVEEventType.PAGE_RELOAD]: callback => {
-    return onPageReload(callback);
-  },
-  [types.UVEEventType.REQUEST_BOUNDS]: callback => {
-    return onRequestBounds(callback);
-  },
-  [types.UVEEventType.IFRAME_SCROLL]: callback => {
-    return onIframeScroll(callback);
-  },
-  [types.UVEEventType.CONTENTLET_HOVERED]: callback => {
-    return onContentletHovered(callback);
   }
-};
-/**
- * Default UVE event
- *
- * @param {string} event - The event to subscribe to.
- * @internal
- */
-const __UVE_EVENT_ERROR_FALLBACK__ = event => {
   return {
-    unsubscribe: () => {
-      /* do nothing */
-    },
-    event
+    error: null
   };
 };
-/**
- * Development mode
- *
- * @internal
- */
-const DEVELOPMENT_MODE = 'development';
-/**
- * Production mode
- *
- * @internal
- */
-const PRODUCTION_MODE = 'production';
-/**
- * End class
- *
- * @internal
- */
-const END_CLASS = 'col-end-';
-/**
- * Start class
- *
- * @internal
- */
-const START_CLASS = 'col-start-';
-/**
- * Empty container style for React
- *
- * @internal
- */
-const EMPTY_CONTAINER_STYLE_REACT = {
-  width: '100%',
-  backgroundColor: '#ECF0FD',
-  display: 'flex',
-  justifyContent: 'center',
-  alignItems: 'center',
-  color: '#030E32',
-  height: '10rem'
-};
-/**
- * Empty container style for Angular
- *
- * @internal
- */
-const EMPTY_CONTAINER_STYLE_ANGULAR = {
-  width: '100%',
-  'background-color': '#ECF0FD',
-  display: 'flex',
-  'justify-content': 'center',
-  'align-items': 'center',
-  color: '#030E32',
-  height: '10rem'
-};
-/**
- * Custom no component
- *
- * @internal
- */
-const CUSTOM_NO_COMPONENT = 'CustomNoComponent';
 
-exports.CUSTOM_NO_COMPONENT = CUSTOM_NO_COMPONENT;
-exports.DEVELOPMENT_MODE = DEVELOPMENT_MODE;
-exports.EMPTY_CONTAINER_STYLE_ANGULAR = EMPTY_CONTAINER_STYLE_ANGULAR;
-exports.EMPTY_CONTAINER_STYLE_REACT = EMPTY_CONTAINER_STYLE_REACT;
-exports.END_CLASS = END_CLASS;
-exports.PRODUCTION_MODE = PRODUCTION_MODE;
-exports.START_CLASS = START_CLASS;
-exports.__UVE_EVENTS__ = __UVE_EVENTS__;
-exports.__UVE_EVENT_ERROR_FALLBACK__ = __UVE_EVENT_ERROR_FALLBACK__;
-exports.combineClasses = combineClasses;
-exports.computeScrollIsInBottom = computeScrollIsInBottom;
-exports.findDotCMSElement = findDotCMSElement;
-exports.findDotCMSVTLData = findDotCMSVTLData;
-exports.getClosestDotCMSContainerData = getClosestDotCMSContainerData;
-exports.getColumnPositionClasses = getColumnPositionClasses;
-exports.getContainersData = getContainersData;
-exports.getContentletsInContainer = getContentletsInContainer;
-exports.getDotCMSContainerData = getDotCMSContainerData;
-exports.getDotCMSContentletsBound = getDotCMSContentletsBound;
-exports.getDotCMSPageBounds = getDotCMSPageBounds;
-exports.getDotContainerAttributes = getDotContainerAttributes;
-exports.getDotContentletAttributes = getDotContentletAttributes;
+Object.defineProperty(exports, "Blocks", {
+    enumerable: true,
+    get: function () { return constants.Blocks; }
+});
+exports.CUSTOM_NO_COMPONENT = constants.CUSTOM_NO_COMPONENT;
+exports.DEVELOPMENT_MODE = constants.DEVELOPMENT_MODE;
+exports.EMPTY_CONTAINER_STYLE_ANGULAR = constants.EMPTY_CONTAINER_STYLE_ANGULAR;
+exports.EMPTY_CONTAINER_STYLE_REACT = constants.EMPTY_CONTAINER_STYLE_REACT;
+exports.END_CLASS = constants.END_CLASS;
+exports.PRODUCTION_MODE = constants.PRODUCTION_MODE;
+exports.START_CLASS = constants.START_CLASS;
+Object.defineProperty(exports, "__DOTCMS_UVE_EVENT__", {
+    enumerable: true,
+    get: function () { return constants.__DOTCMS_UVE_EVENT__; }
+});
+exports.__UVE_EVENTS__ = constants.__UVE_EVENTS__;
+exports.__UVE_EVENT_ERROR_FALLBACK__ = constants.__UVE_EVENT_ERROR_FALLBACK__;
+exports.combineClasses = constants.combineClasses;
+exports.computeScrollIsInBottom = constants.computeScrollIsInBottom;
+exports.findDotCMSElement = constants.findDotCMSElement;
+exports.findDotCMSVTLData = constants.findDotCMSVTLData;
+exports.getClosestDotCMSContainerData = constants.getClosestDotCMSContainerData;
+exports.getColumnPositionClasses = constants.getColumnPositionClasses;
+exports.getContainersData = constants.getContainersData;
+exports.getContentletsInContainer = constants.getContentletsInContainer;
+exports.getDotCMSContainerData = constants.getDotCMSContainerData;
+exports.getDotCMSContentletsBound = constants.getDotCMSContentletsBound;
+exports.getDotCMSPageBounds = constants.getDotCMSPageBounds;
+exports.getDotContainerAttributes = constants.getDotContainerAttributes;
+exports.getDotContentletAttributes = constants.getDotContentletAttributes;
+exports.isValidBlocks = isValidBlocks;
+exports.setBounds = setBounds;