@capillarytech/creatives-library 8.0.263 → 8.0.265

package/v2Components/HtmlEditor/HTMLEditor.js

@@ -12,14 +12,14 @@
  * Note: Uses injectIntl with forwardRef to provide direct access to CodeEditorPane via ref
  */
 
-import React, {
-  useRef, useCallback, useMemo, useState, useEffect, useImperativeHandle, forwardRef,
-} from 'react';
+import React, { useRef, useCallback, useMemo, useState } from 'react';
 import PropTypes from 'prop-types';
+import { Layout } from 'antd'; // Fallback - no Cap UI equivalent
 import { injectIntl, intlShape } from 'react-intl';
 
 // Cap UI Components (First Preference)
 import CapRow from '@capillarytech/cap-ui-library/CapRow';
+import CapColumn from '@capillarytech/cap-ui-library/CapColumn';
 import CapSpin from '@capillarytech/cap-ui-library/CapSpin';
 import CapNotification from '@capillarytech/cap-ui-library/CapNotification';
 import CapModal from '@capillarytech/cap-ui-library/CapModal';
@@ -30,6 +30,7 @@ import DeviceToggle from './components/DeviceToggle';
 import SplitContainer from './components/SplitContainer';
 import CodeEditorPane from './components/CodeEditorPane';
 import PreviewPane from './components/PreviewPane';
+import ValidationErrorDisplay from './components/ValidationErrorDisplay';
 import { EditorProvider } from './components/common/EditorContext';
 
 // Hooks and utilities
@@ -39,11 +40,7 @@ import { useLayoutState } from './hooks/useLayoutState';
 import { useValidation } from './hooks/useValidation';
 
 // Constants
-import {
-  HTML_EDITOR_VARIANTS, DEVICE_TYPES, DEFAULT_HTML_CONTENT, TAG, EMBEDDED, DEFAULT, FULL, ALL, SMS, EMAIL,
-  BLOCKING_ERROR_RULE_IDS,
-  VALIDATION_SEVERITY,
-} from './constants';
+import { HTML_EDITOR_VARIANTS, DEVICE_TYPES, DEFAULT_HTML_CONTENT } from './constants';
 
 // Styles
 import './_htmlEditor.scss';
@@ -51,33 +48,8 @@ import './components/FullscreenModal/_fullscreenModal.scss';
 
 // Messages
 import messages from './messages';
-import { ISSUE_SOURCES } from './utils/validationConstants';
-
-/** Check if an issue is a blocking error (Errors tab). Non-blocking = Warnings. */
-const isBlockingError = (issue) => {
-  const { rule, source, severity } = issue || {};
-  if (rule === 'liquid-api-validation' || rule === 'standard-api-validation') return true;
-  if (source === ISSUE_SOURCES.LIQUID && severity === VALIDATION_SEVERITY.ERROR) return true;
-  if (BLOCKING_ERROR_RULE_IDS.includes(rule)) return true;
-  return false;
-};
-
-/** Count issues as Errors (blocking) and Warnings (non-blocking). */
-const countIssuesBySeverity = (allIssues) => {
-  let errors = 0;
-  let warnings = 0;
-  (allIssues || []).forEach((issue) => {
-    if (isBlockingError(issue)) errors += 1;
-    else warnings += 1;
-  });
-  return {
-    errors,
-    warnings,
-    total: (allIssues || []).length,
-  };
-};
 
