Let the dealer find one hand in the log instead of scrolling the night

The hand log exists for one moment: somebody at the rail says they won a pot an hour ago and wants it looked up. A night runs to sixty hands or more and the panel showed five of them at a time, in a box fixed at 260px whether the dealer was on a phone or a 27" screen with room for twenty. There was no way to ask for a hand — only to scroll and read every row. A filter box over the list now takes a name, an amount or a hand number. Matching is loose on purpose: "fay" whatever case it's typed in, "190" for a $190 pot or a $190 payout, "$1,90" for the same typed badly, "#12" when the dealer knows the hand and wants that exact one. Beside it, how much of the night is hidden — "8 of 60" — since a filter matching one hand otherwise looks like a table that only played one. The list also takes the room it has: clamp(200px, 42vh, 560px) rather than a flat 260, which is seven or eight rows instead of five on a desktop and no worse on a phone. Export stays the whole night, always. A CSV quietly missing the hands scrolled past would be a record with holes in it and nothing on the file to say so — if a filter is up when it's exported, the toast says how many went in. Matching deliberately covers only what the row displays. Searching the full ledger as well was the first attempt, so the hand that broke somebody could be found under the loser's name — but the ledger holds everyone who put a chip in, and measured on a seven-handed night where nobody folded, "Fay" returned 60 of 60. A filter that searches text the panel doesn't show looks broken even when it's right. Co-Authored-By: Claude Opus 5 <[email protected]> Claude-Session: https://claude.ai/code/session_015bnp7xKUPFFSpwkYNFaPgb
2026-09-01 22:39:55 -06:00
parent c76ebf4d18
commit 01f5139740
5 changed files with 250 additions and 2 deletions
@@ -591,15 +591,33 @@ document.addEventListener("DOMContentLoaded", () => {
        if (!ok) return;

        HoldemState.clearHistory(state);
+        Render.historyFilter = "";
+        document.getElementById("handHistoryFilter").value = "";
        hooks.save(state);
        Render.renderAll();
        Toast.show("Hand history cleared.", { duration: 2500 });
    });

+    // The filter is how the dealer looks at the log, not something about the table, so
+    // it lives on the view: it isn't saved, isn't undoable, and doesn't reach the other
+    // tab. Clearing the history clears it too, since there is nothing left to filter.
+    document.getElementById("handHistoryFilter").addEventListener("input", e => {
+        Render.historyFilter = e.target.value;
+        Render.renderHandHistory();
+    });
+
    document.getElementById("exportHistoryBtn").addEventListener("click", () => {
        if ((state.handHistory || []).length === 0) return;
+        // Always the whole night. A filter is for reading the panel; an export that
+        // quietly dropped the hands scrolled past would be a record with holes in it,
+        // and nothing on the CSV would say so.
        HandHistoryExport.download(state.handHistory, HoldemState.sessionStandings(state),
            { notes: state.notes });
+        if (Render.historyFilter) {
+            Toast.show(`Exported all ${state.handHistory.length} hands, not just the ${
+                state.handHistory.filter(h => Render.handMatchesFilter(h, Render.historyFilter)).length} shown.`,
+                { duration: 3500 });
+        }
    });

    // The load happens on the first line of this file, long before there's a Toast to
@@ -967,9 +967,50 @@ const Render = {
            newest ? newest.handNumber : "",
            newest ? newest.timestamp : "",
            newest ? newest.pot : "",
+            // Typing in the filter changes the list without changing the history, and
+            // the redraw is skipped when the signature matches — leave this out and the
+            // box takes input and does nothing.
+            this.historyFilter || "",
        ].join("|");
    },

+    // What the dealer opens the log for is one hand: the one somebody is arguing
+    // about. A night runs to sixty or more, five at a time in the panel, so finding it
+    // meant scrolling and reading every row. A name, an amount, or a hand number
+    // narrows it instead.
+    //
+    // Matching is deliberately loose. "fay" finds Fay whatever case it's typed in;
+    // "190" finds a $190 pot, a $190 payout, or hand 190, because a dealer half
+    // remembering an amount shouldn't have to know which of those they mean; "#12"
+    // pins it to the hand number, for when they do.
+    handMatchesFilter(entry, query) {
+        if (!query) return true;
+        const term = query.trim().toLowerCase();
+        if (!term) return true;
+
+        const handNumber = String(entry.handNumber || "");
+        if (term.startsWith("#")) return handNumber.startsWith(term.slice(1));
+
+        // Only what the row itself shows. Matching the hand's full ledger as well was
+        // the first attempt, on the reasoning that a dealer might hunt for the hand
+        // that broke somebody by the loser's name — but the ledger holds everyone who
+        // put a chip in, so at a table where nobody folds it matched every hand.
+        // Measured on a seven-handed night: "Fay" returned 60 of 60. Searching text the
+        // panel doesn't display is a filter that looks broken even when it's right.
+        const labels = (entry.payouts || []).map(p => String(p.label || "").toLowerCase()).join(" ");
+        if (labels.includes(term)) return true;
+
+        // Amounts, matched on the digits so "$190", "190" and "1,90" all behave.
+        const digits = term.replace(/[^0-9.]/g, "");
+        if (digits) {
+            const amounts = [entry.pot, ...(entry.payouts || []).map(p => p.amount)]
+                .map(a => String(Money.round(Number(a) || 0)));
+            if (amounts.some(a => a.startsWith(digits))) return true;
+            if (handNumber === digits) return true;
+        }
+        return false;
+    },
+
    // Rebuilding this panel measured 25.7ms of the 30ms a full re-render costs — and a
    // full re-render runs after every fold, call and raise. The log only changes when a
    // hand is settled or the history is cleared, perhaps once every thirty taps, so it
@@ -988,10 +1029,29 @@ const Render = {
        emptyHint.hidden = history.length > 0;
        document.getElementById("exportHistoryBtn").disabled = history.length === 0;

+        const query = this.historyFilter || "";
+        const shown = query ? history.filter(entry => this.handMatchesFilter(entry, query)) : history;
+
+        // How much of the night is being hidden. Without it a filter that matches one
+        // hand looks exactly like a table that only played one, which is the sort of
+        // thing a dealer reads wrong at 2am with somebody leaning over the rail.
+        const count = document.getElementById("handHistoryCount");
+        if (count) {
+            count.hidden = !query || history.length === 0;
+            count.textContent = `${shown.length} of ${history.length}`;
+        }
+        const noMatch = document.getElementById("handHistoryNoMatch");
+        if (noMatch) {
+            noMatch.hidden = !(query && history.length > 0 && shown.length === 0);
+            noMatch.textContent = `No hand matches “${query.trim()}”. The log still has all ${history.length}.`;
+        }
+        const filterBox = document.getElementById("handHistoryFilter");
+        if (filterBox) filterBox.hidden = history.length === 0;
+
        // Built off-document so the panel is laid out once instead of once per row.
        const fragment = document.createDocumentFragment();
        const template = document.getElementById("handHistoryRowTemplate");
-        history.forEach(entry => {
+        shown.forEach(entry => {
            const row = template.content.firstElementChild.cloneNode(true);
            row.querySelector(".handHistoryHandNumber").textContent = `Hand #${entry.handNumber}`;
            row.querySelector(".handHistoryPot").textContent = Money.format(entry.pot);