react-native-audio-browser 0.2.0-next.11 → 0.2.0-next.13

package/nitrogen/generated/shared/c++/Track.hpp

@@ -35,9 +35,7 @@ namespace margelo::nitro::audiobrowser { struct ImageSource; }
 // Forward declaration of `TrackRequest` to properly resolve imports.
 namespace margelo::nitro::audiobrowser { struct TrackRequest; }
 // Forward declaration of `TrackStyle` to properly resolve imports.
-namespace margelo::nitro::audiobrowser { enum class TrackStyle; }
-// Forward declaration of `ImageRowItem` to properly resolve imports.
-namespace margelo::nitro::audiobrowser { struct ImageRowItem; }
+namespace margelo::nitro::audiobrowser { struct TrackStyle; }
 
 #include <string>
 #include <optional>
@@ -46,8 +44,6 @@ namespace margelo::nitro::audiobrowser { struct ImageRowItem; }
 #include "ImageSource.hpp"
 #include "TrackRequest.hpp"
 #include "TrackStyle.hpp"
-#include "ImageRowItem.hpp"
-#include <vector>
 
 namespace margelo::nitro::audiobrowser {
 
@@ -57,30 +53,27 @@ namespace margelo::nitro::audiobrowser {
   struct Track final {
   public:
     std::optional<std::string> id     SWIFT_PRIVATE;
-    std::optional<std::string> url     SWIFT_PRIVATE;
+    std::optional<std::string> path     SWIFT_PRIVATE;
     std::optional<std::string> src     SWIFT_PRIVATE;
     std::optional<std::variant<std::string, ArtworkVariants>> artwork     SWIFT_PRIVATE;
     std::optional<ImageSource> artworkSource     SWIFT_PRIVATE;
     std::optional<TrackRequest> request     SWIFT_PRIVATE;
-    std::optional<bool> artworkCarPlayTinted     SWIFT_PRIVATE;
     std::string title     SWIFT_PRIVATE;
     std::optional<std::string> subtitle     SWIFT_PRIVATE;
     std::optional<std::string> artist     SWIFT_PRIVATE;
-    std::optional<std::string> albumUrl     SWIFT_PRIVATE;
+    std::optional<std::string> albumPath     SWIFT_PRIVATE;
     std::optional<std::string> album     SWIFT_PRIVATE;
     std::optional<std::string> description     SWIFT_PRIVATE;
     std::optional<std::string> genre     SWIFT_PRIVATE;
     std::optional<double> duration     SWIFT_PRIVATE;
     std::optional<TrackStyle> style     SWIFT_PRIVATE;
-    std::optional<TrackStyle> childrenStyle     SWIFT_PRIVATE;
+    std::optional<bool> disabled     SWIFT_PRIVATE;
     std::optional<bool> favorited     SWIFT_PRIVATE;
-    std::optional<std::string> groupTitle     SWIFT_PRIVATE;
     std::optional<bool> live     SWIFT_PRIVATE;
-    std::optional<std::vector<ImageRowItem>> imageRow     SWIFT_PRIVATE;
 
   public:
     Track() = default;
-    explicit Track(std::optional<std::string> id, std::optional<std::string> url, std::optional<std::string> src, std::optional<std::variant<std::string, ArtworkVariants>> artwork, std::optional<ImageSource> artworkSource, std::optional<TrackRequest> request, std::optional<bool> artworkCarPlayTinted, std::string title, std::optional<std::string> subtitle, std::optional<std::string> artist, std::optional<std::string> albumUrl, std::optional<std::string> album, std::optional<std::string> description, std::optional<std::string> genre, std::optional<double> duration, std::optional<TrackStyle> style, std::optional<TrackStyle> childrenStyle, std::optional<bool> favorited, std::optional<std::string> groupTitle, std::optional<bool> live, std::optional<std::vector<ImageRowItem>> imageRow): id(id), url(url), src(src), artwork(artwork), artworkSource(artworkSource), request(request), artworkCarPlayTinted(artworkCarPlayTinted), title(title), subtitle(subtitle), artist(artist), albumUrl(albumUrl), album(album), description(description), genre(genre), duration(duration), style(style), childrenStyle(childrenStyle), favorited(favorited), groupTitle(groupTitle), live(live), imageRow(imageRow) {}
+    explicit Track(std::optional<std::string> id, std::optional<std::string> path, std::optional<std::string> src, std::optional<std::variant<std::string, ArtworkVariants>> artwork, std::optional<ImageSource> artworkSource, std::optional<TrackRequest> request, std::string title, std::optional<std::string> subtitle, std::optional<std::string> artist, std::optional<std::string> albumPath, std::optional<std::string> album, std::optional<std::string> description, std::optional<std::string> genre, std::optional<double> duration, std::optional<TrackStyle> style, std::optional<bool> disabled, std::optional<bool> favorited, std::optional<bool> live): id(id), path(path), src(src), artwork(artwork), artworkSource(artworkSource), request(request), title(title), subtitle(subtitle), artist(artist), albumPath(albumPath), album(album), description(description), genre(genre), duration(duration), style(style), disabled(disabled), favorited(favorited), live(live) {}
 
   public:
     friend bool operator==(const Track& lhs, const Track& rhs) = default;
@@ -97,51 +90,45 @@ namespace margelo::nitro {
       jsi::Object obj = arg.asObject(runtime);
       return margelo::nitro::audiobrowser::Track(
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "id"))),
-        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "url"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "path"))),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "src"))),
         JSIConverter<std::optional<std::variant<std::string, margelo::nitro::audiobrowser::ArtworkVariants>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "artwork"))),
         JSIConverter<std::optional<margelo::nitro::audiobrowser::ImageSource>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "artworkSource"))),
         JSIConverter<std::optional<margelo::nitro::audiobrowser::TrackRequest>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "request"))),
