@itmetsam/samurai-framework 0.1.0 → 0.2.0

package/src/browser/emulation.test.ts

@@ -1,200 +0,0 @@
-import assert from "node:assert/strict";
-import { afterEach, describe, it } from "node:test";
-import { UnsupportedOperationError } from "../locator/selector-errors.js";
-import { autoReply, FakeWebSocket } from "../testing/fake-websocket.js";
-import { BiDiConnector } from "../transport/bidi-connection.js";
-import { applyEmulation, EmulationError, type EmulationOptions } from "./emulation.js";
-
-const stops: Array<() => void> = [];
-afterEach(() => stops.splice(0).forEach((stop) => stop()));
-
-const failing = (code: string, message = "nope") => Object.assign(new Error(message), { code });
-
-function setup(handlers: Record<string, (params: any) => object | Error> = {}) {
-  const ws = new FakeWebSocket();
-  const connector = new BiDiConnector(ws as unknown as WebSocket);
-  stops.push(autoReply(ws, handlers));
-  const sent = () => ws.sent.map((m) => [m.method, m.params] as [string, any]);
-  return { ws, connector, sent };
-}
-const PAGE = { contexts: ["ctx-1"] };
-
-describe("applyEmulation: what each option sends", () => {
-  const cases: Array<[string, EmulationOptions, string, object]> = [
-    ["locale", { locale: "nl-NL" }, "emulation.setLocaleOverride", { locale: "nl-NL" }],
-    ["timezone", { timezone: "Europe/Amsterdam" }, "emulation.setTimezoneOverride", { timezone: "Europe/Amsterdam" }],
-    ["userAgent", { userAgent: "Samurai/1.0" }, "emulation.setUserAgentOverride", { userAgent: "Samurai/1.0" }],
-    [
-      "geolocation",
-      { geolocation: { latitude: 52.37, longitude: 4.9, accuracy: 10 } },
-      "emulation.setGeolocationOverride",
-      { coordinates: { latitude: 52.37, longitude: 4.9, accuracy: 10 } },
-    ],
-    [
-      "geolocation without accuracy",
-      { geolocation: { latitude: 1, longitude: 2 } },
-      "emulation.setGeolocationOverride",
-      { coordinates: { latitude: 1, longitude: 2 } },
-    ],
-    ["offline", { offline: true }, "emulation.setNetworkConditions", { networkConditions: { type: "offline" } }],
-    [
-      "orientation",
-      { orientation: "portrait" },
-      "emulation.setScreenOrientationOverride",
-      { screenOrientation: { natural: "portrait", type: "portrait-primary" } },
-    ],
-    [
-      "orientation (full type)",
-      { orientation: "landscape-secondary" },
-      "emulation.setScreenOrientationOverride",
-      { screenOrientation: { natural: "landscape", type: "landscape-secondary" } },
-    ],
-    ["screen", { screen: { width: 800, height: 600 } }, "emulation.setScreenSettingsOverride", { screenArea: { width: 800, height: 600 } }],
-    ["touch", { touch: 5 }, "emulation.setTouchOverride", { maxTouchPoints: 5 }],
-    ["javaScriptEnabled false", { javaScriptEnabled: false }, "emulation.setScriptingEnabled", { enabled: false }],
-  ];
-  for (const [name, options, method, params] of cases) {
-    it(`${name} → ${method}`, async () => {
-      const { connector, sent } = setup();
-      await applyEmulation(connector, PAGE, options);
-      assert.deepEqual(sent(), [[method, { ...params, ...PAGE }]]);
-    });
-  }
-});
-
-describe("applyEmulation: resetting", () => {
-  it("null puts the real value back", async () => {
-    const { connector, sent } = setup();
-    await applyEmulation(connector, PAGE, {
-      locale: null,
-      timezone: null,
-      userAgent: null,
-      geolocation: null,
-      offline: null,
-      orientation: null,
-      screen: null,
-      touch: null,
-      javaScriptEnabled: null,
-    });
-    assert.deepEqual(sent().map(([method, params]) => [method, Object.values(params).filter((v) => v === null).length]), [
-      ["emulation.setLocaleOverride", 1],
-      ["emulation.setTimezoneOverride", 1],
-      ["emulation.setUserAgentOverride", 1],
-      ["emulation.setGeolocationOverride", 1],
-      ["emulation.setNetworkConditions", 1],
-      ["emulation.setScreenOrientationOverride", 1],
-      ["emulation.setScreenSettingsOverride", 1],
-      ["emulation.setTouchOverride", 1],
-      ["emulation.setScriptingEnabled", 1],
-    ]);
-  });
-
-  it("offline false is back online, javaScriptEnabled true is back to the default", async () => {
-    const { connector, sent } = setup();
-    await applyEmulation(connector, PAGE, { offline: false, javaScriptEnabled: true });
-    assert.deepEqual(sent(), [
-      ["emulation.setNetworkConditions", { networkConditions: null, ...PAGE }],
-      ["emulation.setScriptingEnabled", { enabled: null, ...PAGE }],
-    ]);
-  });
-
-  it("undefined leaves an option alone; no options send nothing", async () => {
-    const { connector, sent } = setup();
-    await applyEmulation(connector, PAGE, {});
-    await applyEmulation(connector, PAGE, { locale: undefined, timezone: "UTC" });
-    assert.deepEqual(sent().map(([method]) => method), ["emulation.setTimezoneOverride"]);
-  });
-});
-
-describe("applyEmulation: targets and order", () => {
-  it("a user context target is sent as userContexts", async () => {
-    const { connector, sent } = setup();
-    await applyEmulation(connector, { userContexts: ["u1"] }, { locale: "de-DE" });
-    assert.deepEqual(sent(), [["emulation.setLocaleOverride", { locale: "de-DE", userContexts: ["u1"] }]]);
-  });
-
-  it("options are applied in a fixed order, whatever the order they were given in", async () => {
-    const { connector, sent } = setup();
-    await applyEmulation(connector, PAGE, { offline: true, timezone: "UTC", locale: "en-GB", userAgent: "x" });
-    assert.deepEqual(sent().map(([method]) => method), [
-      "emulation.setLocaleOverride",
-      "emulation.setTimezoneOverride",
-      "emulation.setUserAgentOverride",
-      "emulation.setNetworkConditions",
-    ]);
-  });
-});
-
-describe("applyEmulation: validation happens before anything is sent", () => {
-  const invalid: Array<[string, EmulationOptions, RegExp]> = [
-    ["latitude too big", { geolocation: { latitude: 91, longitude: 0 } }, /latitude must be between -90 and 90/],
-    ["latitude too small", { geolocation: { latitude: -90.5, longitude: 0 } }, /latitude/],
-    ["longitude too big", { geolocation: { latitude: 0, longitude: 181 } }, /longitude must be between -180 and 180/],
-    ["longitude not a number", { geolocation: { latitude: 0, longitude: NaN } }, /longitude/],
-    ["negative accuracy", { geolocation: { latitude: 0, longitude: 0, accuracy: -1 } }, /accuracy must be 0 or more/],
-    ["unknown timezone", { timezone: "Not/AZone" }, /unknown timezone "Not\/AZone"/],
-    ["malformed locale", { locale: "not a locale!" }, /invalid locale "not a locale!"/],
-    ["empty user agent", { userAgent: "" }, /userAgent must not be empty/],
-    ["fractional screen", { screen: { width: 800.5, height: 600 } }, /screen width and height must be positive integers/],
-    ["zero screen", { screen: { width: 0, height: 600 } }, /screen width and height/],
-    ["unknown orientation", { orientation: "diagonal" as never }, /unknown orientation "diagonal"/],
-    ["touch below one", { touch: 0 }, /touch must be a positive integer/],
-    ["fractional touch", { touch: 1.5 }, /touch must be a positive integer/],
-  ];
-  for (const [name, options, message] of invalid) {
-    it(`${name} is a RangeError`, async () => {
-      const { connector, sent } = setup();
-      await assert.rejects(applyEmulation(connector, PAGE, { locale: "en-GB", ...options }), (err: unknown) => {
-        assert.ok(err instanceof RangeError, String(err));
-        assert.match((err as Error).message, message);
-        return true;
-      });
-      assert.deepEqual(sent(), [], "the valid locale was not applied either");
-    });
-  }
-
-  it("accepts UTC offsets as timezones, and locales with extensions", async () => {
-    const { connector, sent } = setup();
-    await applyEmulation(connector, PAGE, { timezone: "Europe/Berlin", locale: "de-DE-u-nu-latn" });
-    assert.equal(sent().length, 2);
-  });
-});
-
-describe("applyEmulation: when the browser refuses", () => {
-  it("a command the browser does not know is UnsupportedOperationError naming the option, with what was applied", async () => {
-    const { connector } = setup({ "emulation.setTouchOverride": () => failing("unknown command") });
-    await assert.rejects(applyEmulation(connector, PAGE, { locale: "nl-NL", touch: 5 }), (err: unknown) => {
-      assert.ok(err instanceof UnsupportedOperationError);
-      assert.match(err.message, /emulate\(\{ touch \}\) is not supported by the browser/);
-      assert.equal((err as { option?: string }).option, "touch");
-      assert.deepEqual((err as { applied?: string[] }).applied, ["locale"]);
-      return true;
-    });
-  });
-
-  it("unsupported operation counts the same", async () => {
-    const { connector } = setup({ "emulation.setScriptingEnabled": () => failing("unsupported operation") });
-    await assert.rejects(applyEmulation(connector, PAGE, { javaScriptEnabled: false }), UnsupportedOperationError);
-  });
-
-  it("another failure is an EmulationError listing what was applied and what failed; nothing is rolled back", async () => {
-    const { connector, sent } = setup({ "emulation.setUserAgentOverride": () => failing("invalid argument", "bad ua") });
-    await assert.rejects(
-      applyEmulation(connector, PAGE, { locale: "nl-NL", timezone: "Europe/Amsterdam", userAgent: "x", offline: true }),
-      (err: unknown) => {
-        assert.ok(err instanceof EmulationError);
-        assert.deepEqual(err.applied, ["locale", "timezone"]);
-        assert.equal(err.failed, "userAgent");
-        assert.equal((err.cause as { code: string }).code, "invalid argument");
-        assert.match(err.message, /emulate\(\): userAgent failed after applying locale, timezone: .*bad ua/);
-        return true;
-      },
-    );
-    assert.equal(sent().length, 3, "the offline option after the failure was not sent");
-  });
-
-  it("with nothing applied before the failure the message says so", async () => {
-    const { connector } = setup({ "emulation.setLocaleOverride": () => failing("invalid argument", "bad") });
-    await assert.rejects(applyEmulation(connector, PAGE, { locale: "nl-NL" }), /emulate\(\): locale failed: /);
-  });
-});

