Actualizar desde Tauri 1.0

Esta guía te guía a través de la actualización de tu aplicación Tauri 1.0 a Tauri 2.0.

Preparándose para Mobile

La interfaz móvil de Tauri requiere que tu proyecto genere una biblioteca compartida. Si tu objetivo es el entorno móvil para tu aplicación existente, debes cambiar tu crate para producir ese tipo de artefacto junto con el ejecutable de escritorio.

1. Cambia el manifiesto de Cargo para producir la biblioteca. Añade el siguiente bloque:

src-tauri/Cargo.toml

[lib]
name = "app_lib"
crate-type = ["staticlib", "cdylib", "rlib"]

2. Renombra src-tauri/src/main.rs a src-tauri/src/lib.rs. Este archivo será compartido por los objetivos de escritorio y móviles.

3. Renombra el encabezado de la función main en lib.rs a lo siguiente:

src-tauri/src/lib.rs

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    // your code here
}

La macro tauri::mobile_entry_point prepara tu función para ser ejecutada en móviles.

4. Vuelve a crear el archivo main.rs llamando a la función run compartida:

src-tauri/src/main.rs

#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]

fn main() {
  app_lib::run();
}

Migración Automatizada

Peligro

¡Este comando no es un sustituto de esta guía! Por favor lee toda la página independientemente de si elegiste usar el comando o no.

La CLI de Tauri v2 incluye un comando migrate que automatiza la mayor parte del proceso y te ayuda a completar la migración:

npm

npm install @tauri-apps/cli@latest
npm run tauri migrate

yarn

yarn upgrade @tauri-apps/cli@latest
yarn tauri migrate

pnpm

pnpm update @tauri-apps/cli@latest
pnpm tauri migrate

cargo

cargo install tauri-cli --version "^2.0.0" --locked
cargo tauri migrate

Obtén más información sobre el comando migrate en la referencia de la Interfaz de Línea de Comandos (CLI)

Resumen de Cambios

A continuación se muestra un resumen de los cambios de Tauri 1.0 a Tauri 2.0:

Configuración de Tauri

• package > productName y package > version se movieron al objeto de nivel superior.
• el nombre del binario ya no se renombra para coincidir con productName automáticamente, por lo que debes agregar una cadena mainBinaryName al objeto de nivel superior que coincida con productName.
• package eliminado.
• clave tauri renombrada a app.
• tauri > allowlist eliminado. Consulta Migrar Permisos.
• tauri > allowlist > protocol > assetScope movido a app > security > assetProtocol > scope. Consulta el Alcance del protocolo Asset para enable, patrones glob, requireLiteralLeadingDot y rutas dinámicas.
• tauri > cli movido a plugins > cli.
• tauri > windows > fileDropEnabled renombrado a app > windows > dragDropEnabled.
• tauri > updater > active eliminado.
• tauri > updater > dialog eliminado.
• tauri > updater movido a plugins > updater.
• bundle > createUpdaterArtifacts added, must be set when using the app updater.
  • establécelo en v1Compatible al actualizar desde aplicaciones v1 que ya estaban distribuidas. Consulta la guía del actualizador para obtener más información.
• tauri > systemTray renombrado a app > trayIcon.
• tauri > pattern movido a app > security > pattern.
• tauri > bundle movido al nivel superior.
• tauri > bundle > identifier movido al objeto de nivel superior.
• tauri > bundle > dmg movido a bundle > macOS > dmg
• tauri > bundle > deb movido a bundle > linux > deb
• tauri > bundle > appimage movido a bundle > linux > appimage
• tauri > bundle > macOS > license eliminado, usa bundle > licenseFile en su lugar.
• tauri > bundle > windows > wix > license eliminado, usa bundle > licenseFile en su lugar.
• tauri > bundle > windows > nsis > license eliminado, usa bundle > licenseFile en su lugar.
• tauri > bundle > windows > webviewFixedRuntimePath eliminado, usa bundle > windows > webviewInstallMode en su lugar.
• build > withGlobalTauri movido a app > withGlobalTauri.
• build > distDir renombrado a frontendDist.
• build > devPath renombrado a devUrl.

Referencia de la API de Configuración de Tauri 2.0

Nuevas Características de Cargo

• linux-protocol-body: Permite el análisis del cuerpo de solicitudes del protocolo personalizado, permitiendo que el IPC lo use. Requiere webkit2gtk 2.40.

Características de Cargo Eliminadas