-        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "artworkCarPlayTinted"))),
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "title"))),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "subtitle"))),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "artist"))),
-        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "albumUrl"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "albumPath"))),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "album"))),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "description"))),
         JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "genre"))),
         JSIConverter<std::optional<double>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "duration"))),
         JSIConverter<std::optional<margelo::nitro::audiobrowser::TrackStyle>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "style"))),
-        JSIConverter<std::optional<margelo::nitro::audiobrowser::TrackStyle>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "childrenStyle"))),
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "disabled"))),
         JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "favorited"))),
-        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "groupTitle"))),
-        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "live"))),
-        JSIConverter<std::optional<std::vector<margelo::nitro::audiobrowser::ImageRowItem>>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "imageRow")))
+        JSIConverter<std::optional<bool>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "live")))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::audiobrowser::Track& arg) {
       jsi::Object obj(runtime);
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "id"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.id));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "url"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.url));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "path"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.path));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "src"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.src));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "artwork"), JSIConverter<std::optional<std::variant<std::string, margelo::nitro::audiobrowser::ArtworkVariants>>>::toJSI(runtime, arg.artwork));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "artworkSource"), JSIConverter<std::optional<margelo::nitro::audiobrowser::ImageSource>>::toJSI(runtime, arg.artworkSource));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "request"), JSIConverter<std::optional<margelo::nitro::audiobrowser::TrackRequest>>::toJSI(runtime, arg.request));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "artworkCarPlayTinted"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.artworkCarPlayTinted));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "title"), JSIConverter<std::string>::toJSI(runtime, arg.title));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "subtitle"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.subtitle));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "artist"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.artist));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "albumUrl"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.albumUrl));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "albumPath"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.albumPath));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "album"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.album));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "description"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.description));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "genre"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.genre));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "duration"), JSIConverter<std::optional<double>>::toJSI(runtime, arg.duration));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "style"), JSIConverter<std::optional<margelo::nitro::audiobrowser::TrackStyle>>::toJSI(runtime, arg.style));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "childrenStyle"), JSIConverter<std::optional<margelo::nitro::audiobrowser::TrackStyle>>::toJSI(runtime, arg.childrenStyle));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "disabled"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.disabled));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "favorited"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.favorited));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "groupTitle"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.groupTitle));
       obj.setProperty(runtime, PropNameIDCache::get(runtime, "live"), JSIConverter<std::optional<bool>>::toJSI(runtime, arg.live));