package/src/browser/emulation.ts

@@ -1,204 +0,0 @@
-import { UnsupportedOperationError } from "../locator/selector-errors.js";
-import type { BiDiConnector } from "../transport/bidi-connection.js";
-import { BiDiError } from "../transport/bidi-error.js";
-import type { BiDiCommands } from "../types/bidi.js";
-
-const ORIENTATIONS = [
-  "portrait-primary",
-  "portrait-secondary",
-  "landscape-primary",
-  "landscape-secondary",
-] as const;
-type OrientationType = (typeof ORIENTATIONS)[number];
-
-/**
- * What to pretend about the browser. `undefined` leaves an option as it is, `null` puts the real value back.
- * Which options a browser supports differs: an unsupported one throws UnsupportedOperationError.
- */
-export interface EmulationOptions {
-  /** A BCP 47 tag, e.g. "nl-NL": `navigator.language`, `Intl` formatting */
-  locale?: string | null;
-  /** An IANA timezone, e.g. "Europe/Amsterdam" */
-  timezone?: string | null;
-  userAgent?: string | null;
-  /** Needs the geolocation permission: see `page.grantPermission("geolocation")` */
-  geolocation?: { latitude: number; longitude: number; accuracy?: number } | null;
-  /** `true`: no network (`navigator.onLine` is false and requests fail); `false` or `null`: back online */
-  offline?: boolean | null;
-  /** "portrait" and "landscape" mean the primary orientation of that kind */
-  orientation?: "portrait" | "landscape" | OrientationType | null;
-  /** The size `screen.width` and `screen.height` report */
-  screen?: { width: number; height: number } | null;
-  /** How many touch points `navigator.maxTouchPoints` reports */
-  touch?: number | null;
-  /** `false` turns JavaScript off; `true` or `null` on again */
-  javaScriptEnabled?: boolean | null;
-}
-
-export type EmulationTarget = { contexts: string[] } | { userContexts: string[] };
-
-/** A part of the options could not be applied; what was applied before it stays applied */
-export class EmulationError extends Error {
-  /** The options that were applied before the failure, in the order they were applied */
-  public readonly applied: string[];
-  public readonly failed: string;
-  public readonly cause: unknown;
-
-  constructor(failed: string, applied: string[], cause: unknown) {
-    const detail = cause instanceof Error ? cause.message : String(cause);
-    super(`emulate(): ${failed} failed${applied.length ? ` after applying ${applied.join(", ")}` : ""}: ${detail}`);
-    this.name = "EmulationError";
-    this.failed = failed;
-    this.applied = applied;
-    this.cause = cause;
-  }
-}
-
-/** The browser does not implement an emulation command */
-export class EmulationUnsupportedError extends UnsupportedOperationError {
-  public readonly option: string;
-  public readonly applied: string[];
-
-  constructor(option: string, applied: string[]) {
-    super(`emulate({ ${option} }) is not supported by the browser`);
-    this.name = "EmulationUnsupportedError";
-    this.option = option;
-    this.applied = applied;
-  }
-}
-
-interface Step {
-  option: string;
-  method: keyof BiDiCommands & `emulation.${string}`;
-  params: object;
-}
-
-const isNumber = (value: unknown): value is number => typeof value === "number" && Number.isFinite(value);
-const isPositiveInteger = (value: unknown): value is number => Number.isInteger(value) && (value as number) > 0;
-
-/** Turns the options into commands, in a fixed order; throws RangeError for an invalid value, before anything is sent */
-function plan(options: EmulationOptions): Step[] {
-  const steps: Step[] = [];
-
-  if (options.locale !== undefined) {
-    if (options.locale !== null) {
-      try {
-        if (options.locale === "" || Intl.getCanonicalLocales(options.locale).length !== 1) throw new RangeError();
-      } catch {
-        throw new RangeError(`emulate(): invalid locale "${options.locale}"`);
-      }
-    }
-    steps.push({ option: "locale", method: "emulation.setLocaleOverride", params: { locale: options.locale } });
-  }
-
-  if (options.timezone !== undefined) {
-    if (options.timezone !== null) {
-      try {
-        new Intl.DateTimeFormat(undefined, { timeZone: options.timezone });
-      } catch {
-        throw new RangeError(`emulate(): unknown timezone "${options.timezone}"`);
-      }
-    }
-    steps.push({ option: "timezone", method: "emulation.setTimezoneOverride", params: { timezone: options.timezone } });
-  }
-
-  if (options.userAgent !== undefined) {
-    if (options.userAgent === "") throw new RangeError("emulate(): userAgent must not be empty");
-    steps.push({ option: "userAgent", method: "emulation.setUserAgentOverride", params: { userAgent: options.userAgent } });
-  }
-
-  if (options.geolocation !== undefined) {
-    const place = options.geolocation;
-    if (place !== null) {
-      if (!isNumber(place.latitude) || place.latitude < -90 || place.latitude > 90) {
-        throw new RangeError("emulate(): latitude must be between -90 and 90");
-      }
-      if (!isNumber(place.longitude) || place.longitude < -180 || place.longitude > 180) {
-        throw new RangeError("emulate(): longitude must be between -180 and 180");
-      }
-      if (place.accuracy !== undefined && (!isNumber(place.accuracy) || place.accuracy < 0)) {
-        throw new RangeError("emulate(): accuracy must be 0 or more");
-      }
-    }
-    steps.push({
-      option: "geolocation",
-      method: "emulation.setGeolocationOverride",
-      params: { coordinates: place },
-    });
-  }
-
-  if (options.offline !== undefined) {
-    steps.push({
-      option: "offline",
-      method: "emulation.setNetworkConditions",
-      params: { networkConditions: options.offline ? { type: "offline" } : null },
-    });
-  }
-
-  if (options.orientation !== undefined) {
-    let screenOrientation: { natural: "portrait" | "landscape"; type: OrientationType } | null = null;
-    if (options.orientation !== null) {
-      const type = (
-        options.orientation === "portrait" || options.orientation === "landscape"
-          ? `${options.orientation}-primary`
-          : options.orientation
-      ) as OrientationType;
-      if (!ORIENTATIONS.includes(type)) throw new RangeError(`emulate(): unknown orientation "${options.orientation}"`);
-      screenOrientation = { natural: type.startsWith("portrait") ? "portrait" : "landscape", type };
-    }
-    steps.push({ option: "orientation", method: "emulation.setScreenOrientationOverride", params: { screenOrientation } });
-  }
-
-  if (options.screen !== undefined) {
-    const area = options.screen;
-    if (area !== null && !(isPositiveInteger(area.width) && isPositiveInteger(area.height))) {
-      throw new RangeError("emulate(): screen width and height must be positive integers");
-    }
-    steps.push({ option: "screen", method: "emulation.setScreenSettingsOverride", params: { screenArea: area } });
-  }
-
-  if (options.touch !== undefined) {
-    if (options.touch !== null && !isPositiveInteger(options.touch)) {
-      throw new RangeError("emulate(): touch must be a positive integer");
-    }
-    steps.push({ option: "touch", method: "emulation.setTouchOverride", params: { maxTouchPoints: options.touch } });
-  }
-
-  if (options.javaScriptEnabled !== undefined) {
-    steps.push({
-      option: "javaScriptEnabled",
-      method: "emulation.setScriptingEnabled",
-      params: { enabled: options.javaScriptEnabled === false ? false : null },
-    });
-  }
-
-  return steps;
-}
-
-/** Throws RangeError when a value is invalid, without sending anything */
-export function validateEmulation(options: EmulationOptions): void {
-  plan(options);
-}
-
-/**
- * Applies the options to `target`, one command after the other. Nothing is rolled back when one fails:
- * the error says what was applied.
- */
-export async function applyEmulation(
-  connector: BiDiConnector,
-  target: EmulationTarget,
-  options: EmulationOptions,
-): Promise<void> {
-  const applied: string[] = [];
-  for (const step of plan(options)) {
-    try {
-      await connector.send(step.method, { ...step.params, ...target } as never);
-    } catch (err) {
-      if (err instanceof BiDiError && (err.code === "unknown command" || err.code === "unsupported operation")) {
-        throw new EmulationUnsupportedError(step.option, applied);
-      }
-      throw new EmulationError(step.option, applied, err);
-    }
-    applied.push(step.option);
-  }
-}

