@stream-io/video-client 0.0.1-alpha.137 → 0.0.1-alpha.139

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 This file was generated using [@jscutlery/semver](https://github.com/jscutlery/semver).
 
+## [0.0.1-alpha.139](https://github.com/GetStream/stream-video-js/compare/client0.0.1-alpha.138...client0.0.1-alpha.139) (2023-05-15)
+
+
+### Features
+
+* faster join flow ([#499](https://github.com/GetStream/stream-video-js/issues/499)) ([898341b](https://github.com/GetStream/stream-video-js/commit/898341b26495412acea7d9e08c0c8f9b0b54e3b3))
+
+
+
+## [0.0.1-alpha.138](https://github.com/GetStream/stream-video-js/compare/client0.0.1-alpha.137...client0.0.1-alpha.138) (2023-05-15)
+
+
+
 ## [0.0.1-alpha.137](https://github.com/GetStream/stream-video-js/compare/client0.0.1-alpha.136...client0.0.1-alpha.137) (2023-05-12)
 
 

package/dist/index.browser.es.js

@@ -6003,30 +6003,6 @@ function removeConnectionEventListeners(cb) {
     }
 }
 
-const hostnameFromUrl = (url) => {
-    try {
-        const u = new URL(url);
-        return {
-            hostname: u.hostname,
-            port: u.port,
-        };
-    }
-    catch (e) {
-        console.warn(`Invalid URL. Can't extract hostname from it.`, e);
-        return {
-            hostname: url,
-            port: 3031,
-        };
-    }
-};
-const toURL = (url) => {
-    try {
-        return new URL(url);
-    }
-    catch (e) {
-        return null;
-    }
-};
 /**
  * The client used for exchanging information with the SFU.
  */
@@ -6036,9 +6012,10 @@ class StreamSfuClient {
      *
      * @param dispatcher the event dispatcher to use.
      * @param url the URL of the SFU.
+     * @param wsEndpoint the WebSocket endpoint of the SFU.
      * @param token the JWT token to use for authentication.
      */
-    constructor(dispatcher, url, token) {
+    constructor(dispatcher, url, wsEndpoint, token) {
         /**
          * A buffer for ICE Candidates that are received before
          * the PeerConnections are ready to handle them.
@@ -6133,17 +6110,6 @@ class StreamSfuClient {
                 }),
             ],
         });
-        // FIXME: OL: this should come from the coordinator API
-        const { hostname, port } = hostnameFromUrl(url);
-        let wsEndpoint = `ws://${hostname}:${port}/ws`;
-        if (!['localhost', '127.0.0.1'].includes(hostname)) {
-            const sfuUrl = toURL(url);
-            if (sfuUrl) {
-                sfuUrl.protocol = 'wss:';
-                sfuUrl.pathname = '/ws';
-                wsEndpoint = sfuUrl.toString();
-            }
-        }
         // Special handling for the ICETrickle kind of events.
         // These events might be triggered by the SFU before the initial RTC
         // connection is established. In that case, those events (ICE candidates)
@@ -7373,99 +7339,19 @@ const registerRingingCallEventHandlers = (call) => {
     };
 };
 
-const toSeconds = (ms) => ms / 1000;
 /**
- * Measures the latency of the current client to the given endpoint.
+ * Collects all necessary information to join a call, talks to the coordinator
+ * and returns the necessary information to join the call.
  *
- * @param endpoint the endpoint.
- * @param timeoutAfterMs the request cancellation period.
- */
-const measureResourceLoadLatencyTo = (endpoint, timeoutAfterMs = 1000) => __awaiter(void 0, void 0, void 0, function* () {
-    const start = Date.now();
-    const controller = new AbortController();
-    const abortTimeout = setTimeout(() => {
-        controller.abort();
-    }, timeoutAfterMs);
-    try {
-        const src = new URL(endpoint);
-        src.searchParams.set('r', `js_${Math.random() * 10000000}`);
-        yield fetch(src.toString(), {
-            signal: controller.signal,
-        });
-        const latency = Date.now() - start;
-        return toSeconds(latency);
-    }
-    catch (e) {
-        console.debug(`failed to measure latency to ${endpoint}`, e);
-        return -1; // indicate error in measurement
-    }
-    finally {
-        // clear timeout in case fetch completes before timeout
-        clearTimeout(abortTimeout);
-    }
-});
-/**
- * Measures the latency of the current client to the given edges.
- *
- * All measurements run in parallel,
- * and the whole process is limited by the given timeout.
- *
- * @param edges the edges to measure latency to.
- * @param attempts the number of attempts to measure latency.
- * @param attemptTimeoutAfterMs the request cancellation period per measurement.
- * @param measureTimeoutAfterMs the hard-limit for the whole measure process.
- */
-const measureLatencyToEdges = (edges, { attempts = 3, attemptTimeoutAfterMs = 1000, measureTimeoutAfterMs = 1200, } = {}) => __awaiter(void 0, void 0, void 0, function* () {
-    const latencyByEdge = {};
-    const measurements = [];
-    const start = Date.now();
-    for (let attempt = 0; attempt < attempts; attempt++) {
-        for (const edge of edges) {
-            measurements.push(measureResourceLoadLatencyTo(edge.latency_url, attemptTimeoutAfterMs).then((latency) => {
-                var _a;
-                var _b;
-                ((_a = latencyByEdge[_b = edge.name]) !== null && _a !== void 0 ? _a : (latencyByEdge[_b] = [])).push(latency);
-            }));
-        }
-    }
-    yield Promise.race([
-        Promise.all(measurements),
-        new Promise((resolve) => setTimeout(resolve, measureTimeoutAfterMs)),
-    ]);
-    console.log(`finished measuring latency to ${edges.length} edges in ${Date.now() - start}ms.`);
-    return latencyByEdge;
-});
-
-const getCascadingModeParams = () => {
-    var _a;
-    if (typeof window === 'undefined')
-        return null;
-    const params = new URLSearchParams((_a = window.location) === null || _a === void 0 ? void 0 : _a.search);
-    const cascadingEnabled = params.get('cascading') !== null;
-    if (cascadingEnabled) {
-        const rawParams = {};
-        params.forEach((value, key) => {
-            rawParams[key] = value;
-        });
-        return rawParams;
-    }
-    return null;
-};
-const watch = (httpClient, type, id, data) => __awaiter(void 0, void 0, void 0, function* () {
-    yield httpClient.connectionIdPromise;
-    // FIXME OL: remove this once cascading is enabled by default
-    const cascadingModeParams = getCascadingModeParams();
-    if (cascadingModeParams) {
-        return httpClient.doAxiosRequest('post', `/call/${type}/${id}/join`, data, {
-            params: Object.assign({}, cascadingModeParams),
-        });
-    }
-    return httpClient.post(`/call/${type}/${id}/join`, data);
-});
+ * @param httpClient the http client to use.
+ * @param type the type of the call.
+ * @param id the id of the call.
+ * @param data the data for the call.
+ */
 const join = (httpClient, type, id, data) => __awaiter(void 0, void 0, void 0, function* () {
-    const joinCallResponse = yield watch(httpClient, type, id, data);
-    const { call, edges, members } = joinCallResponse;
-    const { credentials } = yield getCallEdgeServer(httpClient, type, id, edges);
+    yield httpClient.connectionIdPromise;
+    const joinCallResponse = yield doJoin(httpClient, type, id, data);
+    const { call, credentials, members } = joinCallResponse;
     return {
         connectionConfig: toRtcConfiguration(credentials.ice_servers),
         sfuServer: credentials.server,
@@ -7474,18 +7360,31 @@ const join = (httpClient, type, id, data) => __awaiter(void 0, void 0, void 0, f
         members,
     };
 });
-const getCallEdgeServer = (httpClient, type, id, edges) => __awaiter(void 0, void 0, void 0, function* () {
-    const data = {
-        latency_measurements: yield measureLatencyToEdges(edges),
-    };
+const doJoin = (httpClient, type, id, data) => __awaiter(void 0, void 0, void 0, function* () {
+    const location = yield getLocationHint();
+    const request = Object.assign(Object.assign({}, data), { location });
     // FIXME OL: remove this once cascading is enabled by default
     const cascadingModeParams = getCascadingModeParams();
     if (cascadingModeParams) {
-        return httpClient.doAxiosRequest('post', `/call/${type}/${id}/get_edge_server`, data, {
+        return httpClient.doAxiosRequest('post', `/call/${type}/${id}/join`, request, {
             params: Object.assign({}, cascadingModeParams),
         });
     }
-    return httpClient.post(`/call/${type}/${id}/get_edge_server`, data);
+    return httpClient.post(`/call/${type}/${id}/join`, request);
+});
+const getLocationHint = () => __awaiter(void 0, void 0, void 0, function* () {
+    const hintURL = `https://hint.stream-io-video.com/`;
+    try {
+        const response = yield fetch(hintURL, {
+            method: 'HEAD',
+        });
+        const awsPop = response.headers.get('x-amz-cf-pop') || 'ERR';
+        return awsPop.substring(0, 3); // AMS1-P2 -> AMS
+    }
+    catch (e) {
+        console.error(`Failed to get location hint from ${hintURL}`, e);
+        return 'ERR';
+    }
 });
 const toRtcConfiguration = (config) => {
     if (!config || config.length === 0)
@@ -7499,6 +7398,21 @@ const toRtcConfiguration = (config) => {
     };
     return rtcConfig;
 };
+const getCascadingModeParams = () => {
+    var _a;
+    if (typeof window === 'undefined')
+        return null;
+    const params = new URLSearchParams((_a = window.location) === null || _a === void 0 ? void 0 : _a.search);
+    const cascadingEnabled = params.get('cascading') !== null;
+    if (cascadingEnabled) {
+        const rawParams = {};
+        params.forEach((value, key) => {
+            rawParams[key] = value;
+        });
+        return rawParams;
+    }
+    return null;
+};
 
 /**
  * Creates a new StatsReporter instance that collects metrics about the ongoing call and reports them to the state store
@@ -8058,6 +7972,8 @@ class Call {
             const response = yield this.streamClient.get(this.streamClientBasePath);
             this.state.setMetadata(response.call);
             this.state.setMembers(response.members);
+            this.watching = true;
+            this.clientStore.registerCall(this);
             return response;
         });
         /**
@@ -8072,21 +7988,6 @@ class Call {
             }
             this.state.setMetadata(response.call);
             this.state.setMembers(response.members);
-            this.clientStore.registerCall(this);
-            return response;
-        });
-        /**
-         * Will start to watch for call related WebSocket events, but it won't join the call. If you watch a call you'll be notified about WebSocket events, but you won't be able to publish your audio and video, and you won't be able to see and hear others. You won't show up in the list of joined participants.
-         *
-         * @param data
-         */
-        this.watch = (data) => __awaiter(this, void 0, void 0, function* () {
-            const response = yield watch(this.streamClient, this.type, this.id, data);
-            this.state.setMetadata(response.call);
-            this.state.setMembers(response.members);
-            if ((data === null || data === void 0 ? void 0 : data.ring) && !this.ringing) {
-                this.ringingSubject.next(true);
-            }
             this.watching = true;
             this.clientStore.registerCall(this);
             return response;
@@ -8117,14 +8018,17 @@ class Call {
             this.clientStore.registerCall(this);
             // FIXME OL: remove once cascading is implemented
             let sfuUrl = call.sfuServer.url;
+            let sfuWsUrl = call.sfuServer.ws_endpoint;
             if (typeof window !== 'undefined' &&
                 window.location &&
                 window.location.search) {
                 const params = new URLSearchParams(window.location.search);
                 const sfuUrlParam = params.get('sfuUrl');
                 sfuUrl = sfuUrlParam || call.sfuServer.url;
+                const sfuWsUrlParam = params.get('sfuWsUrl');
+                sfuWsUrl = sfuWsUrlParam || call.sfuServer.ws_endpoint;
             }
-            const sfuClient = (this.sfuClient = new StreamSfuClient(this.dispatcher, sfuUrl, call.token));
+            const sfuClient = (this.sfuClient = new StreamSfuClient(this.dispatcher, sfuUrl, sfuWsUrl, call.token));
             /**
              * A closure which hides away the re-connection logic.
              */
@@ -10567,7 +10471,7 @@ class StreamClient {
     }
     getUserAgent() {
         return (this.userAgent ||
-            `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${"0.0.1-alpha.136"}`);
+            `stream-video-javascript-client-${this.node ? 'node' : 'browser'}-${"0.0.1-alpha.138"}`);
     }
     setUserAgent(userAgent) {
         this.userAgent = userAgent;