• reqwest-client: reqwest es ahora el único cliente soportado.
• reqwest-native-tls-vendored: usa native-tls-vendored en su lugar.
• process-command-api: usa el plugin shell en su lugar (ver instrucciones en la siguiente sección).
• shell-open-api: usa el plugin shell en su lugar (ver instrucciones en la siguiente sección).
• windows7-compat: movido al plugin notification.
• updater: Updater es ahora un plugin.
• linux-protocol-headers: Ahora habilitado por defecto ya que actualizamos nuestra versión mínima de webkit2gtk.
• system-tray: renombrado a tray-icon.

Cambios en Crates de Rust

• módulo api eliminado. Cada módulo API se puede encontrar en un plugin de Tauri.
• módulo api::dialog eliminado. Usa tauri-plugin-dialog en su lugar. Migración
• módulo api::file eliminado. Usa std::fs de Rust en su lugar.
• módulo api::http eliminado. Usa tauri-plugin-http en su lugar. Migración
• módulo api::ip reescrito y movido a tauri::ipc. Revisa las nuevas API, especialmente tauri::ipc::Channel.
• funciones del módulo api::path y tauri::PathResolved movidas a tauri::Manager::path. Migración
• API de api::process::Command, tauri::api::shell y tauri::Manager::shell_scope eliminadas. Usa tauri-plugin-shell en su lugar. Migración
• api::process::current_binary y tauri::api::process::restart movidos a tauri::process.
• módulo api::version ha sido eliminado. Usa el crate semver en su lugar.
• App::clipboard_manager y AppHandle::clipboard_manager eliminados. Usa tauri-plugin-clipboard en su lugar. Migración
• App::get_cli_matches eliminado. Usa tauri-plugin-cli en su lugar. Migración
• App::global_shortcut_manager y AppHandle::global_shortcut_manager eliminados. Usa tauri-plugin-global-shortcut en su lugar. Migración
• Manager::fs_scope eliminado. El alcance del sistema de archivos se puede acceder a través de tauri_plugin_fs::FsExt.
• Plugin::PluginApi ahora recibe una configuración de plugin como segundo argumento.
• Plugin::setup_with_config removed. Use the updated tauri::Plugin::PluginApi instead.
• scope::ipc::RemoteDomainAccessScope::enable_tauri_api and scope::ipc::RemoteDomainAccessScope::enables_tauri_api removed. Enable each core plugin individually via scope::ipc::RemoteDomainAccessScope::add_plugin instead.
• scope::IpcScope removed, use scope::ipc::Scope instead.
• scope::FsScope, scope::GlobPattern and scope::FsScopeEvent removed, use scope::fs::Scope, scope::fs::Pattern and scope::fs::Event respectively.
• updater module removed. Use tauri-plugin-updater instead. Migration
• Env.args field has been removed, use Env.args_os field instead.
• Menu, MenuEvent, CustomMenuItem, Submenu, WindowMenuEvent, MenuItem and Builder::on_menu_event APIs removed. Migration
• SystemTray, SystemTrayHandle, SystemTrayMenu, SystemTrayMenuItemHandle, SystemTraySubmenu, MenuEntry and SystemTrayMenuItem APIs removed. Migration

Cambios en la API de JavaScript

The @tauri-apps/api package no longer provides non-core modules. Only the previous tauri (now core), path, event and window modules are exported. All others have been moved to plugins.

• @tauri-apps/api/tauri module renamed to @tauri-apps/api/core. Migration
• @tauri-apps/api/cli module removed. Use @tauri-apps/plugin-cli instead. Migration
• módulo @tauri-apps/api/clipboard eliminado. Usa @tauri-apps/plugin-clipboard en su lugar. Migración
• módulo @tauri-apps/api/dialog eliminado. Usa @tauri-apps/plugin-dialog en su lugar. Migración
• módulo @tauri-apps/api/fs eliminado. Usa @tauri-apps/plugin-fs en su lugar. Migración
• módulo @tauri-apps/api/global-shortcut eliminado. Usa @tauri-apps/plugin-global-shortcut en su lugar. Migración
• módulo @tauri-apps/api/http eliminado. Usa @tauri-apps/plugin-http en su lugar. Migración
• módulo @tauri-apps/api/os eliminado. Usa @tauri-apps/plugin-os en su lugar. Migración
• módulo @tauri-apps/api/notification eliminado. Usa @tauri-apps/plugin-notification en su lugar. Migración
• módulo @tauri-apps/api/process eliminado. Usa @tauri-apps/plugin-process en su lugar. Migración
• módulo @tauri-apps/api/shell eliminado. Usa @tauri-apps/plugin-shell en su lugar. Migración
• módulo @tauri-apps/api/updater eliminado. Usa @tauri-apps/plugin-updater en su lugar Migración
• módulo @tauri-apps/api/window renombrado a @tauri-apps/api/webviewWindow. Migración

