Expand Soma component coverage

src/uix/soma/components/popover/popover-provider.svelte.test.ts

@@ -0,0 +1,121 @@
+// @vitest-environment jsdom
+
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { createActiveDom } from '$adom';
+import { createActiveTimers } from '$timer';
+import { state } from '$libs/reactive';
+import type { Morfo } from '$uix/morfo';
+import { Soma } from '$soma/core/soma.svelte';
+import {
+	createSomaRuntime,
+	type EventEngineEmitter,
+	type SomaRuntimeSources
+} from '$soma/runtime.svelte';
+import { FloatingProvider } from '$soma/layers/floating';
+
+import { PopoverProvider } from './popover-provider.svelte';
+
+function withEffectRoot<T>(fn: () => T): { result: T; cleanup: () => void } {
+	let result!: T;
+	const cleanup = $effect.root(() => {
+		result = fn();
+	});
+	return { result, cleanup };
+}
+
+function installSomaHarness() {
+	const dom = createActiveDom();
+	const timers = createActiveTimers();
+	const eventEngine = { emit: vi.fn(async () => {}) } satisfies EventEngineEmitter;
+	const soma = {
+		dom,
+		events: eventEngine,
+		uix: { timers },
+		runtime: (morfo: Morfo, sources: Omit<SomaRuntimeSources, 'dom' | 'eventEngine'>) =>
+			createSomaRuntime(morfo, {
+				dom,
+				eventEngine,
+				translate: (key) => key,
+				...sources
+			})
+	} as unknown as Soma;
+
+	vi.spyOn(Soma, 'require').mockReturnValue(soma);
+	vi.spyOn(PopoverProvider.ctx, 'set').mockImplementation((value) => value);
+	vi.spyOn(FloatingProvider, 'create').mockReturnValue({} as FloatingProvider);
+
+	return { dom, eventEngine, timers };
+}
+
+function createPopoverOpts() {
+	return {
+		id: state('popover-root'),
+		ref: state<HTMLElement | null>(null),
+		open: state(false),
+		modal: state(false),
+		onOpenChangeComplete: state(() => {})
+	};
+}
+
+describe('PopoverProvider', () => {
+	afterEach(() => {
+		vi.useRealTimers();
+		vi.restoreAllMocks();
+		document.body.innerHTML = '';
+	});
+
+	it('toggles open state directly for imperative callers', () => {
+		const { dom, timers } = installSomaHarness();
+		const opts = createPopoverOpts();
+
+		const { result: provider, cleanup } = withEffectRoot(() => PopoverProvider.create(opts));
+
+		provider.toggle();
+		expect(opts.open.current).toBe(true);
+		provider.toggle();
+		expect(opts.open.current).toBe(false);
+
+		cleanup();
+		timers.dispose();
+		dom.dispose();
+	});
+
+	it('drives hover open and close through timers and the morfo runtime', async () => {
+		vi.useFakeTimers();
+		const { dom, eventEngine, timers } = installSomaHarness();
+		const opts = createPopoverOpts();
+		const target = document.createElement('button');
+		document.body.appendChild(target);
+
+		const { result: provider, cleanup } = withEffectRoot(() => {
+			const p = PopoverProvider.create(opts);
+			p.contentId.current = 'popover-content';
+			p.runtime.part('content', {
+				id: state('popover-content'),
+				ref: state<HTMLElement | null>(target),
+				syncAttrs: true
+			});
+			return p;
+		});
+		provider.setTriggerRef(target);
+
+		provider.scheduleHoverOpen(25, target);
+		await vi.advanceTimersByTimeAsync(25);
+
+		expect(opts.open.current).toBe(true);
+		expect(eventEngine.emit).toHaveBeenCalledWith(
+			expect.objectContaining({ name: 'present', family: 'emerge', target })
+		);
+
+		provider.scheduleHoverClose(25);
+		await vi.advanceTimersByTimeAsync(25);
+
+		expect(opts.open.current).toBe(false);
+		expect(target.getAttribute('data-last-action')).toBe('dismissed');
+
+		cleanup();
+		timers.dispose();
+		dom.dispose();
+	});
+});

src/uix/soma/components/range-calendar/range-calendar-provider.svelte.test.ts

