@nexface/tools 0.1.0

package/dist/browser/controller.js

@@ -0,0 +1,783 @@
+import { createIdentity, createScrollableIdentity, getElementScrollability, normalizeText, } from "./dom.js";
+import { PageCommandError, findElementHitTarget, prepareLocatorForAction, prepareRefForAction, requireUnique, requireValidRef, resolveLocator, waitForLocator, } from "./locator.js";
+const LOCATOR_METHODS = new Set([
+    "click",
+    "fill",
+    "press",
+    "check",
+    "uncheck",
+    "selectOption",
+    "hover",
+    "focus",
+    "blur",
+    "scrollBy",
+    "scrollTo",
+    "scrollIntoView",
+    "exists",
+    "text",
+    "waitFor",
+]);
+const PAGE_METHODS = new Set([
+    "scrollBy",
+    "waitForTimeout",
+    "waitForURL",
+]);
+const WAIT_FOR_URL_TIMEOUT_MS = 3_000;
+const URL_POLL_INTERVAL_MS = 50;
+const ACTION_METHODS = new Set([
+    "click",
+    "fill",
+    "press",
+    "check",
+    "uncheck",
+    "selectOption",
+    "hover",
+    "focus",
+    "blur",
+    "scrollIntoView",
+    "scrollBy",
+    "scrollTo",
+]);
+function dispatchInput(element) {
+    element.dispatchEvent(new InputEvent("input", {
+        bubbles: true,
+        inputType: "insertText",
+    }));
+    element.dispatchEvent(new Event("change", { bubbles: true }));
+}
+function setNativeValue(element, value) {
+    const prototype = element instanceof HTMLInputElement
+        ? HTMLInputElement.prototype
+        : HTMLTextAreaElement.prototype;
+    const setter = Object.getOwnPropertyDescriptor(prototype, "value")?.set;
+    setter?.call(element, value);
+    dispatchInput(element);
+}
+function dispatchClickSequence(element) {
+    const hit = findElementHitTarget(element);
+    if (!hit) {
+        throw new PageCommandError({
+            code: "ELEMENT_COVERED",
+            message: "Click target does not have an uncovered hit point.",
+        });
+    }
+    const { element: hitTarget, clientX, clientY, } = hit;
+    const init = {
+        bubbles: true,
+        cancelable: true,
+        composed: true,
+        view: window,
+        clientX,
+        clientY,
+        button: 0,
+        detail: 1,
+    };
+    hitTarget.dispatchEvent(new PointerEvent("pointerdown", {
+        ...init,
+        buttons: 1,
+        pointerId: 1,
+        pointerType: "mouse",
+        isPrimary: true,
+    }));
+    const shouldFocus = hitTarget.dispatchEvent(new MouseEvent("mousedown", { ...init, buttons: 1 }));
+    if (shouldFocus &&
+        element instanceof HTMLElement &&
+        element.ownerDocument.activeElement !== element) {
+        element.focus({ preventScroll: true });
+    }
+    if (!element.isConnected || !hitTarget.isConnected) {
+        throw new PageCommandError({
+            code: "REF_ACTION_FAILED",
+            message: "Click target changed after mousedown.",
+        });
+    }
+    hitTarget.dispatchEvent(new PointerEvent("pointerup", {
+        ...init,
+        buttons: 0,
+        pointerId: 1,
+        pointerType: "mouse",
+        isPrimary: true,
+    }));
+    hitTarget.dispatchEvent(new MouseEvent("mouseup", { ...init, buttons: 0 }));
+    if (hitTarget instanceof HTMLElement) {
+        hitTarget.click();
+        return;
+    }
+    hitTarget.dispatchEvent(new MouseEvent("click", { ...init, buttons: 0 }));
+}
+function targetLabel(command) {
+    if (command.target.type === "ref")
+        return command.target.ref;
+    if (command.target.type === "locator") {
+        return JSON.stringify(command.target.locator).slice(0, 500);
+    }
+    return "page";
+}
+function invalidCommand(message) {
+    return new PageCommandError({ code: "INVALID_COMMAND", message });
+}
+function validateMatcher(value, maxChars) {
+    if (typeof value === "string") {
+        if (value.length > maxChars)
+            throw invalidCommand("Matcher is too long.");
+        return;
+    }
+    if (!value || typeof value !== "object") {
+        throw invalidCommand("Matcher must be a string or normalized regex.");
+    }
+    const regex = value;
+    if (typeof regex.source !== "string" ||
+        regex.source.length > maxChars ||
+        typeof regex.flags !== "string" ||
+        !/^[dgimsuvy]*$/.test(regex.flags)) {
+        throw invalidCommand("Regex matcher is invalid.");
+    }
+    try {
+        new RegExp(regex.source, regex.flags);
+    }
+    catch {
+        throw invalidCommand("Regex matcher could not be compiled.");
+    }
+}
+function validateLocator(descriptor, maxChars) {
+    if (!descriptor ||
+        typeof descriptor !== "object" ||
+        !Array.isArray(descriptor.steps) ||
+        descriptor.steps.length === 0) {
+        throw invalidCommand("Locator must contain at least one step.");
+    }
+    if (descriptor.steps.length > 12) {
+        throw invalidCommand("Locator contains too many steps.");
+    }
+    for (const step of descriptor.steps) {
+        if (step.kind === "role") {
+            if (!step.role || step.role.length > 80) {
+                throw invalidCommand("Locator role is invalid.");
+            }
+            if (step.options?.name !== undefined) {
+                validateMatcher(step.options.name, maxChars);
+            }
+            continue;
+        }
+        if (step.kind === "text" || step.kind === "label") {
+            validateMatcher(step.text, maxChars);
+            continue;
+        }
+        if (step.kind === "filter") {
+            validateMatcher(step.hasText, maxChars);
+            continue;
+        }
+        throw invalidCommand("Locator contains an unsupported step.");
+    }
+}
+function validateArgs(command, maxChars) {
+    if (!Array.isArray(command.args)) {
+        throw invalidCommand("Command args must be an array.");
+    }
+    let serialized;
+    try {
+        serialized = JSON.stringify(command.args);
+    }
+    catch {
+        throw invalidCommand("Command args must be serializable.");
+    }
+    if (serialized.length > maxChars) {
+        throw invalidCommand("Command args are too large.");
+    }
+    if (command.method === "fill" || command.method === "press") {
+        if (command.args.length !== 1 || typeof command.args[0] !== "string") {
+            throw invalidCommand(`${command.method}() requires one string argument.`);
+        }
+    }
+    if (command.method === "selectOption") {
+        if (command.args.length !== 1 ||
+            (typeof command.args[0] !== "string" &&
+                !Array.isArray(command.args[0]))) {
+            throw invalidCommand("selectOption() requires a string or string array.");
+        }
+        if (Array.isArray(command.args[0]) &&
+            command.args[0].some((item) => typeof item !== "string")) {
+            throw invalidCommand("selectOption() array values must be strings.");
+        }
+    }
+    if (command.method === "waitFor") {
+        const options = command.args[0];
+        if (command.args.length > 1 ||
+            (options !== undefined &&
+                (typeof options !== "object" || options === null || Array.isArray(options)))) {
+            throw invalidCommand("waitFor() options are invalid.");
+        }
+        const value = options;
+        if (value?.state !== undefined &&
+            !["visible", "hidden", "attached"].includes(String(value.state))) {
+            throw invalidCommand("waitFor() state is invalid.");
+        }
+        if (value?.timeout !== undefined &&
+            (typeof value.timeout !== "number" ||
+                !Number.isFinite(value.timeout) ||
+                value.timeout < 0)) {
+            throw invalidCommand("waitFor() timeout is invalid.");
+        }
+    }
+    if (command.method === "waitForTimeout") {
+        if (command.args.length !== 1 ||
+            typeof command.args[0] !== "number" ||
+            !Number.isFinite(command.args[0]) ||
+            command.args[0] < 0) {
+            throw invalidCommand("waitForTimeout() requires one non-negative number.");
+        }
+    }
+    if (command.method === "waitForURL") {
+        const expected = command.args[0];
+        const options = command.args[1];
+        if (command.args.length < 1 ||
+            command.args.length > 2 ||
+            typeof expected !== "string" ||
+            expected.length === 0 ||
+            (options !== undefined &&
+                (typeof options !== "object" || options === null || Array.isArray(options)))) {
+            throw invalidCommand("waitForURL() requires a URL string and optional timeout options.");
+        }
+        const value = options;
+        if (value &&
+            (Object.keys(value).some((key) => key !== "timeout") ||
+                (value.timeout !== undefined &&
+                    (typeof value.timeout !== "number" ||
+                        !Number.isFinite(value.timeout) ||
+                        value.timeout < 0)))) {
+            throw invalidCommand("waitForURL() options are invalid.");
+        }
+    }
+    if (command.method === "scrollBy") {
+        const value = command.args[0];
+        if (command.args.length !== 1 ||
+            !value ||
+            typeof value !== "object" ||
+            Array.isArray(value) ||
+            Object.keys(value).length === 0 ||
+            Object.keys(value).some((key) => !["x", "y"].includes(key)) ||
+            (value.x !== undefined &&
+                (typeof value.x !== "number" || !Number.isFinite(value.x))) ||
+            (value.y !== undefined &&
+                (typeof value.y !== "number" || !Number.isFinite(value.y)))) {
+            throw invalidCommand("scrollBy() requires finite numeric x/y values.");
+        }
+    }
+    if (command.method === "scrollTo") {
+        const value = command.args[0];
+        if (command.args.length !== 1 ||
+            !value ||
+            typeof value !== "object" ||
+            Array.isArray(value) ||
+            Object.keys(value).length === 0 ||
+            Object.keys(value).some((key) => !["left", "top"].includes(key)) ||
+            (value.left !== undefined &&
+                (typeof value.left !== "number" || !Number.isFinite(value.left))) ||
+            (value.top !== undefined &&
+                (typeof value.top !== "number" || !Number.isFinite(value.top)))) {
+            throw invalidCommand("scrollTo() requires finite numeric left/top values.");
+        }
+    }
+}
+async function waitAnimationFrames(count, signal) {
+    for (let index = 0; index < count; index += 1) {
+        signal.throwIfAborted();
+        await new Promise((resolve) => requestAnimationFrame(() => resolve()));
+    }
+    signal.throwIfAborted();
+}
+export class PageController {
+    limits;
+    animator;
+    executions = new Map();
+    constructor(limits, animator) {
+        this.limits = limits;
+        this.animator = animator;
+    }
+    beginExecution(executionId, registry) {
+        this.executions.set(executionId, {
+            abortController: new AbortController(),
+            callCount: 0,
+            completedActions: [],
+            lastSeq: 0,
+            registry,
+            status: "running",
+        });
+    }
+    cancelExecution(executionId) {
+        const record = this.executions.get(executionId);
+        if (!record)
+            return;
+        record.status = "cancelled";
+        record.abortController.abort();
+    }
+    completeExecution(executionId) {
+        const record = this.executions.get(executionId);
+        if (!record)
+            return { completedActions: [] };
+        record.status = "completed";
+        record.abortController.abort();
+        this.executions.delete(executionId);
+        return {
+            completedActions: [...record.completedActions].sort((a, b) => a.callIndex - b.callIndex),
+            ...(record.failedCall ? { failedCall: record.failedCall } : {}),
+        };
+    }
+    requireActive(command) {
+        if (!command ||
+            typeof command !== "object" ||
+            typeof command.executionId !== "string" ||
+            !Number.isSafeInteger(command.commandSeq) ||
+            command.commandSeq <= 0) {
+            throw invalidCommand("Command envelope is invalid.");
+        }
+        const record = this.executions.get(command.executionId);
+        if (!record ||
+            record.status !== "running" ||
+            record.abortController.signal.aborted) {
+            throw new PageCommandError({
+                code: "EXECUTION_CANCELLED",
+                message: "The execution is no longer active.",
+            });
+        }
+        if (command.commandSeq <= record.lastSeq) {
+            throw invalidCommand("Command sequence must be strictly increasing.");
+        }
+        record.lastSeq = command.commandSeq;
+        record.callCount += 1;
+        if (record.callCount > this.limits.maxPageCalls) {
+            throw invalidCommand(`Page API call budget exceeded (${this.limits.maxPageCalls}).`);
+        }
+        this.validateCommand(command);
+        return record;
+    }
+    validateCommand(command) {
+        if (!command.target ||
+            typeof command.target !== "object" ||
+            !["page", "ref", "locator"].includes(command.target.type) ||
+            typeof command.method !== "string") {
+            throw invalidCommand("Command target or method is invalid.");
+        }
+        if (command.target.type === "page") {
+            if (!PAGE_METHODS.has(command.method)) {
+                throw invalidCommand(`Unsupported page method: ${command.method}`);
+            }
+        }
+        else {
+            if (!LOCATOR_METHODS.has(command.method)) {
+                throw invalidCommand(`Unsupported locator method: ${command.method}`);
+            }
+            if (command.target.type === "ref") {
+                if (!/^@\d+$/.test(command.target.ref)) {
+                    throw invalidCommand("Snapshot ref is invalid.");
+                }
+            }
+            else {
+                validateLocator(command.target.locator, this.limits.maxArgumentChars);
+            }
+        }
+        validateArgs(command, this.limits.maxArgumentChars);
+    }
+    async execute(command) {
+        let record = this.executions.get(command.executionId);
+        try {
+            record = this.requireActive(command);
+            const value = command.target.type === "page"
+                ? await this.executePage(command, record)
+                : await this.executeTarget(command, record);
+            if (ACTION_METHODS.has(command.method) &&
+                !record.completedActions.some((action) => action.callIndex === command.commandSeq)) {
+                this.recordCompletedAction(record, command);
+            }
+            return { ok: true, value };
+        }
+        catch (error) {
+            if (record && !record.failedCall) {
+                const target = targetLabel(command);
+                record.failedCall = {
+                    callIndex: command.commandSeq,
+                    method: command.method,
+                    ...(target ? { target } : {}),
+                };
+            }
+            if (error instanceof PageCommandError) {
+                return { ok: false, error: error.detail };
+            }
+            return {
+                ok: false,
+                error: {
+                    code: "UNSUPPORTED_OPERATION",
+                    message: error instanceof Error ? error.message : String(error),
+                },
+            };
+        }
+    }
+    async executePage(command, record) {
+        if (command.method === "scrollBy") {
+            const value = (command.args[0] ?? {});
+            window.scrollBy({
+                left: Number(value.x ?? 0),
+                top: Number(value.y ?? 0),
+                behavior: "auto",
+            });
+            return null;
+        }
+        if (command.method === "waitForTimeout") {
+            const requested = Number(command.args[0] ?? 0);
+            const duration = Math.max(0, Math.min(requested, this.limits.singleActionTimeoutMs));
+            await new Promise((resolve, reject) => {
+                const onAbort = () => {
+                    window.clearTimeout(timer);
+                    reject(new PageCommandError({
+                        code: "EXECUTION_CANCELLED",
+                        message: "Execution was cancelled while waiting.",
+                    }));
+                };
+                const timer = window.setTimeout(() => {
+                    record.abortController.signal.removeEventListener("abort", onAbort);
+                    resolve();
+                }, duration);
+                record.abortController.signal.addEventListener("abort", onAbort, {
+                    once: true,
+                });
+            });
+            return null;
+        }
+        if (command.method === "waitForURL") {
+            let expectedUrl;
+            try {
+                expectedUrl = new URL(String(command.args[0]), location.href).href;
+            }
+            catch {
+                throw invalidCommand("waitForURL() URL is invalid.");
+            }
+            const options = (command.args[1] ?? {});
+            const timeout = Math.min(options.timeout ?? WAIT_FOR_URL_TIMEOUT_MS, WAIT_FOR_URL_TIMEOUT_MS, this.limits.singleActionTimeoutMs);
+            if (location.href === expectedUrl)
+                return null;
+            await new Promise((resolve, reject) => {
+                let settled = false;
+                const cleanup = () => {
+                    window.clearInterval(interval);
+                    window.clearTimeout(timer);
+                    record.abortController.signal.removeEventListener("abort", onAbort);
+                };
+                const settle = (error) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    cleanup();
+                    if (error)
+                        reject(error);
+                    else
+                        resolve();
+                };
+                const onAbort = () => settle(new PageCommandError({
+                    code: "EXECUTION_CANCELLED",
+                    message: "Execution was cancelled while waiting for the URL.",
+                }));
+                const interval = window.setInterval(() => {
+                    if (location.href === expectedUrl)
+                        settle();
+                }, URL_POLL_INTERVAL_MS);
+                const timer = window.setTimeout(() => settle(new PageCommandError({
+                    code: "ACTION_TIMEOUT",
+                    message: `URL did not become ${expectedUrl} within ${timeout}ms.`,
+                })), timeout);
+                record.abortController.signal.addEventListener("abort", onAbort, {
+                    once: true,
+                });
+            });
+            return null;
+        }
+        throw invalidCommand(`Unsupported page method: ${command.method}`);
+    }
+    resolveRef(command, record) {
+        if (command.target.type !== "ref")
+            return undefined;
+        return record.registry.refs.get(command.target.ref);
+    }
+    locator(command) {
+        return command.target.type === "locator"
+            ? command.target.locator
+            : undefined;
+    }
+    async executeTarget(command, record) {
+        const signal = record.abortController.signal;
+        const ref = this.resolveRef(command, record);
+        const locator = this.locator(command);
+        if (command.method === "exists") {
+            if (ref) {
+                try {
+                    requireValidRef(ref);
+                    return true;
+                }
+                catch {
+                    return false;
+                }
+            }
+            return locator ? resolveLocator(locator).length > 0 : false;
+        }
+        if (command.method === "waitFor") {
+            const options = (command.args[0] ?? {});
+            if (!locator) {
+                requireValidRef(ref);
+                return null;
+            }
+            await waitForLocator(locator, options.state ?? "visible", Math.min(options.timeout ?? this.limits.singleActionTimeoutMs, this.limits.singleActionTimeoutMs), signal);
+            return null;
+        }
+        if (command.method === "text") {
+            const element = ref
+                ? requireValidRef(ref)
+                : locator
+                    ? requireUnique(locator)
+                    : undefined;
+            if (!element)
+                throw invalidCommand("Target is missing.");
+            if (element instanceof HTMLInputElement ||
+                element instanceof HTMLTextAreaElement ||
+                element instanceof HTMLSelectElement) {
+                return element.value;
+            }
+            return normalizeText(element.textContent);
+        }
+        if (command.method === "scrollIntoView") {
+            const element = ref
+                ? requireValidRef(ref)
+                : locator
+                    ? requireUnique(locator)
+                    : undefined;
+            if (!element)
+                throw invalidCommand("Target is missing.");
+            const beforeIdentity = createIdentity(element);
+            element.scrollIntoView({
+                block: "center",
+                inline: "nearest",
+                behavior: "auto",
+            });
+            this.recordCompletedAction(record, command);
+            await new Promise((resolve) => requestAnimationFrame(() => resolve()));
+            signal.throwIfAborted();
+            if (!element.isConnected || createIdentity(element) !== beforeIdentity) {
+                throw new PageCommandError({
+                    code: "REF_ACTION_FAILED",
+                    message: "Target changed while scrolling.",
+                });
+            }
+            return null;
+        }
+        if (command.method === "scrollBy" || command.method === "scrollTo") {
+            const element = ref
+                ? ref.element
+                : locator
+                    ? requireUnique(locator)
+                    : undefined;
+            if (!(element instanceof HTMLElement)) {
+                throw new PageCommandError({
+                    code: "UNSUPPORTED_OPERATION",
+                    message: "Scroll target is not an HTML element.",
+                });
+            }
+            if (ref?.kind !== "scrollable") {
+                if (ref) {
+                    throw new PageCommandError({
+                        code: "UNSUPPORTED_OPERATION",
+                        message: "Snapshot ref is not a scrollable container.",
+                    });
+                }
+            }
+            const identity = createScrollableIdentity(element);
+            if (!element.isConnected || (ref && identity !== ref.identity)) {
+                throw new PageCommandError({
+                    code: "REF_ACTION_FAILED",
+                    message: "Scrollable target changed after the snapshot.",
+                });
+            }
+            const scrollability = getElementScrollability(element);
+            if (!scrollability) {
+                throw new PageCommandError({
+                    code: "UNSUPPORTED_OPERATION",
+                    message: "Target does not currently have a scroll range.",
+                });
+            }
+            this.requireStillActive(record);
+            if (command.method === "scrollBy") {
+                const value = command.args[0];
+                if ((value.x !== undefined && value.x !== 0 && !scrollability.x) ||
+                    (value.y !== undefined && value.y !== 0 && !scrollability.y)) {
+                    throw new PageCommandError({
+                        code: "UNSUPPORTED_OPERATION",
+                        message: "Requested axis does not have a scroll range.",
+                    });
+                }
+                element.scrollBy({
+                    left: Number(value.x ?? 0),
+                    top: Number(value.y ?? 0),
+                    behavior: "auto",
+                });
+            }
+            else {
+                const value = command.args[0];
+                if ((value.left !== undefined &&
+                    value.left !== element.scrollLeft &&
+                    !scrollability.x) ||
+                    (value.top !== undefined &&
+                        value.top !== element.scrollTop &&
+                        !scrollability.y)) {
+                    throw new PageCommandError({
+                        code: "UNSUPPORTED_OPERATION",
+                        message: "Requested axis does not have a scroll range.",
+                    });
+                }
+                element.scrollTo({
+                    left: Number(value.left ?? element.scrollLeft),
+                    top: Number(value.top ?? element.scrollTop),
+                    behavior: "auto",
+                });
+            }
+            this.recordCompletedAction(record, command);
+            await waitAnimationFrames(2, signal);
+            if (!element.isConnected || createScrollableIdentity(element) !== identity) {
+                throw new PageCommandError({
+                    code: "REF_ACTION_FAILED",
+                    message: "Scrollable target changed while scrolling.",
+                });
+            }
+            return null;
+        }
+        const element = ref
+            ? await prepareRefForAction(ref, signal)
+            : locator
+                ? (await waitForLocator(locator, "visible", this.limits.singleActionTimeoutMs, signal),
+                    await prepareLocatorForAction(locator, signal))
+                : undefined;
+        if (!element)
+            throw invalidCommand("Target is missing.");
+        this.requireStillActive(record);
+        this.animator.before(command.method, element);
+        this.requireStillActive(record);
+        const result = this.performAction(element, command);
+        this.recordCompletedAction(record, command);
+        this.animator.after(command.method);
+        return result;
+    }
+    recordCompletedAction(record, command) {
+        if (record.completedActions.some((action) => action.callIndex === command.commandSeq)) {
+            return;
+        }
+        const target = targetLabel(command);
+        record.completedActions.push({
+            callIndex: command.commandSeq,
+            method: command.method,
+            ...(target ? { target } : {}),
+        });
+    }
+    requireStillActive(record) {
+        if (record.status !== "running" ||
+            record.abortController.signal.aborted) {
+            throw new PageCommandError({
+                code: "EXECUTION_CANCELLED",
+                message: "Execution was cancelled before the DOM action.",
+            });
+        }
+    }
+    performAction(element, command) {
+        if (command.method === "click") {
+            dispatchClickSequence(element);
+            return null;
+        }
+        if (command.method === "fill") {
+            const value = String(command.args[0] ?? "");
+            if ((element instanceof HTMLInputElement ||
+                element instanceof HTMLTextAreaElement) &&
+                !element.readOnly) {
+                element.focus({ preventScroll: true });
+                setNativeValue(element, value);
+                return null;
+            }
+            if (element instanceof HTMLElement && element.isContentEditable) {
+                element.focus({ preventScroll: true });
+                element.textContent = value;
+                dispatchInput(element);
+                return null;
+            }
+            throw new PageCommandError({
+                code: "NOT_EDITABLE",
+                message: "fill() target is not editable.",
+            });
+        }
+        if (command.method === "press") {
+            const key = String(command.args[0] ?? "");
+            element.dispatchEvent(new KeyboardEvent("keydown", { key, bubbles: true }));
+            element.dispatchEvent(new KeyboardEvent("keyup", { key, bubbles: true }));
+            return null;
+        }
+        if (command.method === "check" || command.method === "uncheck") {
+            const checked = command.method === "check";
+            if (element instanceof HTMLInputElement &&
+                ["checkbox", "radio"].includes(element.type)) {
+                if (element.type === "radio" && !checked) {
+                    throw new PageCommandError({
+                        code: "UNSUPPORTED_OPERATION",
+                        message: "Native radio elements cannot be unchecked directly.",
+                    });
+                }
+                if (element.checked !== checked) {
+                    dispatchClickSequence(element);
+                }
+                return null;
+            }
+            if (element.getAttribute("aria-checked") !== null) {
+                const current = element.getAttribute("aria-checked") === "true";
+                if (current !== checked)
+                    dispatchClickSequence(element);
+                return null;
+            }
+            throw new PageCommandError({
+                code: "UNSUPPORTED_OPERATION",
+                message: `${command.method}() target is not checkable.`,
+            });
+        }
+        if (command.method === "selectOption") {
+            if (!(element instanceof HTMLSelectElement)) {
+                throw new PageCommandError({
+                    code: "UNSUPPORTED_OPERATION",
+                    message: "selectOption() currently supports native select elements.",
+                });
+            }
+            const requested = command.args[0];
+            const values = Array.isArray(requested)
+                ? requested.map(String)
+                : [String(requested ?? "")];
+            const availableValues = new Set(Array.from(element.options, (option) => option.value));
+            const missing = values.filter((value) => !availableValues.has(value));
+            if (missing.length > 0) {
+                throw new PageCommandError({
+                    code: "NOT_FOUND",
+                    message: `selectOption() values were not found: ${missing.join(", ")}`,
+                });
+            }
+            for (const option of element.options) {
+                option.selected = values.includes(option.value);
+            }
+            dispatchInput(element);
+            return null;
+        }
+        if (command.method === "hover") {
+            element.dispatchEvent(new MouseEvent("mouseover", { bubbles: true, composed: true }));
+            element.dispatchEvent(new MouseEvent("mouseenter", { bubbles: false, composed: true }));
+            return null;
+        }
+        if (command.method === "focus") {
+            element.focus();
+            return null;
+        }
+        if (command.method === "blur") {
+            element.blur();
+            return null;
+        }
+        throw invalidCommand(`Unsupported locator method: ${command.method}`);
+    }
+}
+//# sourceMappingURL=controller.js.map