Los plugins v1 ahora se publican como @tauri-apps/plugin-<plugin-name>. Anteriormente estaban disponibles desde git como tauri-plugin-<plugin-name>-api.

Cambios en Variables de Entorno

La mayoría de las variables de entorno leídas y escritas por la CLI de Tauri fueron renombradas por consistencia y para prevenir errores:

• TAURI_PRIVATE_KEY -> TAURI_SIGNING_PRIVATE_KEY
• TAURI_KEY_PASSWORD -> TAURI_SIGNING_PRIVATE_KEY_PASSWORD
• TAURI_SKIP_DEVSERVER_CHECK -> TAURI_CLI_NO_DEV_SERVER_WAIT
• TAURI_DEV_SERVER_PORT -> TAURI_CLI_PORT
• TAURI_PATH_DEPTH -> TAURI_CLI_CONFIG_DEPTH
• TAURI_FIPS_COMPLIANT -> TAURI_BUNDLER_WIX_FIPS_COMPLIANT
• TAURI_DEV_WATCHER_IGNORE_FILE -> TAURI_CLI_WATCHER_IGNORE_FILENAME
• TAURI_TRAY -> TAURI_LINUX_AYATANA_APPINDICATOR
• TAURI_APPLE_DEVELOPMENT_TEAM -> APPLE_DEVELOPMENT_TEAM
• TAURI_PLATFORM -> TAURI_ENV_PLATFORM
• TAURI_ARCH -> TAURI_ENV_ARCH
• TAURI_FAMILY -> TAURI_ENV_FAMILY
• TAURI_PLATFORM_VERSION -> TAURI_ENV_PLATFORM_VERSION
• TAURI_PLATFORM_TYPE -> TAURI_ENV_PLATFORM_TYPE
• TAURI_DEBUG -> TAURI_ENV_DEBUG

Sistema de eventos

El sistema de eventos fue rediseñado para ser más fácil de usar. En lugar de depender de la fuente del evento, ahora tiene una implementación más simple que se basa en objetivos de eventos.

• La función emit ahora emite el evento a todos los oyentes de eventos.
• Se agregó una nueva función emit_to/emitTo para activar un evento en un objetivo específico.
• emit_filter ahora filtra según el EventTarget en lugar de una ventana.
• Se renombró listen_global a listen_any. Ahora escucha todos los eventos independientemente de sus filtros y objetivos.
• JavaScript: event.listen() se comporta de forma similar a listen_any. Ahora escucha todos los eventos independientemente de sus filtros y objetivos, a menos que se establezca un objetivo en Options.
• JavaScript: WebviewWindow.listen etc. solo escuchan los eventos emitidos hacia su respectivo EventTarget.

Soporte multi-webview

Tauri v2 introduce soporte para multi-webview actualmente detrás de un flag de característica inestable. Para soportarlo, renombramos el tipo Rust Window a WebviewWindow y la función Manager get_window a get_webview_window.

El tipo de API JS WebviewWindow ahora se reexporta desde @tauri-apps/api/webviewWindow en lugar de @tauri-apps/api/window.

Nueva URL de origen en Windows

En Windows, los archivos del frontend en aplicaciones de producción ahora se alojan en http://tauri.localhost en lugar de https://tauri.localhost. Debido a esto, IndexedDB, LocalStorage y Cookies se restablecerán a menos que se haya utilizado dangerousUseHttpScheme en v1. Para evitar esto, puedes configurar app > windows > useHttpsScheme en true o usar WebviewWindowBuilder::use_https_scheme para seguir usando el esquema https.

Pasos Detallados de Migración

Escenarios comunes que podrías encontrar al migrar tu aplicación de Tauri 1.0 a Tauri 2.0.

Migrar al Módulo Core

El módulo @tauri-apps/api/tauri fue renombrado a @tauri-apps/api/core. Simplemente renombra la importación del módulo:

import { invoke } from "@tauri-apps/api/tauri"
import { invoke } from "@tauri-apps/api/core"

Migrar al Plugin CLI

Las API de Rust App::get_cli_matches y JavaScript @tauri-apps/api/cli han sido eliminadas. Usa el plugin @tauri-apps/plugin-cli en su lugar:

1. Añadir a las dependencias de cargo:

Cargo.toml

[dependencies]
tauri-plugin-cli = "2"

2. Usar en proyecto JavaScript o Rust:

JavaScript

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_cli::init())
}

