playwright-automation-core 1.0.0

package/dist/index.js

@@ -0,0 +1,128 @@
+"use strict";
+/**
+ * Playwright-Core Framework
+ *
+ * A unified automation framework supporting:
+ * - Web automation (Playwright)
+ * - API testing (Playwright Request)
+ * - Mobile automation (WebdriverIO + Appium)
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.camelToKebab = exports.escapeRegex = exports.truncate = exports.formatDuration = exports.formatBytes = exports.loadJson = exports.saveJson = exports.ensureDir = exports.formatTimestamp = exports.generateUUID = exports.generateId = exports.isObject = exports.deepClone = exports.deepMerge = exports.isErrorOfType = exports.isFrameworkError = exports.wrapError = exports.FileOperationError = exports.NetworkError = exports.AssertionError = exports.ContextError = exports.SessionError = exports.ScreenshotError = exports.ConfigurationError = exports.MobileOperationError = exports.ApiValidationError = exports.ApiRequestError = exports.NavigationError = exports.ElementNotInteractableError = exports.ElementNotFoundError = exports.DriverNotInitializedError = exports.DriverInitializationError = exports.FrameworkError = exports.getConfig = exports.ConfigManager = exports.retry = exports.waitFor = exports.sleep = exports.waitUtils = exports.RetryExhaustedError = exports.WaitTimeoutError = exports.WaitUtils = exports.getLogger = exports.Logger = exports.HttpMethod = exports.LogLevel = exports.AutomationEngine = exports.MobilePlatform = exports.BrowserType = exports.Platform = void 0;
+exports.MobileAssertions = exports.AppState = exports.MobileDriver = exports.createRequest = exports.ApiRequestBuilder = exports.ApiAssertions = exports.ApiClient = exports.WebAssertions = exports.WebPage = exports.WebDriver = exports.getHookManager = exports.HookEvent = exports.HookManager = exports.ElementActions = exports.getDriverFactory = exports.DriverFactory = exports.BaseDriver = exports.setNestedValue = exports.getNestedValue = exports.flattenObject = exports.deepEqual = exports.omit = exports.pick = exports.objectToMap = exports.mapToObject = exports.measureTime = exports.throttle = exports.debounce = exports.safeJsonParse = exports.getOSPlatform = exports.isCI = exports.toTitleCase = exports.kebabToCamel = void 0;
+// ============ Types ============
+var types_1 = require("./types");
+// Enums
+Object.defineProperty(exports, "Platform", { enumerable: true, get: function () { return types_1.Platform; } });
+Object.defineProperty(exports, "BrowserType", { enumerable: true, get: function () { return types_1.BrowserType; } });
+Object.defineProperty(exports, "MobilePlatform", { enumerable: true, get: function () { return types_1.MobilePlatform; } });
+Object.defineProperty(exports, "AutomationEngine", { enumerable: true, get: function () { return types_1.AutomationEngine; } });
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return types_1.LogLevel; } });
+Object.defineProperty(exports, "HttpMethod", { enumerable: true, get: function () { return types_1.HttpMethod; } });
+// ============ Utilities ============
+var utils_1 = require("./utils");
+// Logger
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return utils_1.Logger; } });
+Object.defineProperty(exports, "getLogger", { enumerable: true, get: function () { return utils_1.getLogger; } });
+// Wait utilities
+Object.defineProperty(exports, "WaitUtils", { enumerable: true, get: function () { return utils_1.WaitUtils; } });
+Object.defineProperty(exports, "WaitTimeoutError", { enumerable: true, get: function () { return utils_1.WaitTimeoutError; } });
+Object.defineProperty(exports, "RetryExhaustedError", { enumerable: true, get: function () { return utils_1.RetryExhaustedError; } });
+Object.defineProperty(exports, "waitUtils", { enumerable: true, get: function () { return utils_1.waitUtils; } });
+Object.defineProperty(exports, "sleep", { enumerable: true, get: function () { return utils_1.sleep; } });
+Object.defineProperty(exports, "waitFor", { enumerable: true, get: function () { return utils_1.waitFor; } });
+Object.defineProperty(exports, "retry", { enumerable: true, get: function () { return utils_1.retry; } });
+// Config manager
+Object.defineProperty(exports, "ConfigManager", { enumerable: true, get: function () { return utils_1.ConfigManager; } });
+Object.defineProperty(exports, "getConfig", { enumerable: true, get: function () { return utils_1.getConfig; } });
+// Errors
+Object.defineProperty(exports, "FrameworkError", { enumerable: true, get: function () { return utils_1.FrameworkError; } });
+Object.defineProperty(exports, "DriverInitializationError", { enumerable: true, get: function () { return utils_1.DriverInitializationError; } });
+Object.defineProperty(exports, "DriverNotInitializedError", { enumerable: true, get: function () { return utils_1.DriverNotInitializedError; } });
+Object.defineProperty(exports, "ElementNotFoundError", { enumerable: true, get: function () { return utils_1.ElementNotFoundError; } });
+Object.defineProperty(exports, "ElementNotInteractableError", { enumerable: true, get: function () { return utils_1.ElementNotInteractableError; } });
+Object.defineProperty(exports, "NavigationError", { enumerable: true, get: function () { return utils_1.NavigationError; } });
+Object.defineProperty(exports, "ApiRequestError", { enumerable: true, get: function () { return utils_1.ApiRequestError; } });
+Object.defineProperty(exports, "ApiValidationError", { enumerable: true, get: function () { return utils_1.ApiValidationError; } });
+Object.defineProperty(exports, "MobileOperationError", { enumerable: true, get: function () { return utils_1.MobileOperationError; } });
+Object.defineProperty(exports, "ConfigurationError", { enumerable: true, get: function () { return utils_1.ConfigurationError; } });
+Object.defineProperty(exports, "ScreenshotError", { enumerable: true, get: function () { return utils_1.ScreenshotError; } });
+Object.defineProperty(exports, "SessionError", { enumerable: true, get: function () { return utils_1.SessionError; } });
+Object.defineProperty(exports, "ContextError", { enumerable: true, get: function () { return utils_1.ContextError; } });
+Object.defineProperty(exports, "AssertionError", { enumerable: true, get: function () { return utils_1.AssertionError; } });
+Object.defineProperty(exports, "NetworkError", { enumerable: true, get: function () { return utils_1.NetworkError; } });
+Object.defineProperty(exports, "FileOperationError", { enumerable: true, get: function () { return utils_1.FileOperationError; } });
+Object.defineProperty(exports, "wrapError", { enumerable: true, get: function () { return utils_1.wrapError; } });
+Object.defineProperty(exports, "isFrameworkError", { enumerable: true, get: function () { return utils_1.isFrameworkError; } });
+Object.defineProperty(exports, "isErrorOfType", { enumerable: true, get: function () { return utils_1.isErrorOfType; } });
+// Helper utilities
+Object.defineProperty(exports, "deepMerge", { enumerable: true, get: function () { return utils_1.deepMerge; } });
+Object.defineProperty(exports, "deepClone", { enumerable: true, get: function () { return utils_1.deepClone; } });
+Object.defineProperty(exports, "isObject", { enumerable: true, get: function () { return utils_1.isObject; } });
+Object.defineProperty(exports, "generateId", { enumerable: true, get: function () { return utils_1.generateId; } });
+Object.defineProperty(exports, "generateUUID", { enumerable: true, get: function () { return utils_1.generateUUID; } });
+Object.defineProperty(exports, "formatTimestamp", { enumerable: true, get: function () { return utils_1.formatTimestamp; } });
+Object.defineProperty(exports, "ensureDir", { enumerable: true, get: function () { return utils_1.ensureDir; } });
+Object.defineProperty(exports, "saveJson", { enumerable: true, get: function () { return utils_1.saveJson; } });
+Object.defineProperty(exports, "loadJson", { enumerable: true, get: function () { return utils_1.loadJson; } });
+Object.defineProperty(exports, "formatBytes", { enumerable: true, get: function () { return utils_1.formatBytes; } });
+Object.defineProperty(exports, "formatDuration", { enumerable: true, get: function () { return utils_1.formatDuration; } });
+Object.defineProperty(exports, "truncate", { enumerable: true, get: function () { return utils_1.truncate; } });
+Object.defineProperty(exports, "escapeRegex", { enumerable: true, get: function () { return utils_1.escapeRegex; } });
+Object.defineProperty(exports, "camelToKebab", { enumerable: true, get: function () { return utils_1.camelToKebab; } });
+Object.defineProperty(exports, "kebabToCamel", { enumerable: true, get: function () { return utils_1.kebabToCamel; } });
+Object.defineProperty(exports, "toTitleCase", { enumerable: true, get: function () { return utils_1.toTitleCase; } });
+Object.defineProperty(exports, "isCI", { enumerable: true, get: function () { return utils_1.isCI; } });
+Object.defineProperty(exports, "getOSPlatform", { enumerable: true, get: function () { return utils_1.getOSPlatform; } });
+Object.defineProperty(exports, "safeJsonParse", { enumerable: true, get: function () { return utils_1.safeJsonParse; } });
+Object.defineProperty(exports, "debounce", { enumerable: true, get: function () { return utils_1.debounce; } });
+Object.defineProperty(exports, "throttle", { enumerable: true, get: function () { return utils_1.throttle; } });
+Object.defineProperty(exports, "measureTime", { enumerable: true, get: function () { return utils_1.measureTime; } });
+Object.defineProperty(exports, "mapToObject", { enumerable: true, get: function () { return utils_1.mapToObject; } });
+Object.defineProperty(exports, "objectToMap", { enumerable: true, get: function () { return utils_1.objectToMap; } });
+Object.defineProperty(exports, "pick", { enumerable: true, get: function () { return utils_1.pick; } });
+Object.defineProperty(exports, "omit", { enumerable: true, get: function () { return utils_1.omit; } });
+Object.defineProperty(exports, "deepEqual", { enumerable: true, get: function () { return utils_1.deepEqual; } });
+Object.defineProperty(exports, "flattenObject", { enumerable: true, get: function () { return utils_1.flattenObject; } });
+Object.defineProperty(exports, "getNestedValue", { enumerable: true, get: function () { return utils_1.getNestedValue; } });
+Object.defineProperty(exports, "setNestedValue", { enumerable: true, get: function () { return utils_1.setNestedValue; } });
+// ============ Core ============
+var core_1 = require("./core");
+// Base driver
+Object.defineProperty(exports, "BaseDriver", { enumerable: true, get: function () { return core_1.BaseDriver; } });
+// Driver factory
+Object.defineProperty(exports, "DriverFactory", { enumerable: true, get: function () { return core_1.DriverFactory; } });
+Object.defineProperty(exports, "getDriverFactory", { enumerable: true, get: function () { return core_1.getDriverFactory; } });
+// Element actions
+Object.defineProperty(exports, "ElementActions", { enumerable: true, get: function () { return core_1.ElementActions; } });
+// Hook manager
+Object.defineProperty(exports, "HookManager", { enumerable: true, get: function () { return core_1.HookManager; } });
+Object.defineProperty(exports, "HookEvent", { enumerable: true, get: function () { return core_1.HookEvent; } });
+Object.defineProperty(exports, "getHookManager", { enumerable: true, get: function () { return core_1.getHookManager; } });
+// ============ Web Module ============
+var web_1 = require("./web");
+// Web driver
+Object.defineProperty(exports, "WebDriver", { enumerable: true, get: function () { return web_1.WebDriver; } });
+// Web page interactions
+Object.defineProperty(exports, "WebPage", { enumerable: true, get: function () { return web_1.WebPage; } });
+// Web assertions
+Object.defineProperty(exports, "WebAssertions", { enumerable: true, get: function () { return web_1.WebAssertions; } });
+// ============ API Module ============
+var api_1 = require("./api");
+// API client
+Object.defineProperty(exports, "ApiClient", { enumerable: true, get: function () { return api_1.ApiClient; } });
+// API assertions
+Object.defineProperty(exports, "ApiAssertions", { enumerable: true, get: function () { return api_1.ApiAssertions; } });
+// API request builder
+Object.defineProperty(exports, "ApiRequestBuilder", { enumerable: true, get: function () { return api_1.ApiRequestBuilder; } });
+Object.defineProperty(exports, "createRequest", { enumerable: true, get: function () { return api_1.createRequest; } });
+// ============ Mobile Module ============
+var mobile_1 = require("./mobile");
+// Mobile driver
+Object.defineProperty(exports, "MobileDriver", { enumerable: true, get: function () { return mobile_1.MobileDriver; } });
+Object.defineProperty(exports, "AppState", { enumerable: true, get: function () { return mobile_1.AppState; } });
+// Mobile assertions
+Object.defineProperty(exports, "MobileAssertions", { enumerable: true, get: function () { return mobile_1.MobileAssertions; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/mobile/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Mobile Module - WebdriverIO + Appium-based mobile automation
+ */
+export { MobileDriver, TouchPoint, GestureOptions, AppState, } from "./mobile.driver";
+export { MobileAssertions, MobileSoftAssertionResult, } from "./mobile.assertions";
+export type { Browser as WebdriverBrowser, Element as WebdriverElement, } from "webdriverio";
+//# sourceMappingURL=index.d.ts.map

