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

package/src/utils/useDebug.test.ts

@@ -0,0 +1,182 @@
+/** @vitest-environment happy-dom */
+
+import { renderHook, act, cleanup } from '@testing-library/react'
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest'
+
+const native = vi.hoisted(() => {
+  const slots = new Map<string, (event: never) => void>()
+  return {
+    slots,
+    browser: new Proxy({} as Record<string, unknown>, {
+      get(target, prop: string) {
+        // Defaults have to be shaped, not undefined: useDebugState reads
+        // `playback.state`, `queue.map(...)` and `progress.position` directly.
+        target[prop] ??= vi.fn(() => defaults[prop])
+        return target[prop]
+      },
+      set(target, prop: string, value) {
+        if (typeof value === 'function') slots.set(prop, value)
+        target[prop] = value
+        return true
+      }
+    })
+  }
+})
+
+const defaults: Record<string, unknown> = {
+  getPlayback: { state: 'none' },
+  getQueue: [],
+  getProgress: { position: 0, duration: 0, buffered: 0 },
+  getOptions: {},
+  getPlayWhenReady: false,
+  getShuffle: false,
+  getRepeatMode: 'off',
+  getOnline: true
+}
+
+vi.mock('../native', () => ({ nativeBrowser: native.browser }))
+
+const { useDebug } = await import('./useDebug')
+
+const fire = (slot: string, event: unknown) =>
+  act(() => native.slots.get(slot)?.(event as never))
+
+let logSpy: ReturnType<typeof vi.spyOn>
+
+beforeEach(() => {
+  logSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+  // Emitters and the log store are module singletons, so both the last value
+  // and the entries outlive a test. Pin a baseline rather than letting each
+  // test inherit whatever the previous one happened to fire.
+  fire('onOnlineChanged', true)
+  fire('onPlaybackProgressUpdated', { position: 0, duration: 0, buffered: 0 })
+  const { result, unmount } = renderHook(() => useDebug({ enabled: false }))
+  act(() => result.current.clear())
+  unmount()
+  logSpy.mockClear()
+})
+
+afterEach(() => {
+  cleanup()
+  logSpy.mockRestore()
+})
+
+describe('useDebug', () => {
+  it('records nothing while disabled', () => {
+    const { result } = renderHook(() => useDebug({ enabled: false }))
+    fire('onOnlineChanged', false)
+    expect(result.current.logs).toEqual([])
+    expect(logSpy).not.toHaveBeenCalled()
+  })
+
+  it('logs a single initial snapshot on mount', () => {
+    const { result } = renderHook(() => useDebug({ enabled: true }))
+    expect(result.current.logs).toHaveLength(1)
+    expect(result.current.logs[0]).toMatchObject({
+      type: 'initial',
+      elapsed: null
+    })
+    expect(result.current.logs[0]!.message).toContain('online: true')
+  })
+
+  it('logs a change entry naming the field that moved', () => {
+    const { result } = renderHook(() => useDebug({ enabled: true }))
+    fire('onOnlineChanged', false)
+
+    expect(result.current.logs).toHaveLength(2)
+    const entry = result.current.logs[1]!
+    expect(entry.type).toBe('change')
+    expect(entry.message).toContain('online')
+    expect(entry.message).toContain('old → true')
+    expect(entry.message).toContain('new → false')
+  })
+
+  it('logs nothing when a re-render changes no field', () => {
+    const { result } = renderHook(() => useDebug({ enabled: true }))
+    fire('onOnlineChanged', true) // already true
+    expect(result.current.logs).toHaveLength(1)
+  })
+
+  // Progress ticks every second; logging each one would bury every other event.
+  it('ignores position drift under two seconds but reports a real seek', () => {
+    const { result } = renderHook(() => useDebug({ enabled: true }))
+
+    fire('onPlaybackProgressUpdated', { position: 1, duration: 0, buffered: 0 })
+    expect(result.current.logs).toHaveLength(1)
+
+    fire('onPlaybackProgressUpdated', {
+      position: 30,
+      duration: 0,
+      buffered: 0
+    })
+    expect(result.current.logs).toHaveLength(2)
+    expect(result.current.logs[1]!.message).toContain('position')
+  })
+
+  it('clears on demand', () => {
+    const { result } = renderHook(() => useDebug({ enabled: true }))
+    fire('onOnlineChanged', false)
+    expect(result.current.logs.length).toBeGreaterThan(0)
+
+    act(() => result.current.clear())
+    expect(result.current.logs).toEqual([])
+  })
+
+  it('caps the history and keeps the newest entries', () => {
+    const { result } = renderHook(() => useDebug({ enabled: true }))
+    for (let i = 0; i < 120; i++) fire('onOnlineChanged', i % 2 === 0)
+
+    expect(result.current.logs).toHaveLength(100)
+    // 120 alternating flips after the initial snapshot: the last one set online
+    // to false (i = 119 is odd), so the newest entry is the tail, not the head.
+    expect(result.current.logs.at(-1)!.message).toContain('new → false')
+  })
+
+  describe('metadata logging', () => {
+    it('is off by default', () => {
+      const { result } = renderHook(() => useDebug({ enabled: true }))
+      fire('onTrackMetadata', { title: 'Song' })
+      expect(result.current.logs.filter((l) => l.type === 'metadata')).toEqual(
+        []
+      )
+    })
+
+    it('records track, timed and chapter events when enabled', () => {
+      const { result } = renderHook(() =>
+        useDebug({ enabled: true, metadata: true })
+      )
+
+      fire('onTrackMetadata', { title: 'Song', artist: null })
+      fire('onTimedMetadata', { title: 'Live' })
+      fire('onChapterMetadata', [{}, {}])
+
+      const entries = result.current.logs.filter((l) => l.type === 'metadata')
+      expect(entries).toHaveLength(3)
+      expect(entries[0]!.message).toContain('[track] title: "Song"')
+      // Null fields are dropped rather than printed as `artist: "null"`.
+      expect(entries[0]!.message).not.toContain('artist')
+      expect(entries[1]!.message).toContain('[timed]')
+      expect(entries[2]!.message).toContain('2 chapters')
+    })
+
+    it('stops recording metadata after unmount', () => {
+      const { result, unmount } = renderHook(() =>
+        useDebug({ enabled: true, metadata: true })
+      )
+      const before = result.current.logs.length
+      unmount()
+      fire('onTrackMetadata', { title: 'Song' })
+      expect(result.current.logs).toHaveLength(before)
+    })
+  })
+
+  it('falls back to __DEV__ when enabled is not given', () => {
+    ;(globalThis as { __DEV__?: boolean }).__DEV__ = false
+    try {
+      const { result } = renderHook(() => useDebug())
+      expect(result.current.logs).toEqual([])
+    } finally {
+      delete (globalThis as { __DEV__?: boolean }).__DEV__
+    }
+  })
+})

