feature: add support for slicing above i32 where u64 can safely be coerced to f64 losslessly

src/error.rs

@@ -42,3 +42,20 @@ impl From<reqwest::Error> for ParquetWasmError {
         Self::HTTPError(Box::new(err))
     }
 }
+
+impl From<ParquetWasmError> for ParquetError {
+    fn from(value: ParquetWasmError) -> Self {
+        // We cannot use the `External` variant as it requires that `ParquetWasmError`
+        // be Send, which `JsValue` is not
+        match value {
+            ParquetWasmError::ArrowError(arrow_error) => {
+                ParquetError::ArrowError(arrow_error.to_string())
+            }
+            ParquetWasmError::ParquetError(parquet_error) => *parquet_error,
+            #[cfg(feature = "async")]
+            ParquetWasmError::HTTPError(error) => ParquetError::External(error),
+            ParquetWasmError::PlatformSupportError(x) => ParquetError::General(x),
+            e => ParquetError::General(e.to_string()),
+        }
+    }
+}

src/reader_async.rs

@@ -7,9 +7,11 @@ use crate::common::fetch::{
 use crate::error::{Result, WasmResult};
 use crate::read_options::{JsReaderOptions, ReaderOptions};
 use crate::reader::cast_metadata_view_types;
+use crate::utils;
 use futures::channel::oneshot;
 use futures::future::BoxFuture;
 use object_store::coalesce_ranges;
+use parquet::errors::ParquetError;
 use std::ops::Range;
 use std::sync::Arc;
 use wasm_bindgen::prelude::*;
@@ -320,21 +322,26 @@ impl WrappedFile {
         Self { inner, size }
     }
 
-    pub async fn get_bytes(&mut self, range: Range<u64>) -> Vec<u8> {
+    pub async fn get_bytes(&mut self, range: Range<u64>) -> crate::error::Result<Vec<u8>> {
         use js_sys::Uint8Array;
         use wasm_bindgen_futures::JsFuture;
         let (sender, receiver) = oneshot::channel();
         let file = self.inner.clone();
         spawn_local(async move {
-            let subset_blob = file
-                .slice_with_i32_and_i32(
-                    range.start.try_into().unwrap(),
-                    range.end.try_into().unwrap(),
-                )
-                .unwrap();
-            let buf = JsFuture::from(subset_blob.array_buffer()).await.unwrap();
-            let out_vec = Uint8Array::new_with_byte_offset(&buf, 0).to_vec();
-            sender.send(out_vec).unwrap();
+            if range.start <= utils::MAX_EXACT_INTEGER && range.end <= utils::MAX_EXACT_INTEGER {
+                let subset_blob = file
+                    .slice_with_f64_and_f64(range.start as f64, range.end as f64)
+                    .unwrap();
+                let buf = JsFuture::from(subset_blob.array_buffer()).await.unwrap();
+                let out_vec = Uint8Array::new_with_byte_offset(&buf, 0).to_vec();
+                sender.send(Ok(out_vec)).unwrap();
+            } else {
+                sender
+                    .send(Err(crate::error::ParquetWasmError::PlatformSupportError(
+                        format!("{range:?} is too large to convert into a Blob slice"),
+                    )))
+                    .unwrap();
+            };
         });
 
         receiver.await.unwrap()
@@ -347,11 +354,14 @@ async fn get_bytes_file(
 ) -> parquet::errors::Result<Bytes> {
     let (sender, receiver) = oneshot::channel();
     spawn_local(async move {
-        let result: Bytes = file.get_bytes(range).await.into();
+        let result = file
+            .get_bytes(range)
+            .await
+            .map(Bytes::from)
+            .map_err(ParquetError::from);
         sender.send(result).unwrap()
     });
-    let data = receiver.await.unwrap();
-    Ok(data)
+    receiver.await.unwrap()
 }
 
 #[derive(Debug, Clone)]
@@ -375,11 +385,14 @@ impl AsyncFileReader for JsFileReader {
             let (sender, receiver) = oneshot::channel();
             let mut file = self.file.clone();
             spawn_local(async move {
-                let result: Bytes = file.get_bytes(range).await.into();
+                let result = file
+                    .get_bytes(range)
+                    .await
+                    .map(Bytes::from)
+                    .map_err(ParquetError::from);
                 sender.send(result).unwrap()
             });
-            let data = receiver.await.unwrap();
-            Ok(data)
+            receiver.await.unwrap()
         }
         .boxed()
     }

src/utils.rs

@@ -1,5 +1,7 @@
 use wasm_bindgen::prelude::*;
 
+pub const MAX_EXACT_INTEGER: u64 = (1u64 << f64::MANTISSA_DIGITS) - 1;
+
 /// Call this function at least once during initialization to get better error
 // messages if the underlying Rust code ever panics (creates uncaught errors).
 #[cfg(feature = "console_error_panic_hook")]