@base44-preview/vite-plugin 0.2.27-pr.43.93e5e43 → 0.2.27-pr.44.b37fb09

package/src/processors/collection-item-id-processor.ts

@@ -1,69 +0,0 @@
-import type { NodePath } from "@babel/traverse";
-import type * as t from "@babel/types";
-import { DATA_COLLECTION_ITEM_ID } from "../consts.js";
-import {
-  JSXAttributeUtils,
-  ExpressionAnalysisUtils,
-} from "./shared-utils.js";
-
-export class DataItemIdProcessor {
-  private attributeUtils: JSXAttributeUtils;
-  private expressionUtils: ExpressionAnalysisUtils;
-
-  constructor(private types: typeof t) {
-    this.attributeUtils = new JSXAttributeUtils(types);
-    this.expressionUtils = new ExpressionAnalysisUtils(types);
-  }
-
-  process(path: NodePath<t.JSXOpeningElement>): void {
-    if (this.attributeUtils.hasAttribute(path, DATA_COLLECTION_ITEM_ID)) {
-      return;
-    }
-
-    const keyAttr = this.findKeyAttribute(path);
-    if (!keyAttr) return;
-
-    const expression = this.extractKeyExpression(keyAttr);
-    if (!expression) return;
-
-    if (!this.expressionUtils.isIdAccess(expression)) return;
-
-    const optionalExpr = this.types.isMemberExpression(expression)
-      ? this.expressionUtils.createOptionalChainExpression(expression)
-      : expression;
-
-    this.attributeUtils.addExpressionAttribute(
-      path,
-      DATA_COLLECTION_ITEM_ID,
-      optionalExpr
-    );
-  }
-
-  private findKeyAttribute(
-    path: NodePath<t.JSXOpeningElement>
-  ): t.JSXAttribute | null {
-    for (const attr of path.node.attributes) {
-      if (
-        this.types.isJSXAttribute(attr) &&
-        this.types.isJSXIdentifier(attr.name) &&
-        attr.name.name === "key"
-      ) {
-        return attr;
-      }
-    }
-    return null;
-  }
-
-  private extractKeyExpression(
-    attr: t.JSXAttribute
-  ): t.Expression | null {
-    if (!attr.value) return null;
-
-    if (this.types.isJSXExpressionContainer(attr.value)) {
-      const expr = attr.value.expression;
-      if (this.types.isExpression(expr)) return expr;
-    }
-
-    return null;
-  }
-}

package/src/processors/collection-reference-field-processor.ts

