vue-parley 4.0.0

package/dist/types/app/composables/call/media.d.ts

@@ -0,0 +1,204 @@
+import { TrackTypes } from './signaling';
+export interface MediaOptions {
+    /** Shows an error; `key` is a `chat.call.errors.*` translation key. */
+    notify: (key: string) => void;
+    isMobile: () => boolean;
+}
+/** This participant's camera, microphone and screen share. */
+export declare function useCallMedia({ notify, isMobile }: MediaOptions): {
+    localStream: globalThis.Ref<{
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+        onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+        addTrack: (track: MediaStreamTrack) => void;
+        clone: () => MediaStream;
+        getAudioTracks: () => MediaStreamTrack[];
+        getTrackById: (trackId: string) => MediaStreamTrack | null;
+        getTracks: () => MediaStreamTrack[];
+        getVideoTracks: () => MediaStreamTrack[];
+        removeTrack: (track: MediaStreamTrack) => void;
+        addEventListener: {
+            <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        };
+        removeEventListener: {
+            <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        };
+        dispatchEvent: (event: Event) => boolean;
+    } | null, MediaStream | {
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+        onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+        addTrack: (track: MediaStreamTrack) => void;
+        clone: () => MediaStream;
+        getAudioTracks: () => MediaStreamTrack[];
+        getTrackById: (trackId: string) => MediaStreamTrack | null;
+        getTracks: () => MediaStreamTrack[];
+        getVideoTracks: () => MediaStreamTrack[];
+        removeTrack: (track: MediaStreamTrack) => void;
+        addEventListener: {
+            <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        };
+        removeEventListener: {
+            <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        };
+        dispatchEvent: (event: Event) => boolean;
+    } | null>;
+    screenStream: globalThis.Ref<{
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+        onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+        addTrack: (track: MediaStreamTrack) => void;
+        clone: () => MediaStream;
+        getAudioTracks: () => MediaStreamTrack[];
+        getTrackById: (trackId: string) => MediaStreamTrack | null;
+        getTracks: () => MediaStreamTrack[];
+        getVideoTracks: () => MediaStreamTrack[];
+        removeTrack: (track: MediaStreamTrack) => void;
+        addEventListener: {
+            <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        };
+        removeEventListener: {
+            <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        };
+        dispatchEvent: (event: Event) => boolean;
+    } | null, MediaStream | {
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+        onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+        addTrack: (track: MediaStreamTrack) => void;
+        clone: () => MediaStream;
+        getAudioTracks: () => MediaStreamTrack[];
+        getTrackById: (trackId: string) => MediaStreamTrack | null;
+        getTracks: () => MediaStreamTrack[];
+        getVideoTracks: () => MediaStreamTrack[];
+        removeTrack: (track: MediaStreamTrack) => void;
+        addEventListener: {
+            <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        };
+        removeEventListener: {
+            <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        };
+        dispatchEvent: (event: Event) => boolean;
+    } | null>;
+    trackTypes: globalThis.Ref<{
+        id: string;
+        type: import('../..').TrackType;
+    }[], TrackTypes | {
+        id: string;
+        type: import('../..').TrackType;
+    }[]>;
+    videoTrack: globalThis.Ref<{
+        contentHint: string;
+        enabled: boolean;
+        readonly id: string;
+        readonly kind: string;
+        readonly label: string;
+        readonly muted: boolean;
+        onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
+        onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+        onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+        readonly readyState: MediaStreamTrackState;
+        applyConstraints: (constraints?: MediaTrackConstraints) => Promise<void>;
+        clone: () => MediaStreamTrack;
+        getCapabilities: () => MediaTrackCapabilities;
+        getConstraints: () => MediaTrackConstraints;
+        getSettings: () => MediaTrackSettings;
+        stop: () => void;
+        addEventListener: {
+            <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        };
+        removeEventListener: {
+            <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        };
+        dispatchEvent: (event: Event) => boolean;
+    } | null, MediaStreamTrack | {
+        contentHint: string;
+        enabled: boolean;
+        readonly id: string;
+        readonly kind: string;
+        readonly label: string;
+        readonly muted: boolean;
+        onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
+        onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+        onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+        readonly readyState: MediaStreamTrackState;
+        applyConstraints: (constraints?: MediaTrackConstraints) => Promise<void>;
+        clone: () => MediaStreamTrack;
+        getCapabilities: () => MediaTrackCapabilities;
+        getConstraints: () => MediaTrackConstraints;
+        getSettings: () => MediaTrackSettings;
+        stop: () => void;
+        addEventListener: {
+            <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        };
+        removeEventListener: {
+            <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        };
+        dispatchEvent: (event: Event) => boolean;
+    } | null>;
+    cameras: globalThis.Ref<{
+        readonly deviceId: string;
+        readonly groupId: string;
+        readonly kind: MediaDeviceKind;
+        readonly label: string;
+        toJSON: () => any;
+    }[], MediaDeviceInfo[] | {
+        readonly deviceId: string;
+        readonly groupId: string;
+        readonly kind: MediaDeviceKind;
+        readonly label: string;
+        toJSON: () => any;
+    }[]>;
+    isAudioOn: globalThis.Ref<boolean, boolean>;
+    isVideoOn: globalThis.Ref<boolean, boolean>;
+    isScreenSharing: globalThis.Ref<boolean, boolean>;
+    isFlashlightOn: globalThis.Ref<boolean, boolean>;
+    isFlashlightSupported: globalThis.ComputedRef<boolean>;
+    checkPermissions: () => Promise<void>;
+    start: () => Promise<void>;
+    toggleAudio: () => void;
+    toggleVideo: () => void;
+    switchCamera: (deviceId: string) => Promise<MediaStreamTrack | null>;
+    startScreenShare: (onEnded: () => void) => Promise<MediaStream | null>;
+    stopScreenShare: () => {
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+        onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+        addTrack: (track: MediaStreamTrack) => void;
+        clone: () => MediaStream;
+        getAudioTracks: () => MediaStreamTrack[];
+        getTrackById: (trackId: string) => MediaStreamTrack | null;
+        getTracks: () => MediaStreamTrack[];
+        getVideoTracks: () => MediaStreamTrack[];
+        removeTrack: (track: MediaStreamTrack) => void;
+        addEventListener: {
+            <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        };
+        removeEventListener: {
+            <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        };
+        dispatchEvent: (event: Event) => boolean;
+    } | null;
+    toggleFlashlight: () => Promise<void>;
+    stopAll: () => void;
+};
+//# sourceMappingURL=media.d.ts.map

