@base44-preview/vite-plugin 0.2.22-pr.37.fd9cb1a → 0.2.22-pr.39.4150ff4

package/src/jsx-processor.ts

@@ -0,0 +1,147 @@
+import type { NodePath } from "@babel/traverse";
+import type * as t from "@babel/types";
+import { StaticArrayProcessor } from "./processors/static-array-processor.js";
+
+export class JSXProcessor {
+  private staticArrayProcessor: StaticArrayProcessor;
+
+  constructor(
+    private types: typeof t,
+    private filename: string
+  ) {
+    this.staticArrayProcessor = new StaticArrayProcessor(types);
+  }
+
+  processJSXElement(path: NodePath<t.JSXOpeningElement>): void {
+    if (this.hasAttribute(path, "data-source-location")) return;
+
+    this.addSourceLocationAttribute(path);
+    this.addDynamicContentAttribute(path);
+    this.addContentEditableAttribute(path);
+    this.staticArrayProcessor.process(path);
+  }
+
+  private addSourceLocationAttribute(
+    path: NodePath<t.JSXOpeningElement>
+  ): void {
+    const { line, column } = path.node.loc?.start || { line: 1, column: 0 };
+    const value = `${this.filename}:${line}:${column}`;
+
+    path.node.attributes.push(
+      this.types.jsxAttribute(
+        this.types.jsxIdentifier("data-source-location"),
+        this.types.stringLiteral(value)
+      )
+    );
+  }
+
+  private addDynamicContentAttribute(
+    path: NodePath<t.JSXOpeningElement>
+  ): void {
+    const parentElement = path.parentPath;
+    if (!parentElement?.isJSXElement()) return;
+
+    const isDynamic = this.checkIfElementHasDynamicContent(
+      parentElement.node as t.JSXElement
+    );
+
+    path.node.attributes.push(
+      this.types.jsxAttribute(
+        this.types.jsxIdentifier("data-dynamic-content"),
+        this.types.stringLiteral(isDynamic ? "true" : "false")
+      )
+    );
+  }
+
+  private addContentEditableAttribute(
+    path: NodePath<t.JSXOpeningElement>
+  ): void {
+    path.node.attributes.push(
+      this.types.jsxAttribute(
+        this.types.jsxIdentifier("content-editable"),
+        this.types.stringLiteral("true")
+      )
+    );
+  }
+
+  private hasAttribute(
+    path: NodePath<t.JSXOpeningElement>,
+    name: string
+  ): boolean {
+    return path.node.attributes.some(
+      (attr: t.JSXAttribute | t.JSXSpreadAttribute) =>
+        this.types.isJSXAttribute(attr) &&
+        this.types.isJSXIdentifier(attr.name) &&
+        attr.name.name === name
+    );
+  }
+
+  private checkIfElementHasDynamicContent(jsxElement: t.JSXElement): boolean {
+    let hasDynamicContent = false;
+
+    const checkNode = (node: t.Node): boolean => {
+      if (this.types.isJSXExpressionContainer(node)) {
+        const expression = (node as t.JSXExpressionContainer).expression;
+        if (this.types.isJSXEmptyExpression(expression)) return false;
+        if (!this.types.isLiteral(expression)) return true;
+      }
+
+      if (
+        this.types.isTemplateLiteral(node) &&
+        (node as t.TemplateLiteral).expressions.length > 0
+      ) {
+        return true;
+      }
+      if (this.types.isMemberExpression(node)) return true;
+      if (this.types.isCallExpression(node)) return true;
+      if (this.types.isConditionalExpression(node)) return true;
+
+      if (this.types.isIdentifier(node)) {
+        const dynamicNames = [
+          "props",
+          "state",
+          "data",
+          "item",
+          "value",
+          "text",
+          "content",
+        ];
+        if (dynamicNames.some((name) => (node as t.Identifier).name.includes(name))) {
+          return true;
+        }
+      }
+
+      return false;
+    };
+
+    const traverseNode = (node: Record<string, unknown>): void => {
+      if (hasDynamicContent) return;
+      if (checkNode(node as unknown as t.Node)) {
+        hasDynamicContent = true;
+        return;
+      }
+
+      for (const key of Object.keys(node)) {
+        if (hasDynamicContent) return;
+        const value = node[key];
+
+        if (Array.isArray(value)) {
+          for (const child of value) {
+            if (child && typeof child === "object" && "type" in child) {
+              traverseNode(child as Record<string, unknown>);
+            }
+          }
+        } else if (value && typeof value === "object" && "type" in value) {
+          traverseNode(value as Record<string, unknown>);
+        }
+      }
+    };
+
+    for (const child of jsxElement.children) {
+      if (hasDynamicContent) break;
+      traverseNode(child as unknown as Record<string, unknown>);
+    }
+
+    return hasDynamicContent;
+  }
+}

