@5stones/react-native-audio-browser 0.2.0 → 0.3.0

package/src/web/SimpleRouter.test.ts

@@ -0,0 +1,160 @@
+import { describe, it, expect } from 'vitest'
+import { SimpleRouter } from './SimpleRouter'
+
+const router = new SimpleRouter()
+
+function match(path: string, routes: Record<string, true>) {
+  return router.findBestMatch(path, routes)
+}
+
+describe('SimpleRouter', () => {
+  describe('exact matches', () => {
+    it('matches a simple path', () => {
+      const result = match('/artists', { '/artists': true })
+      expect(result).not.toBeNull()
+      expect(result![0]).toBe('/artists')
+      expect(result![1].params).toEqual({})
+    })
+
+    it('matches multi-segment paths', () => {
+      const result = match('/artists/top/rated', {
+        '/artists/top/rated': true,
+      })
+      expect(result).not.toBeNull()
+      expect(result![0]).toBe('/artists/top/rated')
+    })
+
+    it('returns null when no route matches', () => {
+      expect(match('/unknown', { '/artists': true })).toBeNull()
+    })
+
+    it('returns null when segment count differs', () => {
+      expect(match('/artists/123', { '/artists': true })).toBeNull()
+    })
+
+    it('returns null when routes are empty', () => {
+      expect(match('/artists', {})).toBeNull()
+    })
+
+    it('treats trailing slashes the same as without', () => {
+      const result = match('/artists/', { '/artists': true })
+      expect(result).not.toBeNull()
+      expect(result![0]).toBe('/artists')
+    })
+  })
+
+  describe('parameter extraction', () => {
+    it('extracts a single parameter', () => {
+      const result = match('/artists/123', { '/artists/{id}': true })
+      expect(result).not.toBeNull()
+      expect(result![1].params).toEqual({ id: '123' })
+    })
+
+    it('extracts multiple parameters', () => {
+      const result = match('/artists/123/albums/456', {
+        '/artists/{artistId}/albums/{albumId}': true,
+      })
+      expect(result).not.toBeNull()
+      expect(result![1].params).toEqual({
+        artistId: '123',
+        albumId: '456',
+      })
+    })
+  })
+
+  describe('single wildcard', () => {
+    it('matches any single segment', () => {
+      expect(match('/artists/anything', { '/artists/*': true })).not.toBeNull()
+    })
+
+    it('does not extract wildcard value into params', () => {
+      const result = match('/artists/anything', { '/artists/*': true })
+      expect(result![1].params).toEqual({})
+    })
+  })
+
+  describe('tail wildcard', () => {
+    it('matches with no remaining segments and has no tail param', () => {
+      const result = match('/files', { '/files/**': true })
+      expect(result).not.toBeNull()
+      expect(result![1].params).toEqual({})
+    })
+
+    it('matches with remaining segments and captures tail', () => {
+      const result = match('/files/a/b/c', { '/files/**': true })
+      expect(result).not.toBeNull()
+      expect(result![1].params).toEqual({ tail: 'a/b/c' })
+    })
+
+    it('matches with a single remaining segment', () => {
+      const result = match('/files/readme.txt', { '/files/**': true })
+      expect(result).not.toBeNull()
+      expect(result![1].params).toEqual({ tail: 'readme.txt' })
+    })
+
+    it('returns null when prefix segments do not match', () => {
+      expect(match('/other/a/b', { '/files/**': true })).toBeNull()
+    })
+
+    it('works with parameters before tail wildcard', () => {
+      const result = match('/api/v1/users/list', {
+        '/api/{version}/**': true,
+      })
+      expect(result).not.toBeNull()
+      expect(result![1].params).toEqual({
+        version: 'v1',
+        tail: 'users/list',
+      })
+    })
+
+    it('matches any path with bare /** pattern', () => {
+      const result = match('/any/path/here', { '/**': true })
+      expect(result).not.toBeNull()
+      expect(result![1].params).toEqual({ tail: 'any/path/here' })
+    })
+  })
+
+  describe('specificity', () => {
+    it('prefers constant segments over parameters', () => {
+      const result = match('/artists/top', {
+        '/artists/{id}': true,
+        '/artists/top': true,
+      })
+      expect(result![0]).toBe('/artists/top')
+    })
+
+    it('prefers parameters over wildcards', () => {
+      const result = match('/artists/123', {
+        '/artists/*': true,
+        '/artists/{id}': true,
+      })
+      expect(result![0]).toBe('/artists/{id}')
+    })
+
+    it('prefers exact match over tail wildcard', () => {
+      const result = match('/api/v1', {
+        '/api/**': true,
+        '/api/{version}': true,
+      })
+      expect(result![0]).toBe('/api/{version}')
+    })
+
+    it('computes correct specificity for tail wildcard patterns', () => {
+      // Regression test for issue #27: specificity must account for
+      // segment types before the ** wildcard.
+      const result = match('/api/v1/users', { '/api/v1/**': true })
+      // constant "api" (1000) + constant "v1" (1000) + tail(1) + 3 segments = 2004
+      expect(result![1].specificity).toBe(2004)
+    })
+
+    it('prefers constant prefix over parameter prefix in tail wildcards', () => {
+      // Second part of issue #27: with correct specificity, the constant
+      // prefix should beat the parameter prefix.
+      const result = match('/api/v1/users', {
+        '/api/{version}/**': true,
+        '/api/v1/**': true,
+      })
+      expect(result![0]).toBe('/api/v1/**')
+    })
+  })
+})

