Fix touch input highlights and barcode camera focus
All checks were successful
Verify and publish Calio container / build-and-push (push) Successful in 46s

Remove field focus outlines. Preserve camera constraints across light and focus changes, fall back to one-shot autofocus, and offer supported manual focus, lens selection, and camera restart. Add scanner regression coverage.
This commit is contained in:
Elijah 2026-10-25 11:02:36 -07:00
parent 40d9bc062b
commit 0ff7279cf6
5 changed files with 394 additions and 21 deletions

View file

@ -35,6 +35,8 @@ The food sheet's **Quick entry** tab starts with **Scan barcode** and **Scan lab
3. The server's copy of **Open Food Facts** (~3.4 million products worldwide, community-entered).
4. The live Open Food Facts API, for products newer than the copies. Answers, including "not found", are cached on the server.
The scanner requests continuous autofocus when supported, with one-shot autofocus as a fallback. **Focus distance** appears only on cameras that expose manual lens control; adjusting it holds a fixed focus until you choose **Use autofocus** or restart. If the image stays blurry, move the package farther away, try **Restart camera**, or choose a different lens under **Camera** when multiple cameras are available. Browser and camera support determine which focus controls are available; the native **Take a photo instead** option remains available.
A find fills the form with the product's name, serving and every nutrient the source has: the seven tracked ones plus extras such as saturated fat, cholesterol, added sugars, vitamins and minerals, under **More nutrients**. **Save this food to my library** is pre-checked so the next scan is instant. When nothing is found, scan the label instead; the barcode stays attached to the food.
**Scan label** opens the iPhone camera app (full resolution, focus and flash, no permission prompt), or a file picker on desktop. The photo is downscaled on the device and read on the server with PaddleOCR PP-OCRv5 (server detection, English recognition) on ONNX Runtime, CPU only, typically in 1–3 seconds. A parser then pulls out the serving size and each nutrient, undoes common OCR confusions (O/0, l/1, a unit read as a digit), checks amounts against their printed %DV, and handles US/Canadian panels, linear labels, tilted photos, Spanish labels and EU "per 100 g" tables (salt → sodium). Values it found replace the form's values; check them against the package before saving. Fill the frame with the panel and keep it flat and sharp: curved containers and glare are the usual causes of misses.

View file

