intellitester 0.2.20 → 0.2.21

package/dist/{chunk-ICJK4WBA.js → chunk-CKUSY4ZM.js}

@@ -129,7 +129,17 @@ var appwriteVerifyEmailActionSchema = z.object({
 var debugActionSchema = z.object({
   type: z.literal("debug")
 }).describe("Pause execution and open Playwright Inspector for debugging");
-var ActionSchema = z.discriminatedUnion("type", [
+var waitForSelectorActionSchema = z.object({
+  type: z.literal("waitForSelector"),
+  target: LocatorSchema,
+  state: z.enum(["enabled", "disabled", "visible", "hidden", "attached", "detached"]).describe("Element state to wait for"),
+  timeout: z.number().int().positive().optional().describe("Time to wait in milliseconds")
+}).describe("Wait for an element to reach a specific state");
+var failActionSchema = z.object({
+  type: z.literal("fail"),
+  message: nonEmptyString.describe("Error message to display when test fails")
+}).describe("Explicitly fail the test with a custom message");
+var BaseActionSchema = z.discriminatedUnion("type", [
   navigateActionSchema,
   tapActionSchema,
   inputActionSchema,
@@ -150,8 +160,20 @@ var ActionSchema = z.discriminatedUnion("type", [
   emailExtractLinkActionSchema,
   emailClearActionSchema,
   appwriteVerifyEmailActionSchema,
-  debugActionSchema
+  debugActionSchema,
+  waitForSelectorActionSchema,
+  failActionSchema
 ]);
+var conditionalActionSchema = z.object({
+  type: z.literal("conditional"),
+  condition: z.object({
+    type: z.enum(["exists", "notExists", "visible", "hidden"]),
+    target: LocatorSchema
+  }).describe("Condition to check"),
+  then: z.array(BaseActionSchema).describe("Steps to execute if condition is true"),
+  else: z.array(BaseActionSchema).optional().describe("Steps to execute if condition is false")
+}).describe("Execute steps conditionally based on element state");
+var ActionSchema = z.union([BaseActionSchema, conditionalActionSchema]);
 var defaultsSchema = z.object({
   timeout: z.number().int().positive().optional().describe("Default timeout in milliseconds for all actions"),
   screenshots: z.enum(["on-failure", "always", "never"]).optional().describe("When to capture screenshots during test execution")
@@ -1352,6 +1374,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);
@@ -1787,6 +1817,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}`);
       }
@@ -2945,5 +3060,5 @@ Collected ${serverResources.length} server-tracked resources`);
 }
 
 export { ActionSchema, IntellitesterConfigSchema, LocatorSchema, TestConfigSchema, TestDefinitionSchema, cleanupConfigSchema, cleanupDiscoverSchema, collectMissingEnvVars, createAIProvider, createTestContext, generateFillerText, generateRandomEmail, generateRandomPhone, generateRandomPhoto, generateRandomUsername, interpolateVariables, isPipelineContent, isPipelineFile, isWorkflowContent, isWorkflowFile, killServer, loadIntellitesterConfig, loadPipelineDefinition, loadTestDefinition, loadWorkflowDefinition, parseIntellitesterConfig, parsePipelineDefinition, parseTestDefinition, parseWorkflowDefinition, previewConfigSchema, runWebTest, runWorkflow, runWorkflowWithContext, setupAppwriteTracking, startTrackingServer, startWebServer };
-//# sourceMappingURL=chunk-ICJK4WBA.js.map
-//# sourceMappingURL=chunk-ICJK4WBA.js.map
+//# sourceMappingURL=chunk-CKUSY4ZM.js.map
+//# sourceMappingURL=chunk-CKUSY4ZM.js.map