Aller au contenu
Meubles Morinière

Le projetCompétences et preuves3 min de lecture

UX

Les règles d’UX sont écrites dans le code : des pages qui n’attendent pas leur lecture la plus lente, pas de toast pour un succès qu’on voit déjà, des gestes qu’on peut annuler, rien de perdu, un site qu’on peut parcourir au clavier.

L’interface sert à une petite équipe, qui travaille au magasin et au téléphone, et à des clients de tous âges, sur réseau mobile. Les captures montrent le résultat. Pour que ça dure, chaque règle d’UX est écrite dans un composant partagé, et un test vérifie les plus fragiles.

Site public · /
L’accueil du site public : une pièce de l’atelier en une, avec sa cote, son prix et sa disponibilité.
ERP · /tableau-de-bord
Le tableau de bord de l’ERP : commandes à préparer, état du site et du magasin, incidents, avancement de l’atelier, devis et stock.
L’accueil du site public sur un téléphone.
Le site public en production et le tableau de bord de l’ERP, sur ordinateur et au téléphone. Les captures viennent du manuel de l’équipe, sur la base de démonstration. Les personnes, les e-mails et les montants y sont fictifs, et les pastilles numérotées guident la lecture.

Une page de l’ERP n’attend jamais sa lecture la plus lente

Le tableau de bord lit l’atelier, les rendez-vous, les devis, les incidents et la caisse. S’il attendait la plus lente de ces lectures, l’équipe regarderait un écran vide chaque matin. Et si une seule échouait, toute la page tomberait.

Du coup, l’en-tête s’affiche tout de suite. Chaque bloc lit ses données dans son propre composant serveur, sous son Suspense. Il arrive à son rythme, avec un fondu depuis son squelette. Chaque bloc a aussi son filet, donc une lecture qui échoue ne casse que son bloc. Et le loading.tsx de la route reprend le même en-tête et les mêmes squelettes, comme ça la page ne saute pas quand on navigue.

AdminDashboardPageapps/erp/app/(console)/tableau-de-bord/page.tsx · lignes 114–180
/**
 * La page du matin : la phrase du jour, la caisse et l'état du magasin, les incidents rangés, puis
 * quatre feuilles qui appellent chacune un geste — l'atelier, les rendez-vous, les devis, ce qui
 * reste à suivre. Des chiffres de vente, elle ne garde que l'encaissé du jour et celui du mois, pour
 * l'échelle ; le reste est sur la page Ventes.
 */
export default function AdminDashboardPage() {
	return (
		<>
			<AdminPageHeader
				section={ROUTES.ADMIN.DASHBOARD}
				intro={false}
				primaryAction={<SaleChooser />}
				foldedActions={<DashboardShortcuts />}
			/>
			<DashboardLiveRefresh />
			<Suspense fallback={<DashboardLedeSkeleton />}>
				<LedeSection />
			</Suspense>
			<Suspense fallback={null}>
				<IncidentsSection />
			</Suspense>
			<Suspense fallback={null}>
				<HealthAlertSection />
			</Suspense>
			<Suspense fallback={null}>
				<SetupSection placement="top" />
			</Suspense>
			<Suspense fallback={null}>
				<PushInviteSection />
			</Suspense>
			<DashboardGrid
				workshop={
					<BlockFailureBoundary spec={DASHBOARD_BLOCKS.workshop}>
						<RevealSuspense fallback={<DashboardBlockSkeleton {...WORKSHOP_SKELETON} />}>
							<WorkshopSection />
						</RevealSuspense>
					</BlockFailureBoundary>
				}
				agenda={
					<BlockFailureBoundary spec={DASHBOARD_BLOCKS.agenda}>
						<RevealSuspense fallback={<DashboardBlockSkeleton {...AGENDA_SKELETON} />}>
							<AgendaSection />
						</RevealSuspense>
					</BlockFailureBoundary>
				}
				quotes={
					<BlockFailureBoundary spec={DASHBOARD_BLOCKS.quotes}>
						<RevealSuspense fallback={<DashboardBlockSkeleton {...QUOTES_SKELETON} />}>
							<QuotesSection />
						</RevealSuspense>
					</BlockFailureBoundary>
				}
				followUps={
					<BlockFailureBoundary spec={DASHBOARD_BLOCKS.followUps}>
						<RevealSuspense fallback={<DashboardBlockSkeleton {...FOLLOW_UPS_SKELETON} />}>
							<FollowUpsSection />
						</RevealSuspense>
					</BlockFailureBoundary>
				}
			/>
			<Suspense fallback={null}>
				<SetupSection placement="bottom" />
			</Suspense>
		</>
	);
}

