@fishjam-cloud/composition 0.29.0-rc.1 → 0.29.0

package/dist/chunk-XAZDKX25.mjs

@@ -0,0 +1,301 @@
+// src/store.ts
+var EMPTY_SNAPSHOT = { peers: [], vad: {} };
+var assertNever = (event) => {
+  throw new Error(`Unhandled composition event: ${JSON.stringify(event)}`);
+};
+var normalizeMetadata = (raw) => {
+  if (raw == null) return {};
+  if (typeof raw === "string") {
+    try {
+      const parsed = JSON.parse(raw);
+      return parsed && typeof parsed === "object" ? parsed : {};
+    } catch {
+      return {};
+    }
+  }
+  return raw;
+};
+var splitMetadata = (raw) => {
+  const obj = normalizeMetadata(raw);
+  return { peer: obj.peer, server: obj.server };
+};
+var roleOf = (stream) => {
+  const type = stream.video?.metadata.type ?? stream.audio?.metadata.type;
+  if (type === "camera" || type === "microphone") return "camera";
+  if (type === "screenShareVideo" || type === "screenShareAudio") return "screenShare";
+  return "custom";
+};
+var CompositionStore = class {
+  peers = /* @__PURE__ */ new Map();
+  roomId;
+  vad = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  cachedSnapshot = EMPTY_SNAPSHOT;
+  cachedPeers = EMPTY_SNAPSHOT.peers;
+  subscribe = (cb) => {
+    this.listeners.add(cb);
+    return () => this.listeners.delete(cb);
+  };
+  getSnapshot = () => {
+    if (this.cachedSnapshot === null) {
+      this.cachedSnapshot = { peers: this.cachedPeers, roomId: this.roomId, vad: this.vadRecord() };
+    }
+    return this.cachedSnapshot;
+  };
+  getPeers = () => this.cachedPeers;
+  getPeer = (peerId) => this.getPeers().find((peer) => peer.id === peerId);
+  getRoomId = () => this.roomId;
+  getVadStatus = (peerId) => {
+    const peer = this.peers.get(peerId);
+    if (!peer) return "silence";
+    for (const track of peer.tracks.values())
+      if (track.type === "audio" && track.inputId && this.vad.get(track.inputId) === "speech") return "speech";
+    return "silence";
+  };
+  reset() {
+    this.peers.clear();
+    this.vad.clear();
+    this.roomId = void 0;
+    this.cachedSnapshot = null;
+    this.cachedPeers = [];
+    this.commit();
+  }
+  seedFromRoom(room) {
+    this.peers.clear();
+    this.vad.clear();
+    this.roomId = room.id;
+    for (const peer of room.peers) {
+      const internal = {
+        id: peer.id,
+        metadata: splitMetadata(peer.metadata),
+        tracks: /* @__PURE__ */ new Map()
+      };
+      for (const track of peer.tracks ?? []) {
+        if (!track.id) continue;
+        internal.tracks.set(track.id, { id: track.id, metadata: normalizeMetadata(track.metadata), type: track.type });
+      }
+      this.peers.set(peer.id, internal);
+    }
+    this.rebuildPeers();
+    this.commit();
+  }
+  applyNotification(event) {
+    if (event.data.roomId !== this.roomId) return;
+    let changed;
+    switch (event.type) {
+      case "peerConnected":
+        changed = this.onPeerConnected(event.data);
+        break;
+      case "peerDisconnected":
+        changed = this.onPeerDisconnected(event.data);
+        break;
+      case "peerMetadataUpdated":
+        changed = this.onPeerMetadataUpdated(event.data);
+        break;
+      case "trackAdded":
+        changed = this.onTrackAdded(event.data);
+        break;
+      case "trackRemoved":
+        changed = this.onTrackRemoved(event.data);
+        break;
+      case "trackMetadataUpdated":
+        changed = this.onTrackMetadataUpdated(event.data);
+        break;
+      case "trackForwarding":
+        changed = this.onTrackForwarding(event.data);
+        break;
+      case "trackForwardingRemoved":
+        changed = this.onTrackForwardingRemoved(event.data);
+        break;
+      case "vadNotification":
+        changed = this.onVadNotification(event.data);
+        break;
+      default:
+        return assertNever(event);
+    }
+    if (changed) this.commit();
+  }
+  ensurePeer(peerId) {
+    let peer = this.peers.get(peerId);
+    if (!peer) {
+      peer = { id: peerId, metadata: { peer: void 0, server: void 0 }, tracks: /* @__PURE__ */ new Map() };
+      this.peers.set(peerId, peer);
+    }
+    return peer;
+  }
+  onPeerConnected(data) {
+    if (this.peers.has(data.peerId)) return false;
+    this.ensurePeer(data.peerId);
+    this.replacePeer(data.peerId);
+    return true;
+  }
+  onPeerDisconnected(data) {
+    const peer = this.peers.get(data.peerId);
+    if (!peer) return false;
+    for (const { inputId } of peer.tracks.values()) if (inputId) this.vad.delete(inputId);
+    this.peers.delete(data.peerId);
+    this.replacePeer(data.peerId);
+    return true;
+  }
+  onPeerMetadataUpdated(data) {
+    this.ensurePeer(data.peerId).metadata = splitMetadata(data.metadata);
+    this.replacePeer(data.peerId);
+    return true;
+  }
+  onTrackAdded(data) {
+    if (!data.peerId || !data.track) return false;
+    const peer = this.ensurePeer(data.peerId);
+    peer.tracks.set(data.track.id, {
+      id: data.track.id,
+      metadata: normalizeMetadata(data.track.metadata),
+      type: data.track.type
+    });
+    this.replacePeer(data.peerId);
+    return true;
+  }
+  onTrackMetadataUpdated(data) {
+    if (!data.peerId || !data.track) return false;
+    const peer = this.peers.get(data.peerId);
+    if (!peer) return false;
+    const metadata = normalizeMetadata(data.track.metadata);
+    const inputId = peer.tracks.get(data.track.id)?.inputId;
+    peer.tracks.set(data.track.id, { id: data.track.id, metadata, type: data.track.type, inputId });
+    this.replacePeer(data.peerId);
+    return true;
+  }
+  onTrackRemoved(data) {
+    if (!data.peerId || !data.track) return false;
+    const peer = this.peers.get(data.peerId);
+    if (!peer) return false;
+    const track = peer.tracks.get(data.track.id);
+    if (!track) return false;
+    peer.tracks.delete(data.track.id);
+    if (track.type === "audio" && track.inputId) this.vad.delete(track.inputId);
+    this.replacePeer(data.peerId);
+    return true;
+  }
+  onTrackForwarding(data) {
+    const peer = this.ensurePeer(data.peerId);
+    if (data.videoTrack) {
+      peer.tracks.set(data.videoTrack.id, {
+        id: data.videoTrack.id,
+        metadata: normalizeMetadata(data.videoTrack.metadata),
+        inputId: data.inputId,
+        type: data.videoTrack.type
+      });
+    }
+    if (data.audioTrack) {
+      peer.tracks.set(data.audioTrack.id, {
+        id: data.audioTrack.id,
+        metadata: normalizeMetadata(data.audioTrack.metadata),
+        inputId: data.inputId,
+        type: data.audioTrack.type
+      });
+    }
+    this.replacePeer(data.peerId);
+    return true;
+  }
+  onTrackForwardingRemoved(data) {
+    let changed = this.vad.delete(data.inputId);
+    const peer = this.peers.get(data.peerId);
+    if (!peer) {
+      if (changed) this.cachedSnapshot = null;
+      return changed;
+    }
+    for (const track of peer.tracks.values()) {
+      if (track.inputId === data.inputId) {
+        track.inputId = void 0;
+        changed = true;
+      }
+    }
+    if (changed) this.replacePeer(data.peerId);
+    return changed;
+  }
+  onVadNotification(data) {
+    const peer = this.peers.get(data.peerId);
+    if (!peer) return false;
+    const track = peer.tracks.get(data.trackId);
+    if (!track || !track.inputId) return false;
+    if (this.vad.get(track.inputId) === data.status) return false;
+    this.vad.set(track.inputId, data.status);
+    this.cachedSnapshot = null;
+    return true;
+  }
+  commit() {
+    for (const cb of this.listeners) cb();
+  }
+  replacePeer(peerId) {
+    const internal = this.peers.get(peerId);
+    const next = this.cachedPeers.slice();
+    const idx = next.findIndex((peer) => peer.id === peerId);
+    if (!internal) {
+      if (idx >= 0) next.splice(idx, 1);
+    } else if (idx >= 0) {
+      next[idx] = this.derivePeer(internal);
+    } else {
+      next.push(this.derivePeer(internal));
+    }
+    this.cachedPeers = next;
+    this.cachedSnapshot = null;
+  }
+  rebuildPeers() {
+    this.cachedPeers = Array.from(this.peers.values(), (peer) => this.derivePeer(peer));
+    this.cachedSnapshot = null;
+  }
+  vadRecord() {
+    const vad = {};
+    for (const [inputId, status] of this.vad) vad[inputId] = status;
+    return vad;
+  }
+  derivePeer(peer) {
+    const streams = /* @__PURE__ */ new Map();
+    let cameraStream;
+    let screenShareStream;
+    const customStreams = [];
+    for (const track of peer.tracks.values()) {
+      if (!track.inputId) continue;
+      const stream = streams.get(track.inputId) || { inputId: track.inputId };
+      if (track.type === "audio")
+        stream.audio = {
+          id: track.id,
+          paused: Boolean(track.metadata.paused),
+          metadata: track.metadata,
+          type: "audio"
+        };
+      else
+        stream.video = {
+          id: track.id,
+          paused: Boolean(track.metadata.paused),
+          metadata: track.metadata,
+          type: "video"
+        };
+      streams.set(track.inputId, stream);
+    }
+    for (const stream of streams.values()) {
+      const role = roleOf(stream);
+      switch (role) {
+        case "camera":
+          cameraStream = stream;
+          break;
+        case "screenShare":
+          screenShareStream = stream;
+          break;
+        default:
+          customStreams.push(stream);
+      }
+    }
+    return {
+      id: peer.id,
+      metadata: peer.metadata,
+      streams: Array.from(streams.values()),
+      cameraStream,
+      screenShareStream,
+      customStreams
+    };
+  }
+};
+var compositionStore = new CompositionStore();
+
+export {
+  compositionStore
+};