package/src/utils/useNativeUpdatedValue.test.ts

@@ -0,0 +1,103 @@
+/** @vitest-environment happy-dom */
+
+import { renderHook, act, cleanup } from '@testing-library/react'
+import { describe, it, expect, afterEach, vi } from 'vitest'
+import { NativeUpdatedValue } from './NativeUpdatedValue'
+import { useNativeUpdatedValue } from './useNativeUpdatedValue'
+
+afterEach(cleanup)
+
+/**
+ * Builds an emitter plus the native-side callback that feeds it, so a test can
+ * push a value the way native would. `NativeUpdatedValue` hands its internal
+ * handler to the setter it is constructed with; capturing that handler _is_ the
+ * native bridge.
+ */
+function makeEmitter<T>() {
+  let emit: (value: T) => void = () => {}
+  const emitter = NativeUpdatedValue.emitterize<T>((cb) => (emit = cb))
+  return {
+    emitter,
+    /** Emit from outside React, as a native event would arrive. */
+    fire: (value: T) => act(() => emit(value)),
+    /** Emit from inside a render pass, where wrapping in `act` would nest. */
+    fireDuringRender: (value: T) => emit(value)
+  }
+}
+
+describe('useNativeUpdatedValue', () => {
+  it('falls back to the getter when nothing has fired yet', () => {
+    const { emitter } = makeEmitter<string>()
+    const { result } = renderHook(() =>
+      useNativeUpdatedValue(() => 'a', emitter)
+    )
+    expect(result.current).toBe('a')
+  })
+
+  it('prefers lastValue over the getter', () => {
+    const { emitter, fire } = makeEmitter<string>()
+    fire('fromNative')
+    const getter = vi.fn(() => 'fromGetter')
+    const { result } = renderHook(() => useNativeUpdatedValue(getter, emitter))
+    expect(result.current).toBe('fromNative')
+    expect(getter).not.toHaveBeenCalled()
+  })
+
+  it('updates when the emitter fires', () => {
+    const { emitter, fire } = makeEmitter<string>()
+    const { result } = renderHook(() =>
+      useNativeUpdatedValue(() => 'a', emitter)
+    )
+    fire('b')
+    expect(result.current).toBe('b')
+  })
+
+  it('extracts eventKey from both lastValue and later events', () => {
+    const { emitter, fire } = makeEmitter<{ volume: number }>()
+    fire({ volume: 0.5 })
+    const { result } = renderHook(() =>
+      useNativeUpdatedValue(() => 0, emitter, 'volume')
+    )
+    expect(result.current).toBe(0.5)
+    fire({ volume: 0.9 })
+    expect(result.current).toBe(0.9)
+  })
+
+  // The reason the effect re-reads `lastValue` instead of going straight to
+  // `addListener`. Nothing reads the value again until the next native event, so
+  // a value landing in this window would otherwise be missed permanently.
+  it('re-syncs a value that lands between the render read and the effect', () => {
+    const { emitter, fireDuringRender } = makeEmitter<string>()
+    // Firing from inside the getter puts the emit exactly where the race is:
+    // after the useState initializer has read, before the effect subscribes.
+    const getter = () => {
+      fireDuringRender('landedMidRender')
+      return 'staleAtRender'
+    }
+    const { result } = renderHook(() => useNativeUpdatedValue(getter, emitter))
+    expect(result.current).toBe('landedMidRender')
+  })
+
+  it('stops updating after unmount', () => {
+    const { emitter, fire } = makeEmitter<string>()
+    const { result, unmount } = renderHook(() =>
+      useNativeUpdatedValue(() => 'a', emitter)
+    )
+    unmount()
+    fire('b')
+    expect(result.current).toBe('a')
+  })
+
+  it('leaves no listener behind on unmount', () => {
+    const { emitter, fire } = makeEmitter<string>()
+    const { unmount } = renderHook(() =>
+      useNativeUpdatedValue(() => 'a', emitter)
+    )
+    unmount()
+    const seen: string[] = []
+    emitter.addListener((v) => seen.push(v))
+    fire('b')
+    // Only the listener added above — the hook's is gone, not merely inert.
+    expect(seen).toEqual(['b'])
+  })
+})

