lhcb-ntuple-wizard-test 2.1.0 → 2.2.0

package/dist/components/TupleToolGroupsAccordion.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Accordion, Button, ListGroup, OverlayTrigger, Tooltip } from "react-bootstrap";
+import { CircleSquare, PencilSquare, PlusLg } from "react-bootstrap-icons";
+import { getControlKey } from "../utils/utils";
+import { useDtt } from "../providers/DttProvider";
+import { ParticleLatex } from "./ParticleLatex";
+import _ from "lodash";
+import { AddTupleToolButton } from "./AddTupleToolButton";
+export function TupleToolGroupsAccordion({ setActiveKey }) {
+    const { dtt, selectedBranch, setSelectedBranch, hoveredBranch, setHoveredBranch, highlightedBranch } = useDtt();
+    function handleGroupSelected(branchGroup) {
+        setActiveKey("0");
+        setSelectedBranch(branchGroup);
+        setHoveredBranch([]);
+    }
+    const groupsWithTools = dtt.getGroupsWithTools();
+    return (_jsxs(Accordion.Item, { eventKey: "1", children: [_jsx(Accordion.Header, { children: _jsxs("div", { className: "d-flex align-items-center gap-2", children: [_jsx(CircleSquare, {}), groupsWithTools.length, " group", groupsWithTools.length === 1 ? "" : "s"] }) }), _jsx(Accordion.Body, { style: { padding: 4 }, children: groupsWithTools.length > 0 ? (_jsxs(ListGroup, { variant: "flush", children: [groupsWithTools.map((group) => {
+                            const branchGroup = group.split(",");
+                            return (_jsx(ListGroup.Item, { onMouseEnter: () => setHoveredBranch(branchGroup), onMouseLeave: () => setHoveredBranch([]), onClick: () => handleGroupSelected(branchGroup), style: {
+                                    cursor: "pointer",
+                                    backgroundColor: _.isEqual(hoveredBranch, branchGroup)
+                                        ? "var(--bs-gray-100)"
+                                        : "transparent",
+                                }, children: _jsxs("div", { className: "d-flex justify-content-between align-items-center", children: [_jsx("div", { className: "d-flex flex-wrap align-items-center gap-3", children: branchGroup.map((pid, i) => (_jsx(ParticleLatex, { particleId: pid, highlighted: _.isEqual(highlightedBranch, branchGroup) }, i))) }), _jsx(OverlayTrigger, { overlay: _jsx(Tooltip, { children: "Edit group TupleTools" }), children: _jsx(Button, { size: "sm", variant: "outline-secondary", onClick: () => handleGroupSelected(branchGroup), children: _jsx(PencilSquare, {}) }) })] }) }, group));
+                        }), selectedBranch.length > 1 && !groupsWithTools.includes(selectedBranch.join(",")) && (_jsx(ListGroup.Item, { onMouseEnter: () => setHoveredBranch(selectedBranch), onMouseLeave: () => setHoveredBranch([]), onClick: () => handleGroupSelected(selectedBranch), style: {
+                                cursor: "pointer",
+                                backgroundColor: _.isEqual(hoveredBranch, selectedBranch)
+                                    ? "var(--bs-gray-100)"
+                                    : "transparent",
+                            }, children: _jsxs("div", { className: "d-flex justify-content-between align-items-center", children: [_jsx("div", { className: "d-flex flex-wrap align-items-center gap-3", children: selectedBranch.map((pid, i) => (_jsx(ParticleLatex, { particleId: pid, highlighted: true }, i))) }), _jsx(OverlayTrigger, { overlay: _jsx(Tooltip, { children: "Create group" }), children: _jsx(Button, { size: "sm", variant: "success", onClick: () => handleGroupSelected(selectedBranch), children: _jsx(PlusLg, {}) }) })] }) }, selectedBranch.join(",")))] })) : (_jsxs("div", { className: "text-muted d-flex flex-column gap-2 p-3", children: [selectedBranch.length === 0 ? (_jsxs("div", { children: ["No groups have been created yet. Select multiple particles (", _jsx("code", { children: getControlKey() }), " + click) and add a TupleTool to create a group."] })) : selectedBranch.length === 1 ? (_jsxs("div", { children: ["Select multiple particles (", _jsx("code", { children: getControlKey() }), " + click) to create a group."] })) : (_jsxs("div", { children: ["No groups include the selected particle", selectedBranch.length > 1 ? "s" : "", ". Add a TupleTool to create a group."] })), selectedBranch.length > 1 && _jsx(AddTupleToolButton, {})] })) })] }));
+}

package/dist/components/TupleToolLabel.d.ts

@@ -2,5 +2,5 @@ import { TupleTool } from "../models/tupleTool";
 interface Props {
     tool: TupleTool;
 }
