@gjsify/webrtc 0.1.15

package/lib/esm/media-stream.js

@@ -0,0 +1,78 @@
+import "@gjsify/dom-events/register/event-target";
+import GLib from "gi://GLib?version=2.0";
+class MediaStream extends EventTarget {
+  id;
+  _tracks = /* @__PURE__ */ new Map();
+  _onaddtrack = null;
+  _onremovetrack = null;
+  constructor(streamOrTracks) {
+    super();
+    this.id = GLib.uuid_string_random();
+    if (streamOrTracks instanceof MediaStream) {
+      for (const track of streamOrTracks.getTracks()) {
+        this._tracks.set(track.id, track.clone());
+      }
+    } else if (Array.isArray(streamOrTracks)) {
+      for (const track of streamOrTracks) {
+        this._tracks.set(track.id, track);
+      }
+    }
+  }
+  get active() {
+    for (const track of this._tracks.values()) {
+      if (track.readyState === "live") return true;
+    }
+    return false;
+  }
+  get onaddtrack() {
+    return this._onaddtrack;
+  }
+  set onaddtrack(v) {
+    this._onaddtrack = v;
+  }
+  get onremovetrack() {
+    return this._onremovetrack;
+  }
+  set onremovetrack(v) {
+    this._onremovetrack = v;
+  }
+  getTracks() {
+    return [...this._tracks.values()];
+  }
+  getAudioTracks() {
+    return this.getTracks().filter((t) => t.kind === "audio");
+  }
+  getVideoTracks() {
+    return this.getTracks().filter((t) => t.kind === "video");
+  }
+  getTrackById(id) {
+    return this._tracks.get(id) ?? null;
+  }
+  addTrack(track) {
+    if (this._tracks.has(track.id)) return;
+    this._tracks.set(track.id, track);
+    const ev = new MediaStreamTrackEvent("addtrack", { track });
+    this._onaddtrack?.call(this, ev);
+    this.dispatchEvent(ev);
+  }
+  removeTrack(track) {
+    if (!this._tracks.delete(track.id)) return;
+    const ev = new MediaStreamTrackEvent("removetrack", { track });
+    this._onremovetrack?.call(this, ev);
+    this.dispatchEvent(ev);
+  }
+  clone() {
+    return new MediaStream(this);
+  }
+}
+class MediaStreamTrackEvent extends Event {
+  track;
+  constructor(type, init) {
+    super(type, init);
+    this.track = init.track;
+  }
+}
+export {
+  MediaStream,
+  MediaStreamTrackEvent
+};

package/lib/esm/register/data-channel.js

@@ -0,0 +1,8 @@
+import { RTCDataChannel } from "../rtc-data-channel.js";
+import { RTCDataChannelEvent } from "../rtc-events.js";
+if (typeof globalThis.RTCDataChannel === "undefined") {
+  globalThis.RTCDataChannel = RTCDataChannel;
+}
+if (typeof globalThis.RTCDataChannelEvent === "undefined") {
+  globalThis.RTCDataChannelEvent = RTCDataChannelEvent;
+}

package/lib/esm/register/error.js

@@ -0,0 +1,8 @@
+import { RTCError } from "../rtc-error.js";
+import { RTCErrorEvent } from "../rtc-events.js";
+if (typeof globalThis.RTCError === "undefined") {
+  globalThis.RTCError = RTCError;
+}
+if (typeof globalThis.RTCErrorEvent === "undefined") {
+  globalThis.RTCErrorEvent = RTCErrorEvent;
+}

package/lib/esm/register/media-devices.js

@@ -0,0 +1,7 @@
+import { MediaDevices } from "../media-devices.js";
+if (typeof globalThis.navigator === "undefined") {
+  globalThis.navigator = {};
+}
+if (typeof globalThis.navigator.mediaDevices === "undefined") {
+  globalThis.navigator.mediaDevices = new MediaDevices();
+}

package/lib/esm/register/media.js

