lhcb-ntuple-wizard-test 2.0.0 → 2.0.2

package/dist/models/yamlFile.js

@@ -0,0 +1,78 @@
+import yaml from "js-yaml";
+import { sanitizeFilename } from "../utils/utils";
+export class YamlFile {
+    name;
+    content;
+    constructor(name, content) {
+        this.name = sanitizeFilename(name);
+        this.content = content;
+    }
+    static fromDtt(dtt) {
+        const yamlContent = {
+            ...dtt.config,
+            tools: YamlFile.reformatTools(dtt.config.tools),
+            branches: Object.fromEntries(Object.entries(dtt.config.branches).map(([branchId, branchConfig]) => [
+                branchId,
+                {
+                    ...branchConfig,
+                    tools: YamlFile.reformatTools(branchConfig.tools),
+                },
+            ])),
+            groups: Object.fromEntries(Object.entries(dtt.config.groups).map(([groupId, groupConfig]) => [
+                groupId,
+                {
+                    ...groupConfig,
+                    tools: YamlFile.reformatTools(groupConfig.tools),
+                },
+            ])),
+        };
+        return new YamlFile(`${dtt.getName()}.yaml`, yaml.dump(yamlContent));
+    }
+    static reformatTools(tools) {
+        return Object.entries(tools).map(([toolName, toolConfig]) => ({
+            [toolName]: Object.fromEntries(Object.entries(toolConfig).map(([paramName, param]) => [paramName, param.value])),
+        }));
+    }
+    static createInfoYaml(rows, metadata) {
+        const uniquePathSet = new Set(rows.flatMap((row) => row.paths));
+        const uniquePaths = [...uniquePathSet].sort();
+        const pathIndex = new Map(uniquePaths.map((p, i) => [p, i]));
+        const info = {
+            defaults: {
+                application: `DaVinci/${metadata.tupleTools.applicationInfo.DaVinci}`,
+                wg: "OpenData",
+                inform: [],
+                automatically_configure: true,
+                output: "DVNtuple.root",
+            },
+        };
+        for (const row of rows) {
+            if (!row.dtt)
+                continue;
+            for (const path of row.paths) {
+                const jobID = pathIndex.get(path);
+                if (jobID === undefined)
+                    continue;
+                const key = `job${jobID}`;
+                const dttFile = row.dtt.getName();
+                if (key in info) {
+                    info[key].options.push(dttFile);
+                }
+                else {
+                    const job = {
+                        input: { bk_query: path },
+                        options: [dttFile],
+                    };
+                    if (path.includes("MDST")) {
+                        const stream = row.lines[0]?.stream;
+                        if (stream) {
+                            job.root_in_tes = `/Event/${stream}`;
+                        }
+                    }
+                    info[key] = job;
+                }
+            }
+        }
+        return new YamlFile("info.yaml", yaml.dump(info));
+    }
+}

package/dist/pages/DecaySearchPage.d.ts

