@appium/fake-driver 4.2.2 → 5.1.0

package/build/lib/commands/alert.d.ts

@@ -1,14 +1,331 @@
-export default extensions;
-export namespace commands {
-    export function getAlertText(): Promise<any>;
-    export function setAlertText(text: any): Promise<void>;
-    export function postAcceptAlert(): Promise<void>;
-    import postDismissAlert = postAcceptAlert;
-    export { postDismissAlert };
-}
-export namespace helpers {
-    function assertNoAlert(): void;
-    function assertAlert(): void;
-}
-declare let extensions: {};
+/// <reference types="node" />
+/**
+ * @template {Class<import('../types').IContextsCommands & import('@appium/types').IFindCommands>} T
+ * @param {T} Base
+ * @returns {Class<AlertCommands>}
+ */
+export function AlertMixin<T extends Class<import("../types").IContextsCommands & import("@appium/types").IFindCommands<any>, {}, any[]>>(Base: T): Class<{
+    assertNoAlert(): void;
+    assertAlert(): void;
+    /**
+     * Get the text of an alert
+     *
+     * @returns {Promise<string>}
+     */
+    getAlertText(): Promise<string>;
+    /**
+     * Set the text of an alert
+     *
+     * @param {string} text
+     * @returns {Promise<void>}
+     */
+    setAlertText(text: string): Promise<void>;
+    /**
+     * Accept an alert
+     *
+     * @returns {Promise<void>}
+     */
+    postAcceptAlert(): Promise<void>;
+    /**
+     * Dismiss an alert
+     *
+     * @returns {Promise<null>}
+     */
+    postDismissAlert: () => Promise<void>;
+    assertWebviewContext(): void;
+    elMap: Record<string, import("../fake-element").FakeElement>;
+    maxElId: number;
+    appModel: import("../fake-app").FakeApp;
+    focusedElId: string;
+    curContext: string;
+    server?: import("@appium/types").AppiumServer | undefined;
+    serverHost?: string | undefined;
+    serverPort?: number | undefined;
+    serverPath?: string | undefined;
+    setUrl?(url: string): Promise<void>;
+    getUrl?(): Promise<string>;
+    back?(): Promise<void>;
+    forward?(): Promise<void>;
+    refresh?(): Promise<void>;
+    title?(): Promise<string>;
+    getWindowHandle?(): Promise<string>;
+    closeWindow?(): Promise<string[]>;
+    setWindow?(handle: string): Promise<void>;
+    getWindowHandles?(): Promise<string[]>;
+    createNewWindow?(type?: import("@appium/types").NewWindowType | undefined): Promise<import("@appium/types").NewWindow>;
+    setFrame?(id: string | number | null): Promise<void>;
+    switchToParentFrame?(): Promise<void>;
+    getWindowRect?(): Promise<import("@appium/types").Rect>;
+    setWindowRect?(x: number, y: number, width: number, height: number): Promise<import("@appium/types").Rect>;
+    maximizeWindow?(): Promise<import("@appium/types").Rect>;
+    minimizeWindow?(): Promise<import("@appium/types").Rect>;
+    fullScreenWindow?(): Promise<import("@appium/types").Rect>;
+    active?(): Promise<import("@appium/types").Element>;
+    elementShadowRoot?(elementId: string): Promise<import("@appium/types").Element>;
+    elementSelected?(elementId: string): Promise<boolean>;
+    getAttribute?(name: string, elementId: string): Promise<string | null>;
+    getProperty?(name: string, elementId: string): Promise<string | null>;
+    getCssProperty?(name: string, elementId: string): Promise<string>;
+    getText?(elementId: string): Promise<string>;
+    getName?(elementId: string): Promise<string>;
+    getElementRect?(elementId: string): Promise<import("@appium/types").Rect>;
+    elementEnabled?(elementId: string): Promise<boolean>;
+    getComputedRole?(elementId: string): Promise<string | null>;
+    getComputedLabel?(elementId: string): Promise<string | null>;
+    elementDisplayed?(elementId: string): Promise<boolean>;
+    click?(elementId: string): Promise<void>;
+    clear?(elementId: string): Promise<void>;
+    setValue?(text: string, elementId: string): Promise<void>;
+    execute?(script: string, args: unknown[]): Promise<unknown>;
+    executeAsync?(script: string, args: unknown[]): Promise<unknown>;
+    getCookies?(): Promise<import("@appium/types").Cookie[]>;
+    getCookie?(name: string): Promise<import("@appium/types").Cookie>;
+    setCookie?(cookie: import("@appium/types").Cookie): Promise<void>;
+    deleteCookie?(name: string): Promise<void>;
+    deleteCookies?(): Promise<void>;
+    performActions?(actions: import("@appium/types").ActionSequence[]): Promise<void>;
+    releaseActions?(): Promise<void>;
+    getScreenshot?(): Promise<string>;
+    getElementScreenshot?(elementId: string): Promise<string>;
+    mobileShake?(): Promise<void>;
+    getDeviceTime?(format?: string | undefined): Promise<string>;
+    lock?(seconds?: number | undefined): Promise<void>;
+    unlock?(): Promise<void>;
+    isLocked?(): Promise<boolean>;
+    startRecordingScreen?(options?: import("@appium/types").StartScreenRecordOptions | undefined): Promise<void>;
+    stopRecordingScreen?(options?: import("@appium/types").StopScreenRecordOptions | undefined): Promise<string>;
+    getPerformanceDataTypes?(): Promise<string[]>;
+    getPerformanceData?(packageName: string, dataType: string, dataReadTimeout?: number | undefined): Promise<string[]>;
+    pressKeyCode?(keycode: number, metastate?: number | undefined, flags?: number | undefined): Promise<void>;
+    longPressKeyCode?(keycode: number, metastate?: number | undefined, flags?: number | undefined): Promise<void>;
+    fingerprint?(fingerprintId: number): Promise<void>;
+    sendSMS?(phoneNumber: string, message: string): Promise<void>;
+    gsmCall?(phoneNumber: string, action: string): Promise<void>;
+    gsmSignal?(signalStrength: string): Promise<void>;
+    gsmVoice?(state: string): Promise<void>;
+    powerCapacity?(percent: number): Promise<void>;
+    powerAC?(state: string): Promise<void>;
+    networkSpeed?(netspeed: string): Promise<void>;
+    keyevent?(keycode: string, metastate?: string | undefined): Promise<void>;
+    mobileRotation?(x: number, y: number, radius: number, rotation: number, touchCount: number, duration: string, elementId?: string | undefined): Promise<void>;
+    getCurrentActivity?(): Promise<string>;
+    getCurrentPackage?(): Promise<string>;
+    installApp?(appPath: string, options?: unknown): Promise<void>;
+    activateApp?(appId: string, options?: unknown): Promise<void>;
+    removeApp?(appId: string, options?: unknown): Promise<void>;
+    terminateApp?(appId: string, options?: unknown): Promise<void>;
+    isAppInstalled?(appId: string): Promise<boolean>;
+    queryAppState?(appId: string): Promise<0 | 1 | 3 | 4>;
+    hideKeyboard?(strategy?: string | undefined, key?: string | undefined, keyCode?: string | undefined, keyName?: string | undefined): Promise<void>;
+    isKeyboardShown?(): Promise<boolean>;
+    pushFile?(path: string, data: string): Promise<void>;
+    pullFile?(path: string): Promise<string>;
+    pullFolder?(path: string): Promise<string>;
+    toggleFlightMode?(): Promise<void>;
+    toggleData?(): Promise<void>;
+    toggleWiFi?(): Promise<void>;
+    toggleLocationServices?(): Promise<void>;
+    openNotifications?(): Promise<void>;
+    startActivity?(appPackage: string, appActivity: string, appWaitPackage?: string | undefined, appWaitActivity?: string | undefined, intentAction?: string | undefined, intentCategory?: string | undefined, intentFlags?: string | undefined, optionalIntentArguments?: string | undefined, dontStopAppOnReset?: boolean | undefined): Promise<void>;
+    getSystemBars?(): Promise<unknown[]>;
+    getDisplayDensity?(): Promise<number>;
+    touchId?(match: boolean): Promise<void>;
+    toggleEnrollTouchId?(enabled: boolean): Promise<void>;
+    launchApp?(): Promise<void>;
+    closeApp?(): Promise<void>;
+    background?(seconds: number | null): Promise<void>;
+    endCoverage?(intent: string, path: string): Promise<void>;
+    getStrings?(language?: string | undefined, stringFile?: string | undefined): Promise<Record<string, unknown>>;
+    setValueImmediate?(value: string, elementId: string): Promise<void>;
+    replaceValue?(value: string, elementId: string): Promise<void>;
+    receiveAsyncResponse?(response: unknown): Promise<void>;
+    setClipboard?(content: string, contentType?: string | undefined, label?: string | undefined): Promise<void>;
+    getClipboard?(contentType?: string | undefined): Promise<string>;
+    asyncScriptTimeout?(ms: number): Promise<void>;
+    getWindowSize?(): Promise<import("@appium/types").Size>;
+    getLocation?(elementId: string): Promise<import("@appium/types").Position>;
+    getLocationInView?(elementId: string): Promise<import("@appium/types").Position>;
+    getSize?(elementId: string): Promise<import("@appium/types").Size>;
+    equalsElement?(elementId: string, otherElementId: string): Promise<boolean>;
+    submit?(elementId: string): Promise<void>;
+    keys?(value: string[]): Promise<void>;
+    availableIMEEngines?(): Promise<string[]>;
+    getActiveIMEEngine?(): Promise<string>;
+    isIMEActivated?(): Promise<boolean>;
+    deactivateIMEEngine?(): Promise<void>;
+    activateIMEEngine?(engine: string): Promise<void>;
+    getOrientation?(): Promise<string>;
+    setOrientation?(orientation: string): Promise<void>;
+    moveTo?(element?: string | null | undefined, xOffset?: number | undefined, yOffset?: number | undefined): Promise<void>;
+    buttonDown?(button?: number | undefined): Promise<void>;
+    buttonUp?(button?: number | undefined): Promise<void>;
+    clickCurrent?(button?: number | undefined): Promise<void>;
+    doubleClick?(): Promise<void>;
+    touchDown?(x: number, y: number): Promise<void>;
+    touchUp?(x: number, y: number): Promise<void>;
+    touchMove?(x: number, y: number): Promise<void>;
+    touchLongClick?(elementId: string): Promise<void>;
+    flick?(element?: string | undefined, xSpeed?: number | undefined, ySpeed?: number | undefined, xOffset?: number | undefined, yOffset?: number | undefined, speed?: number | undefined): Promise<void>;
+    getGeoLocation?(): Promise<import("@appium/types").Location>;
+    setGeoLocation?(location: Partial<import("@appium/types").Location>): Promise<void>;
+    getCurrentContext?(): Promise<string | null>;
+    setContext?(name: string): Promise<void>;
+    getContexts?(): Promise<string[]>;
+    getPageIndex?(elementId: string): Promise<string>;
+    getNetworkConnection?(): Promise<number>;
+    setNetworkConnection?(type: number): Promise<void>;
+    performTouch?(actions: unknown): Promise<void>;
+    performMultiAction?(actions: unknown, elementId: string): Promise<void>;
+    getRotation?(): Promise<import("@appium/types").Rotation>;
+    setRotation?(x: number, y: number, z: number): Promise<void>;
+    executeCdp?(cmd: string, params: unknown): Promise<unknown>;
+    addVirtualAuthenticator?(protocol: "ctap/u2f" | "ctap2" | "ctap2_1", transport: string, hasResidentKey?: boolean | undefined, hasUserVerification?: boolean | undefined, isUserConsenting?: boolean | undefined, isUserVerified?: boolean | undefined): Promise<string>;
+    removeVirtualAuthenticator?(authenticatorId: string): Promise<void>;
+    addAuthCredential?(credentialId: string, isResidentCredential: boolean, rpId: string, privateKey: string, userHandle: string, signCount: number, authenticatorId: string): Promise<void>;
+    getAuthCredential?(): Promise<import("@appium/types").Credential[]>;
+    removeAllAuthCredentials?(): Promise<void>;
+    removeAuthCredential?(credentialId: string, authenticatorId: string): Promise<void>;
+    setUserAuthVerified?(isUserVerified: boolean, authenticatorId: string): Promise<void>;
+    proxyCommand?<T_1 = any>(url: string, method: import("@appium/types").HTTPMethod, body?: string | undefined): Promise<T_1>;
+    cliArgs: import("@appium/types").StringRecord;
+    executeCommand(cmd: string, ...args: any[]): Promise<any>;
+    startUnexpectedShutdown(err?: Error | undefined): Promise<void>;
+    startNewCommandTimeout(): Promise<void>;
+    reset(): Promise<void>;
+    caps?: Partial<import("@appium/types").ConstraintsToCaps<{
+        readonly app: {
+            readonly presence: true;
+            readonly isString: true;
+        };
+        readonly uniqueApp: {
+            readonly isBoolean: true;
+        };
+    }> & void> | undefined;
+    originalCaps?: import("@appium/types").W3CCapabilities<{
+        readonly app: {
+            readonly presence: true;
+            readonly isString: true;
+        };
+        readonly uniqueApp: {
+            readonly isBoolean: true;
+        };
+    }, void> | undefined;
+    desiredCapConstraints: {
+        readonly app: {
+            readonly presence: true;
+            readonly isString: true;
+        };
+        readonly uniqueApp: {
+            readonly isBoolean: true;
+        };
+    };
+    assignServer?(server: import("@appium/types").AppiumServer, host: string, port: number, path: string): void;
+    getSessions(): Promise<import("@appium/types").MultiSessionData<typeof import("@appium/types").BASE_DESIRED_CAP_CONSTRAINTS, void>[]>;
+    getSession(): Promise<import("@appium/types").SingularSessionData<typeof import("@appium/types").BASE_DESIRED_CAP_CONSTRAINTS, void>>;
+    supportedLogTypes: Readonly<import("@appium/types").LogDefRecord<{
+        readonly app: {
+            readonly presence: true;
+            readonly isString: true;
+        };
+        readonly uniqueApp: {
+            readonly isBoolean: true;
+        };
+    }>>;
+    getLogTypes(): Promise<string[]>;
+    getLog(logType: string): Promise<unknown[]>;
+    findElement(strategy: string, selector: string): Promise<import("@appium/types").Element>;
+    findElements(strategy: string, selector: string): Promise<import("@appium/types").Element[]>;
+    findElementFromElement(strategy: string, selector: string, elementId: string): Promise<import("@appium/types").Element>;
+    findElementsFromElement(strategy: string, selector: string, elementId: string): Promise<import("@appium/types").Element[]>;
+    findElementFromShadowRoot?(strategy: string, selector: string, shadowId: string): Promise<import("@appium/types").Element>;
+    findElementsFromShadowRoot?(strategy: string, selector: string, shadowId: string): Promise<import("@appium/types").Element[]>;
+    findElOrEls<Mult extends boolean>(strategy: string, selector: string, mult: Mult, context?: any): Promise<Mult extends true ? import("@appium/types").Element[] : import("@appium/types").Element>;
+    findElOrElsWithProcessing<Mult_1 extends boolean>(strategy: string, selector: string, mult: Mult_1, context?: any): Promise<Mult_1 extends true ? import("@appium/types").Element[] : import("@appium/types").Element>;
+    getPageSource(): Promise<string>;
+    updateSettings: (settings: import("@appium/types").StringRecord) => Promise<void>;
+    getSettings(): Promise<import("@appium/types").StringRecord>;
+    timeouts(type: string, ms: string | number, script?: number | undefined, pageLoad?: number | undefined, implicit?: string | number | undefined): Promise<void>;
+    setNewCommandTimeout(ms: number): void;
+    implicitWait(ms: string | number): Promise<void>;
+    setImplicitWait(ms: number): void;
+    implicitWaitForCondition(condition: () => Promise<any>): Promise<unknown>;
+    getTimeouts(): Promise<Record<string, number>>;
+    implicitWaitW3C(ms: number): Promise<void>;
+    implicitWaitMJSONWP(ms: number): Promise<void>;
+    pageLoadTimeoutW3C(ms: number): Promise<void>;
+    pageLoadTimeoutMJSONWP(ms: number): Promise<void>;
+    scriptTimeoutW3C(ms: number): Promise<void>;
+    scriptTimeoutMJSONWP(ms: number): Promise<void>;
+    newCommandTimeout(ms: number): Promise<void>;
+    parseTimeoutArgument(ms: string | number): number;
+    logCustomEvent(vendor: string, event: string): Promise<void>;
+    getLogEvents(type?: string | string[] | undefined): Promise<import("@appium/types").EventHistory | Record<string, number>>;
+    executeMethod(script: string, args: [] | [import("@appium/types").StringRecord]): Promise<any>;
+    createSession(w3cCaps1: import("@appium/types").W3CCapabilities<{
+        readonly app: {
+            readonly presence: true;
+            readonly isString: true;
+        };
+        readonly uniqueApp: {
+            readonly isBoolean: true;
+        };
+    }, void>, w3cCaps2?: import("@appium/types").W3CCapabilities<{
+        readonly app: {
+            readonly presence: true;
+            readonly isString: true;
+        };
+        readonly uniqueApp: {
+            readonly isBoolean: true;
+        };
+    }, void> | undefined, w3cCaps3?: import("@appium/types").W3CCapabilities<{
+        readonly app: {
+            readonly presence: true;
+            readonly isString: true;
+        };
+        readonly uniqueApp: {
+            readonly isBoolean: true;
+        };
+    }, void> | undefined, driverData?: import("@appium/types").DriverData[] | undefined): Promise<[string, any]>;
+    deleteSession(sessionId?: string | undefined, driverData?: import("@appium/types").DriverData[] | undefined): Promise<void>;
+    shouldValidateCaps: boolean;
+    sessionId: string | null;
+    opts: import("@appium/types").DriverOpts<typeof import("@appium/types").BASE_DESIRED_CAP_CONSTRAINTS>;
+    initialOpts: import("@appium/types").ServerArgs;
+    protocol?: string | undefined;
+    helpers: import("@appium/types").DriverHelpers<typeof import("@appium/types").BASE_DESIRED_CAP_CONSTRAINTS>;
+    basePath: string;
+    relaxedSecurityEnabled: boolean;
+    allowInsecure: string[];
+    denyInsecure: string[];
+    newCommandTimeoutMs: number;
+    implicitWaitMs: number;
+    locatorStrategies: string[];
+    webLocatorStrategies: string[];
+    eventEmitter: import("events");
+    settings: import("@appium/types").DeviceSettings<any>;
+    log: import("@appium/types").AppiumLogger;
+    driverData?: import("@appium/types").DriverData | undefined;
+    isCommandsQueueEnabled: boolean;
+    eventHistory: import("@appium/types").EventHistory;
+    onUnexpectedShutdown(handler: () => any): void;
+    getStatus(): Promise<any>;
+    sessionExists(sessionId: string): boolean;
+    isW3CProtocol(): boolean;
+    isMjsonwpProtocol(): boolean;
+    isFeatureEnabled(name: string): boolean;
+    assertFeatureEnabled(name: string): void;
+    validateLocatorStrategy(strategy: string, webContext?: boolean | undefined): void;
+    proxyActive(sessionId?: string | undefined): boolean;
+    getProxyAvoidList(sessionId?: string | undefined): import("@appium/types").RouteMatcher[];
+    canProxy(sessionId?: string | undefined): boolean;
+    proxyRouteIsAvoided(sessionId: string, method: string, url: string): boolean;
+    addManagedDriver(driver: import("@appium/types").Driver<typeof import("@appium/types").BASE_DESIRED_CAP_CONSTRAINTS, import("@appium/types").StringRecord, any>): void;
+    getManagedDrivers(): import("@appium/types").Driver<typeof import("@appium/types").BASE_DESIRED_CAP_CONSTRAINTS, import("@appium/types").StringRecord, any>[];
+    clearNewCommandTimeout(): Promise<void>;
+    logEvent(eventName: string): void;
+    driverForSession(sessionId: string): import("@appium/types").Core<typeof import("@appium/types").BASE_DESIRED_CAP_CONSTRAINTS> | null;
+}>;
+export type FakeDriverCore = import('../driver').FakeDriverCore;
+export type Class<T, U = {}, V = any[]> = import('@appium/types').Class<T, U, V>;
+export type IAlertCommands = import('../types').IAlertCommands;
 //# sourceMappingURL=alert.d.ts.map

