@flighthq/mediasession 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './mediasession';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './mediasession';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/dist/mediasession.d.ts

@@ -0,0 +1,12 @@
+import type { MediaSessionAction, MediaSessionActionDetails, MediaSessionBackend, MediaSessionMetadata, MediaSessionPlaybackState, MediaSessionPositionState } from '@flighthq/types';
+export declare function clearMediaSessionActionHandler(action: MediaSessionAction): void;
+export declare function clearMediaSessionMetadata(): void;
+export declare function clearMediaSessionPositionState(): void;
+export declare function createWebMediaSessionBackend(): MediaSessionBackend;
+export declare function getMediaSessionBackend(): MediaSessionBackend;
+export declare function setMediaSessionActionHandler(action: MediaSessionAction, handler: (details: Readonly<MediaSessionActionDetails>) => void): void;
+export declare function setMediaSessionBackend(backend: MediaSessionBackend | null): void;
+export declare function setMediaSessionMetadata(metadata: Readonly<MediaSessionMetadata>): void;
+export declare function setMediaSessionPlaybackState(state: MediaSessionPlaybackState): void;
+export declare function setMediaSessionPositionState(state: Readonly<MediaSessionPositionState>): void;
+//# sourceMappingURL=mediasession.d.ts.map

package/dist/mediasession.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mediasession.d.ts","sourceRoot":"","sources":["../src/mediasession.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,yBAAyB,EACzB,mBAAmB,EACnB,oBAAoB,EACpB,yBAAyB,EACzB,yBAAyB,EAC1B,MAAM,iBAAiB,CAAC;AAGzB,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,kBAAkB,GAAG,IAAI,CAE/E;AAGD,wBAAgB,yBAAyB,IAAI,IAAI,CAEhD;AAGD,wBAAgB,8BAA8B,IAAI,IAAI,CAErD;AAKD,wBAAgB,4BAA4B,IAAI,mBAAmB,CAuClE;AAGD,wBAAgB,sBAAsB,IAAI,mBAAmB,CAG5D;AAID,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,kBAAkB,EAC1B,OAAO,EAAE,CAAC,OAAO,EAAE,QAAQ,CAAC,yBAAyB,CAAC,KAAK,IAAI,GAC9D,IAAI,CAEN;AAGD,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI,GAAG,IAAI,CAEhF;AAGD,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,QAAQ,CAAC,oBAAoB,CAAC,GAAG,IAAI,CAEtF;AAGD,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,yBAAyB,GAAG,IAAI,CAEnF;AAGD,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,QAAQ,CAAC,yBAAyB,CAAC,GAAG,IAAI,CAE7F"}

package/dist/mediasession.js

@@ -0,0 +1,95 @@
+// Clears the handler for a transport action; the OS drops the corresponding button.
+export function clearMediaSessionActionHandler(action) {
+    getMediaSessionBackend().setActionHandler(action, null);
+}
+// Clears the now-playing card from the OS media UI.
+export function clearMediaSessionMetadata() {
+    getMediaSessionBackend().setMetadata(null);
+}
+// Clears the scrubber position/duration the OS shows.
+export function clearMediaSessionPositionState() {
+    getMediaSessionBackend().setPositionState(null);
+}
+// Builds the default web backend over navigator.mediaSession. Every method is a no-op when the API
+// (or a specific capability such as setPositionState / MediaMetadata) is absent — jsdom, older
+// browsers, non-secure contexts — rather than throwing.
+export function createWebMediaSessionBackend() {
+    return {
+        setMetadata(metadata) {
+            const session = getWebMediaSession();
+            if (session === null)
+                return;
+            if (metadata === null) {
+                session.metadata = null;
+                return;
+            }
+            if (typeof MediaMetadata === 'undefined')
+                return;
+            session.metadata = new MediaMetadata({
+                title: metadata.title,
+                artist: metadata.artist,
+                album: metadata.album,
+                artwork: [...metadata.artwork],
+            });
+        },
+        setPlaybackState(state) {
+            const session = getWebMediaSession();
+            if (session === null)
+                return;
+            session.playbackState = state;
+        },
+        setPositionState(state) {
+            const session = getWebMediaSession();
+            if (session === null || typeof session.setPositionState !== 'function')
+                return;
+            // A null position clears the OS scrubber; the web API spells "clear" as an omitted argument.
+            session.setPositionState(state ?? undefined);
+        },
+        setActionHandler(action, handler) {
+            const session = getWebMediaSession();
+            if (session === null)
+                return;
+            try {
+                // Some browsers throw for an action they do not support; treat that as a no-op.
+                session.setActionHandler(action, handler ? (details) => handler(details) : null);
+            }
+            catch {
+                // Unsupported action — leave it unregistered.
+            }
+        },
+    };
+}
+// The active media-session backend, or a lazily-created web default. There is always a backend.
+export function getMediaSessionBackend() {
+    if (_backend === null)
+        _backend = createWebMediaSessionBackend();
+    return _backend;
+}
+// Registers a handler the OS invokes when the user presses the corresponding transport button
+// (play/pause/next/seek/…). Pass null via clearMediaSessionActionHandler to remove it.
+export function setMediaSessionActionHandler(action, handler) {
+    getMediaSessionBackend().setActionHandler(action, handler);
+}
+// Installs a native host media-session backend; pass null to fall back to the web default.
+export function setMediaSessionBackend(backend) {
+    _backend = backend;
+}
+// Publishes the now-playing card (title/artist/album/artwork) to the OS media UI.
+export function setMediaSessionMetadata(metadata) {
+    getMediaSessionBackend().setMetadata(metadata);
+}
+// Reports whether media is playing/paused/absent so the OS shows the right play/pause affordance.
+export function setMediaSessionPlaybackState(state) {
+    getMediaSessionBackend().setPlaybackState(state);
+}
+// Publishes the scrubber position/duration/playbackRate so the OS can render an accurate seek bar.
+export function setMediaSessionPositionState(state) {
+    getMediaSessionBackend().setPositionState(state);
+}
+let _backend = null;
+function getWebMediaSession() {
+    if (typeof navigator === 'undefined' || !('mediaSession' in navigator))
+        return null;
+    return navigator.mediaSession;
+}
+//# sourceMappingURL=mediasession.js.map