package/dist/mobile/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mobile/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EACL,YAAY,EACZ,UAAU,EACV,cAAc,EACd,QAAQ,GACT,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EACL,gBAAgB,EAChB,yBAAyB,GAC1B,MAAM,qBAAqB,CAAC;AAG7B,YAAY,EACV,OAAO,IAAI,gBAAgB,EAC3B,OAAO,IAAI,gBAAgB,GAC5B,MAAM,aAAa,CAAC"}

package/dist/mobile/index.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * Mobile Module - WebdriverIO + Appium-based mobile automation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MobileAssertions = exports.AppState = exports.MobileDriver = void 0;
+// Mobile Driver
+var mobile_driver_1 = require("./mobile.driver");
+Object.defineProperty(exports, "MobileDriver", { enumerable: true, get: function () { return mobile_driver_1.MobileDriver; } });
+Object.defineProperty(exports, "AppState", { enumerable: true, get: function () { return mobile_driver_1.AppState; } });
+// Mobile Assertions
+var mobile_assertions_1 = require("./mobile.assertions");
+Object.defineProperty(exports, "MobileAssertions", { enumerable: true, get: function () { return mobile_assertions_1.MobileAssertions; } });
+//# sourceMappingURL=index.js.map

package/dist/mobile/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/mobile/index.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEH,gBAAgB;AAChB,iDAKyB;AAJvB,6GAAA,YAAY,OAAA;AAGZ,yGAAA,QAAQ,OAAA;AAGV,oBAAoB;AACpB,yDAG6B;AAF3B,qHAAA,gBAAgB,OAAA"}