package/dist/core.d.mts

@@ -0,0 +1,84 @@
+import { Room, PeerConnected, PeerDisconnected, PeerMetadataUpdated, TrackAdded, TrackRemoved, TrackMetadataUpdated, TrackForwarding, TrackForwardingRemoved, VadNotification, VadStatus } from '@fishjam-cloud/js-server-sdk';
+import { P as PeerWithStreams } from './types-LgEdO1AS.mjs';
+
+/**
+ * Discriminated notifier event accepted by {@link CompositionStore.applyNotification}.
+ * Each `FishjamWSNotifier` listener maps to one of these variants.
+ */
+type CompositionEvent = {
+    type: 'peerConnected';
+    data: PeerConnected;
+} | {
+    type: 'peerDisconnected';
+    data: PeerDisconnected;
+} | {
+    type: 'peerMetadataUpdated';
+    data: PeerMetadataUpdated;
+} | {
+    type: 'trackAdded';
+    data: TrackAdded;
+} | {
+    type: 'trackRemoved';
+    data: TrackRemoved;
+} | {
+    type: 'trackMetadataUpdated';
+    data: TrackMetadataUpdated;
+} | {
+    type: 'trackForwarding';
+    data: TrackForwarding;
+} | {
+    type: 'trackForwardingRemoved';
+    data: TrackForwardingRemoved;
+} | {
+    type: 'vadNotification';
+    data: VadNotification;
+};
+/**
+ * Complete snapshot of a linked room's state at a given moment.
+ */
+type RoomSnapshot = {
+    peers: PeerWithStreams[];
+    roomId?: string;
+    /** per-`inputId` voice activity, resolved per peer by `useSpeakingState`. */
+    vad: Record<string, VadStatus>;
+};
+interface CompositionStoreFeed {
+    seedFromRoom(room: Room): void;
+    applyNotification(event: CompositionEvent): void;
+    reset(): void;
+}
+declare class CompositionStore implements CompositionStoreFeed {
+    private peers;
+    private roomId;
+    private vad;
+    private listeners;
+    private cachedSnapshot;
+    private cachedPeers;
+    readonly subscribe: (cb: () => void) => (() => void);
+    readonly getSnapshot: () => RoomSnapshot;
+    readonly getPeers: () => PeerWithStreams[];
+    readonly getPeer: (peerId: string) => PeerWithStreams | undefined;
+    readonly getRoomId: () => string | undefined;
+    readonly getVadStatus: (peerId: string) => VadStatus;
+    reset(): void;
+    seedFromRoom(room: Room): void;
+    applyNotification(event: CompositionEvent): void;
+    private ensurePeer;
+    private onPeerConnected;
+    private onPeerDisconnected;
+    private onPeerMetadataUpdated;
+    private onTrackAdded;
+    private onTrackMetadataUpdated;
+    private onTrackRemoved;
+    private onTrackForwarding;
+    private onTrackForwardingRemoved;
+    private onVadNotification;
+    private commit;
+    private replacePeer;
+    private rebuildPeers;
+    private vadRecord;
+    private derivePeer;
+}
+declare const compositionStore: CompositionStore;
+
+export { type CompositionEvent, type CompositionStoreFeed, type RoomSnapshot, compositionStore };

