@itmetsam/samurai-framework 0.22.9 → 0.22.11

package/dist/locator/locator.js

@@ -1,22 +1,15 @@
 import { ElementHandle } from "../script/element-handle.js";
-import { waitForActionable, waitForState, } from "./actionability.js";
-import { setChecked } from "./check-actions.js";
+import { waitForActionable, } from "./actionability.js";
 import { ChainResolver } from "./chain-resolver.js";
 import { callInPage, noElementError, requireElement, } from "./element-access.js";
-import { clearElement, fillElement, focusElement, pressOnElement, pressSequentially, screenshotElement, } from "./element-actions.js";
 import { dragElement } from "./drag-actions.js";
-import { blurElement, dispatchEventOn } from "./event-actions.js";
-import { clickElement, hoverElement, tapElement, } from "./pointer-element-actions.js";
-import { readAccessibleDescription, readAccessibleName, readAllInnerTexts, readAllTextContents, readAttribute, readBoundingBox, readBoundingClientRect, readClassAttribute, readCssValue, readEnabledState, readInnerHTML, readInnerText, readInputValue, readIsChecked, readIsEditable, readIsEnabled, readIsVisible, readTextContent, } from "./element-reads.js";
-import { evaluateOnAll, evaluateOnElement } from "./evaluate.js";
-import { dropFiles, setInputFiles } from "./file-actions.js";
 import { DEFAULT_PAUSE_MS, pause } from "./input-actions.js";
 import { NOT_STRICT, strictViolation, } from "./strict-mode.js";
 import { attributeSelector, cssSelector, describeChain, describeSelector, labelSelector, nthSelector, roleSelector, testIdSelector, textSelector, } from "./selector.js";
-import { selectOptions } from "./select-actions.js";
 import { filterSelector } from "./filter-step.js";
 import { selectorFromString } from "./selector-string.js";
