feat(clipboard): Implement HTML and clear functionality

plugins/clipboard-manager/README.md

@@ -60,7 +60,7 @@ fn main() {
 Afterwards all the plugin's APIs are available through the JavaScript guest bindings:
 
 ```javascript
-import { writeText, readText } from "@tauri-apps/plugin-clipboard-manager";
+import { writeText, readText, writeHtml, readHtml, clear } from "@tauri-apps/plugin-clipboard-manager";
 await writeText("Tauri is awesome!");
 assert(await readText(), "Tauri is awesome!");
 ```

plugins/clipboard-manager/guest-js/index.ts

@@ -11,6 +11,8 @@
 import { invoke } from "@tauri-apps/api/core";
 
 type ClipResponse = Record<"plainText", { text: string }>;
+// Commented this type out as it can come in handy to stay
+//type ClipHtmlResponse = Record<"html", { html: string, altHtml: string }>;
 
 /**
  * Writes plain text to the clipboard.
@@ -53,4 +55,46 @@ async function readText(): Promise<string> {
   return kind.plainText.text;
 }
 
-export { writeText, readText };
+/**
+ * Writes HTML or fallbacks to write provided plain text to the clipboard.
+ * @example
+ * ```typescript
+ * import { writeHtml, readHtml } from '@tauri-apps/plugin-clipboard-manager';
+ * await writeHtml('<h1>Tauri is awesome!</h1>', 'plaintext');
+ * await writeHtml('<h1>Tauri is awesome!</h1>', '<h1>Tauri is awesome</h1>'); // Will write "<h1>Tauri is awesome</h1>" as plain text
+ * assert(await readHtml(), '<h1>Tauri is awesome!</h1>');
+ * ```
+ *
+ * @returns A promise indicating the success or failure of the operation.
+ *
+ * @since 2.0.0
+ */
+async function writeHtml(
+    html: string,
+    altHtml?: string
+): Promise<void> {
+  return invoke("plugin:clipboard-manager|write_html", {
+    data: {
+      html: {
+        html,
+        altHtml
+      },
+    },
+  });
+}
+
+/**
+ * Gets the clipboard content as HTML text.
+ * @example
+ * ```typescript
+ * import { readHtml } from '@tauri-apps/plugin-clipboard-manager';
+ * const clipboardHtml = await readHtml();
+ * ```
+ * @since 2.0.0
+ */
+async function clear(): Promise<void> {
+  await invoke("plugin:clipboard-manager|clear");
+  return;
+}
+
+export { writeText, readText, writeHtml, clear };

plugins/clipboard-manager/src/commands.rs

@@ -22,3 +22,20 @@ pub(crate) async fn read<R: Runtime>(
 ) -> Result<ClipboardContents> {
     clipboard.read()
 }
+
+#[command]
+pub(crate) async fn write_html<R: Runtime>(
+    _app: AppHandle<R>,
+    clipboard: State<'_, Clipboard<R>>,
+    data: ClipKind,
+) -> Result<()> {
+    clipboard.write_html(data)
+}
+
+#[command]
+pub(crate) async fn clear<R: Runtime>(
+    _app: AppHandle<R>,
+    clipboard: State<'_, Clipboard<R>>,
+) -> Result<()> {
+    clipboard.clear()
+}

plugins/clipboard-manager/src/desktop.rs

@@ -28,10 +28,14 @@ pub struct Clipboard<R: Runtime> {
 
 impl<R: Runtime> Clipboard<R> {
     pub fn write(&self, kind: ClipKind) -> crate::Result<()> {
-        let ClipKind::PlainText { text, .. } = kind;
-        match &self.clipboard {
-            Ok(clipboard) => clipboard.lock().unwrap().set_text(text).map_err(Into::into),
-            Err(e) => Err(crate::Error::Clipboard(e.to_string())),
+        match kind {
+            ClipKind::PlainText { text, .. } => {
+                match &self.clipboard {
+                    Ok(clipboard) => clipboard.lock().unwrap().set_text(text).map_err(Into::into),
+                    Err(e) => Err(crate::Error::Clipboard(e.to_string())),
+                }
+            }
+            _ => Err(crate::Error::Clipboard("Invalid clip kind!".to_string())),
         }
     }
 
@@ -44,4 +48,23 @@ impl<R: Runtime> Clipboard<R> {
             Err(e) => Err(crate::Error::Clipboard(e.to_string())),
         }
     }
+
+    pub fn write_html(&self, kind: ClipKind) -> crate::Result<()> {
+        match kind {
+            ClipKind::Html { html, alt_html, .. } => match &self.clipboard {
+                Ok(clipboard) => clipboard.lock().unwrap().set_html(html, alt_html).map_err(Into::into),
+                Err(e) => Err(crate::Error::Clipboard(e.to_string())),
+            }
+            _ => Err(crate::Error::Clipboard("Invalid clip kind!".to_string())),
+            }
+        }
+
+    pub fn clear(&self) -> crate::Result<()> {
+        match &self.clipboard {
+            Ok(clipboard) => {
+                clipboard.lock().unwrap().clear().map_err(Into::into)
+            }
+            Err(e) => Err(crate::Error::Clipboard(e.to_string())),
+        }
+    }
 }

plugins/clipboard-manager/src/lib.rs

@@ -49,7 +49,16 @@ impl<R: Runtime, T: Manager<R>> crate::ClipboardExt<R> for T {
 pub fn init<R: Runtime>() -> TauriPlugin<R> {
     Builder::new("clipboard-manager")
         .js_init_script(include_str!("api-iife.js").to_string())
-        .invoke_handler(tauri::generate_handler![commands::write, commands::read])
+        .invoke_handler(tauri::generate_handler![
+            commands::write,
+            commands::read,
+            #[cfg(desktop)]
+            commands::write_html,
+            #[cfg(desktop)]
+            commands::read_html,
+            #[cfg(desktop)]
+            commands::clear
+        ])
         .setup(|app, api| {
             #[cfg(mobile)]
             let clipboard = mobile::init(app, api)?;

plugins/clipboard-manager/src/mobile.rs

@@ -39,4 +39,17 @@ impl<R: Runtime> Clipboard<R> {
     pub fn read(&self) -> crate::Result<ClipboardContents> {
         self.0.run_mobile_plugin("read", ()).map_err(Into::into)
     }
+
+    // Treat HTML as unsupported on mobile until tested
+    pub fn write_html(&self) -> crate::Result<ClipboardContents> {
+        Err(crate::Error::Clipboard(
+            "Unsupported on this platform".to_string(),
+        ))
+    }
+
+    pub fn read_html(&self) -> crate::Result<ClipboardContents> {
+        Err(crate::Error::Clipboard(
+            "Unsupported on this platform".to_string(),
+        ))
+    }
 }

plugins/clipboard-manager/src/models.rs

@@ -8,10 +8,12 @@ use serde::{Deserialize, Serialize};
 #[serde(rename_all = "camelCase")]
 pub enum ClipKind {
     PlainText { label: Option<String>, text: String },
+    Html { html: String, alt_html: Option<String> }
 }
 
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub enum ClipboardContents {
     PlainText { text: String },
+    Html { html: String, alt_html: Option<String> }
 }