package/src/jsx-utils.ts

@@ -0,0 +1,15 @@
+import type * as t from "@babel/types";
+
+export class JSXUtils {
+  private static types: typeof t;
+
+  static init(types: typeof t) {
+    this.types = types;
+  }
+
+  static getAttributeName(attr: t.JSXAttribute): string {
+    return this.types.isJSXNamespacedName(attr.name)
+      ? `${attr.name.namespace.name}:${attr.name.name.name}`
+      : attr.name.name;
+  }
+}

package/src/processors/shared-utils.ts

@@ -0,0 +1,116 @@
+import type { NodePath } from "@babel/traverse";
+import type * as t from "@babel/types";
+import { JSXUtils } from "../jsx-utils.js";
+
+export class JSXAttributeUtils {
+  constructor(private types: typeof t) {}
+
+  hasAttribute(
+    path: NodePath<t.JSXOpeningElement>,
+    attributeName: string
+  ): boolean {
+    return path.node.attributes.some(
+      (attr: t.JSXAttribute | t.JSXSpreadAttribute) =>
+        this.types.isJSXAttribute(attr) &&
+        JSXUtils.getAttributeName(attr) === attributeName
+    );
+  }
+
+  addStringAttribute(
+    path: NodePath<t.JSXOpeningElement>,
+    attributeName: string,
+    value: string
+  ): void {
+    if (!this.hasAttribute(path, attributeName)) {
+      path.node.attributes.push(
+        this.types.jsxAttribute(
+          this.types.jsxIdentifier(attributeName),
+          this.types.stringLiteral(value)
+        )
+      );
+    }
+  }
+
+  addExpressionAttribute(
+    path: NodePath<t.JSXOpeningElement>,
+    attributeName: string,
+    expression: t.Expression
+  ): void {
+    if (!this.hasAttribute(path, attributeName)) {
+      path.node.attributes.push(
+        this.types.jsxAttribute(
+          this.types.jsxIdentifier(attributeName),
+          this.types.jsxExpressionContainer(expression)
+        )
+      );
+    }
+  }
+}
+
+export class StaticValueUtils {
+  constructor(private types: typeof t) {}
+
+  isPrimitiveLiteral(path: NodePath<t.Node>): boolean {
+    return (
+      path.isStringLiteral() ||
+      path.isNumericLiteral() ||
+      path.isBooleanLiteral() ||
+      path.isNullLiteral()
+    );
+  }
+
+  isStaticValue(
+    path: NodePath<t.Node>,
+    visited: Set<string> = new Set()
+  ): boolean {
+    if (this.isPrimitiveLiteral(path)) return true;
+    if (path.isIdentifier()) return this.isStaticIdentifier(path, visited);
+    if (path.isObjectExpression()) return this.isStaticObject(path, visited);
+    if (path.isArrayExpression())
+      return this.isStaticArrayExpression(path, visited);
+    return false;
+  }
+
+  isStaticIdentifier(
+    path: NodePath<t.Identifier>,
+    visited: Set<string> = new Set()
+  ): boolean {
+    const binding = path.scope.getBinding(path.node.name);
+    if (!binding) return false;
+
+    if (binding.kind === "module") return true;
+
+    if (binding.kind === "const" && binding.path.isVariableDeclarator()) {
+      const name = path.node.name;
+      if (visited.has(name)) return false;
+      visited.add(name);
+
+      const init = binding.path.get("init");
+      if (init.hasNode()) {
+        return this.isStaticValue(init as NodePath<t.Node>, visited);
+      }
+    }
+
+    return false;
+  }
+
+  isStaticObject(
+    path: NodePath<t.ObjectExpression>,
+    visited: Set<string> = new Set()
+  ): boolean {
+    return path.get("properties").every((prop: NodePath) => {
+      if (!prop.isObjectProperty()) return false;
+      return this.isStaticValue(prop.get("value") as NodePath<t.Node>, visited);
+    });
+  }
+
+  isStaticArrayExpression(
+    arrayExpression: NodePath<t.ArrayExpression>,
+    visited: Set<string> = new Set()
+  ): boolean {
+    return arrayExpression.get("elements").every((element) => {
+      if (!element.node || element.isSpreadElement()) return true;
+      return this.isStaticValue(element as unknown as NodePath<t.Node>, visited);
+    });
+  }
+}

