intellitester 0.2.20 → 0.2.21

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

@@ -138,7 +138,17 @@ var appwriteVerifyEmailActionSchema = zod.z.object({
 var debugActionSchema = zod.z.object({
   type: zod.z.literal("debug")
 }).describe("Pause execution and open Playwright Inspector for debugging");
-var ActionSchema = zod.z.discriminatedUnion("type", [
+var waitForSelectorActionSchema = zod.z.object({
+  type: zod.z.literal("waitForSelector"),
+  target: LocatorSchema,
+  state: zod.z.enum(["enabled", "disabled", "visible", "hidden", "attached", "detached"]).describe("Element state to wait for"),
+  timeout: zod.z.number().int().positive().optional().describe("Time to wait in milliseconds")
+}).describe("Wait for an element to reach a specific state");
+var failActionSchema = zod.z.object({
+  type: zod.z.literal("fail"),
+  message: nonEmptyString.describe("Error message to display when test fails")
+}).describe("Explicitly fail the test with a custom message");
+var BaseActionSchema = zod.z.discriminatedUnion("type", [
   navigateActionSchema,
   tapActionSchema,
   inputActionSchema,
@@ -159,8 +169,20 @@ var ActionSchema = zod.z.discriminatedUnion("type", [
   emailExtractLinkActionSchema,
   emailClearActionSchema,
   appwriteVerifyEmailActionSchema,
-  debugActionSchema
+  debugActionSchema,
+  waitForSelectorActionSchema,
+  failActionSchema
 ]);
+var conditionalActionSchema = zod.z.object({
+  type: zod.z.literal("conditional"),
+  condition: zod.z.object({
+    type: zod.z.enum(["exists", "notExists", "visible", "hidden"]),
+    target: LocatorSchema
+  }).describe("Condition to check"),
+  then: zod.z.array(BaseActionSchema).describe("Steps to execute if condition is true"),
+  else: zod.z.array(BaseActionSchema).optional().describe("Steps to execute if condition is false")
+}).describe("Execute steps conditionally based on element state");
+var ActionSchema = zod.z.union([BaseActionSchema, conditionalActionSchema]);
 var defaultsSchema = zod.z.object({
   timeout: zod.z.number().int().positive().optional().describe("Default timeout in milliseconds for all actions"),
   screenshots: zod.z.enum(["on-failure", "always", "never"]).optional().describe("When to capture screenshots during test execution")
@@ -1361,6 +1383,14 @@ var runWait = async (page, action) => {
   }
   await page.waitForTimeout(action.timeout ?? 1e3);
 };
+var waitForCondition = async (checkFn, timeout, errorMessage) => {
+  const start = Date.now();
+  while (Date.now() - start < timeout) {
+    if (await checkFn()) return;
+    await new Promise((r) => setTimeout(r, 100));
+  }
+  throw new Error(errorMessage);
+};
 var runScroll = async (page, action) => {
   if (action.target) {
     const handle = resolveLocator(page, action.target);
@@ -1796,6 +1826,91 @@ async function executeActionWithRetry(page, action, index, options) {
           await page.pause();
           break;
         }
+        case "waitForSelector": {
+          const wsAction = action;
+          const handle = resolveLocator(page, wsAction.target);
+          const timeout = wsAction.timeout ?? 3e4;
+          if (debugMode) {
+            console.log(`[DEBUG] Waiting for element to be ${wsAction.state}:`, wsAction.target);
+          }
+          switch (wsAction.state) {
+            case "visible":
+            case "hidden":
+            case "attached":
+            case "detached":
+              await handle.waitFor({ state: wsAction.state, timeout });
+              break;
+            case "enabled":
+              await waitForCondition(
+                () => handle.isEnabled(),
+                timeout,
+                `Element did not become enabled within ${timeout}ms`
+              );
+              break;
+            case "disabled":
+              await waitForCondition(
+                () => handle.isDisabled(),
+                timeout,
+                `Element did not become disabled within ${timeout}ms`
+              );
+              break;
+          }
+          break;
+        }
+        case "conditional": {
+          const condAction = action;
+          const handle = resolveLocator(page, condAction.condition.target);
+          let conditionMet = false;
+          if (debugMode) {
+            console.log(`[DEBUG] Checking condition ${condAction.condition.type}:`, condAction.condition.target);
+          }
+          try {
+            switch (condAction.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 = condAction.condition.type === "notExists";
+          }
+          if (debugMode) {
+            console.log(`[DEBUG] Condition result: ${conditionMet}`);
+          }
+          const stepsToRun = conditionMet ? condAction.then : condAction.else ?? [];
+          for (const [nestedIdx, nestedAction] of stepsToRun.entries()) {
+            if (debugMode) {
+              console.log(`[DEBUG] Executing nested step ${nestedIdx + 1}: ${nestedAction.type}`);
+            }
+            await executeActionWithRetry(page, nestedAction, index, {
+              baseUrl,
+              context,
+              screenshotDir,
+              debugMode,
+              interactive,
+              aiConfig
+            });
+          }
+          break;
+        }
+        case "fail": {
+          const failAction = action;
+          throw new Error(failAction.message);
+        }
         default:
           throw new Error(`Unsupported action type: ${action.type}`);
       }
@@ -2989,5 +3104,5 @@ exports.runWorkflowWithContext = runWorkflowWithContext;
 exports.setupAppwriteTracking = setupAppwriteTracking;
 exports.startTrackingServer = startTrackingServer;
 exports.startWebServer = startWebServer;
-//# sourceMappingURL=chunk-JIVORCLQ.cjs.map
-//# sourceMappingURL=chunk-JIVORCLQ.cjs.map
+//# sourceMappingURL=chunk-PP666GZQ.cjs.map
+//# sourceMappingURL=chunk-PP666GZQ.cjs.map