@@ -1,225 +0,0 @@
-import type { NodePath } from "@babel/traverse";
-import type * as t from "@babel/types";
-import {
-  DATA_COLLECTION_FIELD_REFERENCE,
-  DATA_COLLECTION_REFERENCE,
-} from "../consts.js";
-import {
-  JSXAttributeUtils,
-  ExpressionAnalysisUtils,
-  TypeCheckUtils,
-} from "./shared-utils.js";
-
-export class ReferenceFieldProcessor {
-  private attributeUtils: JSXAttributeUtils;
-  private expressionUtils: ExpressionAnalysisUtils;
-  private typeCheckUtils: TypeCheckUtils;
-
-  constructor(private types: typeof t) {
-    this.attributeUtils = new JSXAttributeUtils(types);
-    this.expressionUtils = new ExpressionAnalysisUtils(types);
-    this.typeCheckUtils = new TypeCheckUtils(types);
-  }
-
-  process(path: NodePath<t.JSXOpeningElement>): void {
-    if (
-      this.attributeUtils.hasAttribute(path, DATA_COLLECTION_FIELD_REFERENCE)
-    ) {
-      return;
-    }
-
-    if (
-      this.isReturnedFromReferenceMap(path) ||
-      this.isInsideReferenceLogicalExpression(path) ||
-      this.isInReferencePropertyMapChain(path)
-    ) {
-      this.attributeUtils.addStringAttribute(
-        path,
-        DATA_COLLECTION_FIELD_REFERENCE,
-        "true"
-      );
-    }
-  }
-
-  /**
-   * Strategy A: Element is the direct return of a .map() callback
-   * whose array is a reference variable (initialized via type-check pattern).
-   */
-  private isReturnedFromReferenceMap(
-    path: NodePath<t.JSXOpeningElement>
-  ): boolean {
-    const jsxElement = path.parentPath;
-    if (!jsxElement?.isJSXElement()) return false;
-
-    const parent = jsxElement.parentPath;
-    if (!parent) return false;
-
-    const callbackFn = this.findEnclosingMapCallback(parent);
-    if (!callbackFn) return false;
-
-    const mapCall = callbackFn.parentPath;
-    if (!mapCall?.isCallExpression()) return false;
-
-    const callee = mapCall.get("callee");
-    if (!callee.isMemberExpression()) return false;
-
-    const arrayObj = callee.get("object") as NodePath<t.Expression>;
-    return this.isReferenceArray(arrayObj);
-  }
-
-  /**
-   * Strategy B: Element is inside a && expression where the left operand
-   * references a field name that appears in an ancestor's data-collection-reference.
-   */
-  private isInsideReferenceLogicalExpression(
-    path: NodePath<t.JSXOpeningElement>
-  ): boolean {
-    const jsxElement = path.parentPath;
-    if (!jsxElement?.isJSXElement()) return false;
-
-    const logicalParent = jsxElement.parentPath;
-    if (!logicalParent?.isLogicalExpression()) return false;
-    if (logicalParent.node.operator !== "&&") return false;
-
-    const left = logicalParent.node.left;
-    const fieldName = this.extractFieldNameFromExpression(left as t.Expression);
-    if (!fieldName) return false;
-
-    return this.isFieldInAncestorReference(path, fieldName);
-  }
-
-  /**
-   * Strategy C: Element is inside a .map() chain on a reference property.
-   * e.g. item.relatedProducts.map(...) or item.relatedProducts.filter(...).map(...)
-   */
-  private isInReferencePropertyMapChain(
-    path: NodePath<t.JSXOpeningElement>
-  ): boolean {
-    const jsxElement = path.parentPath;
-    if (!jsxElement?.isJSXElement()) return false;
-
-    let current: NodePath | null = jsxElement;
-    while (current) {
-      if (current.isCallExpression()) {
-        const callee = current.get("callee");
-        if (callee.isMemberExpression()) {
-          const fieldName = this.extractReferenceFieldFromMapChain(callee);
-          if (fieldName && this.isFieldInAncestorReference(path, fieldName)) {
-            return true;
-          }
-        }
-      }
-      current = current.parentPath;
-    }
-
-    return false;
-  }
-
-  private findEnclosingMapCallback(
-    path: NodePath
-  ): NodePath<t.Function> | null {
-    let current: NodePath | null = path;
-    while (current) {
-      if (current.isArrowFunctionExpression() || current.isFunctionExpression()) {
-        const parent = current.parentPath;
-        if (parent?.isCallExpression()) {
-          const callee = parent.get("callee");
-          if (callee.isMemberExpression()) {
-            const prop = callee.get("property") as NodePath;
-            if (
-              prop.isIdentifier() &&
-              (prop.node.name === "map" || prop.node.name === "flatMap")
-            ) {
-              return current as NodePath<t.Function>;
-            }
-          }
-        }
-      }
-      current = current.parentPath;
-    }
-    return null;
-  }
-
-  private isReferenceArray(path: NodePath<t.Expression>): boolean {
-    if (!path.isIdentifier()) return false;
-
-    const binding = path.scope.getBinding(path.node.name);
-    if (!binding?.path.isVariableDeclarator()) return false;
-
-    const init = binding.path.get("init");
-    if (!init.isConditionalExpression()) return false;
-
-    const test = init.node.test;
-    return this.typeCheckUtils.isReferenceTypeCheck(test as t.Expression);
-  }
-
-  private extractFieldNameFromExpression(
-    node: t.Expression
-  ): string | null {
-    if (this.types.isMemberExpression(node)) {
-      const prop = node.property;
-      if (this.types.isIdentifier(prop)) return prop.name;
-    }
-    if (this.types.isOptionalMemberExpression(node)) {
-      const prop = node.property;
-      if (this.types.isIdentifier(prop)) return prop.name;
-    }
-    return null;
-  }
-
-  private isFieldInAncestorReference(
-    path: NodePath,
-    fieldName: string
-  ): boolean {
-    const ancestor = this.attributeUtils.findAncestorWithAttribute(
-      path,
-      DATA_COLLECTION_REFERENCE
-    );
-    if (!ancestor) return false;
-
-    const refValue = this.attributeUtils.getAttributeStringValue(
-      ancestor,
-      DATA_COLLECTION_REFERENCE
-    );
-    if (!refValue) return false;
-
-    const references = refValue.split(",").map((r) => r.trim());
-    return references.includes(fieldName);
-  }
-
-  private extractReferenceFieldFromMapChain(
-    callee: NodePath<t.MemberExpression>
-  ): string | null {
-    const prop = callee.get("property") as NodePath;
-    if (!prop.isIdentifier()) return null;
-
-    const methodName = prop.node.name;
-    const obj = callee.get("object") as NodePath<t.Expression>;
-
-    if (methodName === "map" || methodName === "flatMap") {
-      if (obj.isMemberExpression()) {
-        const fieldProp = obj.get("property") as NodePath;
-        if (fieldProp.isIdentifier()) return fieldProp.node.name;
-      }
-    }
-
-    if (methodName === "map" || methodName === "flatMap") {
-      if (obj.isCallExpression()) {
-        const innerCallee = obj.get("callee");
-        if (innerCallee.isMemberExpression()) {
-          return this.extractReferenceFieldFromMapChain(innerCallee);
-        }
-      }
-    }
-
-    if (
-      ["filter", "sort", "slice"].includes(methodName) &&
-      obj.isMemberExpression()
-    ) {
-      const fieldProp = obj.get("property") as NodePath;
-      if (fieldProp.isIdentifier()) return fieldProp.node.name;
-    }
-
-    return null;
-  }
-}