-      obj.setProperty(runtime, PropNameIDCache::get(runtime, "imageRow"), JSIConverter<std::optional<std::vector<margelo::nitro::audiobrowser::ImageRowItem>>>::toJSI(runtime, arg.imageRow));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -153,26 +140,23 @@ namespace margelo::nitro {
         return false;
       }
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "id")))) return false;
-      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "url")))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "path")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "src")))) return false;
       if (!JSIConverter<std::optional<std::variant<std::string, margelo::nitro::audiobrowser::ArtworkVariants>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "artwork")))) return false;
       if (!JSIConverter<std::optional<margelo::nitro::audiobrowser::ImageSource>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "artworkSource")))) return false;
       if (!JSIConverter<std::optional<margelo::nitro::audiobrowser::TrackRequest>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "request")))) return false;
-      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "artworkCarPlayTinted")))) return false;
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "title")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "subtitle")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "artist")))) return false;
-      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "albumUrl")))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "albumPath")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "album")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "description")))) return false;
       if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "genre")))) return false;
       if (!JSIConverter<std::optional<double>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "duration")))) return false;
       if (!JSIConverter<std::optional<margelo::nitro::audiobrowser::TrackStyle>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "style")))) return false;
-      if (!JSIConverter<std::optional<margelo::nitro::audiobrowser::TrackStyle>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "childrenStyle")))) return false;
+      if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "disabled")))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "favorited")))) return false;
-      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "groupTitle")))) return false;
       if (!JSIConverter<std::optional<bool>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "live")))) return false;
-      if (!JSIConverter<std::optional<std::vector<margelo::nitro::audiobrowser::ImageRowItem>>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "imageRow")))) return false;
       return true;
     }
   };

package/nitrogen/generated/shared/c++/TrackStyle.hpp

@@ -7,11 +7,6 @@
 
 #pragma once
 
-#if __has_include(<NitroModules/NitroHash.hpp>)
-#include <NitroModules/NitroHash.hpp>
-#else
-#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
-#endif
 #if __has_include(<NitroModules/JSIConverter.hpp>)
 #include <NitroModules/JSIConverter.hpp>
 #else
@@ -22,54 +17,98 @@
 #else
 #error NitroModules cannot be found! Are you sure you installed NitroModules properly?
 #endif
