Archivos de configuración

Dado que Tauri es un conjunto de herramientas para crear aplicaciones, puede haber muchos archivos para configurar los ajustes del proyecto. Algunos archivos comunes con los que puedes encontrarte son tauri.conf.json, package.json y Cargo.toml. Explicamos brevemente cada uno en esta página para orientarte en la dirección correcta sobre qué archivos modificar.

Configuración de Tauri

La configuración de Tauri se utiliza para definir la fuente de tu aplicación Web, describir los metadatos de tu aplicación, configurar paquetes, establecer configuraciones de plugins, modificar el comportamiento en tiempo de ejecución configurando ventanas, iconos de la bandeja del sistema, menús y más.

Este archivo lo utilizan el runtime de Tauri y la CLI de Tauri. Puedes definir configuraciones de compilación (como el comando que se ejecuta antes de que tauri build o tauri dev entren en acción), establecer el nombre y la versión de tu aplicación, controlar el runtime de Tauri y configurar plugins.

Consejo

Puedes encontrar todas las opciones en la referencia de configuración.

Formatos soportados

El formato predeterminado de la configuración de Tauri es JSON. El formato JSON5 o TOML se puede habilitar agregando la flag de función config-json5 o config-toml (respectivamente) a las dependencias tauri y tauri-build en Cargo.toml.

Cargo.toml

[build-dependencies]
tauri-build = { version = "2.0.0", features = [ "config-json5" ] }

[dependencies]
tauri = { version = "2.0.0", features = [  "config-json5" ] }

La estructura y los valores son los mismos en todos los formatos; sin embargo, el formato debe ser coherente con el formato del archivo respectivo:

tauri.conf.json

{
  build: {
    devUrl: 'http://localhost:3000',
    // start the dev server
    beforeDevCommand: 'npm run dev',
  },
  bundle: {
    active: true,
    icon: ['icons/app.png'],
  },
  app: {
    windows: [
      {
        title: 'MyApp',
      },
    ],
  },
  plugins: {
    updater: {
      pubkey: 'updater pub key',
      endpoints: ['https://my.app.updater/{{target}}/{{current_version}}'],
    },
  },
}

Tauri.toml

[build]
dev-url = "http://localhost:3000"
# start the dev server
before-dev-command = "npm run dev"

[bundle]
active = true
icon = ["icons/app.png"]

[[app.windows]]
title = "MyApp"

[plugins.updater]
pubkey = "updater pub key"
endpoints = ["https://my.app.updater/{{target}}/{{current_version}}"]

Ten en cuenta que JSON5 y TOML admiten comentarios, y TOML puede usar kebab-case para los nombres de configuración, lo cual es más idiomático. Los nombres de campo distinguen mayúsculas de minúsculas en los 3 formatos.

Configuración específica de la plataforma

Además del archivo de configuración predeterminado, Tauri puede leer una configuración específica de la plataforma desde:

• tauri.linux.conf.json o Tauri.linux.toml para Linux
• tauri.windows.conf.json o Tauri.windows.toml para Windows
• tauri.macos.conf.json o Tauri.macos.toml para macOS
• tauri.android.conf.json o Tauri.android.toml para Android
• tauri.ios.conf.json o Tauri.ios.toml para iOS

El archivo de configuración específico de la plataforma se fusiona con el objeto de configuración principal siguiendo la especificación JSON Merge Patch (RFC 7396).

Por ejemplo, dado el siguiente tauri.conf.json base:

tauri.conf.json

{
  "productName": "MyApp",
  "bundle": {
    "resources": ["./resources"]
  },
  "plugins": {
    "deep-link": {}
  }
}

Y el tauri.linux.conf.json dado:

tauri.linux.conf.json

{
  "productName": "my-app",
  "bundle": {
    "resources": ["./linux-assets"]
  },
  "plugins": {
    "cli": {
      "description": "My app",
      "subcommands": {
        "update": {}
      }
    },
    "deep-link": {}
  }
}

El objeto de configuración resuelto para Linux sería el siguiente:

{
  "productName": "my-app",
  "bundle": {
    "resources": ["./linux-assets"]
  },
  "plugins": {
    "cli": {
      "description": "My app",
      "subcommands": {
        "update": {}
      }
    },
    "deep-link": {}
  }
}

Adicionalmente, puedes proporcionar una configuración para fusionar a través de la CLI; consulta la siguiente sección para obtener más información.

Extender la configuración

La CLI de Tauri te permite extender la configuración de Tauri al ejecutar uno de los comandos dev, android dev, ios dev, build, android build, ios build o bundle. La extensión de la configuración se puede proporcionar mediante el argumento --config, ya sea como una cadena JSON pura o como la ruta a un archivo JSON. Tauri utiliza la especificación JSON Merge Patch (RFC 7396) para fusionar el valor de configuración proporcionado con el objeto de configuración resuelto originalmente.

Este mecanismo se puede utilizar para definir múltiples variantes de tu aplicación o tener más flexibilidad al configurar tus paquetes de aplicación.

Por ejemplo, para distribuir una aplicación beta completamente aislada puedes usar esta función para configurar un nombre e identificador de aplicación separados:

src-tauri/tauri.beta.conf.json

{
  "productName": "My App Beta",
  "identifier": "com.myorg.myappbeta"
}

Y para distribuir esta aplicación beta separada, proporcionas este archivo de configuración al compilarla:

