Struct QuickJsBackend 

pub struct QuickJsBackend {
    pub services: Arc<dyn PluginServiceBridge>,
    /* private fields */
}

QuickJS-based JavaScript runtime for plugins

Fields

services: Arc<dyn PluginServiceBridge>

Bridge for editor services (i18n, theme, etc.)

Implementations

impl QuickJsBackend

pub fn new() -> Result<Self>

Create a new QuickJS backend (standalone, for testing)

pub fn with_state( state_snapshot: Arc<RwLock<EditorStateSnapshot>>, command_sender: Sender<PluginCommand>, services: Arc<dyn PluginServiceBridge>, ) -> Result<Self>

Create a new QuickJS backend with editor state

pub fn with_state_and_responses( state_snapshot: Arc<RwLock<EditorStateSnapshot>>, command_sender: Sender<PluginCommand>, pending_responses: PendingResponses, services: Arc<dyn PluginServiceBridge>, ) -> Result<Self>

Create a new QuickJS backend with editor state and shared pending responses

pub async fn load_module_with_source( &mut self, path: &str, _plugin_source: &str, ) -> Result<()>

Load and execute a TypeScript/JavaScript plugin from a file path

pub async fn emit( &mut self, event_name: &str, event_data: &Value, ) -> Result<bool>

Emit an event to all registered handlers

pub fn has_handlers(&self, event_name: &str) -> bool

Check if any handlers are registered for an event

pub fn start_action(&mut self, action_name: &str) -> Result<()>

Start an action without waiting for async operations to complete. This is useful when the calling thread needs to continue processing ResolveCallback requests that the action may be waiting for.

pub async fn execute_action(&mut self, action_name: &str) -> Result<()>

Execute a registered action by name

pub fn poll_event_loop_once(&mut self) -> bool

Poll the event loop once to run any pending microtasks

pub fn send_status(&self, message: String)

Send a status message to the editor

pub fn send_hook_completed(&self, hook_name: String)

Send a hook-completed sentinel to the editor. This signals that all commands from the hook have been sent, allowing the render loop to wait deterministically.

pub fn resolve_callback(&mut self, callback_id: JsCallbackId, result_json: &str)

Resolve a pending async callback with a result (called from Rust when async op completes)

Takes a JSON string which is parsed and converted to a proper JS value. This avoids string interpolation with eval for better type safety.

pub fn reject_callback(&mut self, callback_id: JsCallbackId, error: &str)

Reject a pending async callback with an error (called from Rust when async op fails)