zstd.ts

import type { Codec, CodecConstructor } from "./types.js";

type WasmModule = typeof import("../pkg/rumcodecs-wasm-node/rumcodecs_wasm.js");

const DEFAULT_CLEVEL = 1;
const MAX_CLEVEL = 22;

let wasmModule: Promise<WasmModule> | null = null;

async function getModule(): Promise<WasmModule> {
  if (!wasmModule) {
    wasmModule = import("../pkg/rumcodecs-wasm-node/rumcodecs_wasm.js");
  }
  return wasmModule;
}

interface ZstdConfig {
  level?: number;
}

const Zstd: CodecConstructor<ZstdConfig> = class Zstd implements Codec {
  public static codecId = "zstd";
  public static DEFAULT_CLEVEL = DEFAULT_CLEVEL;
  public static MAX_CLEVEL = MAX_CLEVEL;
  public level: number;

  constructor(level = DEFAULT_CLEVEL) {
    if (!Number.isInteger(level)) {
      throw Error(`Invalid level "${level}". Must be an integer.`);
    }
    this.level = level;
  }

  static fromConfig({ level }: ZstdConfig): Zstd {
    return new Zstd(level);
  }

  async encode(data: Uint8Array): Promise<Uint8Array> {
    let level = this.level;
    if (level <= 0) {
      level = DEFAULT_CLEVEL;
    }
    if (level > MAX_CLEVEL) {
      level = MAX_CLEVEL;
    }
    const m = await getModule();
    return m.zstd_compress(data, level);
  }

  async decode(data: Uint8Array, out?: Uint8Array): Promise<Uint8Array> {
    const m = await getModule();
    const result = m.zstd_decompress(data);
    // An empty result is how the WASM side reports failure, and a frame that
    // really does hold nothing looks identical. The frame header settles it:
    // only a frame declaring zero bytes may legitimately decode to nothing.
    // A frame carrying no declared size at all (`undefined`) cannot be told
    // apart, and erring toward an Error beats returning an untouched `out`.
    if (result.length === 0 && m.zstd_declared_content_size(data) !== 0) {
      throw new Error("Zstd decompression failed");
    }
    if (out !== undefined) {
      out.set(result);
      return out;
    }
    return result;
  }
};

export default Zstd;