package/build/lib/commands/alert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"alert.d.ts","sourceRoot":"","sources":["../../../lib/commands/alert.js"],"names":[],"mappings":";;IAkBA,6CAGC;IAED,uDAOC;IAED,iDAGC;;;;;IA7BD,+BAIC;IAED,6BAIC;;AAZC,2BAAe"}
+{"version":3,"file":"alert.d.ts","sourceRoot":"","sources":["../../../lib/commands/alert.js"],"names":[],"mappings":";AAEA;;;;GAIG;AACH,oJAFa;;;IAmBT;;;;OAIG;oBADU,QAAQ,MAAM,CAAC;IAO5B;;;;;OAKG;uBAFQ,MAAM,GACJ,QAAQ,IAAI,CAAC;IAW1B;;;;OAIG;uBADU,QAAQ,IAAI,CAAC;IAO1B;;;;OAIG;4BAXU,QAAQ,IAAI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA/CG,CA+DhC;6BAGY,OAAO,WAAW,EAAE,cAAc;0CAKlC,OAAO,eAAe,EAAE,KAAK,CAAC,CAAC,EAAC,CAAC,EAAC,CAAC,CAAC;6BAIpC,OAAO,UAAU,EAAE,cAAc"}

package/build/lib/commands/alert.js

@@ -1,54 +1,81 @@
 "use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.helpers = exports.default = exports.commands = void 0;
