@happyvertical/smrt-ui 0.53.1 → 0.53.2

package/dist/components/data/__tests__/data-table-helpers.test.js

@@ -1,36 +0,0 @@
-/**
- * Unit tests for DataTable sort/accessor helpers (coverage uplift, S6 gate).
- */
-import { describe, expect, it } from 'vitest';
-import { defaultSort, getNestedValue } from '../types';
-describe('getNestedValue', () => {
-    it('reads dot-notation paths', () => {
-        expect(getNestedValue({ a: { b: 5 } }, 'a.b')).toBe(5);
-        expect(getNestedValue({ a: 1 }, 'a')).toBe(1);
-    });
-    it('returns undefined for missing paths / non-objects', () => {
-        expect(getNestedValue({ a: 1 }, 'x.y')).toBeUndefined();
-        expect(getNestedValue(null, 'a')).toBeUndefined();
-    });
-});
-describe('defaultSort', () => {
-    it('returns 0 when direction is null', () => {
-        expect(defaultSort({ a: 1 }, { a: 2 }, 'a', null)).toBe(0);
-    });
-    it('sorts numbers by direction', () => {
-        expect(defaultSort({ a: 1 }, { a: 2 }, 'a', 'asc')).toBeLessThan(0);
-        expect(defaultSort({ a: 1 }, { a: 2 }, 'a', 'desc')).toBeGreaterThan(0);
-    });
-    it('sorts strings and dates', () => {
-        expect(defaultSort({ a: 'apple' }, { a: 'banana' }, 'a', 'asc')).toBeLessThan(0);
-        expect(defaultSort({ a: new Date(1) }, { a: new Date(2) }, 'a', 'asc')).toBeLessThan(0);
-    });
-    it('handles nullish values', () => {
-        expect(defaultSort({ a: null }, { a: 1 }, 'a', 'asc')).toBeGreaterThan(0);
-        expect(defaultSort({ a: 1 }, { a: null }, 'a', 'asc')).toBeLessThan(0);
-        expect(defaultSort({ a: null }, { a: null }, 'a', 'asc')).toBe(0);
-    });
-    it('falls back to string compare for mixed types', () => {
-        expect(typeof defaultSort({ a: true }, { a: false }, 'a', 'asc')).toBe('number');
-    });
-});

package/dist/components/data/__tests__/data-table-surface.test.js

@@ -1,49 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { DATA_TABLE_SURFACE_CONTROL_IDS, dataTableCommandFromDataSurfaceCommand, } from '../data-table-surface.js';
-const identity = { surfaceId: 'pin', kind: 'table' };
-function command(controlId, payload) {
-    return {
-        version: 1,
-        commandId: 'pin',
-        identity,
-        expectedRevision: 0,
-        controlId,
-        ...(payload === undefined ? {} : { payload }),
-    };
-}
-/**
- * A minimal, valid payload for each canonical table controlId — proof that
- * `DATA_TABLE_SURFACE_CONTROL_IDS` names exactly the ids
- * `dataTableCommandFromDataSurfaceCommand` translates, not a superset or
- * subset. Consumers (e.g. `@happyvertical/smrt-svelte`'s
- * `mountListDataSurface`) rely on this enumeration to distinguish "a table
- * command whose payload failed to translate" from "a genuinely unknown
- * control" — drift here would silently break that distinction.
- */
-const VALID_PAYLOADS = {
-    'set-search': { search: 'x' },
-    'set-filters': { filters: [] },
-    'set-sorting': { sorting: [] },
-    'toggle-sorting': { columnId: 'title' },
-    'set-page': { page: 1 },
-    'set-page-size': { pageSize: 25 },
-    'set-column-order': { columnIds: ['title'] },
-    'set-column-visibility': { columns: [] },
-    'set-selected-rows': { rowIds: [] },
-    'toggle-row-selection': { rowId: 'a' },
-    'set-expanded-rows': { rowIds: [] },
-    'toggle-row-expansion': { rowId: 'a' },
-    reset: undefined,
-};
-describe('DATA_TABLE_SURFACE_CONTROL_IDS', () => {
-    it('names exactly the ids dataTableCommandFromDataSurfaceCommand translates', () => {
-        for (const controlId of DATA_TABLE_SURFACE_CONTROL_IDS) {
-            expect(dataTableCommandFromDataSurfaceCommand(command(controlId, VALID_PAYLOADS[controlId])), `expected controlId "${controlId}" to translate with its documented valid payload`).not.toBeNull();
-        }
-    });
-    it('does not include a genuinely unknown/custom controlId', () => {
-        expect(DATA_TABLE_SURFACE_CONTROL_IDS).not.toContain('refresh');
-        expect(DATA_TABLE_SURFACE_CONTROL_IDS).not.toContain('focus');
-        expect(dataTableCommandFromDataSurfaceCommand(command('a-bespoke-control'))).toBeNull();
-    });
-});

