react-native-audio-browser 0.0.1 → 0.1.0-next.1

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

@@ -0,0 +1,194 @@
+/**
+ * Simple route matcher for path patterns with parameter extraction.
+ *
+ * Supports patterns like:
+ * - /artists - exact match
+ * - /artists/{id} - parameter extraction
+ * - /artists/{id}/albums - multiple segments with parameters
+ * - /artists/* - wildcard match (matches any single segment)
+ * - /files/** - tail wildcard (matches remaining path segments)
+ *
+ * Route specificity rules:
+ * - More path segments = higher specificity
+ * - Constant segments > parameter segments > wildcards > tail wildcards
+ * - Most specific route wins
+ */
+
+import { assertedNotNullish } from '../utils/validation'
+
+export interface RouteMatch {
+  params: Record<string, string>
+  specificity: number
+}
+
+export class SimpleRouter {
+  /**
+   * Finds the best matching route for the given path.
+   *
+   * @param path The incoming path to match (e.g., "/artists/123")
+   * @param routes Map of route patterns to match against
+   * @return Tuple of [route pattern, match result] or null if no match
+   */
+  findBestMatch<T>(
+    path: string,
+    routes: Record<string, T>
+  ): [string, RouteMatch] | null {
+    const matches: Array<[string, RouteMatch]> = []
+
+    for (const pattern of Object.keys(routes)) {
+      const match = this.matchPattern(pattern, path)
+      if (match) {
+        matches.push([pattern, match])
+      }
+    }
+
+    if (matches.length === 0) {
+      return null
+    }
+
+    // Find the match with highest specificity
+    return matches.reduce((best, current) =>
+      current[1].specificity > best[1].specificity ? current : best
+    )
+  }
+
+  /**
+   * Attempts to match a single pattern against a path.
+   *
+   * @param pattern Route pattern (e.g., "/artists/{id}", "/files/*", "/api/**")
+   * @param path Incoming path (e.g., "/artists/123")
+   * @return RouteMatch if successful, null otherwise
+   */
+  private matchPattern(pattern: string, path: string): RouteMatch | null {
+    const patternSegments = pattern.split('/').filter((s) => s.length > 0)
+    const pathSegments = path.split('/').filter((s) => s.length > 0)
+
+    const params: Record<string, string> = {}
+    let constantSegments = 0
+    let parameterSegments = 0
+    let wildcardSegments = 0
+    let hasTailWildcard = false
+
+    // Check for tail wildcard at end
+    if (
+      patternSegments.length > 0 &&
+      patternSegments[patternSegments.length - 1] === '**'
+    ) {
+      hasTailWildcard = true
+
+      // For tail wildcard, pattern must have <= path segments
+      if (patternSegments.length - 1 > pathSegments.length) {
+        return null
+      }
+
+      // Match all segments except the tail wildcard
+      for (let i = 0; i < patternSegments.length - 1; i++) {
+        if (
+          !this.matchSingleSegment(
+            assertedNotNullish(patternSegments[i]),
+            assertedNotNullish(pathSegments[i]),
+            params
+          )
+        ) {
+          return null
+        }
+        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
+      if (pathSegments.length > patternSegments.length - 1) {
+        const remainingSegments = pathSegments.slice(patternSegments.length - 1)
+        params['tail'] = remainingSegments.join('/')
+      }
+    } else {
+      // Normal matching - must have same number of segments
+      if (patternSegments.length !== pathSegments.length) {
+        return null
+      }
+
+      for (let i = 0; i < patternSegments.length; i++) {
+        if (
+          !this.matchSingleSegment(
+            assertedNotNullish(patternSegments[i]),
+            assertedNotNullish(pathSegments[i]),
+            params
+          )
+        ) {
+          return null
+        }
+        const [constCount, paramCount, wildcardCount] =
+          this.updateSegmentCounts(
+            assertedNotNullish(patternSegments[i]),
+            constantSegments,
+            parameterSegments,
+            wildcardSegments
+          )
+        constantSegments = constCount
+        parameterSegments = paramCount
+        wildcardSegments = wildcardCount
+      }
+    }
+
+    // Specificity calculation (higher = more specific):
+    // - Constants: 1000 points each
+    // - Parameters: 100 points each
+    // - Single wildcards: 10 points each
+    // - Tail wildcard: 1 point
+    // - Base path length: segments count
+    const specificity =
+      constantSegments * 1000 +
+      parameterSegments * 100 +
+      wildcardSegments * 10 +
+      (hasTailWildcard ? 1 : 0) +
+      patternSegments.length
+
+    return { params, specificity }
+  }
+
+  private matchSingleSegment(
+    patternSegment: string,
+    pathSegment: string,
+    params: Record<string, string>
+  ): boolean {
+    // Parameter segment: {paramName}
+    if (patternSegment.startsWith('{') && patternSegment.endsWith('}')) {
+      const paramName = patternSegment.substring(1, patternSegment.length - 1)
+      params[paramName] = pathSegment
+      return true
+    }
+    // Single wildcard: *
+    if (patternSegment === '*') {
+      return true
+    }
+    // Constant segment: must match exactly
+    if (patternSegment === pathSegment) {
+      return true
+    }
+    // Mismatch
+    return false
+  }
+
+  private updateSegmentCounts(
+    patternSegment: string,
+    constantSegments: number,
+    parameterSegments: number,
+    wildcardSegments: number
+  ): [number, number, number] {
+    if (patternSegment.startsWith('{') && patternSegment.endsWith('}')) {
+      return [constantSegments, parameterSegments + 1, wildcardSegments]
+    } else if (patternSegment === '*') {
+      return [constantSegments, parameterSegments, wildcardSegments + 1]
+    } else {
+      return [constantSegments + 1, parameterSegments, wildcardSegments]
+    }
+  }
+}

package/src/web/TrackPlayer/Event.ts

@@ -0,0 +1,11 @@
+// Web-specific event constants
+export enum Event {
+  PlaybackState = 'playback-state',
+  PlaybackProgressUpdated = 'playback-progress-updated',
+  PlaybackQueueEnded = 'playback-queue-ended',
+  PlaybackPlayWhenReadyChanged = 'playback-play-when-ready-changed',
+  PlaybackActiveTrackChanged = 'playback-active-track-changed',
+  PlaybackError = 'playback-error',
+  PlaybackRepeatModeChanged = 'playback-repeat-mode-changed',
+  PlaybackOptionsChanged = 'playback-options-changed'
+}