@formant/data-sdk 0.0.76 → 0.0.79

package/dist/data-sdk.es.js

@@ -19217,6 +19217,218 @@ class Device {
     return interventionResponse;
   }
 }
+class PeerDevice {
+  constructor(peer_url) {
+    __publicField(this, "rtcClient");
+    __publicField(this, "remoteDevicePeerId");
+    __publicField(this, "realtimeListeners", []);
+    __publicField(this, "id");
+    __publicField(this, "handleMessage", (peerId, message) => {
+      this.realtimeListeners.forEach((_) => _(peerId, message));
+    });
+    this.peer_url = peer_url;
+  }
+  async getLatestTelemetry() {
+    const data = await fetch(`${this.peer_url}/telemetry`);
+    const telemetry = await data.json();
+    const entries = Object.entries(telemetry);
+    return entries.map(([stream, latestValue]) => {
+      const v = {
+        deviceId: this.id,
+        streamName: stream,
+        streamType: "json",
+        currentValue: latestValue,
+        currentValueTime: latestValue.timestamp,
+        tags: {}
+      };
+      return v;
+    });
+  }
+  async getDeviceId() {
+    let result = await fetch(`${this.peer_url}/configuration`);
+    const cfg = await result.json();
+    return cfg.agent_config.id;
+  }
+  async getConfiguration() {
+    let result = await fetch(`${this.peer_url}/configuration`);
+    const cfg = await result.json();
+    return cfg.agent_config.document;
+  }
+  getRealtimeStatus() {
+    if (this.rtcClient && this.remoteDevicePeerId) {
+      return this.rtcClient.getConnectionStatus(this.remoteDevicePeerId);
+    } else {
+      throw new Error(`Realtime connection hasn't been started`);
+    }
+  }
+  getRealtimePing() {
+    if (this.rtcClient && this.remoteDevicePeerId) {
+      return this.rtcClient.getPing(this.remoteDevicePeerId);
+    } else {
+      throw new Error(`Realtime connection hasn't been started`);
+    }
+  }
+  async startRealtimeConnection(_sessionType) {
+    if (!this.rtcClient) {
+      const rtcClient = new dist.exports.RtcClient({
+        lanOnlyMode: true,
+        receive: this.handleMessage
+      });
+      await rtcClient.connectLan(this.peer_url);
+      while (true) {
+        await delay(100);
+        if (rtcClient.getConnections()[0].isReady()) {
+          break;
+        }
+      }
+      this.rtcClient = rtcClient;
+    } else {
+      throw new Error(`Already created realtime connection to device ${this.id}`);
+    }
+  }
+  addRealtimeListener(listener) {
+    this.realtimeListeners.push(listener);
+  }
+  removeRealtimeListener(listener) {
+    const i = this.realtimeListeners.indexOf(listener);
+    if (i === -1) {
+      throw new Error("Could not find realtime listener to remove");
+    }
+    this.realtimeListeners.splice(i, 1);
+  }
+  async getRealtimeVideoStreams() {
+    var _a, _b, _c;
+    const document2 = await this.getConfiguration();
+    const streams = [];
+    for (const _ of (_a = document2.teleop.hardwareStreams) != null ? _a : []) {
+      if (_.rtcStreamType === "h264-video-frame") {
+        streams.push({
+          name: _.name
+        });
+      }
+    }
+    for (const _ of (_b = document2.teleop.rosStreams) != null ? _b : []) {
+      if (_.topicType == "formant/H264VideoFrame") {
+        streams.push({
+          name: _.topicName
+        });
+      }
+    }
+    for (const _ of (_c = document2.teleop.customStreams) != null ? _c : []) {
+      if (_.rtcStreamType === "h264-video-frame") {
+        streams.push({
+          name: _.name
+        });
+      }
+    }
+    return streams;
+  }
+  async getRealtimeManipulators() {
+    var _a;
+    const document2 = await this.getConfiguration();
+    const manipulators = [];
+    for (const _ of (_a = document2.teleop.rosStreams) != null ? _a : []) {
+      if (_.topicType == "sensor_msgs/JointState") {
+        manipulators.push(new Manipulator(this, {
+          currentJointStateStream: { name: _.topicName },
+          plannedJointStateStream: _.plannedTopic ? { name: _.plannedTopic } : void 0,
+          planValidStream: _.planValidTopic ? { name: _.planValidTopic } : void 0,
+          endEffectorStream: _.endEffectorTopic ? { name: _.endEffectorTopic } : void 0,
+          endEffectorLinkName: _.endEffectorLinkName,
+          baseReferenceFrame: _.baseReferenceFrame,
+          localFrame: _.localFrame
+        }));
+      }
+    }
+    return manipulators;
+  }
+  async startListeningToRealtimeVideo(stream) {
+    const client = defined(this.rtcClient, "Realtime connection has not been started");
+    const devicePeer = await this.getRemotePeer();
+    client.controlRemoteStream(defined(devicePeer).id, {
+      streamName: stream.name,
+      enable: true,
+      pipeline: "rtc"
+    });
+  }
+  async stopListeningToRealtimeVideo(stream) {
+    const client = defined(this.rtcClient, "Realtime connection has not been started");
+    const devicePeer = await this.getRemotePeer();
+    client.controlRemoteStream(defined(devicePeer).id, {
+      streamName: stream.name,
+      enable: false,
+      pipeline: "rtc"
+    });
+  }
+  async startListeningToRealtimeDataStream(stream) {
+    const client = defined(this.rtcClient, "Realtime connection has not been started");
+    const devicePeer = await this.getRemotePeer();
+    client.controlRemoteStream(defined(devicePeer).id, {
+      streamName: stream.name,
+      enable: true,
+      pipeline: "rtc"
+    });
+  }
+  async stopListeningToRealtimeDataStream(stream) {
+    const client = defined(this.rtcClient, "Realtime connection has not been started");
+    const devicePeer = await this.getRemotePeer();
+    client.controlRemoteStream(defined(devicePeer).id, {
+      streamName: stream.name,
+      enable: false,
+      pipeline: "rtc"
+    });
+  }
+  async enableRealtimeTelemetryPriorityIngestion(streamName) {
+    const client = defined(this.rtcClient, "Realtime connection has not been started");
+    const devicePeer = await this.getRemotePeer();
+    client.controlRemoteStream(defined(devicePeer).id, {
+      streamName,
+      enablePriorityUpload: true,
+      pipeline: "telemetry"
+    });
+  }
+  async disableRealtimeTelemetryPriorityIngestion(streamName) {
+    const client = defined(this.rtcClient, "Realtime connection has not been started");
+    const devicePeer = await this.getRemotePeer();
+    client.controlRemoteStream(defined(devicePeer).id, {
+      streamName,
+      enablePriorityUpload: false,
+      pipeline: "telemetry"
+    });
+  }
+  async getRemotePeer() {
+    const peers = await defined(this.rtcClient, "Realtime connection has not been started").getPeers();
+    const devicePeer = peers.find((_) => _.deviceId === this.id);
+    return defined(devicePeer, "Could not find remote peer for device " + this.id);
+  }
+  async stopRealtimeConnection() {
+    if (this.rtcClient) {
+      await this.rtcClient.disconnect(this.id);
+    } else {
+      throw new Error(`Realtime connection hasn't been started for ${this.id}`);
+    }
+  }
+  async createCustomDataChannel(channelName, rtcConfig) {
+    const client = defined(this.rtcClient, "Realtime connection has not been started");
+    const devicePeer = await this.getRemotePeer();
+    const p = await new Promise((resolve) => {
+      client.createCustomDataChannel(defined(devicePeer).id, channelName, __spreadValues({
+        ordered: true
+      }, rtcConfig), false, (_peerId, channel) => {
+        const dataChannel = new DataChannel(channel);
+        resolve(dataChannel);
+      });
+    });
+    await p.waitTilReady();
+    return p;
+  }
+  createCustomRequestDataChannel(channelName, timeout = 3e3) {
+    return new TextRequestDataChannel(this, channelName, timeout);
+  }
+  createCustomBinaryRequestDataChannel(channelName, timeout = 3e3) {
+    return new BinaryRequestDataChannel(this, channelName, timeout);
+  }
+}
 const _Fleet = class {
   static async setDefaultDevice(deviceId) {
     _Fleet.defaultDeviceId = deviceId;
@@ -19242,6 +19454,11 @@ const _Fleet = class {
     _Fleet.knownContext.push(new WeakRef(context));
     return context;
   }
+  static async getPeerDevice(url) {
+    const peer = new PeerDevice(url);
+    peer.id = await peer.getDeviceId();
+    return peer;
+  }
   static async getDevice(deviceId) {
     if (!Authentication.token) {
       throw new Error("Not authenticated");
@@ -19537,4 +19754,4 @@ const moduleName = urlParams.get("module");
 if (moduleName) {
   Authentication.listenForRefresh();
 }
-export { App, Authentication, BinaryRequestDataChannel, CaptureStream, DataChannel, Device, Fleet, KeyValue, Manipulator, SessionType, TextRequestDataChannel, accessLevels, administrator, aggregateLevels, annotationTypes, eventTypes, healthStatuses, interventionTypes, operator, severities, videoMimeTypes, viewer };
+export { App, Authentication, BinaryRequestDataChannel, CaptureStream, DataChannel, Device, Fleet, KeyValue, Manipulator, PeerDevice, SessionType, TextRequestDataChannel, accessLevels, administrator, aggregateLevels, annotationTypes, eventTypes, healthStatuses, interventionTypes, operator, severities, videoMimeTypes, viewer };