@happyvertical/smrt-svelte 0.53.0 → 0.53.2

package/dist/browser-ai/adapters/stt/browser-speech.test.js

@@ -1,113 +0,0 @@
-/**
- * BrowserSpeechSTTAdapter errors: every Web Speech error reaches `onError`
- * with its code (`speechError`), including an `aborted` the adapter did not
- * cause, and through smrt-ui's `Dictation` Brave's "starts, then `network`"
- * becomes a plain error instead of a silent stop.
- */
-import { Dictation } from '@happyvertical/smrt-ui/forms';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { BrowserSpeechSTTAdapter, } from './browser-speech.js';
-import { createSttDictationSource } from './dictation-source.js';
-class FakeRecognition {
-    static last = null;
-    /** What the browser does after start(): Brave errors with `network`. */
-    static afterStart = null;
-    lang = '';
-    continuous = false;
-    interimResults = false;
-    maxAlternatives = 1;
-    onresult = null;
-    onerror = null;
-    onstart = null;
-    onend = null;
-    constructor() {
-        FakeRecognition.last = this;
-    }
-    start = vi.fn(() => {
-        this.onstart?.();
-        FakeRecognition.afterStart?.(this);
-    });
-    stop = vi.fn(() => this.onend?.());
-    abort = vi.fn(() => {
-        this.onerror?.({ error: 'aborted', message: '' });
-        this.onend?.();
-    });
-    fail(code) {
-        this.onerror?.({ error: code, message: '' });
-        this.onend?.();
-    }
-}
-function install() {
-    window.webkitSpeechRecognition =
-        FakeRecognition;
-}
-afterEach(() => {
-    delete window
-        .webkitSpeechRecognition;
-    FakeRecognition.last = null;
-    FakeRecognition.afterStart = null;
-});
-describe('BrowserSpeechSTTAdapter errors', () => {
-    it.each([
-        'network',
-        'not-allowed',
-        'service-not-allowed',
-        'no-speech',
-        'audio-capture',
-        'aborted',
-        'language-not-supported',
-    ])('reports %s with its code', async (code) => {
-        install();
-        const adapter = new BrowserSpeechSTTAdapter();
-        const errors = [];
-        adapter.onError((error) => errors.push(error));
-        await adapter.start({ continuous: true });
-        FakeRecognition.last?.fail(code);
-        expect(errors).toHaveLength(1);
-        expect(errors[0].speechError).toBe(code);
-    });
-    it('does not report the abort it caused itself', async () => {
-        install();
-        const adapter = new BrowserSpeechSTTAdapter();
-        const onError = vi.fn();
-        adapter.onError(onError);
-        await adapter.start();
-        adapter.abort();
-        expect(onError).not.toHaveBeenCalled();
-    });
-});
-describe('Dictation over the browser adapter', () => {
-    it("Brave: it beeps, then 'network' — shown as unavailable, not a silent stop", async () => {
-        install();
-        FakeRecognition.afterStart = (r) => queueMicrotask(() => r.fail('network'));
-        const log = vi.fn();
-        const beep = vi.fn(async () => true);
-        const dictation = new Dictation({
-            source: createSttDictationSource(),
-            onText: () => { },
-            beep,
-            log,
-            requestMicrophone: false,
-        });
-        await dictation.start();
-        await vi.waitFor(() => expect(dictation.state).toBe('error'));
-        expect(beep).toHaveBeenCalled();
-        expect(dictation.errorKind).toBe('unsupported');
-        expect(dictation.errorCode).toBe('network');
-        expect(log).toHaveBeenCalledWith(expect.objectContaining({ kind: 'unsupported', code: 'network' }));
-    });
-    it('an end straight after starting with no error is a failure too', async () => {
-        install();
-        FakeRecognition.afterStart = (r) => queueMicrotask(() => r.onend?.());
-        const dictation = new Dictation({
-            source: createSttDictationSource(),
-            onText: () => { },
-            beep: false,
-            log: () => { },
-            requestMicrophone: false,
-        });
-        await dictation.start();
-        await vi.waitFor(() => expect(dictation.state).toBe('error'));
-        expect(dictation.errorKind).toBe('interrupted');
-    });
-});

package/dist/browser-ai/adapters/stt/dictation-source.test.js