@ -1,8 +1,14 @@
import { useEffect, useRef, useState } from "react";
import { Camera, Flashlight, Search } from "lucide-react";
import { Camera, Flashlight, RotateCcw, Search } from "lucide-react";
import { normalizeBarcode } from "../shared/barcode.js";
import { Modal } from "./components";
import { barcodeDetector, detectBarcode } from "./scan";
import {
autofocus,
cameraCapabilities,
cameraConstraint,
manualFocusRange,
} from "./cameraFocus";
type Status = "starting" | "scanning" | "denied" | "unavailable";
@ -20,6 +26,14 @@ export function BarcodeScanner({
const [torch, setTorch] = useState<boolean | null>(null);
const [digits, setDigits] = useState("");
const [error, setError] = useState("");
const [restart, setRestart] = useState(0);
const [focus, setFocus] = useState<ReturnType<typeof manualFocusRange>>(null);
const [adjusting, setAdjusting] = useState(false);
const [manual, setManual] = useState(false);
const [canAutofocus, setCanAutofocus] = useState(false);
const [cameras, setCameras] = useState<MediaDeviceInfo[]>([]);
const [cameraId, setCameraId] = useState("");
const [activeCameraId, setActiveCameraId] = useState("");
const finish = (gtin: string) => {
if (done.current) return;
done.current = true;
@ -33,12 +47,19 @@ export function BarcodeScanner({
let stream: MediaStream | undefined;
let stopped = false;
let timer = 0;
setStatus("starting");
setTorch(null);
setFocus(null);
setManual(false);
setCanAutofocus(false);
setAdjusting(false);
const reader = barcodeDetector();
(async () => {
try {
stream = await navigator.mediaDevices.getUserMedia({
audio: false,
video: {
...(cameraId ? { deviceId: { exact: cameraId } } : {}),
facingMode: { ideal: "environment" },
width: { ideal: 1920 },
height: { ideal: 1080 },
@ -57,20 +78,27 @@ export function BarcodeScanner({
const element = video.current!;
element.srcObject = stream;
await element.play().catch(() => {});
if (stopped) return;
const camera = stream.getVideoTracks()[0];
track.current = camera;
const capabilities = camera.getCapabilities?.() as
| (MediaTrackCapabilities & { torch?: boolean; focusMode?: string[] })
| undefined;
const capabilities = cameraCapabilities(camera);
if (capabilities?.torch) setTorch(false);
if (capabilities?.focusMode?.includes("continuous"))
camera
.applyConstraints({
advanced: [{ focusMode: "continuous" } as MediaTrackConstraintSet],
})
.catch(() => {});
setActiveCameraId(camera.getSettings().deviceId ?? "");
setCanAutofocus(Boolean(capabilities.focusMode?.some(
mode => mode === "continuous" || mode === "single-shot",
)));
// Permission makes lens names available. Let the user switch away from
// a fixed-focus rear lens when a phone chooses it by default.
void navigator.mediaDevices.enumerateDevices?.().then(devices => {
if (!stopped)
setCameras(devices.filter(device => device.kind === "videoinput" && device.deviceId));
}).catch(() => {});
await autofocus(camera);
if (stopped) return;
setFocus(manualFocusRange(camera));
setStatus("scanning");
const detector = await reader.catch(() => null);
if (stopped) return;
if (!detector) return setStatus("unavailable");
const canvas = document.createElement("canvas");
const context = canvas.getContext("2d", { willReadFrequently: true })!;
@ -109,16 +137,40 @@ export function BarcodeScanner({
// A dropped frame; try the next one.
}
}
timer = window.setTimeout(tick, 100);
if (!stopped && !done.current) timer = window.setTimeout(tick, 100);
};
void tick();
})();
return () => {
stopped = true;
clearTimeout(timer);
track.current = null;
stream?.getTracks().forEach((t) => t.stop());
};
}, []);
}, [restart, cameraId]);
async function adjustFocus(value?: number) {
const camera = track.current;
if (!camera) return;
setAdjusting(true);
setError("");
try {
if (value === undefined) {
const applied = await autofocus(camera);
if (track.current === camera) {
if (applied) setManual(false);
else setError("Autofocus isn’t available. Adjust focus or restart the camera.");
}
} else {
await cameraConstraint(camera, { focusMode: "manual", focusDistance: value });
if (track.current === camera) setManual(true);
}
} catch {
if (track.current === camera) setError("This camera couldn’t adjust focus. Try restarting it or taking a photo.");
} finally {
if (track.current === camera) setAdjusting(false);
}
}
async function photo(file: File | undefined) {
if (!file) return;
@ -161,20 +213,89 @@ export function BarcodeScanner({
className="scanner-torch"
aria-label={torch ? "Turn light off" : "Turn light on"}
aria-pressed={torch}
onClick={() => {
disabled={adjusting}
onClick={async () => {
const camera = track.current;
if (!camera) return;
const next = !torch;
track.current
?.applyConstraints({
advanced: [{ torch: next } as MediaTrackConstraintSet],
})
.then(() => setTorch(next))
.catch(() => setTorch(null));
setAdjusting(true);
try {
await cameraConstraint(camera, { torch: next });
if (track.current === camera) setTorch(next);
} catch {
if (track.current === camera) setTorch(null);
} finally {
if (track.current === camera) setAdjusting(false);
}
}}
>
<Flashlight size={18} />
</button>
)}
</div>
{status === "scanning" && (
<div className="scanner-focus">
<p className="muted small">
If it’s blurry, move the barcode farther away and hold still.
</p>
{focus && (
<label>
Focus distance
<input
type="range"
min={focus.min}
max={focus.max}
step={focus.step}
value={focus.value}
onChange={event => {
const value = Number(event.target.value);
setFocus(current => current && { ...current, value });
void adjustFocus(value);
}}
/>
</label>
)}
{canAutofocus && (
<button
type="button"
className="secondary"
disabled={adjusting}
onClick={() => void adjustFocus()}
>
{manual ? "Use autofocus" : "Refocus"}
</button>
)}
<button
type="button"
className="secondary"
onClick={() => {
setError("");
setRestart(current => current + 1);
}}
>
<RotateCcw size={17} />Restart camera
</button>
</div>
)}
{cameras.length > 1 && (
<label className="scanner-camera">
Camera
<select
value={cameraId || activeCameraId}
onChange={event => {
setError("");
setCameraId(event.target.value);
}}
>
{!activeCameraId && !cameraId && <option value="">Default camera</option>}
{cameras.map((camera, index) => (
<option key={camera.deviceId} value={camera.deviceId}>
{camera.label || `Camera ${index + 1}`}
</option>
))}
</select>
</label>
)}
<div className="scanner-actions">
<label className="secondary">
<Camera size={17} />

85
src/cameraFocus.ts Normal file
View file

@ -0,0 +1,85 @@
// Image Capture controls aren't included in every browser's DOM typings.
export type CameraCapabilities = MediaTrackCapabilities & {
torch?: boolean;
focusMode?: string[];
focusDistance?: { min: number; max: number; step?: number };
};
export function cameraCapabilities(camera: MediaStreamTrack): CameraCapabilities {
try {
return camera.getCapabilities?.() ?? {};
} catch {
return {};
}
}
// applyConstraints replaces the previous constraints. Keep resolution, focus
// and torch together, including when switching between auto and manual focus.
const pending = new WeakMap<MediaStreamTrack, Promise<void>>();
export function cameraConstraint(
camera: MediaStreamTrack,
changes: Record<string, string | number | boolean>,
): Promise<void> {
// A dragged slider and a light toggle can overlap. Read settings only after
// the previous update completes so neither request discards the other.
const update = (pending.get(camera) ?? Promise.resolve())
.catch(() => {})
.then(async () => {
const current = camera.getConstraints();
const advanced = (current.advanced ?? [])
.map((entry) => Object.fromEntries(
Object.entries(entry).filter(([key]) => !(key in changes)),
))
.filter((entry) => Object.keys(entry).length);
const base = Object.fromEntries(
Object.entries(current).filter(([key]) => !(key in changes)),
);
await camera.applyConstraints({
...base,
advanced: [...advanced, changes] as MediaTrackConstraintSet[],
});
});
pending.set(camera, update);
return update;
}
export async function autofocus(camera: MediaStreamTrack): Promise<boolean> {
const modes = cameraCapabilities(camera).focusMode ?? [];
for (const mode of ["continuous", "single-shot"]) {
if (!modes.includes(mode)) continue;
try {
await cameraConstraint(camera, { focusMode: mode });
const settings = camera.getSettings() as MediaTrackSettings & {
focusMode?: string;
};
// Advanced constraints can be silently ignored. Try the fallback if the
// browser reports that it kept a different mode.
if (settings.focusMode && settings.focusMode !== mode) continue;
return true;
} catch {
// Some cameras advertise a mode but reject it at this resolution.
}
}
return false;
}
export function manualFocusRange(camera: MediaStreamTrack) {
const capabilities = cameraCapabilities(camera);
const range = capabilities.focusDistance;
if (
!capabilities.focusMode?.includes("manual") || !range ||
!Number.isFinite(range.min) || !Number.isFinite(range.max) ||
range.max <= range.min
)
return null;
const settings = camera.getSettings() as MediaTrackSettings & {
focusDistance?: number;
};
return {
min: range.min,
max: range.max,
step: range.step && range.step > 0 ? range.step : (range.max - range.min) / 100,
value: Math.max(range.min, Math.min(range.max, settings.focusDistance ?? (range.min + range.max) / 2)),
};
}

View file

@ -99,8 +99,7 @@ a:focus-visible {
input:focus,
select:focus,
textarea:focus {
outline: 2px solid var(--accent);
outline-offset: 1px;
outline: none;
}
button {
touch-action: manipulation;
@ -1327,6 +1326,19 @@ textarea {
.scanner-actions {
margin-top: 14px;
}
.scanner-focus {
display: grid;
gap: 10px;
margin-top: 12px;
}
.scanner-camera {
margin-top: 12px;
}
.scanner-focus input[type="range"] {
padding: 0;
border: 0;
accent-color: var(--accent);
}
.scanner-actions .secondary {
width: 100%;
cursor: pointer;

153
tests/scanner.test.js Normal file
View file

@ -0,0 +1,153 @@
import test from "node:test";
import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import vm from "node:vm";
import ts from "typescript";
// Mount the real scanner with a browser-shaped camera. This exercises startup
// and the actual UI handlers without needing permission or physical hardware.
async function mount({ modes = ["continuous", "single-shot"], rejectContinuous = false, capabilities = {} } = {}) {
const calls = [];
let constraints = { width: { ideal: 1920 }, height: { ideal: 1080 } };
let settings = {};
let stops = 0;
const camera = {
getCapabilities: () => ({ focusMode: modes, torch: true, ...capabilities }),
getConstraints: () => constraints,
getSettings: () => settings,
stop: () => stops++,
async applyConstraints(next) {
calls.push(next);
const applied = Object.assign({}, next, ...(next.advanced ?? []));
const mode = applied.focusMode?.exact ?? applied.focusMode;
if (mode === "continuous" && rejectContinuous) throw new Error("Focus rejected");
constraints = next;
settings = { focusMode: mode, focusDistance: applied.focusDistance, torch: applied.torch };
},
};
const stream = { getTracks: () => [camera], getVideoTracks: () => [camera] };
const video = { play: async () => {}, videoWidth: 0, videoHeight: 0 };
const refs = [], states = [], effects = [];
let refIndex = 0, stateIndex = 0, mounted = false;
const jsx = (type, props) => ({ type, props });
const react = {
useRef(initial) {
const index = refIndex++;
return refs[index] ??= { current: index === 0 ? video : initial };
},
useState(initial) {
const index = stateIndex++;
if (!(index in states)) states[index] = initial;
return [states[index], value => { states[index] = typeof value === "function" ? value(states[index]) : value; }];
},
useEffect(effect) { if (!mounted) effects.push(effect); },
};
const cache = new Map();
function load(file) {
if (cache.has(file.href)) return cache.get(file.href);
const exports = {};
cache.set(file.href, exports);
const context = {
exports,
require(name) {
if (name === "react") return react;
if (name === "react/jsx-runtime") return { jsx, jsxs: jsx };
if (name === "lucide-react") return {};
if (name === "./components") return { Modal: "Modal" };
if (name === "./scan") return { barcodeDetector: async () => ({}), detectBarcode: async () => null };
if (name === "../shared/barcode.js") return { normalizeBarcode: () => null };
return load(new URL(name + ".ts", file));
},
navigator: { mediaDevices: { getUserMedia: async () => stream } },
document: { createElement: () => ({ getContext: () => ({}) }) },
window: { setTimeout: () => 1 }, clearTimeout() {},
};
vm.runInNewContext(ts.transpileModule(readFileSync(file, "utf8"), {
compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022, jsx: ts.JsxEmit.ReactJSX },
}).outputText, context);
return exports;
}
const { BarcodeScanner } = load(new URL("../src/Scanner.tsx", import.meta.url));
const render = () => {
refIndex = stateIndex = 0;
return BarcodeScanner({ close() {}, detected() {} });
};
render();
mounted = true;
const cleanups = effects.map(effect => effect());
const settle = () => new Promise(resolve => setImmediate(resolve));
await settle();
const walk = (predicate, tree) => {
if (!tree || typeof tree !== "object") return;
if (predicate(tree)) return tree;
for (const child of [tree.props?.children].flat(Infinity)) {
const result = walk(predicate, child);
if (result) return result;
}
};
return { camera, calls, find: predicate => walk(predicate, render()), settle, cleanup: () => cleanups.forEach(fn => fn?.()), stops: () => stops };
}
test("scanner falls back to one-shot autofocus when continuous focus fails", async () => {
const app = await mount({ rejectContinuous: true });
assert.equal(app.camera.getSettings().focusMode, "single-shot");
app.find(node => node.props?.children === "Refocus").props.onClick();
await app.settle();
assert.equal(app.calls.filter(call => call.advanced?.some(entry => entry.focusMode === "single-shot")).length, 2);
app.cleanup();
});
test("switching the scanner light preserves autofocus and video constraints", async () => {
const app = await mount();
await app.find(node => node.props?.className === "scanner-torch").props.onClick();
await app.settle();
assert.equal(app.camera.getSettings().focusMode, "continuous");
assert.equal(app.camera.getSettings().torch, true);
assert.equal(app.camera.getConstraints().width.ideal, 1920);
app.cleanup();
assert.equal(app.stops(), 1);
});
test("manual focus locks the chosen distance and survives light changes", async () => {
const app = await mount({
modes: ["continuous", "manual"],
capabilities: { focusDistance: { min: 0, max: 10, step: 0.1 } },
});
const slider = () => app.find(node => node.type === "input" && node.props.type === "range");
assert.equal(slider().props.min, 0);
assert.equal(slider().props.max, 10);
// Simulate a fast drag: queued requests must retain the final position.
slider().props.onChange({ target: { value: "2" } });
slider().props.onChange({ target: { value: "3" } });
await app.settle();
assert.equal(app.camera.getSettings().focusMode, "manual");
assert.equal(app.camera.getSettings().focusDistance, 3);
assert.equal(slider().props.value, 3);
await app.find(node => node.props?.className === "scanner-torch").props.onClick();
assert.equal(app.camera.getSettings().focusMode, "manual");
assert.equal(app.camera.getSettings().focusDistance, 3);
assert.equal(app.camera.getSettings().torch, true);
app.find(node => node.props?.children === "Use autofocus").props.onClick();
await app.settle();
assert.equal(app.camera.getSettings().focusMode, "continuous");
assert.equal(app.camera.getSettings().torch, true);
app.cleanup();
});
test("scanner stays usable when the browser exposes no focus controls", async () => {
const app = await mount({ modes: [] });
assert.equal(app.calls.length, 0);
assert.equal(app.find(node => node.type === "input" && node.props.type === "range"), undefined);
assert.ok(app.find(node => node.props?.className === "scanner-view live"));
assert.ok(app.find(node => node.props?.onClick && Array.isArray(node.props.children) && node.props.children.includes("Restart camera")));
app.cleanup();
});
test("manual-only cameras offer fixed focus without an unsupported autofocus button", async () => {
const app = await mount({ modes: ["manual"], capabilities: { focusDistance: { min: 0, max: 1 } } });
app.find(node => node.type === "input" && node.props.type === "range").props.onChange({ target: { value: "0.4" } });
await app.settle();
assert.equal(app.camera.getSettings().focusMode, "manual");
assert.equal(app.find(node => node.props?.children === "Use autofocus"), undefined);
app.cleanup();
});