Add stepper provider coverage

continue.md

@@ -109,9 +109,11 @@ Actualizacion 2026-05-15:
     con mirror al item y ellipsis decorativo/interactivo.
   - Cobertura nueva para Toolbar: roving focus, focusin, group single/multiple
     y separator.
+  - Cobertura nueva para Stepper: conteo/estado de steps, attrs runtime,
+    selección lineal/no lineal, teclado y prev/next/completed.
   - Validado por fase:
     - `npm run check` -> 0 errores, 0 warnings.
-    - `npm run test` -> 215 archivos, 2193 tests OK.
+    - `npm run test` -> 216 archivos, 2197 tests OK.
     - tests focales de Select/Popover/Toast/RangeCalendar -> 11 tests OK.
     - tests focales Dialog/Drawer/Popover/Select -> 10 tests OK.
     - `command-provider.svelte.test.ts` -> 2 tests OK.
@@ -155,6 +157,7 @@ Actualizacion 2026-05-15:
     - `pagination-provider.svelte.test.ts` -> 3 tests OK.
     - `breadcrumb-provider.svelte.test.ts` -> 3 tests OK.
     - `toolbar-provider.svelte.test.ts` -> 3 tests OK.
+    - `stepper-provider.svelte.test.ts` -> 3 tests OK.
     - guardia `rg "from './.*provider\\.svelte'" src/uix/soma/components -g 'exports.ts'`
       -> solo queda `select/components/select-provider.svelte`, que es wrapper
       publico, no runtime provider.

src/uix/soma/SOMA_ARCHITECTURE.md

@@ -541,6 +541,8 @@ Los tests por componente estan creciendo desde las piezas de mayor riesgo. A
   separator, link current con mirror al item y ellipsis decorativo/interactivo.
 - `toolbar/toolbar-provider.svelte.test.ts` — roving focus, focusin, group
   single/multiple y separator.
+- `stepper/stepper-provider.svelte.test.ts` — conteo/estado de steps,
+  attrs runtime, selección lineal/no lineal, teclado y prev/next/completed.
 
 Pendiente: seguir ampliando cobertura por el resto del catalogo Soma, ya por
 componentes de riesgo medio y familias menos centrales. `table-core`,

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