package.json

{
  "dependencies": {
    "@tauri-apps/plugin-cli": "^2.0.0"
  }
}

import { getMatches } from '@tauri-apps/plugin-cli';
const matches = await getMatches();

Rust

fn main() {
    use tauri_plugin_cli::CliExt;
    tauri::Builder::default()
        .plugin(tauri_plugin_cli::init())
        .setup(|app| {
            let cli_matches = app.cli().matches()?;
            Ok(())
        })
}

Migrar al Plugin Clipboard

Las API de Rust App::clipboard_manager y AppHandle::clipboard_manager y JavaScript @tauri-apps/api/clipboard han sido eliminadas. Usa el plugin @tauri-apps/plugin-clipboard-manager en su lugar:

[dependencies]
tauri-plugin-clipboard-manager = "2"

JavaScript

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_clipboard_manager::init())
}

package.json

{
  "dependencies": {
    "@tauri-apps/plugin-clipboard-manager": "^2.0.0"
  }
}

import { writeText, readText } from '@tauri-apps/plugin-clipboard-manager';
await writeText('Tauri is awesome!');
assert(await readText(), 'Tauri is awesome!');

Rust

use tauri_plugin_clipboard::{ClipboardExt, ClipKind};
tauri::Builder::default()
    .plugin(tauri_plugin_clipboard::init())
    .setup(|app| {
        app.clipboard().write(ClipKind::PlainText {
            label: None,
            text: "Tauri is awesome!".into(),
        })?;
        Ok(())
    })

Migrar al Plugin Dialog

Las API de Rust tauri::api::dialog y JavaScript @tauri-apps/api/dialog han sido eliminadas. Usa el plugin @tauri-apps/plugin-dialog en su lugar:

1. Añadir a las dependencias de cargo:

Cargo.toml

[dependencies]
tauri-plugin-dialog = "2"

2. Usar en proyecto JavaScript o Rust:

JavaScript

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_dialog::init())
}

package.json

{
  "dependencies": {
    "@tauri-apps/plugin-dialog": "^2.0.0"
  }
}

import { save } from '@tauri-apps/plugin-dialog';
const filePath = await save({
  filters: [
    {
      name: 'Image',
      extensions: ['png', 'jpeg'],
    },
  ],
});

Rust

use tauri_plugin_dialog::DialogExt;
tauri::Builder::default()
    .plugin(tauri_plugin_dialog::init())
    .setup(|app| {
        app.dialog().file().pick_file(|file_path| {
            // do something with the optional file path here
            // the file path is `None` if the user closed the dialog
        });

        app.dialog().message("Tauri is Awesome!").show();
        Ok(())
     })

Migrar al Plugin File System

Las API de Rust tauri::api::file y JavaScript @tauri-apps/api/fs han sido eliminadas. Usa std::fs para Rust y el plugin @tauri-apps/plugin-fs para JavaScript en su lugar:

1. Añadir a las dependencias de cargo:

Cargo.toml

[dependencies]
tauri-plugin-fs = "2"

2. Usar en proyecto JavaScript o Rust:

JavaScript

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_fs::init())
}

package.json

{
  "dependencies": {
    "@tauri-apps/plugin-fs": "^2.0.0"
  }
}

import { mkdir, BaseDirectory } from '@tauri-apps/plugin-fs';
await mkdir('db', { baseDir: BaseDirectory.AppLocalData });

Algunas funciones y tipos han sido renombrados o eliminados:

• Alias del enum Dir eliminado, usa BaseDirectory.
• Las interfaces y alias de tipos FileEntry, FsBinaryFileOption, FsDirOptions, FsOptions, FsTextFileOption y BinaryFileContents han sido eliminados y reemplazados con nuevas interfaces adecuadas para cada función.
• createDir renombrado a mkdir.
• readBinaryFile renombrado a readFile.
• removeDir eliminado y reemplazado con remove.
• removeFile eliminado y reemplazado con remove.
• renameFile eliminado y reemplazado con rename.
• writeBinaryFile renombrado a writeFile.

Rust

Usa las funciones de std::fs de Rust.

Migrar al Plugin Global Shortcut

Las API de Rust App::global_shortcut_manager y AppHandle::global_shortcut_manager y JavaScript @tauri-apps/api/global-shortcut han sido eliminadas. Usa el plugin @tauri-apps/plugin-global-shortcut en su lugar:

1. Añadir a las dependencias de cargo:

Cargo.toml

[dependencies]
[target."cfg(not(any(target_os = \"android\", target_os = \"ios\")))".dependencies]
tauri-plugin-global-shortcut = "2"