-
-require("source-map-support/register");
-
-var _driver = require("appium/driver");
-
-let commands = {},
-    helpers = {},
-    extensions = {};
-exports.helpers = helpers;
-exports.commands = commands;
-
-helpers.assertNoAlert = function assertNoAlert() {
-  if (this.appModel.hasAlert()) {
-    throw new _driver.errors.UnexpectedAlertOpenError();
-  }
-};
-
-helpers.assertAlert = function assertAlert() {
-  if (!this.appModel.hasAlert()) {
-    throw new _driver.errors.NoAlertOpenError();
-  }
-};
-
-commands.getAlertText = async function getAlertText() {
-  this.assertAlert();
-  return this.appModel.alertText();
-};
-
-commands.setAlertText = async function setAlertText(text) {
-  this.assertAlert();
-
-  try {
-    this.appModel.setAlertText(text);
-  } catch (e) {
-    throw new _driver.errors.InvalidElementStateError();
-  }
-};
-
-commands.postAcceptAlert = async function postAcceptAlert() {
-  this.assertAlert();
-  this.appModel.handleAlert();
-};
-
-commands.postDismissAlert = commands.postAcceptAlert;
-Object.assign(extensions, commands, helpers);
-var _default = extensions;
-exports.default = _default;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertMixin = void 0;
+const driver_1 = require("appium/driver");
+/**
+ * @template {Class<import('../types').IContextsCommands & import('@appium/types').IFindCommands>} T
+ * @param {T} Base
+ * @returns {Class<AlertCommands>}
+ */
+function AlertMixin(Base) {
+    /**
+     * @implements {IAlertCommands}
+     */
+    class AlertCommands extends Base {
+        constructor() {
+            super(...arguments);
+            /**
+             * Dismiss an alert
+             *
+             * @returns {Promise<null>}
+             */
+            this.postDismissAlert = this.postAcceptAlert;
+        }
+        assertNoAlert() {
+            if (this.appModel.hasAlert()) {
+                throw new driver_1.errors.UnexpectedAlertOpenError();
+            }
+        }
+        assertAlert() {
+            if (!this.appModel.hasAlert()) {
+                throw new driver_1.errors.NoAlertOpenError();
+            }
+        }
+        /**
+         * Get the text of an alert
+         *
+         * @returns {Promise<string>}
+         */
+        async getAlertText() {
+            this.assertAlert();
+            return this.appModel.alertText();
+        }
+        /**
+         * Set the text of an alert
+         *
+         * @param {string} text
+         * @returns {Promise<void>}
+         */
+        async setAlertText(text) {
+            this.assertAlert();
+            try {
+                this.appModel.setAlertText(text);
+            }
+            catch (e) {
+                throw new driver_1.errors.InvalidElementStateError();
+            }
+        }
+        /**
+         * Accept an alert
+         *
+         * @returns {Promise<void>}
+         */
+        async postAcceptAlert() {
+            this.assertAlert();
+            this.appModel.handleAlert();
+        }
+    }
+    return AlertCommands;
+}
+exports.AlertMixin = AlertMixin;
+/**
+ * @typedef {import('../driver').FakeDriverCore} FakeDriverCore
+ */
+/**
+ * @template T,[U={}],[V=Array<any>]
+ * @typedef {import('@appium/types').Class<T,U,V>} Class
+ */
+/**
+ * @typedef {import('../types').IAlertCommands} IAlertCommands
+ */
+//# sourceMappingURL=alert.js.map

