Struct Scripting 

pub struct Scripting { /* private fields */ }

With this you register your script sources and global/“merged” scripts for the whole page

You usually only use it during bundle initialization. There are already handlers for /scripting/path_to_your_script.js and /scripting/script.js.

Implementations

impl Scripting

pub fn try_new() -> Result<Self>

pub fn register_embedded_scripts<E: RustEmbed + Send + Sync + 'static>( &mut self, )

Registers a script from a rust_embed struct

Example

use quokka::state::Scripting;

#[derive(rust_embed::RustEmbed)]
#[folder = "test/scripts"]
#[include = "*.js"]
struct Scripts;

let mut scripting = Scripting::try_new().unwrap();

assert!(scripting.get_script("test.js").is_none());

scripting.register_embedded_scripts::<Scripts>();
assert_eq!(scripting.get_script("test.js").unwrap(), "console.log(\"Hello World\");\n");

pub fn add_merged_script(&mut self, script: &str)

Adds a script to the default group. Same as Scripting.add_merged_script_group("default", path)

pub fn add_merged_script_group(&mut self, group: &str, script: &str)

Adds a global script.

The merged scripts are supposed to be loaded on all pages. Adding a big or a lot of scripts will impact the sites performance and reduce the user experiance. Use with caution.

Note

The script name has to be a valid import part. Relative paths in the current directory need to start with a ./. An alphanumeric “word” will be seen as an item of an import map more details here

Example

use quokka::state::Scripting;

#[derive(rust_embed::RustEmbed)]
#[folder = "test/scripts"]
#[include = "*.js"]
struct Scripts;

let mut scripting = Scripting::try_new().unwrap();

assert!(scripting.get_merged_script().is_empty());

scripting.add_merged_script_group("default", "./test.js");
assert_eq!(scripting.get_merged_script(), "import \"./test.js\";\n");

pub fn get_script(&self, path: &str) -> Option<String>

Gets a script by its path

Example

use quokka::state::Scripting;

#[derive(rust_embed::RustEmbed)]
#[folder = "test/scripts"]
#[include = "*.js"]
struct Scripts;

let mut scripting = Scripting::try_new().unwrap();

assert!(scripting.get_script("test.js").is_none());

scripting.register_embedded_scripts::<Scripts>();
assert_eq!(scripting.get_script("test.js").unwrap(), "console.log(\"Hello World\");\n");

pub fn get_merged_script(&self) -> String

Gets the default merged scripts. Same as Scripting.get_merged_script_group("default")

pub fn get_merged_script_group(&self, group: &str) -> String

Gets the merged script. Merged scripts are supposed to be used on all sides. The merged script will rely on ECMAScript imports to get all the required scripts.

Example

use quokka::state::Scripting;

#[derive(rust_embed::RustEmbed)]
#[folder = "test/scripts"]
#[include = "*.js"]
struct Scripts;

let mut scripting = Scripting::try_new().unwrap();

assert!(scripting.get_merged_script().is_empty());

scripting.add_merged_script("test.js");
assert_eq!(scripting.get_merged_script(), "import \"test.js\";\n");

Trait Implementations

impl Clone for Scripting

fn clone(&self) -> Scripting

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Scripting

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromRef<DefaultState> for Scripting

fn from_ref(state: &DefaultState) -> Self

Converts to this type from a reference to the input type.

impl FromState<Scripting> for Scripting

fn from_state(state: &Scripting) -> Self

impl ProvideState<Scripting> for DefaultState

fn provide(&self) -> Scripting

impl ProvideStateRef<Scripting> for DefaultState

fn provide_ref(&self) -> &Scripting

fn provide_mut(&mut self) -> &mut Scripting

impl TryFromModule for Scripting

async fn try_from_module(_: &Module) -> Result<Option<Self>>

where Self: Sized,

Builds the state from a module

fn try_from_config(config: &Config) -> impl Future<Output = Result<Self>>

where Self: Sized,

Simplifies building from the root config struct

fn try_from_modules(modules: &Vec<Module>) -> impl Future<Output = Result<Self>>

where Self: Sized,

Simplifies building from multiple modules