@base44-preview/vite-plugin 0.2.22-pr.36.db00ef7 → 0.2.22-pr.37.68542f2

package/src/injections/visual-edit-agent/capabilities/inline-editing/index.ts

@@ -0,0 +1,10 @@
+export {
+  enterInlineEditingMode,
+  clearInlineEditingMode,
+  shouldEnterInlineEditingMode,
+  setInlineEditCallback,
+} from "./core.js";
+
+export { injectFocusOutlineCSS, removeFocusOutlineCSS } from "./styles.js";
+
+export { isEditableTextElement, selectText } from "./validation.js";

package/src/injections/visual-edit-agent/capabilities/inline-editing/styles.ts

@@ -0,0 +1,26 @@
+/**
+ * Inject CSS to suppress the browser's default focus outline on contentEditable elements
+ */
+export function injectFocusOutlineCSS(): void {
+  const existingStyle = document.getElementById("visual-edit-focus-styles");
+  if (existingStyle) return;
+
+  const style = document.createElement("style");
+  style.id = "visual-edit-focus-styles";
+  style.textContent = `
+    [data-selected="true"][contenteditable="true"]:focus {
+      outline: none !important;
+    }
+  `;
+  document.head.appendChild(style);
+}
+
+/**
+ * Remove the injected focus outline CSS
+ */
+export function removeFocusOutlineCSS(): void {
+  const style = document.getElementById("visual-edit-focus-styles");
+  if (style) {
+    style.remove();
+  }
+}

package/src/injections/visual-edit-agent/capabilities/inline-editing/validation.ts

@@ -0,0 +1,67 @@
+/**
+ * Select all text content in an element using the Selection API
+ */
+export function selectText(element: HTMLElement): void {
+  const range = document.createRange();
+  range.selectNodeContents(element);
+  const selection = window.getSelection();
+  selection?.removeAllRanges();
+  selection?.addRange(range);
+}
+
+/**
+ * Check if an element is an editable text element
+ * Based on the eligibility rules from inlineEdit.md (non-dynamic only)
+ */
+export function isEditableTextElement(element: Element): boolean {
+  // Must be an HTMLElement
+  if (!(element instanceof HTMLElement)) {
+    return false;
+  }
+
+  // Must be an allowed tag
+  const allowedTags = [
+    "div",
+    "p",
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "span",
+    "li",
+    "td",
+    "a",
+    "button",
+    "label",
+  ];
+  if (!allowedTags.includes(element.tagName.toLowerCase())) {
+    return false;
+  }
+
+  // Must have text content
+  const textContent = element.textContent?.trim() || "";
+  if (textContent.length === 0) {
+    return false;
+  }
+
+  // Must NOT contain img, video, canvas, or svg
+  const hasMediaElements =
+    element.querySelector("img, video, canvas, svg") !== null;
+  if (hasMediaElements) {
+    return false;
+  }
+
+  // Must NOT have complex children (must be a leaf text node or simple container)
+  if (element.children.length > 0) {
+    return false;
+  }
+
+  // Must NOT be dynamic content
+  if (element.dataset.dynamicContent === "true") {
+    return false;
+  }
+
+  return true;
+}

package/src/injections/visual-edit-agent/constants.ts

@@ -0,0 +1,9 @@
+export const INLINE_EDIT_DEBOUNCE_MS = 500;
+export const OVERLAY_TRANSITION = "all 0.1s ease-in-out";
+export const OVERLAY_Z_INDEX = "9999";
+export const SELECTED_BORDER_COLOR = "#2563EB";
+export const HOVER_BORDER_COLOR = "#95a5fc";
+export const HOVER_BACKGROUND_COLOR = "rgba(99, 102, 241, 0.05)";
+export const LABEL_TOP_OFFSET = "-27px";
+export const LABEL_LEFT_OFFSET = "-2px";
+export const REPOSITION_DELAY_MS = 50;

package/src/injections/visual-edit-agent/handlers/click-handlers.ts

