@perspective-dev/client 4.0.1 → 4.1.1

package/dist/wasm/perspective-js.wasm.d.ts

@@ -62,14 +62,26 @@ export const view_remove_delete: (a: number, b: number) => number;
 export const view_collapse: (a: number, b: number) => number;
 export const view_expand: (a: number, b: number) => number;
 export const view_set_depth: (a: number, b: number) => number;
+export const __wbg_jsvirtualdataslice_free: (a: number, b: number) => void;
+export const jsvirtualdataslice_new: () => number;
+export const jsvirtualdataslice_setCol: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+export const jsvirtualdataslice_setStringCol: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const jsvirtualdataslice_setIntegerCol: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const jsvirtualdataslice_setFloatCol: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const jsvirtualdataslice_setBooleanCol: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const jsvirtualdataslice_setDatetimeCol: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const __wbg_jsvirtualserver_free: (a: number, b: number) => void;
+export const jsvirtualserver_new: (a: number, b: number) => void;
+export const jsvirtualserver_handleRequest: (a: number, b: number, c: number) => number;
 export const init: () => void;
 export const proxysession_new: (a: number, b: number) => number;
-export const __wbindgen_export_0: (a: number, b: number) => number;
-export const __wbindgen_export_1: (a: number, b: number, c: number, d: number) => number;
-export const __wbindgen_export_2: (a: number) => void;
-export const __wbindgen_export_3: (a: number, b: number, c: number) => void;
-export const __wbindgen_export_4: WebAssembly.Table;
+export const __wasm_bindgen_func_elem_553: (a: number, b: number) => number;
+export const __wasm_bindgen_func_elem_123: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_3515: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_3500: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_5070: (a: number, b: number, c: number, d: number) => void;
+export const __wbindgen_export: (a: number, b: number) => number;
+export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_export3: (a: number) => void;
+export const __wbindgen_export4: (a: number, b: number, c: number) => void;
 export const __wbindgen_add_to_stack_pointer: (a: number) => number;
-export const __wbindgen_export_5: (a: number, b: number) => number;
-export const __wbindgen_export_6: (a: number, b: number, c: number) => void;
-export const __wbindgen_export_7: (a: number, b: number, c: number, d: number) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@perspective-dev/client",
-  "version": "4.0.1",
+  "version": "4.1.1",
   "description": "",
   "repository": {
     "type": "git",
@@ -23,6 +23,7 @@
       "types": "./dist/esm/perspective.node.d.ts",
       "default": "./dist/esm/perspective.node.js"
     },
+    "./virtual_servers/*": "./dist/esm/virtual_servers/*",
     "./dist/*": "./dist/*",
     "./src/*": "./src/*",
     "./test/*": "./test/*",
@@ -47,6 +48,7 @@
     "@perspective-dev/esbuild-plugin": "",
     "@perspective-dev/metadata": "",
     "@perspective-dev/test": "",
+    "@duckdb/duckdb-wasm": "^1.30.0",
     "@playwright/experimental-ct-react": "=1.52.0",
     "@playwright/test": "=1.52.0",
     "@types/node": ">=22",
@@ -58,6 +60,7 @@
     "moment": "^2.30.1",
     "typedoc": "^0.28.7",
     "typescript": ">=5 <6",
