@happyvertical/smrt-ui 0.53.0 → 0.53.2

package/dist/components/forms/__tests__/dictation-recording.test.js

@@ -1,582 +0,0 @@
-/**
- * Dictation's recording fallback: when the browser has no speech recognition
- * (Firefox) or it fails with no speech service behind it (Brave), record with
- * MediaRecorder and hand the audio to `transcribe`. Fake speech source, fake
- * recorder, fake MediaRecorder: nothing here touches a real microphone.
- */
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { createMediaRecorderCapture, DictationError, pickDictationMimeType, } from '../audio-capture.js';
-import { Dictation, } from '../dictation.svelte.js';
-import { createHttpTranscriber } from '../dictation-transcribe.js';
-function fakeSource(options = {}) {
-    const results = new Set();
-    const errors = new Set();
-    const ends = new Set();
-    return {
-        start: vi.fn(async () => {
-            if (options.startError)
-                throw options.startError;
-        }),
-        stop: vi.fn(async () => {
-            for (const cb of ends)
-                cb();
-        }),
-        onResult: (cb) => (results.add(cb), () => results.delete(cb)),
-        onError: (cb) => (errors.add(cb), () => errors.delete(cb)),
-        onEnd: (cb) => (ends.add(cb), () => ends.delete(cb)),
-        emitResult(text, isFinal) {
-            for (const cb of results)
-                cb({ text, isFinal });
-        },
-        emitError(error) {
-            for (const cb of errors)
-                cb(error);
-        },
-        emitEnd() {
-            for (const cb of ends)
-                cb();
-        },
-    };
-}
-function speechError(code) {
-    return Object.assign(new Error(`Speech recognition error: ${code}`), {
-        speechError: code,
-    });
-}
-function fakeCaptureFactory(options = {}) {
-    const made = [];
-    const factory = vi.fn(() => {
-        const limits = new Set();
-        const capture = {
-            start: vi.fn(async () => {
-                await options.startGate;
-                if (options.startError)
-                    throw options.startError;
-            }),
-            stop: vi.fn(async () => {
-                if (options.stopError)
-                    throw options.stopError;
-                return {
-                    audio: new Blob(['opus-bytes'], { type: 'audio/webm;codecs=opus' }),
-                    mimeType: 'audio/webm;codecs=opus',
-                    durationMs: 3200,
-                    reachedTimeLimit: false,
-                    ...options.recording,
-                };
-            }),
-            cancel: vi.fn(),
-            onLimit: (cb) => (limits.add(cb), () => limits.delete(cb)),
-            hitLimit(reason) {
-                for (const cb of limits)
-                    cb(reason);
-            },
-        };
-        made.push(capture);
-        return capture;
-    });
-    return { factory, made };
-}
-afterEach(() => {
-    vi.useRealTimers();
-    vi.unstubAllGlobals();
-});
-describe('Dictation recording fallback', () => {
-    it('records when there is no speech source, then writes it down', async () => {
-        const { factory, made } = fakeCaptureFactory();
-        const transcribe = vi.fn(async () => 'make it square');
-        const onText = vi.fn();
-        const beep = vi.fn(async () => true);
-        const dictation = new Dictation({
-            onText,
-            transcribe,
-            capture: factory,
-            beep,
-            language: 'en-CA',
-            maxDurationMs: 90_000,
-            maxBytes: 5_000_000,
-        });
-        expect(dictation.available).toBe(true);
-        await dictation.start();
-        expect(dictation.state).toBe('listening');
-        expect(dictation.recording).toBe(true);
-        expect(factory).toHaveBeenCalledWith({
-            maxDurationMs: 90_000,
-            maxBytes: 5_000_000,
-        });
-        await vi.waitFor(() => expect(beep).toHaveBeenCalledTimes(1));
-        let release;
-        transcribe.mockImplementationOnce(() => new Promise((resolve) => (release = resolve)));
-        const stopped = dictation.stop();
-        await vi.waitFor(() => expect(transcribe).toHaveBeenCalled());
-        expect(dictation.state).toBe('transcribing');
-        expect(dictation.active).toBe(false);
-        release('  make it square ');
-        await stopped;
-        expect(made[0].stop).toHaveBeenCalled();
-        expect(transcribe).toHaveBeenCalledWith(expect.any(Blob), {
-            mimeType: 'audio/webm;codecs=opus',
-            language: 'en-CA',
-            durationMs: 3200,
-            signal: expect.any(AbortSignal),
-        });
-        expect(onText).toHaveBeenCalledWith('make it square');
-        expect(dictation.state).toBe('idle');
-        expect(dictation.recording).toBe(false);
-    });
-    it('switches to recording when Brave fails with `network`, and records straight away next time', async () => {
-        const source = fakeSource();
-        const { factory, made } = fakeCaptureFactory();
-        const log = vi.fn();
-        const onText = vi.fn();
-        const dictation = new Dictation({
-            source: () => source,
-            onText,
-            transcribe: async () => 'the arena at night',
-            capture: factory,
-            beep: false,
-            requestMicrophone: false,
-            log,
-        });
-        await dictation.start();
-        expect(dictation.state).toBe('listening');
-        expect(dictation.recording).toBe(false);
-        source.emitError(speechError('network'));
-        await vi.waitFor(() => expect(made).toHaveLength(1));
-        await vi.waitFor(() => expect(made[0].start).toHaveBeenCalled());
-        await made[0].start.mock.results[0].value;
-        await Promise.resolve();
-        expect(dictation.state).toBe('listening');
-        expect(dictation.recording).toBe(true);
-        expect(source.stop).toHaveBeenCalled();
-        expect(log).toHaveBeenCalledWith(expect.objectContaining({
-            kind: 'unsupported',
-            code: 'network',
-            fallback: 'recording',
-        }));
-        await dictation.stop();
-        expect(onText).toHaveBeenCalledWith('the arena at night');
-        expect(dictation.state).toBe('idle');
-        source.start.mockClear();
-        await dictation.start();
-        expect(source.start).not.toHaveBeenCalled();
-        expect(made).toHaveLength(2);
-        expect(dictation.recording).toBe(true);
-    });
-    it('records when the recogniser refuses to start (`service-not-allowed`)', async () => {
-        const source = fakeSource({
-            startError: speechError('service-not-allowed'),
-        });
-        const { factory, made } = fakeCaptureFactory();
-        const dictation = new Dictation({
-            source: () => source,
-            onText: () => { },
-            transcribe: async () => 'hello',
-            capture: factory,
-            beep: false,
-            requestMicrophone: false,
-            log: () => { },
-        });
-        await dictation.start();
-        await vi.waitFor(() => expect(dictation.state).toBe('listening'));
-        expect(dictation.recording).toBe(true);
-        expect(made).toHaveLength(1);
-    });
-    it('records when the browser has no speech recognition at all (Firefox)', async () => {
-        const { factory } = fakeCaptureFactory();
-        const dictation = new Dictation({
-            source: () => {
-                throw Object.assign(new Error('Speech recognition not available'), {
-                    code: 'CAPABILITY_NOT_AVAILABLE',
-                });
-            },
-            onText: () => { },
-            transcribe: async () => 'hello',
-            capture: factory,
-            beep: false,
-            requestMicrophone: false,
-            log: () => { },
-        });
-        await dictation.start();
-        await vi.waitFor(() => expect(dictation.state).toBe('listening'));
-        expect(dictation.recording).toBe(true);
-    });
-    it('records when the recogniser ends straight away without an error', async () => {
-        const source = fakeSource();
-        const { factory } = fakeCaptureFactory();
-        const dictation = new Dictation({
-            source: () => source,
-            onText: () => { },
-            transcribe: async () => 'hello',
-            capture: factory,
-            beep: false,
-            requestMicrophone: false,
-            log: () => { },
-        });
-        await dictation.start();
-        source.emitEnd();
-        await vi.waitFor(() => expect(dictation.recording).toBe(true));
-        expect(dictation.state).toBe('listening');
-    });
-    it('keeps the plain error without a transcribe function', async () => {
-        const source = fakeSource();
-        const dictation = new Dictation({
-            source: () => source,
-            onText: () => { },
-            beep: false,
-            requestMicrophone: false,
-            log: () => { },
-        });
-        await dictation.start();
-        source.emitError(speechError('network'));
-        expect(dictation.state).toBe('error');
-        expect(dictation.errorKind).toBe('unsupported');
-    });
-    it('does not switch after words were already heard', async () => {
-        const source = fakeSource();
-        const { factory } = fakeCaptureFactory();
-        const dictation = new Dictation({
-            source: () => source,
-            onText: () => { },
-            transcribe: async () => 'x',
-            capture: factory,
-            beep: false,
-            requestMicrophone: false,
-            log: () => { },
-        });
-        await dictation.start();
-        source.emitResult('hello', true);
-        source.emitError(speechError('network'));
-        expect(dictation.state).toBe('error');
-        expect(factory).not.toHaveBeenCalled();
-    });
-    it('does not record over a blocked microphone', async () => {
-        const { factory } = fakeCaptureFactory({
-            startError: Object.assign(new Error('Permission denied'), {
-                name: 'NotAllowedError',
-            }),
-        });
-        const dictation = new Dictation({
-            onText: () => { },
-            transcribe: async () => 'x',
-            capture: factory,
-            beep: false,
-            log: () => { },
-        });
-        await dictation.start();
-        expect(dictation.state).toBe('error');
-        expect(dictation.errorKind).toBe('denied');
-    });
-    it.each([
-        [new DictationError('too-long', 'too big'), 'too-long'],
-        [new DictationError('unavailable', 'not set up'), 'unavailable'],
-        [new DictationError('forbidden', 'no'), 'forbidden'],
-        [new Error('Failed to fetch: network down'), 'not-transcribed'],
-    ])('says why writing it down failed (%s)', async (error, kind) => {
-        const { factory } = fakeCaptureFactory();
-        const onText = vi.fn();
-        const dictation = new Dictation({
-            onText,
-            transcribe: async () => {
-                throw error;
-            },
-            capture: factory,
-            beep: false,
-            log: () => { },
-        });
-        await dictation.start();
-        await dictation.stop();
-        expect(dictation.state).toBe('error');
-        expect(dictation.errorKind).toBe(kind);
-        expect(onText).not.toHaveBeenCalled();
-    });
-    it('says nothing was heard when the text comes back empty', async () => {
-        const { factory } = fakeCaptureFactory();
-        const dictation = new Dictation({
-            onText: () => { },
-            transcribe: async () => ({ text: '   ' }),
-            capture: factory,
-            beep: false,
-            log: () => { },
-        });
-        await dictation.start();
-        await dictation.stop();
-        expect(dictation.errorKind).toBe('no-speech');
-    });
-    it('writes the recording down by itself at the time limit', async () => {
-        const { factory, made } = fakeCaptureFactory({
-            recording: { reachedTimeLimit: true, durationMs: 120_000 },
-        });
-        const onText = vi.fn();
-        const dictation = new Dictation({
-            onText,
-            transcribe: async () => 'a long story',
-            capture: factory,
-            beep: false,
-        });
-        await dictation.start();
-        made[0].hitLimit('time');
-        await vi.waitFor(() => expect(onText).toHaveBeenCalledWith('a long story'));
-        expect(dictation.state).toBe('idle');
-    });
-    it('fails as too long when the recording outgrows the size limit', async () => {
-        const { factory, made } = fakeCaptureFactory({
-            stopError: new DictationError('too-long', 'too large'),
-        });
-        const transcribe = vi.fn(async () => 'x');
-        const dictation = new Dictation({
-            onText: () => { },
-            transcribe,
-            capture: factory,
-            beep: false,
-            log: () => { },
-        });
-        await dictation.start();
-        made[0].hitLimit('size');
-        await vi.waitFor(() => expect(dictation.state).toBe('error'));
-        expect(dictation.errorKind).toBe('too-long');
-        expect(transcribe).not.toHaveBeenCalled();
-    });
-    it('stops quietly when the person stops before the microphone opened', async () => {
-        let open;
-        const { factory, made } = fakeCaptureFactory({
-            startGate: new Promise((resolve) => (open = resolve)),
-        });
-        const transcribe = vi.fn(async () => 'x');
-        const dictation = new Dictation({
-            onText: () => { },
-            transcribe,
-            capture: factory,
-            beep: false,
-        });
-        const started = dictation.start();
-        await vi.waitFor(() => expect(made).toHaveLength(1));
-        expect(dictation.state).toBe('starting');
-        await dictation.stop();
-        expect(dictation.state).toBe('idle');
-        expect(made[0].cancel).toHaveBeenCalled();
-        open();
-        await started;
-        expect(dictation.state).toBe('idle');
-        expect(transcribe).not.toHaveBeenCalled();
-    });
-    it('cancels writing it down when disposed', async () => {
-        const { factory } = fakeCaptureFactory();
-        let signal;
-        const onText = vi.fn();
-        const dictation = new Dictation({
-            onText,
-            transcribe: (_audio, options) => {
-                signal = options.signal;
-                return new Promise(() => { });
-            },
-            capture: factory,
-            beep: false,
-        });
-        await dictation.start();
-        void dictation.stop();
-        await vi.waitFor(() => expect(signal).toBeDefined());
-        expect(dictation.state).toBe('transcribing');
-        dictation.dispose();
-        expect(signal.aborted).toBe(true);
-        expect(dictation.state).toBe('idle');
-        expect(onText).not.toHaveBeenCalled();
-    });
-    it('gives up writing it down after the timeout', async () => {
-        const { factory } = fakeCaptureFactory();
-        const dictation = new Dictation({
-            onText: () => { },
-            transcribe: (_audio, { signal }) => new Promise((_resolve, reject) => signal.addEventListener('abort', () => reject(new DOMException('aborted', 'AbortError')))),
-            capture: factory,
-            beep: false,
-            transcribeTimeoutMs: 20,
-            log: () => { },
-        });
-        await dictation.start();
-        await dictation.stop();
-        expect(dictation.errorKind).toBe('not-transcribed');
-        expect(dictation.errorCode).toBe('timeout');
-    });
-    it('ignores taps while writing it down', async () => {
-        const { factory, made } = fakeCaptureFactory();
-        const dictation = new Dictation({
-            onText: () => { },
-            transcribe: () => new Promise(() => { }),
-            capture: factory,
-            beep: false,
-        });
-        await dictation.start();
-        void dictation.stop();
-        await vi.waitFor(() => expect(dictation.state).toBe('transcribing'));
-        await dictation.toggle();
-        expect(dictation.state).toBe('transcribing');
-        expect(made).toHaveLength(1);
-        dictation.dispose();
-    });
-});
-describe('createHttpTranscriber', () => {
-    it('posts the raw audio with its type, language and length, and reads the text', async () => {
-        const fetch = vi.fn(async () => new Response(JSON.stringify({ text: 'hello there' }), {
-            status: 200,
-            headers: { 'content-type': 'application/json' },
-        }));
-        const transcribe = createHttpTranscriber('/sites/x/api/transcribe', {
-            fetch: fetch,
-        });
-        const audio = new Blob(['bytes'], { type: 'audio/mp4' });
-        const controller = new AbortController();
-        const text = await transcribe(audio, {
-            mimeType: 'audio/mp4',
-            language: 'en-US',
-            durationMs: 4321.4,
-            signal: controller.signal,
-        });
-        expect(text).toBe('hello there');
-        const [url, init] = fetch.mock.calls[0];
-        const parsed = new URL(url);
-        expect(parsed.pathname).toBe('/sites/x/api/transcribe');
-        expect(parsed.searchParams.get('language')).toBe('en-US');
-        expect(parsed.searchParams.get('durationMs')).toBe('4321');
-        expect(init.method).toBe('POST');
-        expect(init.body).toBe(audio);
-        expect(init.headers['Content-Type']).toBe('audio/mp4');
-        expect(init.signal).toBe(controller.signal);
-    });
-    it.each([
-        [413, 'too-long'],
-        [503, 'unavailable'],
-        [403, 'forbidden'],
-        [401, 'forbidden'],
-        [502, 'not-transcribed'],
-    ])('turns HTTP %i into %s', async (status, kind) => {
-        const transcribe = createHttpTranscriber('/t', {
-            fetch: (async () => new Response(JSON.stringify({ error: 'nope' }), {
-                status,
-            })),
-        });
-        const error = await transcribe(new Blob(['x']), {
-            mimeType: 'audio/webm',
-            language: 'en',
-            durationMs: 1,
-            signal: new AbortController().signal,
-        }).catch((e) => e);
-        expect(error).toBeInstanceOf(DictationError);
-        expect(error.dictationKind).toBe(kind);
-        expect(error.message).toBe('nope');
-    });
-});
-class FakeMediaRecorder extends EventTarget {
-    stream;
-    static supported = new Set(['audio/webm;codecs=opus', 'audio/webm']);
-    static isTypeSupported(type) {
-        return FakeMediaRecorder.supported.has(type);
-    }
-    static last = null;
-    state = 'inactive';
-    mimeType;
-    timeslice;
-    constructor(stream, options) {
-        super();
-        this.stream = stream;
-        this.mimeType = options?.mimeType ?? '';
-        FakeMediaRecorder.last = this;
-    }
-    start(timeslice) {
-        this.timeslice = timeslice;
-        this.state = 'recording';
-    }
-    stop() {
-        this.state = 'inactive';
-        queueMicrotask(() => this.dispatchEvent(new Event('stop')));
-    }
-    emitData(bytes) {
-        const event = Object.assign(new Event('dataavailable'), {
-            data: new Blob([new Uint8Array(bytes)]),
-        });
-        this.dispatchEvent(event);
-    }
-}
-function stubMedia() {
-    const track = { stop: vi.fn() };
-    const stream = { getTracks: () => [track] };
-    const getUserMedia = vi.fn(async () => stream);
-    vi.stubGlobal('MediaRecorder', FakeMediaRecorder);
-    vi.stubGlobal('navigator', { mediaDevices: { getUserMedia } });
-    return { track, getUserMedia };
-}
-describe('createMediaRecorderCapture', () => {
-    it('prefers WebM/Opus, then MP4 (Safari)', () => {
-        stubMedia();
-        expect(pickDictationMimeType()).toBe('audio/webm;codecs=opus');
-        FakeMediaRecorder.supported = new Set(['audio/mp4']);
-        expect(pickDictationMimeType()).toBe('audio/mp4');
-        FakeMediaRecorder.supported = new Set([
-            'audio/webm;codecs=opus',
-            'audio/webm',
-        ]);
-    });
-    it('records, stops, and closes the microphone', async () => {
-        const { track, getUserMedia } = stubMedia();
-        const capture = createMediaRecorderCapture({});
-        await capture.start();
-        expect(getUserMedia).toHaveBeenCalledWith({ audio: true });
-        const recorder = FakeMediaRecorder.last;
-        expect(recorder.mimeType).toBe('audio/webm;codecs=opus');
-        expect(recorder.timeslice).toBe(1000);
-        recorder.emitData(100);
-        recorder.emitData(50);
-        const recording = await capture.stop();
-        expect(recording.audio.size).toBe(150);
-        expect(recording.mimeType).toBe('audio/webm;codecs=opus');
-        expect(recording.reachedTimeLimit).toBe(false);
-        expect(track.stop).toHaveBeenCalled();
-    });
-    it('stops by itself at the time limit and keeps the audio', async () => {
-        vi.useFakeTimers();
-        const { track } = stubMedia();
-        const capture = createMediaRecorderCapture({ maxDurationMs: 5000 });
-        const onLimit = vi.fn();
-        capture.onLimit(onLimit);
-        await capture.start();
-        FakeMediaRecorder.last.emitData(10);
-        vi.advanceTimersByTime(5000);
-        expect(onLimit).toHaveBeenCalledWith('time');
-        expect(track.stop).toHaveBeenCalled();
-        const recording = await capture.stop();
-        expect(recording.reachedTimeLimit).toBe(true);
-        expect(recording.audio.size).toBe(10);
-    });
-    it('fails as too long past the size limit', async () => {
-        stubMedia();
-        const capture = createMediaRecorderCapture({ maxBytes: 100 });
-        const onLimit = vi.fn();
-        capture.onLimit(onLimit);
-        await capture.start();
-        FakeMediaRecorder.last.emitData(80);
-        FakeMediaRecorder.last.emitData(80);
-        expect(onLimit).toHaveBeenCalledWith('size');
-        const error = await capture.stop().catch((e) => e);
-        expect(error.dictationKind).toBe('too-long');
-    });
-    it('stops waiting when the browser never fires the recorder stop event', async () => {
-        vi.useFakeTimers();
-        stubMedia();
-        const capture = createMediaRecorderCapture({});
-        await capture.start();
-        const recorder = FakeMediaRecorder.last;
-        recorder.stop = () => {
-            recorder.state = 'inactive';
-        };
-        recorder.emitData(42);
-        const pending = capture.stop();
-        await vi.advanceTimersByTimeAsync(3000);
-        const recording = await pending;
-        expect(recording.audio.size).toBe(42);
-        vi.useRealTimers();
-    });
-    it('reports a browser that cannot record', async () => {
-        vi.stubGlobal('MediaRecorder', undefined);
-        const capture = createMediaRecorderCapture({});
-        const error = await capture.start().catch((e) => e);
-        expect(error.dictationKind).toBe('unsupported');
-    });
-});