package/dist/types/app/composables/call/media.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"media.d.ts","sourceRoot":"","sources":["../../../../../app/composables/call/media.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,MAAM,WAAW,YAAY;IAC3B,uEAAuE;IACvE,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9B,QAAQ,EAAE,MAAM,OAAO,CAAC;CACzB;AAgBD,8DAA8D;AAC9D,wBAAgB,YAAY,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA4GvB,MAAM;gCAwBH,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;EAyGpD"}

package/dist/types/app/composables/call/peer.d.ts

@@ -0,0 +1,39 @@
+import { SignalData } from '../../types';
+export interface PeerEvents {
+    /** A message for the other side, to send over signalling. */
+    onSignal(signal: SignalData): void;
+    /** A new remote stream (once per stream, with its tracks already added). */
+    onStream(stream: MediaStream): void;
+    /** The connection is gone, from either side. Fires once. */
+    onClose(): void;
+    onError(error: Error): void;
+}
+export interface PeerOptions extends PeerEvents {
+    /** Whether this side makes the offers. Exactly one side of a pair must be the initiator. */
+    initiator: boolean;
+    stream: MediaStream;
+    config: RTCConfiguration;
+}
+/**
+ * One WebRTC connection to one remote participant, on the plain browser API.
+ *
+ * It speaks simple-peer's wire protocol (with `trickle: false`), so it interoperates with clients
+ * still running the previous, simple-peer based build:
+ * - full offers/answers with the ICE candidates inside the SDP;
+ * - only the initiator makes offers; the other side asks with `{ type: "renegotiate" }` and, for
+ *   tracks the offer had no room for, `{ type: "transceiverRequest" }`, so offers never collide;
+ * - a data channel whose closing tells either side that the other one left.
+ */
+export declare function createPeer(opts: PeerOptions): {
+    /** Applies a message from the other side. */
+    signal(data: SignalData): void;
+    addTrack(track: MediaStreamTrack, stream: MediaStream): void;
+    removeTrack(track: MediaStreamTrack): void;
+    /** Swaps the outgoing video track in place (no renegotiation), or adds it if none is sent. */
+    replaceVideoTrack(track: MediaStreamTrack, stream: MediaStream): void;
+    /** Whether we currently send this track. */
+    isSending(track: MediaStreamTrack): boolean;
+    destroy: () => void;
+};
+export type PeerConnection = ReturnType<typeof createPeer>;
+//# sourceMappingURL=peer.d.ts.map