@@ -0,0 +1,134 @@
+import type { AgentState } from "../state/agent-state.js";
+import { OutgoingMessageType } from "./messages/types.js";
+import { findElementsById } from "../../utils.js";
+import { createOverlay, positionOverlay, clearSelection } from "../ui/overlay.js";
+import { clearHoverOverlays } from "./hover-handlers.js";
+import { shouldEnterInlineEditingMode } from "../capabilities/inline-editing/index.js";
+import { handleClearInlineEditingMode, handleEnterInlineEditingMode } from "./inline-edit-handlers.js";
+import { getElementPosition, getElementClasses } from "../utils/dom-utils.js";
+
+/**
+ * Handle element selection (first click)
+ */
+export function handleElementSelection(
+  state: AgentState,
+  element: Element,
+  visualSelectorId: string | null
+): void {
+  if (state.currentEditingElement) {
+    handleClearInlineEditingMode(state);
+  }
+  clearSelection(state);
+
+  // Find all elements with the same ID
+  const elements = findElementsById(visualSelectorId);
+
+  // Mark elements as selected
+  elements.forEach((el) => {
+    if (el instanceof HTMLElement) {
+      el.dataset.selected = "true";
+    }
+  });
+
+  // Create selected overlays for all matching elements
+  elements.forEach((el) => {
+    const overlay = createOverlay(true);
+    document.body.appendChild(overlay);
+    state.selectedOverlays.push(overlay);
+    positionOverlay(overlay, el, true, state.isVisualEditMode);
+  });
+
+  state.selectedElementId = visualSelectorId;
+
+  // Clear hover overlays
+  clearHoverOverlays(state);
+
+  // Send message to parent window with element info
+  const htmlElement = element as HTMLElement;
+  const elementData = {
+    type: OutgoingMessageType.ELEMENT_SELECTED,
+    tagName: element.tagName,
+    classes: getElementClasses(element),
+    visualSelectorId: visualSelectorId,
+    content: htmlElement.innerText,
+    dataSourceLocation: htmlElement.dataset.sourceLocation,
+    isDynamicContent: htmlElement.dataset.dynamicContent === "true",
+    linenumber: htmlElement.dataset.linenumber,
+    filename: htmlElement.dataset.filename,
+    position: getElementPosition(element.getBoundingClientRect()),
+  };
+  window.parent.postMessage(elementData, "*");
+}
+
+/**
+ * Handle element click
+ */
+export function handleElementClick(state: AgentState, e: MouseEvent): void {
+  if (!state.isVisualEditMode) return;
+
+  const target = e.target as Element;
+
+  // Bail out early if clicking on a contentEditable element (allow normal editing)
+  if (target instanceof HTMLElement && target.contentEditable === "true") {
+    return;
+  }
+
+  // If currently editing, clicking outside should exit editing mode
+  if (state.currentEditingElement) {
+    e.preventDefault();
+    e.stopPropagation();
+    e.stopImmediatePropagation();
+    handleClearInlineEditingMode(state);
+    return;
+  }
+
+  // Close dropdowns when clicking anywhere in iframe if a dropdown is open
+  if (state.isDropdownOpen) {
+    e.preventDefault();
+    e.stopPropagation();
+    e.stopImmediatePropagation();
+
+    window.parent.postMessage({ type: OutgoingMessageType.CLOSE_DROPDOWNS }, "*");
+    return;
+  }
+
+  // Prevent clicking on SVG path elements
+  if (target.tagName.toLowerCase() === "path") {
+    return;
+  }
+
+  // Prevent default behavior immediately when in visual edit mode
+  e.preventDefault();
+  e.stopPropagation();
+  e.stopImmediatePropagation();
+
+  // Support both data-source-location and data-visual-selector-id
+  const element = target.closest(
+    "[data-source-location], [data-visual-selector-id]"
+  );
+  if (!element) {
+    return;
+  }
+
+  const htmlElement = element as HTMLElement;
+  const visualSelectorId =
+    htmlElement.dataset.sourceLocation ||
+    htmlElement.dataset.visualSelectorId;
+
+  // Check if this element is already selected (second click scenario)
+  const isAlreadySelected =
+    state.selectedElementId === visualSelectorId &&
+    htmlElement.dataset.selected === "true";
+
+  if (isAlreadySelected) {
+    // Second click on already-selected element: check if it should enter inline editing
+    // Only if the experiment is enabled
+    if (state.isInlineEditExperimentEnabled && shouldEnterInlineEditingMode(htmlElement)) {
+      handleEnterInlineEditingMode(state, htmlElement);
+      return;
+    }
+  }
+
+  // First click: select the element
+  handleElementSelection(state, element, visualSelectorId || null);
+}