package/dist/core.d.ts

@@ -0,0 +1,84 @@
+import { Room, PeerConnected, PeerDisconnected, PeerMetadataUpdated, TrackAdded, TrackRemoved, TrackMetadataUpdated, TrackForwarding, TrackForwardingRemoved, VadNotification, VadStatus } from '@fishjam-cloud/js-server-sdk';
+import { P as PeerWithStreams } from './types-LgEdO1AS.js';
+
+/**
+ * Discriminated notifier event accepted by {@link CompositionStore.applyNotification}.
+ * Each `FishjamWSNotifier` listener maps to one of these variants.
+ */
+type CompositionEvent = {
+    type: 'peerConnected';
+    data: PeerConnected;
+} | {
+    type: 'peerDisconnected';
+    data: PeerDisconnected;
+} | {
+    type: 'peerMetadataUpdated';
+    data: PeerMetadataUpdated;
+} | {
+    type: 'trackAdded';
+    data: TrackAdded;
+} | {
+    type: 'trackRemoved';
+    data: TrackRemoved;
+} | {
+    type: 'trackMetadataUpdated';
+    data: TrackMetadataUpdated;
+} | {
+    type: 'trackForwarding';
+    data: TrackForwarding;
+} | {
+    type: 'trackForwardingRemoved';
+    data: TrackForwardingRemoved;
+} | {
+    type: 'vadNotification';
+    data: VadNotification;
+};
+/**
+ * Complete snapshot of a linked room's state at a given moment.
+ */
+type RoomSnapshot = {
+    peers: PeerWithStreams[];
+    roomId?: string;
+    /** per-`inputId` voice activity, resolved per peer by `useSpeakingState`. */
+    vad: Record<string, VadStatus>;
+};
+interface CompositionStoreFeed {
+    seedFromRoom(room: Room): void;
+    applyNotification(event: CompositionEvent): void;
+    reset(): void;
+}
+declare class CompositionStore implements CompositionStoreFeed {
+    private peers;
+    private roomId;
+    private vad;
+    private listeners;
+    private cachedSnapshot;
+    private cachedPeers;
+    readonly subscribe: (cb: () => void) => (() => void);
+    readonly getSnapshot: () => RoomSnapshot;
+    readonly getPeers: () => PeerWithStreams[];
+    readonly getPeer: (peerId: string) => PeerWithStreams | undefined;
+    readonly getRoomId: () => string | undefined;
+    readonly getVadStatus: (peerId: string) => VadStatus;
+    reset(): void;
+    seedFromRoom(room: Room): void;
+    applyNotification(event: CompositionEvent): void;
+    private ensurePeer;
+    private onPeerConnected;
+    private onPeerDisconnected;
+    private onPeerMetadataUpdated;
+    private onTrackAdded;
+    private onTrackMetadataUpdated;
+    private onTrackRemoved;
+    private onTrackForwarding;
+    private onTrackForwardingRemoved;
+    private onVadNotification;
+    private commit;
+    private replacePeer;
+    private rebuildPeers;
+    private vadRecord;
+    private derivePeer;
+}
+declare const compositionStore: CompositionStore;
+
+export { type CompositionEvent, type CompositionStoreFeed, type RoomSnapshot, compositionStore };