react-native-nitro-player 0.3.0-alpha.15 → 0.3.0-alpha.17

package/README.md

@@ -134,6 +134,12 @@ const tracks: TrackItem[] = [
     duration: 180.0, // in seconds
     url: 'https://example.com/song.mp3',
     artwork: 'https://example.com/artwork.jpg',
+    // Optional custom data (accessible in player state)
+    extraPayload: {
+      artistId: '123',
+      genre: 'Rock',
+      isFavorite: true,
+    },
   },
 ]
 
@@ -889,6 +895,29 @@ interface TrackItem {
   duration: number // Duration in seconds
   url: string // Audio file URL
   artwork?: string | null // Optional artwork URL
+  // key-value pairs for arbitrary data
+  extraPayload?: {
+    [key: string]: string | number | boolean | Record<string, unknown>
+  }
+}
+```
+
+### Custom Track Metadata (extraPayload)
+
+```typescript
+const track = {
+  // ... standard fields
+  extraPayload: {
+    externalId: 'sp-12345',
+    rating: 4.5,
+    tags: ['chill', 'instrumental']
+  }
+}
+
+// Accessing it later
+const { track } = useOnChangeTrack()
+if (track?.extraPayload?.rating > 4) {
+  console.log('High rated track playing!')
 }
 ```
 

package/android/src/main/java/com/margelo/nitro/nitroplayer/download/DownloadDatabase.kt

@@ -370,6 +370,7 @@ class DownloadDatabase private constructor(
             duration = record.duration,
             url = record.url,
             artwork = artworkVariant,
+            extraPayload = null,
         )
     }
 

package/android/src/main/java/com/margelo/nitro/nitroplayer/playlist/PlaylistManager.kt

@@ -13,6 +13,8 @@ import org.json.JSONObject
 import java.util.UUID
 import java.util.concurrent.CopyOnWriteArrayList
 
+import com.margelo.nitro.core.AnyMap
+
 /**
  * Manages multiple playlists using ExoPlayer's native playlist functionality
  * Based on: https://developer.android.com/media/media3/exoplayer/playlists
@@ -381,6 +383,12 @@ class PlaylistManager private constructor(
                                         put("duration", track.duration)
                                         put("url", track.url)
                                         track.artwork?.let { put("artwork", it) }
+                                        // Serialize extraPayload to JSON for persistence
+                                        track.extraPayload?.let { payload ->
+                                            val extraPayloadMap = payload.toHashMap()
+                                            val extraPayloadJson = JSONObject(extraPayloadMap)
+                                            put("extraPayload", extraPayloadJson)
+                                        }
                                     },
                                 )
                             }
@@ -420,6 +428,24 @@ class PlaylistManager private constructor(
                                 } else {
                                     null
                                 }
+                            // Deserialize extraPayload from JSON
+                            val extraPayload: AnyMap? =
+                                if (trackObj.has("extraPayload")) {
+                                    val extraPayloadJson = trackObj.getJSONObject("extraPayload")
+                                    val map = AnyMap()
+                                    val keyIterator = extraPayloadJson.keys()
+                                    while (keyIterator.hasNext()) {
+                                        val key = keyIterator.next()
+                                        when (val value = extraPayloadJson.get(key)) {
+                                            is String -> map.setString(key, value)
+                                            is Number -> map.setDouble(key, value.toDouble())
+                                            is Boolean -> map.setBoolean(key, value)
+                                        }
+                                    }
+                                    map
+                                } else {
+                                    null
+                                }
                             tracks.add(
                                 TrackItem(
                                     id = trackObj.getString("id"),
@@ -429,6 +455,7 @@ class PlaylistManager private constructor(
                                     duration = trackObj.getDouble("duration"),
                                     url = trackObj.getString("url"),
                                     artwork = artwork,
+                                    extraPayload = extraPayload,
                                 ),
                             )
                         }

package/ios/core/TrackPlayerCore.swift

@@ -362,7 +362,8 @@ class TrackPlayerCore: NSObject {
           album: "",
           duration: 0,
           url: "",
-          artwork: nil
+          artwork: nil,
+          extraPayload: nil
         ), .end)
 
     // Try to play next track

package/ios/download/DownloadDatabase.swift

@@ -452,7 +452,8 @@ final class DownloadDatabase {
       album: record.album,
       duration: record.duration,
       url: record.url,
-      artwork: stringToVariant(record.artwork)
+      artwork: stringToVariant(record.artwork),
+      extraPayload: nil
     )
   }
 

package/ios/download/DownloadManagerCore.swift

@@ -595,7 +595,8 @@ final class DownloadManagerCore: NSObject {
       album: record.album,
       duration: record.duration,
       url: record.url,
-      artwork: artwork
+      artwork: artwork,
+      extraPayload: nil
     )
   }
 

package/ios/playlist/PlaylistManager.swift

@@ -377,6 +377,10 @@ class PlaylistManager {
             } else {
               trackDict["artwork"] = ""
             }
+            // Serialize extraPayload to dictionary for persistence
+            if let extraPayload = track.extraPayload {
+              trackDict["extraPayload"] = extraPayload.toDictionary()
+            }
             return trackDict
           },
         ]
@@ -425,6 +429,24 @@ class PlaylistManager {
             let artwork = artworkString.flatMap {
               !$0.isEmpty ? Variant_NullType_String.second($0) : nil
             }
+            
+            // Deserialize extraPayload from dictionary
+            var extraPayload: AnyMap? = nil
+            if let extraPayloadDict = trackDict["extraPayload"] as? [String: Any] {
+              extraPayload = AnyMap()
+              for (key, value) in extraPayloadDict {
+                if let stringValue = value as? String {
+                  extraPayload?.setString(key: key, value: stringValue)
+                } else if let doubleValue = value as? Double {
+                  extraPayload?.setDouble(key: key, value: doubleValue)
+                } else if let intValue = value as? Int {
+                  extraPayload?.setDouble(key: key, value: Double(intValue))
+                } else if let boolValue = value as? Bool {
+                  extraPayload?.setBoolean(key: key, value: boolValue)
+                }
+              }
+            }
+            
             return TrackItem(
               id: id,
               title: title,
@@ -432,7 +454,8 @@ class PlaylistManager {
               album: album,
               duration: duration,
               url: url,
-              artwork: artwork
+              artwork: artwork,
+              extraPayload: extraPayload
             )
           }
 

package/lib/types/PlayerQueue.d.ts

@@ -1,3 +1,4 @@
+import type { AnyMap } from 'react-native-nitro-modules';
 export type CurrentPlayingType = 'playlist' | 'up-next' | 'play-next' | 'not-playing';
 export interface TrackItem {
     id: string;
@@ -7,6 +8,7 @@ export interface TrackItem {
     duration: number;
     url: string;
     artwork?: string | null;
+    extraPayload?: AnyMap;
 }
 export interface Playlist {
     id: string;

package/nitrogen/generated/android/c++/JDownloadedPlaylist.hpp

@@ -19,6 +19,8 @@
 #include "Playlist.hpp"
 #include "StorageLocation.hpp"
 #include "TrackItem.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
 #include <NitroModules/JNull.hpp>
 #include <NitroModules/Null.hpp>
 #include <optional>

package/nitrogen/generated/android/c++/JDownloadedTrack.hpp

@@ -15,6 +15,8 @@
 #include "JVariant_NullType_String.hpp"
 #include "StorageLocation.hpp"
 #include "TrackItem.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
 #include <NitroModules/JNull.hpp>
 #include <NitroModules/Null.hpp>
 #include <optional>

package/nitrogen/generated/android/c++/JFunc_void_DownloadedTrack.hpp

@@ -22,6 +22,8 @@
 #include <optional>
 #include "JVariant_NullType_String.hpp"
 #include <NitroModules/JNull.hpp>
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
 #include "StorageLocation.hpp"
 #include "JStorageLocation.hpp"
 

package/nitrogen/generated/android/c++/JFunc_void_TrackItem_std__optional_Reason_.hpp

@@ -21,6 +21,8 @@
 #include <variant>
 #include "JVariant_NullType_String.hpp"
 #include <NitroModules/JNull.hpp>
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
 #include "JReason.hpp"
 
 namespace margelo::nitro::nitroplayer {

package/nitrogen/generated/android/c++/JFunc_void_std__string_Playlist_std__optional_QueueOperation_.hpp

@@ -24,6 +24,8 @@
 #include "TrackItem.hpp"
 #include <vector>
 #include "JTrackItem.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
 #include "JQueueOperation.hpp"
 
 namespace margelo::nitro::nitroplayer {

package/nitrogen/generated/android/c++/JFunc_void_std__vector_Playlist__std__optional_QueueOperation_.hpp

@@ -24,6 +24,8 @@
 #include <NitroModules/JNull.hpp>
 #include "TrackItem.hpp"
 #include "JTrackItem.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
 #include "JQueueOperation.hpp"
 
 namespace margelo::nitro::nitroplayer {

package/nitrogen/generated/android/c++/JHybridDownloadManagerSpec.cpp

@@ -69,6 +69,8 @@ namespace margelo::nitro::nitroplayer { enum class PlaybackSource; }
 #include "JDownloadedTrack.hpp"
 #include "TrackItem.hpp"
 #include "JTrackItem.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
 #include "DownloadedPlaylist.hpp"
 #include "JVariant_NullType_DownloadedPlaylist.hpp"
 #include "JDownloadedPlaylist.hpp"

package/nitrogen/generated/android/c++/JHybridPlayerQueueSpec.cpp

@@ -26,6 +26,8 @@ namespace margelo::nitro::nitroplayer { enum class QueueOperation; }
 #include "TrackItem.hpp"
 #include <vector>
 #include "JTrackItem.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
 #include "QueueOperation.hpp"
 #include <functional>
 #include "JFunc_void_std__vector_Playlist__std__optional_QueueOperation_.hpp"

package/nitrogen/generated/android/c++/JHybridTrackPlayerSpec.cpp

@@ -33,6 +33,8 @@ namespace margelo::nitro::nitroplayer { enum class Reason; }
 #include <optional>
 #include "JVariant_NullType_String.hpp"
 #include <NitroModules/JNull.hpp>
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
 #include "PlayerState.hpp"
 #include "JPlayerState.hpp"
 #include "JVariant_NullType_TrackItem.hpp"

package/nitrogen/generated/android/c++/JPlayerState.hpp

@@ -18,6 +18,8 @@
 #include "JVariant_NullType_TrackItem.hpp"
 #include "TrackItem.hpp"
 #include "TrackPlayerState.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
 #include <NitroModules/JNull.hpp>
 #include <NitroModules/Null.hpp>
 #include <optional>

package/nitrogen/generated/android/c++/JPlaylist.hpp

@@ -13,6 +13,8 @@
 #include "JTrackItem.hpp"
 #include "JVariant_NullType_String.hpp"
 #include "TrackItem.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
 #include <NitroModules/JNull.hpp>
 #include <NitroModules/Null.hpp>
 #include <optional>

package/nitrogen/generated/android/c++/JTrackItem.hpp

@@ -11,6 +11,8 @@
 #include "TrackItem.hpp"
 
 #include "JVariant_NullType_String.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
 #include <NitroModules/JNull.hpp>
 #include <NitroModules/Null.hpp>
 #include <optional>
@@ -50,6 +52,8 @@ namespace margelo::nitro::nitroplayer {
       jni::local_ref<jni::JString> url = this->getFieldValue(fieldUrl);
       static const auto fieldArtwork = clazz->getField<JVariant_NullType_String>("artwork");
       jni::local_ref<JVariant_NullType_String> artwork = this->getFieldValue(fieldArtwork);
+      static const auto fieldExtraPayload = clazz->getField<JAnyMap::javaobject>("extraPayload");
+      jni::local_ref<JAnyMap::javaobject> extraPayload = this->getFieldValue(fieldExtraPayload);
       return TrackItem(
         id->toStdString(),
         title->toStdString(),
@@ -57,7 +61,8 @@ namespace margelo::nitro::nitroplayer {
         album->toStdString(),
         duration,
         url->toStdString(),
-        artwork != nullptr ? std::make_optional(artwork->toCpp()) : std::nullopt
+        artwork != nullptr ? std::make_optional(artwork->toCpp()) : std::nullopt,
+        extraPayload != nullptr ? std::make_optional(extraPayload->cthis()->getMap()) : std::nullopt
       );
     }
 
@@ -67,7 +72,7 @@ namespace margelo::nitro::nitroplayer {
      */
     [[maybe_unused]]
     static jni::local_ref<JTrackItem::javaobject> fromCpp(const TrackItem& value) {
-      using JSignature = JTrackItem(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, double, jni::alias_ref<jni::JString>, jni::alias_ref<JVariant_NullType_String>);
+      using JSignature = JTrackItem(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, double, jni::alias_ref<jni::JString>, jni::alias_ref<JVariant_NullType_String>, jni::alias_ref<JAnyMap::javaobject>);
       static const auto clazz = javaClassStatic();
       static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
       return create(
@@ -78,7 +83,8 @@ namespace margelo::nitro::nitroplayer {
         jni::make_jstring(value.album),
         value.duration,
         jni::make_jstring(value.url),
-        value.artwork.has_value() ? JVariant_NullType_String::fromCpp(value.artwork.value()) : nullptr
+        value.artwork.has_value() ? JVariant_NullType_String::fromCpp(value.artwork.value()) : nullptr,
+        value.extraPayload.has_value() ? JAnyMap::create(value.extraPayload.value()) : nullptr
       );
     }
   };

package/nitrogen/generated/android/c++/JVariant_NullType_DownloadedPlaylist.hpp

@@ -23,6 +23,8 @@
 #include "TrackItem.hpp"
 #include <vector>
 #include "JTrackItem.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
 #include "DownloadedTrack.hpp"
 #include "JDownloadedTrack.hpp"
 #include "StorageLocation.hpp"

package/nitrogen/generated/android/c++/JVariant_NullType_DownloadedTrack.hpp

@@ -20,6 +20,8 @@
 #include "JTrackItem.hpp"
 #include <optional>
 #include "JVariant_NullType_String.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
 #include "StorageLocation.hpp"
 #include "JStorageLocation.hpp"
 

package/nitrogen/generated/android/c++/JVariant_NullType_Playlist.hpp

@@ -21,6 +21,8 @@
 #include "TrackItem.hpp"
 #include <vector>
 #include "JTrackItem.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
 
 namespace margelo::nitro::nitroplayer {
 

package/nitrogen/generated/android/c++/JVariant_NullType_TrackItem.hpp

@@ -18,6 +18,8 @@
 #include <string>
 #include <optional>
 #include "JVariant_NullType_String.hpp"
+#include <NitroModules/AnyMap.hpp>
+#include <NitroModules/JAnyMap.hpp>
 
 namespace margelo::nitro::nitroplayer {
 

package/nitrogen/generated/android/kotlin/com/margelo/nitro/nitroplayer/TrackItem.kt

@@ -10,6 +10,7 @@ package com.margelo.nitro.nitroplayer
 import androidx.annotation.Keep
 import com.facebook.proguard.annotations.DoNotStrip
 import com.margelo.nitro.core.NullType
+import com.margelo.nitro.core.AnyMap
 
 /**
  * Represents the JavaScript object/struct "TrackItem".
@@ -37,7 +38,10 @@ data class TrackItem(
   val url: String,
   @DoNotStrip
   @Keep
-  val artwork: Variant_NullType_String?
+  val artwork: Variant_NullType_String?,
+  @DoNotStrip
+  @Keep
+  val extraPayload: AnyMap?
 ) {
   /* primary constructor */
 
@@ -49,8 +53,8 @@ data class TrackItem(
     @Keep
     @Suppress("unused")
     @JvmStatic
-    private fun fromCpp(id: String, title: String, artist: String, album: String, duration: Double, url: String, artwork: Variant_NullType_String?): TrackItem {
-      return TrackItem(id, title, artist, album, duration, url, artwork)
+    private fun fromCpp(id: String, title: String, artist: String, album: String, duration: Double, url: String, artwork: Variant_NullType_String?, extraPayload: AnyMap?): TrackItem {
+      return TrackItem(id, title, artist, album, duration, url, artwork, extraPayload)
     }
   }
 }

package/nitrogen/generated/ios/NitroPlayer-Swift-Cxx-Bridge.hpp

@@ -109,6 +109,7 @@ namespace NitroPlayer { class HybridTrackPlayerSpec_cxx; }
 #include "StorageLocation.hpp"
 #include "TrackItem.hpp"
 #include "TrackPlayerState.hpp"
+#include <NitroModules/AnyMap.hpp>
 #include <NitroModules/Null.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/PromiseHolder.hpp>
@@ -293,6 +294,21 @@ namespace margelo::nitro::nitroplayer::bridge::swift {
     return Func_void_std__exception_ptr_Wrapper(std::move(value));
   }
   
+  // pragma MARK: std::optional<std::shared_ptr<AnyMap>>
+  /**
+   * Specialized version of `std::optional<std::shared_ptr<AnyMap>>`.
+   */
+  using std__optional_std__shared_ptr_AnyMap__ = std::optional<std::shared_ptr<AnyMap>>;
+  inline std::optional<std::shared_ptr<AnyMap>> create_std__optional_std__shared_ptr_AnyMap__(const std::shared_ptr<AnyMap>& value) noexcept {
+    return std::optional<std::shared_ptr<AnyMap>>(value);
+  }
+  inline bool has_value_std__optional_std__shared_ptr_AnyMap__(const std::optional<std::shared_ptr<AnyMap>>& optional) noexcept {
+    return optional.has_value();
+  }
+  inline std::shared_ptr<AnyMap> get_std__optional_std__shared_ptr_AnyMap__(const std::optional<std::shared_ptr<AnyMap>>& optional) noexcept {
+    return *optional;
+  }
+  
   // pragma MARK: std::optional<std::string>
   /**
    * Specialized version of `std::optional<std::string>`.

package/nitrogen/generated/ios/NitroPlayer-Swift-Cxx-Umbrella.hpp

@@ -103,6 +103,7 @@ namespace margelo::nitro::nitroplayer { enum class TrackPlayerState; }
 #include "StorageLocation.hpp"
 #include "TrackItem.hpp"
 #include "TrackPlayerState.hpp"
+#include <NitroModules/AnyMap.hpp>
 #include <NitroModules/Null.hpp>
 #include <NitroModules/Promise.hpp>
 #include <NitroModules/Result.hpp>

package/nitrogen/generated/ios/c++/HybridDownloadManagerSpecSwift.hpp

@@ -49,6 +49,7 @@ namespace margelo::nitro::nitroplayer { enum class PlaybackSource; }
 #include <variant>
 #include <NitroModules/Promise.hpp>
 #include "TrackItem.hpp"
+#include <NitroModules/AnyMap.hpp>
 #include <vector>
 #include "DownloadTask.hpp"
 #include "DownloadState.hpp"

package/nitrogen/generated/ios/c++/HybridPlayerQueueSpecSwift.hpp

@@ -26,6 +26,7 @@ namespace margelo::nitro::nitroplayer { enum class QueueOperation; }
 #include <variant>
 #include "TrackItem.hpp"
 #include <vector>
+#include <NitroModules/AnyMap.hpp>
 #include "QueueOperation.hpp"
 #include <functional>
 

package/nitrogen/generated/ios/c++/HybridTrackPlayerSpecSwift.hpp

@@ -34,6 +34,7 @@ namespace margelo::nitro::nitroplayer { enum class Reason; }
 #include <vector>
 #include <NitroModules/Null.hpp>
 #include <variant>
+#include <NitroModules/AnyMap.hpp>
 #include "PlayerState.hpp"
 #include "TrackPlayerState.hpp"
 #include "CurrentPlayingType.hpp"

package/nitrogen/generated/ios/swift/TrackItem.swift

@@ -19,7 +19,7 @@ public extension TrackItem {
   /**
    * Create a new instance of `TrackItem`.
    */
-  init(id: String, title: String, artist: String, album: String, duration: Double, url: String, artwork: Variant_NullType_String?) {
+  init(id: String, title: String, artist: String, album: String, duration: Double, url: String, artwork: Variant_NullType_String?, extraPayload: AnyMap?) {
     self.init(std.string(id), std.string(title), std.string(artist), std.string(album), duration, std.string(url), { () -> bridge.std__optional_std__variant_nitro__NullType__std__string__ in
       if let __unwrappedValue = artwork {
         return bridge.create_std__optional_std__variant_nitro__NullType__std__string__({ () -> bridge.std__variant_nitro__NullType__std__string_ in
@@ -33,6 +33,12 @@ public extension TrackItem {
       } else {
         return .init()
       }
+    }(), { () -> bridge.std__optional_std__shared_ptr_AnyMap__ in
+      if let __unwrappedValue = extraPayload {
+        return bridge.create_std__optional_std__shared_ptr_AnyMap__(__unwrappedValue.cppPart)
+      } else {
+        return .init()
+      }
     }())
   }
 
@@ -144,4 +150,28 @@ public extension TrackItem {
       }()
     }
   }
+  
+  var extraPayload: AnyMap? {
+    @inline(__always)
+    get {
+      return { () -> AnyMap? in
+        if bridge.has_value_std__optional_std__shared_ptr_AnyMap__(self.__extraPayload) {
+          let __unwrapped = bridge.get_std__optional_std__shared_ptr_AnyMap__(self.__extraPayload)
+          return AnyMap(withCppPart: __unwrapped)
+        } else {
+          return nil
+        }
+      }()
+    }
+    @inline(__always)
+    set {
+      self.__extraPayload = { () -> bridge.std__optional_std__shared_ptr_AnyMap__ in
+        if let __unwrappedValue = newValue {
+          return bridge.create_std__optional_std__shared_ptr_AnyMap__(__unwrappedValue.cppPart)
+        } else {
+          return .init()
+        }
+      }()
+    }
+  }
 }

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

@@ -29,6 +29,7 @@
 #include <NitroModules/Null.hpp>
 #include <variant>
 #include <optional>
+#include <NitroModules/AnyMap.hpp>
 
 namespace margelo::nitro::nitroplayer {
 
@@ -44,10 +45,11 @@ namespace margelo::nitro::nitroplayer {
     double duration     SWIFT_PRIVATE;
     std::string url     SWIFT_PRIVATE;
     std::optional<std::variant<nitro::NullType, std::string>> artwork     SWIFT_PRIVATE;
+    std::optional<std::shared_ptr<AnyMap>> extraPayload     SWIFT_PRIVATE;
 
   public:
     TrackItem() = default;
-    explicit TrackItem(std::string id, std::string title, std::string artist, std::string album, double duration, std::string url, std::optional<std::variant<nitro::NullType, std::string>> artwork): id(id), title(title), artist(artist), album(album), duration(duration), url(url), artwork(artwork) {}
+    explicit TrackItem(std::string id, std::string title, std::string artist, std::string album, double duration, std::string url, std::optional<std::variant<nitro::NullType, std::string>> artwork, std::optional<std::shared_ptr<AnyMap>> extraPayload): id(id), title(title), artist(artist), album(album), duration(duration), url(url), artwork(artwork), extraPayload(extraPayload) {}
   };
 
 } // namespace margelo::nitro::nitroplayer
@@ -66,7 +68,8 @@ namespace margelo::nitro {
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "album")),
         JSIConverter<double>::fromJSI(runtime, obj.getProperty(runtime, "duration")),
         JSIConverter<std::string>::fromJSI(runtime, obj.getProperty(runtime, "url")),
-        JSIConverter<std::optional<std::variant<nitro::NullType, std::string>>>::fromJSI(runtime, obj.getProperty(runtime, "artwork"))
+        JSIConverter<std::optional<std::variant<nitro::NullType, std::string>>>::fromJSI(runtime, obj.getProperty(runtime, "artwork")),
+        JSIConverter<std::optional<std::shared_ptr<AnyMap>>>::fromJSI(runtime, obj.getProperty(runtime, "extraPayload"))
       );
     }
     static inline jsi::Value toJSI(jsi::Runtime& runtime, const margelo::nitro::nitroplayer::TrackItem& arg) {
@@ -78,6 +81,7 @@ namespace margelo::nitro {
       obj.setProperty(runtime, "duration", JSIConverter<double>::toJSI(runtime, arg.duration));
       obj.setProperty(runtime, "url", JSIConverter<std::string>::toJSI(runtime, arg.url));
       obj.setProperty(runtime, "artwork", JSIConverter<std::optional<std::variant<nitro::NullType, std::string>>>::toJSI(runtime, arg.artwork));
+      obj.setProperty(runtime, "extraPayload", JSIConverter<std::optional<std::shared_ptr<AnyMap>>>::toJSI(runtime, arg.extraPayload));
       return obj;
     }
     static inline bool canConvert(jsi::Runtime& runtime, const jsi::Value& value) {
@@ -95,6 +99,7 @@ namespace margelo::nitro {
       if (!JSIConverter<double>::canConvert(runtime, obj.getProperty(runtime, "duration"))) return false;
       if (!JSIConverter<std::string>::canConvert(runtime, obj.getProperty(runtime, "url"))) return false;
       if (!JSIConverter<std::optional<std::variant<nitro::NullType, std::string>>>::canConvert(runtime, obj.getProperty(runtime, "artwork"))) return false;
+      if (!JSIConverter<std::optional<std::shared_ptr<AnyMap>>>::canConvert(runtime, obj.getProperty(runtime, "extraPayload"))) return false;
       return true;
     }
   };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-nitro-player",
-  "version": "0.3.0-alpha.15",
+  "version": "0.3.0-alpha.17",
   "description": "react-native-nitro-player",
   "main": "lib/index",
   "module": "lib/index",

package/src/types/PlayerQueue.ts

@@ -1,3 +1,5 @@
+import type { AnyMap } from 'react-native-nitro-modules'
+
 export type CurrentPlayingType =
   | 'playlist'
   | 'up-next'
@@ -11,6 +13,7 @@ export interface TrackItem {
   duration: number
   url: string
   artwork?: string | null
+  extraPayload?: AnyMap
 }
 
 export interface Playlist {