@base44-preview/vite-plugin 0.2.26-pr.43.e9195be → 0.2.27-pr.41.77be9cb

package/src/processors/shared-utils.ts

@@ -1,7 +1,6 @@
 import type { NodePath } from "@babel/traverse";
 import type * as t from "@babel/types";
 import { JSXUtils } from "../jsx-utils.js";
-import { ALLOWED_CUSTOM_COMPONENTS, EXCLUDED_FIELDS } from "../consts.js";
 
 export class JSXAttributeUtils {
   constructor(private types: typeof t) {}
@@ -17,32 +16,6 @@ export class JSXAttributeUtils {
     );
   }
 
-  getAttributeValue(
-    path: NodePath<t.JSXOpeningElement>,
-    attributeName: string
-  ): t.JSXAttribute["value"] | null {
-    for (const attr of path.node.attributes) {
-      if (
-        this.types.isJSXAttribute(attr) &&
-        JSXUtils.getAttributeName(attr) === attributeName
-      ) {
-        return attr.value;
-      }
-    }
-    return null;
-  }
-
-  getAttributeStringValue(
-    path: NodePath<t.JSXOpeningElement>,
-    attributeName: string
-  ): string | null {
-    const value = this.getAttributeValue(path, attributeName);
-    if (value && this.types.isStringLiteral(value)) {
-      return value.value;
-    }
-    return null;
-  }
-
   addStringAttribute(
     path: NodePath<t.JSXOpeningElement>,
     attributeName: string,
@@ -72,476 +45,6 @@ export class JSXAttributeUtils {
       );
     }
   }