+#if __has_include(<NitroModules/JSIHelpers.hpp>)
+#include <NitroModules/JSIHelpers.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+#if __has_include(<NitroModules/PropNameIDCache.hpp>)
+#include <NitroModules/PropNameIDCache.hpp>
+#else
+#error NitroModules cannot be found! Are you sure you installed NitroModules properly?
+#endif
+
+// Forward declaration of `StyleDisplay` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class StyleDisplay; }
+// Forward declaration of `ArtworkRendering` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class ArtworkRendering; }
+// Forward declaration of `ImageShape` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class ImageShape; }
+// Forward declaration of `CardImage` to properly resolve imports.
+namespace margelo::nitro::audiobrowser { enum class CardImage; }
+
+#include "StyleDisplay.hpp"
+#include <optional>
+#include "ArtworkRendering.hpp"
+#include "ImageShape.hpp"
+#include <string>
+#include "CardImage.hpp"
 
 namespace margelo::nitro::audiobrowser {
 
   /**
-   * An enum which can be represented as a JavaScript union (TrackStyle).
+   * A struct which can be represented as a JavaScript object (TrackStyle).
    */
-  enum class TrackStyle {
-    LIST      SWIFT_NAME(list) = 0,
-    GRID      SWIFT_NAME(grid) = 1,
-  } CLOSED_ENUM;
+  struct TrackStyle final {
+  public:
+    std::optional<StyleDisplay> display     SWIFT_PRIVATE;
+    std::optional<ArtworkRendering> artworkRendering     SWIFT_PRIVATE;
+    std::optional<ImageShape> imageShape     SWIFT_PRIVATE;
+    std::optional<std::string> accessorySymbol     SWIFT_PRIVATE;
+    std::optional<std::string> cardTint     SWIFT_PRIVATE;
+    std::optional<CardImage> cardImage     SWIFT_PRIVATE;
+
+  public:
+    TrackStyle() = default;
+    explicit TrackStyle(std::optional<StyleDisplay> display, std::optional<ArtworkRendering> artworkRendering, std::optional<ImageShape> imageShape, std::optional<std::string> accessorySymbol, std::optional<std::string> cardTint, std::optional<CardImage> cardImage): display(display), artworkRendering(artworkRendering), imageShape(imageShape), accessorySymbol(accessorySymbol), cardTint(cardTint), cardImage(cardImage) {}
+
+  public:
+    friend bool operator==(const TrackStyle& lhs, const TrackStyle& rhs) = default;
+  };
 
 } // namespace margelo::nitro::audiobrowser
 
 namespace margelo::nitro {
 
-  // C++ TrackStyle <> JS TrackStyle (union)
+  // C++ TrackStyle <> JS TrackStyle (object)
   template <>
   struct JSIConverter<margelo::nitro::audiobrowser::TrackStyle> final {
     static inline margelo::nitro::audiobrowser::TrackStyle fromJSI(jsi::Runtime& runtime, const jsi::Value& arg) {
-      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, arg);
-      switch (hashString(unionValue.c_str(), unionValue.size())) {
-        case hashString("list"): return margelo::nitro::audiobrowser::TrackStyle::LIST;
-        case hashString("grid"): return margelo::nitro::audiobrowser::TrackStyle::GRID;
-        default: [[unlikely]]
-          throw std::invalid_argument("Cannot convert \"" + unionValue + "\" to enum TrackStyle - invalid value!");
-      }
+      jsi::Object obj = arg.asObject(runtime);
+      return margelo::nitro::audiobrowser::TrackStyle(
+        JSIConverter<std::optional<margelo::nitro::audiobrowser::StyleDisplay>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "display"))),
+        JSIConverter<std::optional<margelo::nitro::audiobrowser::ArtworkRendering>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "artworkRendering"))),
+        JSIConverter<std::optional<margelo::nitro::audiobrowser::ImageShape>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "imageShape"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "accessorySymbol"))),
+        JSIConverter<std::optional<std::string>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "cardTint"))),
+        JSIConverter<std::optional<margelo::nitro::audiobrowser::CardImage>>::fromJSI(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "cardImage")))
+      );
     }
-    static inline jsi::Value toJSI(jsi::Runtime& runtime, margelo::nitro::audiobrowser::TrackStyle arg) {
-      switch (arg) {
-        case margelo::nitro::audiobrowser::TrackStyle::LIST: return JSIConverter<std::string>::toJSI(runtime, "list");
-        case margelo::nitro::audiobrowser::TrackStyle::GRID: return JSIConverter<std::string>::toJSI(runtime, "grid");
-        default: [[unlikely]]
-          throw std::invalid_argument("Cannot convert TrackStyle to JS - invalid value: "
-                                    + std::to_string(static_cast<int>(arg)) + "!");
-      }
+    static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::audiobrowser::TrackStyle& arg) {
+      jsi::Object obj(runtime);
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "display"), JSIConverter<std::optional<margelo::nitro::audiobrowser::StyleDisplay>>::toJSI(runtime, arg.display));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "artworkRendering"), JSIConverter<std::optional<margelo::nitro::audiobrowser::ArtworkRendering>>::toJSI(runtime, arg.artworkRendering));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "imageShape"), JSIConverter<std::optional<margelo::nitro::audiobrowser::ImageShape>>::toJSI(runtime, arg.imageShape));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "accessorySymbol"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.accessorySymbol));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "cardTint"), JSIConverter<std::optional<std::string>>::toJSI(runtime, arg.cardTint));
+      obj.setProperty(runtime, PropNameIDCache::get(runtime, "cardImage"), JSIConverter<std::optional<margelo::nitro::audiobrowser::CardImage>>::toJSI(runtime, arg.cardImage));
+      return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
-      if (!value.isString()) {
+      if (!value.isObject()) {
         return false;
       }
-      std::string unionValue = JSIConverter<std::string>::fromJSI(runtime, value);
-      switch (hashString(unionValue.c_str(), unionValue.size())) {
-        case hashString("list"):
-        case hashString("grid"):
-          return true;
-        default:
-          return false;
+      jsi::Object obj = value.getObject(runtime);
+      if (!nitro::isPlainObject(runtime, obj)) {
+        return false;
       }
+      if (!JSIConverter<std::optional<margelo::nitro::audiobrowser::StyleDisplay>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "display")))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::audiobrowser::ArtworkRendering>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "artworkRendering")))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::audiobrowser::ImageShape>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "imageShape")))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "accessorySymbol")))) return false;
+      if (!JSIConverter<std::optional<std::string>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "cardTint")))) return false;
+      if (!JSIConverter<std::optional<margelo::nitro::audiobrowser::CardImage>>::canConvert(runtime, obj.getProperty(runtime, PropNameIDCache::get(runtime, "cardImage")))) return false;
+      return true;
     }
   };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-audio-browser",
