lhcb-ntuple-wizard-test 2.1.0 → 2.2.0

package/dist/providers/MetadataProvider.js

@@ -1,4 +1,4 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 /*****************************************************************************\
  * (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration           *
  *                                                                             *
@@ -12,6 +12,7 @@ import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useContext, useEffect, useState } from "react";
 import { config } from "../config.js";
 import pako from "pako";
+import { LoadingIndicator } from "../components/LoadingIndicator";
 const MetadataContextType = createContext(null);
 export function MetadataProvider({ children }) {
     const [error, setError] = useState(null);
@@ -39,12 +40,17 @@ export function MetadataProvider({ children }) {
             .catch(setError);
     }, []);
     if (error) {
-        return _jsxs("h1", { children: ["Oops: ", `${error}`] });
+        console.error("Failed to load metadata:", error);
+        return _jsx("h1", { children: "Error: failed to load metadata" });
     }
-    else {
-        return _jsx(MetadataContextType.Provider, { value: metadata, children: children });
+    if (!metadata) {
+        return _jsx(LoadingIndicator, { height: "70vh", message: "Loading metadata..." });
     }
+    return _jsx(MetadataContextType.Provider, { value: metadata, children: children });
 }
 export const useMetadata = () => {
-    return useContext(MetadataContextType);
+    const ctx = useContext(MetadataContextType);
+    if (!ctx)
+        throw new Error("useMetadata must be used inside MetadataProvider");
+    return ctx;
 };

package/dist/providers/RequestProvider.js

@@ -36,9 +36,9 @@ export const RequestProvider = ({ emailIsKnown, children }) => {
         const isEmptySession = !productionName && contactEmails.length === 0 && rows.length === 0;
         const isEmailValid = contactEmails.length > 0 && contactEmails.every(EmailValidator.validate);
         const allRowsHaveDtt = configuredRows.length > 0 && configuredRows.length === rows.length;
-        const allRowsHaveStrippingLine = rows.every((r) => r.lines.length > 0);
+        const allRowsHaveStrippingLine = rows.every((r) => r.line);
         const allRowsHavePaths = rows.every((r) => r.paths.length > 0);
-        const dttNames = configuredRows.map((r) => r.dtt.getName().trim());
+        const dttNames = configuredRows.map((r) => r.dtt?.getName()?.trim());
         const validDttNames = dttNames.every(Boolean) && new Set(dttNames).size === dttNames.length;
         return {
             isEmptySession,

package/dist/providers/RowProvider.d.ts

@@ -3,8 +3,8 @@ import { RowData } from "../models/rowData";
 import { StrippingLine } from "../models/strippingLine";
 interface RowContextType {
     row: RowData;
-    validateBkPath: (choice: string, lines?: StrippingLine[]) => boolean;
-    updateBkPaths: (paths: string[], lines?: StrippingLine[]) => void;
+    validateBkPath: (choice: string, line?: StrippingLine) => boolean;
+    updateBkPaths: (paths: string[], line?: StrippingLine) => void;
 }
 interface RowProviderProps {
     row: RowData;

package/dist/providers/RowProvider.js

@@ -5,21 +5,22 @@ import { useRows } from "./RowsProvider";
 const RowContext = createContext(null);
 export const RowProvider = ({ row, children }) => {
     const { updateRow } = useRows();
-    const validateBkPathsForLines = useCallback((choice, lines = row.lines) => {
+    const validateBkPathsForLines = useCallback((choice, line = row.line) => {
+        if (!line) {
+            return true;
+        }
         try {
             const path = new BkPath(choice);
-            return lines.every((line) => {
-                const streamName = line.stream.toLowerCase();
-                const fileName = path.fileName.split(".")[0].toLowerCase();
-                const matchingVersion = line.versions.some((v) => path.strippingVersion === v);
-                return ["allstreams", streamName].includes(fileName) && matchingVersion;
-            });
+            const streamName = line.stream.toLowerCase();
+            const fileName = path.fileName.split(".")[0].toLowerCase();
+            const matchingVersion = line.versions.some((v) => path.strippingVersion === v);
+            return ["allstreams", streamName].includes(fileName) && matchingVersion;
         }
         catch {
             return false;
         }
-    }, [row.lines]);
-    const updateBkPathsForLines = useCallback((paths, lines = row.lines) => {
+    }, [row.line]);
+    const updateBkPathsForLines = useCallback((paths, lines = row.line) => {
         updateRow(row.id, (r) => ({
             ...r,
             paths: paths.filter((p) => validateBkPathsForLines(p, lines)),

package/dist/providers/RowsProvider.js

@@ -18,9 +18,6 @@ export const RowsProvider = ({ children }) => {
         setRows((prev) => prev.filter((r) => r.id !== id));
     };
     const generateAllFiles = () => {
-        if (!metadata) {
-            return [];
-        }
         return [
             ...rows.filter((row) => row.dtt).map((row) => YamlFile.fromDtt(row.dtt)),
             YamlFile.createInfoYaml(rows, metadata),

package/dist/tests/components/BookkeepingPathDropdown.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/components/BookkeepingPathDropdown.test.js

@@ -0,0 +1,118 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { render, screen } from "@testing-library/react";
+import { BookkeepingPathDropdown } from "../../components/BookkeepingPathDropdown";
+import { mockStrippingLine } from "../testUtils";
+const SAMPLE_PATH = "/LHCb/Collision16/Beam6500GeV-VeloClosed-MagDown/Real Data/Reco16/Stripping28r2/90000000/ALLSTREAMS.DST";
+const mockUpdateBkPaths = vi.fn();
+const mockValidateBkPath = vi.fn(() => true);
+const mockUpdateRow = vi.fn();
+const mockMetadataWithDataset = {
+    dataset: [SAMPLE_PATH],
+    decays: {},
+    embedding: {},
+    kgdoc: {},
+    lokiVariables: { applicationInfo: {}, lokiVariables: {} },
+    particleProperties: {},
+    stripping: {},
+    strippingHints: {},
+    tupleTools: { applicationInfo: {}, tupleTools: {} },
+    userHints: { decayTags: {}, particleTags: {} },
+};
+vi.mock("../../providers/MetadataProvider", () => ({
+    useMetadata: () => mockMetadataWithDataset,
+}));
+let mockRow = {
+    id: 0,
+    decay: { lines: {}, tags: [], descriptors: {} },
+    dtt: null,
+    line: mockStrippingLine,
+    paths: [],
+    pathOptions: [],
+};
+vi.mock("../../providers/RowProvider", () => ({
+    useRow: () => ({
+        row: mockRow,
+        validateBkPath: mockValidateBkPath,
+        updateBkPaths: mockUpdateBkPaths,
+    }),
+}));
+vi.mock("../../providers/RowsProvider", () => ({
+    useRows: () => ({
+        updateRow: mockUpdateRow,
+    }),
+}));
+vi.mock("../../components/DatasetInfo", () => ({
+    DatasetInfo: ({ pathString }) => _jsx("span", { children: pathString }),
+}));
+// Stub Creatable so we can invoke onCreateOption directly in tests
+let capturedOnCreateOption = null;
+vi.mock("react-select/creatable", () => ({
+    default: ({ onCreateOption, value, isDisabled, }) => {
+        capturedOnCreateOption = onCreateOption;
+        return (_jsxs(_Fragment, { children: [_jsx("input", { role: "combobox", disabled: isDisabled, readOnly: true }), value?.map((v) => (_jsx("span", { children: v.label }, v.value)))] }));
+    },
+}));
+describe("BookkeepingPathDropdown", () => {
+    beforeEach(() => {
+        mockRow = {
+            id: 0,
+            decay: { lines: {}, tags: [], descriptors: {} },
+            dtt: null,
+            line: mockStrippingLine,
+            paths: [],
+            pathOptions: [],
+        };
+        capturedOnCreateOption = null;
+    });
+    it("renders a combobox", () => {
+        render(_jsx(BookkeepingPathDropdown, {}));
+        expect(screen.getByRole("combobox")).toBeInTheDocument();
+    });
+    it("is enabled when a stripping line is selected", () => {
+        render(_jsx(BookkeepingPathDropdown, {}));
+        expect(screen.getByRole("combobox")).not.toBeDisabled();
+    });
+    it("renders without error when dataset has paths", () => {
+        expect(() => render(_jsx(BookkeepingPathDropdown, {}))).not.toThrow();
+    });
+    it("renders selected paths from row.paths", () => {
+        mockRow = { ...mockRow, paths: [SAMPLE_PATH] };
+        render(_jsx(BookkeepingPathDropdown, {}));
+        expect(document.body.textContent).toContain(SAMPLE_PATH);
+    });
+});
+describe("BookkeepingPathDropdown — handleCreatePath", () => {
+    beforeEach(() => {
+        mockRow = {
+            id: 0,
+            decay: { lines: {}, tags: [], descriptors: {} },
+            dtt: null,
+            line: mockStrippingLine,
+            paths: [],
+            pathOptions: [],
+        };
+        mockUpdateRow.mockClear();
+        mockValidateBkPath.mockReset();
+        capturedOnCreateOption = null;
+    });
+    it("calls updateRow with the new path when the path is valid", () => {
+        mockValidateBkPath.mockReturnValue(true);
+        render(_jsx(BookkeepingPathDropdown, {}));
+        capturedOnCreateOption(SAMPLE_PATH);
+        expect(mockUpdateRow).toHaveBeenCalledOnce();
+        const updater = mockUpdateRow.mock.calls[0][1];
+        const result = updater({ paths: [], pathOptions: [] });
+        expect(result.paths).toContain(SAMPLE_PATH);
+        expect(result.pathOptions).toContain(SAMPLE_PATH);
+    });
+    it("shows an alert and does not call updateRow when the path is invalid", () => {
+        mockValidateBkPath.mockReturnValue(false);
+        const alertSpy = vi.spyOn(window, "alert").mockImplementation(() => { });
+        render(_jsx(BookkeepingPathDropdown, {}));
+        capturedOnCreateOption("bad-path");
+        expect(alertSpy).toHaveBeenCalledWith("The path 'bad-path' is not valid for the selected stripping line.");
+        expect(mockUpdateRow).not.toHaveBeenCalled();
+        alertSpy.mockRestore();
+    });
+});

package/dist/tests/components/DatasetInfo.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/components/DatasetInfo.test.js

@@ -0,0 +1,38 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it, vi } from "vitest";
+import { render, screen } from "@testing-library/react";
+import { DatasetInfo } from "../../components/DatasetInfo";
+const VALID_PATH = "/LHCb/Collision16/Beam6500GeV-VeloClosed-MagDown/Real Data/Reco16/Stripping28r2/90000000/DIMUON.DST";
+// Stub the badge components to keep tests focused on DatasetInfo's own logic
+vi.mock("../../components/YearBadge", () => ({ YearBadge: ({ year }) => _jsx("span", { children: year }) }));
+vi.mock("../../components/PolarityBadge", () => ({
+    PolarityBadge: ({ polarity }) => _jsx("span", { children: polarity }),
+}));
+vi.mock("../../components/StrippingLineVersionBadge", () => ({
+    StrippingLineVersionBadge: ({ version }) => _jsx("span", { children: version }),
+}));
+vi.mock("../../components/DatasetEventTypeBadge", () => ({
+    DatasetEventTypeBadge: ({ eventType }) => _jsx("span", { children: eventType }),
+}));
+describe("DatasetInfo", () => {
+    it("renders the file name for a valid path", () => {
+        render(_jsx(DatasetInfo, { pathString: VALID_PATH }));
+        expect(screen.getByText("DIMUON.DST")).toBeInTheDocument();
+    });
+    it("renders the year badge", () => {
+        render(_jsx(DatasetInfo, { pathString: VALID_PATH }));
+        expect(screen.getByText("2016")).toBeInTheDocument();
+    });
+    it("renders the polarity badge", () => {
+        render(_jsx(DatasetInfo, { pathString: VALID_PATH }));
+        expect(screen.getByText("MagDown")).toBeInTheDocument();
+    });
+    it("renders the stripping version badge", () => {
+        render(_jsx(DatasetInfo, { pathString: VALID_PATH }));
+        expect(screen.getByText("28r2")).toBeInTheDocument();
+    });
+    it("returns null (renders nothing) for an invalid path string", () => {
+        const { container } = render(_jsx(DatasetInfo, { pathString: "not/a/valid/path" }));
+        expect(container.firstChild).toBeNull();
+    });
+});

package/dist/tests/components/DecayCard.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/components/DecayCard.test.js

@@ -0,0 +1,115 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { DecayCard } from "../../components/DecayCard";
+import { createMockDtt, createMockRow, mockDecay, mockStrippingLine } from "../testUtils";
+import { MemoryRouter } from "react-router-dom";
+// ---------------------------------------------------------------------------
+// Module mocks
+// ---------------------------------------------------------------------------
+const mockNavigate = vi.fn();
+vi.mock("react-router-dom", async (importOriginal) => {
+    const actual = await importOriginal();
+    return { ...actual, useNavigate: () => mockNavigate };
+});
+let mockRow = createMockRow();
+let mockRows = [mockRow];
+const mockUpdateRow = vi.fn();
+const mockSetRows = vi.fn();
+vi.mock("../../providers/RowProvider", () => ({
+    useRow: () => ({ row: mockRow, validateBkPath: vi.fn(() => true), updateBkPaths: vi.fn() }),
+}));
+vi.mock("../../providers/RowsProvider", () => ({
+    useRows: () => ({
+        rows: mockRows,
+        configuredRows: mockRows.filter((r) => r.dtt),
+        setRows: mockSetRows,
+        updateRow: mockUpdateRow,
+        removeRow: vi.fn(),
+        generateAllFiles: vi.fn(),
+    }),
+}));
+vi.mock("../../providers/WizardConfigProvider", () => ({
+    useWizardConfig: () => ({ variant: "standalone", basePath: "" }),
+}));
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function renderCard() {
+    return render(_jsx(MemoryRouter, { children: _jsx(DecayCard, {}) }));
+}
+// ---------------------------------------------------------------------------
+// Tests — no DTT configured
+// ---------------------------------------------------------------------------
+describe("DecayCard — no DTT", () => {
+    beforeEach(() => {
+        mockRow = createMockRow({ decay: mockDecay, dtt: null });
+        mockRows = [mockRow];
+    });
+    it("renders without crashing", () => {
+        renderCard();
+        expect(screen.getByTestId("inline-math")).toBeInTheDocument();
+    });
+    it("shows a success-variant add button when there is no DTT", () => {
+        const { container } = renderCard();
+        expect(container.querySelector(".btn-success")).toBeInTheDocument();
+    });
+    it("shows the upload button (standalone mode) when there is no DTT", () => {
+        const { container } = renderCard();
+        // Two buttons: success (add) and default (upload)
+        const buttons = container.querySelectorAll(".card-header button");
+        expect(buttons.length).toBeGreaterThanOrEqual(2);
+    });
+    it("calls updateRow when the add button is clicked", async () => {
+        const { container } = renderCard();
+        const addButton = container.querySelector(".btn-success");
+        fireEvent.click(addButton);
+        await waitFor(() => expect(mockUpdateRow).toHaveBeenCalledOnce());
+    });
+    it("does not show the name input when there is no DTT", () => {
+        renderCard();
+        expect(screen.queryByPlaceholderText("MyDecayTree")).not.toBeInTheDocument();
+    });
+    it("does not show the configure (secondary) button when there is no DTT", () => {
+        const { container } = renderCard();
+        expect(container.querySelector(".btn-secondary")).not.toBeInTheDocument();
+    });
+});
+// ---------------------------------------------------------------------------
+// Tests — DTT configured
+// ---------------------------------------------------------------------------
+describe("DecayCard — DTT configured", () => {
+    beforeEach(() => {
+        const dtt = createMockDtt("MyTree");
+        mockRow = createMockRow({ decay: mockDecay, dtt, line: mockStrippingLine });
+        mockRows = [mockRow];
+    });
+    it("shows the DTT name input field", () => {
+        renderCard();
+        expect(screen.getByPlaceholderText("MyDecayTree")).toBeInTheDocument();
+    });
+    it("shows the configure button (secondary variant)", () => {
+        const { container } = renderCard();
+        expect(container.querySelector(".btn-secondary")).toBeInTheDocument();
+    });
+    it("shows the download button (standalone mode)", () => {
+        const { container } = renderCard();
+        // In standalone+DTT mode: secondary (configure), default (download), danger (delete)
+        const buttons = container.querySelectorAll(".card-header button");
+        expect(buttons.length).toBeGreaterThanOrEqual(3);
+    });
+    it("shows a danger-variant delete button", () => {
+        const { container } = renderCard();
+        expect(container.querySelector(".btn-danger")).toBeInTheDocument();
+    });
+    it("navigates to /variables when the configure button is clicked", async () => {
+        const { container } = renderCard();
+        const configureButton = container.querySelector(".btn-secondary");
+        fireEvent.click(configureButton);
+        await waitFor(() => expect(mockNavigate).toHaveBeenCalledWith("/variables"));
+    });
+    it("does not show the add (+) button when DTT exists", () => {
+        const { container } = renderCard();
+        expect(container.querySelector(".btn-success")).not.toBeInTheDocument();
+    });
+});

package/dist/tests/components/DecayLatex.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/components/DecayLatex.test.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it } from "vitest";
+import { render, screen } from "@testing-library/react";
+import { DecayLatex } from "../../components/DecayLatex";
+import { mockDecay } from "../testUtils";
+describe("DecayLatex", () => {
+    it("renders without crashing", () => {
+        render(_jsx(DecayLatex, { decay: mockDecay }));
+        expect(screen.getByTestId("inline-math")).toBeInTheDocument();
+    });
+    it("renders the decay's LaTeX when no selection is provided", () => {
+        render(_jsx(DecayLatex, { decay: mockDecay }));
+        expect(screen.getByTestId("inline-math").textContent).toBe(mockDecay.descriptors.latex);
+    });
+    it("renders the decay's LaTeX when selection is an empty array", () => {
+        render(_jsx(DecayLatex, { decay: mockDecay, selection: [] }));
+        expect(screen.getByTestId("inline-math").textContent).toBe(mockDecay.descriptors.latex);
+    });
+    it("renders highlighted LaTeX when a branch is selected", () => {
+        render(_jsx(DecayLatex, { decay: mockDecay, selection: ["head"] }));
+        const math = screen.getByTestId("inline-math").textContent ?? "";
+        // The selected particle should be wrapped in \textcolor
+        expect(math).toContain("\\textcolor");
+    });
+    it("renders a span wrapper around the math (for the popover trigger)", () => {
+        const { container } = render(_jsx(DecayLatex, { decay: mockDecay }));
+        // The InlineMath is wrapped in a span so the OverlayTrigger can attach
+        const span = container.querySelector("span > span[data-testid='inline-math']");
+        expect(span).not.toBeNull();
+    });
+});

package/dist/tests/components/DecayList.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/components/DecayList.test.js

@@ -0,0 +1,76 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it, vi } from "vitest";
+import { act, fireEvent, render, screen } from "@testing-library/react";
+import { DecayList } from "../../components/DecayList";
+import { mockDecay } from "../testUtils";
+vi.mock("../../components/DecayTagBadge", () => ({
+    DecayTagBadge: ({ tag }) => _jsx("span", { children: tag }),
+}));
+// react-infinite-scroll-component doesn't support scroll in jsdom — render children directly
+// Capture the `next` callback so tests can trigger batch loading
+let capturedNext = null;
+vi.mock("react-infinite-scroll-component", () => ({
+    default: ({ children, next }) => {
+        capturedNext = next;
+        return _jsx("div", { "data-testid": "infinite-scroll", children: children });
+    },
+}));
+vi.mock("../../config", () => ({
+    config: { batch_size: 5 },
+}));
+const mockOnItemSelected = vi.fn();
+const makeDecay = (name) => ({
+    ...mockDecay,
+    descriptors: { ...mockDecay.descriptors, plain: name },
+});
+describe("DecayList — empty", () => {
+    it("shows a 'no matching decays' alert when the list is empty", () => {
+        render(_jsx(DecayList, { decays: [], selectedDecays: [], onItemSelected: mockOnItemSelected }));
+        expect(screen.getByText(/no matching decays/i)).toBeInTheDocument();
+    });
+});
+describe("DecayList — with items", () => {
+    it("renders one list item per decay", () => {
+        const decays = [makeDecay("a"), makeDecay("b"), makeDecay("c")];
+        render(_jsx(DecayList, { decays: decays, selectedDecays: [], onItemSelected: mockOnItemSelected }));
+        expect(screen.getAllByRole("checkbox")).toHaveLength(3);
+    });
+    it("shows the count alert", () => {
+        const decays = [makeDecay("a"), makeDecay("b")];
+        render(_jsx(DecayList, { decays: decays, selectedDecays: [], onItemSelected: mockOnItemSelected }));
+        expect(screen.getByText(/showing 2 of 2/i)).toBeInTheDocument();
+    });
+    it("calls onItemSelected when a decay is clicked", () => {
+        mockOnItemSelected.mockClear();
+        const decays = [makeDecay("a")];
+        const { container } = render(_jsx(DecayList, { decays: decays, selectedDecays: [], onItemSelected: mockOnItemSelected }));
+        fireEvent.click(container.querySelector("li"));
+        expect(mockOnItemSelected).toHaveBeenCalled();
+    });
+    it("renders the initial batch when decay count exceeds batch_size", () => {
+        const decays = Array.from({ length: 8 }, (_, i) => makeDecay(`decay${i}`));
+        render(_jsx(DecayList, { decays: decays, selectedDecays: [], onItemSelected: mockOnItemSelected }));
+        // batch_size is 5, so only 5 items rendered initially
+        expect(screen.getAllByRole("checkbox")).toHaveLength(5);
+        expect(screen.getByText(/showing 5 of 8/i)).toBeInTheDocument();
+    });
+    it("loads more items when fetchMoreData is called", () => {
+        capturedNext = null;
+        const decays = Array.from({ length: 8 }, (_, i) => makeDecay(`decay${i}`));
+        render(_jsx(DecayList, { decays: decays, selectedDecays: [], onItemSelected: mockOnItemSelected }));
+        // Trigger the infinite scroll "next" callback to load more items
+        expect(capturedNext).not.toBeNull();
+        act(() => capturedNext());
+        expect(screen.getAllByRole("checkbox")).toHaveLength(8);
+    });
+    it("deselects a decay when it is in selectedDecays and is clicked", () => {
+        mockOnItemSelected.mockClear();
+        const decay = makeDecay("selected-decay");
+        render(_jsx(DecayList, { decays: [decay], selectedDecays: [decay], onItemSelected: mockOnItemSelected }));
+        const { container } = render(_jsx(DecayList, { decays: [decay], selectedDecays: [decay], onItemSelected: mockOnItemSelected }));
+        fireEvent.click(container.querySelector("li"));
+        // The deselect branch filters out the clicked decay from selectedDecays
+        const calledWith = mockOnItemSelected.mock.calls[mockOnItemSelected.mock.calls.length - 1][0];
+        expect(calledWith).toHaveLength(0);
+    });
+});

package/dist/tests/components/DecayListItem.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/components/DecayListItem.test.js

@@ -0,0 +1,51 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, expect, it, vi } from "vitest";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { DecayListItem } from "../../components/DecayListItem";
+import { mockDecay } from "../testUtils";
+vi.mock("../../components/DecayTagBadge", () => ({
+    DecayTagBadge: ({ tag }) => _jsx("span", { "data-testid": "decay-tag-badge", children: tag }),
+}));
+const mockOnItemSelected = vi.fn();
+describe("DecayListItem", () => {
+    it("renders a checkbox", () => {
+        render(_jsx(DecayListItem, { decay: mockDecay, onItemSelected: mockOnItemSelected }));
+        expect(screen.getByRole("checkbox")).toBeInTheDocument();
+    });
+    it("checkbox is unchecked by default", () => {
+        render(_jsx(DecayListItem, { decay: mockDecay, onItemSelected: mockOnItemSelected }));
+        expect(screen.getByRole("checkbox")).not.toBeChecked();
+    });
+    it("checkbox is checked when initiallySelected=true", () => {
+        render(_jsx(DecayListItem, { decay: mockDecay, initiallySelected: true, onItemSelected: mockOnItemSelected }));
+        expect(screen.getByRole("checkbox")).toBeChecked();
+    });
+    it("calls onItemSelected with selected=false when clicking an unselected item", () => {
+        mockOnItemSelected.mockClear();
+        const { container } = render(_jsx(DecayListItem, { decay: mockDecay, onItemSelected: mockOnItemSelected }));
+        fireEvent.click(container.querySelector("li"));
+        expect(mockOnItemSelected).toHaveBeenCalledWith({ selected: false, decay: mockDecay });
+    });
+    it("calls onItemSelected with selected=true when clicking a selected item", () => {
+        mockOnItemSelected.mockClear();
+        const { container } = render(_jsx(DecayListItem, { decay: mockDecay, initiallySelected: true, onItemSelected: mockOnItemSelected }));
+        fireEvent.click(container.querySelector("li"));
+        expect(mockOnItemSelected).toHaveBeenCalledWith({ selected: true, decay: mockDecay });
+    });
+    it("toggles the checkbox state on click", () => {
+        const { container } = render(_jsx(DecayListItem, { decay: mockDecay, onItemSelected: mockOnItemSelected }));
+        const li = container.querySelector("li");
+        expect(screen.getByRole("checkbox")).not.toBeChecked();
+        fireEvent.click(li);
+        expect(screen.getByRole("checkbox")).toBeChecked();
+    });
+    it("renders tag badges for decay tags", () => {
+        const decayWithTags = { ...mockDecay, tags: ["B2OC", "SLOW"] };
+        render(_jsx(DecayListItem, { decay: decayWithTags, onItemSelected: mockOnItemSelected }));
+        expect(screen.getAllByTestId("decay-tag-badge")).toHaveLength(2);
+    });
+    it("renders the decay latex", () => {
+        render(_jsx(DecayListItem, { decay: mockDecay, onItemSelected: mockOnItemSelected }));
+        expect(screen.getByTestId("inline-math")).toBeInTheDocument();
+    });
+});

package/dist/tests/components/DecayTreeCard.test.d.ts

@@ -0,0 +1 @@
+export {};