@@ -0,0 +1,143 @@
+// @vitest-environment jsdom
+
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { createActiveDom } from '$adom';
+import { state } from '$libs/reactive';
+import type { Morfo } from '$uix/morfo';
+import { CalendarDate, type DateMatcher, type DateRange } from '$libs/days';
+import { Soma } from '$soma/core/soma.svelte';
+import { createSomaRuntime, type SomaRuntimeSources } from '$soma/runtime.svelte';
+
+import {
+	RangeCalendarProvider,
+	resolveInitialRangeCalendarPlaceholder
+} from './range-calendar-provider.svelte';
+
+function withEffectRoot<T>(fn: () => T): { result: T; cleanup: () => void } {
+	let result!: T;
+	const cleanup = $effect.root(() => {
+		result = fn();
+	});
+	return { result, cleanup };
+}
+
+function installSomaHarness() {
+	const dom = createActiveDom();
+	const soma = {
+		dom,
+		langs: {
+			getLocale: () => 'en-US',
+			ts: (key: string) => key
+		},
+		dates: {
+			getDateOrder: () => 'MDY'
+		},
+		runtime: (morfo: Morfo, sources: Omit<SomaRuntimeSources, 'dom' | 'eventEngine'>) =>
+			createSomaRuntime(morfo, {
+				dom,
+				translate: (key) => key,
+				...sources
+			})
+	} as unknown as Soma;
+
+	vi.spyOn(Soma, 'require').mockReturnValue(soma);
+	vi.spyOn(RangeCalendarProvider.ctx, 'set').mockImplementation((value) => value);
+
+	return { dom };
+}
+
+function createRangeCalendarOpts() {
+	return {
+		id: state('range-calendar-root'),
+		ref: state<HTMLElement | null>(document.createElement('div')),
+		placeholder: state(new CalendarDate(2026, 5, 1)),
+		value: state<DateRange>({ start: undefined, end: undefined }),
+		minValue: state<CalendarDate | undefined>(undefined),
+		maxValue: state<CalendarDate | undefined>(undefined),
+		minDays: state<number | undefined>(undefined),
+		maxDays: state<number | undefined>(undefined),
+		allowSingleDay: state(false),
+		disabled: state(false),
+		pagedNavigation: state(false),
+		weekStartsOn: state<0 | 1 | 2 | 3 | 4 | 5 | 6 | undefined>(undefined),
+		weekdayFormat: state<Intl.DateTimeFormatOptions['weekday']>('short'),
+		isDateDisabled: state<DateMatcher | undefined>(undefined),
+		isDateUnavailable: state<DateMatcher | undefined>(undefined),
+		isDateHoliday: state<DateMatcher | undefined>(undefined),
+		fixedWeeks: state(false),
+		numberOfMonths: state(1),
+		calendarLabel: state<string | undefined>(undefined),
+		readonly: state(false),
+		disableDaysOutsideMonth: state(false),
+		monthFormat: state<Intl.DateTimeFormatOptions['month'] | ((month: number) => string)>('long'),
+		yearFormat: state<Intl.DateTimeFormatOptions['year'] | ((year: number) => string)>('numeric'),
+		showWeekNumbers: state(false),
+		weekNumberFormat: state<'iso' | 'simple'>('iso'),
+		announceNavigation: state(false),
+		initialFocus: state(false),
+		dir: state<'ltr' | 'rtl'>('ltr'),
+		locale: state('en-US')
+	};
+}
+
+describe('RangeCalendarProvider', () => {
+	afterEach(() => {
+		vi.restoreAllMocks();
+		document.body.innerHTML = '';
+	});
+
+	it('resolves initial placeholder from range start before falling back to today', () => {
+		const start = new CalendarDate(2026, 5, 15);
+
+		expect(resolveInitialRangeCalendarPlaceholder(undefined, { start, end: undefined })).toBe(start);
+	});
+
+	it('orders clicked endpoints and clears anchor when the range closes', () => {
+		const { dom } = installSomaHarness();
+		const opts = createRangeCalendarOpts();
+		const late = new CalendarDate(2026, 5, 20);
+		const early = new CalendarDate(2026, 5, 10);
+
+		const { result: provider, cleanup } = withEffectRoot(() =>
+			RangeCalendarProvider.create(opts)
+		);
+
+		provider.select(late);
+		expect(opts.value.current).toEqual({ start: late, end: undefined });
+		expect(provider.anchor).toBe(late);
+
+		provider.select(early);
+		expect(opts.value.current).toEqual({ start: early, end: late });
+		expect(provider.anchor).toBeUndefined();
+
+		cleanup();
+		dom.dispose();
+	});
+
+	it('clamps ranges that exceed maxDays and ignores too-short closes', () => {
+		const { dom } = installSomaHarness();
+		const opts = createRangeCalendarOpts();
+		opts.maxDays.current = 3;
+		const start = new CalendarDate(2026, 5, 10);
+		const far = new CalendarDate(2026, 5, 20);
+
+		const { result: provider, cleanup } = withEffectRoot(() =>
+			RangeCalendarProvider.create(opts)
+		);
+
+		provider.select(start);
+		provider.select(far);
+		expect(opts.value.current).toEqual({ start, end: new CalendarDate(2026, 5, 12) });
+
+		opts.value.current = { start: undefined, end: undefined };
+		opts.minDays.current = 3;
+		provider.select(start);
+		provider.select(new CalendarDate(2026, 5, 11));
+		expect(opts.value.current).toEqual({ start, end: undefined });
+		expect(provider.anchor).toBe(start);
+
+		cleanup();
+		dom.dispose();
+	});
+});