@@ -1,52 +0,0 @@
-/**
- * createSttDictationSource: the browser speech adapter, created once and
- * lazily, and rejected plainly where the browser has no speech recognition.
- */
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { createSttDictationSource } from './dictation-source.js';
-class FakeRecognition {
-    lang = '';
-    continuous = false;
-    interimResults = false;
-    maxAlternatives = 1;
-    onresult = null;
-    onerror = null;
-    onstart = null;
-    onend = null;
-    start = vi.fn(() => this.onstart?.());
-    stop = vi.fn(() => this.onend?.());
-    abort = vi.fn();
-}
-describe('createSttDictationSource', () => {
-    afterEach(() => {
-        delete window.SpeechRecognition;
-        delete window
-            .webkitSpeechRecognition;
-    });
-    it('creates one browser speech adapter, on first use', async () => {
-        window.webkitSpeechRecognition =
-            FakeRecognition;
-        const provide = createSttDictationSource();
-        const first = await provide();
-        const second = await provide();
-        expect(first).toBe(second);
-        expect(first.type).toBe('browser-speech');
-        const onStart = vi.fn();
-        first.onStart(onStart);
-        await first.start({
-            language: 'en-CA',
-            continuous: true,
-            interimResults: true,
-        });
-        expect(onStart).toHaveBeenCalled();
-    });
-    it('rejects with CapabilityNotAvailableError without speech recognition, then can retry', async () => {
-        const provide = createSttDictationSource();
-        await expect(provide()).rejects.toMatchObject({
-            name: 'CapabilityNotAvailableError',
-        });
-        window.SpeechRecognition =
-            FakeRecognition;
-        await expect(provide()).resolves.toBeTruthy();
-    });
-});

package/dist/browser-ai/svelte/components/__tests__/ModelStatusControl.test.js

