Hotfix for window focusing

src-tauri/src/lib.rs

@@ -2062,20 +2062,28 @@ async fn handle_plugin_event<R: Runtime>(app_handle: &AppHandle<R>, event: &Inte
     if let Some(e) = response_event {
         let plugin_manager: State<'_, PluginManager> = app_handle.state();
         if let Err(e) = plugin_manager.reply(&event, &e).await {
-            warn!("Failed to reply to plugin manager: {}", e)
+            warn!("Failed to reply to plugin manager: {:?}", e)
         }
     }
 }
 
 // app_handle.get_focused_window locks, so this one is a non-locking version, safe for use in async context
 fn get_focused_window_no_lock<R: Runtime>(app_handle: &AppHandle<R>) -> Option<WebviewWindow<R>> {
+    // TODO: Getting the focused window doesn't seem to work on Windows, so
+    //   we'll need to pass the window label into plugin events instead.
+    if app_handle.webview_windows().len() == 1 {
+        debug!("Returning only webview window");
+        let w = app_handle
+            .webview_windows()
+            .iter()
+            .next()
+            .map(|w| w.1.clone());
+        return w;
+    }
+
     app_handle
-        .windows()
-        .iter()
-        .find(|w| w.1.is_focused().unwrap_or(false))
-        .map(|w| w.1.clone())?
         .webview_windows()
         .iter()
-        .next()
-        .map(|(_, w)| w.to_owned())
+        .find(|w| w.1.is_focused().unwrap_or(false))
+        .map(|w| w.1.clone())
 }

src-tauri/src/template_callback.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 use tauri::{AppHandle, Manager};
-use yaak_plugin_runtime::events::RenderPurpose;
+use yaak_plugin_runtime::events::{RenderPurpose, TemplateFunctionArg};
 use yaak_plugin_runtime::manager::PluginManager;
 use yaak_templates::TemplateCallback;
 
@@ -12,7 +12,10 @@ pub struct PluginTemplateCallback {
 
 impl PluginTemplateCallback {
     pub fn new(app_handle: AppHandle) -> PluginTemplateCallback {
-        PluginTemplateCallback { app_handle, purpose: RenderPurpose::Preview }
+        PluginTemplateCallback {
+            app_handle,
+            purpose: RenderPurpose::Preview,
+        }
     }
 
     pub fn for_send(&self) -> PluginTemplateCallback {
@@ -24,9 +27,41 @@ impl PluginTemplateCallback {
 
 impl TemplateCallback for PluginTemplateCallback {
     async fn run(&self, fn_name: &str, args: HashMap<String, String>) -> Result<String, String> {
+        // The beta named the function `Response` but was changed in stable.
+        // Keep this here for a while because there's no easy way to migrate
+        let fn_name = if fn_name == "Response" {
+            "response"
+        } else {
+            fn_name
+        };
+        
         let plugin_manager = self.app_handle.state::<PluginManager>();
+        let function = plugin_manager
+            .get_template_functions()
+            .await
+            .map_err(|e| e.to_string())?
+            .iter()
+            .flat_map(|f| f.functions.clone())
+            .find(|f| f.name == fn_name)
+            .ok_or("")?;
+
+        let mut args_with_defaults = args.clone();
+        
+        // Fill in default values for all args
+        for a_def in function.args {
+            let base = match a_def {
+                TemplateFunctionArg::Text(a) => a.base,
+                TemplateFunctionArg::Select(a) => a.base,
+                TemplateFunctionArg::Checkbox(a) => a.base,
+                TemplateFunctionArg::HttpRequest(a) => a.base,
+            };
+            if let None = args_with_defaults.get(base.name.as_str()) {
+                args_with_defaults.insert(base.name, base.default_value.unwrap_or_default());
+            }
+        }
+
         let resp = plugin_manager
-            .call_template_function(fn_name, args, self.purpose.clone())
+            .call_template_function(fn_name, args_with_defaults, self.purpose.clone())
             .await
             .map_err(|e| e.to_string())?;
         Ok(resp.unwrap_or_default())

src-web/components/core/Editor/twig/templateTags.ts

@@ -68,7 +68,7 @@ function templateTags(
     syntaxTree(view.state).iterate({
       from,
       to,
-      enter: (node) => {
+      enter(node) {
         if (node.name == 'Tag') {
           // Don't decorate if the cursor is inside the match
           for (const r of view.state.selection.ranges) {
@@ -81,7 +81,14 @@ function templateTags(
 
           // TODO: Search `node.tree` instead of using Regex here
           const inner = rawTag.replace(/^\$\{\[\s*/, '').replace(/\s*]}$/, '');
-          const name = inner.match(/(\w+)[(]/)?.[1] ?? inner;
+          let name = inner.match(/(\w+)[(]/)?.[1] ?? inner;
+
+          // The beta named the function `Response` but was changed in stable.
+          // Keep this here for a while because there's no easy way to migrate
+          if (name === 'Response') {
+            name = 'response';
+          }
+
           let option = options.find((v) => v.name === name);
           if (option == null) {
             option = {
@@ -93,6 +100,7 @@ function templateTags(
               onClick: () => onClickMissingVariable(name, rawTag, node.from),
             };
           }
+
           const widget = new TemplateTagWidget(option, rawTag, node.from);
           const deco = Decoration.replace({ widget, inclusive: true });
           widgets.push(deco.range(node.from, node.to));
@@ -120,14 +128,16 @@ export function templateTagsPlugin(
       }
     },
     {
-      decorations: (v) => v.decorations,
-      provide: (plugin) =>
-        EditorView.atomicRanges.of((view) => {
+      decorations(v) {
+        return v.decorations;
+      },
+      provide(plugin) {
+        return EditorView.atomicRanges.of((view) => {
           return view.plugin(plugin)?.decorations || Decoration.none;
-        }),
-
+        });
+      },
       eventHandlers: {
-        mousedown: (e) => {
+        mousedown(e) {
           const target = e.target as HTMLElement;
           if (target.classList.contains('template-tag')) console.log('CLICKED TEMPLATE TAG');
           // return toggleBoolean(view, view.posAtDOM(target));