intellitester 0.2.21 → 0.2.22

package/dist/{chunk-PP666GZQ.cjs → chunk-GCF2Q77Q.cjs}

@@ -1020,6 +1020,30 @@ var APPWRITE_DELETE_PATTERNS = {
   teamDelete: /\/v1\/teams\/([\w-]+)$/,
   membershipDelete: /\/v1\/teams\/([\w-]+)\/memberships\/([\w-]+)$/
 };
+
+// src/executors/web/browserOptions.ts
+function getBrowserLaunchOptions(options) {
+  return {
+    headless: options.headless,
+    args: [
+      // Shared memory - critical for Docker/CI, harmless locally
+      "--disable-dev-shm-usage",
+      // GPU acceleration - not needed in headless mode
+      "--disable-gpu",
+      // Reduce overhead
+      "--disable-extensions",
+      // Prevent JavaScript throttling (helps with slow page loads)
+      "--disable-background-timer-throttling",
+      "--disable-backgrounding-occluded-windows",
+      "--disable-renderer-backgrounding",
+      // Process isolation - reduces overhead for testing
+      "--disable-features=IsolateOrigins,site-per-process",
+      // Networking tweaks
+      "--disable-features=VizDisplayCompositor",
+      "--disable-blink-features=AutomationControlled"
+    ]
+  };
+}
 function resolveEnvVars(value) {
   return value.replace(/\$\{(\w+)\}/g, (_, name) => process.env[name] || "");
 }
@@ -1972,7 +1996,7 @@ var runWebTest = async (test, options = {}) => {
   process.on("SIGINT", cleanup);
   process.on("SIGTERM", cleanup);
   console.log(`Launching ${browserName}${headless ? " (headless)" : " (visible)"}...`);
-  const browser = await getBrowser(browserName).launch({ headless });
+  const browser = await getBrowser(browserName).launch(getBrowserLaunchOptions({ headless }));
   console.log(`Browser launched successfully`);
   const browserContext = await browser.newContext();
   const page = await browserContext.newPage();
@@ -2507,6 +2531,99 @@ async function runTestInWorkflow(test, page, context, options, _workflowDir, wor
             await page.pause();
             break;
           }
+          case "waitForSelector": {
+            const handle = resolveLocator2(action.target);
+            const timeout = action.timeout ?? 3e4;
+            if (debugMode) {
+              console.log(`  [DEBUG] Waiting for element to be ${action.state}:`, action.target);
+            }
+            const waitForCondition2 = async (checkFn, timeoutMs, errorMessage) => {
+              const start = Date.now();
+              while (Date.now() - start < timeoutMs) {
+                if (await checkFn()) return;
+                await new Promise((r) => setTimeout(r, 100));
+              }
+              throw new Error(errorMessage);
+            };
+            switch (action.state) {
+              case "visible":
+              case "hidden":
+              case "attached":
+              case "detached":
+                await handle.waitFor({ state: action.state, timeout });
+                break;
+              case "enabled":
+                await waitForCondition2(
+                  () => handle.isEnabled(),
+                  timeout,
+                  `Element did not become enabled within ${timeout}ms`
+                );
+                break;
+              case "disabled":
+                await waitForCondition2(
+                  () => handle.isDisabled(),
+                  timeout,
+                  `Element did not become disabled within ${timeout}ms`
+                );
+                break;
+            }
+            break;
+          }
+          case "conditional": {
+            const handle = resolveLocator2(action.condition.target);
+            let conditionMet = false;
+            if (debugMode) {
+              console.log(`  [DEBUG] Checking condition ${action.condition.type}:`, action.condition.target);
+            }
+            try {
+              switch (action.condition.type) {
+                case "exists":
+                  await handle.waitFor({ state: "attached", timeout: 500 });
+                  conditionMet = true;
+                  break;
+                case "notExists":
+                  try {
+                    await handle.waitFor({ state: "detached", timeout: 500 });
+                    conditionMet = true;
+                  } catch {
+                    conditionMet = false;
+                  }
+                  break;
+                case "visible":
+                  conditionMet = await handle.isVisible();
+                  break;
+                case "hidden":
+                  conditionMet = !await handle.isVisible();
+                  break;
+              }
+            } catch {
+              conditionMet = action.condition.type === "notExists";
+            }
+            if (debugMode) {
+              console.log(`  [DEBUG] Condition result: ${conditionMet}`);
+            }
+            const stepsToRun = conditionMet ? action.then : action.else ?? [];
+            for (const nestedAction of stepsToRun) {
+              switch (nestedAction.type) {
+                case "screenshot": {
+                  const filename = nestedAction.name ?? `conditional-step.png`;
+                  const filePath = path__default.default.join(screenshotDir, filename);
+                  await page.screenshot({ path: filePath, fullPage: true });
+                  results.push({ action: nestedAction, status: "passed", screenshotPath: filePath });
+                  break;
+                }
+                case "fail": {
+                  throw new Error(nestedAction.message);
+                }
+                default:
+                  throw new Error(`Nested action type ${nestedAction.type} in conditional not yet supported`);
+              }
+            }
+            break;
+          }
+          case "fail": {
+            throw new Error(action.message);
+          }
           default:
             throw new Error(`Unsupported action type: ${action.type}`);
         }
@@ -2931,7 +3048,7 @@ async function runWorkflow(workflow, workflowFilePath, options = {}) {
   const browserName = options.browser ?? workflow.config?.web?.browser ?? "chromium";
   const headless = options.headed === true ? false : workflow.config?.web?.headless ?? true;
   console.log(`Launching ${browserName}${headless ? " (headless)" : " (visible)"}...`);
-  const browser = await getBrowser2(browserName).launch({ headless });
+  const browser = await getBrowser2(browserName).launch(getBrowserLaunchOptions({ headless }));
   console.log(`Browser launched successfully`);
   const browserContext = await browser.newContext();
   const page = await browserContext.newPage();
@@ -3083,6 +3200,7 @@ exports.generateRandomEmail = generateRandomEmail;
 exports.generateRandomPhone = generateRandomPhone;
 exports.generateRandomPhoto = generateRandomPhoto;
 exports.generateRandomUsername = generateRandomUsername;
+exports.getBrowserLaunchOptions = getBrowserLaunchOptions;
 exports.interpolateVariables = interpolateVariables;
 exports.isPipelineContent = isPipelineContent;
 exports.isPipelineFile = isPipelineFile;
@@ -3104,5 +3222,5 @@ exports.runWorkflowWithContext = runWorkflowWithContext;
 exports.setupAppwriteTracking = setupAppwriteTracking;
 exports.startTrackingServer = startTrackingServer;
 exports.startWebServer = startWebServer;
-//# sourceMappingURL=chunk-PP666GZQ.cjs.map
-//# sourceMappingURL=chunk-PP666GZQ.cjs.map
+//# sourceMappingURL=chunk-GCF2Q77Q.cjs.map
+//# sourceMappingURL=chunk-GCF2Q77Q.cjs.map