Merge remote-tracking branch 'origin/dev' into feat/update-wry

.changes/api-tray-menu.md

@@ -0,0 +1,5 @@
+---
+'@tauri-apps/api': 'minor:feat'
+---
+
+Add `tray` and `menu` modules to create and manage tray icons and menus from Javascript.

.changes/fix-file-drop-event-payload.md

@@ -0,0 +1,5 @@
+---
+"@tauri-apps/api": 'patch:enhance'
+---
+
+Added `position` field to the `FileDropEvent` payload.

.changes/fix-ide-build-run.md

@@ -0,0 +1,6 @@
+---
+"tauri-cli": patch:bug
+"@tauri-apps/cli": patch:bug
+---
+
+Fixes `android build --open` and `ios build --open` IDE failing to read CLI options.

.changes/merge-ios-plist.md

@@ -0,0 +1,6 @@
+---
+"tauri-cli": patch:feat
+"@tauri-apps/cli": patch:feat
+---
+
+Merge `src-tauri/Info.plist` and `src-tauri/Info.ios.plist` with the iOS project plist file.

.changes/syn-2.0.md

@@ -0,0 +1,5 @@
+---
+"tauri-macros": patch:deps
+---
+
+Update to syn v2.

.changes/xcode-archive.md

@@ -0,0 +1,6 @@
+---
+"tauri-cli": patch:bug
+"@tauri-apps/cli": patch:bug
+---
+
+Added support to Xcode's archive. This requires regenerating the Xcode project.

.github/workflows/lint-js.yml

@@ -49,6 +49,9 @@ jobs:
       - name: install deps via yarn
         working-directory: ./tooling/api/
         run: yarn
+      - name: run ts:check
+        working-directory: ./tooling/api/
+        run: yarn ts:check
       - name: run lint
         working-directory: ./tooling/api/
         run: yarn lint

.husky/pre-commit

@@ -11,7 +11,7 @@ if [ -z "$(git diff --name-only tooling/api)" ]; then
 else
   cd tooling/api
   yarn format
-  yarn lint-fix
+  yarn lint:fix
   cd ../..
 fi
 

.scripts/ci/check-license-header.js