package/src/web/SimpleRouter.ts

@@ -92,14 +92,16 @@ export class SimpleRouter {
         ) {
           return null
         }
-        // Note: The Kotlin implementation doesn't update counts here (appears to be a bug)
-        // but we'll match it exactly for consistency
-        this.updateSegmentCounts(
-          assertedNotNullish(patternSegments[i]),
-          constantSegments,
-          parameterSegments,
-          wildcardSegments
-        )
+        const [constCount, paramCount, wildcardCount] =
+          this.updateSegmentCounts(
+            assertedNotNullish(patternSegments[i]),
+            constantSegments,
+            parameterSegments,
+            wildcardSegments
+          )
+        constantSegments = constCount
+        parameterSegments = paramCount
+        wildcardSegments = wildcardCount
       }
 
       // Capture remaining path segments as "tail" parameter

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

@@ -1,89 +0,0 @@
-///
-/// JFunc_void_RemoteLoadEvent.hpp
-/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/nitro
-/// Copyright © 2026 Marc Rousavy @ Margelo
-///
-
-#pragma once
-
-#include <fbjni/fbjni.h>
-#include <functional>
-
-#include "RemoteLoadEvent.hpp"
-#include <functional>
-#include <NitroModules/JNICallable.hpp>
-#include "JRemoteLoadEvent.hpp"
-#include "Track.hpp"
-#include "JTrack.hpp"
-#include <string>
-#include <optional>
-#include "ImageSource.hpp"
-#include "JImageSource.hpp"
-#include "HttpMethod.hpp"
-#include "JHttpMethod.hpp"
-#include <unordered_map>
-#include "TrackStyle.hpp"
-#include "JTrackStyle.hpp"
-#include <vector>
-
-namespace margelo::nitro::audiobrowser {
-
-  using namespace facebook;
-
-  /**
-   * Represents the Java/Kotlin callback `(event: RemoteLoadEvent) -> Unit`.
-   * This can be passed around between C++ and Java/Kotlin.
-   */
-  struct JFunc_void_RemoteLoadEvent: public jni::JavaClass<JFunc_void_RemoteLoadEvent> {
-  public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/Func_void_RemoteLoadEvent;";
-
-  public:
-    /**
-     * Invokes the function this `JFunc_void_RemoteLoadEvent` instance holds through JNI.
-     */
-    void invoke(const RemoteLoadEvent& event) const {
-      static const auto method = javaClassStatic()->getMethod<void(jni::alias_ref<JRemoteLoadEvent> /* event */)>("invoke");
-      method(self(), JRemoteLoadEvent::fromCpp(event));
-    }
-  };
-
-  /**
-   * An implementation of Func_void_RemoteLoadEvent that is backed by a C++ implementation (using `std::function<...>`)
-   */
-  class JFunc_void_RemoteLoadEvent_cxx final: public jni::HybridClass<JFunc_void_RemoteLoadEvent_cxx, JFunc_void_RemoteLoadEvent> {
-  public:
-    static jni::local_ref<JFunc_void_RemoteLoadEvent::javaobject> fromCpp(const std::function<void(const RemoteLoadEvent& /* event */)>& func) {
-      return JFunc_void_RemoteLoadEvent_cxx::newObjectCxxArgs(func);
-    }
-
-  public:
-    /**
-     * Invokes the C++ `std::function<...>` this `JFunc_void_RemoteLoadEvent_cxx` instance holds.
-     */
-    void invoke_cxx(jni::alias_ref<JRemoteLoadEvent> event) {
-      _func(event->toCpp());
-    }
-
-  public:
-    [[nodiscard]]
-    inline const std::function<void(const RemoteLoadEvent& /* event */)>& getFunction() const {
-      return _func;
-    }
-
-  public:
-    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/audiobrowser/Func_void_RemoteLoadEvent_cxx;";
-    static void registerNatives() {
-      registerHybrid({makeNativeMethod("invoke_cxx", JFunc_void_RemoteLoadEvent_cxx::invoke_cxx)});
-    }
-
-  private:
-    explicit JFunc_void_RemoteLoadEvent_cxx(const std::function<void(const RemoteLoadEvent& /* event */)>& func): _func(func) { }
-
-  private:
-    friend HybridBase;
-    std::function<void(const RemoteLoadEvent& /* event */)> _func;
-  };
-
-} // namespace margelo::nitro::audiobrowser

