Struct deno_runtime::worker::MainWorker

pub struct MainWorker {
    pub js_runtime: JsRuntime,
    /* private fields */
}

This worker is created and used by almost all subcommands in Deno executable.

It provides ops available in the Deno namespace.

All WebWorkers created during program execution are descendants of this worker.

Fields

js_runtime: JsRuntime

Implementations

impl MainWorker

pub fn bootstrap_from_options( main_module: ModuleSpecifier, permissions: PermissionsContainer, options: WorkerOptions, ) -> Self

Examples found in repository

examples/extension/main.rs (lines 35-43)

async fn main() -> Result<(), AnyError> {
  let js_path =
    Path::new(env!("CARGO_MANIFEST_DIR")).join("examples/extension/main.js");
  let main_module = ModuleSpecifier::from_file_path(js_path).unwrap();
  eprintln!("Running {main_module}...");
  let mut worker = MainWorker::bootstrap_from_options(
    main_module.clone(),
    PermissionsContainer::allow_all(),
    WorkerOptions {
      module_loader: Rc::new(FsModuleLoader),
      extensions: vec![hello_runtime::init_ops_and_esm()],
      ..Default::default()
    },
  );
  worker.execute_main_module(&main_module).await?;
  worker.run_event_loop(false).await?;
  Ok(())
}

pub fn from_options( main_module: ModuleSpecifier, permissions: PermissionsContainer, options: WorkerOptions, ) -> Self

pub fn bootstrap(&mut self, options: BootstrapOptions)

pub fn execute_script( &mut self, script_name: &'static str, source_code: ModuleCodeString, ) -> Result<Global<Value>, AnyError>

See JsRuntime::execute_script

pub async fn preload_main_module( &mut self, module_specifier: &ModuleSpecifier, ) -> Result<ModuleId, AnyError>

Loads and instantiates specified JavaScript module as “main” module.

pub async fn preload_side_module( &mut self, module_specifier: &ModuleSpecifier, ) -> Result<ModuleId, AnyError>

Loads and instantiates specified JavaScript module as “side” module.

pub async fn evaluate_module(&mut self, id: ModuleId) -> Result<(), AnyError>

Executes specified JavaScript module.

pub async fn run_up_to_duration( &mut self, duration: Duration, ) -> Result<(), AnyError>

Run the event loop up to a given duration. If the runtime resolves early, returns early. Will always poll the runtime at least once.

pub async fn execute_side_module( &mut self, module_specifier: &ModuleSpecifier, ) -> Result<(), AnyError>

Loads, instantiates and executes specified JavaScript module.

pub async fn execute_main_module( &mut self, module_specifier: &ModuleSpecifier, ) -> Result<(), AnyError>

Loads, instantiates and executes specified JavaScript module.

This module will have “import.meta.main” equal to true.

Examples found in repository

examples/extension/main.rs (line 44)

async fn main() -> Result<(), AnyError> {
  let js_path =
    Path::new(env!("CARGO_MANIFEST_DIR")).join("examples/extension/main.js");
  let main_module = ModuleSpecifier::from_file_path(js_path).unwrap();
  eprintln!("Running {main_module}...");
  let mut worker = MainWorker::bootstrap_from_options(
    main_module.clone(),
    PermissionsContainer::allow_all(),
    WorkerOptions {
      module_loader: Rc::new(FsModuleLoader),
      extensions: vec![hello_runtime::init_ops_and_esm()],
      ..Default::default()
    },
  );
  worker.execute_main_module(&main_module).await?;
  worker.run_event_loop(false).await?;
  Ok(())
}

pub fn create_inspector_session(&mut self) -> LocalInspectorSession

Create new inspector session. This function panics if Worker was not configured to create inspector.

pub async fn run_event_loop( &mut self, wait_for_inspector: bool, ) -> Result<(), AnyError>

Examples found in repository

examples/extension/main.rs (line 45)

async fn main() -> Result<(), AnyError> {
  let js_path =
    Path::new(env!("CARGO_MANIFEST_DIR")).join("examples/extension/main.js");
  let main_module = ModuleSpecifier::from_file_path(js_path).unwrap();
  eprintln!("Running {main_module}...");
  let mut worker = MainWorker::bootstrap_from_options(
    main_module.clone(),
    PermissionsContainer::allow_all(),
    WorkerOptions {
      module_loader: Rc::new(FsModuleLoader),
      extensions: vec![hello_runtime::init_ops_and_esm()],
      ..Default::default()
    },
  );
  worker.execute_main_module(&main_module).await?;
  worker.run_event_loop(false).await?;
  Ok(())
}

pub fn exit_code(&self) -> i32

Return exit code set by the executed code (either in main worker or one of child web workers).

pub fn dispatch_load_event(&mut self) -> Result<(), AnyError>

Dispatches “load” event to the JavaScript runtime.

Does not poll event loop, and thus not await any of the “load” event handlers.

pub fn dispatch_unload_event(&mut self) -> Result<(), AnyError>

Dispatches “unload” event to the JavaScript runtime.

Does not poll event loop, and thus not await any of the “unload” event handlers.

pub fn dispatch_process_exit_event(&mut self) -> Result<(), AnyError>

Dispatches process.emit(“exit”) event for node compat.

pub fn dispatch_beforeunload_event(&mut self) -> Result<bool, AnyError>

Dispatches “beforeunload” event to the JavaScript runtime. Returns a boolean indicating if the event was prevented and thus event loop should continue running.

pub fn dispatch_process_beforeexit_event(&mut self) -> Result<bool, AnyError>

Dispatches process.emit(“beforeExit”) event for node compat.