Open-source manufacturing ERP, MES and QMS. Quoting, MRP, inventory, shop floor, quality and lot/serial traceability on one Postgres schema, with a REST API and MCP server. Self-host or use Carbon Cloud.
TypeScript ai-agentsbill-of-materialserpinventory-managementleanmanufacturingmanufacturing-execution-systemmcp-servermesmrpopen-source-erppostgresqlproduction-planningqmsquality-management-systemreact-routerself-hostedsupabasetraceabilitytypescript
fix(react): act on a barcode scan that ends without Enter (#2046)
Brad Barbin225cf09c3412
diff --git a/packages/react/src/__tests__/useKeyboardWedge.test.ts b/packages/react/src/__tests__/useKeyboardWedge.test.tsnew file mode 100644index 0000000000..d1c16a3aa8--- /dev/null+++ b/packages/react/src/__tests__/useKeyboardWedge.test.ts@@ -0,0 +1,30 @@+// SPDX-License-Identifier: AGPL-3.0-only+// Carbon (github.com/crbnos/carbon). Modified or adapted versions of this file,+// including ports, remain AGPLv3; serving them over a network requires releasing their source.++import { describe, expect, it } from "vitest";+import { typedByScanner } from "../hooks/useKeyboardWedge";++// A kanban URL is 70 characters: 69 gaps between its first and last key.+describe("typedByScanner", () => {+ it("accepts a URL a scanner typed at 8 ms per key", () => {+ expect(typedByScanner(0, 69 * 8, 70)).toBe(true);+ });++ it("accepts a scan with one slow gap when the average is still scanner speed", () => {+ // 68 gaps of 10 ms and one Bluetooth hiccup of 400 ms: 1080 / 69 ≈ 15.7 ms.+ expect(typedByScanner(0, 68 * 10 + 400, 70)).toBe(true);+ });++ it("refuses the same URL typed by a person at 150 ms per key", () => {+ expect(typedByScanner(0, 69 * 150, 70)).toBe(false);+ });++ it("refuses an average of exactly 50 ms per key", () => {+ expect(typedByScanner(0, 69 * 50, 70)).toBe(false);+ });++ it("refuses a single key, which has no speed", () => {+ expect(typedByScanner(100, 100, 1)).toBe(false);+ });+});diff --git a/packages/react/src/hooks/useKeyboardWedge.ts b/packages/react/src/hooks/useKeyboardWedge.tsindex 5703068065..42223ac483 100644--- a/packages/react/src/hooks/useKeyboardWedge.ts+++ b/packages/react/src/hooks/useKeyboardWedge.ts@@ -2,7 +2,7 @@// Carbon (github.com/crbnos/carbon). Modified or adapted versions of this file,// including ports, remain AGPLv3; serving them over a network requires releasing their source.-import { useEffect, useState } from "react";+import { useEffect, useRef, useState } from "react";import { useNavigate } from "react-router";interface UseKeyboardWedgeOptions {@@ -11,6 +11,28 @@ interface UseKeyboardWedgeOptions {active?: boolean;}+/** A scanner types faster than this per key on average; a person never does. */+const SCANNER_KEY_GAP_MS = 50;+/** A scan with no Enter suffix is over once no key arrives for this long. */+const SCAN_END_MS = 200;+/** A buffer nobody submitted is dropped after this long without a key. */+const BUFFER_RESET_MS = 3000;++/**+ * Whether `length` keys typed between `firstKeyAt` and `lastKeyAt` came from+ * a barcode scanner rather than a person. Scanners configured without an+ * Enter suffix end a scan by going quiet, so this is how the wedge tells a+ * finished scan from someone typing.+ */+export function typedByScanner(+ firstKeyAt: number,+ lastKeyAt: number,+ length: number+): boolean {+ if (length < 2) return false;+ return (lastKeyAt - firstKeyAt) / (length - 1) < SCANNER_KEY_GAP_MS;+}+export function useKeyboardWedge(options?: UseKeyboardWedgeOptions) {const [inputBuffer, setInputBuffer] = useState("");const navigate = useNavigate();@@ -38,9 +60,41 @@ export function useKeyboardWedge(options?: UseKeyboardWedgeOptions) {const callback = options?.callback ?? defaultCallback;const active = options?.active ?? true;+ // Callers pass inline functions; the listener reads the latest ones so it+ // never re-subscribes (and loses the buffer) mid-scan.+ const handlers = useRef({ test, callback });+ handlers.current = { test, callback };+useEffect(() => {if (!active) return;+ // The buffer lives here, not in state: the Enter that ends a scan must+ // see every key before it, whether or not React has re-rendered since.+ let buffer = "";+ let firstKeyAt = 0;+ let lastKeyAt = 0;+ let scanEndTimer: ReturnType<typeof setTimeout> | undefined;+ let resetTimer: ReturnType<typeof setTimeout> | undefined;++ const clear = () => {+ buffer = "";+ clearTimeout(scanEndTimer);+ clearTimeout(resetTimer);+ setInputBuffer("");+ };++ // A scanner with no Enter suffix: submit once the burst goes quiet.+ const endScan = () => {+ if (+ typedByScanner(firstKeyAt, lastKeyAt, buffer.length) &&+ handlers.current.test(buffer)+ ) {+ const input = buffer;+ clear();+ handlers.current.callback(input);+ }+ };+const handleKeyDown = (event: KeyboardEvent) => {// Check if the active element is an input or textareaconst activeElement = document.activeElement;@@ -53,32 +107,34 @@ export function useKeyboardWedge(options?: UseKeyboardWedgeOptions) {}if (/^[a-zA-Z0-9\-./:?=&_]$/.test(event.key)) {- setInputBuffer((prev) => prev + event.key);+ const now = Date.now();+ if (buffer === "") firstKeyAt = now;+ lastKeyAt = now;+ buffer += event.key;+ setInputBuffer(buffer);+ clearTimeout(scanEndTimer);+ clearTimeout(resetTimer);+ scanEndTimer = setTimeout(endScan, SCAN_END_MS);+ resetTimer = setTimeout(clear, BUFFER_RESET_MS);} else if (event.key === "Enter") {- if (test(inputBuffer)) {+ const input = buffer;+ clear();+ if (handlers.current.test(input)) {event.preventDefault();+ handlers.current.callback(input);}-- if (test(inputBuffer)) {- callback(inputBuffer);- }- setInputBuffer("");} else if (event.key === "Escape") {- setInputBuffer("");+ clear();}};- const timeoutId = setTimeout(() => {- setInputBuffer("");- }, 3000);-document.addEventListener("keydown", handleKeyDown);return () => {document.removeEventListener("keydown", handleKeyDown);- clearTimeout(timeoutId);+ clear();};- }, [inputBuffer, test, callback, active]);+ }, [active]);return inputBuffer;}