npm

npm run tauri build -- --config src-tauri/tauri.beta.conf.json

yarn

yarn tauri build --config src-tauri/tauri.beta.conf.json

pnpm

pnpm tauri build --config src-tauri/tauri.beta.conf.json

deno

deno task tauri build --config src-tauri/tauri.beta.conf.json

bun

bun tauri build --config src-tauri/tauri.beta.conf.json

cargo

cargo tauri build --config src-tauri/tauri.beta.conf.json

Cargo.toml

El archivo de manifiesto de Cargo se utiliza para declarar los crates de Rust de los que depende tu aplicación, metadatos sobre tu aplicación y otras características relacionadas con Rust. Si no tienes intención de realizar desarrollo backend usando Rust para tu aplicación, es posible que no lo modifiques mucho, pero es importante saber que existe y qué hace.

A continuación se muestra un ejemplo de un archivo Cargo.toml elemental para un proyecto de Tauri:

Cargo.toml

[package]
name = "app"
version = "0.1.0"
description = "A Tauri App"
authors = ["you"]
license = ""
repository = ""
default-run = "app"
edition = "2021"
rust-version = "1.57"

[build-dependencies]
tauri-build = { version = "2.0.0" }

[dependencies]
serde_json = "1.0"
serde = { version = "1.0", features = ["derive"] }
tauri = { version = "2.0.0", features = [ ] }

Las partes más importantes a tener en cuenta son las dependencias tauri-build y tauri. Por lo general, ambas deben estar en la misma versión menor más reciente que la CLI de Tauri, pero esto no es estrictamente obligatorio. Si encuentras problemas al intentar ejecutar tu aplicación, debes verificar que todas las versiones de Tauri (tauri y tauri-cli) estén en las versiones más recientes para sus respectivos lanzamientos menores.

Los números de versión de Cargo utilizan Versioning Semántico (Semver). Al ejecutar cargo update en la carpeta src-tauri se obtendrán las versiones compatibles con Semver más recientes disponibles de todas las dependencias. Por ejemplo, si especificas 2.0.0 como la versión para tauri-build, Cargo detectará y descargará la versión 2.0.1 porque es la versión compatible con Semver más reciente disponible. Tauri actualizará el número de versión mayor cada vez que se introduzca un cambio rompiente, lo que significa que siempre deberías poder actualizar de forma segura a las versiones menores y de parches más recientes sin temor a que tu código se rompa.

Si deseas usar una versión específica de un crate, puedes usar versiones exactas en su lugar anteponiendo = al número de versión de la dependencia:

tauri-build = { version = "=2.0.0" }

Una cosa adicional a tener en cuenta es la parte features=[] de la dependencia tauri. Ejecutar tauri dev y tauri build gestionará automáticamente qué características deben habilitarse en tu proyecto según tu configuración de Tauri. Para obtener más información sobre las flags de características de tauri, consulta la documentación.

Cuando compilas tu aplicación, se produce un archivo Cargo.lock. Este archivo se utiliza principalmente para garantizar que se utilicen las mismas dependencias en todas las máquinas durante el desarrollo (similar a yarn.lock, pnpm-lock.yaml o package-lock.json en Node.js). Se recomienda hacer commit de este archivo en tu repositorio de código fuente para obtener compilaciones consistentes.

Para obtener más información sobre el archivo de manifiesto de Cargo, consulta la documentación oficial.

package.json

Este es el archivo de paquete utilizado por Node.js. Si el frontend de tu aplicación Tauri se desarrolla utilizando tecnologías basadas en Node.js (como npm, yarn o pnpm), este archivo se utiliza para configurar las dependencias y scripts del frontend.

Un ejemplo de un archivo package.json elemental para un proyecto de Tauri podría verse algo así:

package.json

{
  "scripts": {
    "dev": "command to start your app development mode",
    "build": "command to build your app frontend",
    "tauri": "tauri"
  },
  "dependencies": {
    "@tauri-apps/api": "^2.0.0",
    "@tauri-apps/cli": "^2.0.0"
  }
}

Es común usar la sección "scripts" para almacenar los comandos utilizados para iniciar y compilar el frontend utilizado por tu aplicación Tauri. El archivo package.json anterior especifica el comando dev que puedes ejecutar usando yarn dev o npm run dev para iniciar el framework del frontend y el comando build que puedes ejecutar usando yarn build o npm run build para compilar los recursos web de tu frontend para que Tauri los agregue en producción. La forma más conveniente de usar estos scripts es vincularlos con la CLI de Tauri a través de los hooks beforeDevCommand y beforeBuildCommand de la configuración de Tauri:

tauri.conf.json

{
  "build": {
    "beforeDevCommand": "yarn dev",
    "beforeBuildCommand": "yarn build"
  }
}

Nota

El script "tauri" solo es necesario cuando se usa npm

El objeto de dependencias especifica qué dependencias debe descargar Node.js cuando ejecutas yarn, pnpm install o npm install (en este caso, la CLI y la API de Tauri).

Además del archivo package.json, es posible que veas un archivo yarn.lock, pnpm-lock.yaml o package-lock.json. Estos archivos ayudan a garantizar que cuando descargues las dependencias más adelante, obtendrás exactamente las mismas versiones que has usado durante el desarrollo (similar a Cargo.lock en Rust).

Para obtener más información sobre el formato del archivo package.json, consulta la documentación oficial.