Pour aller plus loin : Interface de l’ERP, Next.js et React.

Un succès visible ne s’affiche pas en toast, et un geste se défait

Un toast cache une partie de l’écran. Afficher « Enregistré » alors que la personne vient de voir la valeur changer, ça ajoute du bruit. Et demander « Êtes-vous sûr ? » avant chaque geste, ça ralentit, alors qu’un bouton « Annuler » suffirait à le rendre sûr.

Du coup, les callbacks communs à toutes les actions n’affichent pas de toast pour un succès. Le message part au lecteur d’écran, et l’écran montre le reste. Le toast de succès, il faut le demander explicitement. Il sert pour ce que l’écran ne montre pas, et d’abord pour un geste qu’on peut défaire. Dans ce cas, le toast porte « Annuler ».

createToastCallbacksapps/erp/shared/lib/create-toast-callbacks.ts · lignes 19–68
export const createToastCallbacks = <T = ActionState>(
	options: CreateToastCallbacksOptions<T> = {},
) => {
	const {
		showSuccessToast = false,
		announceSuccess = true,
		showErrorToast = true,
		showWarningToast = true,
		validationErrorDisplay = "inline",
		onSuccess: customOnSuccess,
		onWarning: customOnWarning,
		onError: customOnError,
		successAction,
	} = options;

	return {
		onSuccess: (result: T) => {
			const isToasted = showSuccessToast || successAction !== undefined;
			if (!isToasted && announceSuccess && hasMessage(result)) announce(result.message, "polite");

			customOnSuccess?.(result);

			if (!isToasted || !hasMessage(result)) return;
			if (successAction) {
				toast.success(result.message, { action: successAction });
			} else {
				toast.success(result.message);
			}
		},
		onWarning: (result: T) => {
			customOnWarning?.(result);

			if (showWarningToast && hasMessage(result)) {
				toast.warning(result.message);
			}
		},
		onError: (result: T) => {
			customOnError?.(result);

			if (showErrorToast && hasMessage(result)) {
				if (
					getActionStatus(result) !== ActionStatus.VALIDATION_ERROR ||
					validationErrorDisplay === "toast"
				) {
					toast.error(result.message);
				}
			}
		},
	} satisfies Callbacks<T>;
};

Une coupure, un conflit ou une session expirée ne font rien perdre

Au magasin, le réseau coupe, deux personnes modifient la même commande, une session expire en pleine saisie. À chaque fois, l’interface a deux possibilités : jeter le travail, ou dire quoi faire.

Les formulaires, les boutons de geste et les confirmations de l’ERP passent par le même hook.

  • Quand un geste est lent, il dit qu’il travaille.
  • En cas de conflit, il propose de rejouer exactement la même saisie.
  • S’il y a eu un déploiement entre-temps, il propose de recharger.
  • Si la session a expiré, il renvoie à la connexion, puis à la page. Au milieu d’une longue saisie, la saisie reste à l’écran et la connexion s’ouvre dans un autre onglet.
