index.js

import { readFile } from "fs/promises";
import { fileURLToPath } from "url";
import { dirname, join } from "path";

const __dirname = dirname(fileURLToPath(import.meta.url));
const distDir = join(__dirname, "dist");

/**
 * Load and instantiate a WASM module
 * @param {string} filename - Name of the wasm file in dist/
 * @returns {Promise<WebAssembly.Instance>}
 */
async function loadWasm(filename) {
  const wasmPath = join(distDir, filename);
  const wasmBuffer = await readFile(wasmPath);
  const wasmModule = await WebAssembly.compile(wasmBuffer);
  return WebAssembly.instantiate(wasmModule);
}

// =============================================================================
// Low-level instance factories (return raw WASM exports)
// =============================================================================

/**
 * Create a raw WASM instance for complex FFT (f64).
 * @returns {Promise<import('./index.js').FFTExports>}
 */
export async function createFFTInstance() {
  const instance = await loadWasm("fft_combined.wasm");
  return /** @type {import('./index.js').FFTExports} */ (instance.exports);
}

/**
 * Create a raw WASM instance for complex FFT (f32).
 * @returns {Promise<import('./index.js').FFTf32Exports>}
 */
export async function createFFTf32Instance() {
  const instance = await loadWasm("fft_stockham_f32_dual.wasm");
  return /** @type {import('./index.js').FFTf32Exports} */ (instance.exports);
}

/**
 * Create a raw WASM instance for real FFT (f64).
 * @returns {Promise<import('./index.js').RFFTExports>}
 */
export async function createRFFTInstance() {
  const instance = await loadWasm("fft_real_combined.wasm");
  return /** @type {import('./index.js').RFFTExports} */ (instance.exports);
}

/**
 * Create a raw WASM instance for real FFT (f32).
 * @returns {Promise<import('./index.js').RFFTf32Exports>}
 */
export async function createRFFTf32Instance() {
  const instance = await loadWasm("fft_real_f32_dual.wasm");
  return /** @type {import('./index.js').RFFTf32Exports} */ (instance.exports);
}

// =============================================================================
// High-level context factories (recommended)
// =============================================================================

/**
 * Create a high-level complex FFT context (f64).
 * @param {number} size - FFT size (must be power of 2)
 * @returns {Promise<import('./index.js').FFT>}
 */
export async function createFFT(size) {
  const exports = await createFFTInstance();
  exports.precompute_twiddles(size);

  const bufferLength = size * 2;

  return {
    size,
    exports,
    getInputBuffer() {
      return new Float64Array(exports.memory.buffer, 0, bufferLength);
    },
    getOutputBuffer() {
      return new Float64Array(exports.memory.buffer, 0, bufferLength);
    },
    forward() {
      exports.fft(size);
    },
    inverse() {
      exports.ifft(size);
    },
  };
}

/**
 * Create a high-level complex FFT context (f32).
 * @param {number} size - FFT size (must be power of 2)
 * @returns {Promise<import('./index.js').FFTf32>}
 */
export async function createFFTf32(size) {
  const exports = await createFFTf32Instance();
  exports.precompute_twiddles(size);

  const bufferLength = size * 2;

  return {
    size,
    exports,
    getInputBuffer() {
      return new Float32Array(exports.memory.buffer, 0, bufferLength);
    },
    getOutputBuffer() {
      return new Float32Array(exports.memory.buffer, 0, bufferLength);
    },
    forward() {
      exports.fft(size);
    },
    inverse() {
      exports.ifft(size);
    },
  };
}

/**
 * Create a high-level real FFT context (f64).
 * @param {number} size - FFT size (must be power of 2)
 * @returns {Promise<import('./index.js').RFFT>}
 */
export async function createRFFT(size) {
  const exports = await createRFFTInstance();
  exports.precompute_rfft_twiddles(size);

  const outputLength = (size / 2 + 1) * 2;

  return {
    size,
    exports,
    getInputBuffer() {
      return new Float64Array(exports.memory.buffer, 0, size);
    },
    getOutputBuffer() {
      return new Float64Array(exports.memory.buffer, 0, outputLength);
    },
    forward() {
      exports.rfft(size);
    },
    inverse() {
      exports.irfft(size);
    },
  };
}

/**
 * Create a high-level real FFT context (f32).
 * @param {number} size - FFT size (must be power of 2)
 * @returns {Promise<import('./index.js').RFFTf32>}
 */
export async function createRFFTf32(size) {
  const exports = await createRFFTf32Instance();
  exports.precompute_rfft_twiddles(size);

  const outputLength = (size / 2 + 1) * 2;

  return {
    size,
    exports,
    getInputBuffer() {
      return new Float32Array(exports.memory.buffer, 0, size);
    },
    getOutputBuffer() {
      return new Float32Array(exports.memory.buffer, 0, outputLength);
    },
    forward() {
      exports.rfft(size);
    },
    inverse() {
      exports.irfft(size);
    },
  };
}