package/dist/components/data/__tests__/link-step-surface.test.js

@@ -1,172 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createDataSurfaceRegistry } from '../data-surface.js';
-import { registerLinkSurface, resolveLinkTarget } from '../link-surface.js';
-import { registerStepSurface } from '../step-surface.js';
-const links = [
-    { id: 'events', label: 'Events', href: '/s/events', group: 'Content' },
-    { id: 'articles', label: 'Articles', href: '/s/articles', group: 'Content' },
-    { id: 'ads', label: 'Advertising', href: '/s/ads' },
-];
-let sequence = 0;
-function command(surfaceId, kind, controlId, expectedRevision, payload) {
-    sequence += 1;
-    return {
-        version: 1,
-        commandId: `c${sequence}`,
-        identity: { surfaceId, kind },
-        expectedRevision,
-        controlId,
-        ...(payload === undefined ? {} : { payload: payload }),
-    };
-}
-describe('link surface', () => {
-    it('resolves by id, label, and unique prefix; refuses ambiguity', () => {
-        expect(resolveLinkTarget('events', links)).toBe('/s/events');
-        expect(resolveLinkTarget({ target: 'ARTICLES' }, links)).toBe('/s/articles');
-        expect(resolveLinkTarget({ page: 'adv' }, links)).toBe('/s/ads');
-        expect(resolveLinkTarget('a', links)).toBeNull();
-        expect(resolveLinkTarget({ nope: 1 }, links)).toBeNull();
-    });
-    it('publishes links without hrefs and navigates through the open control', async () => {
-        const registry = createDataSurfaceRegistry();
-        const navigate = vi.fn();
-        const handle = registerLinkSurface({
-            registry,
-            surfaceId: 'site-sections',
-            label: 'Site sections',
-            description: 'Pages in this site',
-            links,
-            navigate,
-        });
-        const snapshot = registry.inspect({
-            surfaceId: 'site-sections',
-            kind: 'list',
-        });
-        expect(JSON.stringify(snapshot?.state)).not.toContain('/s/');
-        expect(snapshot?.state.links).toEqual([
-            { id: 'events', label: 'Events', group: 'Content' },
-            { id: 'articles', label: 'Articles', group: 'Content' },
-            { id: 'ads', label: 'Advertising' },
-        ]);
-        const ok = await registry.execute(command('site-sections', 'list', 'open', snapshot?.revision ?? 0, {
-            target: 'Events',
-        }));
-        expect(ok.ok).toBe(true);
-        expect(navigate).toHaveBeenCalledWith('/s/events');
-        const refused = await registry.execute(command('site-sections', 'list', 'open', snapshot?.revision ?? 0, {
-            target: 'https://evil.example',
-        }));
-        expect(refused.ok).toBe(false);
-        handle.update({ state: { active: 'events' } });
-        expect(registry.inspect({ surfaceId: 'site-sections', kind: 'list' })?.revision).toBe((snapshot?.revision ?? 0) + 1);
-        handle.destroy();
-        expect(registry.list()).toHaveLength(0);
-    });
-});
-describe('step surface', () => {
-    const steps = [
-        { id: 'town', label: 'Your town' },
-        { id: 'features', label: 'Features' },
-        { id: 'live', label: 'Go live' },
-    ];
-    const identity = { surfaceId: 'new-site-steps', kind: 'custom' };
-    it('advances a non-writing step through the page handler', async () => {
-        const registry = createDataSurfaceRegistry();
-        const next = vi.fn(() => true);
-        const handle = registerStepSurface({
-            registry,
-            surfaceId: 'new-site-steps',
-            label: 'New site steps',
-            description: 'Start a new town site',
-            steps,
-            current: 'town',
-            next,
-        });
-        const before = registry.inspect(identity);
-        expect(before?.state).toMatchObject({
-            current: 'town',
-            currentLabel: 'Your town',
-            stepNumber: 1,
-            stepCount: 3,
-            nextWrites: false,
-            awaitingPerson: false,
-        });
-        const result = await registry.execute(command('new-site-steps', 'custom', 'next', before?.revision ?? 0));
-        expect(result.ok).toBe(true);
-        expect(next).toHaveBeenCalledTimes(1);
-        handle.update({
-            current: 'features',
-            steps: [{ ...steps[0], complete: true }, steps[1], steps[2]],
-        });
-        const after = registry.inspect(identity);
-        expect(after?.state.current).toBe('features');
-        expect(after?.state.steps).toEqual([
-            { id: 'town', label: 'Your town', status: 'complete' },
-            { id: 'features', label: 'Features', status: 'current' },
-            { id: 'live', label: 'Go live', status: 'upcoming' },
-        ]);
-    });
-    it('refuses when the page handler rejects the step (validation failed)', async () => {
-        const registry = createDataSurfaceRegistry();
-        registerStepSurface({
-            registry,
-            surfaceId: 'new-site-steps',
-            label: 'New site steps',
-            description: 'Start a new town site',
-            steps,
-            current: 'town',
-            next: () => false,
-        });
-        const result = await registry.execute(command('new-site-steps', 'custom', 'next', 1));
-        expect(result.ok).toBe(false);
-    });
-    it('never presses a writing step: it shows the button and waits for the person', async () => {
-        const registry = createDataSurfaceRegistry();
-        const create = vi.fn();
-        const showNext = vi.fn();
-        const handle = registerStepSurface({
-            registry,
-            surfaceId: 'new-site-steps',
-            label: 'New site steps',
-            description: 'Start a new town site',
-            steps,
-            current: 'features',
-            next: create,
-            nextWrites: true,
-            showNext,
-        });
-        const result = await registry.execute(command('new-site-steps', 'custom', 'next', 1));
-        expect(result.ok).toBe(true);
-        expect(create).not.toHaveBeenCalled();
-        expect(showNext).toHaveBeenCalledTimes(1);
-        expect(registry.inspect(identity)?.state).toMatchObject({
-            nextWrites: true,
-            awaitingPerson: true,
-        });
-        handle.update({ current: 'live', nextWrites: false });
-        expect(registry.inspect(identity)?.state.awaitingPerson).toBe(false);
-    });
-    it('goes back and jumps only to available steps', async () => {
-        const registry = createDataSurfaceRegistry();
-        const back = vi.fn();
-        const goTo = vi.fn();
-        registerStepSurface({
-            registry,
-            surfaceId: 'new-site-steps',
-            label: 'New site steps',
-            description: 'Start a new town site',
-            steps: [{ ...steps[0], complete: true }, steps[1], steps[2]],
-            current: 'features',
-            back,
-            goTo,
-        });
-        expect((await registry.execute(command('new-site-steps', 'custom', 'back', 1)))
-            .ok).toBe(true);
-        expect(back).toHaveBeenCalled();
-        expect((await registry.execute(command('new-site-steps', 'custom', 'go-to', 1, {
-            target: 'Go live',
-        }))).ok).toBe(false);
-        expect((await registry.execute(command('new-site-steps', 'custom', 'go-to', 1, 'your town'))).ok).toBe(true);
-        expect(goTo).toHaveBeenCalledWith('town');
-    });
-});

