test.js

import { test } from 'node:test'
import assert from 'node:assert'
import { createRequire, register } from 'node:module'
import convert, { parse, detect, stringify, sampleRate } from './index.js'
import AudioBuffer from 'audio-buffer'

const eq = (a, b) => assert.deepStrictEqual([...a], b)

// === Existing convert tests ===

test('float32 LE → int16 BE', () => {
	let buf = Buffer.alloc(8)
	buf.writeFloatLE(1.0, 0)
	buf.writeFloatLE(-0.5, 4)

	let out = convert(buf, 'float32 le', 'int16 be')
	let raw = Buffer.from(out.buffer)

	assert.equal(raw.readInt16BE(0), 32767)
	assert.equal(raw.readInt16BE(2), -16384)
})

test('endianness swap', () => {
	let out = convert(new Float32Array([1, -0.5]), 'float32 le', 'be')
	let raw = Buffer.from(out.buffer)

	assert.equal(raw.readFloatBE(0), 1.0)
	assert.equal(raw.readFloatBE(4), -0.5)
})

test('format string markers', () => {
	let out = convert(new Uint8Array([0, 255, 255, 0, 0, 255]), 'interleaved', 'float32 planar')
	eq(out, [-1, 127 / 128, -1, 127 / 128, -1, 127 / 128])   // uint8: (v − 128) / 128
})

test('unknown token throws', () => {
	assert.throws(() => convert([0, 0, 0, 0], 'float32 xx'))
})

// int → float divides by 2^(bits−1), as ffmpeg (libswresample: s16 · 1/(1<<15)), libsndfile and Web Audio's
// decodeAudioData do: 0 stays 0.0 and float → int (× 2^(bits−1), rounded, clipped) returns every code. The
// former int → float map spanned max − min (65535): +0.5 LSB of DC, silence read as 1.5e-5, and int16 0 came
// back as 1 (every code ≥ 0 moved up by one).
test('int → float → int is the identity; 0 is 0.0; x = v / 2^(bits−1)', () => {
	for (let [dtype, C, bits, signed] of [['int8', Int8Array, 8, true], ['uint8', Uint8Array, 8, false], ['int16', Int16Array, 16, true], ['uint16', Uint16Array, 16, false], ['int32', Int32Array, 32, true]]) {
		let lo = signed ? -(2 ** (bits - 1)) : 0, hi = signed ? 2 ** (bits - 1) - 1 : 2 ** bits - 1, mid = signed ? 0 : 2 ** (bits - 1)
		let codes = C.from([lo, lo + 1, mid - 1, mid, mid + 1, hi - 1, hi])
		let f = convert(codes, dtype, 'float64')
		eq(Array.from(f), Array.from(codes, v => (v - mid) / 2 ** (bits - 1)))
		eq(Array.from(convert(f, 'float64', dtype)), Array.from(codes))
	}
})

test('float32 → int16/int8/uint16', () => {
	eq(convert(new Float32Array([1, 1, -1, -1]), 'float32', 'int16'), [32767, 32767, -32768, -32768])
	eq(convert(new Float32Array([1, 1, -1, -1]), 'float32', 'int8'), [127, 127, -128, -128])
	eq(convert(new Float32Array([1, 1, -1, -1]), 'float32', 'uint16'), [65535, 65535, 0, 0])
})

test('interleave', () => {
	eq(convert(new Uint8Array([0, 2, 4, 6, 1, 3, 5, 7]), 'planar', 'interleaved'), [0, 1, 2, 3, 4, 5, 6, 7])
})

test('deinterleave', () => {
	let out = convert(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7]), { interleaved: true }, { interleaved: false })
	eq(out, [0, 2, 4, 6, 1, 3, 5, 7])
	assert.ok(out instanceof Uint8Array)
})

test('array output', () => {
	let out = convert(new Uint8Array([0, 255, 0, 255, 0, 255, 0, 255]), { interleaved: true }, 'array planar')
	assert.deepStrictEqual(out, [-1, -1, -1, -1, 127 / 128, 127 / 128, 127 / 128, 127 / 128])
	assert.ok(Array.isArray(out))
})