-export default class Locator {
+import { LocatorElementMethods } from "./locator-element-methods.js";
+export default class Locator extends LocatorElementMethods {
     /**
      * `selector` is an xpath, or a chain of selector steps that each search inside the previous step's matches.
      * `helpers` is the page's helper realm. With it the actionability probe is installed once per
@@ -25,6 +18,7 @@ export default class Locator {
      * `strictness` says whether actions and reads throw when the locator matches several elements (see `strict`); default no.
      */
     constructor(selector, biDiConnector, contextId, helpers, alternatives = [], strictness = NOT_STRICT) {
+        super();
         this.chain =
             typeof selector === "string" ? [selectorFromString(selector)] : selector;
         this.biDiConnector = biDiConnector;
@@ -268,171 +262,10 @@ export default class Locator {
     waitForActionable(action, checks, probe, options) {
         return waitForActionable(this.actionability, action, checks, probe, options);
     }
-    /**
-     * Waits until the element is attached, visible, stable, enabled and not covered, then clicks it with real pointer
-     * input: its centre, or `position` (pixels from its top left corner). `button`, `clickCount`, `delay` (ms between press
-     * and release) and `modifiers` (keys held down) are as in Playwright
-     */
-    async click(options) {
-        await clickElement(this.access, options);
-    }
-    /** `click` with `clickCount: 2` */
-    async dblclick(options) {
-        await clickElement(this.access, { ...options, clickCount: 2 }, "dblclick");
-    }
-    /** Waits until the element is attached, visible, stable and not covered, then moves the mouse onto it (`:hover`, `mouseover`, tooltips) */
-    async hover(options) {
-        await hoverElement(this.access, options);
-    }
-    /** Waits like `click`, then touches the element with a touch pointer: `touchstart`, `touchend`, then the mouse events a tap ends in */
-    async tap(options) {
-        await tapElement(this.access, options);
-    }
     /** Drags this element onto `target` with real pointer input; `sourcePosition`, `targetPosition` and `steps` shape the gesture. Firefox needs synthetic drop events, see the wiki */
     async dragTo(target, options) {
         await dragElement(this.access, target.access, options);
     }
-    /** Waits until the element is attached, then fires a synthetic event (`click`, `keydown`, ...; the class follows the type) at it, bubbling and composed */
-    async dispatchEvent(type, eventInit, options) {
-        await dispatchEventOn(this.access, type, eventInit, options);
-    }
-    /** Waits until the element is attached, then removes focus from it */
-    async blur(options) {
-        await blurElement(this.access, options);
-    }
-    /** Empties an input, textarea or editable element, as `fill("")` does */
-    async clear(options) {
-        await clearElement(this.access, options);
-    }
-    /** Focuses the element and types `text` into it one key press at a time, `delay` ms apart */
-    async pressSequentially(text, options) {
-        await pressSequentially(this.access, text, options);
-    }
-    /**
-     * Checks a checkbox, radio or `role=checkbox|radio|switch` element; does nothing when it is already checked.
-     * Waits like `click`, but a hidden input counts as reachable through its `<label>`, which is what gets clicked.
-     * `trial` waits without clicking. Throws when the click did not change the state.
-     * @example
-     *  await page.getByLabel("I accept the terms").check();
-     */
-    async check(options) {
-        await setChecked(this.access, "check", true, options);
-    }
-    /** Unchecks a checkbox or `role=checkbox|switch` element; does nothing when it is already unchecked. A radio button cannot be unchecked: throws */
-    async uncheck(options) {
-        await setChecked(this.access, "uncheck", false, options);
-    }
-    /** `check()` or `uncheck()`, whichever brings the element to `checked` */
-    async setChecked(checked, options) {
-        await setChecked(this.access, "setChecked", checked, options);
-    }
-    /**
-     * Selects options of a `<select>` or `<select multiple>` (which replaces its selection) and fires `input` and
-     * `change`. A string matches an option's value or its label; `{ value, label, index }` must match every field
-     * given. Waits until the select is visible and enabled and every option exists. Returns the values now selected.
-     * @example
-     *  await page.getByLabel("Country").selectOption("Netherlands");
-     *  await page.locator("select").selectOption([{ index: 0 }, { value: "b" }]);
-     */
-    async selectOption(values, options) {
-        return selectOptions(this.access, values, options);
-    }
-    /**
-     * Sets the files of an `<input type=file>`; `[]` clears it. Paths are relative to the project folder (absolute
-     * ones are used as they are); `generatedFile(…)` writes a file of a given size when the step runs.
-     * Waits for the input to be attached and enabled; it need not be visible, file inputs are often hidden behind a label.
-     * @example
-     *  await page.getByLabel("Avatar").setInputFiles("files/avatar.png");
-     *  await page.getByLabel("Upload").setInputFiles(generatedFile({ name: "huge.pdf", size: "60 MB" }));
-     */
-    async setInputFiles(files, options) {
-        await setInputFiles(this.access, files, options);
-    }
-    /**
-     * Drops files on the element, as dragging them from the desktop does: `dragenter`, `dragover` and `drop`
-     * with a `DataTransfer` holding the files. Takes what `setInputFiles` takes. The events are synthetic
-     * (`isTrusted` is false); a page that only accepts trusted drops ignores them.
-     * Waits for the element to be attached and visible.
-     * @example
-     *  await page.getByTestId("dropzone").dropFiles(["files/a.png", "files/b.png"]);
-     */
-    async dropFiles(files, options) {
-        await dropFiles(this.access, files, options);
-    }
-    /**
-     * Takes a screenshot of just this element, after scrolling it into view and waiting until it is attached and
-     * visible. Returns the image (also written to `options.path`).
-     * @example
-     *  await page.locator("div[@id='chart']").screenshot({ path: "out/chart.png" });
-     */
-    async screenshot(options = {}) {
-        return screenshotElement(this.access, options);
-    }
-    /** Waits until the element is attached, then focuses it */
-    async focus(options) {
-        await focusElement(this.access, options);
-    }
-    /** Waits until the element reaches `state` (default "visible"); does not scroll */
-    async waitFor(options = {}) {
-        await waitForState(this.actionability, options);
-    }
-    /** Returns the browser's getBoundingClientRect result for the given element */
-    async getBoundingClientRect() {
-        return readBoundingClientRect(this.access);
-    }
-    /** Whether the element exists, has a non-empty box and is not hidden by CSS */
-    async isVisible() {
-        return readIsVisible(this.actionability);
-    }
-    /** The opposite of `isVisible`: true for a hidden element and for one that is not there */
-    async isHidden() {
-        return !(await this.isVisible());
-    }
-    /** Trimmed text content, or null when the element is missing */
-    async textContent() {
-        return readTextContent(this.access);
-    }
-    /** Rendered text of the element (as a person would copy it, hidden text left out), untrimmed, or null when the element is missing */
-    async innerText() {
-        return readInnerText(this.access);
-    }
-    /** The markup inside the element, or null when the element is missing */
-    async innerHTML() {
-        return readInnerHTML(this.access);
-    }
-    /** `textContent` of every match, as the page has it (untrimmed, unlike `textContent()`); `[]` when none match. Does not wait */
-    async allTextContents() {
-        return readAllTextContents(this.access);
-    }
-    /** `innerText` of every match; `[]` when none match. Does not wait */
-    async allInnerTexts() {
-        return readAllInnerTexts(this.access);
-    }
-    /** The element's box in CSS pixels from the viewport's top left, or null when it is missing or not rendered (`display: none`). Does not wait or scroll */
-    async boundingBox() {
-        return readBoundingBox(this.access);
-    }
-    /**
-     * Waits until the element is attached (hidden is fine), then calls `fn(element, arg)` in the page and returns the result
-     * (see `page.evaluate` for what comes back). `fn` is a function or the source of one; a strict locator throws when several match.
-     * @example
-     *  const id = await page.getByTestId("row").evaluate((el) => el.dataset.id);
-     */
-    async evaluate(fn, arg, options) {
-        return evaluateOnElement(this.access, fn, arg, options);
-    }
-    /** Calls `fn(elements, arg)` in the page with an array of every match (empty when none; does not wait) and returns the result */
-    async evaluateAll(fn, arg) {
-        return evaluateOnAll(this.access, fn, arg);
-    }
-    /** Value of an input/textarea/select, or null when missing */
-    async inputValue() {
-        return readInputValue(this.access);
-    }
-    /** Attribute value, or null when the element or attribute is missing */
-    async getAttribute(name) {
-        return readAttribute(this.access, name);
-    }
     /** References to the elements currently matching, in document order. Internal: for tooling that identifies elements */
     async elements() {
         return this.resolve();
@@ -441,60 +274,8 @@ export default class Locator {
     async count() {
         return (await this.resolve()).length;
     }
-    /** Whether the element exists and is not disabled; does not wait */
-    async isEnabled() {
-        return readIsEnabled(this.actionability);
-    }
-    /** The opposite of `isEnabled`: true for a disabled element and for one that is not there; does not wait */
-    async isDisabled() {
-        return !(await this.isEnabled());
-    }
-    /** Like `isEnabled`, but null when the element is missing, so callers can tell "disabled" from "not there"; does not wait */
-    async enabledState() {
-        return readEnabledState(this.actionability);
-    }
-    /** Whether a checkbox or radio input is checked or the element has `aria-checked="true"`; null when the element is missing */
-    async isChecked() {
-        return readIsChecked(this.access);
-    }
-    /** The accessible name (what `getByRole`'s `name` is matched against), "" when there is none, or null when the element is missing */
-    async accessibleName() {
-        return readAccessibleName(this.access);
-    }
-    /** The accessible description (`aria-describedby`, `aria-description`, else `title` when it is not the name), or null when the element is missing */
-    async accessibleDescription() {
-        return readAccessibleDescription(this.access);
-    }
-    /** The class attribute as written ("" when the element has none), or null when the element is missing */
-    async classAttribute() {
-        return readClassAttribute(this.access);
-    }
-    /** Computed value of a CSS property (camelCase names become kebab-case, `--custom` is kept), or null when the element is missing */
-    async cssValue(name) {
-        return readCssValue(this.access, name);
-    }
-    /** Whether the element exists and accepts typing (enabled, not readonly, a text field); does not wait */
-    async isEditable() {
-        return readIsEditable(this.actionability);
-    }
     /** Wait for certain time (ms). Default: 300ms  */
     async wait(duration = DEFAULT_PAUSE_MS) {
         await pause(this.biDiConnector, this.contextId, duration);
     }
-    /**
-     * Waits until the element is attached, visible and enabled, focuses it and presses `key` with real keyboard input.
-     * Named keys are `Enter`, `Escape`, `Tab`, `Backspace`, `Delete`, `Space`, `Insert`, `Home`, `End`, `PageUp`, `PageDown`,
-     * `F1` to `F12` and the arrows; any other key must be a single character. A chord holds modifiers (`Control`, `Shift`,
-     * `Alt`, `Meta`, `ControlOrMeta`) while the last key is pressed.
-     * @example
-     *  await page.getByLabel("New todo").press("Enter");
-     *  await page.getByLabel("Name").press("Control+a");
-     */
-    async press(key, options) {
-        await pressOnElement(this.access, key, options);
-    }
-    /** Waits until the field is editable and not covered, then replaces its value by typing `value`; an empty string clears it */
-    async fill(value, options) {
-        await fillElement(this.access, value, options);
-    }
 }

package/dist/request/api-request-context.js

@@ -90,7 +90,7 @@ export class APIRequestContext {
             if (cookie)
                 sent.cookie = sent.cookie ? `${sent.cookie}; ${cookie}` : cookie;
             const remaining = deadline > 0 ? Math.max(1, deadline - Date.now()) : 0;
-            const hop = await this.hop({ url, method, headers: sent, body }, options, remaining, abort.signal);
+            const hop = await this.hop({ url, method, headers: sent, body, budget: timeout }, options, remaining, abort.signal);
             if (hop.setCookies.length > 0)
                 await this.cookies.store(url, hop.setCookies);
             const location = hop.headers.find((h) => h.name.toLowerCase() === "location")?.value;

package/dist/request/http-transport.d.ts

@@ -9,6 +9,8 @@ export interface HopRequest {
     ignoreHTTPSErrors: boolean;
     /** Milliseconds this hop may take; 0 is no limit */
     timeout: number;
+    /** The timeout the caller set for the whole request, which the timeout message names (`timeout` is what is left of it) */
+    budget?: number | undefined;
     signal: AbortSignal;
 }
 export interface HopResponse {

package/dist/request/http-transport.js

@@ -104,7 +104,7 @@ export function sendHop(request) {
             request.timeout > 0
                 ? setTimeout(() => {
                     req.destroy();
-                    finish(new TransportError(`timed out after ${request.timeout}ms (${where})`, "ETIMEDOUT"));
+                    finish(new TransportError(`timed out after ${request.budget ?? request.timeout}ms (${where})`, "ETIMEDOUT"));
                 }, request.timeout)
                 : undefined;
         req.on("error", (err) => finish(new TransportError(`${err.code ?? err.message} (${where})`, err.code)));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itmetsam/samurai-framework",
-  "version": "0.22.9",
+  "version": "0.22.11",
   "description": "Browser test framework over WebDriver BiDi: auto-waiting locators, environments and secrets, a recorder, and a command line.",
   "main": "dist/api.js",
   "exports": {