@@ -0,0 +1,316 @@
+// @vitest-environment jsdom
+
+import { tick } from 'svelte';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { createActiveDom } from '$adom';
+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 {
+	StepperCompletedContentProvider,
+	StepperContentProvider,
+	StepperIndicatorProvider,
+	StepperItemProvider,
+	StepperListProvider,
+	StepperNextTriggerProvider,
+	StepperPrevTriggerProvider,
+	StepperProvider,
+	StepperSeparatorProvider,
+	StepperTriggerProvider
+} from './stepper-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: {
+			ts: vi.fn(() => 'Steps')
+		},
+		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(StepperProvider.ctx, 'set').mockImplementation((value) => value);
+	vi.spyOn(StepperItemProvider.ctx, 'set').mockImplementation((value) => value);
+	vi.spyOn(StepperItemProvider, 'get').mockReturnValue(undefined);
+
+	return { dom };
+}
+
+function stepperOpts(root = document.createElement('div')) {
+	return {
+		id: state('stepper-root'),
+		ref: state<HTMLElement | null>(root),
+		value: state(1),
+		orientation: state<'horizontal' | 'vertical'>('horizontal'),
+		dir: state<'ltr' | 'rtl'>('ltr'),
+		linear: state(true)
+	};
+}
+
+function keyEvent(key: string, currentTarget: HTMLElement) {
+	return {
+		key,
+		currentTarget,
+		preventDefault: vi.fn()
+	};
+}
+
+describe('StepperProvider', () => {
+	afterEach(() => {
+		vi.restoreAllMocks();
+		document.body.innerHTML = '';
+	});
+
+	it('tracks step count, item states and projected runtime attrs', async () => {
+		const { dom } = installSomaHarness();
+		const root = document.createElement('div');
+		const firstEl = document.createElement('li');
+		const currentEl = document.createElement('li');
+		const lastEl = document.createElement('li');
+		const indicatorEl = document.createElement('div');
+		const separatorEl = document.createElement('div');
+		const contentEl = document.createElement('div');
+		document.body.append(root, firstEl, currentEl, lastEl, indicatorEl, separatorEl, contentEl);
+		const opts = stepperOpts(root);
+
+		const { result, cleanup } = withEffectRoot(() => {
+			const provider = StepperProvider.create(opts);
+			vi.spyOn(StepperProvider, 'require').mockReturnValue(provider);
+			const list = StepperListProvider.create({
+				id: state('stepper-list'),
+				ref: state<HTMLElement | null>(document.createElement('ol')),
+				ariaLabel: state<string | undefined>(undefined)
+			});
+			const first = StepperItemProvider.create({
+				id: state('stepper-item-0'),
+				ref: state<HTMLElement | null>(firstEl),
+				index: state(0)
+			});
+			const current = StepperItemProvider.create({
+				id: state('stepper-item-1'),
+				ref: state<HTMLElement | null>(currentEl),
+				index: state(1)
+			});
+			const last = StepperItemProvider.create({
+				id: state('stepper-item-2'),
+				ref: state<HTMLElement | null>(lastEl),
+				index: state(2)
+			});
+			vi.mocked(StepperItemProvider.get).mockReturnValue(current);
+			vi.spyOn(StepperItemProvider, 'require').mockReturnValue(current);
+			const indicator = StepperIndicatorProvider.create({
+				id: state('stepper-indicator'),
+				ref: state<HTMLElement | null>(indicatorEl)
+			});
+			const separator = StepperSeparatorProvider.create({
+				id: state('stepper-separator'),
+				ref: state<HTMLElement | null>(separatorEl)
+			});
+			const content = StepperContentProvider.create({
+				id: state('stepper-content-1'),
+				ref: state<HTMLElement | null>(contentEl),
+				index: state(1)
+			});
+			return { provider, list, first, current, last, indicator, separator, content };
+		});
+
+		expect(result.provider.count).toBe(3);
+		expect(result.provider.percent).toBe(33);
+		expect(result.provider.hasPrevStep).toBe(true);
+		expect(result.provider.hasNextStep).toBe(true);
+		expect(result.first.stepState).toBe('complete');
+		expect(result.current.stepState).toBe('current');
+		expect(result.last.stepState).toBe('incomplete');
+		expect(result.list.props).toMatchObject({
+			id: 'stepper-list',
+			role: 'tablist',
+			'aria-label': 'Steps',
+			'aria-orientation': 'horizontal'
+		});
+		expect(result.content.props.tabindex).toBe(0);
+		expect(result.current.contentId.current).toBe('stepper-content-1');
+
+		await tick();
+		expect(root.getAttribute('data-orientation')).toBe('horizontal');
+		expect(root.getAttribute('data-linear')).toBe('');
+		expect(firstEl.getAttribute('data-state')).toBe('complete');
+		expect(firstEl.getAttribute('data-complete')).toBe('');
+		expect(currentEl.getAttribute('data-state')).toBe('current');
+		expect(currentEl.getAttribute('data-current')).toBe('');
+		expect(lastEl.getAttribute('data-state')).toBe('incomplete');
+		expect(lastEl.getAttribute('data-incomplete')).toBe('');
+		expect(indicatorEl.getAttribute('aria-hidden')).toBe('true');
+		expect(indicatorEl.getAttribute('data-state')).toBe('current');
+		expect(separatorEl.getAttribute('role')).toBe('separator');
+		expect(separatorEl.getAttribute('data-orientation')).toBe('horizontal');
+		expect(contentEl.getAttribute('role')).toBe('tabpanel');
+		expect(contentEl.getAttribute('data-state')).toBe('current');
+
+		cleanup();
+		dom.dispose();
+	});
+
+	it('selects steps by linear rules and focuses registered triggers from the keyboard', async () => {
+		const { dom } = installSomaHarness();
+		const focusSpy = vi.spyOn(dom, 'focus');
+		const root = document.createElement('div');
+		const firstTriggerEl = document.createElement('button');
+		const currentTriggerEl = document.createElement('button');
+		const lastTriggerEl = document.createElement('button');
+		document.body.append(root, firstTriggerEl, currentTriggerEl, lastTriggerEl);
+		const opts = stepperOpts(root);
+
+		const { result, cleanup } = withEffectRoot(() => {
+			const provider = StepperProvider.create(opts);
+			vi.spyOn(StepperProvider, 'require').mockReturnValue(provider);
+			const firstItem = StepperItemProvider.create({
+				id: state('stepper-item-0'),
+				ref: state<HTMLElement | null>(document.createElement('li')),
+				index: state(0)
+			});
+			vi.spyOn(StepperItemProvider, 'require').mockReturnValue(firstItem);
+			const firstTrigger = StepperTriggerProvider.create({
+				id: state('stepper-trigger-0'),
+				ref: state<HTMLElement | null>(firstTriggerEl),
+				disabled: state(false)
+			});
+			const currentItem = StepperItemProvider.create({
+				id: state('stepper-item-1'),
+				ref: state<HTMLElement | null>(document.createElement('li')),
+				index: state(1)
+			});
+			vi.mocked(StepperItemProvider.require).mockReturnValue(currentItem);
+			const currentTrigger = StepperTriggerProvider.create({
+				id: state('stepper-trigger-1'),
+				ref: state<HTMLElement | null>(currentTriggerEl),
+				disabled: state(false)
+			});
+			const lastItem = StepperItemProvider.create({
+				id: state('stepper-item-2'),
+				ref: state<HTMLElement | null>(document.createElement('li')),
+				index: state(2)
+			});
+			vi.mocked(StepperItemProvider.require).mockReturnValue(lastItem);
+			const lastTrigger = StepperTriggerProvider.create({
+				id: state('stepper-trigger-2'),
+				ref: state<HTMLElement | null>(lastTriggerEl),
+				disabled: state(false)
+			});
+			return { provider, firstTrigger, currentTrigger, lastTrigger };
+		});
+
+		expect(result.lastTrigger.isDisabled).toBe(true);
+		result.lastTrigger.onclick({ currentTarget: lastTriggerEl } as never);
+		expect(opts.value.current).toBe(1);
+
+		result.firstTrigger.onclick({ currentTarget: firstTriggerEl } as never);
+		expect(opts.value.current).toBe(0);
+
+		opts.linear.current = false;
+		result.lastTrigger.onclick({ currentTarget: lastTriggerEl } as never);
+		expect(opts.value.current).toBe(2);
+
+		await tick();
+		expect(result.provider.getRegisteredTriggers()).toEqual([
+			firstTriggerEl,
+			currentTriggerEl,
+			lastTriggerEl
+		]);
+
+		const end = keyEvent('End', currentTriggerEl);
+		result.currentTrigger.onkeydown(end as never);
+		expect(end.preventDefault).toHaveBeenCalledOnce();
+		expect(focusSpy).toHaveBeenLastCalledWith(lastTriggerEl);
+
+		const home = keyEvent('Home', currentTriggerEl);
+		result.currentTrigger.onkeydown(home as never);
+		expect(home.preventDefault).toHaveBeenCalledOnce();
+		expect(focusSpy).toHaveBeenLastCalledWith(firstTriggerEl);
+
+		cleanup();
+		dom.dispose();
+	});
+
+	it('moves with prev/next triggers and exposes completed content state', async () => {
+		const { dom } = installSomaHarness();
+		const root = document.createElement('div');
+		const prevEl = document.createElement('button');
+		const nextEl = document.createElement('button');
+		const completedEl = document.createElement('div');
+		document.body.append(root, prevEl, nextEl, completedEl);
+		const opts = stepperOpts(root);
+
+		const { result, cleanup } = withEffectRoot(() => {
+			const provider = StepperProvider.create(opts);
+			vi.spyOn(StepperProvider, 'require').mockReturnValue(provider);
+			StepperItemProvider.create({
+				id: state('stepper-item-0'),
+				ref: state<HTMLElement | null>(document.createElement('li')),
+				index: state(0)
+			});
+			StepperItemProvider.create({
+				id: state('stepper-item-1'),
+				ref: state<HTMLElement | null>(document.createElement('li')),
+				index: state(1)
+			});
+			const prev = StepperPrevTriggerProvider.create({
+				id: state('stepper-prev'),
+				ref: state<HTMLElement | null>(prevEl),
+				disabled: state(false)
+			});
+			const next = StepperNextTriggerProvider.create({
+				id: state('stepper-next'),
+				ref: state<HTMLElement | null>(nextEl),
+				disabled: state(false)
+			});
+			const completed = StepperCompletedContentProvider.create({
+				id: state('stepper-completed'),
+				ref: state<HTMLElement | null>(completedEl)
+			});
+			return { provider, prev, next, completed };
+		});
+
+		expect(result.provider.count).toBe(2);
+		expect(result.completed.isCompleted).toBe(false);
+		result.prev.onclick({ currentTarget: prevEl } as never);
+		expect(opts.value.current).toBe(0);
+		expect(result.prev.isDisabled).toBe(true);
+		result.prev.onclick({ currentTarget: prevEl } as never);
+		expect(opts.value.current).toBe(0);
+		result.next.onclick({ currentTarget: nextEl } as never);
+		result.next.onclick({ currentTarget: nextEl } as never);
+		expect(opts.value.current).toBe(2);
+		expect(result.provider.isCompleted).toBe(true);
+		expect(result.completed.isCompleted).toBe(true);
+		expect(result.next.isDisabled).toBe(true);
+		expect(result.prev.props.type).toBe('button');
+		expect(result.next.props).toMatchObject({
+			type: 'button',
+			disabled: true,
+			'data-disabled': ''
+		});
+
+		await tick();
+		expect(completedEl.getAttribute('data-state')).toBe('completed');
+
+		cleanup();
+		dom.dispose();
+	});
+});