src/uix/soma/components/select/select-provider.svelte.test.ts

@@ -0,0 +1,133 @@
+// @vitest-environment jsdom
+
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { createActiveDom } from '$adom';
+import { createActiveTimers } from '$timer';
+import { state } from '$libs/reactive';
+import type { Morfo } from '$uix/morfo';
+import { Soma } from '$soma/core/soma.svelte';
+import { createSomaRuntime, type SomaRuntimeSources } from '$soma/runtime.svelte';
+import { FloatingProvider } from '$soma/layers/floating';
+
+import { SelectProvider } from './select-provider.svelte';
+import type { ScrollAlignment, SelectType } from './select-provider.svelte';
+
+function withEffectRoot<T>(fn: () => T): { result: T; cleanup: () => void } {
+	let result!: T;
+	const cleanup = $effect.root(() => {
+		result = fn();
+	});
+	return { result, cleanup };
+}
+
+function installSomaHarness() {
+	const dom = createActiveDom();
+	const timers = createActiveTimers();
+	const soma = {
+		dom,
+		uix: { timers },
+		runtime: (morfo: Morfo, sources: Omit<SomaRuntimeSources, 'dom' | 'eventEngine'>) =>
+			createSomaRuntime(morfo, {
+				dom,
+				translate: (key) => key,
+				...sources
+			})
+	} as unknown as Soma;
+
+	vi.spyOn(Soma, 'require').mockReturnValue(soma);
+	vi.spyOn(SelectProvider.ctx, 'set').mockImplementation((value) => value);
+	vi.spyOn(FloatingProvider, 'create').mockReturnValue({} as FloatingProvider);
+
+	return { dom, timers };
+}
+
+function createSelectOpts() {
+	return {
+		id: state('select-root'),
+		ref: state<HTMLElement | null>(null),
+		open: state(true),
+		value: state<string[]>([]),
+		type: state<SelectType>('single'),
+		disabled: state(false),
+		required: state(false),
+		name: state('choice'),
+		loop: state(false),
+		allowDeselect: state(false),
+		scrollAlignment: state<ScrollAlignment>('nearest'),
+		dir: state<'ltr' | 'rtl'>('ltr'),
+		onOpenChangeComplete: state(() => {})
+	};
+}
+
+describe('SelectProvider', () => {
+	afterEach(() => {
+		vi.restoreAllMocks();
+		document.body.innerHTML = '';
+	});
+
+	it('selects, closes and resolves labels in single-select mode', () => {
+		const { dom, timers } = installSomaHarness();
+		const opts = createSelectOpts();
+
+		const { result: provider, cleanup } = withEffectRoot(() => SelectProvider.create(opts));
+		provider.registerLabel('a', 'Alpha');
+
+		provider.selectItem('a');
+
+		expect(opts.value.current).toEqual(['a']);
+		expect(opts.open.current).toBe(false);
+		expect(provider.getDisplayText()).toBe('Alpha');
+
+		opts.open.current = true;
+		opts.allowDeselect.current = true;
+		provider.selectItem('a');
+
+		expect(opts.value.current).toEqual([]);
+		expect(opts.open.current).toBe(false);
+
+		cleanup();
+		timers.dispose();
+		dom.dispose();
+	});
+
+	it('toggles values without closing in multiple-select mode', () => {
+		const { dom, timers } = installSomaHarness();
+		const opts = createSelectOpts();
+		opts.type.current = 'multiple';
+		opts.value.current = ['a'];
+
+		const { result: provider, cleanup } = withEffectRoot(() => SelectProvider.create(opts));
+
+		provider.selectItem('b');
+		expect(opts.value.current).toEqual(['a', 'b']);
+		expect(opts.open.current).toBe(true);
+
+		provider.selectItem('a');
+		expect(opts.value.current).toEqual(['b']);
+		expect(opts.open.current).toBe(true);
+
+		cleanup();
+		timers.dispose();
+		dom.dispose();
+	});
+
+	it('filters disabled DOM items from navigation candidates', () => {
+		const { dom, timers } = installSomaHarness();
+		const opts = createSelectOpts();
+		const container = document.createElement('div');
+		container.innerHTML = `
+			<div id="a" data-select-item data-value="a"></div>
+			<div id="b" data-select-item data-value="b" data-disabled></div>
+			<div id="c" data-select-item data-value="c"></div>
+		`;
+
+		const { result: provider, cleanup } = withEffectRoot(() => SelectProvider.create(opts));
+
+		expect(provider.getItems(container).map((el) => el.id)).toEqual(['a', 'c']);
+
+		cleanup();
+		timers.dispose();
+		dom.dispose();
+	});
+});