-
-  findAncestorWithAttribute(
-    path: NodePath,
-    attributeName: string
-  ): NodePath<t.JSXOpeningElement> | null {
-    let current: NodePath | null = path.parentPath;
-    while (current) {
-      if (current.isJSXElement()) {
-        const opening = current.get("openingElement");
-        if (this.hasAttribute(opening, attributeName)) {
-          return opening;
-        }
-      }
-      current = current.parentPath;
-    }
-    return null;
-  }
-}
-
-export class PathNavigationUtils {
-  constructor(private types: typeof t) {}
-
-  findParentJSXElement(
-    path: NodePath
-  ): NodePath<t.JSXElement> | null {
-    let current: NodePath | null = path.parentPath;
-    while (current) {
-      if (current.isJSXElement()) return current;
-      current = current.parentPath;
-    }
-    return null;
-  }
-
-  findEnclosingFunction(
-    path: NodePath
-  ): NodePath<t.Function> | null {
-    let current: NodePath | null = path.parentPath;
-    while (current) {
-      if (current.isFunction()) return current as NodePath<t.Function>;
-      current = current.parentPath;
-    }
-    return null;
-  }
-
-  findReturnStatement(
-    path: NodePath
-  ): NodePath<t.ReturnStatement> | null {
-    let current: NodePath | null = path.parentPath;
-    while (current) {
-      if (current.isReturnStatement()) return current;
-      current = current.parentPath;
-    }
-    return null;
-  }
-
-  isRootReturnElement(
-    path: NodePath<t.JSXOpeningElement>
-  ): boolean {
-    const jsxElement = path.parentPath;
-    if (!jsxElement?.isJSXElement()) return false;
-
-    const parent = jsxElement.parentPath;
-    if (!parent) return false;
-
-    if (parent.isReturnStatement()) return true;
-
-    if (parent.isArrowFunctionExpression()) return true;
-
-    if (parent.isParenthesizedExpression()) {
-      const grandparent = parent.parentPath;
-      if (grandparent?.isReturnStatement()) return true;
-      if (grandparent?.isArrowFunctionExpression()) return true;
-    }
-
-    return false;
-  }
-
-  findDOMElementTarget(
-    path: NodePath<t.JSXOpeningElement>
-  ): NodePath<t.JSXOpeningElement> | null {
-    if (this.isDOMOrAllowedElement(path)) return path;
-
-    let current: NodePath | null = path.parentPath;
-    while (current) {
-      if (current.isJSXElement()) {
-        const opening = current.get("openingElement");
-        if (this.isDOMOrAllowedElement(opening)) return opening;
-      }
-      current = current.parentPath;
-    }
-    return null;
-  }
-
-  private isDOMOrAllowedElement(
-    path: NodePath<t.JSXOpeningElement>
-  ): boolean {
-    const name = JSXUtils.getElementName(path.node);
-    if (!name) return false;
-
-    if (name.charAt(0) === name.charAt(0).toLowerCase()) return true;
-
-    return ALLOWED_CUSTOM_COMPONENTS.includes(name);
-  }
-}
-
-export class ExpressionAnalysisUtils {
-  constructor(private types: typeof t) {}
-
-  isIdAccess(node: t.Expression): boolean {
-    if (!this.types.isMemberExpression(node)) return false;
-    if (this.types.isIdentifier(node.property)) {
-      return node.property.name === "_id" || node.property.name === "id";
-    }
-    if (this.types.isStringLiteral(node.property)) {
-      return node.property.value === "_id" || node.property.value === "id";
-    }
-    return false;
-  }
-
-  isItemsAccess(node: t.Expression): boolean {
-    return (
-      this.types.isMemberExpression(node) &&
-      this.types.isIdentifier(node.property) &&
-      node.property.name === "items"
-    );
-  }
-
-  isLengthAccess(node: t.Expression): boolean {
-    return (
-      this.types.isMemberExpression(node) &&
-      this.types.isIdentifier(node.property) &&
-      node.property.name === "length"
-    );
-  }
-
-  extractRootIdentifier(node: t.Expression): t.Identifier | null {
-    if (this.types.isIdentifier(node)) return node;
-    if (this.types.isMemberExpression(node)) {
-      return this.extractRootIdentifier(node.object as t.Expression);
-    }
-    if (this.types.isOptionalMemberExpression(node)) {
-      return this.extractRootIdentifier(node.object as t.Expression);
-    }
-    if (this.types.isCallExpression(node) && this.types.isMemberExpression(node.callee)) {
-      return this.extractRootIdentifier(node.callee.object as t.Expression);
-    }
-    return null;
-  }
-
-  unwrapLogicalExpression(node: t.Expression): t.Expression {
-    if (this.types.isLogicalExpression(node)) {
-      if (node.operator === "&&") return node.right as t.Expression;
-      if (node.operator === "||" || node.operator === "??") {
-        return node.left as t.Expression;
-      }
-    }
-    return node;
-  }
-
-  collectMemberExpressionPath(node: t.Expression): string[] {
-    const parts: string[] = [];
-    let current: t.Expression = node;
-
-    while (
-      this.types.isMemberExpression(current) ||
-      this.types.isOptionalMemberExpression(current)
-    ) {
-      const prop = (current as t.MemberExpression).property;
-      if (this.types.isIdentifier(prop)) {
-        parts.unshift(prop.name);
-      } else if (this.types.isStringLiteral(prop)) {
-        parts.unshift(prop.value);
-      }
-      current = (current as t.MemberExpression).object as t.Expression;
-    }
-
-    if (this.types.isIdentifier(current)) {
-      parts.unshift(current.name);
-    }
-
-    return parts;
-  }
-
-  createOptionalChainExpression(
-    node: t.MemberExpression
-  ): t.OptionalMemberExpression {
-    const object = this.types.isOptionalMemberExpression(node.object)
-      ? node.object
-      : this.types.isMemberExpression(node.object)
-        ? this.createOptionalChainExpression(node.object)
-        : node.object;
-
-    const property = node.property as t.Expression;
-
-    return this.types.optionalMemberExpression(
-      object,
-      property,
-      node.computed,
-      true
-    );
-  }
-
-  getFieldPathFromExpression(
-    node: t.Expression,
-    rootName: string
-  ): string | null {
-    const parts = this.collectMemberExpressionPath(node);
-    if (parts.length < 2) return null;
-    if (parts[0] !== rootName) return null;
-
-    const fieldParts = parts.slice(1);
-    const fieldPath = fieldParts.join(".");
-
-    if (EXCLUDED_FIELDS.includes(fieldPath)) return null;
-    return fieldPath;
-  }
-}
-
-export class BindingUtils {
-  constructor(private types: typeof t) {}
-
-  isFunctionParameter(
-    identifierName: string,
-    path: NodePath
-  ): boolean {
-    const fn = path.getFunctionParent();
-    if (!fn) return false;
-
-    const params = fn.get("params");
-    for (const param of (Array.isArray(params) ? params : [params])) {
-      if (param.isIdentifier() && param.node.name === identifierName) {
-        return true;
-      }
-      if (param.isObjectPattern()) {
-        for (const prop of param.get("properties")) {
-          if (
-            prop.isObjectProperty() &&
-            this.types.isIdentifier(prop.node.value) &&
-            prop.node.value.name === identifierName
-          ) {
-            return true;
-          }
-        }
-      }
-      if (param.isArrayPattern()) {
-        for (const el of param.get("elements")) {
-          if (el.isIdentifier() && el.node.name === identifierName) {
-            return true;
-          }
-        }
-      }
-    }
-    return false;
-  }
-
-  isUseStateCall(
-    init: NodePath<t.Node>
-  ): { stateIndex: number; setterName: string | null } | null {
-    if (!init.isCallExpression()) return null;
-
-    const callee = init.get("callee");
-    if (!callee.isIdentifier() || callee.node.name !== "useState") return null;
-
-    const declarator = init.parentPath;
-    if (!declarator?.isVariableDeclarator()) return null;
-
-    const id = declarator.get("id");
-    if (!id.isArrayPattern()) return null;
-
-    const elements = id.get("elements");
-    const setterEl = elements[1];
-    const setterName =
-      setterEl && setterEl.isIdentifier() ? setterEl.node.name : null;
-
-    return { stateIndex: 0, setterName };
-  }
-
-  isPromiseAllCall(
-    init: NodePath<t.Node>
-  ): boolean {
-    if (!init.isAwaitExpression()) {
-      if (init.isCallExpression()) {
-        const callee = init.get("callee");
-        return this.isPromiseAllCallee(callee);
-      }
-      return false;
-    }
-
-    const argument = init.get("argument");
-    if (!argument.isCallExpression()) return false;
-
-    const callee = argument.get("callee");
-    return this.isPromiseAllCallee(callee);
-  }
-
-  private isPromiseAllCallee(callee: NodePath): boolean {
-    if (!callee.isMemberExpression()) return false;
-    const obj = callee.get("object") as NodePath;
-    const prop = callee.get("property") as NodePath;
-    return (
-      obj.isIdentifier() &&
-      obj.node.name === "Promise" &&
-      prop.isIdentifier() &&
-      prop.node.name === "all"
-    );
-  }
-
-  extractDestructuredProperties(
-    pattern: t.ObjectPattern
-  ): string[] {
-    const properties: string[] = [];
-    for (const prop of pattern.properties) {
-      if (this.types.isObjectProperty(prop)) {
-        if (this.types.isIdentifier(prop.key)) {
-          properties.push(prop.key.name);
-        } else if (this.types.isStringLiteral(prop.key)) {
-          properties.push(prop.key.value);
-        }
-      }
-    }
-    return properties;
-  }
-
-  findSetterCallInScope(
-    setterName: string,
-    scope: NodePath
-  ): NodePath<t.CallExpression> | null {
-    let result: NodePath<t.CallExpression> | null = null;
-
-    scope.traverse({
-      CallExpression(callPath) {
-        if (result) return;
-        const callee = callPath.get("callee");
-        if (callee.isIdentifier() && callee.node.name === setterName) {
-          result = callPath;
-        }
-      },
-    });
-
-    return result;
-  }
-}
-
-export class CallExpressionUtils {
-  constructor(private types: typeof t) {}
-
-  isGetAllCall(
-    node: t.CallExpression
-  ): { collectionName: string; references: string[] } | null {
-    const callee = node.callee;
-    if (!this.types.isMemberExpression(callee)) return null;
-
-    const obj = callee.object;
-    const prop = callee.property;
-
-    if (
-      !this.types.isIdentifier(obj) ||
-      obj.name !== "BaseCrudService" ||
-      !this.types.isIdentifier(prop) ||
-      prop.name !== "getAll"
-    ) {
-      return null;
-    }
-
-    const args = node.arguments;
-    if (args.length < 1) return null;
-
-    const firstArg = args[0];
-    if (!this.types.isStringLiteral(firstArg)) return null;
-
-    const collectionName = firstArg.value;
-    const references = this.extractReferencesFromArg(args[1]);
-
-    return { collectionName, references };
-  }
-
-  isGetByIdCall(
-    node: t.CallExpression
-  ): {
-    collectionName: string;
-    multiRefFields: string[];
-  } | null {
-    const callee = node.callee;
-    if (!this.types.isMemberExpression(callee)) return null;
-
-    const obj = callee.object;
-    const prop = callee.property;
-
-    if (
-      !this.types.isIdentifier(obj) ||
-      obj.name !== "BaseCrudService" ||
-      !this.types.isIdentifier(prop) ||
-      prop.name !== "getById"
-    ) {
-      return null;
-    }
-
-    const args = node.arguments;
-    if (args.length < 1) return null;
-
-    const firstArg = args[0];
-    if (!this.types.isStringLiteral(firstArg)) return null;
-
-    const collectionName = firstArg.value;
-    const multiRefFields = this.extractMultiRefFromOptions(args[2]);
-
-    return { collectionName, multiRefFields };
-  }
-
-  private extractReferencesFromArg(
-    arg: t.Expression | t.SpreadElement | t.ArgumentPlaceholder | undefined
-  ): string[] {
-    if (!arg || !this.types.isArrayExpression(arg)) return [];
-
-    return arg.elements
-      .filter((el): el is t.StringLiteral => this.types.isStringLiteral(el))
-      .map((el) => el.value);
-  }
-
-  private extractMultiRefFromOptions(
-    arg: t.Expression | t.SpreadElement | t.ArgumentPlaceholder | undefined
-  ): string[] {
-    if (!arg || !this.types.isObjectExpression(arg)) return [];
-
-    for (const prop of arg.properties) {
-      if (
-        this.types.isObjectProperty(prop) &&
-        this.types.isIdentifier(prop.key) &&
-        prop.key.name === "multiRef" &&
-        this.types.isArrayExpression(prop.value)
-      ) {
-        return prop.value.elements
-          .filter((el): el is t.StringLiteral =>
-            this.types.isStringLiteral(el)
-          )
-          .map((el) => el.value);
-      }
-    }
-    return [];
-  }
-
-  isArrayMethod(
-    node: t.CallExpression,
-    methodName: string
-  ): boolean {
-    const callee = node.callee;
-    return (
-      this.types.isMemberExpression(callee) &&
-      this.types.isIdentifier(callee.property) &&
-      callee.property.name === methodName
-    );
-  }
-
-  isChainedArrayMethod(node: t.CallExpression): boolean {
-    const chainMethods = ["filter", "sort", "slice", "concat", "reverse", "flat"];
-    return chainMethods.some((m) => this.isArrayMethod(node, m));
-  }
-
-  getCallbackArgument(
-    callExpr: t.CallExpression
-  ): t.ArrowFunctionExpression | t.FunctionExpression | null {
-    const firstArg = callExpr.arguments[0];
-    if (
-      this.types.isArrowFunctionExpression(firstArg) ||
-      this.types.isFunctionExpression(firstArg)
-    ) {
-      return firstArg;
-    }
-    return null;
-  }
 }
 
 export class StaticValueUtils {
@@ -610,103 +113,4 @@ export class StaticValueUtils {
       return this.isStaticValue(element as unknown as NodePath<t.Node>, visited);
     });
   }