test('arraybuffer output', () => {
	let out = convert(new Uint8Array([0, 255, 0, 255, 0, 255, 0, 255]), { interleaved: true }, 'arraybuffer planar')
	assert.ok(out instanceof ArrayBuffer)
})

test('speaker test — deinterleave + type conversion', () => {
	eq(convert(new Float32Array([-1, 0, 1, 0]),
		{ type: 'float32', interleaved: false, channels: 2 },
		{ type: 'int16', interleaved: true }
	), [-32768, 32767, 0, 0])

	eq(convert(new Float32Array([-1, 0, 1, 0]),
		{ dtype: 'float32', interleaved: false, channels: 2 },
		{ dtype: 'int16', interleaved: true }
	), [-32768, 32767, 0, 0])
})

test('auto-detect source format', () => {
	eq(convert(new Float32Array([-1, 0, 1, 0]),
		{ type: 'int16', interleaved: true }
	), [-32768, 32767, 0, 0])

	eq(convert(new Uint8Array([0, 255]), 'uint16'), [0, 65535])
})

test('AudioBuffer input', () => {
	let buf1 = new AudioBuffer({ length: 4, sampleRate: 44100 })
	buf1.getChannelData(0).set([0, 0, 1, 1])
	eq(convert(buf1, 'array'), [0, 0, 1, 1])

	let buf2 = new AudioBuffer({ length: 2, numberOfChannels: 2, sampleRate: 44100 })
	buf2.getChannelData(0).set([1, 0])
	buf2.getChannelData(1).set([0, 1])
	eq(convert(buf2, 'array'), [1, 0, 0, 1])
})

test('AudioBuffer to float32', () => {
	let buf = new AudioBuffer({ length: 4, sampleRate: 44100 })
	buf.getChannelData(0).set([0, 1, 0, -1])
	eq(convert(buf, 'float32'), [0, 1, 0, -1])
})

test('float32 planar → AudioBuffer', () => {
	let src = new Float32Array([1, -1, 0, 0.5])
	let out = convert(src, { dtype: 'float32', channels: 2, interleaved: false, sampleRate: 44100 }, 'audiobuffer')
	assert.ok(typeof out.getChannelData === 'function')
	assert.equal(out.numberOfChannels, 2)
	assert.equal(out.length, 2)
	assert.equal(out.sampleRate, 44100)
	eq(out.getChannelData(0), [1, -1])
	eq(out.getChannelData(1), [0, 0.5])
})

test('int16 interleaved → AudioBuffer', () => {
	let src = new Int16Array([32767, 0, -32768, 16384])
	let out = convert(src, { dtype: 'int16', channels: 2, interleaved: true, sampleRate: 48000 }, 'audiobuffer')
	assert.ok(typeof out.getChannelData === 'function')
	assert.equal(out.numberOfChannels, 2)
	assert.equal(out.sampleRate, 48000)
	assert.ok(Math.abs(out.getChannelData(0)[0] - 1) < 0.001)
	assert.ok(Math.abs(out.getChannelData(1)[0] - 0) < 0.001)
	assert.ok(Math.abs(out.getChannelData(0)[1] - (-1)) < 0.001)
})

test('destination container — typed array', () => {
	let holder = new Uint8Array(4)
	convert([0, 1, 0, -1], 'uint8', holder)
	eq(holder, [128, 255, 128, 0])
})

test('destination container — auto-detect both', () => {
	let h = new Uint16Array(2)
	convert(new Uint8Array([0, 255]), h)
	eq(h, [0, 65535])
})

test('destination container — 4-arg', () => {
	let h = []
	convert(new Uint8Array([0, 255, 0, 255]), 'interleaved', 'float32 planar', h)
	assert.deepStrictEqual(h, [-1, -1, 127 / 128, 127 / 128])
})

test('arraybuffer should not shortcut', () => {
	let ab = new Float32Array([0, 0, 1, 1]).buffer
	let out = convert(ab, { type: 'float32', interleaved: true }, 'float32 interleaved')
	assert.ok(out instanceof Float32Array)
	eq(out, [0, 0, 1, 1])
})

test('self-target conversion', () => {
	let arr = new Float32Array([0, 1, 0, 1])
	convert(arr, 'interleaved', 'planar', arr)
	eq(arr, [0, 0, 1, 1])
})