package/src/processors/static-array-processor.ts

@@ -0,0 +1,257 @@
+import type { NodePath } from "@babel/traverse";
+import type * as t from "@babel/types";
+import { JSXAttributeUtils, StaticValueUtils } from "./shared-utils.js";
+
+export const DATA_ARR_INDEX = "data-arr-index";
+export const DATA_ARR_VARIABLE_NAME = "data-arr-variable-name";
+export const DATA_ARR_FIELD = "data-arr-field";
+const GENERATED_INDEX_PARAM = "__arrIdx__";
+
+interface ArrayMapInfo {
+  arrayExpression: NodePath<t.Expression>;
+  callbackParam: string;
+  indexParam: string | null;
+  arrayVariableName: string | null;
+  mapCallPath: NodePath<t.CallExpression>;
+}
+
+export class StaticArrayProcessor {
+  private attributeUtils: JSXAttributeUtils;
+  private staticValueUtils: StaticValueUtils;
+
+  constructor(private types: typeof t) {
+    this.attributeUtils = new JSXAttributeUtils(types);
+    this.staticValueUtils = new StaticValueUtils(types);
+  }
+
+  process(path: NodePath<t.JSXOpeningElement>): void {
+    const arrayInfo = this.findParentArrayMap(path);
+    if (!arrayInfo) return;
+
+    if (!this.isStaticArray(arrayInfo.arrayExpression)) return;
+
+    const indexIdentifier = this.ensureIndexParam(arrayInfo);
+    this.addDataAttributes(path, arrayInfo, indexIdentifier);
+  }
+
+  private addDataAttributes(
+    path: NodePath<t.JSXOpeningElement>,
+    arrayInfo: ArrayMapInfo,
+    indexIdentifier: string
+  ): void {
+    this.attributeUtils.addExpressionAttribute(
+      path,
+      DATA_ARR_INDEX,
+      this.types.identifier(indexIdentifier)
+    );
+
+    if (arrayInfo.arrayVariableName) {
+      this.attributeUtils.addStringAttribute(
+        path,
+        DATA_ARR_VARIABLE_NAME,
+        arrayInfo.arrayVariableName
+      );
+    }
+
+    const fieldPath = this.findTextContentFieldPath(
+      path,
+      arrayInfo.callbackParam
+    );
+    if (fieldPath) {
+      this.attributeUtils.addStringAttribute(path, DATA_ARR_FIELD, fieldPath);
+    }
+  }
+
+  private findTextContentFieldPath(
+    path: NodePath<t.JSXOpeningElement>,
+    callbackParam: string
+  ): string | null {
+    const parentElement = path.parentPath;
+    if (!parentElement?.isJSXElement()) return null;
+
+    for (const child of parentElement.get("children")) {
+      const fieldPath = this.extractFieldPathFromChild(child, callbackParam);
+      if (fieldPath) return fieldPath;
+    }
+
+    return null;
+  }
+
+  private extractFieldPathFromChild(
+    child: NodePath<t.JSXElement["children"][number]>,
+    callbackParam: string
+  ): string | null {
+    if (!child.isJSXExpressionContainer()) return null;
+
+    const expression = child.get("expression");
+    if (!expression.isMemberExpression()) return null;
+
+    return this.extractFieldPath(expression, callbackParam);
+  }
+
+  private extractFieldPath(
+    expr: NodePath<t.MemberExpression>,
+    callbackParam: string
+  ): string | null {
+    const parts = this.collectMemberExpressionParts(expr);
+    if (!parts) return null;
+
+    const { rootName, propertyNames } = parts;
+    return rootName === callbackParam ? propertyNames.join(".") : null;
+  }
+
+  private collectMemberExpressionParts(
+    expr: NodePath<t.MemberExpression>
+  ): { rootName: string; propertyNames: string[] } | null {
+    const propertyNames: string[] = [];
+    let current: NodePath<t.Expression> = expr;
+
+    while (current.isMemberExpression()) {
+      const property = current.get("property");
+      if (!property.isIdentifier()) return null;
+
+      propertyNames.unshift(property.node.name);
+      current = current.get("object") as NodePath<t.Expression>;
+    }
+
+    if (!current.isIdentifier()) return null;
+
+    return { rootName: current.node.name, propertyNames };
+  }
+
+  private ensureIndexParam(arrayInfo: ArrayMapInfo): string {
+    if (arrayInfo.indexParam) {
+      return arrayInfo.indexParam;
+    }
+
+    this.addIndexParamToCallback(arrayInfo.mapCallPath);
+    return GENERATED_INDEX_PARAM;
+  }
+
+  private addIndexParamToCallback(
+    mapCallPath: NodePath<t.CallExpression>
+  ): void {
+    const callback = this.getMapCallback(mapCallPath);
+    if (!callback) return;
+
+    const params = callback.get("params");
+    if (params.length === 1) {
+      callback.node.params.push(this.types.identifier(GENERATED_INDEX_PARAM));
+    }
+  }
+
+  private getMapCallback(
+    mapCallPath: NodePath<t.CallExpression>
+  ): NodePath<t.Function> | null {
+    const args = mapCallPath.get("arguments");
+    const firstArg = args[0];
+    if (firstArg && firstArg.isFunction()) {
+      return firstArg as NodePath<t.Function>;
+    }
+    return null;
+  }
+
+  private findParentArrayMap(
+    path: NodePath<t.JSXOpeningElement>,
+    maxDepth: number = 5
+  ): ArrayMapInfo | null {
+    let currentPath: NodePath = path;
+    let depth = 0;
+
+    while (currentPath.parentPath && depth < maxDepth) {
+      const mapInfo = this.tryExtractMapInfo(currentPath.parentPath);
+      if (mapInfo) return mapInfo;
+
+      currentPath = currentPath.parentPath;
+      depth++;
+    }
+
+    return null;
+  }
+
+  private tryExtractMapInfo(parent: NodePath): ArrayMapInfo | null {
+    if (!parent.isCallExpression()) return null;
+    if (!this.isMapCall(parent)) return null;
+
+    return this.extractArrayMapInfo(parent);
+  }
+
+  private isMapCall(callExpr: NodePath<t.CallExpression>): boolean {
+    const callee = callExpr.get("callee");
+    if (!callee.isMemberExpression()) return false;
+
+    const property = callee.get("property");
+    return property.isIdentifier() && property.node.name === "map";
+  }
+
+  private extractArrayMapInfo(
+    mapCall: NodePath<t.CallExpression>
+  ): ArrayMapInfo | null {
+    const callback = this.getMapCallback(mapCall);
+    if (!callback) return null;
+
+    const params = callback.get("params");
+    const firstParam = params[0];
+    if (!firstParam || !firstParam.isIdentifier()) return null;
+
+    const callee = mapCall.get("callee") as NodePath<t.MemberExpression>;
+    const arrayExpression = callee.get("object") as NodePath<t.Expression>;
+
+    return {
+      arrayExpression,
+      callbackParam: firstParam.node.name,
+      indexParam: this.extractIndexParam(params),
+      arrayVariableName: this.extractArrayVariableName(arrayExpression),
+      mapCallPath: mapCall,
+    };
+  }
+
+  private extractIndexParam(params: NodePath<t.Node>[]): string | null {
+    const secondParam = params[1];
+    return secondParam && secondParam.isIdentifier()
+      ? secondParam.node.name
+      : null;
+  }
+
+  private extractArrayVariableName(
+    arrayExpression: NodePath<t.Expression>
+  ): string | null {
+    return arrayExpression.isIdentifier() ? arrayExpression.node.name : null;
+  }
+
+  private isStaticArray(arrayExpression: NodePath<t.Expression>): boolean {
+    const arrayExpr = this.resolveArrayExpression(arrayExpression);
+    return arrayExpr ? this.isStaticArrayExpression(arrayExpr) : false;
+  }
+
+  private resolveArrayExpression(
+    expression: NodePath<t.Expression>
+  ): NodePath<t.ArrayExpression> | null {
+    if (expression.isArrayExpression()) {
+      return expression;
+    }
+
+    if (expression.isIdentifier()) {
+      return this.resolveIdentifierToArray(expression);
+    }
+
+    return null;
+  }
+
+  private resolveIdentifierToArray(
+    identifier: NodePath<t.Identifier>
+  ): NodePath<t.ArrayExpression> | null {
+    const binding = identifier.scope.getBinding(identifier.node.name);
+
+    if (!binding?.path.isVariableDeclarator()) return null;
+
+    const init = binding.path.get("init");
+    return init.isArrayExpression() ? init : null;
+  }
+
+  private isStaticArrayExpression(
+    arrayExpression: NodePath<t.ArrayExpression>
+  ): boolean {
+    return this.staticValueUtils.isStaticArrayExpression(arrayExpression);
+  }
+}