-
-  isDerivedFromStaticData(
-    identifierName: string,
-    path: NodePath
-  ): boolean {
-    const binding = path.scope.getBinding(identifierName);
-    if (!binding) return false;
-
-    if (binding.path.isVariableDeclarator()) {
-      const init = binding.path.get("init");
-      if (init.isArrayExpression() || init.isObjectExpression()) {
-        return this.isStaticValue(init as NodePath<t.Node>);
-      }
-    }
-
-    const fnParent = path.getFunctionParent();
-    if (!fnParent) return false;
-
-    const params = fnParent.get("params");
-    for (const param of (Array.isArray(params) ? params : [params])) {
-      if (param.isIdentifier() && param.node.name === identifierName) {
-        const mapCall = fnParent.parentPath;
-        if (mapCall?.isCallExpression()) {
-          const callee = mapCall.get("callee");
-          if (
-            callee.isMemberExpression() &&
-            (callee.get("property") as NodePath).isIdentifier()
-          ) {
-            const propName = ((callee.get("property") as NodePath).node as t.Identifier).name;
-            if (propName === "map" || propName === "flatMap") {
-              const arrayObj = callee.get("object") as NodePath<t.Expression>;
-              if (arrayObj.isIdentifier()) {
-                return this.isDerivedFromStaticData(arrayObj.node.name, arrayObj);
-              }
-              if (arrayObj.isArrayExpression()) {
-                return this.isStaticArrayExpression(arrayObj);
-              }
-            }
-          }
-        }
-      }
-    }
-
-    return false;
-  }
-}
-
-export class TypeCheckUtils {
-  constructor(private types: typeof t) {}
-
-  isArrayIsArrayCheck(node: t.Expression): boolean {
-    if (!this.types.isCallExpression(node)) return false;
-
-    const callee = node.callee;
-    return (
-      this.types.isMemberExpression(callee) &&
-      this.types.isIdentifier(callee.object) &&
-      callee.object.name === "Array" &&
-      this.types.isIdentifier(callee.property) &&
-      callee.property.name === "isArray"
-    );
-  }
-
-  isTypeofObjectCheck(node: t.Expression): boolean {
-    if (!this.types.isBinaryExpression(node)) return false;
-    if (node.operator !== "===" && node.operator !== "==") return false;
-
-    const isTypeof = (side: t.Expression) =>
-      this.types.isUnaryExpression(side) && side.operator === "typeof";
-    const isObjectString = (side: t.Expression) =>
-      this.types.isStringLiteral(side) && side.value === "object";
-
-    return (
-      (isTypeof(node.left as t.Expression) &&
-        isObjectString(node.right as t.Expression)) ||
-      (isObjectString(node.left as t.Expression) &&
-        isTypeof(node.right as t.Expression))
-    );
-  }
-
-  isReferenceTypeCheck(node: t.Expression): boolean {
-    return this.isArrayIsArrayCheck(node) || this.isTypeofObjectCheck(node);
-  }
-
-  isLengthCheck(node: t.Expression): boolean {
-    if (this.types.isMemberExpression(node)) {
-      return (
-        this.types.isIdentifier(node.property) &&
-        node.property.name === "length"
-      );
-    }
-    if (this.types.isOptionalMemberExpression(node)) {
-      return (
-        this.types.isIdentifier(node.property) &&
-        node.property.name === "length"
-      );
-    }
-    return false;
-  }
 }

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

@@ -1,13 +1,10 @@
 import type { NodePath } from "@babel/traverse";
 import type * as t from "@babel/types";
-import {
-  DATA_ARR_INDEX,
-  DATA_ARR_VARIABLE_NAME,
-  DATA_ARR_FIELD,
-} from "../consts.js";
 import { JSXAttributeUtils, StaticValueUtils } from "./shared-utils.js";
 
-export { DATA_ARR_INDEX, DATA_ARR_VARIABLE_NAME, DATA_ARR_FIELD };
+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 {