test('arraybuffer output preserves dtype', () => {
	let res = convert(new Float32Array([-1, 0, 1]), 'float32', 'arraybuffer')
	assert.ok(res instanceof ArrayBuffer)
	eq(new Float32Array(res), [-1, 0, 1])

	let res2 = convert(new Float32Array([-1, 0, 1]).buffer, 'float32', 'arraybuffer')
	assert.ok(res2 instanceof ArrayBuffer)
	eq(new Float32Array(res2), [-1, 0, 1])
})

test('full args with undefined to', () => {
	let res = convert([0, 1], 'float32', undefined, new Uint8Array(2))
	eq(res, [128, 255])
})

test('data to arraybuffer container', () => {
	let res = convert(new Uint8Array([127, 255]), new ArrayBuffer(2))
	eq(new Uint8Array(res), [127, 255])
})

test('endianness swap with destination target', () => {
	let dst = new Int16Array(2)
	convert(new Float32Array([1, -0.5]), 'float32 le', 'int16 be', dst)
	let raw = Buffer.from(dst.buffer)
	assert.equal(raw.readInt16BE(0), 32767)
	assert.equal(raw.readInt16BE(2), -16384)
})

// === Planar channel array input (absorbs pcm-encode) ===

test('Float32Array[] → int16 interleaved', () => {
	let left = new Float32Array([1, -1])
	let right = new Float32Array([0, 0.5])
	let out = convert([left, right], 'int16 interleaved')
	assert.ok(out instanceof Int16Array)
	eq(out, [32767, 0, -32768, 16384])
})

test('Float32Array[] → float32 interleaved', () => {
	let left = new Float32Array([1, 0])
	let right = new Float32Array([0, 1])
	let out = convert([left, right], 'float32 interleaved')
	eq(out, [1, 0, 0, 1])
})

test('Float32Array[] → int16 planar (no reinterleave)', () => {
	let left = new Float32Array([1, -1])
	let right = new Float32Array([0, 0.5])
	let out = convert([left, right], 'int16')
	eq(out, [32767, -32768, 0, 16384])
})

test('Float32Array[] mono', () => {
	let ch = new Float32Array([1, 0, -1])
	let out = convert([ch], 'int16')
	eq(out, [32767, 0, -32768])
})

test('Int16Array[] → float32 interleaved', () => {
	let left = new Int16Array([32767, -32768])
	let right = new Int16Array([0, 16384])
	let out = convert([left, right], 'float32 interleaved')
	assert.ok(out instanceof Float32Array)
	assert.ok(Math.abs(out[0] - 1) < 0.001)
	assert.ok(Math.abs(out[2] - (-1)) < 0.001)
})

// === Format parse tests ===

test('parse: basic format string', () => {
	let f = parse('float32 stereo planar le')
	assert.equal(f.dtype, 'float32')
	assert.equal(f.channels, 2)
	assert.equal(f.interleaved, false)
	assert.equal(f.endianness, 'le')
})

test('parse: sample rate', () => {
	let f = parse('int16 stereo 44100')
	assert.equal(f.dtype, 'int16')
	assert.equal(f.channels, 2)
	assert.equal(f.sampleRate, 44100)
})

test('parse: comma/semicolon separators', () => {
	let f = parse('float32, stereo, planar')
	assert.equal(f.dtype, 'float32')
	assert.equal(f.channels, 2)
	assert.equal(f.interleaved, false)
})

test('parse: dtype aliases', () => {
	assert.equal(parse('float').dtype, 'float32')
	assert.equal(parse('int').dtype, 'int32')
	assert.equal(parse('uint').dtype, 'uint32')
})

test('parse: removed aliases throw', () => {
	assert.throws(() => parse('interleave'), /Unknown format token/)
	assert.throws(() => parse('littleendian'), /Unknown format token/)
	assert.throws(() => parse('bigendian'), /Unknown format token/)
})

test('parse: channel aliases', () => {
	assert.equal(parse('mono').channels, 1)
	assert.equal(parse('quad').channels, 4)
	assert.equal(parse('5.1').channels, 6)
	assert.equal(parse('2.1').channels, 3)
})

test('parse: object with type alias', () => {
	let f = parse({ type: 'float32', channels: 2 })
	assert.equal(f.dtype, 'float32')
	assert.equal(f.channels, 2)
})