package/dist/components/data/__tests__/list-sort-state.svelte.test.js

@@ -1,71 +0,0 @@
-import { fireEvent, render, screen } from '@testing-library/svelte';
-import { describe, expect, it, vi } from 'vitest';
-import ListSortSelect from '../ListSortSelect.svelte';
-import { createLocalListSort, createUrlListSort, } from '../list-sort-state.svelte.js';
-import SortableHeader from '../SortableHeader.svelte';
-const spec = {
-    columns: [{ id: 'published', firstDirection: 'desc' }, 'title'],
-    default: { columnId: 'published', direction: 'desc' },
-};
-describe('list sort state', () => {
-    it('local: starts at the default and toggles', () => {
-        const list = createLocalListSort(spec);
-        expect(list.sort).toEqual(spec.default);
-        list.toggle('title');
-        expect(list.sort).toEqual({ columnId: 'title', direction: 'asc' });
-        list.toggle('title');
-        expect(list.sort).toEqual({ columnId: 'title', direction: 'desc' });
-        expect(list.href('title')).toBeUndefined();
-    });
-    it('url: reads the URL, links headers, and navigates on set', async () => {
-        let url = new URL('https://x.test/list?sort=title&dir=asc&page=3');
-        const navigate = vi.fn((href) => {
-            url = new URL(href, url);
-        });
-        const list = createUrlListSort(spec, { url: () => url, navigate });
-        expect(list.sort).toEqual({ columnId: 'title', direction: 'asc' });
-        expect(list.href('title')).toBe('/list?sort=title&dir=desc');
-        expect(list.href('published')).toBe('/list');
-        await list.set({ columnId: 'published', direction: 'asc' });
-        expect(navigate).toHaveBeenCalledWith('/list?sort=published&dir=asc');
-    });
-    it('ignores an undeclared column or unknown direction on set', async () => {
-        const local = createLocalListSort(spec);
-        local.set({ columnId: 'secret_score', direction: 'asc' });
-        expect(local.sort).toEqual(spec.default);
-        local.set({ columnId: 'title', direction: 'sideways' });
-        expect(local.sort).toEqual(spec.default);
-        local.set({ columnId: 'title', direction: 'asc' });
-        expect(local.sort).toEqual({ columnId: 'title', direction: 'asc' });
-        // An invalid initial sort starts at the default.
-        expect(createLocalListSort(spec, { columnId: 'nope', direction: 'asc' }).sort).toEqual(spec.default);
-        const navigate = vi.fn();
-        const url = new URL('https://x.test/list');
-        const remote = createUrlListSort(spec, { url: () => url, navigate });
-        await remote.set({ columnId: 'secret_score', direction: 'desc' });
-        await remote.set(null);
-        expect(navigate).not.toHaveBeenCalled();
-    });
-    it('drives SortableHeader and ListSortSelect through `list`', async () => {
-        const list = createLocalListSort(spec);
-        render(SortableHeader, {
-            props: { list, columnId: 'title', label: 'Title', as: 'div' },
-        });
-        const header = screen.getByRole('columnheader');
-        expect(header.getAttribute('aria-sort')).toBe('none');
-        await fireEvent.click(screen.getByRole('button', { name: 'Sort by Title, ascending' }));
-        expect(list.sort).toEqual({ columnId: 'title', direction: 'asc' });
-        render(ListSortSelect, {
-            props: {
-                list,
-                columns: [
-                    { id: 'published', label: 'Published', kind: 'date' },
-                    { id: 'title', label: 'Title' },
-                ],
-            },
-        });
-        const select = screen.getByLabelText('Sort by');
-        await fireEvent.change(select, { target: { value: 'published:desc' } });
-        expect(list.sort).toEqual(spec.default);
-    });
-});

