impl navigator

packages/webrtc/src/media/track.ts

@@ -71,8 +71,13 @@ export class MediaStream {
   id!: string;
   tracks: MediaStreamTrack[] = [];
 
-  constructor(props: Partial<MediaStream> & Pick<MediaStream, "id">) {
-    Object.assign(this, props);
+  constructor(props: Partial<MediaStream> | MediaStreamTrack[]) {
+    if (Array.isArray(props)) {
+      this.tracks = props;
+    } else {
+      Object.assign(this, props);
+    }
+    this.id ??= v4();
   }
 
   addTrack(track: MediaStreamTrack) {
@@ -83,4 +88,12 @@ export class MediaStream {
   getTracks() {
     return this.tracks;
   }
+
+  getAudioTracks() {
+    return this.tracks.filter((track) => track.kind === "audio");
+  }
+
+  getVideoTracks() {
+    return this.tracks.filter((track) => track.kind === "video");
+  }
 }

packages/webrtc/src/nonstandard/index.ts

@@ -1,2 +1,3 @@
 export * from "./recorder";
 export * from "./userMedia";
+export * from "./navigator";

packages/webrtc/src/nonstandard/navigator.ts

@@ -0,0 +1,93 @@
+import { MediaStream, MediaStreamTrack } from "../media/track";
+
+export class Navigator {
+  readonly mediaDevices: MediaDevices;
+
+  constructor(props: ConstructorParameters<typeof MediaDevices>[0] = {}) {
+    this.mediaDevices = new MediaDevices(props);
+  }
+}
+
+class MediaDevices extends EventTarget {
+  video?: MediaStreamTrack;
+  audio?: MediaStreamTrack;
+
+  constructor(props: { video?: MediaStreamTrack; audio?: MediaStreamTrack }) {
+    super();
+    this.video = props.video;
+    this.audio = props.audio;
+  }
+
+  readonly getUserMedia = async (
+    constraints: MediaStreamConstraints,
+  ): Promise<MediaStream> => {
+    if (constraints.video && constraints.audio) {
+      return new MediaStream([this.video!, this.audio!]);
+    } else if (constraints.audio) {
+      return new MediaStream([this.audio!]);
+    } else if (constraints.video) {
+      return new MediaStream([this.video!]);
+    }
+
+    throw new Error("Not implemented");
+  };
+
+  readonly getDisplayMedia = this.getUserMedia;
+}
+
+interface MediaStreamConstraints {
+  audio?: boolean | MediaTrackConstraints;
+  peerIdentity?: string;
+  preferCurrentTab?: boolean;
+  video?: boolean | MediaTrackConstraints;
+}
+
+interface MediaTrackConstraints extends MediaTrackConstraintSet {
+  advanced?: MediaTrackConstraintSet[];
+}
+
+interface MediaTrackConstraintSet {
+  aspectRatio?: ConstrainDouble;
+  autoGainControl?: ConstrainBoolean;
+  channelCount?: ConstrainULong;
+  deviceId?: ConstrainDOMString;
+  displaySurface?: ConstrainDOMString;
+  echoCancellation?: ConstrainBoolean;
+  facingMode?: ConstrainDOMString;
+  frameRate?: ConstrainDouble;
+  groupId?: ConstrainDOMString;
+  height?: ConstrainULong;
+  noiseSuppression?: ConstrainBoolean;
+  sampleRate?: ConstrainULong;
+  sampleSize?: ConstrainULong;
+  width?: ConstrainULong;
+}
+
+type ConstrainDOMString = string | string[] | ConstrainDOMStringParameters;
+interface ConstrainDOMStringParameters {
+  exact?: string | string[];
+  ideal?: string | string[];
+}
+type ConstrainBoolean = boolean | ConstrainBooleanParameters;
+interface ConstrainBooleanParameters {
+  exact?: boolean;
+  ideal?: boolean;
+}
+type ConstrainULong = number | ConstrainULongRange;
+interface ConstrainULongRange extends ULongRange {
+  exact?: number;
+  ideal?: number;
+}
+interface ULongRange {
+  max?: number;
+  min?: number;
+}
+type ConstrainDouble = number | ConstrainDoubleRange;
+interface ConstrainDoubleRange extends DoubleRange {
+  exact?: number;
+  ideal?: number;
+}
+interface DoubleRange {
+  max?: number;
+  min?: number;
+}