package/dist/mobile/mobile.assertions.d.ts

@@ -0,0 +1,146 @@
+import { AssertionOptions, Locator } from "../types";
+import { Logger } from "../utils";
+import { MobileDriver, AppState } from "./mobile.driver";
+/**
+ * Soft assertion result
+ */
+export interface MobileSoftAssertionResult {
+    passed: boolean;
+    message: string;
+    expected?: unknown;
+    actual?: unknown;
+}
+/**
+ * Mobile Assertions class providing assertion methods for mobile testing.
+ */
+export declare class MobileAssertions {
+    private driver;
+    private logger;
+    private softErrors;
+    constructor(driver: MobileDriver, logger?: Logger);
+    /**
+     * Get soft assertion errors
+     */
+    getSoftErrors(): MobileSoftAssertionResult[];
+    /**
+     * Clear soft assertion errors
+     */
+    clearSoftErrors(): void;
+    /**
+     * Check if all soft assertions passed
+     */
+    allSoftAssertionsPassed(): boolean;
+    /**
+     * Assert all soft assertions and throw if any failed
+     */
+    assertAllSoftAssertions(): void;
+    /**
+     * Handle assertion result
+     */
+    private handleAssertion;
+    /**
+     * Assert element is displayed
+     */
+    assertDisplayed(locator: Locator | string, options?: AssertionOptions): Promise<void>;
+    /**
+     * Assert element is not displayed
+     */
+    assertNotDisplayed(locator: Locator | string, options?: AssertionOptions): Promise<void>;
+    /**
+     * Assert element exists
+     */
+    assertExists(locator: Locator | string, options?: AssertionOptions): Promise<void>;
+    /**
+     * Assert element is enabled
+     */
+    assertEnabled(locator: Locator | string, options?: AssertionOptions): Promise<void>;
+    /**
+     * Assert element is disabled
+     */
+    assertDisabled(locator: Locator | string, options?: AssertionOptions): Promise<void>;
+    /**
+     * Assert element has exact text
+     */
+    assertText(locator: Locator | string, expectedText: string, options?: AssertionOptions): Promise<void>;
+    /**
+     * Assert element contains text
+     */
+    assertTextContains(locator: Locator | string, expectedText: string, options?: AssertionOptions): Promise<void>;
+    /**
+     * Assert element text matches pattern
+     */
+    assertTextMatches(locator: Locator | string, pattern: RegExp, options?: AssertionOptions): Promise<void>;
+    /**
+     * Assert element has attribute with value
+     */
+    assertAttribute(locator: Locator | string, attribute: string, expectedValue: string, options?: AssertionOptions): Promise<void>;
+    /**
+     * Assert element attribute contains value
+     */
+    assertAttributeContains(locator: Locator | string, attribute: string, expectedValue: string, options?: AssertionOptions): Promise<void>;
+    /**
+     * Assert current context
+     */
+    assertContext(expectedContext: string, options?: AssertionOptions): Promise<void>;
+    /**
+     * Assert in native context
+     */
+    assertNativeContext(options?: AssertionOptions): Promise<void>;
+    /**
+     * Assert in webview context
+     */
+    assertWebviewContext(options?: AssertionOptions): Promise<void>;
+    /**
+     * Assert app is installed
+     */
+    assertAppInstalled(appId: string, options?: AssertionOptions): Promise<void>;
+    /**
+     * Assert app is not installed
+     */
+    assertAppNotInstalled(appId: string, options?: AssertionOptions): Promise<void>;
+    /**
+     * Assert app state
+     */
+    assertAppState(expectedState: AppState, appId?: string, options?: AssertionOptions): Promise<void>;
+    /**
+     * Assert app is running in foreground
+     */
+    assertAppRunning(appId?: string, options?: AssertionOptions): Promise<void>;
+    /**
+     * Assert device orientation
+     */
+    assertOrientation(expectedOrientation: "PORTRAIT" | "LANDSCAPE", options?: AssertionOptions): Promise<void>;
+    /**
+     * Assert device is locked
+     */
+    assertLocked(options?: AssertionOptions): Promise<void>;
+    /**
+     * Assert device is unlocked
+     */
+    assertUnlocked(options?: AssertionOptions): Promise<void>;
+    /**
+     * Assert keyboard is shown
+     */
+    assertKeyboardShown(options?: AssertionOptions): Promise<void>;
+    /**
+     * Assert keyboard is hidden
+     */
+    assertKeyboardHidden(options?: AssertionOptions): Promise<void>;
+    /**
+     * Assert condition is true
+     */
+    assertTrue(condition: boolean, message: string, options?: AssertionOptions): void;
+    /**
+     * Assert condition is false
+     */
+    assertFalse(condition: boolean, message: string, options?: AssertionOptions): void;
+    /**
+     * Assert values are equal
+     */
+    assertEqual<T>(actual: T, expected: T, message?: string, options?: AssertionOptions): void;
+    /**
+     * Always fail with message
+     */
+    fail(message: string, options?: AssertionOptions): void;
+}
+//# sourceMappingURL=mobile.assertions.d.ts.map

