snapshot of https://github.com/tauri-apps/tauri.git (dev, 2026-09-23; blobs > 131072B omitted)

2026-09-23 17:00:42 +05:00
commit feda81bf2f
1178 changed files with 156404 additions and 0 deletions
--- a/examples/commands/README.md
+++ b/examples/commands/README.md
@@ -0,0 +1,5 @@
+# Commands Example
+
+A simple Tauri Application showcasing the command API.
+
+To execute run the following on the root directory of the repository: `cargo run --example commands`.
--- a/examples/commands/commands.rs
+++ b/examples/commands/commands.rs
@@ -0,0 +1,32 @@
+// Copyright 2019-2024 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+use tauri::{State, command};
+
+#[command]
+pub fn cmd(_argument: String) {}
+
+#[command]
+pub fn invoke(_argument: String) {}
+
+#[command]
+pub fn message(_argument: String) {}
+
+#[command]
+pub fn resolver(_argument: String) {}
+
+#[command]
+pub fn simple_command(the_argument: String) {
+  println!("{the_argument}");
+}
+
+#[command]
+pub fn stateful_command(the_argument: Option<String>, state: State<'_, super::MyState>) {
+  println!("{:?} {:?}", the_argument, *state);
+}
+
+#[command(rename = "renamed_command_in_mod_new")]
+pub fn renamed_command_in_mod() {
+  println!("renamed command in mod called");
+}
--- a/examples/commands/index.html
+++ b/examples/commands/index.html
@@ -0,0 +1,88 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Tauri</title>
+  </head>
+
+  <body>
+    <h1>Tauri Commands</h1>
+    <div>Response: <span id="response"></span></div>
+    <div>Without Args: <span id="response-optional"></span></div>
+    <div id="container"></div>
+    <script>
+      function runCommand(commandName, args, optional) {
+        const id = optional ? '#response-optional' : '#response'
+        const result = document.querySelector(id)
+        window.__TAURI__.core
+          .invoke(commandName, args)
+          .then((response) => {
+            const val =
+              response instanceof ArrayBuffer
+                ? new TextDecoder().decode(response)
+                : response
+            result.innerText = `Ok(${val})`
+          })
+          .catch((error) => {
+            result.innerText = `Err(${error})`
+          })
+      }
+
+      const container = document.querySelector('#container')
+      const commands = [
+        { name: 'borrow_cmd' },
+        { name: 'raw_request' },
+        { name: 'window_label' },
+        { name: 'simple_command' },
+        { name: 'stateful_command' },
+        { name: 'async_simple_command' },
+        { name: 'async_simple_command_snake' },
+        { name: 'future_simple_command' },
+        { name: 'async_stateful_command' },
+        { name: 'simple_command_with_result' },
+        // snake
+        { name: 'future_simple_command_snake' },
+        { name: 'future_simple_command_with_return_snake' },
+        { name: 'future_simple_command_with_result_snake' },
+        { name: 'force_async_snake' },
+        { name: 'force_async_with_result_snake' },
+        { name: 'simple_command_with_result_snake' },
+        { name: 'stateful_command_with_result_snake' },
+        // state
+        { name: 'stateful_command_with_result' },
+        { name: 'async_simple_command_with_result' },
+        { name: 'future_simple_command_with_return' },
+        { name: 'future_simple_command_with_result' },
+        { name: 'async_stateful_command_with_result' },
+        { name: 'command_arguments_wild' },
+        {
+          name: 'command_arguments_struct',
+          args: { person: { name: 'ferris', age: 6 } }
+        },
+        {
+          name: 'command_arguments_tuple_struct',
+          args: { inlinePerson: ['ferris', 6] }
+        },
+        { name: 'renamed_command' },
+        { name: 'renamed_command_new' },
+        { name: 'renamed_command_in_mod' },
+        { name: 'renamed_command_in_mod_new' }
+      ]
+
+      for (const command of commands) {
+        const { name } = command
+        const args = command.args ?? {
+          [name.endsWith('snake') ? 'the_argument' : 'theArgument']: 'value'
+        }
+        const button = document.createElement('button')
+        button.innerHTML = `Run ${name}`
+        button.addEventListener('click', function () {
+          runCommand(name, args, false)
+          runCommand(name, Object.create(null), true)
+        })
+        container.appendChild(button)
+      }
+    </script>
+  </body>
+</html>
--- a/examples/commands/main.rs
+++ b/examples/commands/main.rs
@@ -0,0 +1,276 @@
+// Copyright 2019-2024 Tauri Programme within The Commons Conservancy
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-License-Identifier: MIT
+
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+// we move some basic commands to a separate module just to show it works
+mod commands;
+use commands::{cmd, invoke, message, renamed_command_in_mod, resolver};
+
+use serde::Deserialize;
+use tauri::{
+  State, Window, command,
+  ipc::{Request, Response},
+};
+
+#[derive(Debug)]
+pub struct MyState {
+  #[allow(dead_code)]
+  value: u64,
+  #[allow(dead_code)]
+  label: String,
+}
+
+#[derive(Debug, serde::Serialize)]
+enum MyError {
+  FooError,
+}
+
+// ------------------------ Commands using Window ------------------------
+#[command]
+fn window_label(window: Window) {
+  println!("window label: {}", window.label());
+}
+
+// Async commands
+
+#[command]
+async fn async_simple_command(the_argument: String) {
+  println!("{the_argument}");
+}
+
+#[command(rename_all = "snake_case")]
+async fn async_simple_command_snake(the_argument: String) {
+  println!("{the_argument}");
+}
+
+#[command]
+async fn async_stateful_command(
+  the_argument: Option<String>,
+  state: State<'_, MyState>,
+) -> Result<(), ()> {
+  println!("{:?} {:?}", the_argument, *state);
+  Ok(())
+}
+// ------------------------ Raw future commands ------------------------
+
+#[command(async)]
+fn future_simple_command(the_argument: String) -> impl std::future::Future<Output = ()> {
+  println!("{the_argument}");
+  std::future::ready(())
+}
+
+#[command(async)]
+fn future_simple_command_with_return(
+  the_argument: String,
+) -> impl std::future::Future<Output = String> {
+  println!("{the_argument}");
+  std::future::ready(the_argument)
+}
+
+#[command(async)]
+fn future_simple_command_with_result(
+  the_argument: String,
+) -> impl std::future::Future<Output = Result<String, ()>> {
+  println!("{the_argument}");
+  std::future::ready(Ok(the_argument))
+}
+
+#[command(async)]
+fn force_async(the_argument: String) -> String {
+  the_argument
+}
+
+#[command(async)]
+fn force_async_with_result(the_argument: &str) -> Result<&str, MyError> {
+  (!the_argument.is_empty())
+    .then_some(the_argument)
+    .ok_or(MyError::FooError)
+}
+
+// ------------------------ Raw future commands - snake_case ------------------------
+
+#[command(async, rename_all = "snake_case")]
+fn future_simple_command_snake(the_argument: String) -> impl std::future::Future<Output = ()> {
+  println!("{the_argument}");
+  std::future::ready(())
+}
+
+#[command(async, rename_all = "snake_case")]
+fn future_simple_command_with_return_snake(
+  the_argument: String,
+) -> impl std::future::Future<Output = String> {
+  println!("{the_argument}");
+  std::future::ready(the_argument)
+}
+
+#[command(async, rename_all = "snake_case")]
+fn future_simple_command_with_result_snake(
+  the_argument: String,
+) -> impl std::future::Future<Output = Result<String, ()>> {
+  println!("{the_argument}");
+  std::future::ready(Ok(the_argument))
+}
+
+#[command(async, rename_all = "snake_case")]
+fn force_async_snake(the_argument: String) -> String {
+  the_argument
+}
+
+#[command(rename_all = "snake_case", async)]
+fn force_async_with_result_snake(the_argument: &str) -> Result<&str, MyError> {
+  (!the_argument.is_empty())
+    .then_some(the_argument)
+    .ok_or(MyError::FooError)
+}
+
+// ------------------------ Commands returning Result ------------------------
+
+#[command]
+fn simple_command_with_result(the_argument: String) -> Result<String, MyError> {
+  println!("{the_argument}");
+  (!the_argument.is_empty())
+    .then_some(the_argument)
+    .ok_or(MyError::FooError)
+}
+
+#[command]
+fn stateful_command_with_result(
+  the_argument: Option<String>,
+  state: State<'_, MyState>,
+) -> Result<String, MyError> {
+  println!("{:?} {:?}", the_argument, *state);
+  dbg!(the_argument.ok_or(MyError::FooError))
+}
+
+// ------------------------ Commands returning Result - snake_case ------------------------
+
+#[command(rename_all = "snake_case")]
+fn simple_command_with_result_snake(the_argument: String) -> Result<String, MyError> {
+  println!("{the_argument}");
+  (!the_argument.is_empty())
+    .then_some(the_argument)
+    .ok_or(MyError::FooError)
+}
+
+#[command(rename_all = "snake_case")]
+fn stateful_command_with_result_snake(
+  the_argument: Option<String>,
+  state: State<'_, MyState>,
+) -> Result<String, MyError> {
+  println!("{:?} {:?}", the_argument, *state);
+  dbg!(the_argument.ok_or(MyError::FooError))
+}
+
+// Async commands
+
+#[command]
+async fn async_simple_command_with_result(the_argument: String) -> Result<String, MyError> {
+  println!("{the_argument}");
+  Ok(the_argument)
+}
+
+#[command]
+async fn async_stateful_command_with_result(
+  the_argument: Option<String>,
+  state: State<'_, MyState>,
+) -> Result<String, MyError> {
+  println!("{:?} {:?}", the_argument, *state);
+  Ok(the_argument.unwrap_or_default())
+}
+
+// Non-Ident command function arguments
+
+#[command]
+fn command_arguments_wild(_: Window) {
+  println!("we saw the wildcard!")
+}
+
+#[command(rename = "renamed_command_new")]
+fn renamed_command() {
+  println!("renamed command called")
+}
+
+#[derive(Deserialize)]
+struct Person<'a> {
+  name: &'a str,
+  age: u8,
+}
+
+#[command]
+fn command_arguments_struct(Person { name, age }: Person<'_>) {
+  println!("received person struct with name: {name} | age: {age}")
+}
+
+#[derive(Deserialize)]
+struct InlinePerson<'a>(&'a str, u8);
+
+#[command]
+fn command_arguments_tuple_struct(InlinePerson(name, age): InlinePerson<'_>) {
+  println!("received person tuple with name: {name} | age: {age}")
+}
+
+#[command]
+fn borrow_cmd(the_argument: &str) -> &str {
+  the_argument
+}
+
+#[command]
+fn borrow_cmd_async(the_argument: &str) -> &str {
+  the_argument
+}
+
+#[command]
+fn raw_request(request: Request<'_>) -> Response {
+  println!("{request:?}");
+  Response::new(include_bytes!("./README.md").to_vec())
+}
+
+fn main() {
+  tauri::Builder::default()
+    .manage(MyState {
+      value: 0,
+      label: "Tauri!".into(),
+    })
+    .invoke_handler(tauri::generate_handler![
+      borrow_cmd,
+      borrow_cmd_async,
+      raw_request,
+      window_label,
+      force_async,
+      force_async_with_result,
+      commands::simple_command,
+      commands::stateful_command,
+      cmd,
+      invoke,
+      message,
+      resolver,
+      async_simple_command,
+      future_simple_command,
+      async_stateful_command,
+      command_arguments_wild,
+      renamed_command,
+      renamed_command_in_mod,
+      command_arguments_struct,
+      simple_command_with_result,
+      async_simple_command_snake,
+      future_simple_command_snake,
+      future_simple_command_with_return_snake,
+      future_simple_command_with_result_snake,
+      force_async_snake,
+      force_async_with_result_snake,
+      simple_command_with_result_snake,
+      stateful_command_with_result_snake,
+      stateful_command_with_result,
+      command_arguments_tuple_struct,
+      async_simple_command_with_result,
+      future_simple_command_with_return,
+      future_simple_command_with_result,
+      async_stateful_command_with_result,
+    ])
+    .run(tauri::generate_context!(
+      "../../examples/commands/tauri.conf.json"
+    ))
+    .expect("error while running tauri application");
+}
--- a/examples/commands/tauri.conf.json
+++ b/examples/commands/tauri.conf.json
@@ -0,0 +1,35 @@
+{
+  "$schema": "../../crates/tauri-schema-generator/schemas/config.schema.json",
+  "productName": "Commands",
+  "version": "0.1.0",
+  "identifier": "com.tauri.dev",
+  "build": {
+    "frontendDist": ["index.html"]
+  },
+  "app": {
+    "withGlobalTauri": true,
+    "windows": [
+      {
+        "title": "Welcome to Tauri!",
+        "width": 800,
+        "height": 600,
+        "resizable": true,
+        "fullscreen": false
+      }
+    ],
+    "security": {
+      "csp": "default-src 'self'; connect-src ipc: http://ipc.localhost"
+    }
+  },
+  "bundle": {
+    "active": true,
+    "targets": "all",
+    "icon": [
+      "../.icons/32x32.png",
+      "../.icons/128x128.png",
+      "../.icons/128x128@2x.png",
+      "../.icons/icon.icns",
+      "../.icons/icon.ico"
+    ]
+  }
+}