package/src/visual-edit-plugin.ts

@@ -3,6 +3,8 @@ import { default as traverse } from "@babel/traverse";
 import { default as generate } from "@babel/generator";
 import * as t from "@babel/types";
 import type { Plugin } from "vite";
+import { StaticArrayProcessor } from "./processors/static-array-processor.js";
+import { JSXUtils } from "./jsx-utils.js";
 
 // Helper function to check if JSX element contains dynamic content
 export function checkIfElementHasDynamicContent(jsxElement: any) {
@@ -213,6 +215,8 @@ export function visualEditPlugin() {
         });
 
         // Traverse the AST and add source location and dynamic content attributes to JSX elements
+        JSXUtils.init(t);
+        const staticArrayProcessor = new StaticArrayProcessor(t);
         let elementsProcessed = 0;
         traverse.default(ast, {
           JSXElement(path) {
@@ -258,6 +262,8 @@ export function visualEditPlugin() {
               sourceLocationAttr,
               dynamicContentAttr
             );
+
+            staticArrayProcessor.process(path.get("openingElement"));
             elementsProcessed++;
           },
         });

package/dist/injections/visual-edit-agent/capabilities/inline-editing/core.d.ts

@@ -1,25 +0,0 @@
-/**
- * Callback function type for handling text input changes
- */
-type OnTextInputChange = (element: HTMLElement) => void;
-/**
- * Set the callback function that will be called on text input changes
- */
-export declare function setInlineEditCallback(callback: OnTextInputChange | null): void;
-/**
- * Check if an element should enter inline editing mode
- * Called when user clicks on an already-selected element
- */
-export declare function shouldEnterInlineEditingMode(element: Element): boolean;
-/**
- * Enable contentEditable mode on an element
- * Follows the exact flow from inlineEdit.md
- */
-export declare function enterInlineEditingMode(element: HTMLElement): void;
-/**
- * Disable contentEditable mode on an element
- * Reverses everything done by enterInlineEditingMode
- */
-export declare function clearInlineEditingMode(element: HTMLElement): void;
-export {};
-//# sourceMappingURL=core.d.ts.map

