@happyvertical/smrt-ui 0.53.0 → 0.53.2

package/dist/components/forms/form-retry/__tests__/submission-key.test.js

@@ -1,236 +0,0 @@
-/**
- * The submission key and its slot (#3291): one key per filled-in form,
- * rotated at most once, never rotated by a late result, and never lost to a
- * storage error.
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { beginSubmit, clearSubmissionKey, isSubmissionKeyPersistent, mintSubmissionKey, readSubmissionKey, resetFormRetryMemory, rotateSubmissionKey, settleSubmit, submitDisposition, } from '../submission-key.js';
-import { fullStorage, memoryStorage, refusingStorage, stickyStorage, } from './storage.js';
-const UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
-beforeEach(() => {
-    resetFormRetryMemory();
-});
-afterEach(() => {
-    vi.unstubAllGlobals();
-});
-describe('submitDisposition', () => {
-    const LIVE = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';
-    const STALE = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb';
-    it('rotates on a confirmed write', () => {
-        expect(submitDisposition(LIVE, LIVE, 'success')).toBe('rotate-and-apply');
-    });
-    it('keeps the key on a validation failure, which wrote nothing', () => {
-        expect(submitDisposition(LIVE, LIVE, 'failure')).toBe('apply');
-    });
-    it('keeps the key AND the form on a transport error', () => {
-        expect(submitDisposition(LIVE, LIVE, 'error')).toBe('transport-error');
-    });
-    it('ignores every result whose key is no longer the live one', () => {
-        for (const outcome of [
-            'success',
-            'failure',
-            'redirect',
-            'error',
-        ]) {
-            expect(submitDisposition(STALE, LIVE, outcome)).toBe('ignore');
-            expect(submitDisposition(LIVE, null, outcome)).toBe('ignore');
-        }
-    });
-    it('treats a redirect as unconfirmed unless the caller says otherwise', () => {
-        expect(submitDisposition(LIVE, LIVE, 'redirect')).toBe('apply');
-        expect(submitDisposition(LIVE, LIVE, 'redirect', {
-            redirectConfirmsWrite: true,
-        })).toBe('rotate-and-apply');
-    });
-});
-describe('the submission slot', () => {
-    const A = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';
-    const B = 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb';
-    const C = 'cccccccc-cccc-4ccc-8ccc-cccccccccccc';
-    const idle = (token = A) => ({ token, inFlight: null });
-    it('refuses a SECOND submit while one is unresolved', () => {
-        const first = beginSubmit(idle());
-        expect(first).toMatchObject({ start: true, sent: A });
-        const second = beginSubmit(first.state);
-        expect(second.start).toBe(false);
-        expect(second.state).toEqual(first.state);
-    });
-    it('accepts the next submit once the first has settled', () => {
-        const first = beginSubmit(idle());
-        const settled = settleSubmit(first.state, first.sent, 'success', {
-            formCleared: true,
-            mint: () => B,
-        });
-        expect(settled).toEqual({
-            state: { token: B, inFlight: null },
-            disposition: 'rotate-and-apply',
-        });
-        expect(beginSubmit(settled.state)).toMatchObject({ start: true, sent: B });
-    });
-    it('keeps the key when the submit wrote nothing', () => {
-        for (const outcome of ['failure', 'error']) {
-            const first = beginSubmit(idle());
-            const settled = settleSubmit(first.state, first.sent, outcome, {
-                formCleared: true,
-                mint: () => B,
-            });
-            expect(settled.state, outcome).toEqual({ token: A, inFlight: null });
-        }
-    });
-    it('ignores a duplicate answer to a submit already settled', () => {
-        const first = beginSubmit(idle());
-        const settled = settleSubmit(first.state, first.sent, 'success', {
-            formCleared: true,
-            mint: () => B,
-        });
-        const late = settleSubmit(settled.state, first.sent, 'success', {
-            formCleared: true,
-            mint: () => C,
-        });
-        expect(late).toEqual({ state: settled.state, disposition: 'ignore' });
-    });
-    it('rotates at most once however many answers arrive', () => {
-        const begun = beginSubmit(idle());
-        let state = begun.state;
-        const mint = vi.fn(() => B);
-        for (let i = 0; i < 3; i += 1) {
-            state = settleSubmit(state, begun.sent, 'success', {
-                formCleared: true,
-                mint,
-            }).state;
-        }
-        expect(mint).toHaveBeenCalledTimes(1);
-    });
-    it('KEEPS the key when a confirmed write left content on the form', () => {
-        const first = beginSubmit(idle());
-        const settled = settleSubmit(first.state, first.sent, 'success', {
-            formCleared: false,
-            mint: () => B,
-        });
-        expect(settled).toEqual({
-            state: { token: A, inFlight: null },
-            disposition: 'rotate-and-apply',
-        });
-    });
-});
-describe('the key store', () => {
-    it('returns one stable UUID per form until it is rotated', () => {
-        const storage = memoryStorage();
-        const first = readSubmissionKey({ form: 'po-line', storage });
-        expect(first).toMatch(UUID_V4);
-        expect(readSubmissionKey({ form: 'po-line', storage })).toBe(first);
-        const rotated = rotateSubmissionKey({ form: 'po-line', storage });
-        expect(rotated).not.toBe(first);
-        expect(readSubmissionKey({ form: 'po-line', storage })).toBe(rotated);
-    });
-    it('keeps forms and scopes apart, under derived names', () => {
-        const storage = memoryStorage();
-        const a = readSubmissionKey({ form: 'receipt', scope: 'po/a', storage });
-        const b = readSubmissionKey({ form: 'receipt', scope: 'po-b', storage });
-        const other = readSubmissionKey({ form: 'request', storage });
-        expect(new Set([a, b, other]).size).toBe(3);
-        expect([...storage.store.keys()].sort()).toEqual([
-            'smrt:form-retry:receipt:po%2Fa:key',
-            'smrt:form-retry:receipt:po-b:key',
-            'smrt:form-retry:request:key',
-        ]);
-        clearSubmissionKey({ form: 'receipt', scope: 'po-b', storage });
-        expect(readSubmissionKey({ form: 'receipt', scope: 'po/a', storage })).toBe(a);
-    });
-    it('honours an explicit storage name, for migrating existing keys', () => {
-        const storage = memoryStorage();
-        storage.store.set('legacy:flha:submission-key', 'carried');
-        expect(readSubmissionKey({
-            form: 'flha',
-            storage,
-            storageKey: 'legacy:flha:submission-key',
-        })).toBe('carried');
-    });
-    it('uses this tab sessionStorage by default, never localStorage', () => {
-        const session = memoryStorage();
-        const local = memoryStorage();
-        vi.stubGlobal('sessionStorage', session);
-        vi.stubGlobal('localStorage', local);
-        const key = readSubmissionKey({ form: 'po' });
-        expect(session.store.get('smrt:form-retry:po:key')).toBe(key);
-        expect(local.store.size).toBe(0);
-        expect(isSubmissionKeyPersistent({ form: 'po' })).toBe(true);
-    });
-    it('private window: falls back to memory, and the key still survives a remount', () => {
-        const storage = refusingStorage();
-        const first = readSubmissionKey({ form: 'po', storage });
-        // One page, two mounts: the second read must find the same key or a retry
-        // after `enhance`'s error path would carry a key the server never saw.
-        expect(readSubmissionKey({ form: 'po', storage })).toBe(first);
-        expect(isSubmissionKeyPersistent({ form: 'po', storage })).toBe(false);
-        expect(() => clearSubmissionKey({ form: 'po', storage })).not.toThrow();
-        expect(readSubmissionKey({ form: 'po', storage })).not.toBe(first);
-    });
-    it('private window: survives the sessionStorage property itself throwing', () => {
-        const original = Object.getOwnPropertyDescriptor(globalThis, 'sessionStorage');
-        Object.defineProperty(globalThis, 'sessionStorage', {
-            configurable: true,
-            get() {
-                throw new DOMException('The operation is insecure.', 'SecurityError');
-            },
-        });
-        try {
-            const first = readSubmissionKey({ form: 'po' });
-            expect(first).toMatch(UUID_V4);
-            expect(readSubmissionKey({ form: 'po' })).toBe(first);
-        }
-        finally {
-            if (original)
-                Object.defineProperty(globalThis, 'sessionStorage', original);
-        }
-    });
-    it('a refused write (full quota) still reads back the same key', () => {
-        const storage = fullStorage();
-        const first = readSubmissionKey({ form: 'po', storage });
-        expect(readSubmissionKey({ form: 'po', storage })).toBe(first);
-    });
-    it('rotates even when the store refuses to remove the old key', () => {
-        const storage = stickyStorage();
-        const first = readSubmissionKey({ form: 'po', storage });
-        const rotated = rotateSubmissionKey({ form: 'po', storage });
-        expect(rotated).not.toBe(first);
-        expect(readSubmissionKey({ form: 'po', storage })).toBe(rotated);
-        expect(storage.store.get('smrt:form-retry:po:key')).toBe(rotated);
-        expect(isSubmissionKeyPersistent({ form: 'po', storage })).toBe(true);
-    });
-    it('rotates when removal AND the replacement write are refused over an existing key', () => {
-        const storage = stickyStorage(true);
-        storage.store.set('smrt:form-retry:po:key', 'stale-key');
-        expect(readSubmissionKey({ form: 'po', storage })).toBe('stale-key');
-        const rotated = rotateSubmissionKey({ form: 'po', storage });
-        expect(rotated).not.toBe('stale-key');
-        // The fresh key lives in memory and takes precedence over stale storage.
-        expect(readSubmissionKey({ form: 'po', storage })).toBe(rotated);
-        expect(isSubmissionKeyPersistent({ form: 'po', storage })).toBe(false);
-    });
-    it.each([
-        ['writes still work', false],
-        ['writes are refused too', true],
-    ])('clearing a key the store will not remove mints a fresh one (%s)', (_label, refuseWrites) => {
-        const storage = stickyStorage();
-        const first = readSubmissionKey({ form: 'po', storage });
-        storage.refuseWrites = refuseWrites;
-        clearSubmissionKey({ form: 'po', storage });
-        const next = readSubmissionKey({ form: 'po', storage });
-        expect(next).not.toBe(first);
-        expect(next).toMatch(UUID_V4);
-        expect(readSubmissionKey({ form: 'po', storage })).toBe(next);
-        expect(isSubmissionKeyPersistent({ form: 'po', storage })).toBe(!refuseWrites);
-    });
-    it('`storage: null` keeps everything in memory', () => {
-        const first = readSubmissionKey({ form: 'po', storage: null });
-        expect(readSubmissionKey({ form: 'po', storage: null })).toBe(first);
-        expect(isSubmissionKeyPersistent({ form: 'po', storage: null })).toBe(false);
-    });
-    it('mints distinct v4 UUIDs', () => {
-        const keys = new Set(Array.from({ length: 50 }, mintSubmissionKey));
-        expect(keys.size).toBe(50);
-        for (const key of keys)
-            expect(key).toMatch(UUID_V4);
-    });
-});

package/dist/components/forms/form-retry/__tests__/submitted-draft.test.js

@@ -1,334 +0,0 @@
-/**
- * The restore-after-reload draft (#3291): restored only under the key it was
- * submitted with, only for the owner who submitted it, only while fresh, only
- * when well-formed — and never at the cost of a thrown storage error.
- */
-import { describe, expect, it } from 'vitest';
-import { applyDraftToForm, clearSubmittedDraft, describeFormData, readSubmittedDraft, saveSubmittedDraft, } from '../submitted-draft.js';
-import { memoryStorage, refusingStorage, stickyStorage } from './storage.js';
-const TOKEN = 'aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa';
-const OWNER = 'tenant-1:person-1';
-const NAME = 'smrt:form-retry:report:draft';
-const ALWAYS = () => true;
-const SAVED_AT = new Date('2026-10-01T12:00:00Z');
-function save(storage, owner = OWNER) {
-    saveSubmittedDraft(storage, NAME, {
-        token: TOKEN,
-        owner,
-        savedAt: SAVED_AT,
-        fields: [
-            ['title', 'Trip over a hose'],
-            ['qty', '1'],
-            ['qty', '2'],
-        ],
-        files: [{ field: 'photo', name: 'a.jpg', type: 'image/jpeg', size: 3 }],
-        values: { captureKey: 'k-1' },
-    });
-}
-describe('saveSubmittedDraft / readSubmittedDraft', () => {
-    it('restores exactly what was submitted, under the same key and owner', () => {
-        const storage = memoryStorage();
-        save(storage);
-        expect(readSubmittedDraft(storage, NAME, {
-            token: TOKEN,
-            owner: OWNER,
-            fresh: ALWAYS,
-        })).toEqual({
-            token: TOKEN,
-            savedAt: SAVED_AT,
-            fields: [
-                ['title', 'Trip over a hose'],
-                ['qty', '1'],
-                ['qty', '2'],
-            ],
-            files: [{ field: 'photo', name: 'a.jpg', type: 'image/jpeg', size: 3 }],
-            values: { captureKey: 'k-1' },
-        });
-    });
-    it('does not restore under a new key, and drops the stale draft', () => {
-        const storage = memoryStorage();
-        save(storage);
-        expect(readSubmittedDraft(storage, NAME, {
-            token: 'bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb',
-            owner: OWNER,
-            fresh: ALWAYS,
-        })).toBeNull();
-        expect(storage.store.size).toBe(0);
-    });
-    it('never restores one person’s draft for another on shared hardware', () => {
-        const storage = memoryStorage();
-        save(storage);
-        expect(readSubmittedDraft(storage, NAME, {
-            token: TOKEN,
-            owner: 'tenant-1:person-2',
-            fresh: ALWAYS,
-        })).toBeNull();
-        expect(storage.store.size).toBe(0);
-    });
-    it('never restores for an empty owner', () => {
-        const storage = memoryStorage();
-        save(storage, '');
-        expect(readSubmittedDraft(storage, NAME, {
-            token: TOKEN,
-            owner: '',
-            fresh: ALWAYS,
-        })).toBeNull();
-    });
-    it('drops an expired draft', () => {
-        const storage = memoryStorage();
-        save(storage);
-        const seen = [];
-        expect(readSubmittedDraft(storage, NAME, {
-            token: TOKEN,
-            owner: OWNER,
-            fresh: (savedAt) => {
-                seen.push(savedAt);
-                return false;
-            },
-        })).toBeNull();
-        expect(seen).toEqual([SAVED_AT]);
-        expect(storage.store.size).toBe(0);
-    });
-    it('drops a draft that is malformed or not JSON', () => {
-        const storage = memoryStorage();
-        const bad = [
-            '{not json',
-            JSON.stringify({
-                v: 2,
-                token: TOKEN,
-                owner: OWNER,
-                savedAt: 1,
-                fields: [],
-                files: [],
-            }),
-            JSON.stringify({
-                v: 1,
-                token: TOKEN,
-                owner: OWNER,
-                fields: [],
-                files: [],
-            }),
-            JSON.stringify({
-                v: 1,
-                token: TOKEN,
-                owner: OWNER,
-                savedAt: 1,
-                fields: [['a', 1]],
-                files: [],
-            }),
-            JSON.stringify({
-                v: 1,
-                token: TOKEN,
-                owner: OWNER,
-                savedAt: 1,
-                fields: [],
-                files: [{ field: 'p' }],
-            }),
-        ];
-        for (const raw of bad) {
-            storage.store.set(NAME, raw);
-            expect(readSubmittedDraft(storage, NAME, {
-                token: TOKEN,
-                owner: OWNER,
-                fresh: ALWAYS,
-            }), raw).toBeNull();
-            expect(storage.store.size, raw).toBe(0);
-        }
-    });
-    it('clears', () => {
-        const storage = memoryStorage();
-        save(storage);
-        clearSubmittedDraft(storage, NAME);
-        expect(storage.store.size).toBe(0);
-    });
-    it('survives a browser that refuses storage (private window)', () => {
-        const storage = refusingStorage();
-        expect(() => saveSubmittedDraft(storage, NAME, {
-            token: TOKEN,
-            owner: OWNER,
-            savedAt: SAVED_AT,
-            fields: [],
-            files: [],
-        })).not.toThrow();
-        expect(() => clearSubmittedDraft(storage, NAME)).not.toThrow();
-    });
-    it('skips a values capture that cannot be serialized', () => {
-        const storage = memoryStorage();
-        const cyclic = {};
-        cyclic.self = cyclic;
-        saveSubmittedDraft(storage, NAME, {
-            token: TOKEN,
-            owner: OWNER,
-            savedAt: SAVED_AT,
-            fields: [],
-            files: [],
-            values: cyclic,
-        });
-        expect(storage.store.size).toBe(0);
-    });
-});
-describe('a later attempt whose values cannot be serialized', () => {
-    it('clears the earlier attempt’s draft instead of leaving it to be restored', () => {
-        const storage = memoryStorage();
-        save(storage);
-        expect(storage.store.has(NAME)).toBe(true);
-        const cyclic = {};
-        cyclic.self = cyclic;
-        saveSubmittedDraft(storage, NAME, {
-            token: TOKEN,
-            owner: OWNER,
-            savedAt: SAVED_AT,
-            fields: [['title', 'A different submission']],
-            files: [],
-            values: cyclic,
-        });
-        expect(readSubmittedDraft(storage, NAME, {
-            token: TOKEN,
-            owner: OWNER,
-            fresh: ALWAYS,
-        })).toBeNull();
-        expect(storage.store.has(NAME)).toBe(false);
-    });
-});
-describe('a store that refuses to remove the draft', () => {
-    const read = (storage) => readSubmittedDraft(storage, NAME, {
-        token: TOKEN,
-        owner: OWNER,
-        fresh: ALWAYS,
-    });
-    it.each([
-        ['writes still work', false],
-        ['writes are refused too', true],
-    ])('clearing leaves nothing to restore (%s)', (_label, refuseWrites) => {
-        const storage = stickyStorage();
-        save(storage);
-        expect(read(storage)).not.toBeNull();
-        storage.refuseWrites = refuseWrites;
-        clearSubmittedDraft(storage, NAME);
-        expect(read(storage)).toBeNull();
-    });
-    it.each([
-        ['writes still work', false],
-        ['writes are refused too', true],
-    ])('an unserializable later attempt leaves nothing to restore (%s)', (_label, refuseWrites) => {
-        const storage = stickyStorage();
-        save(storage);
-        storage.refuseWrites = refuseWrites;
-        const cyclic = {};
-        cyclic.self = cyclic;
-        saveSubmittedDraft(storage, NAME, {
-            token: TOKEN,
-            owner: OWNER,
-            savedAt: SAVED_AT,
-            fields: [['title', 'A different submission']],
-            files: [],
-            values: cyclic,
-        });
-        expect(read(storage)).toBeNull();
-    });
-    it('a draft rejected at read time (another owner) is not restored later', () => {
-        const storage = stickyStorage();
-        save(storage);
-        expect(readSubmittedDraft(storage, NAME, {
-            token: TOKEN,
-            owner: 'tenant-1:person-2',
-            fresh: ALWAYS,
-        })).toBeNull();
-        expect(read(storage)).toBeNull();
-    });
-    it('a later save replaces the invalidation', () => {
-        const storage = stickyStorage();
-        save(storage);
-        clearSubmittedDraft(storage, NAME);
-        save(storage);
-        expect(read(storage)?.fields[0]).toEqual(['title', 'Trip over a hose']);
-    });
-});
-describe('describeFormData', () => {
-    it('keeps text entries in order, describes chosen files, skips excluded names', () => {
-        const data = new FormData();
-        data.append('submissionKey', TOKEN);
-        data.append('title', 'x');
-        data.append('photo', new File(['abc'], 'a.jpg', { type: 'image/jpeg' }));
-        data.append('photo', new File([], '', { type: 'application/octet-stream' }));
-        data.append('title', 'y');
-        expect(describeFormData(data, new Set(['submissionKey']))).toEqual({
-            fields: [
-                ['title', 'x'],
-                ['title', 'y'],
-            ],
-            files: [{ field: 'photo', name: 'a.jpg', type: 'image/jpeg', size: 3 }],
-        });
-    });
-});
-describe('applyDraftToForm', () => {
-    function formOf(html) {
-        document.body.innerHTML = `<form>${html}</form>`;
-        const form = document.body.querySelector('form');
-        if (!form)
-            throw new Error('no form');
-        return form;
-    }
-    it('puts values back by name and order, and notifies bindings', () => {
-        const form = formOf(`
-      <input type="hidden" name="jobId" value="server" />
-      <input name="title" />
-      <input name="qty" /><input name="qty" />
-      <textarea name="notes"></textarea>
-      <select name="unit"><option value="pcs">pcs</option><option value="ft">ft</option></select>
-      <select name="tags" multiple><option value="a" selected>a</option><option value="b">b</option></select>
-      <input type="checkbox" name="urgent" value="yes" />
-      <input type="checkbox" name="checked" value="on" checked />
-      <input type="radio" name="sev" value="minor" checked /><input type="radio" name="sev" value="major" />
-      <input type="password" name="pin" />
-      <input type="file" name="photo" />
-      <input name="secret" />
-    `);
-        const events = [];
-        form.addEventListener('input', (event) => {
-            events.push(event.target.name);
-        });
-        applyDraftToForm(form, {
-            fields: [
-                ['jobId', 'restored'],
-                ['title', 'Trip'],
-                ['qty', '1'],
-                ['qty', '2'],
-                ['notes', 'by the hose'],
-                ['unit', 'ft'],
-                ['tags', 'b'],
-                ['urgent', 'yes'],
-                ['sev', 'major'],
-                ['pin', '1234'],
-                ['secret', 'leaked'],
-            ],
-        }, new Set(['secret']));
-        const value = (selector) => form.querySelector(selector).value;
-        const checked = (selector) => form.querySelector(selector).checked;
-        expect(value('[name=jobId]')).toBe('server');
-        expect(value('[name=title]')).toBe('Trip');
-        expect(Array.from(form.querySelectorAll('[name=qty]'), (q) => q.value)).toEqual(['1', '2']);
-        expect(value('[name=notes]')).toBe('by the hose');
-        expect(value('[name=unit]')).toBe('ft');
-        expect(Array.from(form.querySelector('[name=tags]')
-            .selectedOptions, (o) => o.value)).toEqual(['b']);
-        expect(checked('[name=urgent]')).toBe(true);
-        // Submitted unchecked (absent from the draft): unchecked again.
-        expect(checked('[name=checked]')).toBe(false);
-        expect(checked('[value=major]')).toBe(true);
-        expect(value('[name=pin]')).toBe('');
-        expect(value('[name=secret]')).toBe('');
-        expect(events).toEqual(expect.arrayContaining([
-            'title',
-            'qty',
-            'notes',
-            'unit',
-            'tags',
-            'urgent',
-            'checked',
-            'sev',
-        ]));
-        expect(events).not.toContain('jobId');
-        expect(events).not.toContain('pin');
-    });
-});