@@ -0,0 +1,5 @@
+interface Props {
+    basePath: string;
+}
+export declare function DecaySearchPage({ basePath }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/pages/DecaySearchPage.js

@@ -0,0 +1,197 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/*****************************************************************************\
+ * (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration           *
+ *                                                                             *
+ * This software is distributed under the terms of the GNU General Public      *
+ * Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING".   *
+ *                                                                             *
+ * In applying this licence, CERN does not waive the privileges and immunities *
+ * granted to it by virtue of its status as an Intergovernmental Organization  *
+ * or submit itself to any jurisdiction.                                       *
+ \*****************************************************************************/
+import memoize from "lodash.memoize";
+import { useEffect, useState, useTransition } from "react";
+import { Alert, Badge, Button, Dropdown, DropdownButton, InputGroup, OverlayTrigger, Spinner, Tooltip, } from "react-bootstrap";
+import { Link } from "react-router-dom";
+import Select from "react-select";
+import { useMetadata } from "../providers/MetadataProvider";
+import { DecayList } from "../components/DecayList";
+import { ParticleDropdown } from "../components/ParticleDropdown";
+import { getSelectTagOptions, TagDropdown } from "../components/TagDropdown";
+import { useRows } from "../providers/RowsProvider";
+import { LoadingIndicator } from "../components/LoadingIndicator";
+var MatchType;
+(function (MatchType) {
+    MatchType["any"] = "any";
+    MatchType["all"] = "all";
+    MatchType["none"] = "none";
+})(MatchType || (MatchType = {}));
+var HeadMatchType;
+(function (HeadMatchType) {
+    HeadMatchType["exactly"] = "exactly";
+    HeadMatchType["category"] = "category";
+})(HeadMatchType || (HeadMatchType = {}));
+export function DecaySearchPage({ basePath }) {
+    const metadata = useMetadata();
+    const { rows, setRows } = useRows();
+    const [selectedContains, setSelectedContains] = useState([]);
+    const [selectedHead, setSelectedHead] = useState(null);
+    const [selectedHeadTags, setSelectedHeadTags] = useState([]);
+    const [selectedDecays, setSelectedDecays] = useState(rows.map((row) => row.decay));
+    const [selectedTags, setSelectedTags] = useState(null);
+    const [selectedLine, setSelectedLine] = useState(null);
+    const [chargeConjugateContains, setChargeConjugateContains] = useState(true);
+    const [chargeConjugateHeads, setChargeConjugateHeads] = useState(true);
+    const [containsMatchType, setContainsMatchType] = useState(MatchType.all);
+    const [headMatchType, setHeadMatchType] = useState(HeadMatchType.exactly);
+    const [tagMatchType, setTagMatchType] = useState(MatchType.none);
+    const [headTagMatchType, setHeadTagMatchType] = useState(MatchType.all);
+    const [onlySelected, setOnlySelected] = useState(false);
+    const [showDecaysList, setShowDecaysList] = useState(false);
+    const [isLoadingDecaysList, startTransition] = useTransition();
+    useEffect(() => {
+        startTransition(() => {
+            setShowDecaysList(true);
+        });
+    }, []);
+    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
+        const selectedRows = rows.filter((row) => selectedDecaySet.has(row.decay.descriptors.plain));
+        const existingDecaySet = new Set(selectedRows.map((row) => row.decay.descriptors.plain));
+        // Track used row IDs
+        const usedIds = new Set(selectedRows.map((row) => row.id));
+        let nextId = 0;
+        const getNextId = () => {
+            while (usedIds.has(nextId))
+                nextId++;
+            usedIds.add(nextId);
+            return nextId;
+        };
+        // Add missing decays
+        for (const decay of selectedDecays) {
+            const key = decay.descriptors.plain;
+            if (!existingDecaySet.has(key)) {
+                selectedRows.push({
+                    id: getNextId(),
+                    decay,
+                    dtt: null,
+                    lines: [],
+                    paths: [],
+                    pathOptions: [],
+                });
+            }
+        }
+        setRows(selectedRows);
+    };
+    const variableMatch = (type, conditions) => {
+        switch (type) {
+            case MatchType.all:
+                return conditions.every((x) => x);
+            case MatchType.any:
+                return conditions.some((x) => x);
+            case MatchType.none:
+                return !conditions.some((x) => x);
+        }
+    };
+    const allStrippingLines = memoize(() => {
+        const allLines = Object.values(metadata.stripping).flatMap((stream) => Object.keys(stream));
+        const uniqueLines = new Set(allLines);
+        return [...uniqueLines];
+    });
+    const filterDecays = () => {
+        // TODO: can probably do some refactoring in here (cf variableMatch)
+        let newDecays = Object.values(metadata.decays);
+        if (selectedContains) {
+            newDecays = newDecays.filter((decay) => {
+                const conditions = selectedContains.map((option) => {
+                    const particle = option.value;
+                    const antiparticle = metadata.particleProperties[particle]["antiparticle"];
+                    return (decay.descriptors.plain.includes(particle) ||
+                        (chargeConjugateContains && decay.descriptors.plain.includes(antiparticle)));
+                });
+                return variableMatch(containsMatchType, conditions);
+            });
+        }
+        if (headMatchType === HeadMatchType.exactly) {
+            if (selectedHead) {
+                const particle = selectedHead.value;
+                const antiparticle = metadata.particleProperties[particle].antiparticle;
+                newDecays = newDecays.filter((decay) => {
+                    const head = decay.descriptors.list[0];
+                    return head === particle || (chargeConjugateHeads && head === antiparticle);
+                });
+            }
+        }
+        else if (headMatchType === HeadMatchType.category) {
+            if (selectedHeadTags) {
+                newDecays = newDecays.filter((decay) => {
+                    const conditions = selectedHeadTags.map((option) => {
+                        const tag = option.value;
+                        const head = metadata.particleProperties[decay.descriptors.list[0]];
+                        return head.tags.includes(tag);
+                    });
+                    return variableMatch(headTagMatchType, conditions);
+                });
+            }
+        }
+        if (onlySelected) {
+            newDecays = newDecays.filter((decay) => selectedDecays
+                .map((selectedDecay) => selectedDecay.descriptors.plain)
+                .includes(decay.descriptors.plain));
+        }
+        if (selectedTags) {
+            newDecays = newDecays.filter((decay) => {
+                const conditions = selectedTags.map((tag) => {
+                    return decay.tags.includes(tag.value);
+                });
+                return variableMatch(tagMatchType, conditions);
+            });
+        }
+        if (selectedLine) {
+            const line = selectedLine.value;
+            newDecays = newDecays.filter((decay) => {
+                const decayStreamLines = Object.keys(decay.lines);
+                const decayLines = new Set(decayStreamLines.map((streamLine) => streamLine.split("/")[1]));
+                return decayLines.has(line);
+            });
+        }
+        return newDecays;
+    };
+    function DropdownMatchTypes({ options, stateItem, stateSetter }) {
+        return (_jsx(_Fragment, { children: options.map((option) => (_jsx(Dropdown.Item, { active: stateItem === option, onClick: () => stateSetter(option), children: option }, option))) }));
+    }
+    function DropdownChargeConjugate({ stateItem, stateSetter }) {
+        return (_jsxs(_Fragment, { children: [_jsx(Dropdown.Item, { active: stateItem, onClick: () => stateSetter(true), children: "Include antiparticles" }), _jsx(Dropdown.Item, { active: !stateItem, onClick: () => stateSetter(false), children: "Exclude antiparticles" })] }));
+    }
+    const getDecayList = () => {
+        if (!selectedTags) {
+            return (_jsxs(Alert, { variant: "warning", children: [_jsx(Spinner, { size: "sm", animation: "border" }), " Loading decays..."] }));
+        }
+        if (!showDecaysList || isLoadingDecaysList) {
+            return _jsx(LoadingIndicator, { height: "40vh" });
+        }
+        const filteredDecays = selectedTags ? filterDecays() : [];
+        return (_jsx(DecayList, { decays: filteredDecays, selectedDecays: selectedDecays, onItemSelected: (newSelectedDecays) => {
+                setSelectedDecays([...newSelectedDecays]);
+            } }, JSON.stringify(filteredDecays)));
+    };
+    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 }) })] }) }));
+    };
+    return (_jsxs(_Fragment, { children: [_jsx("h3", { children: "DecayLatex search" }), _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.d.ts

@@ -0,0 +1,5 @@
+interface Props {
+    basePath: string;
+}
+export declare function DecayTreeConfigPage({ basePath }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/pages/DecayTreeConfigPage.js

@@ -0,0 +1,63 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/*****************************************************************************\
+ * (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration           *
+ *                                                                             *
+ * This software is distributed under the terms of the GNU General Public      *
+ * Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING".   *
+ *                                                                             *
+ * In applying this licence, CERN does not waive the privileges and immunities *
+ * granted to it by virtue of its status as an Intergovernmental Organization  *
+ * or submit itself to any jurisdiction.                                       *
+ \*****************************************************************************/
+import { Button, Col, OverlayTrigger, Row, Stack, Tooltip } from "react-bootstrap";
+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";
+export function DecayTreeConfigPage({ basePath }) {
+    const navigate = useNavigate();
+    const metadata = useMetadata();
+    const { rows, setRows } = useRows();
+    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", { children: "DecayTreeTuple configuration" }), _jsx(Stack, { gap: 5, children: rowsToEdit.map((row) => (_jsx(Row, { className: "justify-content-lg-center", children: _jsx(Col, { lg: "auto", children: _jsx(DttProvider, { metadata: metadata, decay: row.decay, initialConfig: row.dtt.config, children: _jsx(DecayTreeCard, { onConfigSaved: (newConfig) => {
+                                    setRows((prev) => {
+                                        return prev.map((r) => r.id === row.id ? { ...r, dtt: new Dtt(newConfig, {}) } : r);
+                                    });
+                                }, 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) }, 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;
+                            }
+                        }
+                        void navigate(basePath);
+                    }, variant: dirtyDtts.size > 0 ? "outline-danger" : "primary", children: dirtyDtts.size > 0 ? "Discard changes" : "Return" }) })] }));
+}