package/dist/injections/visual-edit-agent/capabilities/inline-editing/core.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../../../../../src/injections/visual-edit-agent/capabilities/inline-editing/core.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,KAAK,iBAAiB,GAAG,CAAC,OAAO,EAAE,WAAW,KAAK,IAAI,CAAC;AAQxD;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,GAAG,IAAI,CAE9E;AAkBD;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAYtE;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,CA4BjE;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI,CA0BjE"}

package/dist/injections/visual-edit-agent/capabilities/inline-editing/core.js

@@ -1,95 +0,0 @@
-import { injectFocusOutlineCSS, removeFocusOutlineCSS } from "./styles.js";
-import { selectText, isEditableTextElement } from "./validation.js";
-/**
- * Global callback that gets triggered on every input event
- * This is set by the visual-edit-agent and includes both updatePosition and reportInlineEdit
- */
-let onTextInputChangeCallback = null;
-/**
- * Set the callback function that will be called on text input changes
- */
-export function setInlineEditCallback(callback) {
-    onTextInputChangeCallback = callback;
-}
-/**
- * WeakMap to track AbortControllers for each element's input listener.
- * Using WeakMap ensures no memory leaks — when an element is garbage collected,
- * its entry is automatically removed.
- */
-const listenerAbortControllers = new WeakMap();
-/**
- * Internal handler for the native input event
- */
-function handleInputEvent(e) {
-    if (onTextInputChangeCallback) {
-        onTextInputChangeCallback(this);
-    }
-}
-/**
- * Check if an element should enter inline editing mode
- * Called when user clicks on an already-selected element
- */
-export function shouldEnterInlineEditingMode(element) {
-    // Must have data-selected="true"
-    if (!(element instanceof HTMLElement) || element.dataset.selected !== "true") {
-        return false;
-    }
-    // Must pass all editability checks
-    if (!isEditableTextElement(element)) {
-        return false;
-    }
-    return true;
-}
-/**
- * Enable contentEditable mode on an element
- * Follows the exact flow from inlineEdit.md
- */
-export function enterInlineEditingMode(element) {
-    // Inject CSS to suppress focus outline
-    injectFocusOutlineCSS();
-    // Store original state
-    element.dataset.originalTextContent = element.textContent || "";
-    element.dataset.originalCursor = element.style.cursor;
-    // Enable contentEditable
-    element.contentEditable = "true";
-    // Create an AbortController to manage the input listener lifecycle
-    const abortController = new AbortController();
-    listenerAbortControllers.set(element, abortController);
-    // Add input event listener with AbortSignal for automatic cleanup
-    element.addEventListener("input", handleInputEvent, { signal: abortController.signal });
-    // Set cursor to text
-    element.style.cursor = "text";
-    // Select all text
-    selectText(element);
-    // Focus after render
-    setTimeout(() => {
-        element.focus();
-    }, 0);
-}
-/**
- * Disable contentEditable mode on an element
- * Reverses everything done by enterInlineEditingMode
- */
-export function clearInlineEditingMode(element) {
-    // Abort the input event listener using the stored AbortController
-    const abortController = listenerAbortControllers.get(element);
-    if (abortController) {
-        abortController.abort();
-        listenerAbortControllers.delete(element);
-    }
-    // If element was removed from DOM before cleanup, skip DOM operations
-    if (!element.isConnected) {
-        return;
-    }
-    removeFocusOutlineCSS();
-    // Disable contentEditable
-    element.contentEditable = "false";
-    // Remove stored original text content
-    delete element.dataset.originalTextContent;
-    // Restore original cursor
-    if (element.dataset.originalCursor !== undefined) {
-        element.style.cursor = element.dataset.originalCursor;
-        delete element.dataset.originalCursor;
-    }
-}
-//# sourceMappingURL=core.js.map

package/dist/injections/visual-edit-agent/capabilities/inline-editing/core.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"core.js","sourceRoot":"","sources":["../../../../../src/injections/visual-edit-agent/capabilities/inline-editing/core.ts"],"names":[],"mappings":"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"}

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

@@ -1,4 +0,0 @@
-export { enterInlineEditingMode, clearInlineEditingMode, shouldEnterInlineEditingMode, setInlineEditCallback, } from "./core.js";
-export { injectFocusOutlineCSS, removeFocusOutlineCSS } from "./styles.js";
-export { isEditableTextElement, selectText } from "./validation.js";
-//# sourceMappingURL=index.d.ts.map