2. Usar en proyecto JavaScript o Rust:

JavaScript

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_global_shortcut::Builder::default().build())
}

package.json

{
  "dependencies": {
    "@tauri-apps/plugin-global-shortcut": "^2.0.0"
  }
}

import { register } from '@tauri-apps/plugin-global-shortcut';
await register('CommandOrControl+Shift+C', () => {
  console.log('Shortcut triggered');
});

Rust

use tauri_plugin_global_shortcut::GlobalShortcutExt;

tauri::Builder::default()
    .plugin(
        tauri_plugin_global_shortcut::Builder::new().with_handler(|app, shortcut| {
            println!("Shortcut triggered: {:?}", shortcut);
        })
        .build(),
    )
    .setup(|app| {
        // register a global shortcut
        // on macOS, the Cmd key is used
        // on Windows and Linux, the Ctrl key is used
        app.global_shortcut().register("CmdOrCtrl+Y")?;
        Ok(())
    })

Migrar al Plugin HTTP

Las API de Rust tauri::api::http y JavaScript @tauri-apps/api/http han sido eliminadas. Usa el plugin @tauri-apps/plugin-http en su lugar:

1. Añadir a las dependencias de cargo:

Cargo.toml

[dependencies]
tauri-plugin-http = "2"

2. Usar en proyecto JavaScript o Rust:

JavaScript

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_http::init())
}

package.json

{
  "dependencies": {
    "@tauri-apps/plugin-http": "^2.0.0"
  }
}

import { fetch } from '@tauri-apps/plugin-http';
const response = await fetch(
  'https://raw.githubusercontent.com/tauri-apps/tauri/dev/package.json'
);

Rust

use tauri_plugin_http::reqwest;

tauri::Builder::default()
    .plugin(tauri_plugin_http::init())
    .setup(|app| {
        let response_data = tauri::async_runtime::block_on(async {
            let response = reqwest::get(
                "https://raw.githubusercontent.com/tauri-apps/tauri/dev/package.json",
            )
            .await
            .unwrap();
            response.text().await
        })?;
        Ok(())
    })

El plugin HTTP reexporta reqwest para que puedas consultar su documentación para obtener más información.

Migrar al Plugin Notification

Las API de Rust tauri::api::notification y JavaScript @tauri-apps/api/notification han sido eliminadas. Usa el plugin @tauri-apps/plugin-notification en su lugar:

1. Añadir a las dependencias de cargo:

Cargo.toml

[dependencies]
tauri-plugin-notification = "2"

2. Usar en proyecto JavaScript o Rust:

JavaScript

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_notification::init())
}

package.json

{
  "dependencies": {
    "@tauri-apps/plugin-notification": "^2.0.0"
  }
}

import { sendNotification } from '@tauri-apps/plugin-notification';
sendNotification('Tauri is awesome!');

Rust

use tauri_plugin_notification::NotificationExt;
use tauri::plugin::PermissionState;

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_notification::init())
        .setup(|app| {
            if app.notification().permission_state()? == PermissionState::Unknown {
                app.notification().request_permission()?;
            }
            if app.notification().permission_state()? == PermissionState::Granted {
                app.notification()
                    .builder()
                    .body("Tauri is awesome!")
                    .show()?;
            }
            Ok(())
        })
}

Migrar al Módulo Menu

Las API de Rust Menu se movieron al módulo tauri::menu y se refactorizaron para usar el crate muda.

Usa tauri::menu::MenuBuilder

Usa tauri::menu::MenuBuilder en lugar de tauri::Menu. Ten en cuenta que su constructor toma una instancia de Manager (una de App, AppHandle o WebviewWindow) como argumento:

use tauri::menu::MenuBuilder;

tauri::Builder::default()
    .setup(|app| {
        let menu = MenuBuilder::new(app)
            .copy()
            .paste()
            .separator()
            .undo()
            .redo()
            .text("open-url", "Open URL")
            .check("toggle", "Toggle")
            .icon("show-app", "Show App", app.default_window_icon().cloned().unwrap())
            .build()?;
        app.set_menu(menu);
        Ok(())
    })

Usa tauri::menu::PredefinedMenuItem

Usa tauri::menu::PredefinedMenuItem en lugar de tauri::MenuItem:

use tauri::menu::{MenuBuilder, PredefinedMenuItem};

tauri::Builder::default()
    .setup(|app| {
        let menu = MenuBuilder::new(app).item(&PredefinedMenuItem::copy(app)?).build()?;
        Ok(())
    })

Consejo