@@ -0,0 +1,12 @@
+import { MediaStream } from "../media-stream.js";
+import { MediaStreamTrack } from "../media-stream-track.js";
+import { RTCTrackEvent } from "../rtc-track-event.js";
+if (typeof globalThis.MediaStream === "undefined") {
+  globalThis.MediaStream = MediaStream;
+}
+if (typeof globalThis.MediaStreamTrack === "undefined") {
+  globalThis.MediaStreamTrack = MediaStreamTrack;
+}
+if (typeof globalThis.RTCTrackEvent === "undefined") {
+  globalThis.RTCTrackEvent = RTCTrackEvent;
+}

package/lib/esm/register/peer-connection.js

@@ -0,0 +1,16 @@
+import { RTCPeerConnection } from "../rtc-peer-connection.js";
+import { RTCSessionDescription } from "../rtc-session-description.js";
+import { RTCIceCandidate } from "../rtc-ice-candidate.js";
+import { RTCPeerConnectionIceEvent } from "../rtc-events.js";
+if (typeof globalThis.RTCPeerConnection === "undefined") {
+  globalThis.RTCPeerConnection = RTCPeerConnection;
+}
+if (typeof globalThis.RTCSessionDescription === "undefined") {
+  globalThis.RTCSessionDescription = RTCSessionDescription;
+}
+if (typeof globalThis.RTCIceCandidate === "undefined") {
+  globalThis.RTCIceCandidate = RTCIceCandidate;
+}
+if (typeof globalThis.RTCPeerConnectionIceEvent === "undefined") {
+  globalThis.RTCPeerConnectionIceEvent = RTCPeerConnectionIceEvent;
+}

package/lib/esm/register.js

@@ -0,0 +1,5 @@
+import "./register/peer-connection.js";
+import "./register/data-channel.js";
+import "./register/error.js";
+import "./register/media.js";
+import "./register/media-devices.js";

package/lib/esm/rtc-certificate.js

@@ -0,0 +1,70 @@
+import GLib from "gi://GLib?version=2.0";
+const DEFAULT_EXPIRY_MS = 30 * 24 * 60 * 60 * 1e3;
+class RTCCertificate {
+  expires;
+  // DOMTimeStamp (ms since epoch)
+  _fingerprints;
+  _algorithm;
+  /** @internal — use RTCPeerConnection.generateCertificate() */
+  constructor(algorithm, expires, fingerprints) {
+    this._algorithm = algorithm;
+    this.expires = expires;
+    this._fingerprints = fingerprints;
+  }
+  getFingerprints() {
+    return [...this._fingerprints];
+  }
+  /** @internal — the algorithm name for debugging/inspection */
+  get _algorithmName() {
+    return this._algorithm;
+  }
+}
+async function generateCertificate(keygenAlgorithm) {
+  let name;
+  if (typeof keygenAlgorithm === "string") {
+    name = keygenAlgorithm.toLowerCase();
+  } else if (keygenAlgorithm && typeof keygenAlgorithm === "object" && typeof keygenAlgorithm.name === "string") {
+    name = keygenAlgorithm.name.toLowerCase();
+  } else {
+    throw new DOMException(
+      "generateCertificate: algorithm must have a name property",
+      "NotSupportedError"
+    );
+  }
+  if (name === "ecdsa") {
+    const curve = keygenAlgorithm.namedCurve;
+    if (curve && curve !== "P-256") {
+      throw new DOMException(
+        `generateCertificate: unsupported ECDSA curve '${curve}'`,
+        "NotSupportedError"
+      );
+    }
+  } else if (name === "rsassa-pkcs1-v1_5") {
+    const hash = keygenAlgorithm.hash;
+    const hashName = typeof hash === "string" ? hash : hash?.name;
+    if (hashName && hashName.toUpperCase() === "SHA-1") {
+      throw new DOMException(
+        "generateCertificate: SHA-1 is not supported for RSA certificates",
+        "NotSupportedError"
+      );
+    }
+  } else {
+    throw new DOMException(
+      `generateCertificate: unsupported algorithm '${name}'`,
+      "NotSupportedError"
+    );
+  }
+  const uuid = GLib.uuid_string_random();
+  const checksum = GLib.Checksum.new(GLib.ChecksumType.SHA256);
+  checksum.update(new TextEncoder().encode(uuid + Date.now()));
+  const fingerprintHex = checksum.get_string();
+  const formatted = fingerprintHex.slice(0, 64).match(/.{2}/g).join(":").toUpperCase();
+  const expires = Date.now() + DEFAULT_EXPIRY_MS;
+  return new RTCCertificate(name, expires, [
+    { algorithm: "sha-256", value: formatted }
+  ]);
+}
+export {
+  RTCCertificate,
+  generateCertificate
+};