package/nitrogen/generated/ios/swift/Func_void_RemoteLoadEvent.swift

@@ -1,47 +0,0 @@
-///
-/// Func_void_RemoteLoadEvent.swift
-/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/nitro
-/// Copyright © 2026 Marc Rousavy @ Margelo
-///
-
-import Foundation
-import NitroModules
-
-/**
- * Wraps a Swift `(_ event: RemoteLoadEvent) -> Void` as a class.
- * This class can be used from C++, e.g. to wrap the Swift closure as a `std::function`.
- */
-public final class Func_void_RemoteLoadEvent {
-  public typealias bridge = margelo.nitro.audiobrowser.bridge.swift
-
-  private let closure: (_ event: RemoteLoadEvent) -> Void
-
-  public init(_ closure: @escaping (_ event: RemoteLoadEvent) -> Void) {
-    self.closure = closure
-  }
-
-  @inline(__always)
-  public func call(event: RemoteLoadEvent) -> Void {
-    self.closure(event)
-  }
-
-  /**
-   * Casts this instance to a retained unsafe raw pointer.
-   * This acquires one additional strong reference on the object!
-   */
-  @inline(__always)
-  public func toUnsafe() -> UnsafeMutableRawPointer {
-    return Unmanaged.passRetained(self).toOpaque()
-  }
-
-  /**
-   * Casts an unsafe pointer to a `Func_void_RemoteLoadEvent`.
-   * The pointer has to be a retained opaque `Unmanaged<Func_void_RemoteLoadEvent>`.
-   * This removes one strong reference from the object!
-   */
-  @inline(__always)
-  public static func fromUnsafe(_ pointer: UnsafeMutableRawPointer) -> Func_void_RemoteLoadEvent {
-    return Unmanaged<Func_void_RemoteLoadEvent>.fromOpaque(pointer).takeRetainedValue()
-  }
-}

package/nitrogen/generated/ios/swift/RemoteLoadEvent.swift

@@ -1,70 +0,0 @@
-///
-/// RemoteLoadEvent.swift
-/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
-/// https://github.com/mrousavy/nitro
-/// Copyright © 2026 Marc Rousavy @ Margelo
-///
-
-import Foundation
-import NitroModules
-
-/**
- * Represents an instance of `RemoteLoadEvent`, backed by a C++ struct.
- */
-public typealias RemoteLoadEvent = margelo.nitro.audiobrowser.RemoteLoadEvent
-
-public extension RemoteLoadEvent {
-  private typealias bridge = margelo.nitro.audiobrowser.bridge.swift
-
-  /**
-   * Create a new instance of `RemoteLoadEvent`.
-   */
-  init(track: Track, queue: [Track], startIndex: Double) {
-    self.init(track, { () -> bridge.std__vector_Track_ in
-      var __vector = bridge.create_std__vector_Track_(queue.count)
-      for __item in queue {
-        __vector.push_back(__item)
-      }
-      return __vector
-    }(), startIndex)
-  }
-
-  var track: Track {
-    @inline(__always)
-    get {
-      return self.__track
-    }
-    @inline(__always)
-    set {
-      self.__track = newValue
-    }
-  }
-  
-  var queue: [Track] {
-    @inline(__always)
-    get {
-      return self.__queue.map({ __item in __item })
-    }
-    @inline(__always)
-    set {
-      self.__queue = { () -> bridge.std__vector_Track_ in
-        var __vector = bridge.create_std__vector_Track_(newValue.count)
-        for __item in newValue {
-          __vector.push_back(__item)
-        }
-        return __vector
-      }()
-    }
-  }
-  
-  var startIndex: Double {
-    @inline(__always)
-    get {
-      return self.__startIndex
-    }
-    @inline(__always)
-    set {
-      self.__startIndex = newValue
-    }
-  }
-}