Merge branch 'v2' into i18n-calling-rust

Author: dreyfus92

astro.config.mjs

@@ -284,6 +284,10 @@ export default defineConfig({
               collapsed: true,
               autogenerate: { directory: 'plugin' },
             },
+            {
+              label: 'Contribute',
+              link: '/contribute/',
+            },
             {
               label: 'About',
               translations: {

package.json

@@ -33,17 +33,17 @@
     "astro-d2": "^0.6.0",
     "astro-feelback": "^0.3.4",
     "astrojs-service-worker": "^2.0.0",
-    "jsdom": "^26.0.0",
+    "jsdom": "^26.1.0",
     "prettier": "^3.2.5",
     "prettier-plugin-astro": "^0.14.0",
     "rehype-autolink-headings": "^7.1.0",
-    "sass": "^1.77.2",
-    "sharp": "^0.33.2",
-    "shiki": "^1.1.7",
+    "sass": "^1.89.0",
+    "sharp": "^0.33.5",
+    "shiki": "^3.0.0",
     "starlight-blog": "^0.15.0",
     "starlight-links-validator": "^0.13.0"
   },
-  "packageManager": "pnpm@10.10.0",
+  "packageManager": "pnpm@10.12.3",
   "engines": {
     "pnpm": "^10.0.0"
   },

packages/awesome-tauri

@@ -7,5 +7,12 @@
   "git-submodules": {
     "enabled": true,
     "schedule": ["every weekend"]
-  }
+  },
+  "packageRules": [
+    {
+      "matchPackageNames": ["/.*astro.*/i", "/.*starlight.*/i", "/.*typedoc.*/i"],
+      "groupName": "astro & starlight packages",
+      "separateMajorMinor": false
+    }
+  ]
 }

packages/plugins-workspace

@@ -2,7 +2,7 @@
 title: Tauri Board Elections 2024
 date: 2024-06-28
 authors: [jbolda]