@@ -1,172 +0,0 @@
-/**
- * `ModelStatusControl` — the user-facing model lifecycle surface.
- *
- * The states that matter here are the ones a user acts on: whether the model is
- * loaded, whether it can be loaded on this device at all, and what a download
- * is doing. The `unavailable` case is asserted explicitly because offering a
- * Load button on a device that cannot run the model is the failure this control
- * exists to prevent.
- */
-import { expectNoA11yViolations } from '@happyvertical/smrt-ui/test-support/a11y';
-import { render, screen } from '@testing-library/svelte';
-import userEvent from '@testing-library/user-event';
-import { tick } from 'svelte';
-import { describe, expect, it, vi } from 'vitest';
-import ModelStatusControl from '../ModelStatusControl.svelte';
-function makeBackend(initial = {}) {
-    let status = initial.status ?? 'idle';
-    let progress;
-    const listeners = new Set();
-    const backend = {
-        id: 'local',
-        kind: 'local',
-        get status() {
-            return status;
-        },
-        get progress() {
-            return progress;
-        },
-        loadCalls: 0,
-        unloadCalls: 0,
-        loadImpl: async () => { },
-        setStatus(next) {
-            status = next;
-            for (const listener of [...listeners])
-                listener();
-        },
-        setProgress(next) {
-            progress = next;
-            for (const listener of [...listeners])
-                listener();
-        },
-        async load() {
-            backend.loadCalls += 1;
-            await backend.loadImpl();
-        },
-        async unload() {
-            backend.unloadCalls += 1;
-            status = 'idle';
-            for (const listener of [...listeners])
-                listener();
-        },
-        async chat() {
-            return { content: '' };
-        },
-        async *stream() {
-            yield '';
-        },
-        subscribe(listener) {
-            listeners.add(listener);
-            return () => {
-                listeners.delete(listener);
-            };
-        },
-    };
-    return backend;
-}
-describe('ModelStatusControl', () => {
-    it('offers a load action when the model is not loaded', async () => {
-        const backend = makeBackend({ status: 'idle' });
-        render(ModelStatusControl, { props: { backend } });
-        expect(screen.getByRole('status')).toHaveTextContent('Not loaded');
-        await userEvent.click(screen.getByRole('button', { name: 'Load model' }));
-        expect(backend.loadCalls).toBe(1);
-    });
-    it('offers a release action once the model is ready', async () => {
-        const backend = makeBackend({ status: 'ready' });
-        render(ModelStatusControl, { props: { backend } });
-        expect(screen.getByRole('status')).toHaveTextContent('Ready');
-        await userEvent.click(screen.getByRole('button', { name: 'Unload' }));
-        expect(backend.unloadCalls).toBe(1);
-    });
-    it('hides the release action when the host opts out', () => {
-        const backend = makeBackend({ status: 'ready' });
-        render(ModelStatusControl, {
-            props: { backend, allowUnload: false },
-        });
-        expect(screen.queryByRole('button', { name: 'Unload' })).toBeNull();
-    });
-    it('never offers a load action on a device that cannot run the model', () => {
-        const backend = makeBackend({ status: 'unavailable' });
-        render(ModelStatusControl, { props: { backend } });
-        expect(screen.getByRole('status')).toHaveTextContent('Not available on this device');
-        // The point of the state: no affordance that cannot succeed.
-        expect(screen.queryByRole('button')).toBeNull();
-        expect(screen.getByText(/will use the server route/)).toBeInTheDocument();
-    });
-    it('offers no action for a backend that cannot load or unload', () => {
-        // A route-kind backend defines neither method and always reports `ready`;
-        // offering an Unload that silently does nothing is the same defect as
-        // offering a Load on an unavailable device.
-        const backend = makeBackend({ status: 'ready' });
-        // "A backend with no unload" is not hypothetical: it is the route backend.
-        delete backend.load;
-        delete backend.unload;
-        render(ModelStatusControl, { props: { backend } });
-        expect(screen.getByRole('status')).toHaveTextContent('Ready');
-        expect(screen.queryByRole('button')).toBeNull();
-    });
-    it('offers no load action for an idle backend without load', () => {
-        const backend = makeBackend({ status: 'idle' });
-        delete backend.load;
-        render(ModelStatusControl, { props: { backend } });
-        expect(screen.getByRole('status')).toHaveTextContent('Not loaded');
-        expect(screen.queryByRole('button')).toBeNull();
-    });
-    it('renders download progress while loading', () => {
-        const backend = makeBackend({ status: 'loading' });
-        backend.setProgress({
-            state: 'downloading',
-            bytesLoaded: 250_000,
-            bytesTotal: 500_000,
-            percent: 50,
-        });
-        render(ModelStatusControl, { props: { backend } });
-        expect(screen.getByRole('status')).toHaveTextContent('Loading');
-        expect(screen.getByText('Downloading model')).toBeInTheDocument();
-        expect(screen.getByText('50%')).toBeInTheDocument();
-    });
-    it('offers a retry after a failed load', async () => {
-        const backend = makeBackend({ status: 'error' });
-        render(ModelStatusControl, { props: { backend } });
-        expect(screen.getByRole('status')).toHaveTextContent('Load failed');
-        await userEvent.click(screen.getByRole('button', { name: 'Retry' }));
-        expect(backend.loadCalls).toBe(1);
-    });
-    it('surfaces a rejected load inline and to the host', async () => {
-        const backend = makeBackend({ status: 'idle' });
-        backend.loadImpl = async () => {
-            throw new Error('out of memory');
-        };
-        const onerror = vi.fn();
-        render(ModelStatusControl, { props: { backend, onerror } });
-        await userEvent.click(screen.getByRole('button', { name: 'Load model' }));
-        await tick();
-        expect(await screen.findByRole('alert')).toHaveTextContent('out of memory');
-        expect(onerror).toHaveBeenCalledWith(expect.any(Error));
-    });
-    it('follows a backend status change without a host re-render', async () => {
-        const backend = makeBackend({ status: 'idle' });
-        render(ModelStatusControl, { props: { backend } });
-        expect(screen.getByRole('status')).toHaveTextContent('Not loaded');
-        backend.setStatus('ready');
-        await tick();
-        expect(screen.getByRole('status')).toHaveTextContent('Ready');
-    });
-    it('has no accessibility violations in any state', async () => {
-        for (const status of [
-            'unavailable',
-            'idle',
-            'loading',
-            'ready',
-            'error',
-        ]) {
-            const backend = makeBackend({ status });
-            const { container, unmount } = render(ModelStatusControl, {
-                props: { backend },
-            });
-            await expectNoA11yViolations(container);
-            unmount();
-        }
-    });
-});