test('parse: object with numberOfChannels', () => {
	let f = parse({ dtype: 'int16', numberOfChannels: 6 })
	assert.equal(f.dtype, 'int16')
	assert.equal(f.channels, 6)
})

test('parse: audiobuffer as container', () => {
	assert.deepStrictEqual(parse('audiobuffer'), { container: 'audiobuffer' })
})

// === Format detect tests ===

test('detect: typed arrays', () => {
	assert.equal(detect(new Float32Array(1)).dtype, 'float32')
	assert.equal(detect(new Int16Array(1)).dtype, 'int16')
	assert.equal(detect(new Uint8Array(1)).dtype, 'uint8')
})

test('detect: AudioBuffer', () => {
	let buf = new AudioBuffer({ length: 4, numberOfChannels: 2, sampleRate: 48000 })
	let f = detect(buf)
	assert.equal(f.dtype, 'float32')
	assert.equal(f.channels, 2)
	assert.equal(f.interleaved, false)
	assert.equal(f.sampleRate, 48000)
})

test('detect: planar channel arrays', () => {
	let f = detect([new Float32Array(4), new Float32Array(4)])
	assert.equal(f.dtype, 'float32')
	assert.equal(f.channels, 2)
	assert.equal(f.interleaved, false)
})

test('detect: plain array', () => {
	assert.equal(detect([1, 2, 3]).container, 'array')
})

test('detect: ArrayBuffer', () => {
	assert.equal(detect(new ArrayBuffer(4)).container, 'arraybuffer')
})

// === Format stringify tests ===

test('stringify: basic', () => {
	assert.equal(stringify({ dtype: 'float32', channels: 2, interleaved: false }), 'float32 stereo planar')
})

test('stringify: omits le by default', () => {
	assert.equal(stringify({ dtype: 'int16', endianness: 'le' }), 'int16')
	assert.equal(stringify({ dtype: 'int16', endianness: 'be' }), 'int16 be')
})

test('stringify: with sample rate', () => {
	assert.equal(stringify({ dtype: 'float32', sampleRate: 44100 }), 'float32 44100')
})

test('stringify: omit nothing', () => {
	let s = stringify({ dtype: 'int16', endianness: 'le' }, null)
	assert.equal(s, 'int16 le')
})

// === Rates ===

test('sampleRate: standard sample rates', () => {
	assert.ok(Array.isArray(sampleRate))
	assert.equal(sampleRate.length, 12)
	assert.ok(sampleRate.includes(44100))
	assert.ok(sampleRate.includes(48000))
	assert.ok(sampleRate.includes(96000))
})

// === Sample-rate conversion (polyphase FIR via @audio/resample-polyphase) ===

const goertzel = (d, f, fs) => {
	let w = 2 * Math.PI * f / fs, c = 2 * Math.cos(w), s1 = 0, s2 = 0
	for (let i = 0; i < d.length; i++) { let s = d[i] + c * s1 - s2; s2 = s1; s1 = s }
	return 2 * Math.sqrt(Math.max(0, s1 * s1 + s2 * s2 - c * s1 * s2)) / d.length
}
const sine = (f, n, fs, a = 0.5) => Float32Array.from({ length: n }, (_, i) => a * Math.sin(2 * Math.PI * f * i / fs))
const rms = d => { let s = 0; for (let v of d) s += v * v; return Math.sqrt(s / d.length) }

test('resample: 44100 → 48000 preserves pitch and level', () => {
	let x = sine(440, 44100, 44100)
	let out = convert(x, 'float32 44100', 'float32 48000')
	assert.equal(out.length, Math.round(44100 * 48000 / 44100))
	// tone stays at 440 Hz at the new rate, amplitude preserved
	assert.ok(Math.abs(goertzel(out, 440, 48000) - 0.5) < 0.02, `440 Hz level ${goertzel(out, 440, 48000).toFixed(3)}`)
	assert.ok(Math.abs(rms(out) / rms(x) - 1) < 0.02, 'energy preserved')
})