package/dist/mediasession.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mediasession.js","sourceRoot":"","sources":["../src/mediasession.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@flighthq/mediasession",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src/**/*.test.ts",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
+    "!dist/**/*.test.js.map",
+    "!dist/**/*.test.d.ts.map"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "test": "vitest run --config vitest.config.ts",
+    "test:watch": "vitest --watch --config vitest.config.ts",
+    "prepack": "npm run clean && npm run clean:dist && npm run build",
+    "clean:dist": "tsx ../../scripts/clean-package-dist.ts"
+  },
+  "dependencies": {
+    "@flighthq/types": "0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0"
+  },
+  "description": "OS media-session integration (now-playing metadata, playback/position state, transport-action handlers) over a swappable web/native backend wrapping navigator.mediaSession",
+  "sideEffects": false
+}

package/src/mediasession.test.ts

@@ -0,0 +1,295 @@
+import type { MediaSessionActionDetails, MediaSessionBackend } from '@flighthq/types';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  clearMediaSessionActionHandler,
+  clearMediaSessionMetadata,
+  clearMediaSessionPositionState,
+  createWebMediaSessionBackend,
+  getMediaSessionBackend,
+  setMediaSessionActionHandler,
+  setMediaSessionBackend,
+  setMediaSessionMetadata,
+  setMediaSessionPlaybackState,
+  setMediaSessionPositionState,
+} from './mediasession';
+
+interface FakeMediaSession {
+  metadata: unknown;
+  playbackState: string;
+  positionCalls: unknown[];
+  handlers: Map<string, ((details: MediaSessionActionDetails) => void) | null>;
+  setPositionState?: (state?: unknown) => void;
+  setActionHandler(action: string, handler: ((details: MediaSessionActionDetails) => void) | null): void;
+}
+
+function createFakeBackend(): MediaSessionBackend & { calls: string[]; args: unknown[][] } {
+  const calls: string[] = [];
+  const args: unknown[][] = [];
+  return {
+    calls,
+    args,
+    setMetadata(metadata) {
+      calls.push('setMetadata');
+      args.push([metadata]);
+    },
+    setPlaybackState(state) {
+      calls.push('setPlaybackState');
+      args.push([state]);
+    },
+    setPositionState(state) {
+      calls.push('setPositionState');
+      args.push([state]);
+    },
+    setActionHandler(action, handler) {
+      calls.push('setActionHandler');
+      args.push([action, handler]);
+    },
+  };
+}
+
+function installFakeMediaSession(unsupportedAction?: string): FakeMediaSession {
+  const session: FakeMediaSession = {
+    metadata: undefined,
+    playbackState: 'none',
+    positionCalls: [],
+    handlers: new Map(),
+    setPositionState(state?: unknown) {
+      this.positionCalls.push(state);
+    },
+    setActionHandler(action, handler) {
+      if (action === unsupportedAction) throw new Error('unsupported action');
+      this.handlers.set(action, handler);
+    },
+  };
+  Object.defineProperty(navigator, 'mediaSession', { value: session, configurable: true });
+  return session;
+}
+
+function removeMediaSession(): void {
+  if ('mediaSession' in navigator) {
+    Object.defineProperty(navigator, 'mediaSession', { value: undefined, configurable: true });
+    delete (navigator as { mediaSession?: unknown }).mediaSession;
+  }
+}
+
+class FakeMediaMetadata {
+  title: string;
+  artist: string;
+  album: string;
+  artwork: readonly unknown[];
+  constructor(init: { title: string; artist: string; album: string; artwork: readonly unknown[] }) {
+    this.title = init.title;
+    this.artist = init.artist;
+    this.album = init.album;
+    this.artwork = init.artwork;
+  }
+}
+
+beforeEach(() => {
+  setMediaSessionBackend(null);
+  removeMediaSession();
+  (globalThis as { MediaMetadata?: unknown }).MediaMetadata = FakeMediaMetadata;
+});
+
+afterEach(() => {
+  setMediaSessionBackend(null);
+  removeMediaSession();
+  delete (globalThis as { MediaMetadata?: unknown }).MediaMetadata;
+});
+
+describe('clearMediaSessionActionHandler', () => {
+  it('routes a null action handler through the active backend', () => {
+    const fake = createFakeBackend();
+    setMediaSessionBackend(fake);
+    clearMediaSessionActionHandler('play');
+    expect(fake.calls).toEqual(['setActionHandler']);
+    expect(fake.args[0]).toEqual(['play', null]);
+  });
+
+  it('unregisters the web handler for the action', () => {
+    const session = installFakeMediaSession();
+    setMediaSessionActionHandler('pause', () => {});
+    clearMediaSessionActionHandler('pause');
+    expect(session.handlers.get('pause')).toBeNull();
+  });
+});
+
+describe('clearMediaSessionMetadata', () => {
+  it('routes a null metadata set through the active backend', () => {
+    const fake = createFakeBackend();
+    setMediaSessionBackend(fake);
+    clearMediaSessionMetadata();
+    expect(fake.calls).toEqual(['setMetadata']);
+    expect(fake.args[0]).toEqual([null]);
+  });
+
+  it('assigns null to the web session metadata', () => {
+    const session = installFakeMediaSession();
+    setMediaSessionMetadata({ title: 'A', artist: 'B', album: 'C', artwork: [] });
+    clearMediaSessionMetadata();
+    expect(session.metadata).toBeNull();
+  });
+});
+
+describe('clearMediaSessionPositionState', () => {
+  it('routes a null position through the active backend', () => {
+    const fake = createFakeBackend();
+    setMediaSessionBackend(fake);
+    clearMediaSessionPositionState();
+    expect(fake.calls).toEqual(['setPositionState']);
+    expect(fake.args[0]).toEqual([null]);
+  });
+
+  it('clears the web position by passing undefined', () => {
+    const session = installFakeMediaSession();
+    clearMediaSessionPositionState();
+    expect(session.positionCalls).toEqual([undefined]);
+  });
+});
+
+describe('createWebMediaSessionBackend', () => {
+  it('sets metadata via a MediaMetadata instance', () => {
+    const session = installFakeMediaSession();
+    const backend = createWebMediaSessionBackend();
+    backend.setMetadata({ title: 'Song', artist: 'Artist', album: 'Album', artwork: [{ src: 'a.png' }] });
+    expect(session.metadata).toBeInstanceOf(FakeMediaMetadata);
+    expect((session.metadata as FakeMediaMetadata).title).toBe('Song');
+    expect((session.metadata as FakeMediaMetadata).artwork).toEqual([{ src: 'a.png' }]);
+  });
+
+  it('does not construct MediaMetadata when it is absent', () => {
+    const session = installFakeMediaSession();
+    delete (globalThis as { MediaMetadata?: unknown }).MediaMetadata;
+    const backend = createWebMediaSessionBackend();
+    session.metadata = 'unchanged';
+    backend.setMetadata({ title: 'Song', artist: 'Artist', album: 'Album', artwork: [] });
+    expect(session.metadata).toBe('unchanged');
+  });
+
+  it('assigns the playback state', () => {
+    const session = installFakeMediaSession();
+    const backend = createWebMediaSessionBackend();
+    backend.setPlaybackState('playing');
+    expect(session.playbackState).toBe('playing');
+  });
+
+  it('forwards the position state to setPositionState', () => {
+    const session = installFakeMediaSession();
+    const backend = createWebMediaSessionBackend();
+    backend.setPositionState({ duration: 100, playbackRate: 1, position: 10 });
+    expect(session.positionCalls).toEqual([{ duration: 100, playbackRate: 1, position: 10 }]);
+  });
+
+  it('no-ops setPositionState when the method is absent', () => {
+    const session = installFakeMediaSession();
+    delete session.setPositionState;
+    const backend = createWebMediaSessionBackend();
+    expect(() => backend.setPositionState({ duration: 1, playbackRate: 1, position: 0 })).not.toThrow();
+  });
+
+  it('registers an action handler and maps fired details to the caller', () => {
+    const session = installFakeMediaSession();
+    const backend = createWebMediaSessionBackend();
+    const handler = vi.fn();
+    backend.setActionHandler('seekto', handler);
+    const registered = session.handlers.get('seekto');
+    expect(registered).toBeTypeOf('function');
+    registered?.({ action: 'seekto', seekTime: 42, fastSeek: true });
+    expect(handler).toHaveBeenCalledWith({ action: 'seekto', seekTime: 42, fastSeek: true });
+  });
+
+  it('swallows an unsupported-action throw from setActionHandler', () => {
+    const session = installFakeMediaSession('skipad');
+    const backend = createWebMediaSessionBackend();
+    expect(() => backend.setActionHandler('skipad', () => {})).not.toThrow();
+    expect(session.handlers.has('skipad')).toBe(false);
+  });
+
+  it('is a no-op in an environment without navigator.mediaSession', () => {
+    removeMediaSession();
+    const backend = createWebMediaSessionBackend();
+    expect(() => {
+      backend.setMetadata({ title: 'A', artist: 'B', album: 'C', artwork: [] });
+      backend.setMetadata(null);
+      backend.setPlaybackState('paused');
+      backend.setPositionState({ duration: 1, playbackRate: 1, position: 0 });
+      backend.setPositionState(null);
+      backend.setActionHandler('play', () => {});
+      backend.setActionHandler('play', null);
+    }).not.toThrow();
+  });
+});
+
+describe('getMediaSessionBackend', () => {
+  it('lazily creates a web default backend when none is set', () => {
+    const backend = getMediaSessionBackend();
+    expect(backend).toBeTypeOf('object');
+    expect(backend.setMetadata).toBeTypeOf('function');
+  });
+
+  it('returns the same lazily-created backend on repeat calls', () => {
+    expect(getMediaSessionBackend()).toBe(getMediaSessionBackend());
+  });
+
+  it('returns an installed backend', () => {
+    const fake = createFakeBackend();
+    setMediaSessionBackend(fake);
+    expect(getMediaSessionBackend()).toBe(fake);
+  });
+});
+
+describe('setMediaSessionActionHandler', () => {
+  it('routes the handler through the active backend', () => {
+    const fake = createFakeBackend();
+    setMediaSessionBackend(fake);
+    const handler = () => {};
+    setMediaSessionActionHandler('nexttrack', handler);
+    expect(fake.calls).toEqual(['setActionHandler']);
+    expect(fake.args[0]).toEqual(['nexttrack', handler]);
+  });
+});
+
+describe('setMediaSessionBackend', () => {
+  it('installs a backend and null restores the lazy web default', () => {
+    const fake = createFakeBackend();
+    setMediaSessionBackend(fake);
+    expect(getMediaSessionBackend()).toBe(fake);
+    setMediaSessionBackend(null);
+    const restored = getMediaSessionBackend();
+    expect(restored).not.toBe(fake);
+    expect(restored.setMetadata).toBeTypeOf('function');
+  });
+});
+
+describe('setMediaSessionMetadata', () => {
+  it('routes the metadata through the active backend', () => {
+    const fake = createFakeBackend();
+    setMediaSessionBackend(fake);
+    const metadata = { title: 'A', artist: 'B', album: 'C', artwork: [] };
+    setMediaSessionMetadata(metadata);
+    expect(fake.calls).toEqual(['setMetadata']);
+    expect(fake.args[0]).toEqual([metadata]);
+  });
+});
+
+describe('setMediaSessionPlaybackState', () => {
+  it('routes the playback state through the active backend', () => {
+    const fake = createFakeBackend();
+    setMediaSessionBackend(fake);
+    setMediaSessionPlaybackState('playing');
+    expect(fake.calls).toEqual(['setPlaybackState']);
+    expect(fake.args[0]).toEqual(['playing']);
+  });
+});
+
+describe('setMediaSessionPositionState', () => {
+  it('routes the position state through the active backend', () => {
+    const fake = createFakeBackend();
+    setMediaSessionBackend(fake);
+    const state = { duration: 200, playbackRate: 1, position: 50 };
+    setMediaSessionPositionState(state);
+    expect(fake.calls).toEqual(['setPositionState']);
+    expect(fake.args[0]).toEqual([state]);
+  });
+});