src/uix/soma/components/toast/toaster.svelte.test.ts

@@ -0,0 +1,66 @@
+// @vitest-environment jsdom
+
+import { describe, expect, it, vi } from 'vitest';
+
+import { Toaster } from './toaster.svelte';
+
+describe('Toaster', () => {
+	it('routes max overflow through dismiss state instead of removing immediately', () => {
+		const toaster = new Toaster({ max: 2, duration: 0 });
+
+		const first = toaster.create({ title: 'One' });
+		const second = toaster.create({ title: 'Two' });
+		const third = toaster.create({ title: 'Three' });
+
+		expect(toaster.toasts.map((toast) => toast.id)).toEqual([first, second, third]);
+		expect(toaster.toasts.find((toast) => toast.id === first)?.dismissing).toBe(true);
+		expect(toaster.toasts.find((toast) => toast.id === second)?.dismissing).toBeFalsy();
+	});
+
+	it('dismisses all toasts and calls onDismiss only when removed', () => {
+		const onDismiss = vi.fn();
+		const toaster = new Toaster({ duration: 0 });
+		const id = toaster.create({ title: 'Saved', onDismiss });
+		toaster.create({ title: 'Queued' });
+
+		toaster.dismiss();
+
+		expect(toaster.toasts.every((toast) => toast.dismissing)).toBe(true);
+		expect(onDismiss).not.toHaveBeenCalled();
+
+		toaster.remove(id);
+		expect(onDismiss).toHaveBeenCalledTimes(1);
+		expect(toaster.toasts.some((toast) => toast.id === id)).toBe(false);
+	});
+
+	it('updates promise toasts on fulfill and threat paths', async () => {
+		const toaster = new Toaster({ duration: 0 });
+
+		const fulfillId = toaster.promise(Promise.resolve('ok'), {
+			loading: { title: 'Loading' },
+			fulfill: (value) => ({ title: value }),
+			threat: { title: 'Failed' }
+		});
+		await Promise.resolve();
+
+		expect(toaster.toasts.find((toast) => toast.id === fulfillId)).toMatchObject({
+			title: 'ok',
+			intent: 'fulfill',
+			loading: false
+		});
+
+		const threatId = toaster.promise(Promise.reject(new Error('nope')), {
+			loading: { title: 'Loading' },
+			fulfill: { title: 'Done' },
+			threat: (err) => ({ title: err instanceof Error ? err.message : 'Failed' })
+		});
+		await Promise.resolve();
+		await Promise.resolve();
+
+		expect(toaster.toasts.find((toast) => toast.id === threatId)).toMatchObject({
+			title: 'nope',
+			intent: 'threat',
+			loading: false
+		});
+	});
+});