@rerun-io/web-viewer 0.16.0-rc.2 → 0.16.0-rc.3

package/README.md

@@ -41,7 +41,7 @@ viewer.stop();
 ```
 
 The `rrd` in the snippet above should be a URL pointing to either:
-- A hosted `.rrd` file, such as <https://app.rerun.io/version/0.16.0-rc.2/examples/dna.rrd>
+- A hosted `.rrd` file, such as <https://app.rerun.io/version/0.16.0-rc.3/examples/dna.rrd>
 - A WebSocket connection to the SDK opened via the [`serve`](https://www.rerun.io/docs/reference/sdk-operating-modes#serve) API
 
 If `rrd` is not set, the Viewer will display the same welcome screen as <https://app.rerun.io>.

package/index.d.ts

@@ -18,8 +18,13 @@ declare module '@rerun-io/web-viewer' {
 		 * The viewer must have been started via `WebViewer.start`.
 		 *
 		 * @param rrd URLs to `.rrd` files or WebSocket connections to our SDK.
+		 * @param options
+		 *        - follow_if_http: Whether Rerun should open the resource in "Following" mode when streaming
+		 *        from an HTTP url. Defaults to `false`. Ignored for non-HTTP URLs.
 		 */
-		open(rrd: string | string[]): void;
+		open(rrd: string | string[], options?: {
+			follow_if_http?: boolean;
+		}): void;
 		/**
 		 * Close a recording.
 		 *
@@ -129,8 +134,18 @@ declare module '@rerun-io/web-viewer/re_viewer.js' {
 	panic_message(): string | undefined;
 
 	panic_callstack(): string | undefined;
-
-	add_receiver(url: string): void;
+  /**
+  * Add a new receiver streaming data from the given url.
+  *
+  * If `follow_if_http` is `true`, and the url is an HTTP source, the viewer will open the stream
+  * in `Following` mode rather than `Playing` mode.
+  *
+  * Websocket streams are always opened in `Following` mode.
+  *
+  * It is an error to open a channel twice with the same id.
+  * 
+  */
+	add_receiver(url: string, follow_if_http?: boolean): void;
 
 	remove_receiver(url: string): void;
   /**

package/index.d.ts.map

@@ -18,5 +18,5 @@
 		null,
 		null
 	],
-	"mappings": ";cAuBaA,SAASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAkJTC,UAAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBC/JPC,SAASA;;eAGZC,wBAAwBA;;;;;;;;;;;;;;eAuBxBC,kBAAkBA;;;;;;;;;;eAmBlBC,oBAAoBA;;;;;;;;eAapBC,SAASA"
+	"mappings": ";cAuBaA,SAASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAqJTC,UAAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBClKPC,SAASA;;eAGZC,wBAAwBA;;;;;;;;;;;;;;eAuBxBC,kBAAkBA;;;;;;;;;;eAmBlBC,oBAAoBA;;;;;;;;eAapBC,SAASA"
 }

package/index.js

@@ -88,14 +88,17 @@ export class WebViewer {
    * @see {WebViewer.start}
    *
    * @param {string | string[]} rrd URLs to `.rrd` files or WebSocket connections to our SDK.
+   * @param {{ follow_if_http?: boolean }} options
+   *        - follow_if_http: Whether Rerun should open the resource in "Following" mode when streaming
+   *        from an HTTP url. Defaults to `false`. Ignored for non-HTTP URLs.
    */
-  open(rrd) {
+  open(rrd, options = {}) {
     if (!this.#handle) {
       throw new Error(`attempted to open \`${rrd}\` in a stopped viewer`);
     }
     const urls = Array.isArray(rrd) ? rrd : [rrd];
     for (const url of urls) {
-      this.#handle.add_receiver(url);
+      this.#handle.add_receiver(url, options.follow_if_http);
       if (this.#handle.has_panicked()) {
         throw new Error(`Web viewer crashed: ${this.#handle.panic_message()}`);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rerun-io/web-viewer",
-  "version": "0.16.0-rc.2",
+  "version": "0.16.0-rc.3",
   "description": "Embed the Rerun web viewer in your app",
   "licenses": [
     {

package/re_viewer.d.ts

@@ -99,9 +99,18 @@ export class WebHandle {
 */
   panic_callstack(): string | undefined;
 /**
+* Add a new receiver streaming data from the given url.
+*
+* If `follow_if_http` is `true`, and the url is an HTTP source, the viewer will open the stream
+* in `Following` mode rather than `Playing` mode.
+*
+* Websocket streams are always opened in `Following` mode.
+*
+* It is an error to open a channel twice with the same id.
 * @param {string} url
+* @param {boolean | undefined} [follow_if_http]
 */
-  add_receiver(url: string): void;
+  add_receiver(url: string, follow_if_http?: boolean): void;
 /**
 * @param {string} url
 */

package/re_viewer_bg.js

@@ -10,20 +10,6 @@ heap.push(undefined, null, true, false);
 
 function getObject(idx) { return heap[idx]; }
 
-let heap_next = heap.length;
-
-function dropObject(idx) {
-    if (idx < 132) return;
-    heap[idx] = heap_next;
-    heap_next = idx;
-}
-
-function takeObject(idx) {
-    const ret = getObject(idx);
-    dropObject(idx);
-    return ret;
-}
-
 let WASM_VECTOR_LEN = 0;
 
 let cachedUint8Memory0 = null;
@@ -103,6 +89,20 @@ function getInt32Memory0() {
     return cachedInt32Memory0;
 }
 
+let heap_next = heap.length;
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
 const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder;
 
 let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true });
@@ -222,11 +222,11 @@ function makeMutClosure(arg0, arg1, dtor, f) {
     return real;
 }
 function __wbg_adapter_32(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures__invoke0_mut__hfd827e3087c96cca(arg0, arg1);
+    wasm._dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h5b1e3d49288de840(arg0, arg1);
 }
 
 function __wbg_adapter_35(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures__invoke1_mut__hff75729e8d8e3a19(arg0, arg1, addHeapObject(arg2));
+    wasm._dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h0ff5e9949b0a21b5(arg0, arg1, addHeapObject(arg2));
 }
 
 function __wbg_adapter_38(arg0, arg1) {
@@ -264,7 +264,7 @@ function __wbg_adapter_55(arg0, arg1, arg2) {
 }
 
 function __wbg_adapter_64(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures__invoke1_mut__hb75772ddcede7981(arg0, arg1, addHeapObject(arg2));
+    wasm.wasm_bindgen__convert__closures__invoke1_mut__h1825eb34d949dd69(arg0, arg1, addHeapObject(arg2));
 }
 
 function __wbg_adapter_67(arg0, arg1, arg2) {
@@ -568,12 +568,21 @@ export class WebHandle {
         }
     }
     /**
+    * Add a new receiver streaming data from the given url.
+    *
+    * If `follow_if_http` is `true`, and the url is an HTTP source, the viewer will open the stream
+    * in `Following` mode rather than `Playing` mode.
+    *
+    * Websocket streams are always opened in `Following` mode.
+    *
+    * It is an error to open a channel twice with the same id.
     * @param {string} url
+    * @param {boolean | undefined} [follow_if_http]
     */
-    add_receiver(url) {
+    add_receiver(url, follow_if_http) {
         const ptr0 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.webhandle_add_receiver(this.__wbg_ptr, ptr0, len0);
+        wasm.webhandle_add_receiver(this.__wbg_ptr, ptr0, len0, isLikeNone(follow_if_http) ? 0xFFFFFF : follow_if_http ? 1 : 0);
     }
     /**
     * @param {string} url
@@ -622,10 +631,6 @@ export class WebHandle {
     }
 }
 
-export function __wbindgen_object_drop_ref(arg0) {
-    takeObject(arg0);
-};
-
 export function __wbindgen_string_get(arg0, arg1) {
     const obj = getObject(arg1);
     const ret = typeof(obj) === 'string' ? obj : undefined;
@@ -635,6 +640,10 @@ export function __wbindgen_string_get(arg0, arg1) {
     getInt32Memory0()[arg0 / 4 + 0] = ptr1;
 };
 
+export function __wbindgen_object_drop_ref(arg0) {
+    takeObject(arg0);
+};
+
 export function __wbindgen_string_new(arg0, arg1) {
     const ret = getStringFromWasm0(arg0, arg1);
     return addHeapObject(ret);
@@ -687,12 +696,12 @@ export function __wbindgen_number_get(arg0, arg1) {
     getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
 };
 
-export function __wbg_new_d5a0639d318f3757() {
+export function __wbg_new_83d61ca77025d6af() {
     const ret = new Error();
     return addHeapObject(ret);
 };
 
-export function __wbg_stack_859d1c42605c06b3(arg0, arg1) {
+export function __wbg_stack_829a27f9f3a30c38(arg0, arg1) {
     const ret = getObject(arg1).stack;
     const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
@@ -3429,19 +3438,19 @@ export function __wbg_changedTouches_9667f17739458e92(arg0) {
     return addHeapObject(ret);
 };
 
-export function __wbg_warn_87b3c0ae4e05c120(arg0, arg1) {
+export function __wbg_warn_92f59beb04c257f2(arg0, arg1) {
     console.warn(getStringFromWasm0(arg0, arg1));
 };
 
-export function __wbg_info_6e8225925ec4693f(arg0, arg1) {
+export function __wbg_info_27e26841845d55b3(arg0, arg1) {
     console.info(getStringFromWasm0(arg0, arg1));
 };
 
-export function __wbg_debug_37a00352e443b759(arg0, arg1) {
+export function __wbg_debug_5cc8027c90c78a2d(arg0, arg1) {
     console.debug(getStringFromWasm0(arg0, arg1));
 };
 
-export function __wbg_trace_81472c9cac70d900(arg0, arg1) {
+export function __wbg_trace_9557117b3153e5eb(arg0, arg1) {
     console.trace(getStringFromWasm0(arg0, arg1));
 };
 
@@ -3811,78 +3820,78 @@ export function __wbindgen_memory() {
     return addHeapObject(ret);
 };
 
-export function __wbindgen_closure_wrapper1580(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 497, __wbg_adapter_32);
+export function __wbindgen_closure_wrapper2558(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 723, __wbg_adapter_32);
     return addHeapObject(ret);
 };
 
-export function __wbindgen_closure_wrapper1582(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 497, __wbg_adapter_35);
+export function __wbindgen_closure_wrapper2560(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 723, __wbg_adapter_35);
     return addHeapObject(ret);
 };
 
-export function __wbindgen_closure_wrapper3463(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 1119, __wbg_adapter_38);
+export function __wbindgen_closure_wrapper3473(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 1131, __wbg_adapter_38);
     return addHeapObject(ret);
 };
 
-export function __wbindgen_closure_wrapper6544(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 2476, __wbg_adapter_41);
+export function __wbindgen_closure_wrapper6554(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 2488, __wbg_adapter_41);
     return addHeapObject(ret);
 };
 
-export function __wbindgen_closure_wrapper6546(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 2476, __wbg_adapter_44);
+export function __wbindgen_closure_wrapper6556(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 2488, __wbg_adapter_44);
     return addHeapObject(ret);
 };
 
-export function __wbindgen_closure_wrapper6548(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 2476, __wbg_adapter_47);
+export function __wbindgen_closure_wrapper6558(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 2488, __wbg_adapter_47);
     return addHeapObject(ret);
 };
 
-export function __wbindgen_closure_wrapper19264(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 7700, __wbg_adapter_50);
+export function __wbindgen_closure_wrapper19260(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 7715, __wbg_adapter_50);
     return addHeapObject(ret);
 };
 
-export function __wbindgen_closure_wrapper19266(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 7700, __wbg_adapter_50);
+export function __wbindgen_closure_wrapper19262(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 7715, __wbg_adapter_50);
     return addHeapObject(ret);
 };
 
-export function __wbindgen_closure_wrapper25792(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 10791, __wbg_adapter_55);
+export function __wbindgen_closure_wrapper25789(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 10806, __wbg_adapter_55);
     return addHeapObject(ret);
 };
 
-export function __wbindgen_closure_wrapper25794(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 10791, __wbg_adapter_55);
+export function __wbindgen_closure_wrapper25791(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 10806, __wbg_adapter_55);
     return addHeapObject(ret);
 };
 
-export function __wbindgen_closure_wrapper25796(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 10791, __wbg_adapter_55);
+export function __wbindgen_closure_wrapper25793(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 10806, __wbg_adapter_55);
     return addHeapObject(ret);
 };
 
-export function __wbindgen_closure_wrapper25798(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 10791, __wbg_adapter_55);
+export function __wbindgen_closure_wrapper25795(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 10806, __wbg_adapter_55);
     return addHeapObject(ret);
 };
 
-export function __wbindgen_closure_wrapper32378(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 13734, __wbg_adapter_64);
+export function __wbindgen_closure_wrapper31528(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 13191, __wbg_adapter_64);
     return addHeapObject(ret);
 };
 
-export function __wbindgen_closure_wrapper32729(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 13901, __wbg_adapter_67);
+export function __wbindgen_closure_wrapper32725(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 13916, __wbg_adapter_67);
     return addHeapObject(ret);
 };
 
-export function __wbindgen_closure_wrapper32791(arg0, arg1, arg2) {
-    const ret = makeMutClosure(arg0, arg1, 13914, __wbg_adapter_70);
+export function __wbindgen_closure_wrapper32787(arg0, arg1, arg2) {
+    const ret = makeMutClosure(arg0, arg1, 13929, __wbg_adapter_70);
     return addHeapObject(ret);
 };
 

package/re_viewer_bg.wasm.d.ts

@@ -8,7 +8,7 @@ export function webhandle_destroy(a: number): void;
 export function webhandle_has_panicked(a: number): number;
 export function webhandle_panic_message(a: number, b: number): void;
 export function webhandle_panic_callstack(a: number, b: number): void;
-export function webhandle_add_receiver(a: number, b: number, c: number): void;
+export function webhandle_add_receiver(a: number, b: number, c: number, d: number): void;
 export function webhandle_remove_receiver(a: number, b: number, c: number): void;
 export function webhandle_open_channel(a: number, b: number, c: number, d: number, e: number): void;
 export function webhandle_close_channel(a: number, b: number, c: number): void;
@@ -79,8 +79,8 @@ export function intounderlyingsource_cancel(a: number): void;
 export function __wbindgen_malloc(a: number, b: number): number;
 export function __wbindgen_realloc(a: number, b: number, c: number, d: number): number;
 export const __wbindgen_export_2: WebAssembly.Table;
-export function wasm_bindgen__convert__closures__invoke0_mut__hfd827e3087c96cca(a: number, b: number): void;
-export function wasm_bindgen__convert__closures__invoke1_mut__hff75729e8d8e3a19(a: number, b: number, c: number): void;
+export function _dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h5b1e3d49288de840(a: number, b: number): void;
+export function _dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h0ff5e9949b0a21b5(a: number, b: number, c: number): void;
 export function _dyn_core__ops__function__FnMut_____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__he3e77c8746920ad8(a: number, b: number): void;
 export function wasm_bindgen__convert__closures__invoke1_mut__h545ec82ded2d9534(a: number, b: number, c: number): void;
 export function wasm_bindgen__convert__closures__invoke0_mut__h3e523de377ad9304(a: number, b: number): void;
@@ -88,7 +88,7 @@ export function __wbindgen_add_to_stack_pointer(a: number): number;
 export function wasm_bindgen__convert__closures__invoke0_mut__h48ee5bf1e8dab96d(a: number, b: number, c: number): void;
 export function wasm_bindgen__convert__closures__invoke1_mut__h389a8557fc3a6c1d(a: number, b: number, c: number): void;
 export function _dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__h4415f29ff9ffe1e6(a: number, b: number, c: number): void;
-export function wasm_bindgen__convert__closures__invoke1_mut__hb75772ddcede7981(a: number, b: number, c: number): void;
+export function wasm_bindgen__convert__closures__invoke1_mut__h1825eb34d949dd69(a: number, b: number, c: number): void;
 export function wasm_bindgen__convert__closures__invoke1_mut__h74463477a347a8fe(a: number, b: number, c: number): void;
 export function _dyn_core__ops__function__FnMut__A____Output___R_as_wasm_bindgen__closure__WasmClosure___describe__invoke__haf670f9b2e2edd2a(a: number, b: number, c: number): void;
 export function __wbindgen_free(a: number, b: number, c: number): void;