-excerpt: The Tauri Programme is celebrating it's third anniversary of Tauri becoming a programme within The Commons Conservancy. We are hard at work bringing v2 to a stable release, and now the next round of Tauri Board Director elections is upon us!
+excerpt: The Tauri Programme is celebrating its third anniversary of Tauri becoming a programme within The Commons Conservancy. We are hard at work bringing v2 to a stable release, and now the next round of Tauri Board Director elections is upon us!
 ---
 
 The Tauri Programme is celebrating its third anniversary of Tauri becoming a programme within [The Commons Conservancy](https://commonsconservancy.org/). We are hard at work bringing v2 to a stable release, and now the next round of Tauri Board Director elections is upon us! Want to [get involved in other ways](#interested-in-getting-involved) and help Tauri towards v2? We would love your contributions especially to help evolve the documentation!

packages/tauri

@@ -16,13 +16,15 @@ legacy systems.
 ## Configuration
 
 Because the Brownfield pattern is the default pattern, it doesn't require a configuration option to be set. To explicitly set
-it, you can use the `tauri > pattern` object in the `tauri.conf.json` configuration file.
+it, you can use the `app > security > pattern` object in the `tauri.conf.json` configuration file.
 
 ```json
 {
-  "tauri": {
-    "pattern": {
-      "use": "brownfield"
+  "app": {
+    "security": {
+      "pattern": {
+        "use": "brownfield"
+      }
     }
   }
 }

pnpm-lock.yaml

@@ -103,7 +103,7 @@ This won't be accounting for dynamically added ACLs at runtime so make sure to c
 and let them generate a list of allowed commands from the ACL,
 this will then be used by the `generate_handler` macro to remove unused commands based on that
 
-An internal detial is this environment variable is currently `REMOVE_UNUSED_COMMANDS`,
+An internal detail is this environment variable is currently `REMOVE_UNUSED_COMMANDS`,
 and it's set to project's directory, usually the `src-tauri` directory, this is used for the build scripts to find the capability files,
 and although it's not encouraged, you can still set this environment variable yourself if you can't or don't want to use `tauri-cli` to get this to work
 (**do note that as this is an implementation detail, we don't guarantee the stability of it**)

renovate.json

@@ -0,0 +1,23 @@
+---
+title: Contribute
+description: Guide for Tauri contributors
+sidebar:
+  order: 0
+  label: Overview
+  badge:
+    text: New
+    variant: tip
+---
+
+We, the maintainers, are really excited that you are interested in contributing to Tauri. We welcome contributors of any skill level and are happy to provide guidance on PRs.
+In case of any doubts you can reach out to us on [our Discord server](https://discord.gg/SpmNs4S).
+
+### Project repositories
+
+Main Tauri repositories you can contribute to are:
+
+- The [core Tauri](https://github.com/tauri-apps/tauri/) repository containing the Tauri runtime, build tools, macros and utils.
+- [Plugins workspace](https://github.com/tauri-apps/plugins-workspace) repository with all the official Tauri plugins
+- [Tauri Docs](https://github.com/tauri-apps/tauri-docs) repository containing this website
+
+Each of those Tauri repositories contains a `.github/CONTRIBUTING.md` file. In it you will find instructions on how to set up local development environment and submit a Pull Request.

src/content/docs/blog/tauri-board-elections-2024.md

@@ -216,6 +216,20 @@ class ExamplePlugin(private val activity: Activity): Plugin(activity) {
 }
 ```
 
+:::note
+On Android native commands are scheduled on the main thread. Performing long-running operations will cause the UI to freeze and potentially "Application Not Responding" (ANR) error.
+
+If you need to wait for some blocking IO, you can launch a corouting like that:
+
+```kotlin
+CoroutineScope(Dispatchers.IO).launch {
+  val result = myLongRunningOperation()
+  invoke.resolve(result)
+}
+```
+
+:::
+
 </TabItem>
 <TabItem label="iOS">
 

src/content/docs/concept/Inter-Process Communication/brownfield.md

@@ -171,7 +171,7 @@ The string provided to `Command.sidecar` must match one of the strings defined i
 
 You can pass arguments to Sidecar commands just like you would for running normal [Command][std::process::Command].
 
-Arguments can be either **static** (e.g. `-o` or `serve`) or **dynamic** (e.g. `<file_path>` or `localhost:<PORT>`). You define the arguments in the exact order in which you'd call them. Static arguments are defined as-is, while dynamic arguments can be defined using a regular expression.
+Arguments can be either **static** (e.g. `-o` or `serve`) or **dynamic** (e.g. `<file_path>` or `localhost:<PORT>`). A value of `true` will allow any arguments to be passed to the command. `false` will disable all arguments. If neither `true` or `false` is set, you define the arguments in the exact order in which you'd call them. Static arguments are defined as-is, while dynamic arguments can be defined using a regular expression.
 
 First, define the arguments that need to be passed to the sidecar command in `src-tauri/capabilities/default.json`:
 

src/content/docs/concept/size.mdx

@@ -10,7 +10,7 @@ Code signing is required on macOS to allow your application to be listed in the
 
 ## Prerequisites
 
-Code signing on macOS requires an [Apple Developer] account which is either paid (99$ per year) or on the free plan. You also need an Apple device where you perform the code signing. This is required by the signing process and due to Apple's Terms and Conditions.
+Code signing on macOS requires an [Apple Developer] account which is either paid (99$ per year) or on the free plan (only for testing and development purposes). You also need an Apple device where you perform the code signing. This is required by the signing process and due to Apple's Terms and Conditions.
 
 :::note
 Note when using a free Apple Developer account, you will not be able to notarize your application and it will still show up as not verified when opening the app.
@@ -134,6 +134,7 @@ jobs:
           security create-keychain -p "$KEYCHAIN_PASSWORD" build.keychain
           security default-keychain -s build.keychain
           security unlock-keychain -p "$KEYCHAIN_PASSWORD" build.keychain
+          security set-keychain-settings -t 3600 -u build.keychain
           security import certificate.p12 -k build.keychain -P "$APPLE_CERTIFICATE_PASSWORD" -T /usr/bin/codesign
           security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k "$KEYCHAIN_PASSWORD" build.keychain
           security find-identity -v -p codesigning build.keychain

src/content/docs/contribute/index.mdx

@@ -75,6 +75,8 @@ finish-args:
   - --socket=fallback-x11 # Permission needed to show the window
   - --device=dri # OpenGL, not necessary for all projects
   - --share=ipc
+  - --talk-name=org.kde.StatusNotifierWatcher # Optional: needed only if your app uses the tray icon
+  - --filesystem=xdg-run/tray-icon:create # Optional: needed only if your app uses the tray icon - see an alternative way below
 
 modules:
   - name: binary
@@ -99,6 +101,19 @@ modules:
 
 The Gnome 46 runtime includes all dependencies of the standard Tauri app with their correct versions.
 
+:::note[Using tray-icon without changing the Flatpak manifest]
+If you prefer not opening access from your app to $XDG_RUNTIME_DIR (where tray-icon is saved on linux), you can change the path tauri saves the tray image:
+
+```rust
+TrayIconBuilder::new()
+  .icon(app.default_window_icon().unwrap().clone())
+  .temp_dir_path(app.path().app_cache_dir().unwrap()) // will save to the cache folder ($XDG_CACHE_HOME) where the app already has permission
+  .build()
+  .unwrap();
+```
+
+:::
+
 **5. Install, and Test the app**
 
 ```shell

src/content/docs/develop/Plugins/develop-mobile.mdx

@@ -84,6 +84,24 @@ apps:
     #  - network
     # Add whatever plugs you need here, see https://snapcraft.io/docs/snapcraft-interfaces for more info.
     # The gnome extension already includes [ desktop, desktop-legacy, gsettings, opengl, wayland, x11, mount-observe, calendar-service ]
+    #  - single-instance-plug # add this if you're using the single-instance plugin
+    #slots:
+    # Add the slots you need to expose to other snaps
+    #  - single-instance-plug # add this if you're using the single-instance plugin
+
+# Add these lines only if you're using the single-instance plugin
+# Check https://v2.tauri.app/plugin/single-instance/ for details
+#slots:
+#  single-instance:
+#    interface: dbus
+#    bus: session
+#    name: org.net_mydomain_MyApp.SingleInstance # Remember to change net_mydomain_MyApp to your app ID with "_" instead of "." and "-"
+#
+#plugs:
+#  single-instance-plug:
+#    interface: dbus
+#    bus: session
+#    name: org.net_mydomain_MyApp.SingleInstance # Remember to change net_mydomain_MyApp to your app ID with "_" instead of "." and "-"
 
 package-repositories:
   - type: apt

src/content/docs/develop/sidecar.mdx

@@ -0,0 +1,158 @@
+---
+title: Inicio automático
+description: Inicia automáticamente tu aplicación al arrancar el sistema.
+plugin: autostart
+i18nReady: true
+---
+
+import PluginLinks from '@components/PluginLinks.astro';
+import Compatibility from '@components/plugins/Compatibility.astro';
+
+import { Tabs, TabItem, Steps } from '@astrojs/starlight/components';
+import CommandTabs from '@components/CommandTabs.astro';
+import PluginPermissions from '@components/PluginPermissions.astro';
+
+<PluginLinks plugin={frontmatter.plugin} />
+
+Inicia automáticamente tu aplicación al arrancar el sistema.
+
+## Plataformas compatibles
+
+<Compatibility plugin={frontmatter.plugin} />
+
+## Configuración
+
+Instala el plugin de autostart para comenzar.
+
+<Tabs>
+  <TabItem label="Automático">
+
+    Usa el gestor de paquetes de tu proyecto para añadir la dependencia:
+
+    {' '}
+
+    <CommandTabs
+      npm="npm run tauri add autostart"
+      yarn="yarn run tauri add autostart"
+      pnpm="pnpm tauri add autostart"
+      deno="deno task tauri add autostart"
+      bun="bun tauri add autostart"
+      cargo="cargo tauri add autostart"
+    />
+
+  </TabItem>
+    <TabItem label="Manual">
+      <Steps>
+
+        1. Ejecuta el siguiente comando en la carpeta `src-tauri` para añadir el plugin a las dependencias del proyecto en `Cargo.toml`:
+
+            ```sh frame=none
+            cargo add tauri-plugin-autostart --target 'cfg(any(target_os = "macos", windows, target_os = "linux"))'
+            ```
+
+        2.  Modifica `lib.rs` para inicializar el plugin:
+
+            ```rust title="src-tauri/src/lib.rs" ins={5-6}
+            #[cfg_attr(mobile, tauri::mobile_entry_point)]
+            pub fn run() {
+                tauri::Builder::default()
+                    .setup(|app| {
+                        #[cfg(desktop)]
+                        app.handle().plugin(tauri_plugin_autostart::init(tauri_plugin_autostart::MacosLauncher::LaunchAgent, Some(vec!["--flag1", "--flag2"]) /* arbitrary number of args to pass to your app */));
+                        Ok(())
+                    })
+                    .run(tauri::generate_context!())
+                    .expect("error al ejecutar la aplicación tauri");
+            }
+            ```
+
+        3.  Puedes instalar los enlaces de JavaScript Guest utilizando tu gestor de paquetes de JavaScript preferido:
+
+            <CommandTabs
+                npm="npm install @tauri-apps/plugin-autostart"
+                yarn="yarn add @tauri-apps/plugin-autostart"
+                pnpm="pnpm add @tauri-apps/plugin-autostart"
+                deno="deno add npm:@tauri-apps/plugin-autostart"
+                bun="bun add @tauri-apps/plugin-autostart"
+            />
+
+      </Steps>
+    </TabItem>
+
+</Tabs>
+
+## Uso
+
+El plugin de autostart está disponible tanto en JavaScript como en Rust.
+
+<Tabs syncKey="lang">
+  <TabItem label="JavaScript">
+
+```javascript
+import { enable, isEnabled, disable } from '@tauri-apps/plugin-autostart';
+// si utilizas `"withGlobalTauri": true`, deberías usar
+// const { enable, isEnabled, disable } = window.__TAURI__.autostart;
+
+// Activar el arranque automático
+await enable();
+// Comprobar el estado de activación
+console.log(`registered for autostart? ${await isEnabled()}`);
+// Desactivar el arranque automático
+disable();
+```
+
+  </TabItem>
+  <TabItem label="Rust">
+
+```rust
+#[cfg_attr(mobile, tauri::mobile_entry_point)]
+pub fn run() {
+    tauri::Builder::default()
+        .setup(|app| {
+            #[cfg(desktop)]
+            {
+                use tauri_plugin_autostart::MacosLauncher;
+                use tauri_plugin_autostart::ManagerExt;
+
+                app.handle().plugin(tauri_plugin_autostart::init(
+                    MacosLauncher::LaunchAgent,
+                    Some(vec!["--flag1", "--flag2"]),
+                ));
+
+                // Obtener el gestor de arranque automático
+                let autostart_manager = app.autolaunch();
+                // Activar el arranque automático
+                let _ = autostart_manager.enable();
+                // Comprobar el estado de activación
+                println!("registered for autostart? {}", autostart_manager.is_enabled().unwrap());
+                // Desactivar el arranque automático
+                let _ = autostart_manager.disable();
+            }
+            Ok(())
+        })
+        .run(tauri::generate_context!())
+        .expect("error al ejecutar la aplicación tauri");
+}
+```
+
+  </TabItem>
+</Tabs>
+
+## Permisos
+
+Por defecto, todos los comandos y ámbitos de plugin potencialmente peligrosos están bloqueados y no se pueden acceder. Debes modificar los permisos en tu configuración de `capabilities` para habilitar estos.
+
+Consulta la [Descripción general de capacidades](/es/security/capabilities/) para obtener más información y la [guía paso a paso](/es/learn/security/using-plugin-permissions/) para utilizar los permisos de plugin.
+
+```json title="src-tauri/capabilities/default.json"
+{
+  "permissions": [
+    ...,
+    "autostart:allow-enable",
+    "autostart:allow-disable",
+    "autostart:allow-is-enabled"
+  ]
+}
+```
+
+<PluginPermissions plugin={frontmatter.plugin} />