@itmetsam/samurai-framework 0.9.0 → 0.12.0

package/dist/locator/locator.js

@@ -1,103 +1,14 @@
 import { BiDiError } from "../transport/bidi-error.js";
 import { callFunction, ScriptError } from "../script/call-function.js";
-import { CALL_PROBE, HELPER_SANDBOX, HELPERS_MISSING, } from "../script/helpers.js";
 import { ElementHandle } from "../script/element-handle.js";
 import { takeScreenshot, } from "../browser/screenshot.js";
-import { isGeneratedFile, resolveFileInputs, } from "../browser/generated-files.js";
-import { resolveTimeout, waitUntil, WaitTimeoutError, } from "../wait/wait-until.js";
-import { ActionTimeoutError } from "./action-timeout-error.js";
-import { allPass, DETACHED_STATE, evaluateChecks, parseElementState, PROBE_ELEMENT, } from "./element-state.js";
-import { InvalidSelectorError, UnsupportedOperationError, } from "./selector-errors.js";
-import { LABEL_LOCATE } from "./label-locator.js";
-import { TEXT_LOCATE } from "./text-locator.js";
-import { cssSelector, describeChain, describeSelector, labelSelector, roleSelector, testIdSelector, textSelector, toBiDiLocator, xpathSelector, } from "./selector.js";
-export { InvalidSelectorError, UnsupportedOperationError, } from "./selector-errors.js";
-/** Locator types a connection's browser rejected, so they are not tried again on every poll */
-const unsupportedByConnector = new WeakMap();
-function unsupportedTypes(connector) {
-    let types = unsupportedByConnector.get(connector);
-    if (!types)
-        unsupportedByConnector.set(connector, (types = new Set()));
-    return types;
-}
-/** What `setInputFiles` needs to know about the element before it sends files */
-const FILE_INPUT_INFO = `(el) => ({
-  tag: el.tagName.toLowerCase(),
-  type: (el.getAttribute("type") || "").toLowerCase(),
-  multiple: Boolean(el.multiple),
-})`;
-const FILE_INPUT_CHECKS = ["attached", "enabled"];
-const DROP_CHECKS = ["attached", "visible"];
-/** The sandbox `dropFiles` builds its files in */
-const DROP_SANDBOX = "samurai-drop";
-const DROP_KEY = `globalThis[Symbol.for("samurai.drop")]`;
-const DROP_INPUT = `() => {
-  const input = document.createElement("input");
-  input.type = "file";
-  input.multiple = true;
-  ${DROP_KEY} = input;
-  return input;
-}`;
-/** Fires dragenter, dragover and drop at the element's centre with the input's files (retyped where asked) */
-const DROP_EVENTS = `(el, types) => {
-  const input = ${DROP_KEY};
-  delete ${DROP_KEY};
-  const data = new DataTransfer();
-  Array.from(input.files).forEach((file, i) => {
-    data.items.add(types[i] ? new File([file], file.name, { type: types[i], lastModified: file.lastModified }) : file);
-  });
-  const box = el.getBoundingClientRect();
-  const at = { clientX: box.left + box.width / 2, clientY: box.top + box.height / 2 };
-  for (const type of ["dragenter", "dragover", "drop"]) {
-    el.dispatchEvent(new DragEvent(type, Object.assign({ bubbles: true, cancelable: true, composed: true, dataTransfer: data }, at)));
-  }
-}`;
-const SCREENSHOT_CHECKS = ["attached", "visible"];
-const CLICK_CHECKS = [
-    "attached",
-    "visible",
-    "stable",
-    "enabled",
-    "hit target",
-];
-const FILL_CHECKS = [
-    "attached",
-    "visible",
-    "enabled",
-    "editable",
-    "hit target",
-];
-const PRESS_CHECKS = ["attached", "visible", "enabled"];
-const ATTACHED_ONLY = ["attached"];
-/** WebDriver code points of the named keys `press()` accepts; any other single character is typed as is */
-const NAMED_KEYS = {
-    Backspace: "\uE003",
-    Tab: "\uE004",
-    Enter: "\uE007",
-    Escape: "\uE00C",
-    Space: " ",
-    ArrowLeft: "\uE012",
-    ArrowUp: "\uE013",
-    ArrowRight: "\uE014",
-    ArrowDown: "\uE015",
-    Delete: "\uE017",
-    Home: "\uE011",
-    End: "\uE010",
-    PageUp: "\uE00E",
-    PageDown: "\uE00F",
-};
-/** Unicode code point WebDriver uses for the Backspace key */
-const BACKSPACE = "";
-/**
- * Chrome answers a command sent while the page swaps documents with an unknown error that says the context
- * is gone for the moment; the same call a moment later works.
- */
-const DOCUMENT_SWAP = /Cannot find context with specified id|execution contexts? (was |were )?(cleared|destroyed)/i;
-function isDocumentSwap(err) {
-    return (err instanceof BiDiError &&
-        err.code === "unknown error" &&
-        DOCUMENT_SWAP.test(err.message));
-}
+import { probeState, waitForActionable, waitForState, } from "./actionability.js";
+import { ChainResolver } from "./chain-resolver.js";
+import { dropFiles, setInputFiles, } from "./file-actions.js";
+import { describeType, } from "./element-state.js";
+import { clickRect, DEFAULT_PAUSE_MS, NAMED_KEYS, pause, pressKey, typeText, } from "./input-actions.js";
+import { CLICK_CHECKS, FILL_CHECKS, PRESS_CHECKS, SCREENSHOT_CHECKS, ATTACHED_ONLY, } from "./page-scripts.js";
+import { cssSelector, describeChain, describeSelector, labelSelector, roleSelector, testIdSelector, textSelector, xpathSelector, } from "./selector.js";
 export default class Locator {
     /**
      * `selector` is an xpath, or a chain of selector steps that each search inside the previous step's matches.
@@ -112,6 +23,27 @@ export default class Locator {
         this.contextId = contextId;
         this.helpers = helpers;
         this.alternatives = alternatives;
+        const locator = this;
+        this.actionability = {
+            resolveOne: () => this.resolveOne(),
+            call: (fn, args, sandbox) => this.call(fn, args, sandbox),
+            get selector() {
+                return locator.selector;
+            },
+            helpers,
+        };
+        this.elementContext = {
+            connector: biDiConnector,
+            contextId,
+            get selector() {
+                return locator.selector;
+            },
+            call: (fn, args, sandbox) => this.call(fn, args, sandbox),
+            waitForActionable: (action, checks, probe, options) => this.waitForActionable(action, checks, probe, options),
+            requireElement: () => this.requireElement(),
+            noElementError: () => this.noElementError(),
+        };
+        this.resolver = new ChainResolver(biDiConnector, contextId, (fn, args, sandbox) => this.call(fn, args, sandbox));
     }
     /**
      * The description of this locator used in error messages, e.g. `//form >> role=button[name="Save"]`;
@@ -190,7 +122,7 @@ export default class Locator {
      */
     async resolve(max) {
         this.matched = undefined;
-        const own = await this.resolveChain(max);
+        const own = await this.resolver.resolveChain(this.chain, max);
         if (own.length > 0) {
             this.matched = { index: 0, selector: describeChain(this.chain) };
             return own;
@@ -206,7 +138,7 @@ export default class Locator {
     }
     /** The primary or the first fallback that currently matches, without its own fallbacks */
     async firstMatching() {
-        if ((await this.resolveChain(1)).length > 0)
+        if ((await this.resolver.resolveChain(this.chain, 1)).length > 0)
             return this.withoutFallbacks();
         for (const alternative of this.alternatives) {
             const found = await alternative.firstMatching();
@@ -218,90 +150,9 @@ export default class Locator {
     withoutFallbacks() {
         return new Locator(this.chain, this.biDiConnector, this.contextId, this.helpers);
     }
-    async resolveChain(max) {
-        let nodes;
-        for (const [index, selector] of this.chain.entries()) {
-            if (selector.kind === "nth") {
-                const picked = nodes?.[selector.index];
-                nodes = picked ? [picked] : [];
-            }
-            else {
-                try {
-                    nodes = await this.locateStep(selector, index > 0, nodes, index === this.chain.length - 1 ? max : undefined);
-                }
-                catch (err) {
-                    // The page is swapping documents: nothing matches right now, and the waits that poll try again
-                    if (isDocumentSwap(err))
-                        return [];
-                    throw err;
-                }
-            }
-            if (nodes.length === 0)
-                return [];
-        }
-        return nodes ?? [];
-    }
     async resolveOne() {
         return (await this.resolve(1))[0] ?? null;
     }
-    async locateStep(selector, scoped, startNodes, max) {
-        if (selector.kind === "label")
-            return this.locateInPage(LABEL_LOCATE, selector, startNodes, max);
-        if (selector.kind === "text" &&
-            unsupportedTypes(this.biDiConnector).has("innerText")) {
-            return this.locateByText(selector, startNodes, max);
-        }
-        try {
-            return await this.locateNatively(selector, scoped, startNodes, max);
-        }
-        catch (err) {
-            if (err instanceof BiDiError && err.code === "invalid selector") {
-                throw new InvalidSelectorError(describeSelector(selector, scoped), err.message);
-            }
-            if (err instanceof BiDiError && err.code === "unsupported operation") {
-                if (selector.kind === "text") {
-                    // The browser has no innerText locator (Firefox): remember that and search in the page instead
-                    unsupportedTypes(this.biDiConnector).add("innerText");
-                    return this.locateByText(selector, startNodes, max);
-                }
-                throw new UnsupportedOperationError(`${describeSelector(selector, scoped)}: this kind of locator is not supported by the browser (${err.message})`);
-            }
-            throw err;
-        }
-    }
-    async locateNatively(selector, scoped, startNodes, max) {
-        const { nodes } = await this.biDiConnector.send("browsingContext.locateNodes", {
-            context: this.contextId,
-            locator: toBiDiLocator(selector, scoped),
-            ...(max !== undefined && { maxNodeCount: max }),
-            // Only the references are needed; skip serializing the matched subtrees
-            serializationOptions: { maxDomDepth: 0 },
-            ...(startNodes && {
-                startNodes: startNodes.map(({ sharedId }) => ({ sharedId })),
-            }),
-        });
-        const found = new Map();
-        for (const node of nodes) {
-            if (node.sharedId !== undefined && !found.has(node.sharedId)) {
-                found.set(node.sharedId, new ElementHandle(node.sharedId, node.handle));
-            }
-        }
-        return [...found.values()];
-    }
-    /** Text search done in the page, for browsers without BiDi's innerText locator */
-    locateByText(selector, startNodes, max) {
-        return this.locateInPage(TEXT_LOCATE, selector, startNodes, max);
-    }
-    /** Runs a page-side search `(starts, value, match, ignoreCase) => elements` */
-    async locateInPage(fn, selector, startNodes, max) {
-        const found = await this.call(fn, [
-            startNodes ?? [],
-            selector.value,
-            selector.match,
-            selector.ignoreCase,
-        ]);
-        return max === undefined ? found : found.slice(0, max);
-    }
     /** Calls `fn` in the page; a throwing function becomes a "Failed to locate element" error */
     async call(fn, args, sandbox) {
         try {
@@ -338,120 +189,32 @@ export default class Locator {
     async callOnExistingElement(body) {
         const missing = Symbol("missing");
         const result = await this.callOnElement(missing, body);
-        if (result === missing) {
-            throw new Error(`Failed to locate element ${this.selector}. Details: no element matches`);
-        }
+        if (result === missing)
+            throw this.noElementError();
         return result;
     }
-    /** Reads the element's actionability state: one search, one probe */
-    async probeState(options) {
+    /** The error for an operation that needs an element when none matches */
+    noElementError() {
+        return new Error(`Failed to locate element ${this.selector}. Details: no element matches`);
+    }
+    /** The element the locator matches now; throws when none does */
+    async requireElement() {
         const el = await this.resolveOne();
         if (!el)
-            return DETACHED_STATE;
-        try {
-            return parseElementState(await this.callProbe(el, options));
-        }
-        catch (err) {
-            // The document changed between the search and the probe
-            if ((err instanceof BiDiError && err.code === "no such node") ||
-                isDocumentSwap(err))
-                return DETACHED_STATE;
-            throw err;
-        }
+            throw this.noElementError();
+        return el;
     }
-    async callProbe(el, options) {
-        const args = [el, { ...options }];
-        if (!this.helpers)
-            return this.call(PROBE_ELEMENT, args);
-        await this.helpers.ensureInstalled();
-        let result = await this.call(CALL_PROBE, args, HELPER_SANDBOX);
-        if (result === HELPERS_MISSING) {
-            // A document got past the registration (e.g. created while it was being set up): install again once
-            await this.helpers.reinstall();
-            result = await this.call(CALL_PROBE, args, HELPER_SANDBOX);
-            if (result === HELPERS_MISSING) {
-                throw new ScriptError("the samurai helpers are missing in the page after reinstalling", "probeElement");
-            }
-        }
-        return result;
+    probeState(options) {
+        return probeState(this.actionability, options);
     }
-    /**
-     * Probes until every required check passes and returns that state.
-     * Throws ActionTimeoutError describing the last probe on timeout.
-     */
-    async waitForActionable(action, checks, probe, options) {
-        const timeout = await resolveTimeout(options?.timeout);
-        // Stability compares two probes; with timeout 0 there is only one
-        const required = options?.force
-            ? ATTACHED_ONLY
-            : timeout === 0
-                ? checks.filter((check) => check !== "stable")
-                : checks;
-        let lastChecks;
-        try {
-            return await waitUntil(() => this.probeState(probe), (current, previous) => {
-                lastChecks = evaluateChecks(required, current, previous);
-                return allPass(lastChecks);
-            }, { timeout });
-        }
-        catch (err) {
-            if (!(err instanceof WaitTimeoutError))
-                throw err;
-            const last = err.last;
-            throw new ActionTimeoutError({
-                action,
-                selector: this.selector,
-                timeout,
-                reason: !last
-                    ? "unreadable"
-                    : last.attached
-                        ? "not-actionable"
-                        : "not-attached",
-                checks: lastChecks,
-                coveredBy: lastChecks?.["hit target"] === "fail"
-                    ? (last?.hitTarget ?? undefined)
-                    : undefined,
-            });
-        }
+    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 its centre with real pointer input */
     async click(options) {
         const state = await this.waitForActionable("click", CLICK_CHECKS, { scroll: true, hitTest: true }, options);
         // "attached" is always required, so the box is present
-        await this.clickRect(state.box);
-    }
-    /** Simulate a click event on the center off a page element.
-     * This is mostly used internally to focus input elements when using the `fill()` method
-     * @example
-     *  const container = page.locator("div[@id=['clickable-element']");
-     *  const rect = await container.getBoundingClientRect();
-     *  await container.clickRect(rect);
-     */
-    async clickRect(rect) {
-        await this.biDiConnector.send("input.performActions", {
-            context: this.contextId,
-            actions: [
-                {
-                    type: "pointer",
-                    id: "samurai-pointer",
-                    actions: [
-                        {
-                            type: "pointerMove",
-                            x: rect.x + rect.width / 2,
-                            y: rect.y + rect.height / 2,
-                        },
-                        {
-                            type: "pointerDown",
-                            button: 0,
-                        },
-                        {
-                            type: "pointerUp",
-                            button: 0,
-                        },
-                    ],
-                },
-            ],
-        });
+        await clickRect(this.biDiConnector, this.contextId, state.box);
     }
     /**
      * Sets the files of an `<input type=file>`; `[]` clears it. Paths are relative to the project folder (absolute
@@ -462,35 +225,7 @@ export default class Locator {
      *  await page.getByLabel("Upload").setInputFiles(generatedFile({ name: "huge.pdf", size: "60 MB" }));
      */
     async setInputFiles(files, options) {
-        const paths = await resolveFileInputs(files, "setInputFiles");
-        await this.waitForActionable("setInputFiles", FILE_INPUT_CHECKS, { scroll: false, hitTest: false }, options?.timeout === undefined ? undefined : { timeout: options.timeout });
-        const missing = () => new Error(`Failed to locate element ${this.selector}. Details: no element matches`);
-        const el = await this.resolveOne();
-        if (!el)
-            throw missing();
-        let info;
-        try {
-            info = await this.call(FILE_INPUT_INFO, [el]);
-        }
-        catch (err) {
-            if (err instanceof BiDiError && err.code === "no such node")
-                throw missing();
-            throw err;
-        }
-        if (info.tag !== "input" || info.type !== "file") {
-            const found = info.tag === "input"
-                ? `<input type="${info.type || "text"}">`
-                : `<${info.tag}>`;
-            throw new Error(`setInputFiles(): ${this.selector} is not an <input type=file> (found ${found})`);
-        }
-        if (paths.length > 1 && !info.multiple) {
-            throw new Error(`setInputFiles(): ${this.selector} does not accept multiple files`);
-        }
-        await this.biDiConnector.send("input.setFiles", {
-            context: this.contextId,
-            element: { sharedId: el.sharedId },
-            files: paths,
-        });
+        await setInputFiles(this.elementContext, files, options);
     }
     /**
      * Drops files on the element, as dragging them from the desktop does: `dragenter`, `dragover` and `drop`
@@ -501,21 +236,7 @@ export default class Locator {
      *  await page.getByTestId("dropzone").dropFiles(["files/a.png", "files/b.png"]);
      */
     async dropFiles(files, options) {
-        const list = Array.isArray(files) ? files : [files];
-        const paths = await resolveFileInputs(list, "dropFiles");
-        const types = list.map((file) => isGeneratedFile(file) ? (file.type ?? "") : "");
-        await this.waitForActionable("dropFiles", DROP_CHECKS, { scroll: true, hitTest: false }, options?.timeout === undefined ? undefined : { timeout: options.timeout });
-        const el = await this.resolveOne();
-        if (!el)
-            throw new Error(`Failed to locate element ${this.selector}. Details: no element matches`);
-        // A file input of our own, made in a sandbox and never attached: the page doesn't see it
-        const input = await this.call(DROP_INPUT, [], DROP_SANDBOX);
-        await this.biDiConnector.send("input.setFiles", {
-            context: this.contextId,
-            element: { sharedId: input.sharedId },
-            files: paths,
-        });
-        await this.call(DROP_EVENTS, [el, types], DROP_SANDBOX);
+        await dropFiles(this.elementContext, files, options);
     }
     /**
      * Takes a screenshot of just this element, after scrolling it into view and waiting until it is attached and
@@ -526,10 +247,7 @@ export default class Locator {
     async screenshot(options = {}) {
         const { timeout, ...capture } = options;
         await this.waitForActionable("screenshot", SCREENSHOT_CHECKS, { scroll: true, hitTest: false }, timeout === undefined ? undefined : { timeout });
-        const el = await this.resolveOne();
-        if (!el) {
-            throw new Error(`Failed to locate element ${this.selector}. Details: no element matches`);
-        }
+        const el = await this.requireElement();
         return takeScreenshot(this.biDiConnector, this.contextId, capture, {
             sharedId: el.sharedId,
         });
@@ -540,30 +258,8 @@ export default class Locator {
         await this.callOnExistingElement(`el.focus();`);
     }
     /** Waits until the element reaches `state` (default "visible"); does not scroll */
-    async waitFor({ state = "visible", timeout, } = {}) {
-        const resolved = await resolveTimeout(timeout);
-        const reached = {
-            attached: (current) => current.attached,
-            detached: (current) => !current.attached,
-            visible: (current) => current.attached && current.visible,
-            hidden: (current) => !current.attached || !current.visible,
-        };
-        try {
-            await waitUntil(() => this.probeState({ scroll: false, hitTest: false }), reached[state], {
-                timeout: resolved,
-            });
-        }
-        catch (err) {
-            if (!(err instanceof WaitTimeoutError))
-                throw err;
-            throw new ActionTimeoutError({
-                action: "waitFor",
-                selector: this.selector,
-                timeout: resolved,
-                reason: err.last === undefined ? "unreadable" : "wrong-state",
-                state,
-            });
-        }
+    async waitFor(options = {}) {
+        await waitForState(this.actionability, options);
     }
     /** Returns the browser's getBoundingClientRect result for the given element */
     async getBoundingClientRect() {
@@ -576,34 +272,22 @@ export default class Locator {
         }
         return rect;
     }
-    stringOrNull(value) {
-        if (typeof value === "string")
-            return value;
-        if (value === null)
-            return null;
-        throw new Error(`Expected a string or null but received "${describeType(value)}"`);
-    }
     /** Whether the element exists, has a non-empty box and is not hidden by CSS */
     async isVisible() {
-        const result = await this.callOnElement(false, `
-      const rect = el.getBoundingClientRect();
-      const style = getComputedStyle(el);
-      return rect.width > 0 && rect.height > 0 &&
-        style.display !== "none" && style.visibility !== "hidden" && style.opacity !== "0";
-    `);
-        return result === true;
+        const state = await this.probeState({ scroll: false, hitTest: false });
+        return state.attached && state.visible;
     }
     /** Trimmed text content, or null when the element is missing */
     async textContent() {
-        return this.stringOrNull(await this.callOnElement(null, `return el.textContent.trim();`));
+        return stringOrNull(await this.callOnElement(null, `return el.textContent.trim();`));
     }
     /** Value of an input/textarea/select, or null when missing */
     async inputValue() {
-        return this.stringOrNull(await this.callOnElement(null, `return typeof el.value === "string" ? el.value : null;`));
+        return stringOrNull(await this.callOnElement(null, `return typeof el.value === "string" ? el.value : null;`));
     }
     /** Attribute value, or null when the element or attribute is missing */
     async getAttribute(name) {
-        return this.stringOrNull(await this.callOnElement(null, `return el.getAttribute(name);`, ["name"], [name]));
+        return stringOrNull(await this.callOnElement(null, `return el.getAttribute(name);`, ["name"], [name]));
     }
     /** References to the elements currently matching, in document order. Internal: for tooling that identifies elements */
     async elements() {
@@ -624,22 +308,8 @@ export default class Locator {
         return state.attached && state.editable;
     }
     /** Wait for certain time (ms). Default: 300ms  */
-    async wait(duration = 300) {
-        await this.biDiConnector.send("input.performActions", {
-            context: this.contextId,
-            actions: [
-                {
-                    type: "none",
-                    id: "samurai-sleep",
-                    actions: [
-                        {
-                            type: "pause",
-                            duration,
-                        },
-                    ],
-                },
-            ],
-        });
+    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.
@@ -655,50 +325,24 @@ export default class Locator {
         }
         await this.waitForActionable("press", PRESS_CHECKS, { scroll: true, hitTest: false }, options);
         await this.callOnElement(undefined, `el.focus();`);
-        await this.biDiConnector.send("input.performActions", {
-            context: this.contextId,
-            actions: [
-                {
-                    type: "key",
-                    id: "samurai-keyboard",
-                    actions: [
-                        { type: "keyDown", value: code },
-                        { type: "keyUp", value: code },
-                    ],
-                },
-            ],
-        });
+        await pressKey(this.biDiConnector, this.contextId, code);
     }
     /** 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) {
         const state = await this.waitForActionable("fill", FILL_CHECKS, { scroll: true, hitTest: true }, options);
         // Typing over the selected existing value replaces it; Backspace clears it for an empty value
-        const keys = value === "" ? BACKSPACE : value;
-        const actions = Array.from(keys).flatMap((char) => [
-            {
-                type: "keyDown",
-                value: char,
-            },
-            {
-                type: "keyUp",
-                value: char,
-            },
-        ]);
-        await this.clickRect(state.box);
+        const keys = value === "" ? NAMED_KEYS.Backspace : value;
+        await clickRect(this.biDiConnector, this.contextId, state.box);
+        // Lets the focus the click caused (and the page's focus handlers) settle before the text is selected and typed over
         await this.wait();
         await this.callOnElement(undefined, `if (typeof el.select === "function") el.select();`);
-        await this.biDiConnector.send("input.performActions", {
-            context: this.contextId,
-            actions: [
-                {
-                    actions,
-                    type: "key",
-                    id: "samurai-keyboard",
-                },
-            ],
-        });
+        await typeText(this.biDiConnector, this.contextId, keys);
     }
 }
-function describeType(value) {
-    return value === null ? "null" : typeof value;
+function stringOrNull(value) {
+    if (typeof value === "string")
+        return value;
+    if (value === null)
+        return null;
+    throw new Error(`Expected a string or null but received "${describeType(value)}"`);
 }

package/dist/locator/page-scripts.d.ts

@@ -0,0 +1,16 @@
+import type { CheckName } from "./element-state.js";
+/** Page-side source strings and the actionability checks each action waits for */
+/** What `setInputFiles` needs to know about the element before it sends files */
+export declare const FILE_INPUT_INFO = "(el) => ({\n  tag: el.tagName.toLowerCase(),\n  type: (el.getAttribute(\"type\") || \"\").toLowerCase(),\n  multiple: Boolean(el.multiple),\n})";
+export declare const FILE_INPUT_CHECKS: readonly CheckName[];
+export declare const DROP_CHECKS: readonly CheckName[];
+/** The sandbox `dropFiles` builds its files in */
+export declare const DROP_SANDBOX = "samurai-drop";
+export declare const DROP_INPUT = "() => {\n  const input = document.createElement(\"input\");\n  input.type = \"file\";\n  input.multiple = true;\n  globalThis[Symbol.for(\"samurai.drop\")] = input;\n  return input;\n}";
+/** Fires dragenter, dragover and drop at the element's centre with the input's files (retyped where asked) */
+export declare const DROP_EVENTS = "(el, types) => {\n  const input = globalThis[Symbol.for(\"samurai.drop\")];\n  delete globalThis[Symbol.for(\"samurai.drop\")];\n  const data = new DataTransfer();\n  Array.from(input.files).forEach((file, i) => {\n    data.items.add(types[i] ? new File([file], file.name, { type: types[i], lastModified: file.lastModified }) : file);\n  });\n  const box = el.getBoundingClientRect();\n  const at = { clientX: box.left + box.width / 2, clientY: box.top + box.height / 2 };\n  for (const type of [\"dragenter\", \"dragover\", \"drop\"]) {\n    el.dispatchEvent(new DragEvent(type, Object.assign({ bubbles: true, cancelable: true, composed: true, dataTransfer: data }, at)));\n  }\n}";
+export declare const SCREENSHOT_CHECKS: readonly CheckName[];
+export declare const CLICK_CHECKS: readonly CheckName[];
+export declare const FILL_CHECKS: readonly CheckName[];
+export declare const PRESS_CHECKS: readonly CheckName[];
+export declare const ATTACHED_ONLY: readonly CheckName[];