package/dist/components/data/__tests__/list-sort.test.js

@@ -1,91 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { compareListValues, isValidListSort, listSortAria, listSortHref, listSortOrderBy, listSortSearchParams, parseListSort, sortListRows, toggleListSort, } from '../list-sort.js';
-const spec = {
-    columns: [
-        { id: 'published', firstDirection: 'desc' },
-        'title',
-        { id: 'views', firstDirection: 'desc' },
-    ],
-    default: { columnId: 'published', direction: 'desc' },
-};
-describe('list sort', () => {
-    it('parses the URL, falling back to the default for unknown values', () => {
-        expect(parseListSort(new URLSearchParams(''), spec)).toEqual(spec.default);
-        expect(parseListSort(new URLSearchParams('sort=title&dir=desc'), spec)).toEqual({
-            columnId: 'title',
-            direction: 'desc',
-        });
-        expect(parseListSort(new URLSearchParams('sort=title'), spec)).toEqual({
-            columnId: 'title',
-            direction: 'asc',
-        });
-        expect(parseListSort(new URLSearchParams('sort=views'), spec)).toEqual({
-            columnId: 'views',
-            direction: 'desc',
-        });
-        expect(parseListSort(new URLSearchParams('sort=password&dir=asc'), spec)).toEqual(spec.default);
-        expect(parseListSort(new URLSearchParams('dir=asc'), spec)).toEqual({
-            columnId: 'published',
-            direction: 'asc',
-        });
-        expect(parseListSort(new URLSearchParams('sort=title&dir=sideways'), spec)).toEqual({
-            columnId: 'title',
-            direction: 'asc',
-        });
-    });
-    it('toggles asc/desc and starts a new column at its first direction', () => {
-        const start = spec.default;
-        expect(toggleListSort(start, 'published', spec)).toEqual({
-            columnId: 'published',
-            direction: 'asc',
-        });
-        expect(toggleListSort({ columnId: 'published', direction: 'asc' }, 'published', spec)).toEqual(start);
-        expect(toggleListSort(start, 'title', spec)).toEqual({
-            columnId: 'title',
-            direction: 'asc',
-        });
-        expect(toggleListSort(start, 'views', spec)).toEqual({
-            columnId: 'views',
-            direction: 'desc',
-        });
-        expect(toggleListSort(start, 'nope', spec)).toBe(start);
-        expect(isValidListSort(spec, { columnId: 'nope', direction: 'asc' })).toBe(false);
-    });
-    it('writes the sort to the URL, omits the default, and resets the page', () => {
-        const params = listSortSearchParams('status=draft&page=3', { columnId: 'title', direction: 'asc' }, spec);
-        expect(params.toString()).toBe('status=draft&sort=title&dir=asc');
-        expect(listSortSearchParams('sort=title&dir=asc&page=2', spec.default, spec).toString()).toBe('');
-        expect(listSortSearchParams('sort=title&dir=asc&page=2', { columnId: 'title', direction: 'asc' }, spec).toString()).toBe('sort=title&dir=asc&page=2');
-        expect(listSortHref(new URL('https://x.test/a?page=2'), { columnId: 'views', direction: 'desc' }, spec)).toBe('/a?sort=views&dir=desc');
-        expect(listSortHref(new URL('https://x.test/a?page=2'), spec.default, spec)).toBe('/a?page=2');
-    });
-    it('reports aria-sort', () => {
-        expect(listSortAria(spec.default, 'published')).toBe('descending');
-        expect(listSortAria({ columnId: 'title', direction: 'asc' }, 'title')).toBe('ascending');
-        expect(listSortAria(spec.default, 'title')).toBe('none');
-    });
-    it('sorts rows stably with empty values last in both directions', () => {
-        const rows = [
-            { id: 1, at: '2026-01-02' },
-            { id: 2, at: null },
-            { id: 3, at: '2026-03-01' },
-            { id: 4, at: '2026-01-02' },
-        ];
-        const value = (row) => row.at;
-        expect(sortListRows(rows, { columnId: 'at', direction: 'desc' }, value).map((r) => r.id)).toEqual([3, 1, 4, 2]);
-        expect(sortListRows(rows, { columnId: 'at', direction: 'asc' }, value).map((r) => r.id)).toEqual([1, 4, 3, 2]);
-        expect(compareListValues('item 2', 'item 10', 'asc')).toBeLessThan(0);
-        expect(compareListValues(new Date('2026-01-01'), new Date('2025-01-01'), 'desc')).toBeLessThan(0);
-    });
-    it('builds ORDER BY only from the allow-list', () => {
-        const map = {
-            published: 'COALESCE(c.publish_date, c.created_at)',
-            title: 'c.title',
-        };
-        expect(listSortOrderBy(spec.default, map)).toBe('COALESCE(c.publish_date, c.created_at) DESC NULLS LAST');
-        expect(listSortOrderBy({ columnId: 'title', direction: 'asc' }, map, {
-            nulls: false,
-        })).toBe('c.title ASC');
-        expect(() => listSortOrderBy({ columnId: 'title; drop', direction: 'asc' }, map)).toThrow();
-    });
-});