package/dist/mobile/mobile.assertions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mobile.assertions.d.ts","sourceRoot":"","sources":["../../src/mobile/mobile.assertions.ts"],"names":[],"mappings":"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"}

package/dist/mobile/mobile.assertions.js

@@ -0,0 +1,333 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MobileAssertions = void 0;
+const utils_1 = require("../utils");
+const mobile_driver_1 = require("./mobile.driver");
+/**
+ * Default assertion options
+ */
+const DEFAULT_ASSERTION_OPTIONS = {
+    timeout: 10000,
+    message: "",
+    soft: false,
+};
+/**
+ * Mobile Assertions class providing assertion methods for mobile testing.
+ */
+class MobileAssertions {
+    driver;
+    logger;
+    softErrors = [];
+    constructor(driver, logger) {
+        this.driver = driver;
+        this.logger = logger || utils_1.Logger.getInstance();
+    }
+    /**
+     * Get soft assertion errors
+     */
+    getSoftErrors() {
+        return [...this.softErrors];
+    }
+    /**
+     * Clear soft assertion errors
+     */
+    clearSoftErrors() {
+        this.softErrors = [];
+    }
+    /**
+     * Check if all soft assertions passed
+     */
+    allSoftAssertionsPassed() {
+        return this.softErrors.length === 0;
+    }
+    /**
+     * Assert all soft assertions and throw if any failed
+     */
+    assertAllSoftAssertions() {
+        if (this.softErrors.length > 0) {
+            const messages = this.softErrors
+                .map((e, i) => `${i + 1}. ${e.message}`)
+                .join("\n");
+            const errorCount = this.softErrors.length;
+            this.softErrors = [];
+            throw new utils_1.AssertionError(`${errorCount} soft assertion(s) failed:\n${messages}`, "all passed", "some failed");
+        }
+    }
+    /**
+     * Handle assertion result
+     */
+    handleAssertion(passed, message, expected, actual, options) {
+        if (passed) {
+            this.logger.debug(`✓ Mobile Assertion passed: ${message}`);
+            return;
+        }
+        const errorMessage = options.message || message;
+        const result = {
+            passed: false,
+            message: errorMessage,
+            expected,
+            actual,
+        };
+        if (options.soft) {
+            this.logger.warn(`✗ Soft mobile assertion failed: ${errorMessage}`);
+            this.softErrors.push(result);
+        }
+        else {
+            this.logger.error(`✗ Mobile Assertion failed: ${errorMessage}`);
+            throw new utils_1.AssertionError(errorMessage, expected, actual);
+        }
+    }
+    // ============ Element Visibility Assertions ============
+    /**
+     * Assert element is displayed
+     */
+    async assertDisplayed(locator, options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        const description = typeof locator === "string" ? locator : locator.value;
+        try {
+            await this.driver.waitForDisplayed(locator, opts.timeout);
+            this.handleAssertion(true, `Element is displayed: ${description}`, "displayed", "displayed", opts);
+        }
+        catch {
+            this.handleAssertion(false, `Element should be displayed: ${description}`, "displayed", "not displayed", opts);
+        }
+    }
+    /**
+     * Assert element is not displayed
+     */
+    async assertNotDisplayed(locator, options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        const description = typeof locator === "string" ? locator : locator.value;
+        try {
+            await this.driver.waitForNotDisplayed(locator, opts.timeout);
+            this.handleAssertion(true, `Element is not displayed: ${description}`, "not displayed", "not displayed", opts);
+        }
+        catch {
+            this.handleAssertion(false, `Element should not be displayed: ${description}`, "not displayed", "displayed", opts);
+        }
+    }
+    /**
+     * Assert element exists
+     */
+    async assertExists(locator, options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        const description = typeof locator === "string" ? locator : locator.value;
+        try {
+            await this.driver.findElement(locator);
+            this.handleAssertion(true, `Element exists: ${description}`, "exists", "exists", opts);
+        }
+        catch {
+            this.handleAssertion(false, `Element should exist: ${description}`, "exists", "not found", opts);
+        }
+    }
+    /**
+     * Assert element is enabled
+     */
+    async assertEnabled(locator, options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        const description = typeof locator === "string" ? locator : locator.value;
+        const isEnabled = await this.driver.isEnabled(locator);
+        this.handleAssertion(isEnabled, `Element should be enabled: ${description}`, "enabled", "disabled", opts);
+    }
+    /**
+     * Assert element is disabled
+     */
+    async assertDisabled(locator, options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        const description = typeof locator === "string" ? locator : locator.value;
+        const isEnabled = await this.driver.isEnabled(locator);
+        this.handleAssertion(!isEnabled, `Element should be disabled: ${description}`, "disabled", "enabled", opts);
+    }
+    // ============ Text Assertions ============
+    /**
+     * Assert element has exact text
+     */
+    async assertText(locator, expectedText, options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        const description = typeof locator === "string" ? locator : locator.value;
+        const actualText = await this.driver.getText(locator);
+        const passed = actualText === expectedText;
+        this.handleAssertion(passed, `Element text should be "${expectedText}", got "${actualText}": ${description}`, expectedText, actualText, opts);
+    }
+    /**
+     * Assert element contains text
+     */
+    async assertTextContains(locator, expectedText, options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        const description = typeof locator === "string" ? locator : locator.value;
+        const actualText = await this.driver.getText(locator);
+        const passed = actualText.includes(expectedText);
+        this.handleAssertion(passed, `Element text should contain "${expectedText}", got "${actualText}": ${description}`, `contains "${expectedText}"`, actualText, opts);
+    }
+    /**
+     * Assert element text matches pattern
+     */
+    async assertTextMatches(locator, pattern, options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        const description = typeof locator === "string" ? locator : locator.value;
+        const actualText = await this.driver.getText(locator);
+        const passed = pattern.test(actualText);
+        this.handleAssertion(passed, `Element text should match ${pattern}, got "${actualText}": ${description}`, pattern.toString(), actualText, opts);
+    }
+    // ============ Attribute Assertions ============
+    /**
+     * Assert element has attribute with value
+     */
+    async assertAttribute(locator, attribute, expectedValue, options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        const description = typeof locator === "string" ? locator : locator.value;
+        const actualValue = await this.driver.getAttribute(locator, attribute);
+        const passed = actualValue === expectedValue;
+        this.handleAssertion(passed, `Attribute ${attribute} should be "${expectedValue}", got "${actualValue}": ${description}`, expectedValue, actualValue, opts);
+    }
+    /**
+     * Assert element attribute contains value
+     */
+    async assertAttributeContains(locator, attribute, expectedValue, options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        const description = typeof locator === "string" ? locator : locator.value;
+        const actualValue = await this.driver.getAttribute(locator, attribute);
+        const passed = actualValue?.includes(expectedValue) ?? false;
+        this.handleAssertion(passed, `Attribute ${attribute} should contain "${expectedValue}", got "${actualValue}": ${description}`, `contains "${expectedValue}"`, actualValue, opts);
+    }
+    // ============ Context Assertions ============
+    /**
+     * Assert current context
+     */
+    async assertContext(expectedContext, options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        const actualContext = await this.driver.getContext();
+        const passed = actualContext === expectedContext;
+        this.handleAssertion(passed, `Context should be "${expectedContext}", got "${actualContext}"`, expectedContext, actualContext, opts);
+    }
+    /**
+     * Assert in native context
+     */
+    async assertNativeContext(options = {}) {
+        await this.assertContext("NATIVE_APP", options);
+    }
+    /**
+     * Assert in webview context
+     */
+    async assertWebviewContext(options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        const actualContext = await this.driver.getContext();
+        const passed = actualContext.includes("WEBVIEW");
+        this.handleAssertion(passed, `Should be in webview context, got "${actualContext}"`, "WEBVIEW_*", actualContext, opts);
+    }
+    // ============ App State Assertions ============
+    /**
+     * Assert app is installed
+     */
+    async assertAppInstalled(appId, options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        const isInstalled = await this.driver.isAppInstalled(appId);
+        this.handleAssertion(isInstalled, `App should be installed: ${appId}`, "installed", "not installed", opts);
+    }
+    /**
+     * Assert app is not installed
+     */
+    async assertAppNotInstalled(appId, options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        const isInstalled = await this.driver.isAppInstalled(appId);
+        this.handleAssertion(!isInstalled, `App should not be installed: ${appId}`, "not installed", "installed", opts);
+    }
+    /**
+     * Assert app state
+     */
+    async assertAppState(expectedState, appId, options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        const actualState = await this.driver.getAppState(appId);
+        const passed = actualState === expectedState;
+        const stateNames = {
+            [mobile_driver_1.AppState.NOT_INSTALLED]: "NOT_INSTALLED",
+            [mobile_driver_1.AppState.NOT_RUNNING]: "NOT_RUNNING",
+            [mobile_driver_1.AppState.RUNNING_BACKGROUND_SUSPENDED]: "RUNNING_BACKGROUND_SUSPENDED",
+            [mobile_driver_1.AppState.RUNNING_BACKGROUND]: "RUNNING_BACKGROUND",
+            [mobile_driver_1.AppState.RUNNING_FOREGROUND]: "RUNNING_FOREGROUND",
+        };
+        this.handleAssertion(passed, `App state should be ${stateNames[expectedState]}, got ${stateNames[actualState]}`, stateNames[expectedState], stateNames[actualState], opts);
+    }
+    /**
+     * Assert app is running in foreground
+     */
+    async assertAppRunning(appId, options = {}) {
+        await this.assertAppState(mobile_driver_1.AppState.RUNNING_FOREGROUND, appId, options);
+    }
+    // ============ Device State Assertions ============
+    /**
+     * Assert device orientation
+     */
+    async assertOrientation(expectedOrientation, options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        const actualOrientation = await this.driver.getOrientation();
+        const passed = actualOrientation.toUpperCase() === expectedOrientation;
+        this.handleAssertion(passed, `Orientation should be ${expectedOrientation}, got ${actualOrientation}`, expectedOrientation, actualOrientation, opts);
+    }
+    /**
+     * Assert device is locked
+     */
+    async assertLocked(options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        const isLocked = await this.driver.isLocked();
+        this.handleAssertion(isLocked, "Device should be locked", "locked", "unlocked", opts);
+    }
+    /**
+     * Assert device is unlocked
+     */
+    async assertUnlocked(options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        const isLocked = await this.driver.isLocked();
+        this.handleAssertion(!isLocked, "Device should be unlocked", "unlocked", "locked", opts);
+    }
+    /**
+     * Assert keyboard is shown
+     */
+    async assertKeyboardShown(options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        const isShown = await this.driver.isKeyboardShown();
+        this.handleAssertion(isShown, "Keyboard should be shown", "shown", "hidden", opts);
+    }
+    /**
+     * Assert keyboard is hidden
+     */
+    async assertKeyboardHidden(options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        const isShown = await this.driver.isKeyboardShown();
+        this.handleAssertion(!isShown, "Keyboard should be hidden", "hidden", "shown", opts);
+    }
+    // ============ Generic Assertions ============
+    /**
+     * Assert condition is true
+     */
+    assertTrue(condition, message, options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        this.handleAssertion(condition, message, true, condition, opts);
+    }
+    /**
+     * Assert condition is false
+     */
+    assertFalse(condition, message, options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        this.handleAssertion(!condition, message, false, condition, opts);
+    }
+    /**
+     * Assert values are equal
+     */
+    assertEqual(actual, expected, message, options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        const passed = JSON.stringify(actual) === JSON.stringify(expected);
+        const msg = message ||
+            `Expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`;
+        this.handleAssertion(passed, msg, expected, actual, opts);
+    }
+    /**
+     * Always fail with message
+     */
+    fail(message, options = {}) {
+        const opts = { ...DEFAULT_ASSERTION_OPTIONS, ...options };
+        this.handleAssertion(false, message, "pass", "fail", opts);
+    }
+}
+exports.MobileAssertions = MobileAssertions;
+//# sourceMappingURL=mobile.assertions.js.map