package/src/web/NativeAudioBrowser.ts

@@ -520,7 +520,7 @@ export class NativeAudioBrowser
     })
   }
 
-  async onSearch(query: string): Promise<Track[]> {
+  async search(query: string): Promise<Track[]> {
     // Wrap query string in SearchParams (matches Android's search(query: String) overload)
     return this.searchManager.search({ query, reference: 'unknown' })
   }

package/src/web/browser/BrowserManager.ts

@@ -573,7 +573,7 @@ export class BrowserManager {
    * `request → search` chain (search is its own kind — no browse layer). The
    * query params are seeded on the base so they survive both the static merge
    * and a search `transform`. Shared by `resolveSearchContent` (navigating to a
-   * search path) and `SearchManager` (the voice/`onSearch` API), so the ladder
+   * search path) and `SearchManager` (the voice/`search` API), so the ladder
    * isn't duplicated. Errors propagate to the caller.
    */
   async fetchSearchResults(

package/ios/Model/MediaURL.swift

@@ -1,67 +0,0 @@
-import Foundation
-
-struct MediaURL {
-  let value: URL
-  let isLocal: Bool
-  private let originalObject: Any
-
-  init?(object: Any?) {
-    guard let object else { return nil }
-    originalObject = object
-
-    // This is based on logic found in RCTConvert NSURLRequest
-    if let localObject = object as? [String: Any] {
-      var urlString = localObject["uri"] as? String ?? localObject["url"] as! String
-
-      if let bundleName = localObject["bundle"] as? String {
-        urlString = String(format: "%@.bundle/%@", bundleName, urlString)
-      }
-
-      isLocal = !urlString.lowercased().hasPrefix("http")
-      guard let converted = Self.convertToURL(urlString) else { return nil }
-      value = converted
-    } else {
-      let urlString = object as! String
-      isLocal = urlString.lowercased().hasPrefix("file://")
-      guard let converted = Self.convertToURL(urlString) else { return nil }
-      value = converted
-    }
-  }
-
-  /// Convert a string to URL, matching RCTConvert NSURL behavior
-  private static func convertToURL(_ string: String) -> URL? {
-    // Try as absolute URL first
-    if let url = URL(string: string), url.scheme != nil {
-      return url
-    }
-
-    // If it has a scheme but failed, try percent-encoding
-    if string.contains("://") {
-      var allowed = CharacterSet()
-      allowed.formUnion(.urlUserAllowed)
-      allowed.formUnion(.urlPasswordAllowed)
-      allowed.formUnion(.urlHostAllowed)
-      allowed.formUnion(.urlPathAllowed)
-      allowed.formUnion(.urlQueryAllowed)
-      allowed.formUnion(.urlFragmentAllowed)
-      if let encoded = string.addingPercentEncoding(withAllowedCharacters: allowed),
-         let url = URL(string: encoded)
-      {
-        return url
-      }
-    }
-
-    // Assume it's a local path
-    var path = string.removingPercentEncoding ?? string
-
-    if path.hasPrefix("~") {
-      // Expand tilde for user directory
-      path = NSString(string: path).expandingTildeInPath
-    } else if !path.hasPrefix("/") {
-      // Not absolute - assume it's a bundle resource path
-      path = (Bundle.main.resourcePath ?? "") + "/" + path
-    }
-
-    return URL(fileURLWithPath: path)
-  }
-}

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

@@ -1,94 +0,0 @@
-///
-/// JNotificationButtonLayout.hpp
-/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/nitro
-/// Copyright © Marc Rousavy @ Margelo
-///
-
-#pragma once
-
-#include <fbjni/fbjni.h>
-#include "NotificationButtonLayout.hpp"
-
-#include "JNotificationButton.hpp"
-#include "NotificationButton.hpp"
-#include <optional>
-#include <vector>
-
-namespace margelo::nitro::audiobrowser {
-
-  using namespace facebook;
-
-  /**
-   * The C++ JNI bridge between the C++ struct "NotificationButtonLayout" and the the Kotlin data class "NotificationButtonLayout".
-   */
-  struct JNotificationButtonLayout final: public jni::JavaClass<JNotificationButtonLayout> {
-  public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/NotificationButtonLayout;";
-
-  public:
-    /**
-     * Convert this Java/Kotlin-based struct to the C++ struct NotificationButtonLayout by copying all values to C++.
-     */
-    [[maybe_unused]]
-    [[nodiscard]]
-    NotificationButtonLayout toCpp() const {
-      static const auto clazz = javaClassStatic();
-      static const auto fieldBack = clazz->getField<JNotificationButton>("back");
-      jni::local_ref<JNotificationButton> back = this->getFieldValue(fieldBack);
-      static const auto fieldForward = clazz->getField<JNotificationButton>("forward");
-      jni::local_ref<JNotificationButton> forward = this->getFieldValue(fieldForward);
-      static const auto fieldBackSecondary = clazz->getField<JNotificationButton>("backSecondary");
-      jni::local_ref<JNotificationButton> backSecondary = this->getFieldValue(fieldBackSecondary);
-      static const auto fieldForwardSecondary = clazz->getField<JNotificationButton>("forwardSecondary");
-      jni::local_ref<JNotificationButton> forwardSecondary = this->getFieldValue(fieldForwardSecondary);
-      static const auto fieldOverflow = clazz->getField<jni::JArrayClass<JNotificationButton>>("overflow");
-      jni::local_ref<jni::JArrayClass<JNotificationButton>> overflow = this->getFieldValue(fieldOverflow);
-      return NotificationButtonLayout(
-        back != nullptr ? std::make_optional(back->toCpp()) : std::nullopt,
-        forward != nullptr ? std::make_optional(forward->toCpp()) : std::nullopt,
-        backSecondary != nullptr ? std::make_optional(backSecondary->toCpp()) : std::nullopt,
-        forwardSecondary != nullptr ? std::make_optional(forwardSecondary->toCpp()) : std::nullopt,
-        overflow != nullptr ? std::make_optional([&]() {
-          size_t __size = overflow->size();
-          std::vector<NotificationButton> __vector;
-          __vector.reserve(__size);
-          for (size_t __i = 0; __i < __size; __i++) {
-            auto __element = overflow->getElement(__i);
-            __vector.push_back(__element->toCpp());
-          }
-          return __vector;
-        }()) : std::nullopt
-      );
-    }
-
-  public:
-    /**
-     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
-     */
-    [[maybe_unused]]
-    static jni::local_ref<JNotificationButtonLayout::javaobject> fromCpp(const NotificationButtonLayout& value) {
-      using JSignature = JNotificationButtonLayout(jni::alias_ref<JNotificationButton>, jni::alias_ref<JNotificationButton>, jni::alias_ref<JNotificationButton>, jni::alias_ref<JNotificationButton>, jni::alias_ref<jni::JArrayClass<JNotificationButton>>);
-      static const auto clazz = javaClassStatic();
-      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
-      return create(
-        clazz,
-        value.back.has_value() ? JNotificationButton::fromCpp(value.back.value()) : nullptr,
-        value.forward.has_value() ? JNotificationButton::fromCpp(value.forward.value()) : nullptr,
-        value.backSecondary.has_value() ? JNotificationButton::fromCpp(value.backSecondary.value()) : nullptr,
-        value.forwardSecondary.has_value() ? JNotificationButton::fromCpp(value.forwardSecondary.value()) : nullptr,
-        value.overflow.has_value() ? [&]() {
-          size_t __size = value.overflow.value().size();
-          jni::local_ref<jni::JArrayClass<JNotificationButton>> __array = jni::JArrayClass<JNotificationButton>::newArray(__size);
-          for (size_t __i = 0; __i < __size; __i++) {
-            const auto& __element = value.overflow.value()[__i];
-            auto __elementJni = JNotificationButton::fromCpp(__element);
-            __array->setElement(__i, *__elementJni);
-          }
-          return __array;
-        }() : nullptr
-      );
-    }
-  };
-
-} // namespace margelo::nitro::audiobrowser

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

@@ -1,26 +0,0 @@
-///
-/// JVariant_NullType_NotificationButtonLayout.cpp
-/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/nitro
-/// Copyright © Marc Rousavy @ Margelo
-///
-
-#include "JVariant_NullType_NotificationButtonLayout.hpp"
-
-namespace margelo::nitro::audiobrowser {
-  /**
-   * Converts JVariant_NullType_NotificationButtonLayout to std::variant<nitro::NullType, NotificationButtonLayout>
-   */
-  std::variant<nitro::NullType, NotificationButtonLayout> JVariant_NullType_NotificationButtonLayout::toCpp() const {
-    if (isInstanceOf(JVariant_NullType_NotificationButtonLayout_impl::First::javaClassStatic())) {
-      // It's a `nitro::NullType`
-      auto jniValue = static_cast<const JVariant_NullType_NotificationButtonLayout_impl::First*>(this)->getValue();
-      return nitro::null;
-    } else if (isInstanceOf(JVariant_NullType_NotificationButtonLayout_impl::Second::javaClassStatic())) {
-      // It's a `NotificationButtonLayout`
-      auto jniValue = static_cast<const JVariant_NullType_NotificationButtonLayout_impl::Second*>(this)->getValue();
-      return jniValue->toCpp();
-    }
-    throw std::invalid_argument("Variant is unknown Kotlin instance!");
-  }
-} // namespace margelo::nitro::audiobrowser

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

@@ -1,75 +0,0 @@
-///
-/// JVariant_NullType_NotificationButtonLayout.hpp
-/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/nitro
-/// Copyright © Marc Rousavy @ Margelo
-///
-
-#pragma once
-
-#include <fbjni/fbjni.h>
-#include <variant>
-
-#include <NitroModules/Null.hpp>
-#include "NotificationButtonLayout.hpp"
-#include <variant>
-#include <NitroModules/JNull.hpp>
-#include "JNotificationButtonLayout.hpp"
-#include "NotificationButton.hpp"
-#include <optional>
-#include "JNotificationButton.hpp"
-#include <vector>
-
-namespace margelo::nitro::audiobrowser {
-
-  using namespace facebook;
-
-  /**
-   * The C++ JNI bridge between the C++ std::variant and the Java class "Variant_NullType_NotificationButtonLayout".
-   */
-  class JVariant_NullType_NotificationButtonLayout: public jni::JavaClass<JVariant_NullType_NotificationButtonLayout> {
-  public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/Variant_NullType_NotificationButtonLayout;";
-
-    static jni::local_ref<JVariant_NullType_NotificationButtonLayout> create_0(jni::alias_ref<JNull> value) {
-      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_NotificationButtonLayout(jni::alias_ref<JNull>)>("create");
-      return method(javaClassStatic(), value);
-    }
-    static jni::local_ref<JVariant_NullType_NotificationButtonLayout> create_1(jni::alias_ref<JNotificationButtonLayout> value) {
-      static const auto method = javaClassStatic()->getStaticMethod<JVariant_NullType_NotificationButtonLayout(jni::alias_ref<JNotificationButtonLayout>)>("create");
-      return method(javaClassStatic(), value);
-    }
-
-    static jni::local_ref<JVariant_NullType_NotificationButtonLayout> fromCpp(const std::variant<nitro::NullType, NotificationButtonLayout>& variant) {
-      switch (variant.index()) {
-        case 0: return create_0(JNull::null());
-        case 1: return create_1(JNotificationButtonLayout::fromCpp(std::get<1>(variant)));
-        default: throw std::invalid_argument("Variant holds unknown index! (" + std::to_string(variant.index()) + ")");
-      }
-    }
-
-    [[nodiscard]] std::variant<nitro::NullType, NotificationButtonLayout> toCpp() const;
-  };
-
-  namespace JVariant_NullType_NotificationButtonLayout_impl {
-    class First final: public jni::JavaClass<First, JVariant_NullType_NotificationButtonLayout> {
-    public:
-      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/Variant_NullType_NotificationButtonLayout$First;";
-    
-      [[nodiscard]] jni::local_ref<JNull> getValue() const {
-        static const auto field = javaClassStatic()->getField<JNull>("value");
-        return getFieldValue(field);
-      }
-    };
-    
-    class Second final: public jni::JavaClass<Second, JVariant_NullType_NotificationButtonLayout> {
-    public:
-      static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/Variant_NullType_NotificationButtonLayout$Second;";
-    
-      [[nodiscard]] jni::local_ref<JNotificationButtonLayout> getValue() const {
-        static const auto field = javaClassStatic()->getField<JNotificationButtonLayout>("value");
-        return getFieldValue(field);
-      }
-    };
-  } // namespace JVariant_NullType_NotificationButtonLayout_impl
-} // namespace margelo::nitro::audiobrowser

package/nitrogen/generated/android/kotlin/com/margelo/nitro/audiobrowser/NotificationButtonLayout.kt

@@ -1,50 +0,0 @@
-///
-/// NotificationButtonLayout.kt
-/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/nitro
-/// Copyright © Marc Rousavy @ Margelo
-///
-
-package com.margelo.nitro.audiobrowser
-
-import androidx.annotation.Keep
-import com.facebook.proguard.annotations.DoNotStrip
-
-
-/**
- * Represents the JavaScript object/struct "NotificationButtonLayout".
- */
-@DoNotStrip
-@Keep
-data class NotificationButtonLayout(
-  @DoNotStrip
-  @Keep
-  val back: NotificationButton?,
-  @DoNotStrip
-  @Keep
-  val forward: NotificationButton?,
-  @DoNotStrip
-  @Keep
-  val backSecondary: NotificationButton?,
-  @DoNotStrip
-  @Keep
-  val forwardSecondary: NotificationButton?,
-  @DoNotStrip
-  @Keep
-  val overflow: Array<NotificationButton>?
-) {
-  /* primary constructor */
-
-  companion object {
-    /**
-     * Constructor called from C++
-     */
-    @DoNotStrip
-    @Keep
-    @Suppress("unused")
-    @JvmStatic
-    private fun fromCpp(back: NotificationButton?, forward: NotificationButton?, backSecondary: NotificationButton?, forwardSecondary: NotificationButton?, overflow: Array<NotificationButton>?): NotificationButtonLayout {
-      return NotificationButtonLayout(back, forward, backSecondary, forwardSecondary, overflow)
-    }
-  }
-}