package/src/browser/file-chooser.test.ts

@@ -1,142 +0,0 @@
-import assert from "node:assert/strict";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { after, afterEach, describe, it } from "node:test";
-import { autoReply, FakeWebSocket, tick } from "../testing/fake-websocket.js";
-import { BiDiConnector } from "../transport/bidi-connection.js";
-import { ContextTree } from "./context-tree.js";
-import { FileChooser, FileChooserTracker } from "./file-chooser.js";
-
-const TREE = [
-  { context: "top", parent: null, children: [{ context: "frame", parent: "top", children: [] }] },
-  { context: "other", parent: null, children: [] },
-];
-const stops: Array<() => void> = [];
-afterEach(() => stops.splice(0).forEach((stop) => stop()));
-const dir = mkdtempSync(path.join(tmpdir(), "samurai-chooser-"));
-after(() => rmSync(dir, { recursive: true, force: true }));
-const file = (name: string) => {
-  const full = path.join(dir, name);
-  writeFileSync(full, name);
-  return full;
-};
-
-async function setup(handlers: Record<string, (params: any) => object | Error> = {}) {
-  const ws = new FakeWebSocket();
-  const connector = new BiDiConnector(ws as unknown as WebSocket);
-  stops.push(autoReply(ws, { "browsingContext.getTree": () => ({ contexts: TREE }), "input.setFiles": () => ({}), ...handlers }));
-  const tree = await ContextTree.create(connector);
-  const tracker = await FileChooserTracker.start(connector, tree, "top");
-  const seen: FileChooser[] = [];
-  tracker.on("filechooser", (chooser) => seen.push(chooser));
-  const open = (extra: { context?: string; multiple?: boolean; element?: object | null } = {}) =>
-    ws.emitEvent("input.fileDialogOpened", {
-      context: extra.context ?? "top",
-      multiple: extra.multiple ?? false,
-      ...(extra.element !== null && { element: extra.element ?? { type: "node", sharedId: "input-1", value: {} } }),
-    });
-  const setFiles = () => ws.sent.filter((m) => m.method === "input.setFiles").map((m) => m.params as any);
-  return { ws, tracker, seen, open, setFiles };
-}
-
-describe("FileChooserTracker", () => {
-  it("announces a chooser for this page, with what the browser says about it", async () => {
-    const { seen, open } = await setup();
-    open({ multiple: true });
-    open({ multiple: false });
-    assert.equal(seen.length, 2);
-    assert.ok(seen[0] instanceof FileChooser);
-    assert.deepEqual(seen.map((chooser) => chooser.isMultiple()), [true, false]);
-  });
-
-  it("takes iframes, ignores other pages", async () => {
-    const { seen, open } = await setup();
-    open({ context: "frame" });
-    open({ context: "other" });
-    assert.equal(seen.length, 1);
-  });
-
-  it("a throwing listener does not stop the others; off removes one", async () => {
-    const { tracker, open } = await setup();
-    let second = 0;
-    let removed = 0;
-    const gone = () => removed++;
-    tracker.on("filechooser", () => {
-      throw new Error("listener failed");
-    });
-    tracker.on("filechooser", () => second++);
-    tracker.on("filechooser", gone);
-    tracker.off("filechooser", gone);
-    open();
-    assert.equal(second, 1);
-    assert.equal(removed, 0);
-  });
-
-  it("subscribes to the event and lets go of it on dispose", async () => {
-    const { ws, tracker, open, seen } = await setup();
-    assert.ok(ws.sent.some((m) => m.method === "session.subscribe" && (m.params as any).events[0] === "input.fileDialogOpened"));
-    await tracker.dispose();
-    await tick(10);
-    open();
-    assert.equal(seen.length, 0);
-    await assert.doesNotReject(tracker.dispose());
-  });
-});
-
-describe("FileChooser.setFiles", () => {
-  it("sets the files on the element the browser named, in the frame that opened the dialog", async () => {
-    const { seen, open, setFiles } = await setup();
-    open({ context: "frame", element: { type: "node", sharedId: "in-frame" } });
-    const a = file("a.txt");
-    await seen[0]!.setFiles(a);
-    assert.deepEqual(setFiles(), [{ context: "frame", element: { sharedId: "in-frame" }, files: [a] }]);
-  });
-
-  it("takes a list, and resolves relative paths", async () => {
-    const { seen, open, setFiles } = await setup();
-    open({ multiple: true });
-    const [a, b] = [file("m1.txt"), file("m2.txt")];
-    await seen[0]!.setFiles([path.relative(process.cwd(), a), b]);
-    assert.deepEqual(setFiles()[0].files, [a, b]);
-  });
-
-  it("refuses several files for a chooser that takes one, and sends nothing", async () => {
-    const { seen, open, setFiles } = await setup();
-    open({ multiple: false });
-    await assert.rejects(seen[0]!.setFiles([file("x1.txt"), file("x2.txt")]), /file chooser does not accept multiple files/);
-    assert.deepEqual(setFiles(), []);
-  });
-
-  it("an empty list clears the selection", async () => {
-    const { seen, open, setFiles } = await setup();
-    open();
-    await seen[0]!.setFiles([]);
-    assert.deepEqual(setFiles()[0].files, []);
-  });
-
-  it("checks the files exist first, before sending", async () => {
-    const { seen, open, setFiles } = await setup();
-    open();
-    const missing = path.join(dir, "nope.txt");
-    await assert.rejects(seen[0]!.setFiles(missing), new Error(`setFiles(): file not found: ${missing}`));
-    const folder = path.join(dir, "folder");
-    mkdirSync(folder);
-    await assert.rejects(seen[0]!.setFiles(folder), new Error(`setFiles(): not a file: ${folder}`));
-    assert.deepEqual(setFiles(), []);
-  });
-
-  it("without an element reference it cannot set anything", async () => {
-    const { seen, open, setFiles } = await setup();
-    open({ element: null });
-    await assert.rejects(seen[0]!.setFiles(file("e.txt")), /file chooser has no element reference/);
-    assert.deepEqual(setFiles(), []);
-  });
-
-  it("rethrows what the browser answers", async () => {
-    const failing = Object.assign(new Error("read-only"), { code: "unable to set file input" });
-    const { seen, open } = await setup({ "input.setFiles": () => failing });
-    open();
-    await assert.rejects(seen[0]!.setFiles(file("f.txt")), { name: "BiDiError", code: "unable to set file input" });
-  });
-});