-  "version": "0.2.0-next.11",
+  "version": "0.2.0-next.13",
   "description": "react-native-audio-browser is a react native package built with Nitro",
   "keywords": [
     "react-native",
@@ -31,6 +31,7 @@
     "ios/**/*.mm",
     "ios/**/*.cpp",
     "ios/**/*.swift",
+    "website/guide",
     "*.podspec",
     "README.md"
   ],
@@ -46,23 +47,27 @@
   "scripts": {
     "android:format": "yarn workspace example-native android:format",
     "android:format:check": "yarn workspace example-native android:format:check",
+    "android:gradle-stop": "yarn workspace example-native android:gradle-stop",
     "android:ide": "yarn workspace example-native android:ide",
     "android:logs": "react-native log-android",
     "android:test": "yarn workspace example-native android:test",
+    "android:types": "yarn workspace example-native android:types",
     "build": "yarn prepare",
     "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
     "codegen": "node codegen/index.js --logLevel=\"debug\" && node post-script.cjs && node codegen/strip-struct-equality.cjs && yarn build",
     "prepare": "bob build && yarn hooks:install",
     "hooks:install": "git config core.hooksPath .githooks || exit 0",
     "example": "yarn workspace example-native",
+    "ci:android": "yarn android:format:check && yarn android:types && yarn android:test",
     "ci:format": "oxfmt --check --ignore-path .gitignore --ignore-path .oxfmtignore .",
     "ci:format:ios": "swiftformat --lint ios",
+    "ci:ios": "yarn ci:format:ios && yarn ios:test",
     "ci:lint": "oxlint --type-aware src",
     "format": "oxfmt --write --ignore-path .gitignore --ignore-path .oxfmtignore .",
     "ios:format": "swiftformat ios",
     "ios:ide": "yarn workspace example-native ios:ide",
     "ios:rebuild": "yarn workspace example-native ios:rebuild",
-    "ios:test": "swift test",
+    "ios:test": "swift test --disable-sandbox",
     "lint": "oxlint --fix",
     "release": "semantic-release",
     "test": "vitest run",

package/src/AudioBrowser.ts

@@ -1,4 +1,5 @@
 // `./native` is deliberately not re-exported — see public-surface.test.ts.
 export * from './features'
 export * from './types'
+export * from './utils/getTrackIdentity'
 export * from './utils/useDebug'

package/src/features/browser-config.test.ts

@@ -18,7 +18,7 @@ describe('toNativeConfig route classification', () => {
 
   it('keeps a static page with a string artwork out of the RouteConfig branch', () => {
     const page = {
-      url: '/x',
+      path: '/x',
       title: 'X',
       artwork: 'https://img.example.com/x.png',
       children: []
@@ -28,6 +28,21 @@ describe('toNativeConfig route classification', () => {
     expect(entry?.artwork).toBeUndefined()
   })
 
+  it('classifies a static page as static despite its top-level `path` key', () => {
+    // `path` is also a RequestConfig field; the page's required `title` must
+    // win the classification (a config with a `path` alone is not a page).
+    const page = { path: '/x', title: 'X', children: [] }
+    const entry = entryFor({ '/x': page }, '/x')
+    expect(entry?.browseStatic).toEqual(page)
+    expect(entry?.browseConfig).toBeUndefined()
+  })
+
+  it('classifies a path-only request config as a request config', () => {
+    const entry = entryFor({ '/x': { path: '/remapped' } }, '/x')
+    expect(entry?.browseConfig).toEqual({ path: '/remapped' })
+    expect(entry?.browseStatic).toBeUndefined()
+  })
+
   it('classifies a method-only request config as a request config', () => {
     const entry = entryFor({ '/x': { method: 'POST' } }, '/x')
     expect(entry?.browseConfig).toEqual({ method: 'POST' })
@@ -66,13 +81,13 @@ describe('validateBrowserConfiguration', () => {
   it('is silent for a valid configuration', () => {
     validateBrowserConfiguration({
       routes: {
-        '/favorites': async () => ({ url: '/favorites', title: 'Favorites' }),
+        '/favorites': async () => ({ path: '/favorites', title: 'Favorites' }),
         '/albums/{id}': { baseUrl: 'https://api.example.com' },
         '*': { baseUrl: 'https://api.example.com' }
       },
       tabs: [
-        { title: 'Home', url: '/' },
-        { title: 'Search', url: '/search' }
+        { title: 'Home', path: '/' },
+        { title: 'Search', path: '/search' }
       ]
     })
     expect(warnings).toEqual([])
@@ -96,14 +111,14 @@ describe('validateBrowserConfiguration', () => {
 
   it('does not flag a valid static page as unclassifiable', () => {
     validateBrowserConfiguration({
-      routes: { '/x': { url: '/x', title: 'X', children: [] } }
+      routes: { '/x': { path: '/x', title: 'X', children: [] } }
     })
     expect(warnings).toEqual([])
   })
 
   it('warns on more than 4 static tabs', () => {
     validateBrowserConfiguration({
-      tabs: [1, 2, 3, 4, 5].map((n) => ({ title: `Tab ${n}`, url: `/${n}` }))
+      tabs: [1, 2, 3, 4, 5].map((n) => ({ title: `Tab ${n}`, path: `/${n}` }))
     })
     expect(warnings.some((w) => w.includes('at most 4'))).toBe(true)
   })

package/src/features/browser-config.ts

@@ -38,9 +38,12 @@ function isTransformableRequestConfig(
   source: unknown
 ): source is TransformableRequestConfig {
   if (!isObjectValue(source)) return false
-  // Any RequestConfig key marks a request config. A static ResolvedTrack
-  // shares none of these at the top level (its per-track request override is
-  // nested under `request`).
+  // A static ResolvedTrack page also carries a top-level `path`, so `path`
+  // alone cannot mark a request config. A page is recognised by its required
+  // `title` — no RequestConfig field is named `title`.
+  if ('title' in source) return false
+  // Any RequestConfig key marks a request config. (A static ResolvedTrack's
+  // per-track request override is nested under `request`, not top-level.)
   return (
     'baseUrl' in source ||
     'path' in source ||
@@ -120,7 +123,7 @@ function searchSourceToRouteEntry(source: SearchSource): NativeRouteEntry {
  */
 function wrapTracksAsResolvedTrack(tracks: Track[]): ResolvedTrack {
   return {
-    url: TABS_ROUTE_PATH,
+    path: TABS_ROUTE_PATH,
     title: 'Tabs',
     children: tracks
   }
@@ -245,14 +248,14 @@ export function validateBrowserConfiguration(
         !isRouteConfig(source) &&
         !isTransformableRequestConfig(source)
       ) {
-        // Falls through to the static-page branch; a page needs url + title.
+        // Falls through to the static-page branch; a page needs path + title.
         const page = source as Partial<ResolvedTrack>
-        if (typeof page.url !== 'string' || typeof page.title !== 'string') {
+        if (typeof page.path !== 'string' || typeof page.title !== 'string') {
           warn(
             `route "${path}" matched no source shape — expected a callback, ` +
               `a request config ({ baseUrl, path, headers, ... }), a ` +
               `RouteConfig ({ browse, media, artwork }), or a static page ` +
-              `({ url, title, children? }). It will be served as static ` +
+              `({ path, title, children? }). It will be served as static ` +
               `content and likely render a blank screen.`
           )
         }
@@ -287,7 +290,7 @@ export function toNativeConfig(
     handleTrackLoad: config.handleTrackLoad,
     androidControllerOfflineError: config.androidControllerOfflineError,
     carPlayLoadingTitle: config.carPlayLoadingTitle,
-    resolveAlbumUrl: config.resolveAlbumUrl,
+    resolveAlbumPath: config.resolveAlbumPath,
     formatNavigationError: config.formatNavigationError
   }
 }

package/src/features/browser.test.ts

@@ -12,7 +12,7 @@ describe('getBrowserConfiguration', () => {
   })
 
   it('returns the last configuration in its public shape', () => {
-    const config = { tabs: [{ title: 'Home', url: '/' }] }
+    const config = { tabs: [{ title: 'Home', path: '/' }] }
     configureBrowser(config)
     expect(getBrowserConfiguration()).toBe(config)
   })

package/src/features/browser.ts

@@ -43,8 +43,8 @@ let currentConfiguration: BrowserConfiguration | undefined
  *     }
  *   },
  *   tabs: [
- *     { title: 'Home', url: '/' },
- *     { title: 'Search', url: '/search' }
+ *     { title: 'Home', path: '/' },
+ *     { title: 'Search', path: '/search' }
  *   ]
  * })
  * ```

package/src/features/favorites.ts

@@ -37,26 +37,29 @@ export function toggleActiveTrackFavorited(): void {
 }
 
 /**
- * Sets the list of favorited track source identifiers.
+ * Sets the list of favorited track identifiers.
  *
  * This syncs your app's favorites with the native favorites cache, enabling
  * the heart button in media controllers (notification, Android Auto, CarPlay)
  * to show the correct state.
  *
- * Note: This is only needed if the tracks provided to AudioBrowser do not
- * include the `favorited` field. If your API already includes favorite state in
- * track responses, the native favorites cache is populated automatically during browsing.
+ * Each identifier is matched **exactly** against a track's *identity* — its
+ * `id` when set, falling back to `src`. Store favorites as the same stable
+ * identifier you put in `Track.id` (or as the full `src` for id-less tracks).
  *
- * When the heart button is tapped in media controllers or when you call
- * `setActiveTrackFavorited()`, the native favorites cache is automatically
- * updated. You only need to call this on app launch to hydrate the cache.
+ * A track whose response already carries `favorited` keeps that value on
+ * display surfaces — a caller-set flag wins over cache hydration. The cache
+ * itself is written only by this call and by heart toggles
+ * (`setActiveTrackFavorited()` / media-controller taps), so you only need to
+ * call this on app launch — and again whenever the collection changes outside
+ * the player (a sync from another device, say).
  *
- * @param favorites - Array of favorited track `src` values
+ * @param favorites - Array of favorited track identities (`id`, or `src` for id-less tracks)
  *
  * @example
  * ```ts
- * const favoriteSrcs = await loadFavoritesFromStorage()
- * setFavorites(favoriteSrcs)
+ * const favoriteIds = await loadFavoritesFromStorage()
+ * setFavorites(favoriteIds)
  * ```
  */
 export function setFavorites(favorites: string[]): void {

package/src/features/hook-wiring.test.ts

@@ -4,10 +4,12 @@ import { renderHook, act, cleanup } from '@testing-library/react'
 import { describe, it, expect, afterEach, vi } from 'vitest'
 
 /**
- * The 22 hooks that are a single delegation to `useNativeUpdatedValue`. Their
+ * The hooks that are a single delegation to `useNativeUpdatedValue`. Their
  * behaviour is covered once in `utils/useNativeUpdatedValue.test.ts`; what is
  * per-hook and untestable there is the wiring — which native callback slot the
  * emitter claims, and which `eventKey` is pulled out of the payload.
+ * (`useActiveTrack` and `useQueue` are getter-refreshed instead — they update
+ * on transitions AND favorite toggles — and are covered in their own block.)
  *
  * Both are easy to get wrong and silent when wrong: the hook simply never
  * updates, or yields the whole event where a field was meant. Five slots
@@ -159,13 +161,6 @@ const wirings: Wiring[] = [
     event: true,
     expected: true
   },
-  {
-    name: 'useQueue',
-    hook: useQueue,
-    slot: 'onPlaybackQueueChanged',
-    event: [{ src: 'a' }],
-    expected: [{ src: 'a' }]
-  },
   {
     name: 'useFormattedNavigationError',
     hook: useFormattedNavigationError,
@@ -210,13 +205,6 @@ const wirings: Wiring[] = [
     event: { repeatMode: 'queue' },
     expected: 'queue'
   },
-  {
-    name: 'useActiveTrack',
-    hook: useActiveTrack,
-    slot: 'onPlaybackActiveTrackChanged',
-    event: { track: { src: 'a' } },
-    expected: { src: 'a' }
-  },
   {
     name: 'useBatteryWarningPending',
     hook: useBatteryWarningPending,
@@ -252,3 +240,63 @@ describe('hook wiring table', () => {
     expect(new Set(wirings.map((w) => w.slot)).size).toBe(wirings.length)
   })
 })
+
+/**
+ * `useActiveTrack` and `useQueue` are getter-refreshed: a favorite toggle
+ * mutates the active track in place WITHOUT a transition event —
+ * transitions and mutations are separate events — so
+ * these hooks re-read their native getter on the transition slot AND on
+ * `onFavoriteChanged`.
+ */
+const { nativeBrowser } = await import('../native')
+
+describe.each([
+  {
+    name: 'useActiveTrack',
+    hook: useActiveTrack,
+    getter: 'getActiveTrack',
+    transitionSlot: 'onPlaybackActiveTrackChanged',
+    initial: { src: 'a', favorited: false },
+    mutated: { src: 'a', favorited: true }
+  },
+  {
+    name: 'useQueue',
+    hook: useQueue,
+    getter: 'getQueue',
+    transitionSlot: 'onPlaybackQueueChanged',
+    initial: [{ src: 'a', favorited: false }],
+    mutated: [{ src: 'a', favorited: true }]
+  }
+])(
+  '$name (getter-refreshed)',
+  ({ hook, getter, transitionSlot, initial, mutated }) => {
+    it(`re-reads ${getter} on ${transitionSlot} and onFavoriteChanged`, () => {
+      expect(slots.has(transitionSlot)).toBe(true)
+      expect(slots.has('onFavoriteChanged')).toBe(true)
+
+      const getterMock = (
+        nativeBrowser as unknown as Record<string, ReturnType<typeof vi.fn>>
+      )[getter]!
+
+      getterMock.mockReturnValue(initial)
+      const { result } = renderHook(() => hook())
+      expect(result.current).toEqual(initial)
+
+      // A transition re-reads the getter (the event payload is not consumed).
+      getterMock.mockReturnValue(mutated)
+      act(() => slots.get(transitionSlot)!({}))
+      expect(result.current).toEqual(mutated)
+
+      // A favorite toggle mutates in place — no transition event fires, but
+      // the hook must still refresh.
+      getterMock.mockReturnValue(initial)
+      act(() =>
+        slots.get('onFavoriteChanged')!({
+          track: { src: 'a' },
+          favorited: false
+        })
+      )
+      expect(result.current).toEqual(initial)
+    })
+  }
+)