@mondaydotcomorg/atp-compiler 0.19.22 → 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) {
@@ -1265,6 +1375,114 @@ function transformToSequential(path, node, methodName, callback, onTransform) {
   return true;
 }
 __name(transformToSequential, "transformToSequential");
+var traverse2 = typeof _traverse__default.default.default === "function" ? _traverse__default.default.default : _traverse__default.default;
+function transformToBatchWithReconstruction(path, node, methodName, callback, batchDetector, onTransform) {
+  if (methodName !== "map") {
+    return false;
+  }
+  const paramName = callback.params[0];
+  if (!t7__namespace.isIdentifier(paramName)) {
+    return false;
+  }
+  const param = paramName.name;
+  const array = node.callee.object;
+  const llmCalls = findAllLLMCallExpressions(callback.body, batchDetector);
+  if (llmCalls.length === 0) {
+    return false;
+  }
+  const methodId = generateUniqueId(`${methodName}_batch_reconstruct`);
+  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);
+  let traversableNode;
+  if (t7__namespace.isBlockStatement(clonedBody)) {
+    traversableNode = t7__namespace.functionDeclaration(t7__namespace.identifier("__temp"), [], clonedBody);
+  } else {
+    traversableNode = t7__namespace.expressionStatement(clonedBody);
+  }
+  let replacementCount = 0;
+  traverse2(t7__namespace.file(t7__namespace.program([
+    traversableNode
+  ])), {
+    AwaitExpression(awaitPath) {
+      const arg = awaitPath.node.argument;
+      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 (replacementCount === 0) {
+    return false;
+  }
+  let reconstructBody;
+  if (t7__namespace.isBlockStatement(clonedBody)) {
+    reconstructBody = clonedBody;
+  } else {
+    reconstructBody = clonedBody;
+  }
+  const reconstructMapper = t7__namespace.arrowFunctionExpression([
+    t7__namespace.identifier(param),
+    t7__namespace.identifier(indexVar)
+  ], reconstructBody);
+  reconstructMapper.async = false;
+  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([
+      ...batchDeclarations,
+      t7__namespace.returnStatement(reconstructCall)
+    ]),
+    true
+    // async
+  ), []);
+  const awaitIife = t7__namespace.awaitExpression(iife);
+  path.replaceWith(awaitIife);
+  onTransform();
+  return true;
+}
+__name(transformToBatchWithReconstruction, "transformToBatchWithReconstruction");
 
 // src/transformer/array-transformer.ts
 var ArrayTransformer = class {
@@ -1291,6 +1509,22 @@ var ArrayTransformer = class {
       return false;
     }
     const batchResult = this.batchOptimizer.canBatchArrayMethod(callback);
+    if (!batchResult.canBatch && methodName === "map") {
+      const reason = batchResult.reason || "";
+      const canTryBatchReconstruct = reason.includes("object expression") || reason.includes("array expression") || reason.includes("Multiple pausable calls");
+      if (canTryBatchReconstruct) {
+        const llmCall = findLLMCallExpression(callback.body);
+        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;
+          }
+        }
+      }
+    }
     if (batchResult.canBatch && canUseBatchParallel(methodName)) {
       const array = node.callee.object;
       const decision = this.batchOptimizer.makeSmartBatchDecision(methodName, batchResult, array, this.batchSizeThreshold);
@@ -1594,7 +1828,7 @@ function isTransformationError(error) {
 __name(isTransformationError, "isTransformationError");
 
 // src/transformer/index.ts
-var traverse2 = _traverse__default.default.default || _traverse__default.default;
+var traverse3 = _traverse__default.default.default || _traverse__default.default;
 var generate = _generate__default.default.default || _generate__default.default;
 var ATPCompiler = class {
   static {
@@ -1646,7 +1880,7 @@ var ATPCompiler = class {
       this.loopTransformer.resetTransformCount();
       this.arrayTransformer.resetTransformCount();
       this.promiseTransformer.resetTransformCount();
-      traverse2(ast, {
+      traverse3(ast, {
         ForOfStatement: /* @__PURE__ */ __name((path) => {
           this.loopTransformer.transformForOfLoop(path);
         }, "ForOfStatement"),
@@ -2329,7 +2563,7 @@ function createTransformPlugin(config) {
   };
 }
 __name(createTransformPlugin, "createTransformPlugin");
-var traverse3 = _traverse__default.default.default || _traverse__default.default;
+var traverse4 = _traverse__default.default.default || _traverse__default.default;
 var generate2 = _generate__default.default.default || _generate__default.default;
 var PluggableCompiler = class {
   static {
@@ -2450,7 +2684,7 @@ var PluggableCompiler = class {
           }
         }
       }
-      traverse3(ast, visitors);
+      traverse4(ast, visitors);
       let optimizedAst = ast;
       const optimizers = this.registry.getOptimizers();
       for (const optimizer of optimizers) {
@@ -2842,7 +3076,7 @@ var AsyncTimeoutPlugin = class {
     return null;
   }
 };
-var traverse4 = _traverse__default.default.default || _traverse__default.default;
+var traverse5 = _traverse__default.default.default || _traverse__default.default;
 var SecurityValidatorPlugin = class {
   static {
     __name(this, "SecurityValidatorPlugin");
@@ -2879,7 +3113,7 @@ var SecurityValidatorPlugin = class {
     }
     let maxNestingFound = 0;
     let complexityScore = 0;
-    traverse4(ast, {
+    traverse5(ast, {
       enter(path) {
         const depth = path.scope.path.node ? getDepth(path) : 0;
         maxNestingFound = Math.max(maxNestingFound, depth);
@@ -2994,6 +3228,7 @@ exports.resumableSome = resumableSome;
 exports.resumableWhile = resumableWhile;
 exports.setCheckpointManager = setCheckpointManager;
 exports.setRuntimeContext = setRuntimeContext;
+exports.transformToBatchWithReconstruction = transformToBatchWithReconstruction;
 exports.wrapInAsyncFunction = wrapInAsyncFunction;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map