package/dist/types/app/composables/call/peer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"peer.d.ts","sourceRoot":"","sources":["../../../../../app/composables/call/peer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAK1C,MAAM,WAAW,UAAU;IACzB,6DAA6D;IAC7D,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC;IACnC,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,WAAW,GAAG,IAAI,CAAC;IACpC,4DAA4D;IAC5D,OAAO,IAAI,IAAI,CAAC;IAChB,OAAO,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CAC7B;AAED,MAAM,WAAW,WAAY,SAAQ,UAAU;IAC7C,4FAA4F;IAC5F,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,WAAW,CAAC;IACpB,MAAM,EAAE,gBAAgB,CAAC;CAC1B;AAUD;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,WAAW;IAqJxC,6CAA6C;iBAChC,UAAU;oBAwBP,gBAAgB,UAAU,WAAW;uBAMlC,gBAAgB;IAQnC,8FAA8F;6BACrE,gBAAgB,UAAU,WAAW;IAO9D,4CAA4C;qBAC3B,gBAAgB;;EAMpC;AAED,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC"}

package/dist/types/app/composables/call/peers.d.ts

@@ -0,0 +1,54 @@
+import { Ref } from 'vue';
+import { SignalData } from '../../types';
+import { Signaling, TrackTypes } from './signaling';
+export interface RemoteStream {
+    name: string;
+    stream: MediaStream;
+}
+export interface PeerOptions {
+    selfId: string;
+    signaling: Signaling;
+    localStream: Ref<MediaStream | null>;
+    screenStream: Ref<MediaStream | null>;
+    /** ICE servers and policy for each new connection, or null when none are usable yet. */
+    rtcConfig: () => RTCConfiguration | null;
+    log: (...args: unknown[]) => void;
+}
+/**
+ * One connection per remote participant, plus the streams they send us.
+ *
+ * Who makes the offer is decided by comparing ids, so both sides agree without a round trip.
+ * A peer can't be created before our own media exists; such requests wait until it does.
+ */
+export declare function usePeers(opts: PeerOptions): {
+    peers: Ref<Record<string, {
+        signal(data: SignalData): void;
+        addTrack(track: MediaStreamTrack, stream: MediaStream): void;
+        removeTrack(track: MediaStreamTrack): void;
+        replaceVideoTrack(track: MediaStreamTrack, stream: MediaStream): void;
+        isSending(track: MediaStreamTrack): boolean;
+        destroy: () => void;
+    }>, Record<string, {
+        signal(data: SignalData): void;
+        addTrack(track: MediaStreamTrack, stream: MediaStream): void;
+        removeTrack(track: MediaStreamTrack): void;
+        replaceVideoTrack(track: MediaStreamTrack, stream: MediaStream): void;
+        isSending(track: MediaStreamTrack): boolean;
+        destroy: () => void;
+    }>>;
+    remoteVideos: Ref<Record<string, RemoteStream>, Record<string, RemoteStream>>;
+    remoteScreens: Ref<Record<string, RemoteStream>, Record<string, RemoteStream>>;
+    remoteStreamTypes: Ref<Record<string, TrackTypes>, Record<string, TrackTypes>>;
+    isInitiator: (remoteId: string) => boolean;
+    has: (remoteId: string) => boolean;
+    add: (remoteId: string, name: string) => void;
+    remove: (remoteId: string) => void;
+    signal: (remoteId: string, name: string, data: SignalData & {
+        sdp: string;
+    }) => void;
+    addTrackToAll: (track: MediaStreamTrack, stream: MediaStream) => void;
+    removeTrackFromAll: (track: MediaStreamTrack) => void;
+    replaceVideoTrack: (track: MediaStreamTrack, stream: MediaStream) => void;
+    destroyAll: () => void;
+};
+//# sourceMappingURL=peers.d.ts.map

