@perspective-dev/client 4.4.1 → 4.5.0

package/dist/esm/perspective.node.d.ts

@@ -20,6 +20,18 @@ export declare function make_client(send_request: (buffer: Uint8Array) => Promis
 export declare function cwd_static_file_handler(request: http.IncomingMessage, response: http.ServerResponse<http.IncomingMessage>, assets?: string[], { debug }?: {
     debug?: boolean | undefined;
 }): Promise<void>;
+/**
+ * A simple Node `http`-based WebSocket adapter that exposes a
+ * `PerspectiveServer` over the wire.
+ *
+ * @remarks
+ *
+ * **Security.** `WebSocketServer` is a reference integration with no
+ * authentication, authorization, origin enforcement, or rate limiting, and
+ * is not safe to expose to untrusted networks — see
+ * [`SECURITY.md`](https://github.com/perspective-dev/perspective/blob/master/SECURITY.md)
+ * for the full threat model.
+ */
 export declare class WebSocketServer {
     _server: http.Server | any;
     _wss: HttpWebSocketServer;

package/dist/esm/perspective.node.js

@@ -64,6 +64,36 @@ var Client = class _Client {
       wasm.__wbindgen_add_to_stack_pointer(16);
     }
   }
+  /**
+   * Unsafely gets a [`View`] by raw ID, useful for JavaScript multi-threaded
+   * (via Web Worker) context where a standard `View` cannot otherwise be
+   * shared because its wrapper is not serializable.
+   *
+   * # Safety
+   *
+   * This method is unsafe because the lifetime of a [`View`] is bound to
+   * the [`Client`] which created it.
+   *
+   * The caller must guarantee that `entity_id` corresponds to a live
+   * [`crate::View`] on the connected server (obtained from another
+   * [`Client`]'s [`crate::View::get_name`] and forwarded across the
+   * serialization boundary).
+   *
+   * # JavaScript Examples
+   *
+   * ```javascript
+   * const view = client.__unsafe_open_view(name_from_main_thread);
+   * const cols = await view.to_columns();
+   * ```
+   * @param {string} entity_id
+   * @returns {View}
+   */
+  __unsafe_open_view(entity_id) {
+    const ptr0 = passStringToWasm0(entity_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.client___unsafe_open_view(this.__wbg_ptr, ptr0, len0);
+    return View.__wrap(ret);
+  }
   /**
    * Retrieves the names of all tables that this client has access to.
    *
@@ -1085,6 +1115,24 @@ var View = class _View {
     const ret = wasm.view___get_model(this.__wbg_ptr);
     return _View.__wrap(ret);
   }
+  /**
+   * @returns {string}
+   */
+  __unsafe_get_name() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.view___unsafe_get_name(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var v1 = getCachedStringFromWasm0(r0, r1);
+      if (r0 !== 0) {
+        wasm.__wbindgen_export4(r0, r1, 1);
+      }
+      return v1;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
   /**
    * Collapses the `group_by` row at `row_index`.
    * @param {number} row_index
@@ -1371,6 +1419,29 @@ var View = class _View {
     const ret = wasm.view_to_ndjson(this.__wbg_ptr, isLikeNone(window2) ? 0 : addHeapObject(window2));
     return takeObject(ret);
   }
+  /**
+   * Fetches columns from the [`View`] in Arrow format, decodes them, and
+   * passes typed array views to `callback`. All arrays are only valid for
+   * the duration of the callback — if `callback` returns a `Promise`, it
+   * is awaited before the backing Arrow buffer is released, so async
+   * callbacks may use the views for the full duration of the awaited
+   * work (e.g. across an `await requestAnimationFrame`-backed promise).
+   *
+   * # Arguments
+   *
+   * - `window` - Optional [`TypedArrayWindow`] controlling row/column
+   *   windowing and output options (e.g., `float32` mode).
+   * - `callback` - A JS function called with `(names: string[], values:
+   *   TypedArray[], validities: (Uint8Array|null)[], dictionaries:
+   *   (string[]|null)[]) => void | Promise<void>`.
+   * @param {TypedArrayWindow | null | undefined} window
+   * @param {Function} callback
+   * @returns {Promise<void>}
+   */
+  with_typed_arrays(window2, callback) {
+    const ret = wasm.view_with_typed_arrays(this.__wbg_ptr, isLikeNone(window2) ? 0 : addHeapObject(window2), addHeapObject(callback));
+    return takeObject(ret);
+  }
 };
 if (Symbol.dispose) View.prototype[Symbol.dispose] = View.prototype.free;
 var VirtualDataSlice = class _VirtualDataSlice {
@@ -1708,6 +1779,12 @@ function __wbg_get_imports() {
         return addHeapObject(ret);
       }, arguments);
     },
+    __wbg_call_41bedb84c3e5c0c9: function() {
+      return handleError(function(arg0, arg1, arg2, arg3, arg4, arg5) {
+        const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3), getObject(arg4), getObject(arg5));
+        return addHeapObject(ret);
+      }, arguments);
+    },
     __wbg_call_4708e0c13bdc8e95: function() {
       return handleError(function(arg0, arg1, arg2) {
         const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
@@ -1948,7 +2025,7 @@ function __wbg_get_imports() {
           const a = state0.a;
           state0.a = 0;
           try {
-            return __wasm_bindgen_func_elem_10784(a, state0.b, arg02, arg12);
+            return __wasm_bindgen_func_elem_11006(a, state0.b, arg02, arg12);
           } finally {
             state0.a = a;
           }
@@ -1976,6 +2053,10 @@ function __wbg_get_imports() {
       const ret = new Function(v0);
       return addHeapObject(ret);
     },
+    __wbg_new_with_length_1763c527b2923202: function(arg0) {
+      const ret = new Array(arg0 >>> 0);
+      return addHeapObject(ret);
+    },
     __wbg_next_3482f54c49e8af19: function() {
       return handleError(function(arg0) {
         const ret = getObject(arg0).next();
@@ -2108,11 +2189,11 @@ function __wbg_get_imports() {
       console.warn(getObject(arg0));
     },
     __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-      const ret = makeClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_838, __wasm_bindgen_func_elem_1727);
+      const ret = makeClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_860, __wasm_bindgen_func_elem_1768);
       return addHeapObject(ret);
     },
     __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-      const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_3915, __wasm_bindgen_func_elem_3932);
+      const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_4015, __wasm_bindgen_func_elem_4032);
       return addHeapObject(ret);
     },
     __wbindgen_cast_0000000000000003: function(arg0) {
@@ -2129,20 +2210,36 @@ function __wbg_get_imports() {
       return addHeapObject(ret);
     },
     __wbindgen_cast_0000000000000006: function(arg0, arg1) {
+      const ret = getArrayF32FromWasm0(arg0, arg1);
+      return addHeapObject(ret);
+    },
+    __wbindgen_cast_0000000000000007: function(arg0, arg1) {
+      const ret = getArrayF64FromWasm0(arg0, arg1);
+      return addHeapObject(ret);
+    },
+    __wbindgen_cast_0000000000000008: function(arg0, arg1) {
+      const ret = getArrayI32FromWasm0(arg0, arg1);
+      return addHeapObject(ret);
+    },
+    __wbindgen_cast_0000000000000009: function(arg0, arg1) {
+      const ret = getArrayU32FromWasm0(arg0, arg1);
+      return addHeapObject(ret);
+    },
+    __wbindgen_cast_000000000000000a: function(arg0, arg1) {
       const ret = getArrayU8FromWasm0(arg0, arg1);
       return addHeapObject(ret);
     },
-    __wbindgen_cast_0000000000000007: function(arg0) {
+    __wbindgen_cast_000000000000000b: function(arg0) {
       const ret = BigInt.asUintN(64, arg0);
       return addHeapObject(ret);
     },
-    __wbindgen_cast_0000000000000008: function(arg0, arg1) {
+    __wbindgen_cast_000000000000000c: function(arg0, arg1) {
       var v0 = getArrayJsValueFromWasm0(arg0, arg1).slice();
       wasm.__wbindgen_export4(arg0, arg1 * 4, 4);
       const ret = v0;
       return addHeapObject(ret);
     },
-    __wbindgen_cast_0000000000000009: function(arg0, arg1) {
+    __wbindgen_cast_000000000000000d: function(arg0, arg1) {
       var v0 = getArrayU8FromWasm0(arg0, arg1).slice();
       wasm.__wbindgen_export4(arg0, arg1 * 1, 1);
       const ret = v0;
@@ -2161,15 +2258,15 @@ function __wbg_get_imports() {
     "./perspective-js.wasm_bg.js": import0
   };
 }
-function __wasm_bindgen_func_elem_1727(arg0, arg1) {
-  const ret = wasm.__wasm_bindgen_func_elem_1727(arg0, arg1);
+function __wasm_bindgen_func_elem_1768(arg0, arg1) {
+  const ret = wasm.__wasm_bindgen_func_elem_1768(arg0, arg1);
   return takeObject(ret);
 }
-function __wasm_bindgen_func_elem_3932(arg0, arg1, arg2) {
-  wasm.__wasm_bindgen_func_elem_3932(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_4032(arg0, arg1, arg2) {
+  wasm.__wasm_bindgen_func_elem_4032(arg0, arg1, addHeapObject(arg2));
 }
-function __wasm_bindgen_func_elem_10784(arg0, arg1, arg2, arg3) {
-  wasm.__wasm_bindgen_func_elem_10784(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+function __wasm_bindgen_func_elem_11006(arg0, arg1, arg2, arg3) {
+  wasm.__wasm_bindgen_func_elem_11006(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
 }
 var ClientFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
 }, unregister: () => {
@@ -2273,6 +2370,18 @@ function dropObject(idx) {
   heap[idx] = heap_next;
   heap_next = idx;
 }
+function getArrayF32FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+function getArrayF64FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+function getArrayI32FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getInt32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
 function getArrayJsValueFromWasm0(ptr, len) {
   ptr = ptr >>> 0;
   const mem = getDataViewMemory0();
@@ -2282,6 +2391,10 @@ function getArrayJsValueFromWasm0(ptr, len) {
   }
   return result;
 }
+function getArrayU32FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
 function getArrayU8FromWasm0(ptr, len) {
   ptr = ptr >>> 0;
   return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
@@ -2300,10 +2413,38 @@ function getDataViewMemory0() {
   }
   return cachedDataViewMemory0;
 }
+var cachedFloat32ArrayMemory0 = null;
+function getFloat32ArrayMemory0() {
+  if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+    cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
+  }
+  return cachedFloat32ArrayMemory0;
+}
+var cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+  if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+    cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+  }
+  return cachedFloat64ArrayMemory0;
+}
+var cachedInt32ArrayMemory0 = null;
+function getInt32ArrayMemory0() {
+  if (cachedInt32ArrayMemory0 === null || cachedInt32ArrayMemory0.byteLength === 0) {
+    cachedInt32ArrayMemory0 = new Int32Array(wasm.memory.buffer);
+  }
+  return cachedInt32ArrayMemory0;
+}
 function getStringFromWasm0(ptr, len) {
   ptr = ptr >>> 0;
   return decodeText(ptr, len);
 }
+var cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+  if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+    cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+  }
+  return cachedUint32ArrayMemory0;
+}
 var cachedUint8ArrayMemory0 = null;
 function getUint8ArrayMemory0() {
   if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
@@ -2433,6 +2574,10 @@ function __wbg_finalize_init(instance, module) {
   wasm = instance.exports;
   wasmModule = module;
   cachedDataViewMemory0 = null;
+  cachedFloat32ArrayMemory0 = null;
+  cachedFloat64ArrayMemory0 = null;
+  cachedInt32ArrayMemory0 = null;
+  cachedUint32ArrayMemory0 = null;
   cachedUint8ArrayMemory0 = null;
   return wasm;
 }
@@ -2640,8 +2785,8 @@ async function decode_api_responses(core, ptr, callback) {
         messages.getInt32(i * 16 + 8, true),
         messages.getInt32(i * 16 + 12, true)
       ] : [
-        messages.getInt32(i * 12, true),
-        messages.getInt32(i * 12 + 4, true),
+        messages.getUint32(i * 12, true),
+        messages.getUint32(i * 12 + 4, true),
         messages.getInt32(i * 12 + 8, true)
       ];
       const data = new Uint8Array(
@@ -3017,7 +3162,7 @@ var CONTENT_TYPES = {
   ".wasm": "application/wasm",
   ".svg": "image/svg+xml"
 };
-async function cwd_static_file_handler(request, response, assets = ["./"], { debug = true } = {}) {
+async function cwd_static_file_handler(request, response, assets = ["./"], { debug = false } = {}) {
   let url2 = request.url?.split(/[\?\#]/)[0].replace(/@[\^~]?\d+.[\d\*]*.[\d\*]*/, "") || "/";
   if (url2 === "/") {
     url2 = "/index.html";