package/src/injections/visual-edit-agent/handlers/hover-handlers.ts

@@ -0,0 +1,78 @@
+import type { AgentState } from "../state/agent-state.js";
+import { findElementsById } from "../../utils.js";
+import { createOverlay, positionOverlay, clearOverlays } from "../ui/overlay.js";
+
+/**
+ * Clear hover overlays
+ */
+export function clearHoverOverlays(state: AgentState): void {
+  clearOverlays(state.hoverOverlays);
+  state.hoverOverlays = [];
+  state.currentHighlightedElements = [];
+}
+
+/**
+ * Handle mouse over event
+ */
+export function handleMouseOver(state: AgentState, e: MouseEvent): void {
+  if (!state.isVisualEditMode || state.isPopoverDragging || state.currentEditingElement) return;
+
+  const target = e.target as Element;
+
+  // Prevent hover effects when a dropdown is open
+  if (state.isDropdownOpen) {
+    clearHoverOverlays(state);
+    return;
+  }
+
+  // Prevent hover effects on SVG path elements
+  if (target.tagName.toLowerCase() === "path") {
+    clearHoverOverlays(state);
+    return;
+  }
+
+  // Support both data-source-location and data-visual-selector-id
+  const element = target.closest(
+    "[data-source-location], [data-visual-selector-id]"
+  );
+  if (!element) {
+    clearHoverOverlays(state);
+    return;
+  }
+
+  // Prefer data-source-location, fallback to data-visual-selector-id
+  const htmlElement = element as HTMLElement;
+  const selectorId =
+    htmlElement.dataset.sourceLocation ||
+    htmlElement.dataset.visualSelectorId;
+
+  // Skip if this element is already selected
+  if (state.selectedElementId === selectorId) {
+    clearHoverOverlays(state);
+    return;
+  }
+
+  // Find all elements with the same ID
+  const elements = findElementsById(selectorId || null);
+
+  // Clear previous hover overlays
+  clearHoverOverlays(state);
+
+  // Create overlays for all matching elements
+  elements.forEach((el) => {
+    const overlay = createOverlay(false);
+    document.body.appendChild(overlay);
+    state.hoverOverlays.push(overlay);
+    positionOverlay(overlay, el, false, state.isVisualEditMode);
+  });
+
+  state.currentHighlightedElements = elements;
+}
+
+/**
+ * Handle mouse out event
+ */
+export function handleMouseOut(state: AgentState): void {
+  if (state.isPopoverDragging || state.currentEditingElement) return;
+  clearHoverOverlays(state);
+}

package/src/injections/visual-edit-agent/handlers/inline-edit-handlers.ts