El constructor del menú tiene métodos dedicados para agregar cada elemento de menú predefinido para que puedas llamar a .copy() en lugar de .item(&PredefinedMenuItem::copy(app, None)?).

Usa tauri::menu::MenuItemBuilder

Usa tauri::menu::MenuItemBuilder en lugar de tauri::CustomMenuItem:

use tauri::menu::MenuItemBuilder;

tauri::Builder::default()
    .setup(|app| {
        let toggle = MenuItemBuilder::new("Toggle").accelerator("Ctrl+Shift+T").build(app)?;
        Ok(())
    })

Usa tauri::menu::SubmenuBuilder

Usa tauri::menu::SubmenuBuilder en lugar de tauri::Submenu:

use tauri::menu::{MenuBuilder, SubmenuBuilder};

tauri::Builder::default()
    .setup(|app| {
        let submenu = SubmenuBuilder::new(app, "Sub")
            .text("Tauri")
            .separator()
            .check("Is Awesome")
            .build()?;
        let menu = MenuBuilder::new(app).item(&submenu).build()?;
        Ok(())
    })

tauri::Builder::menu ahora toma un closure porque el menú necesita una instancia de Manager para ser construido. Consulta la documentación para obtener más información.

Eventos de Menú

La API de Rust tauri::Builder::on_menu_event fue eliminada. Usa tauri::App::on_menu_event o tauri::AppHandle::on_menu_event en su lugar:

use tauri::menu::{CheckMenuItemBuilder, MenuBuilder, MenuItemBuilder};

tauri::Builder::default()
    .setup(|app| {
        let toggle = MenuItemBuilder::with_id("toggle", "Toggle").build(app)?;
        let check = CheckMenuItemBuilder::new("Mark").build(app)?;
        let menu = MenuBuilder::new(app).items(&[&toggle, &check]).build()?;

        app.set_menu(menu)?;

        app.on_menu_event(move |app, event| {
            if event.id() == check.id() {
                println!("`check` triggered, do something! is checked? {}", check.is_checked().unwrap());
            } else if event.id() == "toggle" {
                println!("toggle triggered!");
            }
        });
        Ok(())
    })

Ten en cuenta que hay dos formas de verificar qué elemento de menú fue seleccionado: mover el elemento al closure del controlador de eventos y comparar los ID, o definir un ID personalizado para el elemento a través del constructor with_id y usar esa cadena de ID para comparar.

Consejo

Los elementos de menú se pueden compartir entre menús, y el evento de menú está vinculado a un elemento de menú en lugar de un menú o ventana. Si no deseas que todos los oyentes se activen cuando se selecciona un elemento de menú, no compartas elementos de menú y usa instancias dedicadas en su lugar, que podrías mover al closure tauri::WebviewWindow/WebviewWindowBuilder::on_menu_event.

Migrar al Plugin OS

Las API de Rust tauri::api::os y JavaScript @tauri-apps/api/os han sido eliminadas. Usa el plugin @tauri-apps/plugin-os en su lugar:

1. Añadir a las dependencias de cargo:

Cargo.toml

[dependencies]
tauri-plugin-os = "2"

2. Usar en proyecto JavaScript o Rust:

JavaScript

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_os::init())
}

package.json

{
  "dependencies": {
    "@tauri-apps/plugin-os": "^2.0.0"
  }
}

import { arch } from '@tauri-apps/plugin-os';
const architecture = await arch();

Rust

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_os::init())
        .setup(|app| {
            let os_arch = tauri_plugin_os::arch();
            Ok(())
        })
}

Migrar al Plugin Process

Las API de Rust tauri::api::process y JavaScript @tauri-apps/api/process han sido eliminadas. Usa el plugin @tauri-apps/plugin-process en su lugar:

1. Añadir a las dependencias de cargo:

Cargo.toml

[dependencies]
tauri-plugin-process = "2"

2. Usar en proyecto JavaScript o Rust:

JavaScript

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_process::init())
}

package.json

{
  "dependencies": {
    "@tauri-apps/plugin-process": "^2.0.0"
  }
}

import { exit, relaunch } from '@tauri-apps/plugin-process';
await exit(0);
await relaunch();

Rust

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_process::init())
        .setup(|app| {
            // exit the app with a status code
            app.handle().exit(1);
            // restart the app
            app.handle().restart();
            Ok(())
        })
}

Migrar al Plugin Shell

Las API de Rust tauri::api::shell y JavaScript @tauri-apps/api/shell han sido eliminadas. Usa el plugin @tauri-apps/plugin-shell en su lugar:

1. Añadir a las dependencias de cargo:

