@mondaydotcomorg/atp-compiler 0.19.23 → 0.19.26

package/dist/index.cjs

@@ -863,15 +863,102 @@ var BatchParallelDetector = class {
     return void 0;
   }
 };
-function findLLMCallExpression(body) {
-  let found = null;
+function collectReferencedIdentifiers(node) {
+  const identifiers = /* @__PURE__ */ new Set();
+  const visit = /* @__PURE__ */ __name((n) => {
+    if (t7__namespace.isIdentifier(n)) {
+      identifiers.add(n.name);
+    }
+    Object.keys(n).forEach((key) => {
+      if (key === "type" || key === "loc" || key === "start" || key === "end") return;
+      const value = n[key];
+      if (Array.isArray(value)) {
+        value.forEach((item) => {
+          if (item && typeof item === "object" && item.type) {
+            visit(item);
+          }
+        });
+      } else if (value && typeof value === "object" && value.type) {
+        visit(value);
+      }
+    });
+  }, "visit");
+  visit(node);
+  return identifiers;
+}
+__name(collectReferencedIdentifiers, "collectReferencedIdentifiers");
+function collectLocalVariables(body) {
+  const locals = /* @__PURE__ */ new Set();
+  const visit = /* @__PURE__ */ __name((node) => {
+    if (t7__namespace.isVariableDeclaration(node)) {
+      for (const decl of node.declarations) {
+        if (t7__namespace.isIdentifier(decl.id)) {
+          locals.add(decl.id.name);
+        } else if (t7__namespace.isObjectPattern(decl.id)) {
+          for (const prop of decl.id.properties) {
+            if (t7__namespace.isObjectProperty(prop) && t7__namespace.isIdentifier(prop.value)) {
+              locals.add(prop.value.name);
+            } else if (t7__namespace.isRestElement(prop) && t7__namespace.isIdentifier(prop.argument)) {
+              locals.add(prop.argument.name);
+            }
+          }
+        } else if (t7__namespace.isArrayPattern(decl.id)) {
+          for (const elem of decl.id.elements) {
+            if (t7__namespace.isIdentifier(elem)) {
+              locals.add(elem.name);
+            }
+          }
+        }
+      }
+    }
+    if (t7__namespace.isFunction(node)) {
+      return;
+    }
+    Object.keys(node).forEach((key) => {
+      if (key === "type" || key === "loc" || key === "start" || key === "end") return;
+      const value = node[key];
+      if (Array.isArray(value)) {
+        value.forEach((item) => {
+          if (item && typeof item === "object" && item.type) {
+            visit(item);
+          }
+        });
+      } else if (value && typeof value === "object" && value.type) {
+        visit(value);
+      }
+    });
+  }, "visit");
+  visit(body);
+  return locals;
+}
+__name(collectLocalVariables, "collectLocalVariables");
+function hasLLMCallDependencies(body, batchDetector, itemParamName) {
+  const localVariables = collectLocalVariables(body);
+  if (localVariables.size === 0) {
+    return false;
+  }
+  const allCalls = findAllAwaitedMemberCalls(body);
+  for (const call of allCalls) {
+    const payloadNode = batchDetector.extractPayloadNode(call);
+    if (payloadNode) {
+      const referencedIds = collectReferencedIdentifiers(payloadNode);
+      for (const id of referencedIds) {
+        if (localVariables.has(id) && id !== itemParamName) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+__name(hasLLMCallDependencies, "hasLLMCallDependencies");
+function findAllAwaitedMemberCalls(body) {
+  const calls = [];
   const visit = /* @__PURE__ */ __name((node) => {
-    if (found) return;
     if (t7__namespace.isAwaitExpression(node) && t7__namespace.isCallExpression(node.argument)) {
       const call = node.argument;
       if (t7__namespace.isMemberExpression(call.callee)) {
-        found = call;
-        return;
+        calls.push(call);
       }
     }
     Object.keys(node).forEach((key) => {
@@ -888,7 +975,30 @@ function findLLMCallExpression(body) {
     });
   }, "visit");
   visit(body);
-  return found;
+  return calls;
+}
+__name(findAllAwaitedMemberCalls, "findAllAwaitedMemberCalls");
+function findAllLLMCallExpressions(body, batchDetector) {
+  const allCalls = findAllAwaitedMemberCalls(body);
+  const llmCalls = [];
+  for (const call of allCalls) {
+    const callInfo = batchDetector.extractCallInfo(call);
+    const payloadNode = batchDetector.extractPayloadNode(call);
+    if (callInfo && payloadNode) {
+      llmCalls.push({
+        callNode: call,
+        callInfo,
+        payloadNode,
+        key: `${callInfo.type}:${callInfo.operation}`
+      });
+    }
+  }
+  return llmCalls;
+}
+__name(findAllLLMCallExpressions, "findAllLLMCallExpressions");
+function findLLMCallExpression(body) {
+  const calls = findAllAwaitedMemberCalls(body);
+  return calls[0] ?? null;
 }
 __name(findLLMCallExpression, "findLLMCallExpression");
 function getArrayMethodName(node) {
@@ -1276,54 +1386,72 @@ function transformToBatchWithReconstruction(path, node, methodName, callback, ba
   }
   const param = paramName.name;
   const array = node.callee.object;
-  const llmCall = findLLMCallExpression(callback.body);
-  if (!llmCall) {
-    return false;
-  }
-  const callInfo = batchDetector.extractCallInfo(llmCall);
-  if (!callInfo) {
-    return false;
-  }
-  const payloadNode = batchDetector.extractPayloadNode(llmCall);
-  if (!payloadNode) {
+  const llmCalls = findAllLLMCallExpressions(callback.body, batchDetector);
+  if (llmCalls.length === 0) {
     return false;
   }
   const methodId = generateUniqueId(`${methodName}_batch_reconstruct`);
-  const resultsVar = `__batch_results_${methodId.replace(/[^a-zA-Z0-9]/g, "_")}`;
-  const indexVar = "__idx";
-  const payloadMapper = t7__namespace.arrowFunctionExpression([
-    t7__namespace.identifier(param)
-  ], t7__namespace.objectExpression([
-    t7__namespace.objectProperty(t7__namespace.identifier("type"), t7__namespace.stringLiteral(callInfo.type)),
-    t7__namespace.objectProperty(t7__namespace.identifier("operation"), t7__namespace.stringLiteral(callInfo.operation)),
-    t7__namespace.objectProperty(t7__namespace.identifier("payload"), t7__namespace.cloneNode(payloadNode, true))
-  ]));
+  const originalIndexParam = callback.params[1];
+  const indexVar = originalIndexParam && t7__namespace.isIdentifier(originalIndexParam) ? originalIndexParam.name : "__idx";
+  const batchDeclarations = [];
+  const resultVarByCallIndex = /* @__PURE__ */ new Map();
+  for (let i = 0; i < llmCalls.length; i++) {
+    const call = llmCalls[i];
+    const resultsVar = `__batch_results_${i}_${methodId.replace(/[^a-zA-Z0-9]/g, "_")}`;
+    resultVarByCallIndex.set(i, resultsVar);
+    const payloadMapper = t7__namespace.arrowFunctionExpression([
+      t7__namespace.identifier(param)
+    ], t7__namespace.objectExpression([
+      t7__namespace.objectProperty(t7__namespace.identifier("type"), t7__namespace.stringLiteral(call.callInfo.type)),
+      t7__namespace.objectProperty(t7__namespace.identifier("operation"), t7__namespace.stringLiteral(call.callInfo.operation)),
+      t7__namespace.objectProperty(t7__namespace.identifier("payload"), t7__namespace.cloneNode(call.payloadNode, true))
+    ]));
+    const batchCall = t7__namespace.awaitExpression(t7__namespace.callExpression(t7__namespace.memberExpression(t7__namespace.identifier("__runtime"), t7__namespace.identifier("batchParallel")), [
+      t7__namespace.callExpression(t7__namespace.memberExpression(t7__namespace.cloneNode(array, true), t7__namespace.identifier("map")), [
+        payloadMapper
+      ]),
+      t7__namespace.stringLiteral(`${methodId}_${i}`)
+    ]));
+    batchDeclarations.push(t7__namespace.variableDeclaration("const", [
+      t7__namespace.variableDeclarator(t7__namespace.identifier(resultsVar), batchCall)
+    ]));
+  }
   const clonedBody = t7__namespace.cloneNode(callback.body, true);
-  const resultAccess = t7__namespace.memberExpression(t7__namespace.identifier(resultsVar), t7__namespace.identifier(indexVar), true);
   let traversableNode;
   if (t7__namespace.isBlockStatement(clonedBody)) {
     traversableNode = t7__namespace.functionDeclaration(t7__namespace.identifier("__temp"), [], clonedBody);
   } else {
     traversableNode = t7__namespace.expressionStatement(clonedBody);
   }
-  let replaced = false;
+  let replacementCount = 0;
   traverse2(t7__namespace.file(t7__namespace.program([
     traversableNode
   ])), {
     AwaitExpression(awaitPath) {
-      if (replaced) return;
       const arg = awaitPath.node.argument;
-      if (t7__namespace.isCallExpression(arg)) {
-        const info = batchDetector.extractCallInfo(arg);
-        if (info && info.type === callInfo.type && info.operation === callInfo.operation) {
-          awaitPath.replaceWith(resultAccess);
-          replaced = true;
+      if (!t7__namespace.isCallExpression(arg)) return;
+      const info = batchDetector.extractCallInfo(arg);
+      if (!info) return;
+      const key = `${info.type}:${info.operation}`;
+      let matchedIndex = -1;
+      for (let i = 0; i < llmCalls.length; i++) {
+        const original = llmCalls[i];
+        if (original.key === key && resultVarByCallIndex.has(i)) {
+          matchedIndex = i;
+          break;
         }
       }
+      if (matchedIndex === -1) return;
+      const resultsVar = resultVarByCallIndex.get(matchedIndex);
+      if (!resultsVar) return;
+      resultVarByCallIndex.delete(matchedIndex);
+      const resultAccess = t7__namespace.memberExpression(t7__namespace.identifier(resultsVar), t7__namespace.identifier(indexVar), true);
+      awaitPath.replaceWith(resultAccess);
+      replacementCount++;
     },
     noScope: true
   });
-  if (!replaced) {
+  if (replacementCount === 0) {
     return false;
   }
   let reconstructBody;
@@ -1337,22 +1465,18 @@ function transformToBatchWithReconstruction(path, node, methodName, callback, ba
     t7__namespace.identifier(indexVar)
   ], reconstructBody);
   reconstructMapper.async = false;
-  const batchCall = t7__namespace.awaitExpression(t7__namespace.callExpression(t7__namespace.memberExpression(t7__namespace.identifier("__runtime"), t7__namespace.identifier("batchParallel")), [
-    t7__namespace.callExpression(t7__namespace.memberExpression(t7__namespace.cloneNode(array, true), t7__namespace.identifier("map")), [
-      payloadMapper
-    ]),
-    t7__namespace.stringLiteral(methodId)
-  ]));
-  const resultsDeclaration = t7__namespace.variableDeclaration("const", [
-    t7__namespace.variableDeclarator(t7__namespace.identifier(resultsVar), batchCall)
-  ]);
   const reconstructCall = t7__namespace.callExpression(t7__namespace.memberExpression(t7__namespace.cloneNode(array, true), t7__namespace.identifier("map")), [
     reconstructMapper
   ]);
-  const iife = t7__namespace.callExpression(t7__namespace.arrowFunctionExpression([], t7__namespace.blockStatement([
-    resultsDeclaration,
-    t7__namespace.returnStatement(reconstructCall)
-  ]), true), []);
+  const iife = t7__namespace.callExpression(t7__namespace.arrowFunctionExpression(
+    [],
+    t7__namespace.blockStatement([
+      ...batchDeclarations,
+      t7__namespace.returnStatement(reconstructCall)
+    ]),
+    true
+    // async
+  ), []);
   const awaitIife = t7__namespace.awaitExpression(iife);
   path.replaceWith(awaitIife);
   onTransform();
@@ -1387,10 +1511,13 @@ var ArrayTransformer = class {
     const batchResult = this.batchOptimizer.canBatchArrayMethod(callback);
     if (!batchResult.canBatch && methodName === "map") {
       const reason = batchResult.reason || "";
-      const hasObjectOrArrayReturn = reason.includes("object expression") || reason.includes("array expression");
-      if (hasObjectOrArrayReturn) {
+      const canTryBatchReconstruct = reason.includes("object expression") || reason.includes("array expression") || reason.includes("Multiple pausable calls");
+      if (canTryBatchReconstruct) {
         const llmCall = findLLMCallExpression(callback.body);
-        if (llmCall) {
+        const itemParam = callback.params[0];
+        const itemParamName = t7__namespace.isIdentifier(itemParam) ? itemParam.name : void 0;
+        const hasDependencies = hasLLMCallDependencies(callback.body, this.batchDetector, itemParamName);
+        if (llmCall && !hasDependencies) {
           const success = transformToBatchWithReconstruction(path, node, methodName, callback, this.batchDetector, () => this.transformCount++);
           if (success) {
             return true;