useAdminActionapps/erp/shared/hooks/use-admin-action.ts · lignes 66–190
export function useAdminAction<TData = unknown>(
	serverAction: ServerAction<TData>,
	options?: UseAdminActionOptions<TData>,
) {
	const router = useRouter();
	const pathname = usePathname();
	const lastFormData = useRef<FormData | null>(null);
	const failureToast = useRef<string | number | undefined>(undefined);

	const showFailure = (...failure: Parameters<typeof toast.error>) => {
		failureToast.current = toast.error(...failure);
	};

	const remembering: ServerAction<TData> = async (previousState, formData) => {
		// Posé avant tout `await` : le type suit la transition du geste jusqu'au rendu de la réponse.
		// Un geste confirmé dans un panneau s'en passe : le calque des transitions passerait devant le
		// panneau qui se ferme, et sa fermeture dit déjà que c'est fait.
		if (document.querySelector(PANEL_SURFACES) === null) addTransitionType(GESTURE_RESULT);
		lastFormData.current = formData;
		if (failureToast.current !== undefined) {
			toast.dismiss(failureToast.current);
			failureToast.current = undefined;
		}
		let notice: string | number | undefined;
		const timer =
			options?.slowGestureNotice === false
				? undefined
				: setTimeout(() => {
						notice = toast.loading(SLOW_GESTURE_NOTICE);
					}, SLOW_GESTURE_MS);
		try {
			return await serverAction(previousState, formData);
		} catch (error) {
			if (unstable_isUnrecognizedActionError(error)) return errorState(STALE_DEPLOYMENT_MESSAGE);
			throw error;
		} finally {
			if (timer !== undefined) clearTimeout(timer);
			if (notice !== undefined) toast.dismiss(notice);
		}
	};

	const { state, action, isPending } = useActionWithToast(remembering, {
		onSuccess: (result) => {
			triggerHaptic("success");
			options?.onSuccess?.(result);
		},
		onWarning: (result) => {
			triggerHaptic("success");
			options?.onWarning?.(result);
		},
		toastOptions: { ...options?.toastOptions, showErrorToast: false },
		onError: (result) => {
			triggerHaptic("error");
			options?.onError?.(result);
			if (
				options?.refreshOnError &&
				result.status !== ActionStatus.FORBIDDEN &&
				result.status !== ActionStatus.NOT_FOUND &&
				result.message !== NETWORK_FAILURE_MESSAGE
			) {
				router.refresh();
			}
			switch (result.status) {
				case ActionStatus.FORBIDDEN: {
					if (options?.keepsPageWhenSignedOut === true) {
						showFailure(SIGNED_OUT_KEEPS_PAGE_MESSAGE, {
							duration: Number.POSITIVE_INFINITY,
							action: { label: SIGN_IN_AGAIN_LABEL, onClick: () => openSignInBeside(pathname) },
						});
						return;
					}
					router.push(signInAfterSignOut(returnTargetOf(pathname, window.location.search)));
					return;
				}
				case ActionStatus.NOT_FOUND:
					showFailure(result.message);
					if (options?.staysOnNotFound === true) router.refresh();
					else router.push(options?.listHref ?? sectionOf(pathname)?.href ?? ROUTES.ADMIN.ROOT);
					return;
				case ActionStatus.CONFLICT:
					if (options?.globalErrorDisplay === "inline") return;
					if (result.message === CONFLICT_RETRY_MESSAGE) {
						const failed = lastFormData.current;
						let replayed = false;
						showFailure(result.message, {
							action: {
								label: RETRY_LABEL,
								onClick: () => {
									if (failed === null || replayed) return;
									replayed = true;
									startTransition(() => action(failed));
								},
							},
						});
					} else {
						showFailure(result.message);
					}
					return;
				case ActionStatus.VALIDATION_ERROR:
					if (options?.toastOptions?.validationErrorDisplay === "toast") {
						showFailure(result.message);
					}
					return;
				default:
					if (options?.globalErrorDisplay === "inline") return;
					if (result.message === RECENT_SIGN_IN_REQUIRED_MESSAGE) {
						showFailure(result.message, {
							duration: Number.POSITIVE_INFINITY,
							action: { label: SIGN_IN_AGAIN_LABEL, onClick: () => openSignInBeside(pathname) },
						});
					} else if (result.message === STALE_DEPLOYMENT_MESSAGE) {
						showFailure(result.message, {
							action: { label: RELOAD_LABEL, onClick: () => window.location.reload() },
						});
					} else {
						showFailure(result.message);
					}
			}
		},
	});

	useDebugValue(isPending ? "en cours" : (state?.status ?? "au repos"));

	return { state, action, isPending };
}

Le site se parcourt au clavier, et passe les règles WCAG

Un volet qui laisse le focus s’échapper, un lien d’évitement qui manque, un contraste trop faible : ça exclut une partie des clients, et l’équipe ne le voit jamais.

Du coup, les tests e2e passent axe sur les pages et sur les surfaces ouvertes, avec les règles WCAG jusqu’au niveau AA. D’autres parcours se font au clavier seul. Le premier Tab doit mener au lien d’évitement, et le focus doit rester dans le volet du panier. Ces tests se lancent à la main, ils ne tournent pas au push (Qualité).

AXE_TAGSpackages/testing/src/axe.ts · lignes 4–4
export const AXE_TAGS: string[] = ["wcag2a", "wcag2aa", "wcag21a", "wcag21aa", "wcag22aa"];

Pour aller plus loin : Performance et accessibilité, et, côté client, le client paie ce que la page lui a montré.

Sur cette page