@@ -0,0 +1,136 @@
+import type { AgentState } from "../state/agent-state.js";
+import { OutgoingMessageType } from "./messages/types.js";
+import { repositionSelectedOverlays } from "../ui/overlay.js";
+import {
+  enterInlineEditingMode,
+  clearInlineEditingMode,
+  setInlineEditCallback,
+} from "../capabilities/inline-editing/index.js";
+import { INLINE_EDIT_DEBOUNCE_MS } from "../constants.js";
+import { getElementPosition, getElementClasses } from "../utils/dom-utils.js";
+
+/**
+ * Enter inline editing mode
+ */
+export function handleEnterInlineEditingMode(state: AgentState, element: HTMLElement): void {
+  state.currentEditingElement = element;
+
+  // Hide overlays during editing
+  state.selectedOverlays.forEach((overlay) => {
+    overlay.style.display = "none";
+  });
+
+  // Enter inline editing mode (from capabilities/inline-editing)
+  enterInlineEditingMode(element);
+
+  // Notify parent
+  window.parent.postMessage(
+    {
+      type: OutgoingMessageType.CONTENT_EDITING_STARTED,
+      visualSelectorId: state.selectedElementId,
+    },
+    "*"
+  );
+}
+
+/**
+ * Clear inline editing mode
+ */
+export function handleClearInlineEditingMode(state: AgentState): void {
+  if (!state.currentEditingElement) return;
+
+  // Cancel any pending debounced edit — originalTextContent will be deleted below
+  if (state.debouncedSendTimeout) {
+    clearTimeout(state.debouncedSendTimeout);
+    state.debouncedSendTimeout = null;
+  }
+
+  const element = state.currentEditingElement;
+
+  // Clear inline editing mode (from capabilities/inline-editing)
+  clearInlineEditingMode(element);
+
+  // Show overlays again
+  state.selectedOverlays.forEach((overlay) => {
+    overlay.style.display = "";
+  });
+
+  repositionSelectedOverlays(state);
+
+  // Notify parent that editing ended
+  window.parent.postMessage(
+    {
+      type: OutgoingMessageType.CONTENT_EDITING_ENDED,
+      visualSelectorId: state.selectedElementId,
+    },
+    "*"
+  );
+
+  state.currentEditingElement = null;
+}
+
+/**
+ * Report inline edit to parent
+ */
+function reportInlineEdit(state: AgentState, element: HTMLElement): void {
+  const originalContent = element.dataset.originalTextContent;
+  const newContent = element.textContent;
+
+  const elementInfo = {
+    tagName: element.tagName,
+    classes: getElementClasses(element),
+    visualSelectorId: state.selectedElementId,
+    content: newContent,
+    dataSourceLocation: element.dataset.sourceLocation,
+    isDynamicContent: element.dataset.dynamicContent === "true",
+    linenumber: element.dataset.linenumber,
+    filename: element.dataset.filename,
+    position: getElementPosition(element.getBoundingClientRect()),
+  };
+
+  // Send inline edit message
+  window.parent.postMessage(
+    {
+      type: OutgoingMessageType.INLINE_EDIT,
+      elementInfo,
+      originalContent,
+      newContent,
+    },
+    "*"
+  );
+
+  // Update baseline for next edit
+  element.dataset.originalTextContent = newContent || "";
+}
+
+/**
+ * Debounced function to send inline edit messages
+ */
+function debouncedSendInlineEditMessage(state: AgentState, element: HTMLElement): void {
+  // Clear any existing timeout
+  if (state.debouncedSendTimeout) {
+    clearTimeout(state.debouncedSendTimeout);
+  }
+
+  // Set new timeout
+  state.debouncedSendTimeout = setTimeout(() => {
+    reportInlineEdit(state, element);
+  }, INLINE_EDIT_DEBOUNCE_MS);
+}
+
+/**
+ * Callback for text input changes (combines updatePosition and reportInlineEdit)
+ */
+function createTextInputChangeCallback(state: AgentState) {
+  return (element: HTMLElement) => {
+    repositionSelectedOverlays(state);
+    debouncedSendInlineEditMessage(state, element);
+  };
+}
+
+/**
+ * Setup inline edit callback
+ */
+export function setupInlineEditCallback(state: AgentState): void {
+  setInlineEditCallback(createTextInputChangeCallback(state));
+}

package/src/injections/visual-edit-agent/handlers/message-handlers.ts

