@addmaple/brotli 0.1.0 → 0.2.0

package/dist/core.d.ts

@@ -9,4 +9,8 @@ export function free(ptr: number, len: number): void;
 export function compress_level_1(input: WasmInput): Promise<Uint8Array>;
 export function compress_level_4(input: WasmInput): Promise<Uint8Array>;
 export function compress_level_6(input: WasmInput): Promise<Uint8Array>;
-export function compress_level_9(input: WasmInput): Promise<Uint8Array>;
+export function compress_level_9(input: WasmInput): Promise<Uint8Array>;
+export function decompress_brotli(input: WasmInput): Promise<Uint8Array>;
+export function create_brotli_compressor(input: WasmInput): Promise<number>;
+export function compress_brotli_chunk(input: WasmInput): Promise<Uint8Array>;
+export function destroy_brotli_compressor(input: WasmInput): Promise<Uint8Array>;

package/dist/core.js

@@ -18,7 +18,7 @@ export function wasmExports() {
 let _ready = null;
 export function registerInit(fn) { _initFn = fn; }
 
-async function ensureReady() {
+export async function ensureReady() {
   if (_ready) return _ready;
   if (!_initFn) throw new Error("init not registered");
   _ready = _initFn();
@@ -42,7 +42,42 @@ function toBytes(input) {
   if (input instanceof Uint8Array) return input;
   if (ArrayBuffer.isView(input)) return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
   if (input instanceof ArrayBuffer) return new Uint8Array(input);
-  throw new TypeError("Expected a TypedArray or ArrayBuffer");
+  if (typeof input === 'string') return new TextEncoder().encode(input);
+  throw new TypeError("Expected a TypedArray, ArrayBuffer, or string");
+}
+
+function scalarSize(type) {
+  switch (type) {
+    case "f64": return 8;
+    case "f32":
+    case "i32":
+    case "u32": return 4;
+    case "i16":
+    case "u16": return 2;
+    case "i8":
+    case "u8": return 1;
+    case "u32_array":
+    case "i32_array":
+    case "f32_array": return 1024 * 1024;
+    default: return 0;
+  }
+}
+
+function decodeReturn(view, type) {
+  switch (type) {
+    case "f32": return view.getFloat32(0, true);
+    case "f64": return view.getFloat64(0, true);
+    case "i32": return view.getInt32(0, true);
+    case "u32": return view.getUint32(0, true);
+    case "i16": return view.getInt16(0, true);
+    case "u16": return view.getUint16(0, true);
+    case "i8": return view.getInt8(0);
+    case "u8": return view.getUint8(0);
+    case "u32_array": return new Uint32Array(view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength));
+    case "i32_array": return new Int32Array(view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength));
+    case "f32_array": return new Float32Array(view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength));
+    default: return null;
+  }
 }
 
 function callWasm(abi, input, outLen, reuse) {
@@ -138,3 +173,64 @@ async function compress_level_9(input) {
   return result;
 }
 export { compress_level_9 };
+
+async function decompress_brotli(input) {
+  await ensureReady();
+  const view = toBytes(input);
+  const len = view.byteLength;
+  const outLen = len * 100;
+  const { outPtr, written, inPtr } = callWasm("decompress_brotli", view, outLen, null);
+
+  const result = memoryU8().slice(outPtr, outPtr + written);
+
+  free(inPtr, len);
+  free(outPtr, outLen);
+  return result;
+}
+export { decompress_brotli };
+
+async function create_brotli_compressor(input) {
+  await ensureReady();
+  const view = toBytes(input);
+  const len = view.byteLength;
+  const outLen = (scalarSize('u32') || 4);
+  const { outPtr, written, inPtr } = callWasm("create_brotli_compressor", view, outLen, null);
+
+  const retView = new DataView(memoryU8().buffer, outPtr, written);
+  const result = decodeReturn(retView, "u32");
+
+  free(inPtr, len);
+  free(outPtr, outLen);
+  return result;
+}
+export { create_brotli_compressor };
+
+async function compress_brotli_chunk(input) {
+  await ensureReady();
+  const view = toBytes(input);
+  const len = view.byteLength;
+  const outLen = len + 1024;
+  const { outPtr, written, inPtr } = callWasm("compress_brotli_chunk", view, outLen, null);
+
+  const result = memoryU8().slice(outPtr, outPtr + written);
+
+  free(inPtr, len);
+  free(outPtr, outLen);
+  return result;
+}
+export { compress_brotli_chunk };
+
+async function destroy_brotli_compressor(input) {
+  await ensureReady();
+  const view = toBytes(input);
+  const len = view.byteLength;
+  const outLen = Math.max(len, 4);
+  const { outPtr, written, inPtr } = callWasm("destroy_brotli_compressor", view, outLen, null);
+
+  const result = memoryU8().slice(outPtr, outPtr + written);
+
+  free(inPtr, len);
+  free(outPtr, outLen);
+  return result;
+}
+export { destroy_brotli_compressor };

package/dist/custom.js

@@ -1,4 +1,30 @@
-import { compress_level_1, compress_level_4, compress_level_6, compress_level_9, wasmExports } from './core.js';
+import { 
+  compress_level_1, 
+  compress_level_4, 
+  compress_level_6, 
+  compress_level_9,
+  decompress_brotli,
+  create_brotli_compressor,
+  compress_brotli_chunk,
+  destroy_brotli_compressor,
+  wasmExports,
+  alloc,
+  free,
+  memoryU8,
+  ensureReady
+} from './core.js';
+
+function toBytes(input) {
+  if (input instanceof Uint8Array) return input;
+  if (ArrayBuffer.isView(input)) return new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+  if (input instanceof ArrayBuffer) return new Uint8Array(input);
+  if (typeof input === 'string') return new TextEncoder().encode(input);
+  throw new TypeError("Expected a TypedArray, ArrayBuffer, or string");
+}
+
+// ============================================================================
+// One-shot Compression API
+// ============================================================================
 
 export async function compress(input, options = {}) {
   const level = options.level ?? 9;
@@ -13,8 +39,143 @@ export async function compress(input, options = {}) {
   }
 }
 
+// ============================================================================
+// One-shot Decompression API
+// ============================================================================
+
+export async function decompress(input) {
+  await ensureReady();
+  
+  const view = toBytes(input);
+  const len = view.byteLength;
+  
+  // Start with a reasonable estimate (100x compressed size)
+  let outLen = Math.max(len * 100, 65536);
+  
+  const inPtr = alloc(len);
+  let outPtr = alloc(outLen);
+  
+  try {
+    memoryU8().set(view, inPtr);
+    let written = wasmExports().decompress_brotli(inPtr, len, outPtr, outLen);
+    
+    // Negative value means we need more space
+    if (written < 0) {
+      const neededLen = -written;
+      free(outPtr, outLen);
+      outLen = neededLen;
+      outPtr = alloc(outLen);
+      
+      // Retry with correct size
+      written = wasmExports().decompress_brotli(inPtr, len, outPtr, outLen);
+      
+      if (written < 0) {
+        throw new Error('Decompression failed after resize');
+      }
+    }
+    
+    const result = memoryU8().slice(outPtr, outPtr + written);
+    free(inPtr, len);
+    free(outPtr, outLen);
+    return result;
+  } catch (error) {
+    free(inPtr, len);
+    free(outPtr, outLen);
+    throw new Error(`Decompression failed: ${error.message}`);
+  }
+}
+
+// ============================================================================
+// Streaming Compression API
+// ============================================================================
+
+export class StreamingCompressor {
+  constructor(options = {}) {
+    this._initPromise = ensureReady();
+    this.level = options.level ?? 6;
+    this.handle = null;
+  }
+
+  async _ensureInit() {
+    await this._initPromise;
+    if (this.handle === null) {
+      this.handle = wasmExports().create_brotli_compressor(this.level);
+      if (this.handle === 0) {
+        throw new Error('Failed to create compressor');
+      }
+    }
+  }
+
+  async compressChunk(input, finish = false) {
+    await this._ensureInit();
+    if (this.handle === 0) {
+      throw new Error('Compressor already destroyed');
+    }
+    
+    const view = toBytes(input);
+    const len = view.byteLength;
+    const outLen = len + 1024;
+    
+    const inPtr = alloc(len);
+    const outPtr = alloc(outLen);
+    
+    try {
+      memoryU8().set(view, inPtr);
+      const written = wasmExports().compress_brotli_chunk(this.handle, inPtr, len, outPtr, outLen, finish ? 1 : 0);
+      
+      if (written < 0) {
+        if (written === -1) {
+          throw new Error('Compression failed');
+        } else {
+          // Negative value indicates needed buffer size
+          free(outPtr, outLen);
+          const neededLen = -written;
+          const newOutPtr = alloc(neededLen);
+          memoryU8().set(view, inPtr);
+          const retryWritten = wasmExports().compress_brotli_chunk(this.handle, inPtr, len, newOutPtr, neededLen, finish ? 1 : 0);
+          if (retryWritten < 0) {
+            free(newOutPtr, neededLen);
+            throw new Error('Compression failed after retry');
+          }
+          const result = memoryU8().slice(newOutPtr, newOutPtr + retryWritten);
+          free(newOutPtr, neededLen);
+          free(inPtr, len);
+          if (finish) this.handle = 0;
+          return result;
+        }
+      }
+      
+      if (written === 0) {
+        free(outPtr, outLen);
+        free(inPtr, len);
+        return new Uint8Array(0);
+      }
+      
+      const result = memoryU8().slice(outPtr, outPtr + written);
+      free(outPtr, outLen);
+      free(inPtr, len);
+      
+      if (finish) this.handle = 0;
+      return result;
+    } catch (error) {
+      free(outPtr, outLen);
+      free(inPtr, len);
+      throw new Error(`Compression failed: ${error.message}`);
+    }
+  }
+
+  async destroy() {
+    await this._initPromise;
+    if (this.handle !== 0 && this.handle !== null) {
+      wasmExports().destroy_brotli_compressor(this.handle);
+      this.handle = 0;
+    }
+  }
+}
+
 export function getLoadedVariant() {
   return 'lite';
 }
 
 export { wasmExports };
+