package/dist/pages/LinesTablePage.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from "react";
+interface Props {
+    decaysPath: string;
+    variablesPath: string;
+    submitLocation?: string;
+    hideDownloadButtons?: boolean;
+    hideUploadButtons?: boolean;
+    emailIsKnown?: boolean;
+    requestReasonMessage?: string;
+    requestSubmittedMessage?: ReactNode;
+    csrfToken?: string;
+}
+export declare function LinesTablePage({ submitLocation, hideDownloadButtons, hideUploadButtons, emailIsKnown, requestReasonMessage, requestSubmittedMessage, csrfToken, variablesPath, decaysPath, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/pages/LinesTablePage.js

@@ -0,0 +1,125 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/*****************************************************************************\
+ * (c) Copyright 2021-2024 CERN for the benefit of the LHCb Collaboration      *
+ *                                                                             *
+ * This software is distributed under the terms of the GNU General Public      *
+ * Licence version 3 (GPL Version 3), copied verbatim in the file "COPYING".   *
+ *                                                                             *
+ * In applying this licence, CERN does not waive the privileges and immunities *
+ * granted to it by virtue of its status as an Intergovernmental Organization  *
+ * or submit itself to any jurisdiction.                                       *
+ \*****************************************************************************/
+import EmailValidator from "email-validator";
+import yaml from "js-yaml";
+import { useEffect, useMemo, useState } from "react";
+import { Alert, Badge, Button, ButtonGroup, Col, FormControl, InputGroup, OverlayTrigger, Row, Stack, Tooltip, } from "react-bootstrap";
+import { Download, GearWideConnected, PlusLg, Upload } from "react-bootstrap-icons";
+import { useLocation, useNavigate } from "react-router-dom";
+import { downloadText } from "../utils/utils";
+import { DeleteButton } from "../components/DeleteButton";
+import { useMetadata } from "../providers/MetadataProvider";
+import { ConfigFilesUploadingAlert } from "../components/ConfigFilesUploadingAlert";
+import { useRows } from "../providers/RowsProvider";
+import { useRequest } from "../providers/RequestProvider";
+import { LoadingIndicator } from "../components/LoadingIndicator";
+import { LineTableRow } from "../components/LineTableRow";
+import { useProductionConfig } from "../providers/ProductionConfigProvider";
+import { UploadProdConfigModal } from "../components/modals/UploadProdConfigModal";
+import { SubmitRequestButton } from "../components/SubmitRequestButton";
+import { YamlFile } from "../models/yamlFile";
+export function LinesTablePage({ submitLocation, hideDownloadButtons, hideUploadButtons, emailIsKnown, requestReasonMessage, requestSubmittedMessage, csrfToken, variablesPath, decaysPath, }) {
+    const navigate = useNavigate();
+    const location = useLocation();
+    const metadata = useMetadata();
+    const { rows, setRows } = useRows();
+    const request = useRequest();
+    const { parseProductionFiles } = useProductionConfig();
+    const [showProdUploadModal, setShowProdUploadModal] = useState(false);
+    const [prodUploadLoading, setProdUploadLoading] = useState(false);
+    const [requestSubmitted, setRequestSubmitted] = useState(false);
+    useEffect(() => {
+        if (!metadata) {
+            return;
+        }
+        const urlParams = new URLSearchParams(location.search);
+        const cloneParam = urlParams.get("clone");
+        if (cloneParam === "1") {
+            handleClone().catch(console.error);
+        }
+    }, [metadata, location.search]);
+    async function handleClone() {
+        if (!metadata) {
+            return;
+        }
+        const raw = localStorage.getItem("yamlFilesToClone");
+        if (!raw) {
+            return;
+        }
+        setProdUploadLoading(true);
+        setRows([]);
+        try {
+            const yamlFiles = JSON.parse(raw);
+            for (const file of yamlFiles) {
+                if (file.defaults)
+                    file.name = "info.yaml";
+                file.blob = new Blob([yaml.dump(file)]);
+            }
+            const { rows } = await parseProductionFiles(yamlFiles, metadata);
+            setRows(rows);
+        }
+        finally {
+            setProdUploadLoading(false);
+            localStorage.removeItem("yamlFilesToClone");
+        }
+    }
+    const handleSubmitRows = async () => {
+        setRows((prev) => prev.map((r) => ({ ...r, editTree: true })));
+        await navigate(variablesPath);
+    };
+    const updateProductionName = ({ target }) => {
+        const safeName = target.value.replaceAll(/[^\w]/g, "");
+        request.setProductionName(safeName);
+    };
+    const updateContactEmails = ({ target }) => {
+        const emails = target.value.split(/[\s,]+/).filter((s) => s);
+        request.setContactEmails(emails);
+    };
+    const clearAll = () => {
+        request.setProductionName("");
+        request.setContactEmails([]);
+        request.setReasonForRequest("");
+        setRows([]);
+    };
+    const configuredRows = useMemo(() => rows.filter((r) => !!r.dtt), [rows]);
+    const { isEmptySession, isEmailValid, allRowsHaveDtt, allRowsHavePaths, validDttNames } = useMemo(() => {
+        const isEmptySession = !request.productionName && request.contactEmails.length === 0 && rows.length === 0;
+        const isEmailValid = request.contactEmails.length > 0 && request.contactEmails.every(EmailValidator.validate);
+        const allRowsHaveDtt = configuredRows.length > 0 && configuredRows.length === rows.length;
+        const allRowsHavePaths = rows.every((r) => r.paths.length > 0);
+        const names = configuredRows.map((r) => r.dtt.getName().trim() ?? "");
+        const validDttNames = names.every(Boolean) && new Set(names).size === names.length;
+        return {
+            isEmptySession,
+            isEmailValid,
+            allRowsHaveDtt,
+            allRowsHavePaths,
+            validDttNames,
+        };
+    }, [request, rows, configuredRows]);
+    if (!metadata || !request) {
+        return _jsx(LoadingIndicator, { height: "70vh" });
+    }
+    return (_jsxs("div", { className: "d-flex flex-column gap-3", children: [rows.map((row) => (_jsx(LineTableRow, { row: row, hideDownloadButtons: hideDownloadButtons ?? false, hideUploadButtons: hideUploadButtons ?? false, variablesPath: variablesPath }, row.id))), prodUploadLoading && _jsx(ConfigFilesUploadingAlert, {}), requestSubmitted && (_jsx(Row, { className: "mt-3", children: _jsx(Col, { children: _jsxs(Alert, { variant: "success", dismissible: true, onClose: () => setRequestSubmitted(false), children: [_jsx(Alert.Heading, { children: "Request submitted!" }), requestSubmittedMessage] }) }) })), _jsx(Row, { children: _jsx(Col, { xs: "auto", children: _jsxs(ButtonGroup, { children: [_jsx(OverlayTrigger, { overlay: _jsx(Tooltip, { children: "Select decays" }), children: _jsxs(Button, { type: "submit", variant: "success", onClick: () => void navigate(decaysPath), className: "align-items-center d-flex gap-1", children: [_jsx(PlusLg, {}), " Select decays"] }) }), !hideUploadButtons && (_jsx(OverlayTrigger, { overlay: _jsx(Tooltip, { children: "Upload Production configuration file" }), children: _jsx(Button, { className: "ms-auto align-items-center d-flex", type: "button", onClick: () => setShowProdUploadModal(true), children: _jsx(Upload, {}) }) })), showProdUploadModal && _jsx(UploadProdConfigModal, { onClose: () => setShowProdUploadModal(false) }), _jsx(OverlayTrigger, { overlay: _jsx(Tooltip, { children: "Configure all DecayTreeTuples" }), children: _jsxs(Button, { type: "submit", variant: "secondary", onClick: () => {
+                                        handleSubmitRows().catch(console.error);
+                                    }, disabled: !allRowsHaveDtt, className: "align-items-center d-flex gap-1", children: [_jsx(GearWideConnected, {}), " ", _jsx(Badge, { pill: true, bg: "primary", children: configuredRows.length })] }) }), !hideDownloadButtons && (_jsx(OverlayTrigger, { overlay: _jsx(Tooltip, { children: "Download Analysis Production configuration file (info.yaml)" }), children: _jsx(Button, { variant: "primary", type: "button", onClick: () => downloadText(YamlFile.createInfoYaml(rows, metadata)), disabled: !allRowsHaveDtt || !allRowsHavePaths || !isEmailValid, className: "align-items-center d-flex", children: _jsx(Download, {}) }) }))] }) }) }), _jsx(Row, { children: _jsxs(Col, { xs: 4, children: [_jsxs(InputGroup, { hasValidation: true, children: [_jsx(OverlayTrigger, { overlay: _jsx(Tooltip, { children: "Name of this production. This will become the subdirectory in AnalysisProductions" }), children: _jsx(InputGroup.Text, { children: "Production name" }) }), _jsx(FormControl, { value: request.productionName, onChange: updateProductionName, isValid: !!request.productionName, placeholder: "MyAnalysis" })] }), !emailIsKnown && (_jsxs(InputGroup, { hasValidation: true, className: "mt-1", children: [_jsx(OverlayTrigger, { overlay: _jsx(Tooltip, { children: "Email addresses to notify (comma-separated)" }), children: _jsx(InputGroup.Text, { children: "Email" }) }), _jsx(FormControl, { value: request.contactEmails.join(", "), onChange: updateContactEmails, isInvalid: !isEmailValid && request.contactEmails.length > 0, placeholder: "name@example.com" }), _jsx(FormControl.Feedback, { type: "invalid", children: "Please enter valid email addresses" })] })), _jsxs(Stack, { direction: "horizontal", gap: 1, className: "mt-3", children: [_jsx(SubmitRequestButton, { disabledMessage: !allRowsHaveDtt
+                                        ? "Please configure a DecayTreeTuple for each selected decay before submitting"
+                                        : !allRowsHavePaths
+                                            ? "Please select at least one Bookkeeping path for each decay before submitting"
+                                            : !request.productionName
+                                                ? "Please enter a production name before submitting"
+                                                : !(emailIsKnown || isEmailValid)
+                                                    ? "Please enter valid email addresses before submitting"
+                                                    : !validDttNames
+                                                        ? "Please make sure all DecayTreeTuple names are unique before submitting"
+                                                        : null, onSubmit: () => setRequestSubmitted(true), submitLocation: submitLocation, hideDownloadButtons: hideDownloadButtons, requestReasonMessage: requestReasonMessage, csrfToken: csrfToken }), _jsx(DeleteButton, { action: clearAll, disabled: isEmptySession, outline: undefined, children: "Clear all" })] })] }) })] }));
+}

package/dist/providers/DttProvider.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from "react";
+import Dtt, { DttConfig, ToolParamTypeMap } from "../models/dtt";
+import { MetadataContext } from "./MetadataProvider";
+import { DecayData } from "../models/decayData";
+import { TupleTool } from "../models/tupleTool";
+interface DttContextType {
+    dtt: Dtt;
+    decay: DecayData;
+    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;
+}
+interface DttProviderProps {
+    initialConfig: DttConfig;
+    decay: DecayData;
+    metadata: MetadataContext;
+    children: ReactNode;
+}
+export declare function DttProvider({ initialConfig, decay, metadata, children }: DttProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useDtt(): DttContextType;
+export {};

package/dist/providers/DttProvider.js

@@ -0,0 +1,77 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useReducer } from "react";
+import Dtt from "../models/dtt";
+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 [state, dispatch] = useReducer(reducer, null, () => ({
+        dtt: new Dtt(structuredClone(initialConfig), metadata.tupleTools.tupleTools),
+        decay,
+        lastSaved: structuredClone(initialConfig),
+        dirty: false,
+    }));
+    const updateToolParam = useCallback((branch, tool, param, value) => {
+        const next = state.dtt.withUpdatedToolParam(branch, tool, param, value);
+        if (next === state.dtt)
+            return;
+        dispatch({ type: "UPDATE", dtt: next });
+    }, [state.dtt]);
+    const addTool = useCallback((branch, tool) => {
+        dispatch({
+            type: "UPDATE",
+            dtt: state.dtt.withAddedTool(tool, branch),
+        });
+    }, [state.dtt]);
+    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 value = {
+        dtt: state.dtt,
+        decay,
+        dirty: state.dirty,
+        updateToolParam,
+        addTool,
+        removeTool,
+        save,
+        revert,
+    };
+    return _jsx(DttContext.Provider, { value: value, children: children });
+}
+export function useDtt() {
+    const ctx = useContext(DttContext);
+    if (!ctx)
+        throw new Error("useDtt must be used inside DttProvider");
+    return ctx;
+}