package/lib/esm/rtc-data-channel.js

@@ -0,0 +1,266 @@
+import GLib from "gi://GLib?version=2.0";
+import { DataChannelBridge } from "@gjsify/webrtc-native";
+import { RTCError } from "./rtc-error.js";
+import { RTCErrorEvent } from "./rtc-events.js";
+const STATE_MAP = {
+  1: "connecting",
+  2: "open",
+  3: "closing",
+  4: "closed"
+};
+function toGBytes(buffer) {
+  let view;
+  if (ArrayBuffer.isView(buffer)) {
+    view = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  } else {
+    view = new Uint8Array(buffer);
+  }
+  return new GLib.Bytes(view);
+}
+function bytesToArrayBuffer(bytes) {
+  const arr = bytes.toArray?.();
+  if (arr instanceof Uint8Array) {
+    return arr.buffer.slice(arr.byteOffset, arr.byteOffset + arr.byteLength);
+  }
+  const data = bytes.get_data?.();
+  if (data instanceof Uint8Array) {
+    return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+  }
+  return new ArrayBuffer(0);
+}
+class RTCDataChannel extends EventTarget {
+  _native;
+  _bridge;
+  _binaryType = "arraybuffer";
+  _bufferedAmount = 0;
+  _closed = false;
+  // `on<event>` attribute handlers — W3C requires both addEventListener and on*.
+  _onopen = null;
+  _onclose = null;
+  _onerror = null;
+  _onmessage = null;
+  _onbufferedamountlow = null;
+  _onclosing = null;
+  /**
+   * @internal
+   * Accepts either a raw GstWebRTCDataChannel (for locally-created channels)
+   * or a pre-made DataChannelBridge (for remotely-originated channels that
+   * the WebrtcbinBridge already wrapped on the streaming thread to avoid
+   * missing early messages).
+   */
+  constructor(source) {
+    super();
+    if (source.channel !== void 0 && source.dispose_bridge) {
+      this._bridge = source;
+      this._native = this._bridge.channel;
+    } else {
+      this._native = source;
+      this._bridge = new DataChannelBridge({ channel: this._native });
+    }
+    this._bridge.connect("opened", () => this._handleOpen());
+    this._bridge.connect("closed", () => this._handleClose());
+    this._bridge.connect("error-occurred", (_b, message) => this._handleError(message));
+    this._bridge.connect("message-string", (_b, data) => this._handleString(data));
+    this._bridge.connect("message-data", (_b, data) => this._handleData(data));
+    this._bridge.connect("buffered-amount-low", () => this._handleBufferedAmountLow());
+    this._bridge.connect("ready-state-changed", () => this._handleReadyStateChange());
+  }
+  // ---- Properties --------------------------------------------------------
+  get label() {
+    return this._native.label;
+  }
+  get ordered() {
+    return this._native.ordered;
+  }
+  get protocol() {
+    return this._native.protocol;
+  }
+  get negotiated() {
+    return this._native.negotiated;
+  }
+  get id() {
+    return this._native.id >= 0 ? this._native.id : null;
+  }
+  get maxPacketLifeTime() {
+    const v = this._native.max_packet_lifetime;
+    return v >= 0 ? v : null;
+  }
+  get maxRetransmits() {
+    const v = this._native.max_retransmits;
+    return v >= 0 ? v : null;
+  }
+  get readyState() {
+    if (this._closed) return "closed";
+    return STATE_MAP[this._native.ready_state] ?? "connecting";
+  }
+  get bufferedAmount() {
+    try {
+      return Number(this._native.buffered_amount) || this._bufferedAmount;
+    } catch {
+      return this._bufferedAmount;
+    }
+  }
+  get bufferedAmountLowThreshold() {
+    return Number(this._native.buffered_amount_low_threshold) || 0;
+  }
+  set bufferedAmountLowThreshold(v) {
+    this._native.buffered_amount_low_threshold = v;
+  }
+  get binaryType() {
+    return this._binaryType;
+  }
+  set binaryType(v) {
+    if (v !== "arraybuffer" && v !== "blob") return;
+    if (v === "blob" && typeof globalThis.Blob === "undefined") {
+      const DOMExc = globalThis.DOMException;
+      const msg = `binaryType 'blob' requires globalThis.Blob. Import '@gjsify/buffer/register' to provide it.`;
+      throw DOMExc ? new DOMExc(msg, "NotSupportedError") : new Error(msg);
+    }
+    this._binaryType = v;
+  }
+  // ---- on<event> attribute accessors -------------------------------------
+  get onopen() {
+    return this._onopen;
+  }
+  set onopen(h) {
+    this._onopen = h;
+  }
+  get onclose() {
+    return this._onclose;
+  }
+  set onclose(h) {
+    this._onclose = h;
+  }
+  get onclosing() {
+    return this._onclosing;
+  }
+  set onclosing(h) {
+    this._onclosing = h;
+  }
+  get onerror() {
+    return this._onerror;
+  }
+  set onerror(h) {
+    this._onerror = h;
+  }
+  get onmessage() {
+    return this._onmessage;
+  }
+  set onmessage(h) {
+    this._onmessage = h;
+  }
+  get onbufferedamountlow() {
+    return this._onbufferedamountlow;
+  }
+  set onbufferedamountlow(h) {
+    this._onbufferedamountlow = h;
+  }
+  // ---- Methods -----------------------------------------------------------
+  send(data) {
+    const state = this.readyState;
+    if (state !== "open") {
+      const DOMExc = globalThis.DOMException;
+      const msg = `RTCDataChannel.send: readyState is '${state}', expected 'open'`;
+      throw DOMExc ? new DOMExc(msg, "InvalidStateError") : new Error(msg);
+    }
+    if (typeof data === "string") {
+      this._native.send_string(data);
+      this._bufferedAmount += new TextEncoder().encode(data).byteLength;
+      return;
+    }
+    if (typeof globalThis.Blob !== "undefined" && data instanceof globalThis.Blob) {
+      const blob = data;
+      blob.arrayBuffer().then((buf) => {
+        try {
+          this._native.send_data(toGBytes(buf));
+          this._bufferedAmount += buf.byteLength;
+        } catch {
+        }
+      });
+      return;
+    }
+    if (ArrayBuffer.isView(data)) {
+      const bytes = toGBytes(data);
+      this._native.send_data(bytes);
+      this._bufferedAmount += data.byteLength;
+      return;
+    }
+    if (data instanceof ArrayBuffer) {
+      const bytes = toGBytes(data);
+      this._native.send_data(bytes);
+      this._bufferedAmount += data.byteLength;
+      return;
+    }
+    throw new TypeError("RTCDataChannel.send: unsupported data type");
+  }
+  close() {
+    if (this._closed) return;
+    try {
+      this._native.close();
+    } catch {
+    }
+    this._disconnectSignals();
+    this._closed = true;
+  }
+  /** @internal */
+  _disconnectSignals() {
+    try {
+      this._bridge.dispose_bridge();
+    } catch {
+    }
+  }
+  // ---- Signal → event translators ---------------------------------------
+  // Already running on the main context (DataChannelBridge did the hop).
+  _handleOpen() {
+    const ev = new Event("open");
+    this._onopen?.call(this, ev);
+    this.dispatchEvent(ev);
+  }
+  _handleClose() {
+    this._closed = true;
+    const ev = new Event("close");
+    this._onclose?.call(this, ev);
+    this.dispatchEvent(ev);
+  }
+  _handleError(message) {
+    const rtcErr = new RTCError(
+      { errorDetail: "data-channel-failure" },
+      message || "RTCDataChannel error"
+    );
+    const ev = new RTCErrorEvent("error", { error: rtcErr });
+    this._onerror?.call(this, ev);
+    this.dispatchEvent(ev);
+  }
+  _handleString(data) {
+    const ev = new MessageEvent("message", { data });
+    this._onmessage?.call(this, ev);
+    this.dispatchEvent(ev);
+  }
+  _handleData(bytes) {
+    if (!bytes) return;
+    const buf = bytesToArrayBuffer(bytes);
+    let data = buf;
+    if (this._binaryType === "blob" && typeof globalThis.Blob !== "undefined") {
+      data = new globalThis.Blob([buf]);
+    }
+    const ev = new MessageEvent("message", { data });
+    this._onmessage?.call(this, ev);
+    this.dispatchEvent(ev);
+  }
+  _handleBufferedAmountLow() {
+    this._bufferedAmount = Number(this._native.buffered_amount) || 0;
+    const ev = new Event("bufferedamountlow");
+    this._onbufferedamountlow?.call(this, ev);
+    this.dispatchEvent(ev);
+  }
+  _handleReadyStateChange() {
+    if (this.readyState === "closing") {
+      const ev = new Event("closing");
+      this._onclosing?.call(this, ev);
+      this.dispatchEvent(ev);
+    }
+  }
+}
+export {
+  RTCDataChannel
+};