package/build/lib/commands/alert.js.map

@@ -1 +1 @@
-{"version":3,"file":"alert.js","names":["commands","helpers","extensions","assertNoAlert","appModel","hasAlert","errors","UnexpectedAlertOpenError","assertAlert","NoAlertOpenError","getAlertText","alertText","setAlertText","text","e","InvalidElementStateError","postAcceptAlert","handleAlert","postDismissAlert","Object","assign"],"sources":["../../../lib/commands/alert.js"],"sourcesContent":["import {errors} from 'appium/driver';\n\nlet commands = {},\n  helpers = {},\n  extensions = {};\n\nhelpers.assertNoAlert = function assertNoAlert() {\n  if (this.appModel.hasAlert()) {\n    throw new errors.UnexpectedAlertOpenError();\n  }\n};\n\nhelpers.assertAlert = function assertAlert() {\n  if (!this.appModel.hasAlert()) {\n    throw new errors.NoAlertOpenError();\n  }\n};\n\ncommands.getAlertText = async function getAlertText() {\n  this.assertAlert();\n  return this.appModel.alertText();\n};\n\ncommands.setAlertText = async function setAlertText(text) {\n  this.assertAlert();\n  try {\n    this.appModel.setAlertText(text);\n  } catch (e) {\n    throw new errors.InvalidElementStateError();\n  }\n};\n\ncommands.postAcceptAlert = async function postAcceptAlert() {\n  this.assertAlert();\n  this.appModel.handleAlert();\n};\n\ncommands.postDismissAlert = commands.postAcceptAlert;\n\nObject.assign(extensions, commands, helpers);\nexport {commands, helpers};\nexport default extensions;\n"],"mappings":";;;;;;;;;AAAA;;AAEA,IAAIA,QAAQ,GAAG,EAAf;AAAA,IACEC,OAAO,GAAG,EADZ;AAAA,IAEEC,UAAU,GAAG,EAFf;;;;AAIAD,OAAO,CAACE,aAAR,GAAwB,SAASA,aAAT,GAAyB;EAC/C,IAAI,KAAKC,QAAL,CAAcC,QAAd,EAAJ,EAA8B;IAC5B,MAAM,IAAIC,cAAA,CAAOC,wBAAX,EAAN;EACD;AACF,CAJD;;AAMAN,OAAO,CAACO,WAAR,GAAsB,SAASA,WAAT,GAAuB;EAC3C,IAAI,CAAC,KAAKJ,QAAL,CAAcC,QAAd,EAAL,EAA+B;IAC7B,MAAM,IAAIC,cAAA,CAAOG,gBAAX,EAAN;EACD;AACF,CAJD;;AAMAT,QAAQ,CAACU,YAAT,GAAwB,eAAeA,YAAf,GAA8B;EACpD,KAAKF,WAAL;EACA,OAAO,KAAKJ,QAAL,CAAcO,SAAd,EAAP;AACD,CAHD;;AAKAX,QAAQ,CAACY,YAAT,GAAwB,eAAeA,YAAf,CAA4BC,IAA5B,EAAkC;EACxD,KAAKL,WAAL;;EACA,IAAI;IACF,KAAKJ,QAAL,CAAcQ,YAAd,CAA2BC,IAA3B;EACD,CAFD,CAEE,OAAOC,CAAP,EAAU;IACV,MAAM,IAAIR,cAAA,CAAOS,wBAAX,EAAN;EACD;AACF,CAPD;;AASAf,QAAQ,CAACgB,eAAT,GAA2B,eAAeA,eAAf,GAAiC;EAC1D,KAAKR,WAAL;EACA,KAAKJ,QAAL,CAAca,WAAd;AACD,CAHD;;AAKAjB,QAAQ,CAACkB,gBAAT,GAA4BlB,QAAQ,CAACgB,eAArC;AAEAG,MAAM,CAACC,MAAP,CAAclB,UAAd,EAA0BF,QAA1B,EAAoCC,OAApC;eAEeC,U"}
+{"version":3,"file":"alert.js","sourceRoot":"","sources":["../../../lib/commands/alert.js"],"names":[],"mappings":";;;AAAA,0CAAqC;AAErC;;;;GAIG;AACH,SAAgB,UAAU,CAAC,IAAI;IAC7B;;OAEG;IACH,MAAM,aAAc,SAAQ,IAAI;QAAhC;;YAgDE;;;;eAIG;YACH,qBAAgB,GAAG,IAAI,CAAC,eAAe,CAAC;QAC1C,CAAC;QArDC,aAAa;YACX,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE;gBAC5B,MAAM,IAAI,eAAM,CAAC,wBAAwB,EAAE,CAAC;aAC7C;QACH,CAAC;QAED,WAAW;YACT,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,EAAE;gBAC7B,MAAM,IAAI,eAAM,CAAC,gBAAgB,EAAE,CAAC;aACrC;QACH,CAAC;QAED;;;;WAIG;QACH,KAAK,CAAC,YAAY;YAChB,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,OAAO,IAAI,CAAC,QAAQ,CAAC,SAAS,EAAE,CAAC;QACnC,CAAC;QAED;;;;;WAKG;QACH,KAAK,CAAC,YAAY,CAAC,IAAI;YACrB,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,IAAI;gBACF,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;aAClC;YAAC,OAAO,CAAC,EAAE;gBACV,MAAM,IAAI,eAAM,CAAC,wBAAwB,EAAE,CAAC;aAC7C;QACH,CAAC;QAED;;;;WAIG;QACH,KAAK,CAAC,eAAe;YACnB,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,CAAC;QAC9B,CAAC;KAQF;IAED,OAAO,aAAa,CAAC;AACvB,CAAC;AA7DD,gCA6DC;AAED;;GAEG;AAEH;;;GAGG;AAEH;;GAEG"}