package/src/browser/file-chooser.ts

@@ -1,99 +0,0 @@
-import EventEmitter from "node:events";
-import logger from "../logger/index.js";
-import type { BiDiConnector } from "../transport/bidi-connection.js";
-import type { Subscription } from "../transport/subscriptions.js";
-import type { FileDialogInfo } from "../types/bidi-modules/input.js";
-import type { ContextTree } from "./context-tree.js";
-import { assertIsFile, resolveFiles } from "./file-paths.js";
-
-/**
- * A native file picker the page asked for (a click on an `<input type=file>` or its label). Nothing appears on screen:
- * answer it with `setFiles()`.
- */
-export class FileChooser {
-  constructor(
-    private connector: BiDiConnector,
-    private info: FileDialogInfo,
-  ) {}
-
-  /** Whether the input lets the user pick several files */
-  public isMultiple(): boolean {
-    return this.info.multiple;
-  }
-
-  /**
-   * Picks the files (an empty list picks none). Paths resolve against the working directory and must exist on the
-   * machine the browser runs on.
-   */
-  public async setFiles(files: string | string[]): Promise<void> {
-    const sharedId = (this.info.element as { sharedId?: string } | undefined)?.sharedId;
-    if (!sharedId) throw new Error("file chooser has no element reference");
-    const paths = resolveFiles(files);
-    for (const file of paths) await assertIsFile(file, "setFiles");
-    if (paths.length > 1 && !this.info.multiple) {
-      throw new Error("file chooser does not accept multiple files");
-    }
-    await this.connector.send("input.setFiles", {
-      context: this.info.context,
-      element: { sharedId },
-      files: paths,
-    });
-  }
-}
-
-interface EventMap {
-  filechooser: [FileChooser];
-}
-
-/** Follows the file pickers of one page (frames included) */
-export class FileChooserTracker {
-  private events = new EventEmitter();
-  private subscription: Subscription | undefined;
-  private disposed = false;
-
-  private constructor(
-    private connector: BiDiConnector,
-    private tree: ContextTree,
-    private contextId: string,
-  ) {}
-
-  public static async start(connector: BiDiConnector, tree: ContextTree, contextId: string): Promise<FileChooserTracker> {
-    const tracker = new FileChooserTracker(connector, tree, contextId);
-    connector.onEvent("input.fileDialogOpened", tracker.onOpened);
-    try {
-      tracker.subscription = await connector.subscribe(["input.fileDialogOpened"]);
-    } catch (err) {
-      connector.offEvent("input.fileDialogOpened", tracker.onOpened);
-      throw err;
-    }
-    return tracker;
-  }
-
-  public on(event: "filechooser", listener: (...args: EventMap["filechooser"]) => void): void {
-    this.events.on(event, listener as (...args: unknown[]) => void);
-  }
-
-  public off(event: "filechooser", listener: (...args: EventMap["filechooser"]) => void): void {
-    this.events.off(event, listener as (...args: unknown[]) => void);
-  }
-
-  /** Idempotent */
-  public async dispose(): Promise<void> {
-    if (this.disposed) return;
-    this.disposed = true;
-    this.connector.offEvent("input.fileDialogOpened", this.onOpened);
-    await this.subscription?.unsubscribe();
-  }
-
-  private onOpened = (params: FileDialogInfo) => {
-    if (!this.tree.isWithin(params.context, this.contextId)) return;
-    const chooser = new FileChooser(this.connector, params);
-    for (const listener of this.events.rawListeners("filechooser")) {
-      try {
-        listener(chooser);
-      } catch (err) {
-        logger.error("A filechooser listener threw", { err });
-      }
-    }
-  };
-}

package/src/browser/file-paths.ts

@@ -1,18 +0,0 @@
-import { stat } from "node:fs/promises";
-import path from "node:path";
-
-/** Absolute paths for `files` (relative ones resolve against the working directory) */
-export function resolveFiles(files: string | string[]): string[] {
-  return (Array.isArray(files) ? files : [files]).map((file) => path.resolve(file));
-}
-
-/** Throws unless `file` is an existing regular file; `operation` names the caller in the message */
-export async function assertIsFile(file: string, operation: string): Promise<void> {
-  let info;
-  try {
-    info = await stat(file);
-  } catch {
-    throw new Error(`${operation}(): file not found: ${file}`);
-  }
-  if (!info.isFile()) throw new Error(`${operation}(): not a file: ${file}`);
-}