Cargo.toml

[dependencies]
tauri-plugin-shell = "2"

2. Usar en proyecto JavaScript o Rust:

JavaScript

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_shell::init())
}

package.json

{
  "dependencies": {
    "@tauri-apps/plugin-shell": "^2.0.0"
  }
}

import { Command, open } from '@tauri-apps/plugin-shell';
const output = await Command.create('echo', 'message').execute();

await open('https://github.com/tauri-apps/tauri');

Rust

• Abrir una URL

use tauri_plugin_shell::ShellExt;

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_shell::init())
        .setup(|app| {
            app.shell().open("https://github.com/tauri-apps/tauri", None)?;
            Ok(())
        })
}

• Iniciar un proceso hijo y recuperar el código de estado

use tauri_plugin_shell::ShellExt;

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_shell::init())
        .setup(|app| {
            let status = tauri::async_runtime::block_on(async move { app.shell().command("which").args(["ls"]).status().await.unwrap() });
            println!("`which` finished with status: {:?}", status.code());
            Ok(())
        })
}

• Iniciar un proceso hijo y capturar su salida

use tauri_plugin_shell::ShellExt;

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_shell::init())
        .setup(|app| {
            let output = tauri::async_runtime::block_on(async move { app.shell().command("echo").args(["TAURI"]).output().await.unwrap() });
            assert!(output.status.success());
            assert_eq!(String::from_utf8(output.stdout).unwrap(), "TAURI");
            Ok(())
        })
}

• Iniciar un proceso hijo y leer sus eventos de forma asíncrona:

use tauri_plugin_shell::{ShellExt, process::CommandEvent};

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_shell::init())
        .setup(|app| {
            let handle = app.handle().clone();
            tauri::async_runtime::spawn(async move {
                let (mut rx, mut child) = handle.shell().command("cargo")
                    .args(["tauri", "dev"])
                    .spawn()
                    .expect("Failed to spawn cargo");

                let mut i = 0;
                while let Some(event) = rx.recv().await {
                    if let CommandEvent::Stdout(line) = event {
                        println!("got: {}", String::from_utf8(line).unwrap());
                       i += 1;
                       if i == 4 {
                           child.write("message from Rust\n".as_bytes()).unwrap();
                           i = 0;
                       }
                   }
                }
            });
            Ok(())
        })
}

Migrar al Módulo Tray Icon

Las API de Rust SystemTray fueron renombradas a TrayIcon por consistencia. Las nuevas API se pueden encontrar en el módulo Rust tray.

Usa tauri::tray::TrayIconBuilder

Usa tauri::tray::TrayIconBuilder en lugar de tauri::SystemTray:

let tray = tauri::tray::TrayIconBuilder::with_id("my-tray").build(app)?;

Consulta TrayIconBuilder para obtener más información.

Migrar a Menu

Usa tauri::menu::Menu en lugar de tauri::SystemTrayMenu, tauri::menu::Submenu en lugar de tauri::SystemTraySubmenu y tauri::menu::PredefinedMenuItem en lugar de tauri::SystemTrayMenuItem.

Eventos del Tray

tauri::SystemTray::on_event se ha dividido en tauri::tray::TrayIconBuilder::on_menu_event y tauri::tray::TrayIconBuilder::on_tray_icon_event:

use tauri::{
    menu::{MenuBuilder, MenuItemBuilder},
    tray::{MouseButton, MouseButtonState, TrayIconBuilder, TrayIconEvent},
};

tauri::Builder::default()
    .setup(|app| {
        let toggle = MenuItemBuilder::with_id("toggle", "Toggle").build(app)?;
        let menu = MenuBuilder::new(app).items(&[&toggle]).build()?;
        let tray = TrayIconBuilder::new()
            .menu(&menu)
            .on_menu_event(move |app, event| match event.id().as_ref() {
                "toggle" => {
                    println!("toggle clicked");
                }
                _ => (),
            })
            .on_tray_icon_event(|tray, event| {
                if let TrayIconEvent::Click {
                        button: MouseButton::Left,
                        button_state: MouseButtonState::Up,
                        ..
                } = event
                {
                    let app = tray.app_handle();
                    if let Some(webview_window) = app.get_webview_window("main") {
                       let _ = webview_window.unminimize();
                       let _ = webview_window.show();
                       let _ = webview_window.set_focus();
                    }
                }
            })
            .build(app)?;

        Ok(())
    })

Migrar al Plugin Updater

Cambio de comportamiento por defecto

