Skip to content

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.

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.ts
new file mode 100644
index 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.ts
index 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 textarea
const 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;
}