package/dist/components/layout/__tests__/Container.test.js

@@ -1,62 +0,0 @@
-/**
- * Component tests for the Container layout primitive (Sweep S11, #1416).
- *
- * Mirrors the Button golden pattern: render via Testing Library, assert the
- * rendered DOM/class/attribute API, and prove axe-clean output.
- */
-import { render, screen } from '@testing-library/svelte';
-import { createRawSnippet } from 'svelte';
-import { describe, expect, it } from 'vitest';
-import { expectNoA11yViolations } from '../../../test-support/a11y';
-import Container from '../Container.svelte';
-/** Build a text Snippet for the `children` prop. */
-function textSnippet(text) {
-    return createRawSnippet(() => ({ render: () => `<span>${text}</span>` }));
-}
-describe('Container', () => {
-    it('renders slotted children', () => {
-        render(Container, { props: { children: textSnippet('Inside') } });
-        expect(screen.getByText('Inside')).toBeInTheDocument();
-    });
-    it('applies the default lg max-width class', () => {
-        const { container } = render(Container, {
-            props: { children: textSnippet('x') },
-        });
-        const div = container.querySelector('div.container');
-        expect(div).not.toBeNull();
-        expect(div).toHaveClass('container', 'max-w-lg');
-    });
-    it.each([
-        'sm',
-        'md',
-        'lg',
-        'xl',
-        'full',
-    ])('maps maxWidth=%s to the max-w-%s class', (maxWidth) => {
-        const { container } = render(Container, {
-            props: { maxWidth, children: textSnippet('x') },
-        });
-        expect(container.querySelector('div.container')).toHaveClass(`max-w-${maxWidth}`);
-    });
-    it('passes ...rest attributes through to the root element', () => {
-        const { container } = render(Container, {
-            props: {
-                children: textSnippet('x'),
-                id: 'main-region',
-                'data-testid': 'wrap',
-                role: 'region',
-                'aria-label': 'Main content',
-            },
-        });
-        const div = container.querySelector('div.container');
-        expect(div).toHaveAttribute('id', 'main-region');
-        expect(div).toHaveAttribute('data-testid', 'wrap');
-        expect(screen.getByRole('region', { name: 'Main content' })).toBe(div);
-    });
-    it('is axe-clean with content', async () => {
-        const { container } = render(Container, {
-            props: { children: textSnippet('Accessible content') },
-        });
-        await expectNoA11yViolations(container);
-    });
-});