Requirements and Packages - SeleniumBase for Rust

Two declarations of the Plugin trait that the set checks before anything starts: requirements says what browser a plugin can run with, and packages lists the scripts and styles it loads into every new tab. Both items are in seleniumbase_rs_plugin, defined in crates/seleniumbase-rs-plugin/src/lib.rs.

Requirements#

struct seleniumbase_rs_plugin::Requirements

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]pub struct Requirements(/* private u8 */);impl Requirements {    pub const RUN_LAST: Self;    pub const HEADFUL: Self;    pub const LAUNCH_ONLY: Self;    pub const CHROMIUM_ONLY: Self;    pub const fn empty() -> Self;    pub const fn contains(self, other: Self) -> bool;}impl std::ops::BitOr for Requirements { type Output = Self; }

Conditions a plugin needs, combined with |, returned by Plugin::requirements. PluginSet::check_with compares them with the LaunchContext and refuses a browser that does not fit with PluginError::Requirement, before anything starts. A refusal is an error, not a warning.

Requirementsflags#

Show constants

Requirements::CHROMIUM_ONLYconst#

Refuses browsers that are not Chromium-based (family other than Chromium): it needs a Chromium-based browser. Say it when the plugin needs send, or a script that runs before the page’s own.

Requirements::LAUNCH_ONLYconst#

Refuses a browser the program attaches to instead of starting (connecting: true), such as one attached with Browser::connect_with_plugins or on a remote WebDriver server: it only works with a browser the program starts, not one it attaches to.

Requirements::HEADFULconst#

Refuses a headless browser: it needs a browser with a window, not a headless one.

Requirements::RUN_LASTconst#

Refuses nothing. The plugin runs in the phase Last, after the plugins without this flag, whatever its metadata says.

sbrs plugin info prints them under needs as a Chromium-based browser, a browser it starts itself, not one it attaches to, a window, not headless and to run after the plugins without this flag.

Requirements::empty#

fn const

#[must_use]pub const fn empty() -> Self

returnRequirements#

No requirements; also Requirements::default() and the default of Plugin::requirements.

Requirements::contains#

fn const

#[must_use]pub const fn contains(self, other: Self) -> bool

otherRequirementsrequired#

The flags to look for.

returnbool#

Whether every flag of other is set.

Package#

struct seleniumbase_rs_plugin::Package

#[derive(Clone, Debug, PartialEq, Eq)]pub struct Package { /* private: kind, integrity, hosts */ }

JavaScript or CSS that a plugin loads into pages, returned by Plugin::packages. Make one with a constructor, then say where it loads with only_on or everywhere: the check refuses a plugin with a package that does neither (one of its packages says neither `only_on` nor `everywhere` ), so a plugin never loads a script into every site by accident. Pin the version in a URL and add integrity so the browser checks the file.

For every new tab, PluginSet::on_page_created hands each package’s init_script() to PageHandle::add_init_script, before the plugin’s own on_page_created. Declare the matching capability, page.script:HOSTS or page.script:*; this version does not compare the packages with it.

Constructor	Loads	When, in each matching document
`Package::script(code)`	inline JavaScript	as soon as the document starts, before the page’s own scripts
`Package::style(css)`	an inline `style` element	at `DOMContentLoaded`, or at once if the document has loaded
`Package::script_url(url)`	a `script` element with `src`, `crossOrigin = 'anonymous'` and the integrity	as `style`
`Package::style_url(url)`	a `link rel="stylesheet"` element, `crossOrigin = 'anonymous'` and the integrity	as `style`

The element goes into document.head, or the document element when there is no head. A document matches when location.hostname equals one of the hosts or ends with . and one of them; with everywhere, every document matches.

Package::script_url#

pub fn script_url(url: impl Into<String>) -> Self

urlimpl Into<String>required#

The script’s URL. Pin the version in it.

returnPackage#

A script loaded from url, with no hosts yet.

Package::style_url#

pub fn style_url(url: impl Into<String>) -> Self

urlimpl Into<String>required#

The stylesheet’s URL.

returnPackage#

A stylesheet loaded from url, with no hosts yet.

Package::script#

pub fn script(code: impl Into<String>) -> Self

codeimpl Into<String>required#

JavaScript run in every matching document before the page’s own scripts.

returnPackage#

An inline script, with no hosts yet.

Package::style#

pub fn style(css: impl Into<String>) -> Self

cssimpl Into<String>required#

CSS added to every matching document.

returnPackage#

An inline stylesheet, with no hosts yet.

Package::integrity#

#[must_use]pub fn integrity(mut self, hash: impl Into<String>) -> Self

hashimpl Into<String>required#

The Subresource Integrity hash of the file at the URL, such as sha384-....

returnPackage#

The package with the hash; the browser refuses a file that does not match. It applies to script_url and style_url; inline code has no file to check.

Package::only_on#

#[must_use]pub fn only_on<I, S>(mut self, hosts: I) -> Selfwhere    I: IntoIterator<Item = S>,    S: Into<String>,

hostsimpl IntoIterator<Item = impl Into<String>>required#

Host names, such as ["example.com"]. Each also covers its subdomains. They are compared as written with location.hostname, which browsers keep in lower case.

returnPackage#

The package, loading only on these hosts. It replaces an earlier only_on or everywhere.

Package::everywhere#

#[must_use]pub fn everywhere(mut self) -> Self

returnPackage#

The package, loading on every site. It replaces an earlier only_on.

Package::init_script#

#[must_use]pub fn init_script(&self) -> Option<String>

returnOption<String>#

The script that loads the package into a document, for PageHandle::add_init_script; None when the package does not say where it loads.

Every value (URL, hash, CSS, host list) goes into the script as a JSON literal, so a quote in it cannot break the script; inline script code is inserted as written, followed by a line break. The ResponseExample shows two results.