test('resample: downsample anti-aliases (10 kHz into 8 kHz target)', () => {
	let x = sine(10000, 44100, 44100)
	let out = convert(x, 'float32 44100', 'float32 8000')
	assert.equal(out.length, Math.round(44100 * 8000 / 44100))
	// 10 kHz is above the 4 kHz target Nyquist — must be attenuated, not folded
	assert.ok(rms(out) < rms(x) * 0.01, `alias floor ${(20 * Math.log10(rms(out) / rms(x))).toFixed(1)} dB`)
})

test('resample: int16 interleaved stereo → float32, layout preserved', () => {
	let n = 22050, fs = 44100
	let inter = new Int16Array(n * 2)
	for (let i = 0; i < n; i++) {
		inter[i * 2] = Math.round(0.5 * 32767 * Math.sin(2 * Math.PI * 440 * i / fs))
		inter[i * 2 + 1] = Math.round(0.25 * 32767 * Math.sin(2 * Math.PI * 880 * i / fs))
	}
	let out = convert(inter, 'int16 stereo interleaved 44100', 'float32 22050')
	assert.equal(out.length, n)                            // half rate, still interleaved stereo
	let L = new Float32Array(n / 2), R = new Float32Array(n / 2)
	for (let i = 0; i < n / 2; i++) { L[i] = out[i * 2]; R[i] = out[i * 2 + 1] }
	assert.ok(Math.abs(goertzel(L, 440, 22050) - 0.5) < 0.03, 'left keeps 440')
	assert.ok(Math.abs(goertzel(R, 880, 22050) - 0.25) < 0.03, 'right keeps 880')
})

test('resample: audiobuffer output carries the target rate', () => {
	let ab = new AudioBuffer({ length: 44100, numberOfChannels: 1, sampleRate: 44100 })
	ab.copyToChannel(sine(440, 44100, 44100), 0)
	let out = convert(ab, 'audiobuffer 48000')
	assert.equal(out.sampleRate, 48000)
	assert.equal(out.length, 48000)
	assert.ok(Math.abs(out.duration - 1) < 1e-6, 'duration preserved')
	assert.ok(Math.abs(goertzel(out.getChannelData(0), 440, 48000) - 0.5) < 0.02, 'pitch preserved')
})

test('resample: same rate is a pass-through (no filter applied)', () => {
	let x = sine(440, 4096, 44100)
	let out = convert(x, 'float32 44100', 'float32 44100')
	eq(out, [...x])
})

// A module with a top-level await makes every importer wait for it; bundled into split chunks that cycle through it
// (two resolved copies in a module worker), the wait never ended. require(esm) loads only a module graph without one
// (Node 20.19, 22.12+: ERR_REQUIRE_ASYNC_MODULE otherwise), so it pins that no importer waits on this package.
test('no top-level await: the module and its imports load synchronously (require(esm))', { skip: !process.features?.require_module && 'Node without require(esm)' }, () => {
	let m = createRequire(import.meta.url)('./index.js')
	assert.equal(typeof m.default, 'function')
	let ab = m.default(new Float32Array([0.5, -0.5]), 'float32', 'audiobuffer')
	assert.equal(ab.length, 2, 'AudioBuffer output available right after a synchronous load')
})

// A browser worker has no AudioBuffer global (it is window-only) and no require: the stand-in loads in the background,
// `ready` settles when it has. Simulated: a fresh copy of the module with require unavailable while it evaluates, and a
// loader hook that holds its audio-buffer import for 2 s, so the conversion before `await ready` meets the load pending.
test('worker-like (no AudioBuffer, no require): a clear error until `await ready`, then audiobuffer output', async () => {
	register('data:text/javascript,' + encodeURIComponent(`export async function resolve(spec, ctx, next) {
		if (spec === 'audio-buffer' && ctx.parentURL?.includes('worker-like')) await new Promise(r => setTimeout(r, 2000))
		return next(spec, ctx)
	}`))
	let gbm = process.getBuiltinModule, m
	process.getBuiltinModule = undefined
	try { m = await import('./index.js?worker-like') } finally { process.getBuiltinModule = gbm }
	assert.throws(() => m.default(new Float32Array([0.5]), 'float32', 'audiobuffer'), /await ready/)
	await m.ready
	assert.equal(m.default(new Float32Array([0.5, -0.5]), 'float32', 'audiobuffer').length, 2)
})