refactor(tauri): rename init_script to initialization_script (#1200)

.changes/plugin-initialization-script.md

@@ -0,0 +1,5 @@
+---
+"tauri": minor
+---
+
+Renamed the `Plugin` trait `init_script` to `initialization_script`.

tauri/src/app/runner.rs

@@ -209,7 +209,7 @@ fn spawn_updater() {
   });
 }
 
-pub fn init() -> String {
+pub fn event_initialization_script() -> String {
   #[cfg(not(event))]
   return String::from("");
   #[cfg(event)]
@@ -273,22 +273,23 @@ fn build_webview<A: ApplicationExt + 'static>(
     _ => content_url.to_string(),
   };
 
-  let init = format!(
+  let initialization_script = format!(
     r#"
-      {tauri_init}
-      {event_init}
+      {tauri_initialization_script}
+      {event_initialization_script}
       if (window.__TAURI_INVOKE_HANDLER__) {{
         window.__TAURI_INVOKE_HANDLER__(JSON.stringify({{ cmd: "__initialized" }}))
       }} else {{
         window.addEventListener('DOMContentLoaded', function () {{
           window.__TAURI_INVOKE_HANDLER__(JSON.stringify({{ cmd: "__initialized" }}))
         }})
       }}
-      {plugin_init}
+      {plugin_initialization_script}
     "#,
-    tauri_init = application.context.tauri_script,
-    event_init = init(),
-    plugin_init = crate::async_runtime::block_on(crate::plugin::init_script(A::plugin_store()))
+    tauri_initialization_script = application.context.tauri_script,
+    event_initialization_script = event_initialization_script(),
+    plugin_initialization_script =
+      crate::async_runtime::block_on(crate::plugin::initialization_script(A::plugin_store()))
   );
 
   let application = Arc::new(application);
@@ -370,7 +371,7 @@ fn build_webview<A: ApplicationExt + 'static>(
   webview_application.create_webview(
     A::WebviewBuilder::new()
       .url(url)
-      .initialization_script(&init),
+      .initialization_script(&initialization_script),
     main_window,
     vec![tauri_invoke_handler],
   )?;

tauri/src/plugin.rs

@@ -39,8 +39,12 @@ pub trait Plugin<D: ApplicationDispatcherExt + 'static>: Send + Sync {
     Ok(())
   }
 
-  /// The JS script to evaluate on init.
-  async fn init_script(&self) -> Option<String> {
+  /// The JS script to evaluate on webview initialization.
+  /// The script is wrapped into its own context with `(function () { /* your script here */ })();`,
+  /// so global variables must be assigned to `window` instead of implicity declared.
+  ///
+  /// It's guaranteed that this script is executed before the page is loaded.
+  async fn initialization_script(&self) -> Option<String> {
     None
   }
 
@@ -89,22 +93,25 @@ pub(crate) async fn initialize<D: ApplicationDispatcherExt + 'static>(
   Ok(())
 }
 
-pub(crate) async fn init_script<D: ApplicationDispatcherExt + 'static>(
+pub(crate) async fn initialization_script<D: ApplicationDispatcherExt + 'static>(
   store: &PluginStore<D>,
 ) -> String {
   let mut plugins = store.lock().await;
   let mut futures = Vec::new();
   for plugin in plugins.iter_mut() {
-    futures.push(plugin.init_script());
+    futures.push(plugin.initialization_script());
   }
 
-  let mut init = String::new();
+  let mut initialization_script = String::new();
   for res in join_all(futures).await {
-    if let Some(init_script) = res {
-      init.push_str(&format!("(function () {{ {} }})();", init_script));
+    if let Some(plugin_initialization_script) = res {
+      initialization_script.push_str(&format!(
+        "(function () {{ {} }})();",
+        plugin_initialization_script
+      ));
     }
   }
-  init
+  initialization_script
 }
 
 pub(crate) async fn created<D: ApplicationDispatcherExt + 'static>(