@arkiv-network/sdk 0.1.2-dev.0 → 0.1.3-dev.1

package/src/utils/compression.ts

@@ -1,48 +1,99 @@
 // src/utils/compression.ts
 
 import type { BrotliWasmType } from "brotli-wasm"
-import brotliPromise from "brotli-wasm"
 
+// Detect if we're in Node.js environment
+const isNode = typeof process !== "undefined" && process.versions?.node != null
+
+let zlib: typeof import("zlib") | null = null
 let brotli: BrotliWasmType | null = null
 
-async function getBrotli(): Promise<BrotliWasmType | null> {
-  if (brotli) return brotli
+// Lazy load zlib (Node.js only)
+async function getZlib(): Promise<typeof import("zlib") | null> {
+  if (!isNode) return null
 
-  if (!brotliPromise) {
-    console.debug("Importing brotli-wasm")
+  if (!zlib) {
     try {
-      console.debug("Importing brotli-wasm as module")
-      brotli = await brotliPromise
-      console.debug("Imported brotli-wasm as module", brotli)
+      zlib = await import("zlib")
     } catch (error) {
-      console.error("Error importing brotli-wasm", error)
-      console.debug("Importing brotli-wasm as require")
-      brotli = require("brotli-wasm")
-      console.debug("Imported brotli-wasm as require", brotli)
+      console.error("Error importing zlib", error)
+      return null
     }
   }
+  return zlib
+}
+
+// Lazy load brotli-wasm (browser/fallback)
+async function getBrotli(): Promise<BrotliWasmType | null> {
+  if (brotli) return brotli
+
+  try {
+    const brotliModule = await import("brotli-wasm")
+    brotli = brotliModule.default || brotliModule
+  } catch (error) {
+    console.error("Error importing brotli-wasm", error)
+    return null
+  }
 
-  brotli = await brotliPromise
   return brotli
 }
 
 export async function compress(data: Uint8Array): Promise<Uint8Array> {
-  const brotliInstance = await getBrotli()
   console.debug(`Compressing data (size: ${data.length})`)
+
+  // Try Node.js zlib first (if available)
+  if (isNode) {
+    const zlibModule = await getZlib()
+    if (zlibModule) {
+      try {
+        // zlib.brotliCompress expects Buffer, returns Buffer
+        const buffer = Buffer.from(data)
+        const compressed = zlibModule.brotliCompressSync(buffer)
+        const result = new Uint8Array(compressed)
+        console.debug(`Brotli compressed with zlib (size: ${result.length})`)
+        return result
+      } catch (error) {
+        console.warn("zlib compression failed, falling back to brotli-wasm", error)
+      }
+    }
+  }
+
+  // Fallback to brotli-wasm (browser or if zlib fails)
+  const brotliInstance = await getBrotli()
   if (!brotliInstance) {
     console.warn("Brotli instance not found, not compressing data")
     return data
   }
+
   const brotliCompressed = brotliInstance.compress(data)
-  console.debug(`Brotli compressed data (size: ${brotliCompressed.length})`)
+  console.debug(`Brotli compressed with wasm (size: ${brotliCompressed.length})`)
   return brotliCompressed
 }
 
 export async function decompress(data: Uint8Array): Promise<Uint8Array> {
+  // Try Node.js zlib first (if available)
+  if (isNode) {
+    const zlibModule = await getZlib()
+    if (zlibModule) {
+      try {
+        // zlib.brotliDecompress expects Buffer, returns Buffer
+        const buffer = Buffer.from(data)
+        const decompressed = zlibModule.brotliDecompressSync(buffer)
+        const result = new Uint8Array(decompressed)
+        console.debug(`Brotli decompressed with zlib (size: ${result.length})`)
+        return result
+      } catch (error) {
+        console.warn("zlib decompression failed, falling back to brotli-wasm", error)
+      }
+    }
+  }
+
+  // Fallback to brotli-wasm (browser or if zlib fails)
   const brotliInstance = await getBrotli()
   if (!brotliInstance) {
     console.warn("Brotli instance not found, not decompressing data")
     return data
   }
+
   return brotliInstance.decompress(data)
 }