El diálogo integrado con verificación automática de actualizaciones fue eliminado, usa las API de Rust y JS para verificar e instalar actualizaciones en su lugar. ¡No hacerlo evitará que tus usuarios reciban más actualizaciones!

Las API de Rust tauri::updater y JavaScript @tauri-apps/api-updater han sido eliminadas. Para establecer un objetivo de actualizador personalizado con @tauri-apps/plugin-updater:

1. Añadir a las dependencias de cargo:

[dependencies]
tauri-plugin-updater = "2"

2. Usar en proyecto JavaScript o Rust:

JavaScript

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_updater::Builder::new().build())
}

package.json

{
  "dependencies": {
    "@tauri-apps/plugin-updater": "^2.0.0"
  }
}

import { check } from '@tauri-apps/plugin-updater';
import { relaunch } from '@tauri-apps/plugin-process';

const update = await check();
if (update?.available) {
  console.log(`Update to ${update.version} available! Date: ${update.date}`);
  console.log(`Release notes: ${update.body}`);
  await update.downloadAndInstall();
  // requires the `process` plugin
  await relaunch();
}

Rust

Para verificar actualizaciones:

use tauri_plugin_updater::UpdaterExt;

fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_updater::Builder::new().build())
        .setup(|app| {
            let handle = app.handle();
            tauri::async_runtime::spawn(async move {
                let response = handle.updater().check().await;
            });
            Ok(())
        })
}

Para establecer un objetivo de actualizador personalizado:

fn main() {
    let mut updater = tauri_plugin_updater::Builder::new();
    #[cfg(target_os = "macos")]
    {
        updater = updater.target("darwin-universal");
    }
    tauri::Builder::default()
        .plugin(updater.build())
}

Migrar Path al Administrador de Tauri

Las funciones del módulo Rust tauri::api::path y tauri::PathResolver se han movido a tauri::Manager::path:

use tauri::{path::BaseDirectory, Manager};

tauri::Builder::default()
    .setup(|app| {
        let home_dir_path = app.path().home_dir().expect("failed to get home dir");

        let path = app.path().resolve("path/to/something", BaseDirectory::Config)?;

        Ok(())
  })

Migrar a la nueva API de Window

En el lado de Rust, Window fue renombrado a WebviewWindow, su constructor WindowBuilder ahora se llama WebviewWindowBuilder y WindowUrl ahora se llama WebviewUrl.

Además, la función Manager::get_window fue renombrada a get_webview_window y la API de la ventana parent_window fue renombrada a parent_raw para soportar una API de ventana padre de alto nivel.

En el lado de JavaScript, la clase WebviewWindow ahora se exporta en la ruta @tauri-apps/api/webviewWindow.

La función onMenuClicked fue eliminada, puedes interceptar eventos de menú al crear un menú en JavaScript en su lugar.

Migrar Archivos Adicionales Embebidos (Recursos)

En el lado de JavaScript, asegúrate de Migrar al Plugin File System. Además, ten en cuenta los cambios realizados en la lista de permitidos de la v1 en Migrar Permisos.

En el lado de Rust, asegúrate de Migrar Path al Administrador de Tauri.

Migrar Binarios Externos Embebidos (Sidecar)

En Tauri v1, los binarios externos y sus argumentos se definían en la lista de permitidos. En v2, usa el nuevo sistema de permisos. Lee Migrar Permisos para obtener más información.

En el lado de JavaScript, asegúrate de Migrar al Plugin Shell.

En el lado de Rust, la API tauri::api::process fue eliminada. Usa las API tauri_plugin_shell::ShellExt y tauri_plugin_shell::process::CommandEvent en su lugar. Lee la guía de Incrustar Binarios Externos para ver cómo.

La flag de características “process-command-api” se eliminó en la v2. Por lo tanto, ejecutar binarios externos ya no requiere que esta característica esté definida en la configuración de Tauri.

Migrar Permisos

La lista de permitidos de v1 ha sido reescrita en un sistema de permisos completamente nuevo que funciona para plugins individuales y es mucho más configurable para soporte de múltiples ventanas y URL remotas. Este nuevo sistema funciona como una lista de control de acceso (ACL) donde puedes permitir o denegar comandos, asignar permisos a un conjunto específico de ventanas y dominios, y definir alcances de acceso.

Para habilitar permisos para tu aplicación, debes crear archivos de capacidades dentro de la carpeta src-tauri/capabilities, y Tauri configurará automáticamente todo lo demás por ti.

El comando de la CLI migrate analiza automáticamente tu lista de permitidos v1 y genera el archivo de capacidades asociado.

Para obtener más información sobre permisos y capacidades, consulta la documentación de seguridad.