+    "web-worker": "1.4.1",
     "zx": ">=8 <9"
   },
   "scripts": {

package/src/rust/client.rs

@@ -116,8 +116,17 @@ impl ProxySession {
 #[wasm_bindgen]
 #[derive(TryFromJsValue, Clone)]
 pub struct Client {
-    pub(crate) close: Option<Function>,
     pub(crate) client: perspective_client::Client,
+    pub(crate) close: Option<Function>,
+}
+
+impl From<perspective_client::Client> for Client {
+    fn from(client: perspective_client::Client) -> Self {
+        Client {
+            client,
+            close: None,
+        }
+    }
 }
 
 impl PartialEq for Client {
@@ -132,6 +141,8 @@ impl PartialEq for Client {
 #[derivative(Clone(bound = ""))]
 struct JsReconnect<I>(Arc<dyn Fn(I) -> js_sys::Promise>);
 
+// This type is not thread safe, but the JavaScript environment does not allow
+// threading.
 unsafe impl<I> Send for JsReconnect<I> {}
 unsafe impl<I> Sync for JsReconnect<I> {}
 
@@ -414,10 +425,8 @@ impl Client {
     /// const tables = await client.get_hosted_table_names();
     /// ```
     #[wasm_bindgen]
-    pub async fn get_hosted_table_names(&self) -> ApiResult<JsValue> {
-        Ok(JsValue::from_serde_ext(
-            &self.client.get_hosted_table_names().await?,
-        )?)
+    pub async fn get_hosted_table_names(&self) -> ApiResult<Vec<String>> {
+        Ok(self.client.get_hosted_table_names().await?)
     }
 
     /// Register a callback which is invoked whenever [`Client::table`] (on this

package/src/rust/lib.rs

@@ -30,6 +30,8 @@ mod table;
 mod table_data;
 pub mod utils;
 mod view;
+#[cfg(target_arch = "wasm32")]
+mod virtual_server;
 
 #[cfg(feature = "export-init")]
 use wasm_bindgen::prelude::*;
@@ -37,11 +39,14 @@ use wasm_bindgen::prelude::*;
 pub use crate::client::Client;
 pub use crate::table::*;
 pub use crate::table_data::*;
+#[cfg(target_arch = "wasm32")]
+pub use crate::virtual_server::*;
 
 #[cfg(feature = "export-init")]
 #[wasm_bindgen(typescript_custom_section)]
 const TS_APPEND_CONTENT: &'static str = r#"
 export type * from "../../src/ts/ts-rs/ViewWindow.d.ts";
+export type * from "../../src/ts/ts-rs/ColumnType.d.ts";
 export type * from "../../src/ts/ts-rs/ColumnWindow.d.ts";
 export type * from "../../src/ts/ts-rs/TableInitOptions.d.ts";
 export type * from "../../src/ts/ts-rs/ViewConfigUpdate.d.ts";
@@ -49,9 +54,14 @@ export type * from "../../src/ts/ts-rs/ViewOnUpdateResp.d.ts";
 export type * from "../../src/ts/ts-rs/OnUpdateOptions.d.ts";
 export type * from "../../src/ts/ts-rs/UpdateOptions.d.ts";
 export type * from "../../src/ts/ts-rs/DeleteOptions.d.ts";
+export type * from "../../src/ts/ts-rs/Scalar.d.ts";
 export type * from "../../src/ts/ts-rs/SystemInfo.d.ts";
+export type * from "../../src/ts/ts-rs/SortDir.d.ts";
+export type * from "../../src/ts/ts-rs/Filter.d.ts";
+export type * from "../../src/ts/ts-rs/ViewConfig.d.ts";
 
 import type {ColumnWindow} from "../../src/ts/ts-rs/ColumnWindow.d.ts";
+import type {ColumnType} from "../../src/ts/ts-rs/ColumnType.d.ts";
 import type {ViewWindow} from "../../src/ts/ts-rs/ViewWindow.d.ts";
 import type {TableInitOptions} from "../../src/ts/ts-rs/TableInitOptions.d.ts";
 import type {ViewConfigUpdate} from "../../src/ts/ts-rs/ViewConfigUpdate.d.ts";
@@ -65,6 +75,6 @@ import type {SystemInfo} from "../../src/ts/ts-rs/SystemInfo.d.ts";
 #[cfg(feature = "export-init")]
 #[wasm_bindgen]
 pub fn init() {
-    console_error_panic_hook::set_once();
+    // console_error_panic_hook::set_once();
     utils::set_global_logging();
 }

package/src/rust/table.rs

@@ -57,7 +57,8 @@ impl Table {
 extern "C" {
     // TODO Fix me
     #[wasm_bindgen(typescript_type = "\
-        string | ArrayBuffer | Record<string, unknown[]> | Record<string, unknown>[]")]
+        string | ArrayBuffer | Record<string, unknown[]> | Record<string, unknown>[] | \
+                                      Record<string, ColumnType>")]
     pub type JsTableInitData;
 
     #[wasm_bindgen(typescript_type = "ViewConfigUpdate")]
@@ -179,7 +180,7 @@ impl Table {
     ///
     /// Note that all [`Table`] columns are _nullable_, regardless of the data
     /// type.
-    #[wasm_bindgen]
+    #[wasm_bindgen(unchecked_return_type = "Record<string, ColumnType>")]
     pub async fn schema(&self) -> ApiResult<JsValue> {
         let schema = self.0.schema().await?;
         Ok(JsValue::from_serde_ext(&schema)?)

package/src/rust/table_data.rs

@@ -15,10 +15,11 @@ use js_sys::{Array, ArrayBuffer, Function, JSON, Object, Reflect, Uint8Array};
 use perspective_client::config::ColumnType;
 use perspective_client::{TableData, TableReadFormat, UpdateData};
 use wasm_bindgen::convert::TryFromJsValue;
+use wasm_bindgen::intern;
 use wasm_bindgen::prelude::*;
 
 use crate::apierror;
-use crate::utils::{ApiError, ApiResult, JsValueSerdeExt, ToApiError};
+use crate::utils::{ApiError, ApiResult, JsValueSerdeExt};
 pub use crate::view::*;
 
 #[ext]
@@ -27,10 +28,10 @@ impl Vec<(String, ColumnType)> {
         Ok(Object::keys(value.unchecked_ref())
             .iter()
             .map(|x| -> Result<_, JsValue> {
-                let key = x.as_string().into_apierror()?;
+                let key = x.as_string().expect("Not string??");
                 let val = Reflect::get(value, &x)?
                     .as_string()
-                    .into_apierror()?
+                    .expect("Y no string?")
                     .into_serde_ext()?;
 
                 Ok((key, val))
@@ -44,8 +45,10 @@ pub(crate) impl TableData {
     fn from_js_value(value: &JsValue, format: Option<TableReadFormat>) -> ApiResult<TableData> {
         if let Some(result) = UpdateData::from_js_value_partial(value, format)? {
             Ok(result.into())
-        } else if value.is_instance_of::<Object>() && Reflect::has(value, &"__get_model".into())? {
-            let val = Reflect::get(value, &"__get_model".into())?
+        } else if value.is_instance_of::<Object>()
+            && Reflect::has(value, &intern("__get_model").into())?
+        {
+            let val = Reflect::get(value, &intern("__get_model").into())?
                 .dyn_into::<Function>()?
                 .call0(value)?;
 
@@ -69,7 +72,9 @@ pub(crate) impl TableData {
             if all_strings() {
                 Ok(TableData::Schema(Vec::from_js_value(value)?))
             } else if all_arrays() {
-                let json = JSON::stringify(value)?.as_string().into_apierror()?;
+                let json = JSON::stringify(value)?
+                    .as_string()
+                    .expect("STRINGIFY_ARRAY??");
                 Ok(UpdateData::JsonColumns(json).into())
             } else {
                 Err(apierror!(TableError(value.clone())))
@@ -91,20 +96,20 @@ pub(crate) impl UpdateData {
         } else if value.is_string() {
             match format {
                 None | Some(TableReadFormat::Csv) => {
-                    Ok(Some(UpdateData::Csv(value.as_string().into_apierror()?)))
+                    Ok(Some(UpdateData::Csv(value.as_string().expect("Csv????"))))
                 },
                 Some(TableReadFormat::JsonString) => Ok(Some(UpdateData::JsonRows(
-                    value.as_string().into_apierror()?,
+                    value.as_string().expect("JSON???"),
                 ))),
                 Some(TableReadFormat::ColumnsString) => Ok(Some(UpdateData::JsonColumns(
-                    value.as_string().into_apierror()?,
+                    value.as_string().expect("ColumnString???"),
                 ))),
                 Some(TableReadFormat::Arrow) => Ok(Some(UpdateData::Arrow(
-                    value.as_string().into_apierror()?.into_bytes().into(),
+                    value.as_string().expect("Arrow???").into_bytes().into(),
+                ))),
+                Some(TableReadFormat::Ndjson) => Ok(Some(UpdateData::Ndjson(
+                    value.as_string().expect("Ndjson???"),
                 ))),
-                Some(TableReadFormat::Ndjson) => {
-                    Ok(Some(UpdateData::Ndjson(value.as_string().into_apierror()?)))
-                },
             }
         } else if value.is_instance_of::<ArrayBuffer>() {
             let uint8array = Uint8Array::new(value);
@@ -138,7 +143,7 @@ pub(crate) impl UpdateData {
                 None | Some(TableReadFormat::Arrow) => Ok(Some(UpdateData::Arrow(slice.into()))),
             }
         } else if value.is_instance_of::<Array>() {
-            let rows = JSON::stringify(value)?.as_string().into_apierror()?;
+            let rows = JSON::stringify(value)?.as_string().expect("STRINGIFY??");
             Ok(Some(UpdateData::JsonRows(rows)))
         } else {
             Ok(None)

package/src/rust/utils/browser.rs

@@ -32,8 +32,4 @@ pub mod global {
     pub fn navigator() -> web_sys::Navigator {
         window().navigator()
     }
-
-    pub fn clipboard() -> web_sys::Clipboard {
-        navigator().clipboard()
-    }
 }

package/src/rust/utils/console_logger.rs

@@ -18,6 +18,7 @@ use tracing::field::{Field, Visit};
 use tracing_subscriber::Layer;
 use tracing_subscriber::layer::Context;
 use tracing_subscriber::registry::LookupSpan;
+use wasm_bindgen::intern;
 use wasm_bindgen::prelude::*;
 
 use crate::utils::*;
@@ -111,8 +112,8 @@ impl<'a> tracing::Metadata<'a> {
             level.web_logger_4()(
                 &format!("%c {level} %c {origin}%c {msg} ").into(),
                 &level.web_log_color().into(),
-                &"color: gray; font-style: italic".into(),
-                &"color: inherit".into(),
+                &intern("color: gray; font-style: italic").into(),
+                &intern("color: inherit").into(),
             );
         } else {
             level.web_logger_1()(&format!("{origin} {msg}").into());

package/src/rust/utils/errors.rs

@@ -16,6 +16,7 @@ use std::string::FromUtf8Error;
 
 use perspective_client::{ClientError, ExprValidationResult};
 use thiserror::*;
+use wasm_bindgen::intern;
 use wasm_bindgen::prelude::*;
 
 #[macro_export]
@@ -35,7 +36,7 @@ macro_rules! apierror {
 fn format_js_error(value: &JsValue) -> String {
     if let Some(err) = value.dyn_ref::<js_sys::Error>() {
         let msg = err.message().as_string().unwrap();
-        if let Ok(x) = js_sys::Reflect::get(value, &"stack".into()) {
+        if let Ok(x) = js_sys::Reflect::get(value, &intern("stack").into()) {
             format!("{}\n{}", msg, x.as_string().unwrap())
         } else {
             msg
@@ -108,15 +109,6 @@ pub enum ApiErrorType {
     #[error(transparent)]
     StdIoError(Rc<std::io::Error>),
 
-    #[error(transparent)]
-    RmpSerdeEncodeError(Rc<rmp_serde::encode::Error>),
-
-    #[error(transparent)]
-    RmpSerdeDecodeError(Rc<rmp_serde::decode::Error>),
-
-    #[error(transparent)]
-    Base64DecodeError(#[from] base64::DecodeError),
-
     #[error(transparent)]
     ChronoParseError(#[from] chrono::ParseError),
 }
@@ -146,9 +138,6 @@ impl ApiError {
             ApiErrorType::SerdeWasmBindgenError(_) => "[SerdeWasmBindgenError]",
             ApiErrorType::Utf8Error(_) => "[FromUtf8Error]",
             ApiErrorType::StdIoError(_) => "[StdIoError]",
-            ApiErrorType::RmpSerdeEncodeError(_) => "[RmpSerdeEncodeError]",
-            ApiErrorType::RmpSerdeDecodeError(_) => "[RmpSerdeDecodeError]",
-            ApiErrorType::Base64DecodeError(_) => "[Base64DecodeError]",
             ApiErrorType::ChronoParseError(_) => "[ChronoParseError]",
             ApiErrorType::ViewerPluginError(_) => "[ViewerPluginError]",
             ApiErrorType::JsRawError(_) => "[JsRawError]",
@@ -167,7 +156,7 @@ impl ApiError {
 
     /// This error's stacktrace from when it was constructed.
     pub fn stacktrace(&self) -> String {
-        js_sys::Reflect::get(&self.1.0, &"stack".into())
+        js_sys::Reflect::get(&self.1.0, &intern("stack").into())
             .unwrap()
             .as_string()
             .unwrap()
@@ -175,6 +164,8 @@ impl ApiError {
     }
 }
 
+// This type is not thread safe, but the JavaScript environment does not allow
+// threading.
 unsafe impl Send for ApiError {}
 unsafe impl Sync for ApiError {}
 
@@ -210,18 +201,6 @@ impl From<std::io::Error> for ApiError {
     }
 }
 
-impl From<rmp_serde::decode::Error> for ApiError {
-    fn from(value: rmp_serde::decode::Error) -> Self {
-        ApiErrorType::RmpSerdeDecodeError(Rc::new(value)).into()
-    }
-}
-
-impl From<rmp_serde::encode::Error> for ApiError {
-    fn from(value: rmp_serde::encode::Error) -> Self {
-        ApiErrorType::RmpSerdeEncodeError(Rc::new(value)).into()
-    }
-}
-
 impl From<Box<dyn std::error::Error>> for ApiError {
     fn from(value: Box<dyn std::error::Error>) -> Self {
         ApiErrorType::ExternalError(Rc::new(value)).into()
@@ -237,7 +216,10 @@ impl From<serde_json::Error> for ApiError {
 impl From<JsValue> for ApiError {
     fn from(err: JsValue) -> Self {
         if err.is_instance_of::<js_sys::Error>() {
-            ApiErrorType::JsRawError(err.clone().unchecked_into()).into()
+            ApiError(
+                ApiErrorType::JsRawError(err.clone().unchecked_into()),
+                JsBackTrace(Rc::new(err.unchecked_into())),
+            )
         } else {
             apierror!(JsError(err))
         }
@@ -263,7 +245,7 @@ pub trait ToApiError<T> {
 
 impl<T> ToApiError<T> for Option<T> {
     fn into_apierror(self) -> ApiResult<T> {
-        self.ok_or_else(|| "Unwrap on None".into())
+        self.ok_or_else(|| intern("Unwrap on None").into())
     }
 }
 

package/src/rust/utils/futures.rs

@@ -46,6 +46,12 @@ where
     pub fn new<U: Future<Output = ApiResult<T>> + 'static>(x: U) -> Self {
         Self(Box::pin(x))
     }
+
+    pub fn new_throttled<U: Future<Output = ApiResult<T>> + 'static>(x: U) -> ApiFuture<()> {
+        ApiFuture::<()>(Box::pin(
+            async move { x.await.ignore_view_delete().map(|_| ()) },
+        ))
+    }
 }
 
 impl<T> ApiFuture<T>
@@ -87,7 +93,7 @@ where
         future_to_promise(async move {
             match fut.0.await.ignore_view_delete()? {
                 Some(x) => Ok(x).into_js_result(),
-                None => Ok::<_, JsValue>(()).into_js_result(),
+                None => Err("View not found".into()).into_js_result(),
             }
         })
     }
@@ -161,14 +167,14 @@ pub impl<T> Result<T, ApiError> {
     /// case (instead of whatever the `async` returns), which is helpful for
     /// detecting this condition when debugging.
     fn ignore_view_delete(self) -> Result<Option<T>, ApiError> {
-        self.map(|x| Some(x)).or_else(|x| match x.inner() {
+        self.map(|x| Some(x)).or_else(|err| match err.inner() {
             ApiErrorType::ClientError(ClientError::ViewNotFound) => Ok(None),
             ApiErrorType::JsRawError(..) | ApiErrorType::JsError(..)
-                if format!("{x}").contains("View not found") =>
+                if format!("{err}").contains("View not found") =>
             {
                 Ok(None)
             },
-            x => Err(x.clone().into()),
+            _ => Err(err),
         })
     }
 }

package/src/rust/utils/json.rs

@@ -106,8 +106,8 @@ macro_rules! json_internal {
 
     // Insert the current entry followed by trailing comma.
     (@object $object:ident [$($key:tt)+] ($value:expr) , $($rest:tt)*) => {
-        let k = js_intern::js_intern!($($key)+);
-        js_sys::Reflect::set(&$object, k, &$value).unwrap();
+        let k = JsValue::from(wasm_bindgen::intern($($key)+));
+        js_sys::Reflect::set(&$object, &k, &$value).unwrap();
         $crate::json_internal!(@object $object () ($($rest)*) ($($rest)*));
     };
 
@@ -118,8 +118,8 @@ macro_rules! json_internal {
 
     // Insert the last entry without trailing comma.
     (@object $object:ident [$($key:tt)+] ($value:expr)) => {
-        let k = js_intern::js_intern!($($key)+);
-        js_sys::Reflect::set(&$object, k, &$value).unwrap();
+        let k = JsValue::from(wasm_bindgen::intern($($key)+));
+        js_sys::Reflect::set(&$object, &k, &$value).unwrap();
     };
 
     // Next value is `null`.