package/dist/types/app/composables/call/peers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"peers.d.ts","sourceRoot":"","sources":["../../../../../app/composables/call/peers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,GAAG,EAAE,MAAM,KAAK,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAEzD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,WAAW,CAAC;CACrB;AAED,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,SAAS,CAAC;IACrB,WAAW,EAAE,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;IACrC,YAAY,EAAE,GAAG,CAAC,WAAW,GAAG,IAAI,CAAC,CAAC;IACtC,wFAAwF;IACxF,SAAS,EAAE,MAAM,gBAAgB,GAAG,IAAI,CAAC;IACzC,GAAG,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,CAAC;CACnC;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,WAAW;;;;;;;;;;;;;;;;;;;4BAcT,MAAM;oBACd,MAAM;oBAqCN,MAAM,QAAQ,MAAM;uBAnCjB,MAAM;uBAyFN,MAAM,QAAQ,MAAM,QAAQ,UAAU,GAAG;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE;2BAepD,gBAAgB,UAAU,WAAW;gCAIhC,gBAAgB;+BAKjB,gBAAgB,UAAU,WAAW;;EAqCxE"}

package/dist/types/app/composables/call/session.d.ts

@@ -0,0 +1,284 @@
+import { CallHandlers } from '../../types';
+export interface CallSessionOptions {
+    handlers: CallHandlers;
+    channel: string;
+    self: {
+        id: string;
+        name: () => string;
+        avatar: () => Blob | undefined;
+    };
+    /** Shows an error; `key` is a translation key. */
+    notify: (key: string) => void;
+}
+/**
+ * One call, from joining to hanging up: signalling, peer connections and local media. It lives in
+ * the call store, not in a component, so the call carries on while no call view is mounted.
+ */
+export declare function createCallSession(opts: CallSessionOptions): {
+    channel: string;
+    start: () => Promise<void>;
+    end: () => void;
+    toggleScreenShare: () => Promise<void>;
+    switchCamera: (deviceId: string) => Promise<{
+        readonly active: boolean;
+        readonly id: string;
+        onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+        onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+        addTrack: (track: MediaStreamTrack) => void;
+        clone: () => MediaStream;
+        getAudioTracks: () => MediaStreamTrack[];
+        getTrackById: (trackId: string) => MediaStreamTrack | null;
+        getTracks: () => MediaStreamTrack[];
+        getVideoTracks: () => MediaStreamTrack[];
+        removeTrack: (track: MediaStreamTrack) => void;
+        addEventListener: {
+            <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+        };
+        removeEventListener: {
+            <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+            (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+        };
+        dispatchEvent: (event: Event) => boolean;
+    } | null>;
+    signaling: {
+        listen: (on: import('./signaling').SignalingHandlers) => Promise<void>;
+        stop: () => void;
+        join: () => Promise<void>;
+        trackTypes: (types: import('./signaling').TrackTypes) => Promise<void>;
+        signal: (to: string, signal: import('../../types').SignalData) => Promise<void>;
+        ring: (channel: string, avatar?: string) => Promise<void>;
+        hangup: (channel: string) => Promise<void>;
+    };
+    media: {
+        localStream: globalThis.Ref<{
+            readonly active: boolean;
+            readonly id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            };
+            removeEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | null, MediaStream | {
+            readonly active: boolean;
+            readonly id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            };
+            removeEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | null>;
+        screenStream: globalThis.Ref<{
+            readonly active: boolean;
+            readonly id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            };
+            removeEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | null, MediaStream | {
+            readonly active: boolean;
+            readonly id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            };
+            removeEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | null>;
+        trackTypes: globalThis.Ref<{
+            id: string;
+            type: import('../../types').TrackType;
+        }[], import('./signaling').TrackTypes | {
+            id: string;
+            type: import('../../types').TrackType;
+        }[]>;
+        videoTrack: globalThis.Ref<{
+            contentHint: string;
+            enabled: boolean;
+            readonly id: string;
+            readonly kind: string;
+            readonly label: string;
+            readonly muted: boolean;
+            onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
+            onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+            onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+            readonly readyState: MediaStreamTrackState;
+            applyConstraints: (constraints?: MediaTrackConstraints) => Promise<void>;
+            clone: () => MediaStreamTrack;
+            getCapabilities: () => MediaTrackCapabilities;
+            getConstraints: () => MediaTrackConstraints;
+            getSettings: () => MediaTrackSettings;
+            stop: () => void;
+            addEventListener: {
+                <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            };
+            removeEventListener: {
+                <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | null, MediaStreamTrack | {
+            contentHint: string;
+            enabled: boolean;
+            readonly id: string;
+            readonly kind: string;
+            readonly label: string;
+            readonly muted: boolean;
+            onended: ((this: MediaStreamTrack, ev: Event) => any) | null;
+            onmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+            onunmute: ((this: MediaStreamTrack, ev: Event) => any) | null;
+            readonly readyState: MediaStreamTrackState;
+            applyConstraints: (constraints?: MediaTrackConstraints) => Promise<void>;
+            clone: () => MediaStreamTrack;
+            getCapabilities: () => MediaTrackCapabilities;
+            getConstraints: () => MediaTrackConstraints;
+            getSettings: () => MediaTrackSettings;
+            stop: () => void;
+            addEventListener: {
+                <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            };
+            removeEventListener: {
+                <K extends keyof MediaStreamTrackEventMap>(type: K, listener: (this: MediaStreamTrack, ev: MediaStreamTrackEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | null>;
+        cameras: globalThis.Ref<{
+            readonly deviceId: string;
+            readonly groupId: string;
+            readonly kind: MediaDeviceKind;
+            readonly label: string;
+            toJSON: () => any;
+        }[], MediaDeviceInfo[] | {
+            readonly deviceId: string;
+            readonly groupId: string;
+            readonly kind: MediaDeviceKind;
+            readonly label: string;
+            toJSON: () => any;
+        }[]>;
+        isAudioOn: globalThis.Ref<boolean, boolean>;
+        isVideoOn: globalThis.Ref<boolean, boolean>;
+        isScreenSharing: globalThis.Ref<boolean, boolean>;
+        isFlashlightOn: globalThis.Ref<boolean, boolean>;
+        isFlashlightSupported: globalThis.ComputedRef<boolean>;
+        checkPermissions: () => Promise<void>;
+        start: () => Promise<void>;
+        toggleAudio: () => void;
+        toggleVideo: () => void;
+        switchCamera: (deviceId: string) => Promise<MediaStreamTrack | null>;
+        startScreenShare: (onEnded: () => void) => Promise<MediaStream | null>;
+        stopScreenShare: () => {
+            readonly active: boolean;
+            readonly id: string;
+            onaddtrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            onremovetrack: ((this: MediaStream, ev: MediaStreamTrackEvent) => any) | null;
+            addTrack: (track: MediaStreamTrack) => void;
+            clone: () => MediaStream;
+            getAudioTracks: () => MediaStreamTrack[];
+            getTrackById: (trackId: string) => MediaStreamTrack | null;
+            getTracks: () => MediaStreamTrack[];
+            getVideoTracks: () => MediaStreamTrack[];
+            removeTrack: (track: MediaStreamTrack) => void;
+            addEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            };
+            removeEventListener: {
+                <K extends keyof MediaStreamEventMap>(type: K, listener: (this: MediaStream, ev: MediaStreamEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            };
+            dispatchEvent: (event: Event) => boolean;
+        } | null;
+        toggleFlashlight: () => Promise<void>;
+        stopAll: () => void;
+    };
+    peers: {
+        peers: globalThis.Ref<Record<string, {
+            signal(data: import('../../types').SignalData): void;
+            addTrack(track: MediaStreamTrack, stream: MediaStream): void;
+            removeTrack(track: MediaStreamTrack): void;
+            replaceVideoTrack(track: MediaStreamTrack, stream: MediaStream): void;
+            isSending(track: MediaStreamTrack): boolean;
+            destroy: () => void;
+        }>, Record<string, {
+            signal(data: import('../../types').SignalData): void;
+            addTrack(track: MediaStreamTrack, stream: MediaStream): void;
+            removeTrack(track: MediaStreamTrack): void;
+            replaceVideoTrack(track: MediaStreamTrack, stream: MediaStream): void;
+            isSending(track: MediaStreamTrack): boolean;
+            destroy: () => void;
+        }>>;
+        remoteVideos: globalThis.Ref<Record<string, import('./peers').RemoteStream>, Record<string, import('./peers').RemoteStream>>;
+        remoteScreens: globalThis.Ref<Record<string, import('./peers').RemoteStream>, Record<string, import('./peers').RemoteStream>>;
+        remoteStreamTypes: globalThis.Ref<Record<string, import('./signaling').TrackTypes>, Record<string, import('./signaling').TrackTypes>>;
+        isInitiator: (remoteId: string) => boolean;
+        has: (remoteId: string) => boolean;
+        add: (remoteId: string, name: string) => void;
+        remove: (remoteId: string) => void;
+        signal: (remoteId: string, name: string, data: import('../../types').SignalData & {
+            sdp: string;
+        }) => void;
+        addTrackToAll: (track: MediaStreamTrack, stream: MediaStream) => void;
+        removeTrackFromAll: (track: MediaStreamTrack) => void;
+        replaceVideoTrack: (track: MediaStreamTrack, stream: MediaStream) => void;
+        destroyAll: () => void;
+    };
+    participantCount: globalThis.ComputedRef<number>;
+    tileCount: globalThis.ComputedRef<number>;
+};
+export type CallSession = ReturnType<typeof createCallSession>;
+//# sourceMappingURL=session.d.ts.map

package/dist/types/app/composables/call/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../../../app/composables/call/session.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAK5C,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,YAAY,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,IAAI,GAAG,SAAS,CAAA;KAAE,CAAC;IACzE,kDAAkD;IAClD,MAAM,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CAC/B;AASD;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,kBAAkB;;;;;6BA0GlB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0B7C;AAED,MAAM,MAAM,WAAW,GAAG,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/types/app/composables/call/signaling.d.ts

@@ -0,0 +1,36 @@
+import { CallHandlers, SignalData, TrackType } from '../../types';
+export type TrackTypes = {
+    id: string;
+    type: TrackType;
+}[];
+export interface SignalingHandlers {
+    /** An SDP offer/answer or ICE candidate addressed to us. */
+    onSignal(from: string, name: string, signal: SignalData & {
+        sdp: string;
+    }): void;
+    /** Someone entered the call. */
+    onJoin(from: string, name: string): void;
+    /** Someone described which of their streams are camera, screen, … */
+    onTrackTypes(from: string, types: TrackTypes): void;
+    /** Someone left the call. */
+    onHangup(from: string): void;
+}
+/**
+ * The call's messages over the host's pub/sub (`CallHandlers`), typed. Knows nothing about
+ * WebRTC: it only turns calls into messages and messages into callbacks.
+ */
+export declare function createSignaling(handlers: Pick<CallHandlers, "publisher" | "subscriber" | "unSubscriber">, self: {
+    id: string;
+    name: () => string;
+}): {
+    listen: (on: SignalingHandlers) => Promise<void>;
+    stop: () => void;
+    join: () => Promise<void>;
+    trackTypes: (types: TrackTypes) => Promise<void>;
+    signal: (to: string, signal: SignalData) => Promise<void>;
+    /** Rings the other side of `channel`. */
+    ring: (channel: string, avatar?: string) => Promise<void>;
+    hangup: (channel: string) => Promise<void>;
+};
+export type Signaling = ReturnType<typeof createSignaling>;
+//# sourceMappingURL=signaling.d.ts.map

package/dist/types/app/composables/call/signaling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signaling.d.ts","sourceRoot":"","sources":["../../../../../app/composables/call/signaling.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EAEZ,UAAU,EACV,SAAS,EACV,MAAM,SAAS,CAAC;AAGjB,MAAM,MAAM,UAAU,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,SAAS,CAAA;CAAE,EAAE,CAAC;AAE3D,MAAM,WAAW,iBAAiB;IAChC,4DAA4D;IAC5D,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,GAAG;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACjF,gCAAgC;IAChC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACzC,qEAAqE;IACrE,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;IACpD,6BAA6B;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC9B;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,IAAI,CAAC,YAAY,EAAE,WAAW,GAAG,YAAY,GAAG,cAAc,CAAC,EACzE,IAAI,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,MAAM,CAAA;CAAE;iBAOd,iBAAiB;;;wBAoCrB,UAAU;iBAKjB,MAAM,UAAU,UAAU;IAUvC,yCAAyC;oBACzB,MAAM,WAAW,MAAM;sBAKrB,MAAM;EAM3B;AAED,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC"}