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

package/dist/core.js

@@ -0,0 +1,327 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core.ts
+var core_exports = {};
+__export(core_exports, {
+  compositionStore: () => compositionStore
+});
+module.exports = __toCommonJS(core_exports);
+
+// 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();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compositionStore
+});

package/dist/core.mjs

@@ -0,0 +1,6 @@
+import {
+  compositionStore
+} from "./chunk-XAZDKX25.mjs";
+export {
+  compositionStore
+};

package/dist/index.d.mts

@@ -1,6 +1,35 @@
+import { P as PeerWithStreams } from './types-LgEdO1AS.mjs';
+export { A as AudioTrackState, S as Stream, T as TrackState, V as VideoTrackState } from './types-LgEdO1AS.mjs';
+import { VadStatus } from '@fishjam-cloud/js-server-sdk';
+export { VadStatus } from '@fishjam-cloud/js-server-sdk';
+
+/**
+ * All peers in the linked room, projected into composition streams. Flat list —
+ * the worker is not a peer, so there is no local/remote split.
+ */
+declare function usePeers<PeerMetadata = unknown, ServerMetadata = unknown>(): PeerWithStreams<PeerMetadata, ServerMetadata>[];
+/**
+ * The peer with the given `peerId`, or `undefined`.
+ */
+declare function usePeer<PeerMetadata = unknown, ServerMetadata = unknown>(peerId: string): PeerWithStreams<PeerMetadata, ServerMetadata> | undefined;
+/**
+ * The linked room's id, or `undefined` when no room is linked.
+ */
+declare function useRoom(): {
+    id: string;
+} | undefined;
+/**
+ * Voice-activity status for the peer identified by `peerId`: `'speech'` when any
+ * of the peer's forwarded audio inputs is speaking, otherwise `'silence'`.
+ */
+declare function useSpeakingState(peerId: string): VadStatus;
+
 interface CompositionEventBus {
     on<T = unknown>(eventName: string, callback: (data: T) => void): () => void;
 }
+declare global {
+    var eventBus: CompositionEventBus;
+}
 declare const eventBus: CompositionEventBus;
 
-export { type CompositionEventBus, eventBus };
+export { type CompositionEventBus, PeerWithStreams, eventBus, usePeer, usePeers, useRoom, useSpeakingState };

package/dist/index.d.ts

@@ -1,6 +1,35 @@
+import { P as PeerWithStreams } from './types-LgEdO1AS.js';
+export { A as AudioTrackState, S as Stream, T as TrackState, V as VideoTrackState } from './types-LgEdO1AS.js';
+import { VadStatus } from '@fishjam-cloud/js-server-sdk';
+export { VadStatus } from '@fishjam-cloud/js-server-sdk';
+
+/**
+ * All peers in the linked room, projected into composition streams. Flat list —
+ * the worker is not a peer, so there is no local/remote split.
+ */
+declare function usePeers<PeerMetadata = unknown, ServerMetadata = unknown>(): PeerWithStreams<PeerMetadata, ServerMetadata>[];
+/**
+ * The peer with the given `peerId`, or `undefined`.
+ */
+declare function usePeer<PeerMetadata = unknown, ServerMetadata = unknown>(peerId: string): PeerWithStreams<PeerMetadata, ServerMetadata> | undefined;
+/**
+ * The linked room's id, or `undefined` when no room is linked.
+ */
+declare function useRoom(): {
+    id: string;
+} | undefined;
+/**
+ * Voice-activity status for the peer identified by `peerId`: `'speech'` when any
+ * of the peer's forwarded audio inputs is speaking, otherwise `'silence'`.
+ */
+declare function useSpeakingState(peerId: string): VadStatus;
+
 interface CompositionEventBus {
     on<T = unknown>(eventName: string, callback: (data: T) => void): () => void;
 }
+declare global {
+    var eventBus: CompositionEventBus;
+}
 declare const eventBus: CompositionEventBus;
 
-export { type CompositionEventBus, eventBus };
+export { type CompositionEventBus, PeerWithStreams, eventBus, usePeer, usePeers, useRoom, useSpeakingState };