@mondaydotcomorg/atp-compiler 0.19.22 → 0.19.23

package/dist/index.js

@@ -1239,6 +1239,100 @@ function transformToSequential(path, node, methodName, callback, onTransform) {
   return true;
 }
 __name(transformToSequential, "transformToSequential");
+var traverse2 = typeof _traverse.default === "function" ? _traverse.default : _traverse;
+function transformToBatchWithReconstruction(path, node, methodName, callback, batchDetector, onTransform) {
+  if (methodName !== "map") {
+    return false;
+  }
+  const paramName = callback.params[0];
+  if (!t7.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.arrowFunctionExpression([
+    t7.identifier(param)
+  ], t7.objectExpression([
+    t7.objectProperty(t7.identifier("type"), t7.stringLiteral(callInfo.type)),
+    t7.objectProperty(t7.identifier("operation"), t7.stringLiteral(callInfo.operation)),
+    t7.objectProperty(t7.identifier("payload"), t7.cloneNode(payloadNode, true))
+  ]));
+  const clonedBody = t7.cloneNode(callback.body, true);
+  const resultAccess = t7.memberExpression(t7.identifier(resultsVar), t7.identifier(indexVar), true);
+  let traversableNode;
+  if (t7.isBlockStatement(clonedBody)) {
+    traversableNode = t7.functionDeclaration(t7.identifier("__temp"), [], clonedBody);
+  } else {
+    traversableNode = t7.expressionStatement(clonedBody);
+  }
+  let replaced = false;
+  traverse2(t7.file(t7.program([
+    traversableNode
+  ])), {
+    AwaitExpression(awaitPath) {
+      if (replaced) return;
+      const arg = awaitPath.node.argument;
+      if (t7.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.isBlockStatement(clonedBody)) {
+    reconstructBody = clonedBody;
+  } else {
+    reconstructBody = clonedBody;
+  }
+  const reconstructMapper = t7.arrowFunctionExpression([
+    t7.identifier(param),
+    t7.identifier(indexVar)
+  ], reconstructBody);
+  reconstructMapper.async = false;
+  const batchCall = t7.awaitExpression(t7.callExpression(t7.memberExpression(t7.identifier("__runtime"), t7.identifier("batchParallel")), [
+    t7.callExpression(t7.memberExpression(t7.cloneNode(array, true), t7.identifier("map")), [
+      payloadMapper
+    ]),
+    t7.stringLiteral(methodId)
+  ]));
+  const resultsDeclaration = t7.variableDeclaration("const", [
+    t7.variableDeclarator(t7.identifier(resultsVar), batchCall)
+  ]);
+  const reconstructCall = t7.callExpression(t7.memberExpression(t7.cloneNode(array, true), t7.identifier("map")), [
+    reconstructMapper
+  ]);
+  const iife = t7.callExpression(t7.arrowFunctionExpression([], t7.blockStatement([
+    resultsDeclaration,
+    t7.returnStatement(reconstructCall)
+  ]), true), []);
+  const awaitIife = t7.awaitExpression(iife);
+  path.replaceWith(awaitIife);
+  onTransform();
+  return true;
+}
+__name(transformToBatchWithReconstruction, "transformToBatchWithReconstruction");
 
 // src/transformer/array-transformer.ts
 var ArrayTransformer = class {
@@ -1265,6 +1359,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);
@@ -1568,7 +1675,7 @@ function isTransformationError(error) {
 __name(isTransformationError, "isTransformationError");
 
 // src/transformer/index.ts
-var traverse2 = _traverse.default || _traverse;
+var traverse3 = _traverse.default || _traverse;
 var generate = _generate.default || _generate;
 var ATPCompiler = class {
   static {
@@ -1620,7 +1727,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"),
@@ -2303,7 +2410,7 @@ function createTransformPlugin(config) {
   };
 }
 __name(createTransformPlugin, "createTransformPlugin");
-var traverse3 = _traverse.default || _traverse;
+var traverse4 = _traverse.default || _traverse;
 var generate2 = _generate.default || _generate;
 var PluggableCompiler = class {
   static {
@@ -2424,7 +2531,7 @@ var PluggableCompiler = class {
           }
         }
       }
-      traverse3(ast, visitors);
+      traverse4(ast, visitors);
       let optimizedAst = ast;
       const optimizers = this.registry.getOptimizers();
       for (const optimizer of optimizers) {
@@ -2816,7 +2923,7 @@ var AsyncTimeoutPlugin = class {
     return null;
   }
 };
-var traverse4 = _traverse.default || _traverse;
+var traverse5 = _traverse.default || _traverse;
 var SecurityValidatorPlugin = class {
   static {
     __name(this, "SecurityValidatorPlugin");
@@ -2853,7 +2960,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);
@@ -2900,6 +3007,6 @@ function getDepth(path) {
 }
 __name(getDepth, "getDepth");
 
-export { ATPCompiler, ArrayTransformer, AsyncIterationDetector, AsyncTimeoutPlugin, BatchOptimizer, BatchParallelDetector, BatchPauseExecutionError, CheckpointError, CheckpointManager, CheckpointOperation, DEFAULT_COMPILER_CONFIG, DefaultArrayTransformerPlugin, DefaultDetectionPlugin, DefaultLoopTransformerPlugin, DefaultPromiseTransformerPlugin, IN_ISOLATE_RUNTIME_FUNCTIONS, InfiniteLoopDetectionError, LoopTransformer, PAUSABLE_CALL_PATTERNS, PluggableCompiler, PluginRegistry, PromiseTransformer, RuntimeFunction, SecurityValidationError, SecurityValidatorPlugin, TransformationError, batchParallel, cleanupRuntime, clearCheckpointManager, clearRuntimeContext, containsAwait, containsPausableCall, createDefaultCompiler, createRuntimeCall, createTransformPlugin, extractForOfParamName, generateUniqueId, getCheckpointManager, getMemberExpressionPath, getNodeLocation, getRuntimeContext, hasCheckpointManager, hasRuntimeContext, initializeRuntime, isArrayMethod, isAsyncFunction, isBatchPauseError, isCheckpointError, isCompiler, isInIsolateRuntimeFunction, isPausableCall, isPausableCallExpression, isTransformationError, resetIdCounter, resumableEvery, resumableFilter, resumableFind, resumableFlatMap, resumableForEach, resumableForLoop, resumableForOf, resumableMap, resumablePromiseAll, resumablePromiseAllSettled, resumableReduce, resumableSome, resumableWhile, setCheckpointManager, setRuntimeContext, wrapInAsyncFunction };
+export { ATPCompiler, ArrayTransformer, AsyncIterationDetector, AsyncTimeoutPlugin, BatchOptimizer, BatchParallelDetector, BatchPauseExecutionError, CheckpointError, CheckpointManager, CheckpointOperation, DEFAULT_COMPILER_CONFIG, DefaultArrayTransformerPlugin, DefaultDetectionPlugin, DefaultLoopTransformerPlugin, DefaultPromiseTransformerPlugin, IN_ISOLATE_RUNTIME_FUNCTIONS, InfiniteLoopDetectionError, LoopTransformer, PAUSABLE_CALL_PATTERNS, PluggableCompiler, PluginRegistry, PromiseTransformer, RuntimeFunction, SecurityValidationError, SecurityValidatorPlugin, TransformationError, batchParallel, cleanupRuntime, clearCheckpointManager, clearRuntimeContext, containsAwait, containsPausableCall, createDefaultCompiler, createRuntimeCall, createTransformPlugin, extractForOfParamName, generateUniqueId, getCheckpointManager, getMemberExpressionPath, getNodeLocation, getRuntimeContext, hasCheckpointManager, hasRuntimeContext, initializeRuntime, isArrayMethod, isAsyncFunction, isBatchPauseError, isCheckpointError, isCompiler, isInIsolateRuntimeFunction, isPausableCall, isPausableCallExpression, isTransformationError, resetIdCounter, resumableEvery, resumableFilter, resumableFind, resumableFlatMap, resumableForEach, resumableForLoop, resumableForOf, resumableMap, resumablePromiseAll, resumablePromiseAllSettled, resumableReduce, resumableSome, resumableWhile, setCheckpointManager, setRuntimeContext, transformToBatchWithReconstruction, wrapInAsyncFunction };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map