@luxonis/visualizer-protobuf 2.0.0 → 2.0.2

package/dist/worker-utils-BbyBpOVt.js

@@ -1,453 +0,0 @@
-import { F as FoxgloveCommunicator } from './communicator-D_EeiIbd.js';
-
-class EventEmitter {
-    id = 0;
-    handlers = {};
-    emit(event, data) {
-        const handlers = this.handlers[event] ?? [];
-        for (const { handler } of handlers) {
-            handler(...data);
-        }
-    }
-    on(event, handler) {
-        const key = event;
-        const id = this.id + 1;
-        if (!this.handlers[key]) {
-            this.handlers[key] = [];
-        }
-        this.handlers[key].push({ id, handler });
-        return this.off(event, id);
-    }
-    off(event, id) {
-        const key = event;
-        if (!this.handlers[key]) {
-            return;
-        }
-        const index = this.handlers[key].findIndex(handler => handler.id === id);
-        if (index > 0) {
-            this.handlers[key].splice(index, 1);
-        }
-    }
-    isEventHandled(event) {
-        const eventHandlers = this.handlers[event];
-        return !!eventHandlers && Object.values(eventHandlers).length > 0;
-    }
-}
-
-class WebRtcDataChannel {
-    channel;
-    events = new EventEmitter();
-    oldMessages = [];
-    constructor(channel) {
-        this.channel = channel;
-        this.channel.onerror = event => this.events.emit('error', [event]);
-        this.channel.onmessage = event => this.events.emit('message', [event]);
-        this.channel.onclose = event => this.events.emit('close', [event]);
-        this.channel.onopen = event => {
-            this.events.emit('open', [event]);
-            for (const message of this.oldMessages) {
-                this.sendMessage(message);
-            }
-            this.oldMessages = [];
-        };
-    }
-    get raw() {
-        return this.channel;
-    }
-    get label() {
-        return this.channel.label;
-    }
-    sendMessage(message) {
-        if (this.channel.readyState === 'open') {
-            this.channel.send(message);
-        }
-        else {
-            this.oldMessages.push(message);
-        }
-    }
-    /**
-     * This method does **not** filter messages. Use this method only intead of {@link on}
-     * if you are sure all messages sent over this channel will contain text.
-     */
-    onTextMessage(callback) {
-        return this.events.on('message', async (event) => {
-            const buffer = await event.data.arrayBuffer();
-            const message = new TextDecoder('utf-8').decode(buffer);
-            callback(message);
-        });
-    }
-    on = this.events.on.bind(this.events);
-}
-
-class WebRtcConnection {
-    iceServers;
-    #peerConnection;
-    connected = false;
-    events = new EventEmitter();
-    onIceCandidate;
-    onConnectionEstablished;
-    constructor(props) {
-        this.iceServers = props.iceServers;
-        this.onIceCandidate = props.onCandidate;
-        this.onConnectionEstablished = props.onConnectionEstablished;
-        this.#peerConnection = this.createPeerConnection();
-    }
-    createPeerConnection() {
-        const config = {
-            iceServers: this.iceServers ?? [],
-        };
-        const connection = new RTCPeerConnection(config);
-        connection.addEventListener('connectionstatechange', () => {
-            if (connection.connectionState === 'disconnected' ||
-                connection.connectionState === 'failed' ||
-                connection.connectionState === 'closed') {
-                this.events.emit('connection_closed', []);
-                this.connected = false;
-            }
-        });
-        connection.addEventListener('iceconnectionstatechange', () => {
-            if (connection.connectionState === 'connected') {
-                this.onConnectionEstablished();
-                this.connected = true;
-            }
-            else if (this.connected) {
-                this.events.emit('connection_closed', []);
-                this.connected = false;
-            }
-        });
-        connection.onicecandidate = event => {
-            if (event.candidate) {
-                this.onIceCandidate(event.candidate);
-            }
-        };
-        connection.ondatachannel = event => {
-            const channel = new WebRtcDataChannel(event.channel);
-            if (channel.label === 'ping-pong') {
-                channel.on('message', () => channel.sendMessage('pong'));
-            }
-            this.events.emit('data_channel', [channel]);
-        };
-        return connection;
-    }
-    get peerConnection() {
-        return this.#peerConnection;
-    }
-    createDataChannel(label, options) {
-        const channel = this.#peerConnection.createDataChannel(label, options);
-        return new WebRtcDataChannel(channel);
-    }
-    setRemoteDescription(type, sdp) {
-        return this.#peerConnection.setRemoteDescription({ type, sdp });
-    }
-    async createDescription(type) {
-        const description = await this.#peerConnection[type === 'offer' ? 'createOffer' : 'createAnswer']();
-        await this.#peerConnection.setLocalDescription(description);
-        return description;
-    }
-    addIceCandidate(candidate) {
-        return this.#peerConnection.addIceCandidate(new RTCIceCandidate(candidate));
-    }
-    close() {
-        return this.#peerConnection.close();
-    }
-    on = this.events.on.bind(this.events);
-}
-
-const DEFAULT_SIGNALING_SERVER_URL = 'wss://signal.cloud.luxonis.com/session/';
-class WebRtcClient {
-    config;
-    socket;
-    connection = null;
-    signalingConnectionRetries;
-    events = new EventEmitter();
-    iceCandidates = [];
-    constructor(config) {
-        this.config = config;
-        this.signalingConnectionRetries = (config.signalingConnectionRetries ?? 3) || 0;
-        this.connectSignalingServer();
-    }
-    get signalingServerConnected() {
-        return this.socket.readyState === WebSocket.OPEN;
-    }
-    disconnect(reason) {
-        this.connection?.close();
-        this.sendMessage({
-            Disconnect: {
-                type: 'normal',
-                reason,
-            },
-        });
-    }
-    connect() {
-        this.sendMessage({
-            ConnectSession: {
-                client_id: this.config.clientId,
-                application_identifier: this.config.applicationIdentifier,
-                auth_payload: this.config.authPayload,
-            },
-        });
-    }
-    connectSignalingServer() {
-        this.socket = new WebSocket(this.config.signalingServerUrl ?? DEFAULT_SIGNALING_SERVER_URL);
-        this.socket.onopen = () => {
-            this.connect();
-        };
-        // this.socket.onclose = () => console.debug('[WebRTC] Disconnected from signaling server');
-        this.socket.onerror = error => {
-            this.events.emit('error', ['signaling_connection_error', error]);
-            if (!this.events.isEventHandled('error')) {
-                console.error('[WebRTC] Signaling connection error:', error);
-            }
-            setTimeout(() => {
-                if (this.signalingConnectionRetries) {
-                    this.signalingConnectionRetries -= 1;
-                    if (this.socket.readyState === WebSocket.CLOSED || this.socket.readyState === WebSocket.CLOSING) {
-                        // console.debug('[WebRTC] Reconnecting to signaling server');
-                        this.connectSignalingServer();
-                    }
-                }
-            }, 3_000);
-        };
-        this.socket.onmessage = event => {
-            const message = JSON.parse(event.data);
-            this.handleSignalingMessage(message);
-        };
-    }
-    disconnectSignalingServer(reason) {
-        if (this.signalingServerConnected) {
-            this.sendMessage({
-                Disconnect: {
-                    type: 'normal',
-                    reason,
-                },
-            });
-            this.socket.close();
-        }
-    }
-    handleSignalingMessage(message) {
-        if ('AcknowledgeSession' in message) {
-            if (message.AcknowledgeSession.acknowledge) {
-                this.createConnection();
-            }
-            else {
-                if (!this.events.isEventHandled('error')) {
-                    console.error('[WebRTC] Connection refused:', message.AcknowledgeSession.reason);
-                }
-                this.events.emit('error', ['signaling_rejected', message.AcknowledgeSession.reason]);
-                this.dispose('Connection refused');
-            }
-        }
-        else if ('Candidate' in message) {
-            void this.handleCandidateMessage(message);
-        }
-        else if ('Disconnect' in message) {
-            this.dispose('Targed disconnected');
-        }
-    }
-    async handleCandidateMessage({ Candidate: { type: kind, candidate } }) {
-        if (!this.connection) {
-            // console.error('[WebRTC] Candidate message dropped: conenction not established');
-            return;
-        }
-        // console.debug('[WebRTC] Processing candidate message', kind);
-        switch (kind) {
-            case 'answer':
-            case 'offer': {
-                const data = `${candidate}`;
-                if (data === 'null' || data === '') {
-                    console.error('[WebRTC] Offer refused: remote description cannot be null');
-                    this.reconnect('Error: received invalid candidate');
-                    return;
-                }
-                // console.debug('[WebRTC] Offer accepted. Setting remote description..');
-                await this.connection.setRemoteDescription(kind, candidate);
-                // console.debug('[WebRTC] Set remote description');
-                for (const candidate of this.iceCandidates) {
-                    // console.debug('[WebRTC] Adding stored ICE candidate');
-                    this.connection.addIceCandidate(JSON.parse(candidate));
-                }
-                this.iceCandidates = [];
-                if (kind === 'offer') {
-                    const answer = await this.connection.createDescription('answer');
-                    // console.debug('[WebRTC] Answer created (set local description)');
-                    this.sendMessage({
-                        Candidate: {
-                            type: 'answer',
-                            candidate: answer.sdp ?? '',
-                        },
-                    });
-                }
-                return;
-            }
-            case 'candidate': {
-                if (this.connection.peerConnection.remoteDescription === null) {
-                    // console.debug('[WebRTC] Storing ICE candidate (remote description is not set yet)');
-                    this.iceCandidates.push(candidate);
-                }
-                else {
-                    // console.debug('[WebRTC] Adding ICE candidate');
-                    return this.connection.addIceCandidate(JSON.parse(candidate));
-                }
-            }
-        }
-    }
-    reconnect(reason) {
-        // console.debug(`[WebRTC] Reconnecting: ${reason}`);
-        this.disconnect(reason);
-        this.connect();
-    }
-    sendMessage(message) {
-        // console.debug('[WebRTC] Sending message', message);
-        if (this.socket.readyState === WebSocket.OPEN) {
-            this.socket.send(JSON.stringify(message));
-        }
-    }
-    createConnection() {
-        this.connection = new WebRtcConnection({
-            iceServers: this.config.iceServers,
-            onCandidate: candidate => {
-                this.sendMessage({
-                    Candidate: {
-                        type: 'candidate',
-                        candidate: JSON.stringify(candidate),
-                    },
-                });
-            },
-            onConnectionEstablished: () => this.disconnectSignalingServer('P2P connection established'),
-        });
-        this.events.emit('connection_established', [this.connection]);
-    }
-    dispose(reason) {
-        this.disconnect(reason);
-        this.disconnectSignalingServer(reason);
-    }
-    on = this.events.on.bind(this.events);
-}
-
-// This Source Code Form is subject to the terms of the Mozilla Public
-// License, v2.0. If a copy of the MPL was not distributed with this
-// file, You can obtain one at http://mozilla.org/MPL/2.0/
-
-const MESSAGE_CHANNEL_NAME = "message";
-const SYSTEM_CHANNEL_NAME = "system";
-class WebRtcWorker extends FoxgloveCommunicator {
-  #webrtc;
-  #messageChannel = null;
-  #systemChannel = null;
-  #isReady = false;
-  #subscriptionId = 0;
-  #createWebRtc(config) {
-    this.#webrtc = new WebRtcClient(config);
-  }
-  #handleMessages() {
-    this.#webrtc.on("connection_established", connection => {
-      connection.on("data_channel", channel => {
-        // this.#onOpen(); // TODO:
-
-        if (channel.label === MESSAGE_CHANNEL_NAME) {
-          this.#messageChannel = channel;
-          channel.on("message", async ({
-            data: {
-              subscriptionId,
-              data
-            }
-          }) => {
-            this.handleGenericMessage(subscriptionId, data);
-          });
-        } else if (channel.label === SYSTEM_CHANNEL_NAME) {
-          this.#systemChannel = channel;
-          channel.on("message", async event => {
-            // TODO: Handle service call responses
-            const message = JSON.parse(event.data);
-            if (message.op === "advertise") {
-              this.handleChannelsAdvertisement(message.channels);
-            } else if (message.op === 'unadvertise') {
-              this.handleChannelsUnadvertisement(message.channelIds);
-            } else if (message.op === 'advertiseServices') {
-              this.handleServicesAdvertisement(message.services);
-              // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            } else if (message.op === 'unadvertiseServices') {
-              this.handleServicesUnadvertisement(message.serviceIds);
-            }
-          });
-        }
-      });
-      connection.on("connection_closed", () => {
-        // this.#onClose(); // TODO:
-      });
-    });
-  }
-  isReady() {
-    return this.#isReady;
-  }
-  sendServiceCallRequest(request) {
-    // TODO: Should be binary
-    // https://github.com/foxglove/ws-protocol/blob/main/docs/spec.md#service-call-request
-    this.#messageChannel?.sendMessage(JSON.stringify(request));
-  }
-  subscribe(channel) {
-    this.#subscriptionId += 1;
-    this.#systemChannel?.sendMessage(JSON.stringify({
-      op: 'subscribe',
-      subscriptions: [{
-        id: this.#subscriptionId,
-        channelId: channel
-      }]
-    }));
-    return this.#subscriptionId;
-  }
-  constructor(config, send, sendWithTransfer) {
-    super();
-    this.send = send;
-    this.sendWithTransfer = sendWithTransfer;
-    this.#createWebRtc(config);
-    this.#handleMessages();
-  }
-
-  // TODO: binary support
-  rawSend(channel, data) {
-    if (this.isReady()) {
-      const target = channel === 'message' ? this.#messageChannel : this.#systemChannel;
-      target?.sendMessage(data);
-    }
-  }
-  close() {
-    this.#webrtc.dispose("Connection closed");
-  }
-  callService({
-    name,
-    serviceCallId,
-    body = {}
-  }) {
-    super.callService({
-      name,
-      serviceCallId,
-      body
-    });
-  }
-}
-function createWebRtcWorkerMessageListener(send, sendWithTransfer) {
-  let webrtcWorker = null;
-  return async event => {
-    const {
-      type,
-      data
-    } = event.data;
-    switch (type) {
-      case "open":
-        webrtcWorker = new WebRtcWorker(data.config, send, sendWithTransfer);
-        break;
-      case "close":
-        webrtcWorker?.close();
-        break;
-      case "send":
-        webrtcWorker?.rawSend(data.channel, data.message);
-        break;
-      case "call_service":
-        webrtcWorker?.callService(data);
-        break;
-    }
-  };
-}
-
-export { createWebRtcWorkerMessageListener as c };