-const HTMLEditor = forwardRef(({
+const HTMLEditor = ({
   intl,
   variant = HTML_EDITOR_VARIANTS.EMAIL, // New prop: 'email' or 'inapp'
   layoutType, // Layout type for InApp variant
@@ -89,33 +61,17 @@ const HTMLEditor = forwardRef(({
   showFullscreenButton = true,
   autoSave = true,
   autoSaveInterval = 30000, // 30 seconds
-  // Tag-related props - tags are fetched and managed by parent component (EmailHTMLEditor, INAPP, etc.)
-  tags = [],
-  injectedTags = {},
-  location,
-  eventContextTags = [],
-  selectedOfferDetails = [],
-  channel,
-  userLocale = 'en',
-  moduleFilterEnabled = true,
-  onTagContextChange, // Parent component handles tag fetching
-  onTagSelect = null,
-  onContextChange = null,
-  globalActions = null,
-  isLiquidEnabled = false, // Controls Liquid tab visibility in ValidationTabs
-  isFullMode = true, // Full mode vs library mode - controls layout and visibility
-  onErrorAcknowledged = null, // Callback when user clicks redirection icon to acknowledge errors
-  onValidationChange = null, // Callback when validation state changes (for parent to track errors)
-  apiValidationErrors = null, // API validation errors from validateLiquidTemplateContent { liquidErrors: [], standardErrors: [] }
   ...props
-}, ref) => {
+}) => {
   // Separate refs for main and modal editors to avoid conflicts
   const mainEditorRef = useRef(null);
   const modalEditorRef = useRef(null);
   const [isFullscreenModalOpen, setIsFullscreenModalOpen] = useState(false);
 
   // Get the currently active editor ref based on fullscreen state
-  const getActiveEditorRef = useCallback(() => isFullscreenModalOpen ? modalEditorRef : mainEditorRef, [isFullscreenModalOpen]);
+  const getActiveEditorRef = useCallback(() => {
+    return isFullscreenModalOpen ? modalEditorRef : mainEditorRef;
+  }, [isFullscreenModalOpen]);
 
   // Initialize custom hooks for state management - always call both hooks to follow Rules of Hooks
   const isEmailVariant = variant === HTML_EDITOR_VARIANTS.EMAIL;
@@ -124,7 +80,7 @@ const HTMLEditor = forwardRef(({
     autoSave: isEmailVariant ? autoSave : false,
     autoSaveInterval,
     onSave: isEmailVariant ? onSave : null,
-    onChange: isEmailVariant ? onContentChange : null,
+    onChange: isEmailVariant ? onContentChange : null
   };
 
   const emailContent = useEditorContent(
@@ -141,7 +97,7 @@ const HTMLEditor = forwardRef(({
       // Convert string content to device-specific format
       inAppInitialContent = {
         [DEVICE_TYPES.ANDROID]: initialContent,
-        [DEVICE_TYPES.IOS]: initialContent,
+        [DEVICE_TYPES.IOS]: initialContent
       };
     } else {
       // Use provided device-specific content
@@ -153,7 +109,7 @@ const HTMLEditor = forwardRef(({
     autoSave: isInAppVariant ? autoSave : false,
     autoSaveInterval,
     onSave: isInAppVariant ? onSave : null,
-    onChange: isInAppVariant ? onContentChange : null,
+    onChange: isInAppVariant ? onContentChange : null
   };
 
   const inAppContent = useInAppContent(inAppInitialContent, inAppOptions);
@@ -161,64 +117,6 @@ const HTMLEditor = forwardRef(({
   // Use appropriate content hook based on variant
   const content = variant === HTML_EDITOR_VARIANTS.EMAIL ? emailContent : inAppContent;
 
-  // Update content when initialContent prop changes (for edit mode)
-  // This ensures the editor updates when template data loads
-  useEffect(() => {
-    if (isEmailVariant && emailContent && initialContent !== undefined && initialContent !== null) {
-      // Only update if content is different to avoid unnecessary updates
-      if (emailContent.content !== initialContent) {
-        emailContent.updateContent(initialContent, true); // immediate update
-      }
-    } else if (isInAppVariant && inAppContent && initialContent !== undefined && initialContent !== null) {
-      // Handle InApp variant updates
-      const contentToUpdate = typeof initialContent === 'string'
-        ? { [DEVICE_TYPES.ANDROID]: initialContent, [DEVICE_TYPES.IOS]: initialContent }
-        : initialContent;
-      if (inAppContent.updateContent) {
-        const currentContent = inAppContent.getDeviceContent?.(inAppContent.activeDevice);
-        const newContent = contentToUpdate[inAppContent.activeDevice] || contentToUpdate[DEVICE_TYPES.ANDROID] || '';
-        if (currentContent !== newContent) {
-          inAppContent.updateContent(newContent, true);
-        }
-      }
-    }
-  }, [initialContent, isEmailVariant, isInAppVariant]);
-  // Handle context change for tag API calls
-  // If variant is INAPP, use SMS layout; otherwise use the channel (EMAIL)
-  const handleContextChange = useCallback((contextData) => {
-    // If onContextChange is provided, use it instead of making our own API call
-    // This prevents duplicate API calls when parent component handles tag fetching
-    if (onContextChange) {
-      onContextChange(contextData);
-      return;
-    }
-
-    // Only make API call if onContextChange is not provided and globalActions is available
-    if (!globalActions || !location) {
-      return;
-    }
-
-    const { type } = location.query || {};
-    const tempData = (contextData || '').toLowerCase();
-    const isEmbedded = type === EMBEDDED;
-    const embedded = isEmbedded ? type : FULL;
-    const context = tempData === ALL ? DEFAULT : tempData;
-
-    // Determine layout: INAPP variant uses SMS, EMAIL variant uses EMAIL
-    const layout = variant === HTML_EDITOR_VARIANTS.INAPP ? SMS : EMAIL;
-
-    const query = {
-      layout,
-      type: TAG,
-      context,
-      embedded,
-    };
-
-    // Call the API via Redux action - this will trigger the saga which calls Api.fetchSchemaForEntity
-    // The API endpoint will be: /meta/TAG?query={...}
-    globalActions.fetchSchemaForEntity(query);
-  }, [variant, globalActions, location, onContextChange]);
-
   // Destructure content properties for cleaner access throughout component
   const {
     activeDevice,
@@ -226,14 +124,14 @@ const HTMLEditor = forwardRef(({
     switchDevice,
     toggleContentSync,
     getDeviceContent,
-    markAsSaved,
+    markAsSaved
   } = content || {};
 
   const layout = useLayoutState({
     splitSizes: [50, 50],
     viewMode: 'desktop',
     mobileWidth: 375,
-    isFullscreen: false,
+    isFullscreen: false
   });
 
   // Get current content for validation based on variant
@@ -260,7 +158,7 @@ const HTMLEditor = forwardRef(({
       'sanitizer.productionValidHtml': messages.sanitizer.productionValidHtml,
       'sanitizer.productionSanitized': messages.sanitizer.productionSanitized,
       'sanitizer.productionInlineCss': messages.sanitizer.productionInlineCss,
-      'sanitizer.productionLargeContent': messages.sanitizer.productionLargeContent,
+      'sanitizer.productionLargeContent': messages.sanitizer.productionLargeContent
     };
 
     const messageObj = messageMap[messageKey];
@@ -281,7 +179,7 @@ const HTMLEditor = forwardRef(({
       'validator.largeImageDetected': messages.validator.largeImageDetected,
       'validator.unclosedCssRule': messages.validator.unclosedCssRule,
       'validator.emptyCssRule': messages.validator.emptyCssRule,
-      'validator.cssValidationFailed': messages.validator.cssValidationFailed,
+      'validator.cssValidationFailed': messages.validator.cssValidationFailed
     };
 
     const messageObj = messageMap[messageKey];
@@ -292,215 +190,57 @@ const HTMLEditor = forwardRef(({
     enableRealTime: true,
     debounceMs: 500,
     enableSanitization: true,
-    securityLevel: 'standard',
-    apiValidationErrors, // Pass API validation errors to merge with client-side validation
+    securityLevel: 'standard'
   }, formatSanitizerMessage, formatValidatorMessage);
 
-  // Expose validation and content state via ref
-  useImperativeHandle(ref, () => ({
-    getValidation: () => validation,
-    getContent: () => currentContent,
-    isContentEmpty: () => !currentContent || currentContent.trim() === '',
-    getIssueCounts: () => {
-      if (!validation || typeof validation.getAllIssues !== 'function') {
-        return { errors: 0, warnings: 0, total: 0 };
-      }
-      return countIssuesBySeverity(validation.getAllIssues());
-    },
-    getValidationState: () => ({
-      isValidating: validation?.isValidating || false,
-      hasErrors: validation?.hasBlockingErrors || false,
-      issueCounts: !validation || typeof validation.getAllIssues !== 'function'
-        ? { errors: 0, warnings: 0, total: 0 }
-        : countIssuesBySeverity(validation.getAllIssues()),
-    })
-    ,
-  }), [validation, currentContent, apiValidationErrors]); // Include apiValidationErrors so ref methods return updated counts
-
-  // Use ref to store callback to avoid infinite loops (callback in deps would cause re-runs)
-  const onValidationChangeRef = useRef(onValidationChange);
-  useEffect(() => {
-    onValidationChangeRef.current = onValidationChange;
-  }, [onValidationChange]);
-
-  // Track last sent validation state to prevent duplicate updates
-  const lastSentValidationStateRef = useRef(null);
-
-  // Store validation ref to access current value without triggering re-renders
-  const validationRef = useRef(validation);
-  validationRef.current = validation;
-
-  // Extract STABLE primitive values from validation for dependency array
-  const isValidating = validation?.isValidating;
-  const validationTotalErrors = validation?.summary?.totalErrors || 0;
-  const validationTotalWarnings = validation?.summary?.totalWarnings || 0;
-  const validationLastValidated = validation?.lastValidated?.getTime?.() || null;
-  // Only Rule Group #1 (Input & Sanitization) blocks; use for UI gating (Done/Update/Preview/Test)
-  const validationHasBlockingErrors = validation?.hasBlockingErrors || false;
-
-  // Notify parent component when validation state changes
-  useEffect(() => {
-    if (!onValidationChangeRef.current) {
-      return;
-    }
-
-    // Skip if still validating (wait for validation to complete)
-    if (isValidating) {
-      return;
-    }
-
-    // Calculate issue counts: Errors (blocking) and Warnings (non-blocking)
-    const calculateIssueCounts = () => {
-      const currentValidation = validationRef.current;
-      if (!currentValidation || typeof currentValidation.getAllIssues !== 'function') {
-        return { errors: 0, warnings: 0, total: 0 };
-      }
-      return countIssuesBySeverity(currentValidation.getAllIssues());
-    };
-
-    const issueCounts = calculateIssueCounts();
-    const isContentEmpty = !currentContent || currentContent.trim() === '';
-
-    // hasErrors = only Rule Group #1 (Input & Sanitization) – gates Done/Update/Preview/Test
-    const newState = {
-      isContentEmpty,
-      issueCounts,
-      validationComplete: true,
-      hasErrors: validationRef.current?.hasBlockingErrors ?? false,
-    };
-
-    // Only call callback if state actually changed (prevent infinite loops)
-    const lastState = lastSentValidationStateRef.current;
-    const hasChanged = !lastState
-      || lastState.isContentEmpty !== newState.isContentEmpty
-      || lastState.validationComplete !== newState.validationComplete
-      || lastState.hasErrors !== newState.hasErrors
-      || lastState.issueCounts?.total !== newState.issueCounts?.total
-      || lastState.issueCounts?.errors !== newState.issueCounts?.errors
-      || lastState.issueCounts?.warnings !== newState.issueCounts?.warnings;
-
-    if (hasChanged) {
-      lastSentValidationStateRef.current = newState;
-      onValidationChangeRef.current(newState);
-    }
-  }, [isValidating, validationTotalErrors, validationTotalWarnings, validationLastValidated, validationHasBlockingErrors, currentContent, apiValidationErrors]);
+  // Handle label insertion at cursor position
+  const handleLabelInsert = useCallback((label, position) => {
+    // With injectIntl({ forwardRef: true }), ref points directly to CodeEditorPane
+    const activeEditorRef = getActiveEditorRef();
+    const editor = activeEditorRef.current;
 
-  // Send initial state on mount to ensure parent has correct initial button state
-  const hasInitializedRef = useRef(false);
-  useEffect(() => {
-    if (hasInitializedRef.current || !onValidationChangeRef.current) {
-      return;
-    }
-    hasInitializedRef.current = true;
-
-    // Send initial state with validationComplete=false to indicate validation pending
-    const isContentEmpty = !currentContent || currentContent.trim() === '';
-    onValidationChangeRef.current({
-      isContentEmpty,
-      issueCounts: { errors: 0, warnings: 0, total: 0 },
-      validationComplete: false, // Validation hasn't run yet
-      hasErrors: false,
-    });
-  }, [currentContent]); // Only depend on currentContent to run on initial content load
-
-  // Force validation state recalculation when API validation errors change
-  // This ensures that API errors are included in issue counts and displayed in ValidationErrorDisplay
-  useEffect(() => {
-    if (!onValidationChangeRef.current) {
+    if (!editor) {
+      CapNotification.warning({
+        message: intl.formatMessage(messages.labelInsertError),
+        description: intl.formatMessage(messages.editorNotReady),
+        duration: 3
+      });
       return;
     }
 
-    // Skip if still validating (wait for validation to complete)
-    if (validation?.isValidating) {
+    // Check if the required methods exist
+    if (typeof editor?.insertText !== 'function') {
+      CapNotification.error({
+        message: intl.formatMessage(messages.labelInsertError),
+        description: intl.formatMessage(messages.editorMethodNotAvailable),
+        duration: 4
+      });
       return;
     }
 
-    // Recalculate issue counts (Errors + Warnings) including API errors
-    const issueCounts = !validation || typeof validation.getAllIssues !== 'function'
-      ? { errors: 0, warnings: 0, total: 0 }
-      : countIssuesBySeverity(validation.getAllIssues());
-    const isContentEmpty = !currentContent || currentContent.trim() === '';
-
-    const newState = {
-      isContentEmpty,
-      issueCounts,
-      validationComplete: true,
-      hasErrors: validation?.hasBlockingErrors ?? false,
-    };
-
-    const lastState = lastSentValidationStateRef.current;
-    const hasChanged = !lastState
-      || lastState.hasErrors !== newState.hasErrors
-      || lastState.issueCounts?.total !== newState.issueCounts?.total
-      || lastState.issueCounts?.errors !== newState.issueCounts?.errors
-      || lastState.issueCounts?.warnings !== newState.issueCounts?.warnings;
+    try {
+      // Get current cursor position or use provided position
+      const cursor = position !== undefined
+        ? position
+        : (typeof editor?.getCursor === 'function' ? editor.getCursor() : 0);
 
-    if (hasChanged) {
-      lastSentValidationStateRef.current = newState;
-      onValidationChangeRef.current(newState);
-    }
-  }, [apiValidationErrors, validation, currentContent, onValidationChangeRef]);
+      // Insert label at cursor position
+      editor.insertText(label, cursor);
 
-  // Handle label insertion at cursor position
-  // Note: This is called for notification purposes only when tag is inserted via CodeEditorPane
-  // The actual insertion happens in CodeEditorPane.handleTagSelect
-  const handleLabelInsert = useCallback((label, position) => {
-    // If position is explicitly null, it means the editor wasn't ready when tag was selected
-    // In this case, CodeEditorPane couldn't insert the tag, so we should try here
-    if (position === null) {
-      // With injectIntl({ forwardRef: true }), ref points directly to CodeEditorPane
-      const activeEditorRef = getActiveEditorRef();
-      const editor = activeEditorRef.current;
-
-      if (!editor) {
-        CapNotification.warning({
-          message: intl.formatMessage(messages.labelInsertError),
-          description: intl.formatMessage(messages.editorNotReady),
-          duration: 3,
-        });
-        return;
-      }
+      // Focus the editor if focus method is available
+      editor?.focus?.();
 
-      // Check if the required methods exist
-      if (typeof editor?.insertText !== 'function') {
-        CapNotification.error({
-          message: intl.formatMessage(messages.labelInsertError),
-          description: intl.formatMessage(messages.editorMethodNotAvailable),
-          duration: 4,
-        });
-        return;
-      }
-
-      try {
-        // Get current cursor position
-        const cursor = typeof editor?.getCursor === 'function' ? editor.getCursor() : 0;
-
-        // Insert label at cursor position
-        editor.insertText(label, cursor);
-
-        // Focus the editor if focus method is available
-        editor?.focus?.();
-
-        // Show success notification
-        CapNotification.success({
-          message: intl.formatMessage(messages.labelInserted),
-          description: intl.formatMessage(messages.labelInsertedDescription, { label }),
-          duration: 2,
-        });
-      } catch (error) {
-        CapNotification.error({
-          message: intl.formatMessage(messages.labelInsertError),
-          description: error.message,
-          duration: 4,
-        });
-      }
-    } else {
-      // Tag was already inserted by CodeEditorPane (position is a valid number)
-      // Just show success notification - no need to access editor
+      // Show success notification
       CapNotification.success({
         message: intl.formatMessage(messages.labelInserted),
         description: intl.formatMessage(messages.labelInsertedDescription, { label }),
-        duration: 2,
+        duration: 2
+      });
+    } catch (error) {
+      CapNotification.error({
+        message: intl.formatMessage(messages.labelInsertError),
+        description: error.message,
+        duration: 4
       });
     }
   }, [intl, getActiveEditorRef]);
@@ -509,23 +249,23 @@ const HTMLEditor = forwardRef(({
   const handleSave = useCallback(() => {
     try {
       const { html, css, javascript } = content?.content || {};
-      const contentToSave = { html, css, javascript };
+      const currentContent = { html, css, javascript };
 
       if (onSave) {
-        onSave(contentToSave);
+        onSave(currentContent);
       }
 
       markAsSaved?.();
 
       CapNotification.success({
         message: intl.formatMessage(messages.contentSaved),
-        duration: 2,
+        duration: 2
       });
     } catch (error) {
       CapNotification.error({
         message: intl.formatMessage(messages.saveError),
         description: error.message,
-        duration: 4,
+        duration: 4
       });
     }
   }, [content, onSave, intl, markAsSaved]);
@@ -536,27 +276,21 @@ const HTMLEditor = forwardRef(({
     const editorInstance = activeEditorRef.current;
     const { line, column = 1 } = error || {};
 
-    // Notify parent that user acknowledged errors by clicking redirection icon
-    // This enables the buttons even if we can't navigate to a specific line
-    if (onErrorAcknowledged) {
-      onErrorAcknowledged();
-    }
-
-    if (editorInstance) {
+    if (editorInstance && line) {
       try {
-        // If line number exists, navigate to it; otherwise just focus the editor
-        if (line && editorInstance?.navigateToLine) {
+        // Access the CodeMirror view through the exposed ref methods
+        if (editorInstance?.navigateToLine) {
           editorInstance.navigateToLine(line, column);
         } else {
-          // For API errors without line numbers, just focus the editor
           editorInstance?.focus?.();
+          // Fallback: just focus the editor if navigation isn't available
         }
       } catch (err) {
         // Fallback: just focus the editor
         editorInstance?.focus?.();
       }
     }
-  }, [getActiveEditorRef, onErrorAcknowledged]);
+  }, [getActiveEditorRef]);
 
   // Handle fullscreen modal
   const handleOpenFullscreen = useCallback(() => {
@@ -573,7 +307,6 @@ const HTMLEditor = forwardRef(({
     content,
     layout,
     validation,
-    isLiquidEnabled,
     editorRef: getActiveEditorRef(),
     handleLabelInsert,
     handleSave,
@@ -586,14 +319,13 @@ const HTMLEditor = forwardRef(({
       switchDevice,
       toggleContentSync,
       getDeviceContent,
-      layoutType,
-    }),
+      layoutType
+    })
   }), [
     variant,
     content,
     layout,
     validation,
-    isLiquidEnabled,
     getActiveEditorRef,
     handleLabelInsert,
     handleSave,
@@ -604,7 +336,7 @@ const HTMLEditor = forwardRef(({
     switchDevice,
     toggleContentSync,
     getDeviceContent,
-    layoutType,
+    layoutType
   ]);
 
   // Loading state
@@ -616,14 +348,9 @@ const HTMLEditor = forwardRef(({
     );
   }
 
-  // Add library-mode class when not in full mode
-  // Note: isFullMode defaults to true, so library mode is when isFullMode === false
-  const isLibraryMode = isFullMode === false;
-  const editorClassName = `html-editor html-editor--${variant} ${isLibraryMode ? 'html-editor--library-mode' : ''} ${className}`.trim();
-
   return (
     <EditorProvider value={contextValue}>
-      <div className={editorClassName} {...props}>
+      <div className={`html-editor html-editor--${variant} ${className}`} {...props}>
         {/* Editor Toolbar - Conditional based on variant */}
         {variant === HTML_EDITOR_VARIANTS.EMAIL ? (
           <EditorToolbar
@@ -660,23 +387,19 @@ const HTMLEditor = forwardRef(({
               ref={mainEditorRef}
               readOnly={readOnly}
               onLabelInsert={handleLabelInsert}
-              onErrorClick={handleValidationErrorClick}
-              tags={tags}
-              injectedTags={injectedTags}
-              location={location}
-              eventContextTags={eventContextTags}
-              selectedOfferDetails={selectedOfferDetails}
-              channel={channel}
-              userLocale={userLocale}
-              moduleFilterEnabled={moduleFilterEnabled}
-              onTagContextChange={onTagContextChange}
-              onTagSelect={onTagSelect}
-              onContextChange={handleContextChange}
             />
 
             {/* Preview Pane */}
             <PreviewPane />
           </SplitContainer>
+
+          {/* Validation Display - Full Width Below Split Container */}
+          <ValidationErrorDisplay
+            validation={validation}
+            onErrorClick={handleValidationErrorClick}
+            variant={variant}
+            className="html-editor-validation"
+          />
         </CapRow>
 
         {/* Fullscreen Modal */}
@@ -685,20 +408,20 @@ const HTMLEditor = forwardRef(({
           visible={isFullscreenModalOpen}
           onCancel={handleCloseFullscreen}
           footer={null}
-          maskClosable
+          maskClosable={false}
           centered
           closable={false}
-          width="93vw"
+          width={"90vw"}
           className="html-editor-fullscreen-modal"
         >
-          <CapRow className={`html-editor-fullscreen html-editor-fullscreen--${variant} ${isLibraryMode ? 'html-editor-fullscreen--library-mode' : ''}`}>
+          <CapRow className="html-editor-fullscreen">
             {/* Editor Toolbar - Conditional based on variant */}
             {variant === HTML_EDITOR_VARIANTS.EMAIL ? (
               <EditorToolbar
-                showFullscreenButton // Show fullscreen button in modal to allow closing
+                showFullscreenButton={true} // Show fullscreen button in modal to allow closing
                 onLabelInsert={handleLabelInsert}
                 onSave={handleSave}
-                isFullscreenMode
+                isFullscreenMode={true}
                 onToggleFullscreen={handleCloseFullscreen} // Close modal when clicked in fullscreen mode
               />
             ) : (
@@ -711,10 +434,10 @@ const HTMLEditor = forwardRef(({
                   onKeepContentSameChange={toggleContentSync}
                 />
                 <EditorToolbar
-                  showFullscreenButton // Show fullscreen button in modal to allow closing
+                  showFullscreenButton={true} // Show fullscreen button in modal to allow closing
                   onLabelInsert={handleLabelInsert}
                   onSave={handleSave}
-                  isFullscreenMode
+                  isFullscreenMode={true}
                   onToggleFullscreen={handleCloseFullscreen} // Close modal when clicked in fullscreen mode
                   variant={variant}
                   showTitle={false} // Hide title in InApp variant
@@ -729,30 +452,28 @@ const HTMLEditor = forwardRef(({
                 <CodeEditorPane
                   ref={modalEditorRef}
                   readOnly={readOnly}
-                  isFullscreenMode
+                  isFullscreenMode={true}
                   onLabelInsert={handleLabelInsert}
-                  onErrorClick={handleValidationErrorClick}
-                  tags={tags}
-                  injectedTags={injectedTags}
-                  location={location}
-                  eventContextTags={eventContextTags}
-                  selectedOfferDetails={selectedOfferDetails}
-                  channel={channel}
-                  userLocale={userLocale}
-                  moduleFilterEnabled={moduleFilterEnabled}
-                  onTagContextChange={onTagContextChange}
                 />
 
-                {/* Preview Pane */}
-                <PreviewPane isFullscreenMode isModalContext />
-              </SplitContainer>
+              {/* Preview Pane */}
+              <PreviewPane isFullscreenMode={true} isModalContext={true} />
+            </SplitContainer>
+
+            {/* Validation Display in Modal */}
+            <ValidationErrorDisplay
+              validation={validation}
+              onErrorClick={handleValidationErrorClick}
+              variant={variant}
+              className="html-editor-validation"
+            />
             </CapRow>
           </CapRow>
         </CapModal>
       </div>
     </EditorProvider>
   );
-});
+};
 
 HTMLEditor.propTypes = {
   intl: intlShape.isRequired,
@@ -760,7 +481,7 @@ HTMLEditor.propTypes = {
   layoutType: PropTypes.string, // Layout type for InApp variant
   initialContent: PropTypes.oneOfType([
     PropTypes.string,
-    PropTypes.objectOf(PropTypes.string), // Per-device content for INAPP variant
+    PropTypes.objectOf(PropTypes.string) // Per-device content for INAPP variant
   ]),
   onSave: PropTypes.func,
   onContentChange: PropTypes.func,
@@ -768,33 +489,11 @@ HTMLEditor.propTypes = {
   readOnly: PropTypes.bool,
   showFullscreenButton: PropTypes.bool,
   autoSave: PropTypes.bool,
-  autoSaveInterval: PropTypes.number,
-  // Tag-related props - tags are fetched and managed by parent component
-  tags: PropTypes.array,
-  injectedTags: PropTypes.object,
-  location: PropTypes.object,
-  eventContextTags: PropTypes.array,
-  selectedOfferDetails: PropTypes.array,
-  channel: PropTypes.string,
-  userLocale: PropTypes.string,
-  moduleFilterEnabled: PropTypes.bool,
-  onTagContextChange: PropTypes.func, // Required - parent must handle tag fetching
-  onTagSelect: PropTypes.func,
-  onContextChange: PropTypes.func, // Deprecated: use globalActions instead
-  globalActions: PropTypes.object,
-  isLiquidEnabled: PropTypes.bool, // Controls Liquid tab visibility in validation
-  isFullMode: PropTypes.bool, // Full mode vs library mode
-  onErrorAcknowledged: PropTypes.func, // Callback when user clicks redirection icon to acknowledge errors
-  onValidationChange: PropTypes.func, // Callback when validation state changes
-  apiValidationErrors: PropTypes.shape({
-    liquidErrors: PropTypes.arrayOf(PropTypes.string),
-    standardErrors: PropTypes.arrayOf(PropTypes.string),
-  }), // API validation errors from validateLiquidTemplateContent
+  autoSaveInterval: PropTypes.number
 };
 
 HTMLEditor.defaultProps = {
   variant: HTML_EDITOR_VARIANTS.EMAIL, // Default to email variant
-  layoutType: null,
   initialContent: null, // Will use default from useEditorContent hook
   onSave: null,
   onContentChange: null,
@@ -802,26 +501,8 @@ HTMLEditor.defaultProps = {
   readOnly: false,
   showFullscreenButton: true,
   autoSave: true,
-  autoSaveInterval: 30000,
-  // Tag-related defaults - tags are fetched and managed by parent component
-  tags: [],
-  injectedTags: {},
-  location: null,
-  eventContextTags: [],
-  selectedOfferDetails: [],
-  channel: null,
-  userLocale: 'en',
-  moduleFilterEnabled: true,
-  onTagContextChange: null, // Parent component should provide this
-  onTagSelect: null,
-  onContextChange: null,
-  globalActions: null, // Redux actions for API calls
-  isLiquidEnabled: false,
-  isFullMode: true, // Default to full mode
-  onErrorAcknowledged: null, // Callback when user clicks redirection icon to acknowledge errors
-  onValidationChange: null, // Callback when validation state changes
-  apiValidationErrors: null, // API validation errors from validateLiquidTemplateContent
+  autoSaveInterval: 30000
 };
 
-// Export with injectIntl - HTMLEditor now uses forwardRef internally
-export default injectIntl(HTMLEditor);
+// Export with forwardRef to allow direct access to CodeEditorPane via ref
+export default injectIntl(HTMLEditor, { forwardRef: true });