package/lib/esm/rtc-dtls-transport.js

@@ -0,0 +1,41 @@
+import "@gjsify/dom-events/register/event-target";
+class RTCDtlsTransport extends EventTarget {
+  iceTransport;
+  _state = "new";
+  _onstatechange = null;
+  _onerror = null;
+  constructor(iceTransport) {
+    super();
+    this.iceTransport = iceTransport;
+  }
+  get state() {
+    return this._state;
+  }
+  get onstatechange() {
+    return this._onstatechange;
+  }
+  set onstatechange(v) {
+    this._onstatechange = v;
+  }
+  get onerror() {
+    return this._onerror;
+  }
+  set onerror(v) {
+    this._onerror = v;
+  }
+  getRemoteCertificates() {
+    return [];
+  }
+  // ---- Internal setters (called by RTCPeerConnection) ---------------------
+  /** @internal */
+  _setState(state) {
+    if (this._state === state) return;
+    this._state = state;
+    const ev = new Event("statechange");
+    this._onstatechange?.call(this, ev);
+    this.dispatchEvent(ev);
+  }
+}
+export {
+  RTCDtlsTransport
+};

package/lib/esm/rtc-dtmf-sender.js

@@ -0,0 +1,109 @@
+import "@gjsify/dom-events/register/event-target";
+const VALID_DTMF_CHARS = new Set("0123456789ABCDabcd#*,");
+const MIN_DURATION = 40;
+const MAX_DURATION = 6e3;
+const DEFAULT_DURATION = 100;
+const MIN_INTER_TONE_GAP = 30;
+const DEFAULT_INTER_TONE_GAP = 70;
+const COMMA_DELAY = 2e3;
+class RTCDTMFToneChangeEvent extends Event {
+  tone;
+  constructor(type, init = {}) {
+    super(type, init);
+    this.tone = init.tone ?? "";
+  }
+}
+class RTCDTMFSender extends EventTarget {
+  _toneBuffer = "";
+  _duration = DEFAULT_DURATION;
+  _interToneGap = DEFAULT_INTER_TONE_GAP;
+  _timerId = null;
+  _canInsert = true;
+  _ontonechange = null;
+  /** @internal — back-references set by RTCRtpSender */
+  _isStopped = () => false;
+  _getCurrentDirection = () => null;
+  get toneBuffer() {
+    return this._toneBuffer;
+  }
+  get canInsertDTMF() {
+    return this._canInsert;
+  }
+  get ontonechange() {
+    return this._ontonechange;
+  }
+  set ontonechange(v) {
+    this._ontonechange = v;
+  }
+  insertDTMF(tones, duration, interToneGap) {
+    if (this._isStopped()) {
+      throw new DOMException(
+        "Failed to execute 'insertDTMF': The associated transceiver is stopped",
+        "InvalidStateError"
+      );
+    }
+    const dir = this._getCurrentDirection();
+    if (dir === "recvonly" || dir === "inactive") {
+      throw new DOMException(
+        "Failed to execute 'insertDTMF': The associated transceiver direction does not allow sending",
+        "InvalidStateError"
+      );
+    }
+    for (const ch of tones) {
+      if (!VALID_DTMF_CHARS.has(ch)) {
+        throw new DOMException(
+          `Failed to execute 'insertDTMF': Invalid DTMF character '${ch}'`,
+          "InvalidCharacterError"
+        );
+      }
+    }
+    tones = tones.replace(/[a-d]/g, (c) => c.toUpperCase());
+    const d = duration ?? DEFAULT_DURATION;
+    this._duration = Math.max(MIN_DURATION, Math.min(MAX_DURATION, d));
+    const g = interToneGap ?? DEFAULT_INTER_TONE_GAP;
+    this._interToneGap = Math.max(MIN_INTER_TONE_GAP, g);
+    this._toneBuffer = tones;
+    if (this._timerId !== null) {
+      clearTimeout(this._timerId);
+      this._timerId = null;
+    }
+    if (tones.length > 0) {
+      this._scheduleNextTone(0);
+    }
+  }
+  _scheduleNextTone(delay) {
+    this._timerId = setTimeout(() => {
+      this._timerId = null;
+      this._playNextTone();
+    }, delay);
+  }
+  _playNextTone() {
+    if (this._toneBuffer.length === 0) {
+      this._fireToneChange("");
+      return;
+    }
+    const tone = this._toneBuffer[0];
+    this._toneBuffer = this._toneBuffer.slice(1);
+    this._fireToneChange(tone);
+    const delay = tone === "," ? COMMA_DELAY : this._duration + this._interToneGap;
+    this._scheduleNextTone(delay);
+  }
+  _fireToneChange(tone) {
+    const ev = new RTCDTMFToneChangeEvent("tonechange", { tone });
+    this._ontonechange?.call(this, ev);
+    this.dispatchEvent(ev);
+  }
+  /** @internal — called by RTCRtpSender on cleanup */
+  _stop() {
+    if (this._timerId !== null) {
+      clearTimeout(this._timerId);
+      this._timerId = null;
+    }
+    this._toneBuffer = "";
+    this._canInsert = false;
+  }
+}
+export {
+  RTCDTMFSender,
+  RTCDTMFToneChangeEvent
+};

