@mondaydotcomorg/atp-compiler 0.19.21 → 0.19.23

package/dist/index.cjs

@@ -507,6 +507,21 @@ var BatchOptimizer = class {
         reason: "Simple conditional - can batch but consider array size"
       };
     }
+    const lastStmt = statements[statements.length - 1];
+    if (t7__namespace.isReturnStatement(lastStmt) && lastStmt.argument) {
+      if (t7__namespace.isObjectExpression(lastStmt.argument)) {
+        return {
+          canBatch: false,
+          reason: "Return statement is object expression - batch would lose structure"
+        };
+      }
+      if (t7__namespace.isArrayExpression(lastStmt.argument)) {
+        return {
+          canBatch: false,
+          reason: "Return statement is array expression - batch would lose structure"
+        };
+      }
+    }
     return {
       canBatch: true,
       llmCallPattern: "single",
@@ -1250,6 +1265,100 @@ 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 llmCall = findLLMCallExpression(callback.body);
+  if (!llmCall) {
+    return false;
+  }
+  const callInfo = batchDetector.extractCallInfo(llmCall);
+  if (!callInfo) {
+    return false;
+  }
+  const payloadNode = batchDetector.extractPayloadNode(llmCall);
+  if (!payloadNode) {
+    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 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;
+  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;
+        }
+      }
+    },
+    noScope: true
+  });
+  if (!replaced) {
+    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 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 awaitIife = t7__namespace.awaitExpression(iife);
+  path.replaceWith(awaitIife);
+  onTransform();
+  return true;
+}
+__name(transformToBatchWithReconstruction, "transformToBatchWithReconstruction");
 
 // src/transformer/array-transformer.ts
 var ArrayTransformer = class {
@@ -1276,6 +1385,19 @@ var ArrayTransformer = class {
       return false;
     }
     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 llmCall = findLLMCallExpression(callback.body);
+        if (llmCall) {
+          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);
@@ -1579,7 +1701,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 {
@@ -1631,7 +1753,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"),
@@ -2314,7 +2436,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 {
@@ -2435,7 +2557,7 @@ var PluggableCompiler = class {
           }
         }
       }
-      traverse3(ast, visitors);
+      traverse4(ast, visitors);
       let optimizedAst = ast;
       const optimizers = this.registry.getOptimizers();
       for (const optimizer of optimizers) {
@@ -2827,7 +2949,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");
@@ -2864,7 +2986,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);
@@ -2979,6 +3101,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