lecodes-sdk 2.2.6 → 2.2.8

package/dist/types/plugins/gen/webrtc/sdk/webrtc.d.ts

@@ -0,0 +1,328 @@
+import type { Listener, NativeView } from "../../../../plugin";
+import type { AudioConstraints, AudioOutput, DataChannelInit, DataChannelState, DeviceInfo, Encoding, FacingMode, IceCandidate, IceConnectionState, IceGatheringState, IceServer, MediaKind, ObjectFit, OfferOptions, PeerConnectionState, RtcConfiguration, RtcVideoEvents, SdpType, SenderParameters, SessionDescription, SignalingState, TrackSettings, TransceiverDirection, TransceiverInit, VideoConstraints } from "../contract";
+export type { AudioConstraints, AudioOutput, DataChannelInit, DataChannelState, DeviceInfo, Encoding, FacingMode, IceCandidate, IceConnectionState, IceGatheringState, IceServer, MediaKind, ObjectFit, OfferOptions, PeerConnectionState, RtcConfiguration, RtcVideoEvents, SdpType, SenderParameters, SessionDescription, SignalingState, TrackSettings, TransceiverDirection, TransceiverInit, VideoConstraints, };
+/** A listener of one event type; it gets the event, which carries `type` and `target`. */
+export type RTCEventListener<E> = (event: E) => void;
+/** What every object of the API emits from: `addEventListener` / `removeEventListener`, and the
+ *  `on<type>` properties the subclasses declare. */
+export declare class RTCEventTarget {
+    private readonly _listeners;
+    addEventListener<E = any>(type: string, listener: RTCEventListener<E>): void;
+    removeEventListener<E = any>(type: string, listener: RTCEventListener<E>): void;
+}
+export interface RTCPeerConnectionIceEvent {
+    type: "icecandidate";
+    candidate: RTCIceCandidate | null;
+    target: RTCPeerConnection;
+}
+export interface RTCTrackEvent {
+    type: "track";
+    track: MediaStreamTrack;
+    streams: MediaStream[];
+    receiver: RTCRtpReceiver;
+    transceiver: RTCRtpTransceiver;
+    target: RTCPeerConnection;
+}
+export interface RTCDataChannelEvent {
+    type: "datachannel";
+    channel: RTCDataChannel;
+    target: RTCPeerConnection;
+}
+export interface RTCMessageEvent {
+    type: "message";
+    data: string | ArrayBuffer;
+    target: RTCDataChannel;
+}
+export interface RTCErrorEvent {
+    type: "error";
+    message: string;
+    target: RTCDataChannel;
+}
+export interface RTCEvent<T extends RTCEventTarget = RTCEventTarget> {
+    type: string;
+    target: T;
+}
+/** One track of audio or video, local (`mediaDevices.getUserMedia`) or received (`pc.ontrack`). */
+export declare class MediaStreamTrack extends RTCEventTarget {
+    readonly id: string;
+    readonly kind: MediaKind;
+    readonly label: string;
+    private _enabled;
+    private _muted;
+    private _state;
+    onended: RTCEventListener<RTCEvent<MediaStreamTrack>> | null;
+    onmute: RTCEventListener<RTCEvent<MediaStreamTrack>> | null;
+    onunmute: RTCEventListener<RTCEvent<MediaStreamTrack>> | null;
+    /** A disabled track sends silence / black frames and stays in every connection. */
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    /** A received track the other side is not sending on. */
+    get muted(): boolean;
+    get readyState(): "live" | "ended";
+    /** End the track: a local one releases its device (once no track of it is left). */
+    stop(): void;
+    /** Re-aim a local video track: the other camera (`facingMode`), another size or rate. */
+    applyConstraints(constraints?: VideoConstraints): Promise<void>;
+    /** What a local video track captures with (a promise: the host knows). */
+    getSettings(): Promise<TrackSettings>;
+    /** The same track object (a track is a handle, not a buffer). */
+    clone(): MediaStreamTrack;
+}
+/** A group of tracks: what `getUserMedia` resolves with, what a `track` event names, what
+ *  `addTrack` associates a track with. The id is a label on the wire. */
+export declare class MediaStream extends RTCEventTarget {
+    readonly id: string;
+    private readonly _tracks;
+    onaddtrack: RTCEventListener<{
+        type: "addtrack";
+        track: MediaStreamTrack;
+        target: MediaStream;
+    }> | null;
+    onremovetrack: RTCEventListener<{
+        type: "removetrack";
+        track: MediaStreamTrack;
+        target: MediaStream;
+    }> | null;
+    constructor(tracks?: MediaStreamTrack[] | MediaStream, id?: string);
+    /** Whether a track of it is live. */
+    get active(): boolean;
+    getTracks(): MediaStreamTrack[];
+    getAudioTracks(): MediaStreamTrack[];
+    getVideoTracks(): MediaStreamTrack[];
+    getTrackById(id: string): MediaStreamTrack | null;
+    addTrack(track: MediaStreamTrack): void;
+    removeTrack(track: MediaStreamTrack): void;
+    clone(): MediaStream;
+}
+/** The constraints of `getUserMedia`, the browser's: `true` for the default device, an object to say which. */
+export interface MediaStreamConstraints {
+    audio?: boolean | AudioConstraints;
+    video?: boolean | VideoConstraints;
+}
+declare class MediaDevices extends RTCEventTarget {
+    ondevicechange: RTCEventListener<RTCEvent<MediaDevices>> | null;
+    /** Whether this host registered the "rtcMedia" service — the devices. */
+    get isSupported(): boolean;
+    /** Capture: asks for the permissions it needs, resolves with a stream of the new tracks. Rejects
+     *  with "denied" / "notFound" / "failed". */
+    getUserMedia(constraints?: MediaStreamConstraints): Promise<MediaStream>;
+    /** The devices the host can capture with (their labels need a granted permission on the web). */
+    enumerateDevices(): Promise<DeviceInfo[]>;
+    /** Where the call's audio plays on a phone: the earpiece or the loudspeaker. A no-op on the web. */
+    setAudioOutput(output: AudioOutput): Promise<void>;
+}
+/** `navigator.mediaDevices` of the browser: the capture and the device list. Host-optional —
+ *  `mediaDevices.isSupported` before offering a call. */
+export declare const mediaDevices: MediaDevices;
+/** The browser's RTCSessionDescription: `{ type, sdp }`, as it is signaled. */
+export declare class RTCSessionDescription implements SessionDescription {
+    readonly type: SdpType;
+    readonly sdp: string;
+    constructor(init: SessionDescription);
+    toJSON(): SessionDescription;
+}
+/** The browser's RTCIceCandidate: what `icecandidate` carries and `addIceCandidate` takes. */
+export declare class RTCIceCandidate implements IceCandidate {
+    readonly candidate: string;
+    readonly sdpMid: string | null;
+    readonly sdpMLineIndex: number | null;
+    readonly usernameFragment: string | undefined;
+    constructor(init: RTCIceCandidateInit);
+    toJSON(): IceCandidate;
+}
+export interface RTCIceCandidateInit {
+    candidate?: string;
+    sdpMid?: string | null;
+    sdpMLineIndex?: number | null;
+    usernameFragment?: string;
+}
+/** The sending half of a transceiver: the track it sends and its encodings. */
+export declare class RTCRtpSender {
+    private readonly _pc;
+    private _track;
+    /** What it sends; null = nothing. */
+    get track(): MediaStreamTrack | null;
+    /** Swap the track without renegotiating; null = send nothing. */
+    replaceTrack(track: MediaStreamTrack | null): Promise<void>;
+    /** The encodings (a promise: the host holds them). */
+    getParameters(): Promise<SenderParameters>;
+    /** The encodings' active / bitrate / scale. */
+    setParameters(parameters: SenderParameters): Promise<void>;
+    /** The stats of this sender. */
+    getStats(): Promise<Map<string, any>>;
+}
+/** The receiving half of a transceiver: its track exists from the start, media arrives into it. */
+export declare class RTCRtpReceiver {
+    readonly track: MediaStreamTrack;
+    private readonly _pc;
+    getStats(): Promise<Map<string, any>>;
+}
+/** One m-line of the session: a sender and a receiver, a direction, a mid once negotiated. */
+export declare class RTCRtpTransceiver {
+    readonly sender: RTCRtpSender;
+    readonly receiver: RTCRtpReceiver;
+    private readonly _pc;
+    private _mid;
+    private _direction;
+    private _currentDirection;
+    private _stopped;
+    /** The m-line's id once a description named it. */
+    get mid(): string | null;
+    /** The direction wanted; setting it takes effect at the next negotiation. */
+    get direction(): TransceiverDirection;
+    set direction(value: TransceiverDirection);
+    /** The direction negotiated; null before the first answer. */
+    get currentDirection(): TransceiverDirection | null;
+    get stopped(): boolean;
+    /** Stop sending and receiving on it; the next negotiation removes the m-line. */
+    stop(): void;
+}
+/** A data channel: strings and bytes, ordered and reliable unless said otherwise. */
+export declare class RTCDataChannel extends RTCEventTarget {
+    readonly label: string;
+    readonly ordered: boolean;
+    readonly maxPacketLifeTime: number | null;
+    readonly maxRetransmits: number | null;
+    readonly protocol: string;
+    readonly negotiated: boolean;
+    /** Bytes arrive as an ArrayBuffer (the browser's "blob" is not a thing here). */
+    binaryType: "arraybuffer";
+    private readonly _pc;
+    private _streamId;
+    private _state;
+    private _threshold;
+    /** What was sent before the host made the channel. */
+    private _queue;
+    onopen: RTCEventListener<RTCEvent<RTCDataChannel>> | null;
+    onclose: RTCEventListener<RTCEvent<RTCDataChannel>> | null;
+    onerror: RTCEventListener<RTCErrorEvent> | null;
+    onmessage: RTCEventListener<RTCMessageEvent> | null;
+    onbufferedamountlow: RTCEventListener<RTCEvent<RTCDataChannel>> | null;
+    /** The SCTP stream id; null until the transport assigned one. */
+    get id(): number | null;
+    get readyState(): DataChannelState;
+    /** Bytes queued and not yet sent (a promise: the host counts them). */
+    getBufferedAmount(): Promise<number>;
+    get bufferedAmountLowThreshold(): number;
+    set bufferedAmountLowThreshold(value: number);
+    /** Send a string or bytes. Throws when the channel is closing or closed. */
+    send(data: string | ArrayBuffer | ArrayBufferView): void;
+    private _send;
+    close(): void;
+}
+/** `RTCConfiguration` of the browser, with `iceServers[].urls` as one URL or several. */
+export interface RTCConfiguration extends Omit<RtcConfiguration, "iceServers"> {
+    iceServers?: {
+        urls: string | string[];
+        username?: string;
+        credential?: string;
+    }[];
+}
+/** A connection to one peer: the browser's RTCPeerConnection. The session with the host opens on
+ *  the first call and closes with `close()`. Signaling — carrying the descriptions and the
+ *  candidates to the other side — is the app's. */
+export declare class RTCPeerConnection extends RTCEventTarget {
+    /** Whether this host registered the "rtcPeerConnection" service. */
+    static get isSupported(): boolean;
+    private _configuration;
+    private _local;
+    private _remote;
+    private _signaling;
+    private _gathering;
+    private _ice;
+    private _connection;
+    private readonly _transceivers;
+    private readonly _channels;
+    private readonly _remoteTracks;
+    /** While a local description is being set, its candidates wait: the browser delivers them
+     *  after the promise, and the app's signaling expects the description first. */
+    private _settingLocal;
+    private _heldCandidates;
+    onnegotiationneeded: RTCEventListener<RTCEvent<RTCPeerConnection>> | null;
+    onicecandidate: RTCEventListener<RTCPeerConnectionIceEvent> | null;
+    onsignalingstatechange: RTCEventListener<RTCEvent<RTCPeerConnection>> | null;
+    onicegatheringstatechange: RTCEventListener<RTCEvent<RTCPeerConnection>> | null;
+    oniceconnectionstatechange: RTCEventListener<RTCEvent<RTCPeerConnection>> | null;
+    onconnectionstatechange: RTCEventListener<RTCEvent<RTCPeerConnection>> | null;
+    ontrack: RTCEventListener<RTCTrackEvent> | null;
+    ondatachannel: RTCEventListener<RTCDataChannelEvent> | null;
+    constructor(configuration?: RTCConfiguration);
+    get localDescription(): RTCSessionDescription | null;
+    get remoteDescription(): RTCSessionDescription | null;
+    get currentLocalDescription(): RTCSessionDescription | null;
+    get currentRemoteDescription(): RTCSessionDescription | null;
+    get signalingState(): SignalingState;
+    get iceGatheringState(): IceGatheringState;
+    get iceConnectionState(): IceConnectionState;
+    get connectionState(): PeerConnectionState;
+    createOffer(options?: OfferOptions): Promise<RTCSessionDescription>;
+    createAnswer(): Promise<RTCSessionDescription>;
+    /** Without a description: the implicit form — an answer to a pending remote offer, an offer
+     *  otherwise. `localDescription` holds what is in force after. */
+    setLocalDescription(description?: SessionDescription | RTCSessionDescription | {
+        type: SdpType;
+        sdp?: string;
+    }): Promise<void>;
+    setRemoteDescription(description: SessionDescription | RTCSessionDescription | {
+        type: SdpType;
+        sdp?: string;
+    }): Promise<void>;
+    /** A candidate of the other side; none (or an empty one) = the end of its candidates. */
+    addIceCandidate(candidate?: RTCIceCandidateInit | RTCIceCandidate | null): Promise<void>;
+    /** The next offer carries new ICE credentials. */
+    restartIce(): void;
+    getConfiguration(): RTCConfiguration;
+    setConfiguration(configuration: RTCConfiguration): Promise<void>;
+    /** Send a local track, in the streams named (the browser's `addTrack(track, ...streams)`). The
+     *  sender is known once the host made it: a promise, where the browser answers at once. */
+    addTrack(track: MediaStreamTrack, ...streams: MediaStream[]): Promise<RTCRtpSender>;
+    removeTrack(sender: RTCRtpSender): Promise<void>;
+    /** Add an m-line: for a kind, or for a track to send on it. A promise, where the browser answers at once. */
+    addTransceiver(trackOrKind: MediaStreamTrack | MediaKind, init?: Omit<TransceiverInit, "trackId" | "streamIds"> & {
+        streams?: MediaStream[];
+    }): Promise<RTCRtpTransceiver>;
+    /** The transceivers as last synced (after every description, on every `track` event). */
+    getTransceivers(): RTCRtpTransceiver[];
+    getSenders(): RTCRtpSender[];
+    getReceivers(): RTCRtpReceiver[];
+    /** The RTCStatsReport: a Map of the stats id → the stats object (`type`, `timestamp` in ms, the
+     *  fields of its type), for the whole connection or one track's senders / receivers. */
+    getStats(selector?: MediaStreamTrack | null): Promise<Map<string, any>>;
+    /** Open a data channel. The channel is "connecting" until the host and the other side are ready;
+     *  what is sent before counts as queued. */
+    createDataChannel(label: string, init?: DataChannelInit): RTCDataChannel;
+    /** Close the connection: the session with the host ends, every received track ends, every
+     *  channel closes. */
+    close(): void;
+    private _transceiverOf;
+    private _syncTransceivers;
+    private _onTrack;
+}
+export interface RTCVideoViewOptions {
+    /** The track to draw; none = black. */
+    track?: MediaStreamTrack | null;
+    /** Default "cover". */
+    objectFit?: ObjectFit;
+    /** Flip horizontally — the front camera's preview. Default false. */
+    mirror?: boolean;
+}
+/** A tree node that draws one video track: embed it among a screen's children (sized by its
+ *  styles) or present it fullscreen (`open()`). `track` may change at any time. */
+export interface RTCVideoView extends NativeView {
+    /** The track drawn; null = black. */
+    track: MediaStreamTrack | null;
+    objectFit: ObjectFit;
+    mirror: boolean;
+    /** `resize`: the first frame, and every change of the picture's size. */
+    on<K extends keyof RtcVideoEvents & string>(event: K, callback: Listener<RtcVideoEvents, K>): this;
+    off<K extends keyof RtcVideoEvents & string>(event: K, callback: Listener<RtcVideoEvents, K>): this;
+}
+/**
+ * Create a video view. `RTCVideoView.isSupported` reports whether this host has the capability —
+ * check it before offering the feature (a view no host registered mounts nothing).
+ */
+export declare const RTCVideoView: {
+    (options?: RTCVideoViewOptions): RTCVideoView;
+    /** Whether this host registered an "rtcVideo" view. */
+    readonly isSupported: boolean;
+};

package/dist/types/version.d.ts

@@ -1,4 +1,4 @@
-export declare const SDK_VERSION = "2.2.6";
+export declare const SDK_VERSION = "2.2.8";
 /** The major of a semver string, or null when it is not one. */
 export declare const sdkMajor: (version: string | null | undefined) => number | null;
 /** The `// sdk: <version>` line of a compiled bundle's header (sdk/src/compile/header.ts), read from