-export declare function TupleToolLabel({ tool }: Props): import("react/jsx-runtime").JSX.Element | null;
+export declare function TupleToolLabel({ tool }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/TupleToolLabel.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /*****************************************************************************\
  * (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration           *
  *                                                                             *
@@ -13,8 +13,5 @@ import { OverlayTrigger, Tooltip } from "react-bootstrap";
 import { useMetadata } from "../providers/MetadataProvider.js";
 export function TupleToolLabel({ tool }) {
     const metadata = useMetadata();
-    if (!metadata) {
-        return null;
-    }
-    return (_jsx(OverlayTrigger, { overlay: _jsx(Tooltip, { children: metadata.tupleTools.tupleTools[tool.class].description }), children: _jsx("span", { children: tool.toString() }) }));
+    return (_jsx(OverlayTrigger, { overlay: _jsx(Tooltip, { children: metadata.tupleTools.tupleTools[tool.class].description }), children: _jsxs("div", { className: "d-flex flex-column gap-1", children: [_jsx("code", { style: { textOverflow: "ellipsis", overflow: "hidden", whiteSpace: "nowrap" }, children: tool.class }), _jsx("p", { className: "m-0 text-muted", style: { textOverflow: "ellipsis", overflow: "hidden", whiteSpace: "nowrap" }, children: tool.name })] }) }));
 }

package/dist/components/TupleToolsAccordion.d.ts

@@ -0,0 +1 @@
+export declare function TupleToolsAccordion(): import("react/jsx-runtime").JSX.Element;

package/dist/components/TupleToolsAccordion.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Accordion, Button, ButtonGroup, ListGroup, OverlayTrigger, Tooltip } from "react-bootstrap";
+import { PencilSquare, Tools } from "react-bootstrap-icons";
+import { ConfigureTupleToolModal } from "./modals/ConfigureTupleToolModal";
+import { useState } from "react";
+import { useDtt } from "../providers/DttProvider";
+import { TupleToolLabel } from "./TupleToolLabel";
+import { DeleteButton } from "./DeleteButton";
+import { AddTupleToolButton } from "./AddTupleToolButton";
+import { GuideLinkButton } from "./GuideLinkButton";
+export function TupleToolsAccordion() {
+    const [showConfigModal, setShowConfigModal] = useState(null);
+    const { dtt, removeTool, selectedBranch } = useDtt();
+    const tools = dtt.listTools(selectedBranch);
+    return (_jsxs(_Fragment, { children: [showConfigModal && (_jsx(ConfigureTupleToolModal, { tool: showConfigModal.tool, deleteIfCancelled: false, onClose: () => setShowConfigModal(null) })), _jsxs(Accordion.Item, { eventKey: "0", children: [_jsx(Accordion.Header, { children: _jsxs("div", { className: "d-flex align-items-center gap-2", children: [_jsx(Tools, {}), tools.length, " TupleTool", tools.length === 1 ? "" : "s", selectedBranch.length === 0 ? " (global)" : selectedBranch.length > 1 ? " (group)" : "", _jsx(GuideLinkButton, { page: "tupleTools", topic: "TupleTools" })] }) }), _jsxs(Accordion.Body, { style: { padding: 4 }, children: [tools.length === 0 ? (_jsxs("div", { className: "text-muted pt-3 pb-2", style: { paddingLeft: "1rem", paddingRight: "1rem" }, children: ["No TupleTools have been added", " ", selectedBranch.length === 0
+                                        ? "to the decay"
+                                        : selectedBranch.length === 1
+                                            ? "to this particle"
+                                            : "to this group", " ", "yet."] })) : (_jsx(ListGroup, { variant: "flush", children: tools.map((tool) => {
+                                    return (_jsxs(ListGroup.Item, { className: "d-flex justify-content-between align-items-start", children: [_jsx("div", { style: { width: 240 }, children: _jsx(TupleToolLabel, { tool: tool }) }), _jsxs(ButtonGroup, { size: "sm", children: [_jsx(OverlayTrigger, { overlay: _jsx(Tooltip, { children: "Configure TupleTool" }), children: _jsx(Button, { variant: "outline-secondary", onClick: () => setShowConfigModal({ tool }), children: _jsx(PencilSquare, {}) }) }), _jsx(DeleteButton, { outline: true, action: () => removeTool(selectedBranch, tool), popupMessage: "Remove?", placement: "right" })] })] }, tool.toString()));
+                                }) })), _jsx("div", { className: "pb-2", style: { paddingLeft: "1rem", paddingRight: "1rem" }, children: _jsx(AddTupleToolButton, {}) })] })] })] }));
+}

package/dist/components/modals/AddTupleToolModal.js

@@ -1,10 +1,11 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Button, ButtonGroup, FormControl, InputGroup, Modal } from "react-bootstrap";
+import { Button, ButtonGroup, FormControl, Modal } from "react-bootstrap";
 import { TupleToolClassDropdown } from "../TupleToolClassDropdown";
 import { TupleToolDocsAccordion } from "../TupleToolDocsAccordion";
 import { useDtt } from "../../providers/DttProvider";
 import { TupleTool } from "../../models/tupleTool";
 import { useEffect, useRef, useState } from "react";
+import { ParticleLatex } from "../ParticleLatex";
 export function AddTupleToolModal({ onClose }) {
     const { dtt, addTool, selectedBranch } = useDtt();
     const nameInputRef = useRef(null);
@@ -12,7 +13,7 @@ export function AddTupleToolModal({ onClose }) {
     useEffect(() => {
         nameInputRef.current?.focus();
     }, [selectedTool]);
-    return (_jsxs(Modal, { show: true, onHide: () => onClose(null), children: [_jsx(Modal.Header, { closeButton: true, children: "Add TupleTool" }), _jsxs(Modal.Body, { className: "gap-3 d-flex flex-column", children: [_jsxs(InputGroup, { hasValidation: true, children: [_jsx(TupleToolClassDropdown, { onChange: (option) => {
+    return (_jsxs(Modal, { show: true, onHide: () => onClose(null), size: "lg", children: [_jsx(Modal.Header, { closeButton: true, children: _jsx(Modal.Title, { children: "Add TupleTool" }) }), _jsxs(Modal.Body, { className: "gap-3 d-flex flex-column", children: [selectedBranch.length > 0 && (_jsxs("div", { className: "d-flex flex-row gap-2", children: [_jsx("h6", { className: "my-auto", children: "Target:" }), selectedBranch.map((pid, i) => (_jsx(ParticleLatex, { particleId: pid }, i)))] })), _jsxs("div", { className: "d-flex flex-row gap-2", children: [_jsx(TupleToolClassDropdown, { onChange: (option) => {
                                     if (option) {
                                         setSelectedTool((prev) => new TupleTool(option.value, prev?.name || ""));
                                     }

package/dist/components/modals/ConfigureTupleToolModal.js

@@ -13,7 +13,7 @@ import { toast } from "react-toastify";
 export function ConfigureTupleToolModal({ tool, deleteIfCancelled, onClose }) {
     const { dtt, updateToolParam, removeTool, selectedBranch } = useDtt();
     const toolConfig = dtt.getToolConfig(selectedBranch, tool);
-    return (_jsxs(Modal, { show: true, size: "xl", fullscreen: "lg-down", backdrop: "static", keyboard: false, children: [_jsxs(Modal.Header, { children: ["Configure ", tool.toString()] }), _jsxs(Modal.Body, { className: "gap-3 d-flex flex-column", children: [_jsx(Form, { children: Object.entries(toolConfig).map(([paramName, param]) => {
+    return (_jsxs(Modal, { show: true, size: "xl", fullscreen: "lg-down", backdrop: "static", keyboard: false, children: [_jsx(Modal.Header, { children: _jsxs(Modal.Title, { style: { textOverflow: "ellipsis", overflow: "hidden", whiteSpace: "nowrap" }, children: ["Configure ", tool.toString()] }) }), _jsxs(Modal.Body, { className: "gap-3 d-flex flex-column", children: [_jsx(Form, { children: Object.entries(toolConfig).map(([paramName, param]) => {
                             const { description, type, default: defaultValue, value } = param;
                             let inputComponent;
                             switch (type) {

package/dist/components/modals/UploadDttConfigModal.d.ts

@@ -3,5 +3,5 @@ interface Props {
     onClose: () => void;
     currentRow?: RowData;
 }
-export declare function UploadDttConfigModal({ onClose, currentRow }: Props): import("react/jsx-runtime").JSX.Element | null;
+export declare function UploadDttConfigModal({ onClose, currentRow }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/modals/UploadDttConfigModal.js

@@ -28,7 +28,7 @@ export function UploadDttConfigModal({ onClose, currentRow }) {
             if (importedConfig.descriptorTemplate === currentRow.decay.descriptors.template) {
                 updateRow(currentRow.id, (r) => ({
                     ...r,
-                    dtt: importedRow.dtt.withInputsFromLines(currentRow.lines),
+                    dtt: currentRow.line ? importedRow.dtt.withInputFromLine(currentRow.line) : importedRow.dtt,
                 }));
                 onClose();
             }
@@ -42,9 +42,6 @@ export function UploadDttConfigModal({ onClose, currentRow }) {
             onClose();
         }
     }
-    if (!metadata) {
-        return null;
-    }
     return (_jsxs(Modal, { show: true, animation: false, children: [_jsx(Modal.Header, { children: _jsx(Modal.Title, { children: " Upload configuration file " }) }), _jsxs(Modal.Body, { children: [_jsx(Form.Group, { controlId: "formFile2", className: "mb-3", children: _jsx(Form.Control, { type: "file", multiple: !currentRow, accept: ".yaml", onChange: (event) => {
                                 const files = event.target.files;
                                 if (files) {

package/dist/config.d.ts

@@ -39,6 +39,7 @@ export declare const config: {
             width: number;
         };
     };
+    disabledTupleTools: string[];
     tupleToolValidation: TupleToolValidation;
 };
 interface TupleToolValidation {

package/dist/config.js

@@ -22,8 +22,8 @@ export const config = {
     },
     dttGraphOptions: {
         height: "500px",
-        zoomMin: 0.2,
-        zoomMax: 3.0,
+        zoomMin: 0.5, // multiplier
+        zoomMax: 2.0, // multiplier
         zoomStep: 0.018,
         layout: {
             rankDir: "TB", // top -> bottom
@@ -42,6 +42,7 @@ export const config = {
             width: 1,
         },
     },
+    disabledTupleTools: ["LoKi__Hybrid__ArrayTupleTool"],
     tupleToolValidation: {
         ["LoKi__Hybrid__TupleTool"]: {
             validate: (config) => {

package/dist/models/bkPath.js

@@ -8,7 +8,7 @@ export class BkPath {
     fileName;
     constructor(path) {
         if (!BkPath.isValid(path)) {
-            throw new Error(`Invalid bookkeeping path: ${path}`);
+            throw new Error(`Invalid dataset: ${path}`);
         }
         const parts = path.split("/");
         const [, type, year] = parts;

package/dist/models/dtt.d.ts

@@ -81,7 +81,7 @@ export interface DttConfig {
         [particleId: string]: BranchConfig;
     };
     descriptorTemplate?: string;
-    inputs?: string[];
+    input?: string;
     groups: {
         [particleGroup: string]: GroupConfig;
     };
@@ -117,7 +117,7 @@ export default class Dtt {
     toSavedConfig(): SavedDttConfig;
     private static getBranchConfigs;
     static create(descriptorTemplate: string, branchItemsList: BranchMapItem[], inputs: string[], name: string, toolMetadata: ToolMetadata): Dtt;
-    withInputsFromLines(lines: StrippingLine[]): Dtt;
+    withInputFromLine(line: StrippingLine): Dtt;
     withName(name: string): Dtt;
     withConfig(config: DttConfig): Dtt;
     withAddedTool(tool: TupleTool, branch?: string[]): Dtt;
@@ -128,11 +128,14 @@ export default class Dtt {
     getToolsByBranch(branch?: string[]): {
         [toolString: string]: ToolConfig;
     };
+    getBranchTools(branch?: string[]): string[];
     private static getToolsByBranchFromConfig;
     getParticlesByBranchId(branchIds: string[]): string[];
     private static getDefaultToolConfig;
     getToolConfig(branch: string[], tool: TupleTool): ToolConfig;
     listTools(branch?: string[]): TupleTool[];
+    getGroupsWithTools(): string[];
+    getGroupsThatIncludeBranch(branch: string[]): string[];
     toolExists(tool: TupleTool, branch?: string[]): boolean;
 }
 export {};

package/dist/models/dtt.js

@@ -15,20 +15,28 @@ export default class Dtt {
         }));
     }
     static formatToolsForLoading(tools, toolMetadata) {
-        return Object.fromEntries(tools.map((toolConfig) => {
-            const toolName = Object.keys(toolConfig)[0];
-            const params = toolConfig[toolName];
+        return Object.fromEntries(tools
+            .map((toolConfig) => {
+            const toolClass = Object.keys(toolConfig)[0];
+            const params = toolConfig[toolClass];
+            const toolInterface = toolMetadata[toolClass]?.interface;
+            if (!toolInterface) {
+                return null;
+            }
             return [
-                toolName,
-                Object.fromEntries(Object.entries(params).map(([paramName, value]) => {
-                    const paramMetadata = toolMetadata[toolName].interface.find((param) => param.name === paramName);
+                toolClass,
+                Object.fromEntries(Object.entries(params)
+                    .map(([paramName, value]) => {
+                    const paramMetadata = toolInterface.find((param) => param.name === paramName);
                     if (!paramMetadata) {
-                        throw new Error(`No metadata for param ${paramName} of tool ${toolName}`);
+                        return null;
                     }
                     return [paramName, { value, ...paramMetadata }];
-                })),
+                })
+                    .filter(Boolean)),
             ];
-        }));
+        })
+            .filter(Boolean));
     }
     static fromSavedConfig(savedConfig, toolMetadata) {
         const config = {
@@ -95,7 +103,7 @@ export default class Dtt {
             "TupleToolEventInfo",
         ];
         return new Dtt({
-            inputs,
+            input: inputs.length > 0 ? inputs[0] : undefined,
             descriptorTemplate,
             tools: Object.fromEntries(defaultTools.map((tool) => [tool, Dtt.getDefaultToolConfig(toolMetadata, tool)])),
             branches: Dtt.getBranchConfigs(branchItemsList),
@@ -103,12 +111,10 @@ export default class Dtt {
             name,
         }, toolMetadata);
     }
-    withInputsFromLines(lines) {
-        const inputs = lines.map(({ stream, line }) => {
-            const lineLocation = String(line).replace("Stripping", "");
-            return `/Event/${stream}/Phys/${lineLocation}/Particles`;
-        });
-        return new Dtt({ ...this.config, inputs }, this.metadata);
+    withInputFromLine(line) {
+        const lineLocation = String(line.line).replace("Stripping", "");
+        const input = `/Event/${line.stream}/Phys/${lineLocation}/Particles`;
+        return new Dtt({ ...this.config, input }, this.metadata);
     }
     // Set the class+name combination
     withName(name) {
@@ -144,7 +150,10 @@ export default class Dtt {
         if (!this.config.name) {
             return "";
         }
-        return this.config.name.split("/")[1];
+        if (this.config.name.includes("/")) {
+            return this.config.name.split("/")[1];
+        }
+        return this.config.name;
     }
     // Delete all groups with an empty tool list
     pruneGroups() {
@@ -154,11 +163,13 @@ export default class Dtt {
             }
         }
     }
-    // Find the appropriate object which has a "tools" list
     getToolsByBranch(branch) {
         this.pruneGroups();
         return Dtt.getToolsByBranchFromConfig(this.config, branch);
     }
+    getBranchTools(branch) {
+        return Object.keys(Dtt.getToolsByBranchFromConfig(this.config, branch));
+    }
     static getToolsByBranchFromConfig(config, branch) {
         if (!branch || branch?.length === 0) {
             return config.tools;
@@ -205,6 +216,14 @@ export default class Dtt {
     listTools(branch) {
         return Object.keys(this.getToolsByBranch(branch)).map((toolString) => TupleTool.fromString(toolString));
     }
+    getGroupsWithTools() {
+        return Object.entries(this.config.groups)
+            .filter(([, groupConfig]) => Object.keys(groupConfig.tools).length > 0)
+            .map(([key]) => key);
+    }
+    getGroupsThatIncludeBranch(branch) {
+        return this.getGroupsWithTools().filter((group) => branch.every((particle) => group.split(",").includes(particle)));
+    }
     toolExists(tool, branch) {
         return tool.toString() in this.getToolsByBranch(branch);
     }

package/dist/models/rowData.d.ts

@@ -6,7 +6,7 @@ export interface RowData {
     decay: DecayData;
     dtt: Dtt | null;
     editTree?: boolean;
-    lines: StrippingLine[];
+    line: StrippingLine | null;
     paths: string[];
     pathOptions: string[];
 }

package/dist/models/yamlFile.js

@@ -33,7 +33,7 @@ export class YamlFile {
                         options: [dttFile],
                     };
                     if (path.includes("MDST")) {
-                        const stream = row.lines[0]?.stream;
+                        const stream = row.line?.stream;
                         if (stream)
                             job.root_in_tes = `/Event/${stream}`;
                     }

package/dist/pages/DecaySearchPage.js

@@ -21,6 +21,7 @@ import { getSelectTagOptions, TagDropdown } from "../components/TagDropdown";
 import { useRows } from "../providers/RowsProvider";
 import { LoadingIndicator } from "../components/LoadingIndicator";
 import { useWizardConfig } from "../providers/WizardConfigProvider";
+import { GuideLinkButton } from "../components/GuideLinkButton";
 var MatchType;
 (function (MatchType) {
     MatchType["any"] = "any";
@@ -57,15 +58,9 @@ export function DecaySearchPage() {
         });
     }, []);
     useEffect(() => {
-        if (!metadata) {
-            return;
-        }
         // Set default value for selectedTags when metadata is loaded
         setSelectedTags(getSelectTagOptions(metadata.userHints.decayTags, (tag) => tag.hide));
     }, [metadata]);
-    if (!metadata) {
-        return _jsx(LoadingIndicator, { height: "70vh" });
-    }
     const sendData = () => {
         const selectedDecaySet = new Set(selectedDecays.map((d) => d.descriptors.plain));
         // Keep only rows whose decay is still selected
@@ -88,7 +83,7 @@ export function DecaySearchPage() {
                     id: getNextId(),
                     decay,
                     dtt: null,
-                    lines: [],
+                    line: null,
                     paths: [],
                     pathOptions: [],
                 });
@@ -191,9 +186,9 @@ export function DecaySearchPage() {
     const getExtraInputs = () => {
         return (_jsx(_Fragment, { children: _jsxs(InputGroup, { size: "sm", children: [_jsx(DropdownButton, { title: "Tags (" + tagMatchType + " of):", variant: "outline-secondary", children: _jsx(DropdownMatchTypes, { options: Object.values(MatchType), stateItem: tagMatchType, stateSetter: setTagMatchType }) }), _jsx(TagDropdown, { type: "decayTags", placeholder: "DecayLatex tags", value: selectedTags, onChange: (values) => setSelectedTags([...values]), closeMenuOnSelect: false }), _jsx("div", { className: "react-select form-control p-0", children: _jsx(Select, { placeholder: "Stripping line", isClearable: true, options: metadata
                                 ? allStrippingLines().map((line) => ({ value: line, label: line }))
-                                : [], onChange: setSelectedLine, isLoading: !metadata }) })] }) }));
+                                : [], onChange: setSelectedLine }) })] }) }));
     };
-    return (_jsxs(_Fragment, { children: [_jsx("h3", { children: "Decay search" }), _jsxs(InputGroup, { size: "sm", children: [_jsxs(DropdownButton, { title: "Head (" +
+    return (_jsxs(_Fragment, { children: [_jsxs("h3", { className: "d-flex align-items-center gap-2", children: ["Decay search", _jsx(GuideLinkButton, { page: "selectingDecays", topic: "Selecting decays" })] }), _jsxs(InputGroup, { size: "sm", children: [_jsxs(DropdownButton, { title: "Head (" +
                             (headMatchType === HeadMatchType.exactly ? headMatchType : headTagMatchType + " of") +
                             "):", variant: "outline-secondary", children: [_jsx(DropdownMatchTypes, { options: Object.values(HeadMatchType), stateItem: headMatchType, stateSetter: setHeadMatchType }), _jsx(Dropdown.Divider, {}), headMatchType === HeadMatchType.exactly ? (_jsx(DropdownChargeConjugate, { stateItem: chargeConjugateHeads, stateSetter: setChargeConjugateHeads })) : (_jsx(DropdownMatchTypes, { options: Object.values(MatchType), stateItem: headTagMatchType, stateSetter: setHeadTagMatchType }))] }), headMatchType === HeadMatchType.exactly ? (_jsx(ParticleDropdown, { isClearable: true, onlyHeads: true, placeholder: "DecayLatex head", onChange: (value) => setSelectedHead(value) })) : (_jsx(TagDropdown, { type: "particleTags", placeholder: "DecayLatex head", filter: (tag) => !tag.hide, onChange: (values) => setSelectedHeadTags([...values]) })), _jsxs(DropdownButton, { title: "Contains (" + containsMatchType + " of):", variant: "outline-secondary", children: [_jsx(DropdownMatchTypes, { options: Object.values(MatchType), stateItem: containsMatchType, stateSetter: setContainsMatchType }), _jsx(Dropdown.Divider, {}), _jsx(DropdownChargeConjugate, { stateItem: chargeConjugateContains, stateSetter: setChargeConjugateContains })] }), _jsx(ParticleDropdown, { isMulti: true, onlyKnown: true, placeholder: "Particles in decay...", onChange: (values) => setSelectedContains(values), closeMenuOnSelect: false }), _jsx(InputGroup.Text, { children: "Show only selected:" }), _jsx(InputGroup.Checkbox, { onChange: () => setOnlySelected(!onlySelected) })] }), getExtraInputs(), getDecayList(), _jsx(Link, { to: basePath, children: _jsx(OverlayTrigger, { overlay: _jsx(Tooltip, { children: "Return to production configuration" }), children: _jsxs(Button, { variant: "success", type: "submit", onClick: sendData, children: ["Select ", _jsx(Badge, { pill: true, bg: "secondary", children: selectedDecays.length })] }) }) })] }));
 }

package/dist/pages/DecayTreeConfigPage.js

@@ -14,50 +14,16 @@ import { useNavigate } from "react-router-dom";
 import { useMetadata } from "../providers/MetadataProvider";
 import { DecayTreeCard } from "../components/DecayTreeCard";
 import { useRows } from "../providers/RowsProvider";
-import Dtt from "../models/dtt";
 import { DttProvider } from "../providers/DttProvider";
-import { LoadingIndicator } from "../components/LoadingIndicator";
-import { useEffect, useState } from "react";
 import { useWizardConfig } from "../providers/WizardConfigProvider";
+import { RowProvider } from "../providers/RowProvider";
 export function DecayTreeConfigPage() {
     const navigate = useNavigate();
     const metadata = useMetadata();
-    const { rows, updateRow } = useRows();
+    const { rows } = useRows();
     const { basePath } = useWizardConfig();
-    const [dirtyDtts, setDirtyDtts] = useState(new Set());
-    // Listen for when the user is about to leave the page and alert them if there are unsaved changes
-    useEffect(() => {
-        const handleBeforeUnload = (event) => {
-            if (dirtyDtts.size > 0) {
-                event.preventDefault();
-            }
-        };
-        window.addEventListener("beforeunload", handleBeforeUnload);
-        return () => {
-            window.removeEventListener("beforeunload", handleBeforeUnload);
-        };
-    }, [dirtyDtts]);
-    if (!metadata) {
-        return _jsx(LoadingIndicator, { height: "70vh" });
-    }
     const rowsToEdit = rows.filter((row) => !!row.editTree);
-    return (_jsxs(_Fragment, { children: [_jsx("h3", { className: "mb-4", children: "DecayTreeTuple configuration" }), _jsx(Stack, { gap: 5, children: rowsToEdit.map((row) => (_jsx(DttProvider, { metadata: metadata, decay: row.decay, initialConfig: row.dtt.config, children: _jsx(DecayTreeCard, { onConfigSaved: (newConfig) => {
-                            updateRow(row.id, (r) => ({ ...r, dtt: new Dtt(newConfig, {}) }));
-                        }, onDirtyUpdated: (dttName, dirty) => setDirtyDtts((prev) => {
-                            if (dirty) {
-                                return new Set(prev.add(dttName));
-                            }
-                            else {
-                                const newSet = new Set(prev);
-                                newSet.delete(dttName);
-                                return newSet;
-                            }
-                        }) }) }, row.id))) }), _jsx(OverlayTrigger, { placement: "right", overlay: _jsx(Tooltip, { children: "Return to Stripping line and dataset selection" }), children: _jsx(Button, { className: "mt-2 mb-4", type: "submit", onClick: () => {
-                        if (dirtyDtts.size > 0) {
-                            if (!confirm("You have unsaved changes. Are you sure you want to discard them?")) {
-                                return;
-                            }
-                        }
+    return (_jsxs(_Fragment, { children: [_jsx("h3", { className: "mb-4", children: "DecayTreeTuple configuration" }), _jsx(Stack, { gap: 5, children: rowsToEdit.map((row) => (_jsx(RowProvider, { row: row, children: _jsx(DttProvider, { metadata: metadata, decay: row.decay, initialConfig: row.dtt.config, children: _jsx(DecayTreeCard, {}) }, row.id) }, row.id))) }), _jsx(OverlayTrigger, { placement: "right", overlay: _jsx(Tooltip, { children: "Return to Stripping line and dataset selection" }), children: _jsx(Button, { className: "mt-2 mb-4", type: "submit", onClick: () => {
                         void navigate(basePath);
-                    }, variant: dirtyDtts.size > 0 ? "outline-danger" : "primary", children: dirtyDtts.size > 0 ? "Discard changes" : "Return" }) })] }));
+                    }, children: "Return" }) })] }));
 }

package/dist/pages/RequestPage.js

@@ -26,6 +26,7 @@ import { RowProvider } from "../providers/RowProvider";
 import { ProductionNameInput } from "../components/ProductionNameInput";
 import { RequestEmailInput } from "../components/RequestEmailInput";
 import { RequestButtonGroup } from "../components/RequestButtonGroup";
+import { GuideLinkButton } from "../components/GuideLinkButton";
 import { useWizardConfig } from "../providers/WizardConfigProvider";
 export function RequestPage() {
     const metadata = useMetadata();
@@ -38,9 +39,6 @@ export function RequestPage() {
     const [showReasonForRequestModal, setShowReasonForRequestModal] = useState(false);
     const [checkedIfCloneNeeded, setCheckedIfCloneNeeded] = useState(false);
     useEffect(() => {
-        if (!metadata) {
-            return;
-        }
         // If the localStorage has been set, we should clone the configuration
         const infoYamlString = localStorage.getItem("infoYamlToClone");
         const dttConfigsString = localStorage.getItem("dttConfigsToClone");
@@ -96,5 +94,5 @@ export function RequestPage() {
                             !validation.allRowsHaveStrippingLine ||
                             !validation.allRowsHavePaths) && (_jsx(Alert, { variant: "danger", className: "mb-0", children: rows.length === 0
                             ? "Please select at least one decay"
-                            : "Please name all DecayTreeTuples and select at least one stripping line and bookkeeping path for each decay" })), _jsx(Row, { children: _jsx(Col, { xs: "auto", children: _jsx(RequestButtonGroup, {}) }) }), _jsx(Row, { children: _jsxs(Col, { xs: "auto", children: [_jsx(ProductionNameInput, {}), !emailIsKnown && _jsx(RequestEmailInput, {}), _jsxs(Stack, { direction: "horizontal", gap: 1, className: "mt-3 mb-3", children: [_jsxs(Button, { className: "align-items-center d-flex gap-1", onClick: () => void handlePrimaryAction(), children: [variant === "standalone" ? _jsx(Download, {}) : _jsx(Send, {}), variant === "standalone" ? "Download" : "Submit"] }), _jsx(DeleteButton, { action: clearAll, disabled: validation.isEmptySession, outline: undefined, children: "Clear all" })] })] }) })] })] }));
+                            : "Please name all DecayTreeTuples and select at least one stripping line and dataset for each decay" })), _jsx(Row, { children: _jsx(Col, { xs: "auto", children: _jsx(RequestButtonGroup, {}) }) }), _jsx(Row, { children: _jsxs(Col, { xs: "auto", children: [_jsxs("div", { className: "d-flex align-items-center flex-row gap-2", children: [_jsxs("div", { children: [_jsx(ProductionNameInput, {}), !emailIsKnown && _jsx(RequestEmailInput, {})] }), rows.length > 0 && (_jsx(GuideLinkButton, { page: "submittingRequests", topic: "Submitting requests" }))] }), _jsxs(Stack, { direction: "horizontal", gap: 2, className: "mt-3 mb-3", children: [_jsxs(Button, { className: "align-items-center d-flex gap-1", onClick: () => void handlePrimaryAction(), children: [variant === "standalone" ? _jsx(Download, {}) : _jsx(Send, {}), variant === "standalone" ? "Download" : "Submit"] }), _jsx(DeleteButton, { action: clearAll, disabled: validation.isEmptySession, outline: undefined, children: "Clear all" })] })] }) })] })] }));
 }

package/dist/providers/DttProvider.d.ts

@@ -9,11 +9,11 @@ interface DttContextType {
     updateToolParam<K extends keyof ToolParamTypeMap>(this: void, branch: string[], tool: TupleTool, param: string, value: ToolParamTypeMap[K]): void;
     addTool(this: void, branch: string[], tool: TupleTool): void;
     removeTool(this: void, branch: string[], tool: TupleTool): void;
-    dirty: boolean;
-    save(this: void): void;
-    revert(this: void): void;
     selectedBranch: string[];
     setSelectedBranch: (branch: string[]) => void;
+    hoveredBranch: string[];
+    setHoveredBranch: (branch: string[]) => void;
+    highlightedBranch: string[];
 }
 interface DttProviderProps {
     initialConfig: DttConfig;

package/dist/providers/DttProvider.js

@@ -1,74 +1,49 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useCallback, useContext, useReducer, useState } from "react";
+import { createContext, useCallback, useContext, useState } from "react";
 import Dtt from "../models/dtt";
+import { useRows } from "./RowsProvider";
+import { useRow } from "./RowProvider";
 const DttContext = createContext(null);
-function reducer(state, action) {
-    switch (action.type) {
-        case "INIT":
-            return {
-                dtt: action.dtt,
-                lastSaved: structuredClone(action.config),
-                dirty: false,
-            };
-        case "UPDATE":
-            return {
-                ...state,
-                dtt: action.dtt,
-                dirty: true,
-            };
-        case "SAVE":
-            return {
-                ...state,
-                lastSaved: structuredClone(state.dtt.config),
-                dirty: false,
-            };
-        case "REVERT":
-            return {
-                ...state,
-                dtt: state.dtt.withConfig(state.lastSaved),
-                dirty: false,
-            };
-    }
-}
 export function DttProvider({ initialConfig, decay, metadata, children }) {
+    const { row } = useRow();
+    const { updateRow } = useRows();
     const [selectedBranch, setSelectedBranch] = useState([]);
-    const [state, dispatch] = useReducer(reducer, null, () => ({
-        dtt: new Dtt(structuredClone(initialConfig), metadata.tupleTools.tupleTools),
-        decay,
-        lastSaved: structuredClone(initialConfig),
-        dirty: false,
-    }));
+    const [hoveredBranch, setHoveredBranch] = useState([]);
+    const [dtt, setDtt] = useState(() => new Dtt(structuredClone(initialConfig), metadata.tupleTools.tupleTools));
+    const save = useCallback((next) => {
+        updateRow(row.id, (r) => ({
+            ...r,
+            dtt: new Dtt(structuredClone(next.config), {}),
+        }));
+    }, [row.id, updateRow]);
     const updateToolParam = useCallback((branch, tool, param, value) => {
-        const next = state.dtt.withUpdatedToolParam(branch, tool, param, value);
-        if (next === state.dtt)
+        const next = dtt.withUpdatedToolParam(branch, tool, param, value);
+        if (next === dtt)
             return;
-        dispatch({ type: "UPDATE", dtt: next });
-    }, [state.dtt]);
+        setDtt(next);
+        save(next);
+    }, [dtt, save]);
     const addTool = useCallback((branch, tool) => {
-        dispatch({
-            type: "UPDATE",
-            dtt: state.dtt.withAddedTool(tool, branch),
-        });
-    }, [state.dtt]);
+        const next = dtt.withAddedTool(tool, branch);
+        setDtt(next);
+        save(next);
+    }, [dtt, save]);
     const removeTool = useCallback((branch, tool) => {
-        dispatch({
-            type: "UPDATE",
-            dtt: state.dtt.withRemovedTool(tool, branch),
-        });
-    }, [state.dtt]);
-    const save = useCallback(() => dispatch({ type: "SAVE" }), []);
-    const revert = useCallback(() => dispatch({ type: "REVERT" }), []);
+        const next = dtt.withRemovedTool(tool, branch);
+        setDtt(next);
+        save(next);
+    }, [dtt, save]);
     const value = {
-        dtt: state.dtt,
+        dtt,
         decay,
-        dirty: state.dirty,
         updateToolParam,
         addTool,
         removeTool,
-        save,
-        revert,
         selectedBranch,
         setSelectedBranch,
+        hoveredBranch,
+        setHoveredBranch,
+        highlightedBranch: hoveredBranch.length > 0 ? hoveredBranch : selectedBranch,
     };
     return _jsx(DttContext.Provider, { value: value, children: children });
 }

package/dist/providers/MetadataProvider.d.ts

@@ -83,5 +83,5 @@ interface Props {
     children: ReactNode;
 }
 export declare function MetadataProvider({ children }: Props): import("react/jsx-runtime").JSX.Element;
-export declare const useMetadata: () => MetadataContext | null;
+export declare const useMetadata: () => MetadataContext;
 export {};