@roxybrowser/playwright 2.0.2-beta.0

package/dist/locator.js

@@ -0,0 +1,883 @@
+import { readFile, stat } from "node:fs/promises";
+import { basename, extname, resolve } from "node:path";
+import { TimeoutError } from "./errors.js";
+import { assertFillValue } from "./assertions.js";
+import { resolveHumanizationOptions } from "./human/profile.js";
+import { assertMaxArguments, serializePageFunction } from "./evaluation.js";
+import { RoxyElementHandle, serializeEvaluationArgument } from "./elementHandle.js";
+import { convertInputFiles } from "./inputFiles.js";
+import { normalizeSelectOptionValues } from "./selectOptionValues.js";
+import { createRemoteJSHandle, createSmartHandle } from "./jsHandle.js";
+import { createAltTextLocatorSelector, createInternalTextLocatorSelector, createLabelLocatorSelector, createPlaceholderLocatorSelector, createRoleLocatorSelector, createTestIdLocatorSelector, createTextLocatorSelector, createTitleLocatorSelector } from "./locatorSelectors.js";
+import { parseSelectorChain } from "./selectors.js";
+const ENTER_FRAME_SELECTOR = {
+    strategy: "control",
+    value: "enter-frame"
+};
+const FIRST_SELECTOR = {
+    strategy: "control",
+    value: "pick",
+    pick: { kind: "first" }
+};
+const LAST_SELECTOR = {
+    strategy: "control",
+    value: "pick",
+    pick: { kind: "last" }
+};
+const DEFAULT_LOCATOR_HUMAN_DEFAULTS = resolveHumanizationOptions({ enabled: false });
+const DEFAULT_WAIT_TIMEOUT_MS = 30_000;
+function cloneLocatorSelector(selector) {
+    return {
+        ...selector,
+        ...(selector.hasChain ? { hasChain: selector.hasChain.map(cloneLocatorSelector) } : {})
+    };
+}
+function cloneLocatorSelectorChain(chain) {
+    return chain.map(cloneLocatorSelector);
+}
+function selectorChainForLocator(locator, optionName) {
+    const chain = locator._roxySelectorChain?.();
+    if (!chain) {
+        throw new Error(`Inner "${optionName}" locator must belong to the same frame.`);
+    }
+    return cloneLocatorSelectorChain(chain);
+}
+function frameIdentityForLocator(locator) {
+    return locator._roxyFrameIdentity?.();
+}
+function assertSameFrameLocator(currentFrameIdentity, locator, errorMessage) {
+    const innerFrameIdentity = frameIdentityForLocator(locator);
+    if (currentFrameIdentity !== undefined &&
+        innerFrameIdentity !== undefined &&
+        currentFrameIdentity !== innerFrameIdentity) {
+        throw new Error(errorMessage);
+    }
+}
+function selectorChainForSameFrameLocator(currentFrameIdentity, locator, errorMessage) {
+    assertSameFrameLocator(currentFrameIdentity, locator, errorMessage);
+    const chain = locator._roxySelectorChain?.();
+    if (!chain) {
+        throw new Error(errorMessage);
+    }
+    return cloneLocatorSelectorChain(chain);
+}
+class DisposableStub {
+    callback;
+    constructor(callback) {
+        this.callback = callback;
+    }
+    dispose() {
+        return this.callback();
+    }
+}
+async function convertDropFiles(files) {
+    if (files === undefined) {
+        return [];
+    }
+    const items = Array.isArray(files) ? files : [files];
+    if (items.every((item) => typeof item === "string")) {
+        return Promise.all(items.map(async (filePath) => {
+            const resolved = resolve(filePath);
+            const [buffer, fileStat] = await Promise.all([
+                readFile(resolved),
+                stat(resolved)
+            ]);
+            return {
+                buffer: buffer.toString("base64"),
+                lastModifiedMs: fileStat.mtimeMs,
+                mimeType: inferDropMimeType(resolved),
+                name: basename(resolved)
+            };
+        }));
+    }
+    const resolved = await convertInputFiles(items);
+    return resolved.payloads.map((payload) => ({
+        buffer: payload.base64,
+        mimeType: payload.mimeType,
+        name: payload.name,
+        ...(payload.lastModifiedMs === undefined ? {} : { lastModifiedMs: payload.lastModifiedMs })
+    }));
+}
+function inferDropMimeType(filePath) {
+    const extension = extname(filePath).toLowerCase();
+    switch (extension) {
+        case ".avif":
+            return "image/avif";
+        case ".bmp":
+            return "image/bmp";
+        case ".css":
+            return "text/css";
+        case ".csv":
+            return "text/csv";
+        case ".gif":
+            return "image/gif";
+        case ".htm":
+        case ".html":
+            return "text/html";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".js":
+        case ".mjs":
+            return "text/javascript";
+        case ".json":
+            return "application/json";
+        case ".md":
+            return "text/markdown";
+        case ".pdf":
+            return "application/pdf";
+        case ".png":
+            return "image/png";
+        case ".svg":
+            return "image/svg+xml";
+        case ".txt":
+            return "text/plain";
+        case ".webp":
+            return "image/webp";
+        case ".xml":
+            return "application/xml";
+        case ".zip":
+            return "application/zip";
+        default:
+            return "application/octet-stream";
+    }
+}
+function chainLocator(adapter, selector) {
+    const chain = parseSelectorChain(selector);
+    const [first, ...rest] = chain;
+    if (!first) {
+        throw new Error("Selector must not be empty.");
+    }
+    let current = adapter.locator(first);
+    for (const part of rest) {
+        current = current.locator(part);
+    }
+    return current;
+}
+export class RoxyLocator {
+    adapter;
+    humanController;
+    beforeAction;
+    humanDefaults;
+    frameResolver;
+    ownerPage;
+    frameIdentity;
+    selectorChain;
+    constructor(adapter, humanController, selectorChain = null, beforeAction, humanDefaults = DEFAULT_LOCATOR_HUMAN_DEFAULTS, frameResolver, ownerPage, frameIdentity) {
+        this.adapter = adapter;
+        this.humanController = humanController;
+        this.beforeAction = beforeAction;
+        this.humanDefaults = humanDefaults;
+        this.frameResolver = frameResolver;
+        this.ownerPage = ownerPage;
+        this.frameIdentity = frameIdentity;
+        this.selectorChain = selectorChain ? cloneLocatorSelectorChain(selectorChain) : null;
+    }
+    _roxySelectorChain() {
+        return this.selectorChain ? cloneLocatorSelectorChain(this.selectorChain) : null;
+    }
+    _roxyFrameIdentity() {
+        return this.frameIdentity;
+    }
+    page() {
+        if (!this.ownerPage) {
+            throw new Error("Locator is not associated with a page.");
+        }
+        return this.ownerPage;
+    }
+    cloneWith(adapter, selectorChain = this.selectorChain) {
+        return new RoxyLocator(adapter, this.humanController, selectorChain, this.beforeAction, this.humanDefaults, this.frameResolver, this.ownerPage, this.frameIdentity);
+    }
+    locator(selectorOrLocator, options) {
+        if (typeof selectorOrLocator !== "string") {
+            const selector = {
+                strategy: "control",
+                value: "chain",
+                composite: "chain",
+                hasChain: selectorChainForSameFrameLocator(this.frameIdentity, selectorOrLocator, "Locators must belong to the same frame.")
+            };
+            const locator = this.cloneWith(this.adapter.locator(selector), [...(this.selectorChain ?? []), selector]);
+            return options ? locator.filter(options) : locator;
+        }
+        const selector = selectorOrLocator;
+        const chain = parseSelectorChain(selector);
+        const locator = new RoxyLocator(chainLocator(this.adapter, selector), this.humanController, [...(this.selectorChain ?? []), ...chain], this.beforeAction, this.humanDefaults, this.frameResolver, this.ownerPage, this.frameIdentity);
+        return options ? locator.filter(options) : locator;
+    }
+    _roxyLocatorFromChain(chain, options) {
+        let adapter = this.adapter;
+        for (const selector of chain) {
+            adapter = adapter.locator(selector);
+        }
+        const locator = this.cloneWith(adapter, [...(this.selectorChain ?? []), ...cloneLocatorSelectorChain(chain)]);
+        return options ? locator.filter(options) : locator;
+    }
+    frameLocator(selector) {
+        return this.locator(selector).contentFrame();
+    }
+    contentFrame() {
+        return new RoxyFrameLocator(this, new RoxyLocator(this.adapter.locator(ENTER_FRAME_SELECTOR), this.humanController, [...(this.selectorChain ?? []), ENTER_FRAME_SELECTOR], this.beforeAction, this.humanDefaults, this.frameResolver, this.ownerPage, this.frameIdentity));
+    }
+    getByText(text, options) {
+        return new RoxyLocator(this.adapter.getByText(text, options), this.humanController, this.extendSelectorChain("getByText", text, options), this.beforeAction, this.humanDefaults, this.frameResolver, this.ownerPage, this.frameIdentity);
+    }
+    getByAltText(text, options) {
+        return new RoxyLocator(this.adapter.getByAltText(text, options), this.humanController, this.extendSelectorChain("getByAltText", text, options), this.beforeAction, this.humanDefaults, this.frameResolver, this.ownerPage, this.frameIdentity);
+    }
+    getByLabel(text, options) {
+        return new RoxyLocator(this.adapter.getByLabel(text, options), this.humanController, this.extendSelectorChain("getByLabel", text, options), this.beforeAction, this.humanDefaults, this.frameResolver, this.ownerPage, this.frameIdentity);
+    }
+    getByPlaceholder(text, options) {
+        return new RoxyLocator(this.adapter.getByPlaceholder(text, options), this.humanController, this.extendSelectorChain("getByPlaceholder", text, options), this.beforeAction, this.humanDefaults, this.frameResolver, this.ownerPage, this.frameIdentity);
+    }
+    getByTestId(testId) {
+        return new RoxyLocator(this.adapter.getByTestId(testId), this.humanController, this.extendSelectorChain("getByTestId", testId), this.beforeAction, this.humanDefaults, this.frameResolver, this.ownerPage, this.frameIdentity);
+    }
+    getByRole(role, options) {
+        return new RoxyLocator(this.adapter.getByRole(role, options), this.humanController, this.extendSelectorChain("getByRole", role, options), this.beforeAction, this.humanDefaults, this.frameResolver, this.ownerPage, this.frameIdentity);
+    }
+    getByTitle(text, options) {
+        return new RoxyLocator(this.adapter.getByTitle(text, options), this.humanController, this.extendSelectorChain("getByTitle", text, options), this.beforeAction, this.humanDefaults, this.frameResolver, this.ownerPage, this.frameIdentity);
+    }
+    first() {
+        return this.cloneWith(this.adapter.first(), [...(this.selectorChain ?? []), FIRST_SELECTOR]);
+    }
+    last() {
+        return this.cloneWith(this.adapter.last(), [...(this.selectorChain ?? []), LAST_SELECTOR]);
+    }
+    nth(index) {
+        if (this.selectorChain?.some((selector) => selector.capture)) {
+            throw new Error("Can't query n-th element");
+        }
+        return this.cloneWith(this.adapter.nth(index), [
+            ...(this.selectorChain ?? []),
+            {
+                strategy: "control",
+                value: "pick",
+                pick: { kind: "nth", index }
+            }
+        ]);
+    }
+    filter(options) {
+        let adapter = this.adapter;
+        const chain = [...(this.selectorChain ?? [])];
+        if (options?.has !== undefined) {
+            const selector = {
+                strategy: "control",
+                value: "has",
+                filter: true,
+                hasChain: selectorChainForSameFrameLocator(this.frameIdentity, options.has, 'Inner "has" locator must belong to the same frame.')
+            };
+            adapter = adapter.locator(selector);
+            chain.push(selector);
+        }
+        if (options?.hasNot !== undefined) {
+            const selector = {
+                strategy: "control",
+                value: "has-not",
+                filter: true,
+                negate: true,
+                hasChain: selectorChainForSameFrameLocator(this.frameIdentity, options.hasNot, 'Inner "hasNot" locator must belong to the same frame.')
+            };
+            adapter = adapter.locator(selector);
+            chain.push(selector);
+        }
+        if (options?.hasText !== undefined) {
+            const selector = {
+                ...createInternalTextLocatorSelector(options.hasText),
+                filter: true
+            };
+            adapter = adapter.locator(selector);
+            chain.push(selector);
+        }
+        if (options?.hasNotText !== undefined) {
+            const selector = {
+                ...createInternalTextLocatorSelector(options.hasNotText),
+                filter: true,
+                negate: true
+            };
+            adapter = adapter.locator(selector);
+            chain.push(selector);
+        }
+        if (options?.visible !== undefined) {
+            const selector = {
+                strategy: "control",
+                value: "visible",
+                filter: true,
+                visible: options.visible
+            };
+            adapter = adapter.locator(selector);
+            chain.push(selector);
+        }
+        return this.cloneWith(adapter, chain);
+    }
+    and(locator) {
+        const selector = {
+            strategy: "control",
+            value: "and",
+            composite: "and",
+            hasChain: selectorChainForSameFrameLocator(this.frameIdentity, locator, "Locators must belong to the same frame.")
+        };
+        return this.cloneWith(this.adapter.locator(selector), [...(this.selectorChain ?? []), selector]);
+    }
+    or(locator) {
+        const selector = {
+            strategy: "control",
+            value: "or",
+            composite: "or",
+            hasChain: selectorChainForSameFrameLocator(this.frameIdentity, locator, "Locators must belong to the same frame.")
+        };
+        return this.cloneWith(this.adapter.locator(selector), [...(this.selectorChain ?? []), selector]);
+    }
+    describe(description) {
+        return this.cloneWith(this.adapter, [
+            ...(this.selectorChain ?? []),
+            { strategy: "control", value: "describe", description }
+        ]);
+    }
+    description() {
+        const lastSelector = this.selectorChain?.[this.selectorChain.length - 1];
+        return lastSelector?.strategy === "control" && lastSelector.value === "describe"
+            ? lastSelector.description ?? null
+            : null;
+    }
+    async all() {
+        return Array.from({ length: await this.count() }, (_value, index) => this.nth(index));
+    }
+    async allInnerTexts() {
+        return this.evaluateAll((elements) => elements.map((element) => element.innerText));
+    }
+    async allTextContents() {
+        return this.evaluateAll((elements) => elements.map((element) => element.textContent || ""));
+    }
+    async count() {
+        return this.adapter.count();
+    }
+    async evaluate(pageFunction, argOrOptions, options) {
+        assertMaxArguments(arguments.length, 3);
+        const hasArg = arguments.length >= 2 && (arguments.length !== 2 || !looksLikeTimeoutOptions(argOrOptions));
+        void (hasArg ? options : argOrOptions);
+        return this.adapter.evaluate(serializePageFunction(pageFunction), serializeEvaluationArgument(hasArg ? argOrOptions : undefined), typeof pageFunction === "function");
+    }
+    async evaluateAll(pageFunction, arg) {
+        assertMaxArguments(arguments.length, 2);
+        return this.adapter.evaluateAll(serializePageFunction(pageFunction), serializeEvaluationArgument(arg), typeof pageFunction === "function");
+    }
+    async evaluateHandle(pageFunction, argOrOptions, options) {
+        assertMaxArguments(arguments.length, 3);
+        const hasArg = arguments.length >= 2 && (arguments.length !== 2 || !looksLikeTimeoutOptions(argOrOptions));
+        void (hasArg ? options : argOrOptions);
+        if (this.adapter.evaluateHandle) {
+            return await createRemoteJSHandle(await this.adapter.evaluateHandle(serializePageFunction(pageFunction), serializeEvaluationArgument(hasArg ? argOrOptions : undefined), typeof pageFunction === "function"), (reference) => this.frameResolver?.createElementHandleFromReference(reference)
+                ?? new RoxyElementHandle(this.adapter.elementHandle(), this.humanDefaults, this.frameResolver));
+        }
+        return createSmartHandle(await this.evaluate(pageFunction, hasArg ? argOrOptions : undefined));
+    }
+    async boundingBox(options) {
+        void options;
+        return this.adapter.boundingBox();
+    }
+    async actionPoint(options = {}) {
+        const box = await this.boundingBox(options.timeout === undefined ? undefined : { timeout: options.timeout });
+        if (!box) {
+            throw new Error("locator.dragTo: Element is not visible.");
+        }
+        const position = options.position ?? {
+            x: box.width / 2,
+            y: box.height / 2
+        };
+        return {
+            x: box.x + position.x,
+            y: box.y + position.y
+        };
+    }
+    async dblclick(options) {
+        const actionOptions = this.withBeforeActionRetry(options);
+        await this.beforeAction?.(this, actionOptions);
+        await this.adapter.dblclick(actionOptions);
+    }
+    async check(options) {
+        const actionOptions = this.withBeforeActionRetry(options);
+        await this.beforeAction?.(this, actionOptions);
+        await this.adapter.check(actionOptions);
+    }
+    async clear(options) {
+        await this.fill("", options);
+    }
+    async click(options) {
+        const actionOptions = this.withBeforeActionRetry(options);
+        await this.beforeAction?.(this, actionOptions);
+        await this.humanController.click(this.adapter, actionOptions);
+    }
+    async hover(options) {
+        const actionOptions = this.withBeforeActionRetry(options);
+        await this.beforeAction?.(this, actionOptions);
+        await this.humanController.hover(this.adapter, actionOptions);
+    }
+    async fill(value, options) {
+        assertFillValue(value);
+        await this.beforeAction?.(this, options);
+        await this.humanController.fill(this.adapter, value, options);
+    }
+    async type(value, options) {
+        await this.beforeAction?.(this, options);
+        await this.humanController.type(this.adapter, value, options);
+    }
+    async press(key, options) {
+        await this.beforeAction?.(this, options);
+        await this.humanController.press(this.adapter, key, options);
+    }
+    async pressSequentially(text, options) {
+        await this.type(text, options);
+    }
+    async focus() {
+        await this.adapter.focus();
+    }
+    async blur(options) {
+        void options;
+        await this.adapter.blur();
+    }
+    async dispatchEvent(type, eventInit, options) {
+        await this.adapter.dispatchEvent(type, eventInit, options);
+    }
+    async dragTo(target, options) {
+        const sourcePoint = await this.actionPoint({
+            ...(options?.sourcePosition === undefined ? {} : { position: options.sourcePosition }),
+            ...(options?.timeout === undefined ? {} : { timeout: options.timeout })
+        });
+        if (!(target instanceof RoxyLocator)) {
+            throw new Error("locator.dragTo: Target must be a Roxy locator.");
+        }
+        const targetPoint = await target.actionPoint({
+            ...(options?.targetPosition === undefined ? {} : { position: options.targetPosition }),
+            ...(options?.timeout === undefined ? {} : { timeout: options.timeout })
+        });
+        if (options?.trial) {
+            return;
+        }
+        const mouse = this.page().mouse;
+        await mouse.move(sourcePoint.x, sourcePoint.y);
+        await mouse.down();
+        await mouse.move(targetPoint.x, targetPoint.y, options?.steps === undefined ? undefined : { steps: options.steps });
+        await mouse.up();
+    }
+    async drop(payload, options) {
+        const hasFiles = payload.files !== undefined && (Array.isArray(payload.files) ? payload.files.length > 0 : true);
+        const hasData = payload.data !== undefined && Object.keys(payload.data).length > 0;
+        if (!hasFiles && !hasData) {
+            throw new Error('At least one of "files" or "data" must be provided.');
+        }
+        const handle = await this.elementHandle(options?.timeout === undefined ? {} : { timeout: options.timeout });
+        if (!handle) {
+            throw new Error("No element found.");
+        }
+        const files = hasFiles ? await convertDropFiles(payload.files) : [];
+        const data = payload.data ?? {};
+        const result = await handle.evaluate((element, dropPayload) => {
+            if (!element.isConnected) {
+                return "error:notconnected";
+            }
+            const dataTransfer = new DataTransfer();
+            for (const file of dropPayload.files) {
+                const bytes = Uint8Array.from(atob(file.buffer), (char) => char.charCodeAt(0));
+                const fileOptions = { type: file.mimeType || "application/octet-stream" };
+                if (file.lastModifiedMs !== undefined) {
+                    fileOptions.lastModified = file.lastModifiedMs;
+                }
+                dataTransfer.items.add(new File([bytes], file.name, fileOptions));
+            }
+            for (const [type, value] of Object.entries(dropPayload.data)) {
+                dataTransfer.setData(type, value);
+            }
+            const rect = element.getBoundingClientRect();
+            const point = dropPayload.position ?? {
+                x: rect.width / 2,
+                y: rect.height / 2
+            };
+            const clientX = rect.left + point.x;
+            const clientY = rect.top + point.y;
+            const makeEvent = (type) => new DragEvent(type, {
+                bubbles: true,
+                cancelable: true,
+                clientX,
+                clientY,
+                composed: true,
+                dataTransfer
+            });
+            element.dispatchEvent(makeEvent("dragenter"));
+            const over = makeEvent("dragover");
+            element.dispatchEvent(over);
+            if (!over.defaultPrevented) {
+                element.dispatchEvent(makeEvent("dragleave"));
+                return "not-accepted";
+            }
+            element.dispatchEvent(makeEvent("drop"));
+            return "accepted";
+        }, {
+            data,
+            files,
+            position: options?.position
+        });
+        if (result === "error:notconnected") {
+            throw new Error("Element is not attached to the DOM.");
+        }
+        if (result === "not-accepted") {
+            throw new Error("Drop target did not accept the drop; its dragover handler did not call preventDefault().");
+        }
+    }
+    async getAttribute(name) {
+        return this.adapter.getAttribute(name);
+    }
+    async highlight(_options = {}) {
+        return new DisposableStub(() => this.hideHighlight());
+    }
+    async hideHighlight() { }
+    async innerHTML() {
+        return this.adapter.innerHTML();
+    }
+    async innerText() {
+        return this.adapter.innerText();
+    }
+    async inputValue() {
+        return this.adapter.inputValue();
+    }
+    async isChecked() {
+        return this.adapter.isChecked();
+    }
+    async isDisabled() {
+        return this.adapter.isDisabled();
+    }
+    async isEditable() {
+        return this.adapter.isEditable();
+    }
+    async isEnabled() {
+        return this.adapter.isEnabled();
+    }
+    async isHidden() {
+        return this.adapter.isHidden();
+    }
+    async ariaSnapshot(options) {
+        void options;
+        const handle = await this.elementHandle();
+        if (!handle) {
+            throw new Error("No element found.");
+        }
+        return handle.evaluate((element) => element.textContent ?? "");
+    }
+    async normalize() {
+        return this;
+    }
+    async textContent() {
+        return this.adapter.textContent();
+    }
+    async uncheck(options) {
+        const actionOptions = this.withBeforeActionRetry(options);
+        await this.beforeAction?.(this, actionOptions);
+        await this.adapter.uncheck(actionOptions);
+    }
+    async selectOption(values, options) {
+        await this.beforeAction?.(this, options);
+        const handle = await this.elementHandle(options?.timeout === undefined ? {} : { timeout: options.timeout });
+        if (!handle) {
+            throw new TimeoutError(`locator.elementHandle: Timeout ${options?.timeout ?? DEFAULT_WAIT_TIMEOUT_MS}ms exceeded.`);
+        }
+        return this.adapter.selectOption(await normalizeSelectOptionValues(handle, values), options);
+    }
+    async screenshot(options) {
+        const handle = await this.elementHandle(options?.timeout === undefined ? {} : { timeout: options.timeout });
+        if (!handle) {
+            throw new Error("No element found.");
+        }
+        return handle.screenshot(options);
+    }
+    async scrollIntoViewIfNeeded(options) {
+        const handle = await this.elementHandle(options?.timeout === undefined ? {} : { timeout: options.timeout });
+        if (!handle) {
+            throw new Error("No element found.");
+        }
+        await handle.scrollIntoViewIfNeeded(options);
+    }
+    async selectText(options = {}) {
+        const handle = await this.elementHandle(options.timeout === undefined ? {} : { timeout: options.timeout });
+        if (!handle) {
+            throw new Error("No element found.");
+        }
+        await handle.selectText(options);
+    }
+    async setChecked(checked, options) {
+        if (checked) {
+            await this.check(options);
+            return;
+        }
+        await this.uncheck(options);
+    }
+    async setInputFiles(files, options) {
+        const handle = await this.elementHandle(options?.timeout === undefined ? {} : { timeout: options.timeout });
+        if (!handle) {
+            throw new Error("No element found.");
+        }
+        await handle.setInputFiles(files, options);
+    }
+    async tap(options) {
+        await this.beforeAction?.(this, options);
+        await this.adapter.tap(options);
+    }
+    async isVisible() {
+        return this.adapter.isVisible();
+    }
+    async waitFor(options = {}) {
+        const state = options.state ?? "visible";
+        const timeout = options.timeout ?? DEFAULT_WAIT_TIMEOUT_MS;
+        const startTime = Date.now();
+        while (timeout === 0 || Date.now() - startTime <= timeout) {
+            await this.beforeAction?.(this, {
+                timeout: timeout === 0 ? 0 : Math.max(0, timeout - (Date.now() - startTime))
+            });
+            const count = await this.count().catch((error) => {
+                if (shouldRethrowWaitForResolutionError(error)) {
+                    throw error;
+                }
+                return 0;
+            });
+            const attached = count > 0;
+            const visible = attached
+                ? await this.isVisible().catch((error) => {
+                    if (shouldRethrowWaitForResolutionError(error)) {
+                        throw error;
+                    }
+                    return false;
+                })
+                : false;
+            if (state === "attached" && attached)
+                return;
+            if (state === "visible" && visible)
+                return;
+            if (state === "hidden" && !visible)
+                return;
+            if (state === "detached" && !attached)
+                return;
+            await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+        throw new TimeoutError(`Timeout ${timeout}ms exceeded.`);
+    }
+    async elementHandle(options = {}) {
+        const timeout = options.timeout ?? DEFAULT_WAIT_TIMEOUT_MS;
+        const startTime = Date.now();
+        let lastError;
+        while (timeout === 0 || Date.now() - startTime <= timeout) {
+            try {
+                return new RoxyElementHandle(await this.adapter.elementHandle(), this.humanDefaults, this.frameResolver);
+            }
+            catch (error) {
+                lastError = error;
+                if (timeout === 0) {
+                    break;
+                }
+                await new Promise((resolve) => setTimeout(resolve, 50));
+            }
+        }
+        if (lastError) {
+            throw lastError;
+        }
+        throw new TimeoutError(`Timeout ${timeout}ms exceeded.`);
+    }
+    async elementHandles() {
+        const handles = await this.adapter.elementHandles();
+        return handles.map((handle) => new RoxyElementHandle(handle, this.humanDefaults, this.frameResolver));
+    }
+    toString() {
+        return this.description() ?? formatLocatorChain(this.selectorChain ?? []);
+    }
+    extendSelectorChain(kind, value, options) {
+        const current = this.selectorChain ?? [];
+        switch (kind) {
+            case "getByText":
+                return [...current, createTextLocatorSelector(value, options)];
+            case "getByAltText":
+                return [...current, createAltTextLocatorSelector(value, options)];
+            case "getByLabel":
+                return [...current, createLabelLocatorSelector(value, options)];
+            case "getByPlaceholder":
+                return [
+                    ...current,
+                    createPlaceholderLocatorSelector(value, options)
+                ];
+            case "getByTestId":
+                return [...current, createTestIdLocatorSelector(value)];
+            case "getByRole":
+                return [
+                    ...current,
+                    createRoleLocatorSelector(String(value), options)
+                ];
+            case "getByTitle":
+                return [...current, createTitleLocatorSelector(value, options)];
+        }
+    }
+    withBeforeActionRetry(options) {
+        if (!this.beforeAction) {
+            return options;
+        }
+        return {
+            ...(options ?? {}),
+            __roxyBeforeActionRetry: async () => {
+                return await this.beforeAction?.(this, options);
+            }
+        };
+    }
+}
+export class RoxyFrameLocator {
+    ownerLocator;
+    contentLocator;
+    constructor(ownerLocator, contentLocator) {
+        this.ownerLocator = ownerLocator;
+        this.contentLocator = contentLocator;
+    }
+    first() {
+        return this.ownerLocator.first().contentFrame();
+    }
+    last() {
+        return this.ownerLocator.last().contentFrame();
+    }
+    nth(index) {
+        return this.ownerLocator.nth(index).contentFrame();
+    }
+    frameLocator(selector) {
+        return this.contentLocator.frameLocator(selector);
+    }
+    locator(selectorOrLocator, options) {
+        if (typeof selectorOrLocator !== "string") {
+            const chain = selectorOrLocator._roxySelectorChain?.();
+            if (!chain) {
+                throw new Error("Locators must belong to the same frame.");
+            }
+            return this.contentLocator._roxyLocatorFromChain(chain, options);
+        }
+        const locator = this.contentLocator.locator(selectorOrLocator);
+        return options ? locator.filter(options) : locator;
+    }
+    getByText(text, options) {
+        return this.contentLocator.getByText(text, options);
+    }
+    getByAltText(text, options) {
+        return this.contentLocator.getByAltText(text, options);
+    }
+    getByLabel(text, options) {
+        return this.contentLocator.getByLabel(text, options);
+    }
+    getByPlaceholder(text, options) {
+        return this.contentLocator.getByPlaceholder(text, options);
+    }
+    getByTestId(testId) {
+        return this.contentLocator.getByTestId(testId);
+    }
+    getByRole(role, options) {
+        return this.contentLocator.getByRole(role, options);
+    }
+    getByTitle(text, options) {
+        return this.contentLocator.getByTitle(text, options);
+    }
+    owner() {
+        return this.ownerLocator;
+    }
+}
+function looksLikeTimeoutOptions(value) {
+    return Boolean(value
+        && typeof value === "object"
+        && "timeout" in value
+        && Object.keys(value).every((key) => key === "timeout"));
+}
+function shouldRethrowWaitForResolutionError(error) {
+    const message = String(error instanceof Error ? error.message : error);
+    return (message.includes("strict mode violation")
+        || message.includes("Can't query n-th element")
+        || message.includes("<iframe> was expected"));
+}
+function formatLocatorChain(chain) {
+    const formatted = chain
+        .map(formatLocatorSelector)
+        .filter((part) => Boolean(part));
+    return formatted.length ? formatted.join(".") : "locator('')";
+}
+function formatLocatorSelector(selector) {
+    if (selector.strategy === "control" && selector.value === "describe") {
+        return null;
+    }
+    if (selector.strategy === "css") {
+        switch (selector.label) {
+            case "alt":
+                return formatTextLocatorCall("getByAltText", selector);
+            case "label":
+                return formatTextLocatorCall("getByLabel", selector);
+            case "placeholder":
+                return formatTextLocatorCall("getByPlaceholder", selector);
+            case "testId":
+                return formatTextLocatorCall("getByTestId", selector);
+            case "title":
+                return formatTextLocatorCall("getByTitle", selector);
+            default:
+                return `locator(${quote(selector.value)})`;
+        }
+    }
+    if (selector.strategy === "text") {
+        return formatTextLocatorCall("getByText", selector);
+    }
+    if (selector.strategy === "role") {
+        const options = formatLocatorOptions([
+            formatMaybeRegexOption("name", selector.name, selector.nameIsRegex, selector.nameRegexFlags),
+            typeof selector.name === "string" && selector.exact ? "exact: true" : null
+        ]);
+        return `getByRole(${quote(selector.value)}${options})`;
+    }
+    if (selector.strategy === "control") {
+        if (selector.value === "enter-frame") {
+            return "contentFrame()";
+        }
+        if (selector.value === "pick" && selector.pick) {
+            if (selector.pick.kind === "nth") {
+                return `nth(${selector.pick.index})`;
+            }
+            return `${selector.pick.kind}()`;
+        }
+        if (selector.value === "chain" && selector.hasChain) {
+            return `locator(${formatLocatorChain(selector.hasChain)})`;
+        }
+        if (selector.value === "and" && selector.hasChain) {
+            return `and(${formatLocatorChain(selector.hasChain)})`;
+        }
+        if (selector.value === "or" && selector.hasChain) {
+            return `or(${formatLocatorChain(selector.hasChain)})`;
+        }
+        if (selector.value === "has" && selector.hasChain) {
+            return `filter({ has: ${formatLocatorChain(selector.hasChain)} })`;
+        }
+        if (selector.value === "has-not" && selector.hasChain) {
+            return `filter({ hasNot: ${formatLocatorChain(selector.hasChain)} })`;
+        }
+        return `locator(${quote(`internal:control=${selector.value}`)})`;
+    }
+    return `locator(${quote(`${selector.strategy}=${selector.value}`)})`;
+}
+function formatTextLocatorCall(method, selector) {
+    const value = formatMaybeRegexValue(selector.value, selector.isRegex, selector.regexFlags);
+    const options = typeof selector.value === "string" && selector.exact
+        ? ", { exact: true }"
+        : "";
+    return `${method}(${value}${options})`;
+}
+function formatMaybeRegexOption(name, value, isRegex, flags) {
+    if (value === undefined) {
+        return null;
+    }
+    return `${name}: ${formatMaybeRegexValue(value, isRegex, flags)}`;
+}
+function formatMaybeRegexValue(value, isRegex, flags) {
+    return isRegex ? `/${value.replace(/\//g, "\\/")}/${flags ?? ""}` : quote(value);
+}
+function formatLocatorOptions(options) {
+    const filtered = options.filter((option) => Boolean(option));
+    return filtered.length ? `, { ${filtered.join(", ")} }` : "";
+}
+function quote(value) {
+    return `'${JSON.stringify(value).slice(1, -1).replace(/'/g, "\\'")}'`;
+}
+//# sourceMappingURL=locator.js.map