@@ -0,0 +1,191 @@
+import type { AgentState } from "../state/agent-state.js";
+import { IncomingMessageType, OutgoingMessageType } from "./messages/types.js";
+import { findElementsById, updateElementClasses } from "../../utils.js";
+import { clearSelection, repositionSelectedOverlays, repositionHoverOverlays } from "../ui/overlay.js";
+import { clearHoverOverlays } from "./hover-handlers.js";
+import { handleClearInlineEditingMode } from "./inline-edit-handlers.js";
+import { REPOSITION_DELAY_MS } from "../constants.js";
+import { handleToggleVisualEditMode } from "./messages/toggle-visual-edit-mode.js";
+import { handleToggleInlineEditMode } from "./messages/toggle-inline-edit-mode.js";
+import { getElementPosition, isElementInViewport } from "../utils/dom-utils.js";
+
+/**
+ * Send element position update to parent
+ */
+function sendElementPositionUpdate(state: AgentState): void {
+  if (!state.selectedElementId) return;
+
+  const elements = findElementsById(state.selectedElementId);
+  const [element] = elements;
+  if (!element) return;
+
+  const rect = element.getBoundingClientRect();
+
+  window.parent.postMessage(
+    {
+      type: OutgoingMessageType.ELEMENT_POSITION_UPDATE,
+      position: getElementPosition(rect),
+      isInViewport: isElementInViewport(rect),
+      visualSelectorId: state.selectedElementId,
+    },
+    "*"
+  );
+}
+
+/**
+ * Unselect the current element
+ */
+export function unselectElement(state: AgentState): void {
+  if (state.currentEditingElement) {
+    handleClearInlineEditingMode(state);
+  }
+  clearSelection(state);
+}
+
+/**
+ * Update element classes and reposition overlays
+ */
+export function updateElementClassesAndReposition(
+  state: AgentState,
+  visualSelectorId: string,
+  classes: string
+): void {
+  const elements = findElementsById(visualSelectorId);
+  if (elements.length === 0) return;
+
+  updateElementClasses(elements, classes);
+
+  // Use a small delay to allow the browser to recalculate layout before repositioning
+  setTimeout(() => {
+    if (state.selectedElementId === visualSelectorId) {
+      repositionSelectedOverlays(state);
+    }
+
+    if (state.currentHighlightedElements.length > 0) {
+      const hoveredElement = state.currentHighlightedElements[0] as HTMLElement;
+      if (hoveredElement?.dataset?.visualSelectorId === visualSelectorId) {
+        repositionHoverOverlays(state);
+      }
+    }
+  }, REPOSITION_DELAY_MS);
+}
+
+/**
+ * Update element content by visual selector ID
+ */
+export function updateElementContent(
+  state: AgentState,
+  visualSelectorId: string,
+  content: string
+): void {
+  const elements = findElementsById(visualSelectorId);
+
+  if (elements.length === 0) {
+    return;
+  }
+
+  elements.forEach((element) => {
+    (element as HTMLElement).innerText = content;
+  });
+
+  setTimeout(() => {
+    if (state.selectedElementId === visualSelectorId) {
+      repositionSelectedOverlays(state);
+    }
+  }, REPOSITION_DELAY_MS);
+}
+
+/**
+ * Handle scroll events to update popover position
+ */
+export function handleScroll(state: AgentState): void {
+  sendElementPositionUpdate(state);
+}
+
+/**
+ * Handle window resize to reposition overlays
+ */
+export function handleResize(state: AgentState): void {
+  repositionSelectedOverlays(state);
+  repositionHoverOverlays(state);
+}
+
+/**
+ * Handle messages from parent window
+ */
+export function handleMessage(state: AgentState, event: MessageEvent): void {
+  const message = event.data;
+
+  switch (message.type as IncomingMessageType) {
+    case IncomingMessageType.TOGGLE_VISUAL_EDIT_MODE:
+      handleToggleVisualEditMode(state, message);
+      break;
+
+    case IncomingMessageType.UPDATE_CLASSES:
+      if (message.data && message.data.classes !== undefined) {
+        updateElementClassesAndReposition(
+          state,
+          message.data.visualSelectorId,
+          message.data.classes
+        );
+      } else {
+        console.warn(
+          "[VisualEditAgent] Invalid update-classes message:",
+          message
+        );
+      }
+      break;
+
+    case IncomingMessageType.UNSELECT_ELEMENT:
+      unselectElement(state);
+      break;
+
+    case IncomingMessageType.REFRESH_PAGE:
+      window.location.reload();
+      break;
+
+    case IncomingMessageType.UPDATE_CONTENT:
+      if (message.data && message.data.content !== undefined) {
+        updateElementContent(
+          state,
+          message.data.visualSelectorId,
+          message.data.content
+        );
+      } else {
+        console.warn(
+          "[VisualEditAgent] Invalid update-content message:",
+          message
+        );
+      }
+      break;
+
+    case IncomingMessageType.TOGGLE_INLINE_EDIT_MODE:
+      handleToggleInlineEditMode(state, message);
+      break;
+
+    case IncomingMessageType.REQUEST_ELEMENT_POSITION:
+      sendElementPositionUpdate(state);
+      break;
+
+    case IncomingMessageType.POPOVER_DRAG_STATE:
+      if (message.data && message.data.isDragging !== undefined) {
+        state.isPopoverDragging = message.data.isDragging;
+        if (message.data.isDragging) {
+          clearHoverOverlays(state);
+        }
+      }
+      break;
+
+    case IncomingMessageType.DROPDOWN_STATE:
+      if (message.data && message.data.isOpen !== undefined) {
+        state.isDropdownOpen = message.data.isOpen;
+        if (message.data.isOpen) {
+          clearHoverOverlays(state);
+        }
+      }
+      break;
+
+    default:
+      break;
+  }
+}