@@ -13,6 +13,8 @@ SPDX-License-Identifier: Apache-2.0
 SPDX-License-Identifier: MIT`
 const bundlerLicense =
   '// Copyright 2016-2019 Cargo-Bundle developers <https://github.com/burtonageo/cargo-bundle>'
+const denoLicense =
+  '// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.'
 
 const extensions = ['.rs', '.js', '.ts', '.yml', '.swift', '.kt']
 const ignore = [
@@ -43,7 +45,8 @@ async function checkFile(file) {
         line.length === 0 ||
         line.startsWith('#!') ||
         line.startsWith('// swift-tools-version:') ||
-        line === bundlerLicense
+        line === bundlerLicense ||
+        line === denoLicense
       ) {
         continue
       }

core/tauri-macros/Cargo.toml

@@ -18,7 +18,7 @@ proc-macro = true
 [dependencies]
 proc-macro2 = "1"
 quote = "1"
-syn = { version = "1", features = [ "full" ] }
+syn = { version = "2", features = [ "full" ] }
 heck = "0.4"
 tauri-codegen = { version = "2.0.0-alpha.10", default-features = false, path = "../tauri-codegen" }
 tauri-utils = { version = "2.0.0-alpha.10", path = "../tauri-utils" }

core/tauri-macros/src/command/handler.rs

@@ -31,7 +31,7 @@ pub struct Handler {
 
 impl Parse for Handler {
   fn parse(input: &ParseBuffer<'_>) -> syn::Result<Self> {
-    let command_defs = input.parse_terminated::<CommandDef, Token![,]>(CommandDef::parse)?;
+    let command_defs = input.parse_terminated(CommandDef::parse, Token![,])?;
 
     // parse the command names and wrappers from the passed paths
     let (commands, wrappers) = command_defs

core/tauri-macros/src/command/wrapper.rs

@@ -10,10 +10,28 @@ use syn::{
   ext::IdentExt,
   parse::{Parse, ParseStream},
   parse_macro_input,
+  punctuated::Punctuated,
   spanned::Spanned,
-  FnArg, ItemFn, Lit, Meta, Pat, Token, Visibility,
+  Expr, ExprLit, FnArg, ItemFn, Lit, Meta, Pat, Token, Visibility,
 };
 
+enum WrapperAttributeKind {
+  Meta(Meta),
+  Async,
+}
+
+impl Parse for WrapperAttributeKind {
+  fn parse(input: ParseStream) -> syn::Result<Self> {
+    match input.parse::<Meta>() {
+      Ok(m) => Ok(Self::Meta(m)),
+      Err(e) => match input.parse::<Token![async]>() {
+        Ok(_) => Ok(Self::Async),
+        Err(_) => Err(e),
+      },
+    }
+  }
+}
+
 struct WrapperAttributes {
   root: TokenStream2,
   execution_context: ExecutionContext,
@@ -28,12 +46,19 @@ impl Parse for WrapperAttributes {
       argument_case: ArgumentCase::Camel,
     };
 
-    loop {
-      match input.parse::<Meta>() {
-        Ok(Meta::List(_)) => {}
-        Ok(Meta::NameValue(v)) => {
+    let attrs = Punctuated::<WrapperAttributeKind, Token![,]>::parse_terminated(input)?;
+    for attr in attrs {
+      match attr {
+        WrapperAttributeKind::Meta(Meta::List(_)) => {
+          return Err(syn::Error::new(input.span(), "unexpected list input"));
+        }
+        WrapperAttributeKind::Meta(Meta::NameValue(v)) => {
           if v.path.is_ident("rename_all") {
-            if let Lit::Str(s) = v.lit {
+            if let Expr::Lit(ExprLit {
+              lit: Lit::Str(s),
+              attrs: _,
+            }) = v.value
+            {
               wrapper_attributes.argument_case = match s.value().as_str() {
                 "snake_case" => ArgumentCase::Snake,
                 "camelCase" => ArgumentCase::Camel,
@@ -46,7 +71,11 @@ impl Parse for WrapperAttributes {
               };
             }
           } else if v.path.is_ident("root") {
-            if let Lit::Str(s) = v.lit {
+            if let Expr::Lit(ExprLit {
+              lit: Lit::Str(s),
+              attrs: _,
+            }) = v.value
+            {
               let lit = s.value();
 
               wrapper_attributes.root = if lit == "crate" {
@@ -58,22 +87,16 @@ impl Parse for WrapperAttributes {
             }
           }
         }
-        Ok(Meta::Path(p)) => {
-          if p.is_ident("async") {
-            wrapper_attributes.execution_context = ExecutionContext::Async;
-          } else {
-            return Err(syn::Error::new(p.span(), "expected `async`"));
-          }
+        WrapperAttributeKind::Meta(Meta::Path(_)) => {
+          return Err(syn::Error::new(
+            input.span(),
+            "unexpected input, expected one of `rename_all`, `root`, `async`",
+          ));
         }
-        Err(_e) => {
-          break;
+        WrapperAttributeKind::Async => {
+          wrapper_attributes.execution_context = ExecutionContext::Async;
         }
       }
-
-      let lookahead = input.lookahead1();
-      if lookahead.peek(Token![,]) {
-        input.parse::<Token![,]>()?;
-      }
     }
 
     Ok(wrapper_attributes)
@@ -101,10 +124,15 @@ struct Invoke {
 
 /// Create a new [`Wrapper`] from the function and the generated code parsed from the function.
 pub fn wrapper(attributes: TokenStream, item: TokenStream) -> TokenStream {
+  let mut attrs = parse_macro_input!(attributes as WrapperAttributes);
   let function = parse_macro_input!(item as ItemFn);
   let wrapper = super::format_command_wrapper(&function.sig.ident);
   let visibility = &function.vis;
 
+  if function.sig.asyncness.is_some() {
+    attrs.execution_context = ExecutionContext::Async;
+  }
+
   // macros used with `pub use my_macro;` need to be exported with `#[macro_export]`
   let maybe_macro_export = match &function.vis {
     Visibility::Public(_) => quote!(#[macro_export]),
@@ -173,28 +201,18 @@ pub fn wrapper(attributes: TokenStream, item: TokenStream) -> TokenStream {
     }
   }
 
-  // body to the command wrapper or a `compile_error!` of an error occurred while parsing it.
-  let (body, attributes) = syn::parse::<WrapperAttributes>(attributes)
-    .map(|mut attrs| {
-      if function.sig.asyncness.is_some() {
-        attrs.execution_context = ExecutionContext::Async;
-      }
-      attrs
-    })
-    .and_then(|attrs| {
-      let body = match attrs.execution_context {
-        ExecutionContext::Async => body_async(&function, &invoke, &attrs),
-        ExecutionContext::Blocking => body_blocking(&function, &invoke, &attrs),
-      };
-      body.map(|b| (b, Some(attrs)))
-    })
-    .unwrap_or_else(|e| (syn::Error::into_compile_error(e), None));
+  let body = match attrs.execution_context {
+    ExecutionContext::Async => {
+      body_async(&function, &invoke, &attrs).unwrap_or_else(syn::Error::into_compile_error)
+    }
+    ExecutionContext::Blocking => {
+      body_blocking(&function, &invoke, &attrs).unwrap_or_else(syn::Error::into_compile_error)
+    }
+  };
 
   let Invoke { message, resolver } = invoke;
 
-  let root = attributes
-    .map(|a| a.root)
-    .unwrap_or_else(|| quote!(::tauri));
+  let root = attrs.root;
 
   // Rely on rust 2018 edition to allow importing a macro from a path.
   quote!(

core/tauri-macros/src/lib.rs

@@ -16,6 +16,7 @@ use proc_macro::TokenStream;
 use syn::{parse_macro_input, DeriveInput};
 
 mod command;
+mod menu;
 mod mobile;
 mod runtime;
 
@@ -89,3 +90,64 @@ pub fn default_runtime(attributes: TokenStream, input: TokenStream) -> TokenStre
   let input = parse_macro_input!(input as DeriveInput);
   runtime::default_runtime(attributes, input).into()
 }
+
+/// Accepts a closure-like syntax to call arbitrary code on a menu item
+/// after matching against `kind` and retrieving it from `resources_table` using `rid`.
+///
+/// You can optionally pass a third parameter to select which item kinds
+/// to match against, by providing a `|` separated list of item kinds
+/// ```ignore
+/// do_menu_item!(|i| i.set_text(text), Check | Submenu);
+/// ```
+/// You could also provide a negated list
+/// ```ignore
+/// do_menu_item!(|i| i.set_text(text), !Check);
+/// do_menu_item!(|i| i.set_text(text), !Check | !Submenu);
+/// ```
+/// but you can't have mixed negations and positive kinds.
+/// ```ignore
+/// do_menu_item!(|i| i.set_text(text), !Check | Submeun);
+/// ```
+///
+/// #### Example
+///
+/// ```ignore
+///  let rid = 23;
+///  let kind = ItemKind::Check;
+///  let resources_table = app.manager.resources_table();
+///  do_menu_item!(|i| i.set_text(text))
+/// ```
+/// which will expand into:
+/// ```ignore
+///  let rid = 23;
+///  let kind = ItemKind::Check;
+///  let resources_table = app.manager.resources_table();
+///  match kind {
+///  ItemKind::Submenu => {
+///    let i = resources_table.get::<Submenu<R>>(rid)?;
+///    i.set_text(text)
+///  }
+///  ItemKind::MenuItem => {
+///    let i = resources_table.get::<MenuItem<R>>(rid)?;
+///    i.set_text(text)
+///  }
+///  ItemKind::Predefined => {
+///    let i = resources_table.get::<PredefinedMenuItem<R>>(rid)?;
+///    i.set_text(text)
+///  }
+///  ItemKind::Check => {
+///    let i = resources_table.get::<CheckMenuItem<R>>(rid)?;
+///    i.set_text(text)
+///  }
+///  ItemKind::Icon => {
+///    let i = resources_table.get::<IconMenuItem<R>>(rid)?;
+///    i.set_text(text)
+///  }
+///  _ => unreachable!(),
+///  }
+/// ```
+#[proc_macro]
+pub fn do_menu_item(input: TokenStream) -> TokenStream {
+  let tokens = parse_macro_input!(input as menu::DoMenuItemInput);
+  menu::do_menu_item(tokens).into()
+}