package/lib/esm/rtc-error.js

@@ -0,0 +1,24 @@
+import "@gjsify/dom-exception/register";
+class RTCError extends DOMException {
+  errorDetail;
+  sdpLineNumber;
+  sctpCauseCode;
+  receivedAlert;
+  sentAlert;
+  httpRequestStatusCode;
+  constructor(init, message) {
+    super(message ?? init.errorDetail, "OperationError");
+    if (!init || !init.errorDetail) {
+      throw new TypeError("RTCError: errorDetail is required");
+    }
+    this.errorDetail = init.errorDetail;
+    this.sdpLineNumber = init.sdpLineNumber ?? null;
+    this.sctpCauseCode = init.sctpCauseCode ?? null;
+    this.receivedAlert = init.receivedAlert ?? null;
+    this.sentAlert = init.sentAlert ?? null;
+    this.httpRequestStatusCode = init.httpRequestStatusCode ?? null;
+  }
+}
+export {
+  RTCError
+};

package/lib/esm/rtc-events.js

@@ -0,0 +1,35 @@
+import "@gjsify/dom-events/register/event-target";
+class RTCPeerConnectionIceEvent extends Event {
+  candidate;
+  url;
+  constructor(type, init = {}) {
+    super(type, init);
+    this.candidate = init.candidate ?? null;
+    this.url = init.url ?? null;
+  }
+}
+class RTCDataChannelEvent extends Event {
+  channel;
+  constructor(type, init) {
+    super(type, init);
+    if (!init || !init.channel) {
+      throw new TypeError("RTCDataChannelEvent requires a `channel` member");
+    }
+    this.channel = init.channel;
+  }
+}
+class RTCErrorEvent extends Event {
+  error;
+  constructor(type, init) {
+    super(type, init);
+    if (!init || !init.error) {
+      throw new TypeError("RTCErrorEvent requires an `error` member");
+    }
+    this.error = init.error;
+  }
+}
+export {
+  RTCDataChannelEvent,
+  RTCErrorEvent,
+  RTCPeerConnectionIceEvent
+};