lhcb-ntuple-wizard-test 2.0.0 → 2.0.1

package/dist/components/TupleToolDropdown.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx } 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 Select from "react-select";
+import { TupleToolLabel } from "./TupleToolLabel";
+import { useMetadata } from "../providers/MetadataProvider.js";
+import { TupleTool } from "../models/tupleTool";
+export function TupleToolDropdown({ filterToolTags, ...props }) {
+    const metadata = useMetadata();
+    const options = metadata
+        ? filterToolTags.map((allowedTag) => ({
+            label: allowedTag,
+            options: Object.keys(metadata.tupleTools.tupleTools)
+                .sort()
+                .map(TupleTool.fromString)
+                .map((tool) => ({ value: tool.toString(), label: _jsx(TupleToolLabel, { tool: tool }) }))
+                .filter((tool) => metadata.tupleTools.tupleTools[tool.value].tags.includes(allowedTag)),
+        }))
+        : [];
+    return (_jsx("div", { className: "react-select form-control p-0", children: _jsx(Select, { options: options, isLoading: !metadata, ...props }) }));
+}

package/dist/components/TupleToolGroup.d.ts

@@ -0,0 +1,6 @@
+interface Props {
+    branch: string[];
+    onGroupSelected: (group: string) => void;
+}
+export declare function TupleToolGroup({ branch, onGroupSelected }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/TupleToolGroup.js

@@ -0,0 +1,22 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Button, Card, ListGroup, OverlayTrigger, Popover } from "react-bootstrap";
+import { PencilSquare } from "react-bootstrap-icons";
+import { DecayLatex } from "./DecayLatex";
+import { useDtt } from "../providers/DttProvider";
+export function TupleToolGroup({ branch, onGroupSelected }) {
+    const { dtt, decay } = useDtt();
+    let groups = {};
+    if (branch.length === 0) {
+        groups = dtt.config.groups;
+    }
+    else if (branch.length === 1) {
+        const filteredGroups = Object.entries(dtt.config.groups).filter(([key]) => key.includes(branch[0]));
+        groups = Object.fromEntries(filteredGroups);
+    }
+    const groupKeys = Object.keys(groups);
+    function ToolCount({ group }) {
+        const tools = dtt.listTools(group);
+        return (_jsx(OverlayTrigger, { overlay: _jsx(Popover, { children: _jsx(ListGroup, { children: tools.map((tool) => (_jsx(ListGroup.Item, { children: tool.toString() }, tool.toString()))) }) }), children: _jsxs("div", { children: [tools.length, " TupleTool", tools.length === 1 ? "" : "s"] }) }));
+    }
+    return (_jsxs(Card, { className: "mt-2", children: [_jsxs(Card.Header, { children: [groupKeys.length, " group", groupKeys.length === 1 ? "" : "s"] }), _jsx(ListGroup, { variant: "flush", children: groupKeys.map((selection) => (_jsxs(ListGroup.Item, { className: "d-flex justify-content-between align-items-start", children: [_jsx(DecayLatex, { decay: decay, selection: selection.split(",") }), _jsx(ToolCount, { group: selection.split(",") }), _jsx(Button, { variant: "outline-secondary", size: "sm", onClick: () => onGroupSelected(selection), children: _jsx(PencilSquare, {}) })] }, selection))) })] }));
+}

package/dist/components/TupleToolLabel.d.ts

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

package/dist/components/TupleToolLabel.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } 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 { 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() }) }));
+}

package/dist/components/TupleToolList.d.ts

@@ -0,0 +1,7 @@
+interface Props {
+    branch: string[];
+    onGroupSelected: (group: string) => void;
+    onSave: () => void;
+}
+export declare function TupleToolList({ branch, onGroupSelected, onSave }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/TupleToolList.js

@@ -0,0 +1,38 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } 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 { TupleToolLabel } from "./TupleToolLabel";
+import { DeleteButton } from "./DeleteButton.js";
+import { Button, ButtonGroup, Card, ListGroup, OverlayTrigger, Tooltip } from "react-bootstrap";
+import { PencilSquare, PlusLg } from "react-bootstrap-icons";
+import { useMetadata } from "../providers/MetadataProvider.js";
+import { useState } from "react";
+import { TupleToolGroup } from "./TupleToolGroup";
+import { AddTupleToolModal } from "./modals/AddTupleToolModal";
+import { ConfigureTupleToolModal } from "./modals/ConfigureTupleToolModal";
+import { useDtt } from "../providers/DttProvider";
+export function TupleToolList({ branch, onGroupSelected, onSave }) {
+    const metadata = useMetadata();
+    const { dtt, dirty, save, revert, removeTool } = useDtt();
+    const [showAddModal, setShowAddModal] = useState(false);
+    const [showConfigModalWithTool, setShowConfigModalWithTool] = useState(null);
+    if (!metadata) {
+        return null;
+    }
+    const tools = dtt.listTools(branch);
+    const filterToolTags = branch.length === 0 ? ["IParticleTupleTool", "IEventTupleTool"] : ["IParticleTupleTool"];
+    return (_jsxs(_Fragment, { children: [_jsxs(Card, { children: [_jsxs(Card.Header, { className: "d-flex justify-content-between align-items-start", children: [_jsxs("span", { children: [tools.length, " TupleTool", tools.length === 1 ? "" : "s"] }), _jsx(Button, { variant: "success", size: "sm", onClick: () => setShowAddModal(true), children: _jsx(PlusLg, {}) })] }), _jsx(ListGroup, { variant: "flush", children: tools.map((tool) => {
+                            return (_jsxs(ListGroup.Item, { className: "d-flex justify-content-between align-items-start", variant: showConfigModalWithTool?.equals(tool) ? "secondary" : "", children: [_jsx(TupleToolLabel, { tool: tool }), _jsxs(ButtonGroup, { size: "sm", children: [_jsx(Button, { variant: "outline-secondary", onClick: () => setShowConfigModalWithTool(tool), children: _jsx(PencilSquare, {}) }), _jsx(DeleteButton, { outline: true, action: () => removeTool(branch, tool) })] })] }, tool.toString()));
+                        }) })] }), showAddModal && (_jsx(AddTupleToolModal, { branch: branch, filterToolTags: filterToolTags, onClose: () => setShowAddModal(false) })), showConfigModalWithTool && (_jsx(ConfigureTupleToolModal, { branch: branch, tool: showConfigModalWithTool, onClose: () => setShowConfigModalWithTool(null) })), branch.length === 0 && Object.keys(dtt.config.groups).length > 0 && (_jsx(TupleToolGroup, { branch: branch, onGroupSelected: onGroupSelected })), _jsxs(ButtonGroup, { className: "mt-2", children: [_jsx(OverlayTrigger, { overlay: _jsx(Tooltip, { children: "Save changes to this DecayTreeTuple" }), children: _jsx(Button, { onClick: () => {
+                                save();
+                                onSave();
+                            }, disabled: !dirty, children: "Save" }) }), _jsx(OverlayTrigger, { overlay: _jsx(Tooltip, { children: "Discard changes to this DecayTreeTuple" }), children: _jsx(Button, { variant: "outline-danger", onClick: revert, disabled: !dirty, children: "Revert" }) })] })] }));
+}

package/dist/components/YearBadge.d.ts

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

package/dist/components/YearBadge.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } 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 { Badge } from "react-bootstrap";
+export function YearBadge({ year }) {
+    return (_jsx(Badge, { pill: true, bg: "success", children: year }));
+}

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

@@ -0,0 +1,7 @@
+interface Props {
+    branch: string[];
+    filterToolTags: string[];
+    onClose: () => void;
+}
+export declare function AddTupleToolModal({ branch, filterToolTags, onClose }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/modals/AddTupleToolModal.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, FormControl, InputGroup, Modal } from "react-bootstrap";
+import { TupleToolDropdown } from "../TupleToolDropdown";
+import { TupleToolDocsAccordion } from "../TupleToolDocsAccordion";
+import { useDtt } from "../../providers/DttProvider";
+import { TupleTool } from "../../models/tupleTool";
+import { useEffect, useRef, useState } from "react";
+export function AddTupleToolModal({ branch, filterToolTags, onClose }) {
+    const { dtt, addTool } = useDtt();
+    const nameInputRef = useRef(null);
+    const [selectedTool, setSelectedTool] = useState(null);
+    useEffect(() => {
+        nameInputRef.current?.focus();
+    }, [selectedTool]);
+    return (_jsxs(Modal, { show: true, onHide: onClose, 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(TupleToolDropdown, { filterToolTags: filterToolTags, placeholder: "TupleTool class", onChange: (option) => {
+                                    if (option) {
+                                        setSelectedTool((prev) => new TupleTool(option.value, prev?.name || ""));
+                                    }
+                                }, value: selectedTool ? { value: selectedTool.class, label: selectedTool.class } : null }), _jsx(FormControl, { ref: nameInputRef, placeholder: "TupleTool name", onChange: (event) => {
+                                    // Remove all non-word characters
+                                    const name = event.target.value.replaceAll(/[^\w]/g, "");
+                                    setSelectedTool((prev) => new TupleTool(prev.class, name));
+                                }, value: selectedTool?.name || "", disabled: !selectedTool, isInvalid: !!selectedTool && dtt.toolExists(selectedTool, branch), onKeyDown: (event) => {
+                                    if (event.key === "Enter") {
+                                        addTool(branch, selectedTool);
+                                        onClose();
+                                    }
+                                } }), selectedTool && (_jsxs(FormControl.Feedback, { type: "invalid", children: ["A ", selectedTool.class, " with the name \"", selectedTool.name, "\" already exists"] }))] }), selectedTool && _jsx(TupleToolDocsAccordion, { toolClass: selectedTool.class }), _jsx(Button, { className: "align-self-end", variant: "success", disabled: !selectedTool || dtt.toolExists(selectedTool, branch), onClick: () => {
+                            addTool(branch, selectedTool);
+                            onClose();
+                        }, children: "Add tool" })] })] }));
+}

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

@@ -0,0 +1,8 @@
+import { TupleTool } from "../../models/tupleTool";
+interface Props {
+    branch: string[];
+    tool: TupleTool;
+    onClose: () => void;
+}
+export declare function ConfigureTupleToolModal({ branch, tool, onClose }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/modals/ConfigureTupleToolModal.js

@@ -0,0 +1,43 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Button, Col, Form, Modal, OverlayTrigger, Row, Tooltip } from "react-bootstrap";
+import { StrParamInput } from "../tupleToolParams/StrParamInput";
+import { BoolParamInput } from "../tupleToolParams/BoolParamInput";
+import { NumParamInput } from "../tupleToolParams/NumParamInput";
+import { ListParamInput } from "../tupleToolParams/ListParamInput";
+import { DictParamInput } from "../tupleToolParams/DictParamInput";
+import { QuestionCircle } from "react-bootstrap-icons";
+import { TupleToolDocsAccordion } from "../TupleToolDocsAccordion";
+import { useDtt } from "../../providers/DttProvider";
+export function ConfigureTupleToolModal({ branch, tool, onClose }) {
+    const { dtt, updateToolParam } = useDtt();
+    return (_jsxs(Modal, { show: true, size: "xl", fullscreen: "lg-down", onHide: onClose, children: [_jsxs(Modal.Header, { closeButton: true, children: ["Configure ", tool.toString()] }), _jsxs(Modal.Body, { className: "gap-3 d-flex flex-column", children: [tool ? (_jsx(Form, { children: Object.entries(dtt.getToolConfig(branch, tool)).map(([paramName, param]) => {
+                            const { description, type, default: defaultValue, value } = param;
+                            let inputComponent;
+                            switch (type) {
+                                case "str":
+                                    inputComponent = (_jsx(StrParamInput, { value: value, defaultValue: defaultValue, onChange: (newValue) => updateToolParam(branch, tool, paramName, newValue), param: paramName }));
+                                    break;
+                                case "bool":
+                                    inputComponent = (_jsx(BoolParamInput, { value: value, onChange: (newValue) => updateToolParam(branch, tool, paramName, newValue) }));
+                                    break;
+                                case "int":
+                                case "uint":
+                                case "float":
+                                    inputComponent = (_jsx(NumParamInput, { type: type, value: value, defaultValue: defaultValue, onChange: (newValue) => updateToolParam(branch, tool, paramName, newValue) }));
+                                    break;
+                                case "text":
+                                    inputComponent = (_jsx(ListParamInput, { initialValues: value, defaultValues: defaultValue, newItemValue: "", onChange: (newValue) => updateToolParam(branch, tool, paramName, newValue), buildInnerInput: (props) => _jsx(StrParamInput, { ...props, param: paramName }) }));
+                                    break;
+                                case "[int]":
+                                case "[uint]":
+                                case "[float]":
+                                    inputComponent = (_jsx(ListParamInput, { initialValues: value, defaultValues: defaultValue, newItemValue: 0, onChange: (newValue) => updateToolParam(branch, tool, paramName, newValue), buildInnerInput: (props) => (_jsx(NumParamInput, { type: type.slice(1, -1), ...props })) }));
+                                    break;
+                                case "{str:str}":
+                                case "{str:[str]}":
+                                    inputComponent = (_jsx(DictParamInput, { value: value, onChange: (newValue) => updateToolParam(branch, tool, paramName, newValue) }));
+                                    break;
+                            }
+                            return (_jsxs(Form.Group, { as: Row, className: "mb-2", children: [_jsxs(Form.Label, { column: true, sm: 3, children: [_jsx(OverlayTrigger, { overlay: _jsx(Tooltip, { children: description }), children: _jsx(QuestionCircle, {}) }), _jsxs("code", { children: [" ", paramName, " "] })] }), _jsx(Form.Label, { column: true, sm: 2, children: _jsxs("code", { children: [" ", type, " "] }) }), _jsx(Col, { sm: 7, children: inputComponent })] }, paramName));
+                        }) })) : ("No tool selected"), _jsx(TupleToolDocsAccordion, { toolClass: tool.class }), _jsx(Button, { className: "align-self-end", onClick: onClose, children: "Save & close" })] })] }));
+}

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

@@ -0,0 +1,8 @@
+interface Props {
+    submitLocation: string;
+    onClose: (submitted: boolean) => void;
+    requestReasonMessage?: string;
+    csrfToken?: string;
+}
+export declare function ReasonForRequestModal({ submitLocation, onClose, requestReasonMessage, csrfToken }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/modals/ReasonForRequestModal.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Alert, Button, FormControl, InputGroup, Modal, OverlayTrigger, Spinner, Tooltip } from "react-bootstrap";
+import { useRequest } from "../../providers/RequestProvider";
+import { useState } from "react";
+import { useRows } from "../../providers/RowsProvider";
+export function ReasonForRequestModal({ submitLocation, onClose, requestReasonMessage, csrfToken }) {
+    const { generateAllFiles } = useRows();
+    const { productionName, reasonForRequest, setReasonForRequest } = useRequest();
+    const [requestLoading, setRequestLoading] = useState(false);
+    const [requestError, setRequestError] = useState(null);
+    const submitRequest = (url) => {
+        setRequestLoading(true);
+        setRequestError(null);
+        const allFiles = generateAllFiles();
+        const formData = new FormData();
+        allFiles.forEach((file) => {
+            formData.append("generatedFiles[]", new Blob([file.content], { type: "text/plain" }), file.name);
+        });
+        formData.append("email", localStorage.getItem("email") || "");
+        formData.append("name", productionName);
+        formData.append("reasonForRequest", reasonForRequest);
+        let headers = {};
+        if (csrfToken) {
+            headers = {
+                "X-Csrf-Token": csrfToken,
+            };
+        }
+        fetch(url, {
+            method: "POST",
+            body: formData,
+            credentials: "include",
+            headers: headers,
+        })
+            .then((response) => {
+            if (!response.ok) {
+                throw new Error(`HTTP error! Status: ${response.status}`);
+            }
+            onClose(true);
+        })
+            .catch((error) => {
+            console.error("Fetch error:", error);
+            setRequestError("Something went wrong while submitting your request. Please try again later or contact support.");
+        })
+            .finally(() => {
+            setRequestLoading(false);
+        });
+    };
+    return (_jsxs(Modal, { show: true, onHide: () => onClose(false), size: "lg", children: [_jsx(Modal.Header, { closeButton: true, children: _jsx(Modal.Title, { children: "Reason for request" }) }), _jsxs(Modal.Body, { children: [_jsx(Alert, { children: requestReasonMessage }), requestError && _jsx(Alert, { variant: "danger", children: requestError }), _jsxs(InputGroup, { hasValidation: true, children: [_jsx(OverlayTrigger, { overlay: _jsx(Tooltip, { children: "Reason for requesting the chosen ntuples" }), children: _jsx(InputGroup.Text, { children: "Reason for request" }) }), _jsx(FormControl, { as: "textarea", rows: 3, value: reasonForRequest, onChange: (event) => setReasonForRequest(event.target.value), isValid: !!reasonForRequest, placeholder: "I need these ntuples for..." })] })] }), _jsx(Modal.Footer, { children: _jsx(Button, { variant: "primary", onClick: () => submitRequest(submitLocation), children: requestLoading ? _jsx(Spinner, { animation: "border" }) : "Submit" }) })] }));
+}

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

@@ -0,0 +1,7 @@
+import { RowData } from "../../models/rowData";
+interface Props {
+    row: RowData;
+    onClose: () => void;
+}
+export declare function UploadDttConfigModal({ row, onClose }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/modals/UploadDttConfigModal.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, Form, Modal } from "react-bootstrap";
+import yaml from "js-yaml";
+import Dtt from "../../models/dtt";
+import { useRows } from "../../providers/RowsProvider";
+export function UploadDttConfigModal({ row, onClose }) {
+    const { setRows } = useRows();
+    const uploadConfig = (files) => {
+        const reader = new FileReader();
+        reader.onload = (e) => {
+            if (!e.target) {
+                return;
+            }
+            const text = e.target.result;
+            const config = yaml.load(text);
+            if (config.descriptorTemplate === row.decay.descriptors.template) {
+                const dtt = new Dtt(config, {});
+                setRows((prev) => {
+                    return prev.map((r) => (r.id === row.id ? { ...r, dtt: dtt.withInputsFromLines(row.lines) } : r));
+                });
+                onClose();
+            }
+            else {
+                alert("Make sure to upload a previously downloaded configuration file for the same decay.");
+            }
+        };
+        reader.readAsText(files[0]);
+    };
+    return (_jsxs(Modal, { show: true, animation: false, children: [_jsx(Modal.Header, { children: _jsx(Modal.Title, { children: " Upload configuration file " }) }), _jsx(Modal.Body, { children: _jsx(Form.Group, { controlId: "formFile1", className: "mb-3", children: _jsx(Form.Control, { type: "file", onChange: (event) => {
+                            if (!event.target.files)
+                                return;
+                            event.preventDefault();
+                            uploadConfig(event.target.files);
+                        } }) }) }), _jsx(Modal.Footer, { children: _jsx(Button, { variant: "secondary", onClick: onClose, children: "Close" }) })] }));
+}

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

@@ -0,0 +1,5 @@
+interface Props {
+    onClose: () => void;
+}
+export declare function UploadProdConfigModal({ onClose }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/modals/UploadProdConfigModal.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, Form, Modal } from "react-bootstrap";
+import { useMetadata } from "../../providers/MetadataProvider";
+import { useProductionConfig } from "../../providers/ProductionConfigProvider";
+import { useRows } from "../../providers/RowsProvider";
+import { useRequest } from "../../providers/RequestProvider";
+export function UploadProdConfigModal({ onClose }) {
+    const metadata = useMetadata();
+    const { parseProductionFiles } = useProductionConfig();
+    const { setRows } = useRows();
+    const { setContactEmails } = useRequest();
+    if (!metadata) {
+        return null;
+    }
+    return (_jsxs(Modal, { show: true, animation: false, children: [_jsx(Modal.Header, { children: _jsx(Modal.Title, { children: " Upload configuration file " }) }), _jsx(Modal.Body, { children: _jsx(Form.Group, { controlId: "formFile2", className: "mb-3", children: _jsx(Form.Control, { type: "file", multiple: true, onChange: (event) => {
+                            const files = event.target.files;
+                            if (!files) {
+                                return;
+                            }
+                            parseProductionFiles(Array.from(files), metadata)
+                                .then(({ rows, emails }) => {
+                                setRows(rows);
+                                setContactEmails(emails);
+                            })
+                                .catch(console.error);
+                        } }) }) }), _jsx(Modal.Footer, { children: _jsx(Button, { variant: "secondary", onClick: onClose, children: "Close" }) })] }));
+}

package/dist/components/tupleToolParams/BoolParamInput.d.ts

@@ -0,0 +1,16 @@
+/*****************************************************************************\
+ * (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.                                       *
+ \*****************************************************************************/
+interface Props {
+    value: boolean;
+    onChange: (v: boolean) => void;
+}
+export declare function BoolParamInput({ onChange, value }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/tupleToolParams/BoolParamInput.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } 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 { Form } from "react-bootstrap";
+export function BoolParamInput({ onChange, value }) {
+    return _jsx(Form.Check, { type: "switch", checked: value, onChange: () => onChange(!value) });
+}

package/dist/components/tupleToolParams/DictParamInput.d.ts

@@ -0,0 +1,14 @@
+interface Props {
+    value: {
+        [key: string]: string;
+    } | {
+        [key: string]: string[];
+    };
+    onChange: (value: {
+        [key: string]: string;
+    } | {
+        [key: string]: string[];
+    }) => void;
+}
+export declare function DictParamInput({ onChange, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/tupleToolParams/DictParamInput.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, 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 { useState } from "react";
+import { Alert, Button, ButtonGroup, Card, FormControl } from "react-bootstrap";
+export function DictParamInput({ onChange, ...props }) {
+    const [value, setValue] = useState(JSON.stringify(props.value, null, 2));
+    const [editMode, setEditMode] = useState(false);
+    const [error, setError] = useState(null);
+    const handleSave = () => {
+        try {
+            const json = JSON.parse(value);
+            onChange(json);
+            setError(null);
+            setEditMode(false);
+        }
+        catch (e) {
+            console.error("JSON parsing error:", e);
+            setError("Invalid JSON");
+        }
+    };
+    return (_jsx(Card, { children: _jsxs(Card.Body, { children: [error && _jsx(Alert, { variant: "danger", children: error }), _jsx(FormControl, { as: "textarea", value: value, onChange: (e) => setValue(e.target.value), disabled: !editMode }), _jsxs(ButtonGroup, { children: [editMode && (_jsx(Button, { variant: "primary", onClick: handleSave, children: "Save" })), _jsx(Button, { variant: "outline-secondary", onClick: () => setEditMode(!editMode), children: editMode ? "Cancel" : "Edit" })] })] }) }));
+}

package/dist/components/tupleToolParams/ListParamInput.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from "react";
+interface Props<T> {
+    onChange: (value: T[]) => void;
+    initialValues: T[];
+    defaultValues: T[];
+    newItemValue: T;
+    buildInnerInput: (props: {
+        value: T;
+        onChange: (value: T) => void;
+        defaultValue?: T;
+    }) => ReactNode;
+}
+export declare function ListParamInput<T>({ onChange, initialValues, defaultValues, newItemValue, buildInnerInput }: Props<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/tupleToolParams/ListParamInput.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } 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, CloseButton, InputGroup, ListGroup } from "react-bootstrap";
+import { PlusLg } from "react-bootstrap-icons";
+import { useEffect, useState } from "react";
+export function ListParamInput({ onChange, initialValues, defaultValues, newItemValue, buildInnerInput }) {
+    const [value, setValue] = useState(initialValues);
+    useEffect(() => {
+        // Don't run on the first render
+        if (initialValues === value) {
+            return;
+        }
+        onChange(value);
+    }, [value]);
+    const handleAdd = () => {
+        if (value.length < defaultValues.length) {
+            setValue((prev) => [...prev, defaultValues[prev.length]]);
+        }
+        else {
+            setValue((prev) => [...prev, newItemValue]);
+        }
+    };
+    const handleRemove = (index) => {
+        setValue((prev) => prev.filter((_, i) => i !== index));
+    };
+    return (_jsxs(_Fragment, { children: [_jsx(ListGroup, { variant: "flush", children: value.map((value, i) => (_jsx(ListGroup.Item, { children: _jsxs(InputGroup, { children: [buildInnerInput({
+                                value,
+                                onChange: (newValue) => {
+                                    setValue((prev) => {
+                                        const next = [...prev];
+                                        next[i] = newValue;
+                                        return next;
+                                    });
+                                },
+                                defaultValue: i < defaultValues.length ? defaultValues[i] : undefined,
+                            }), _jsx(CloseButton, { onClick: () => handleRemove(i) })] }) }, i))) }), _jsx(Button, { variant: "success", size: "sm", onClick: handleAdd, children: _jsx(PlusLg, {}) })] }));
+}

package/dist/components/tupleToolParams/NumParamInput.d.ts

@@ -0,0 +1,18 @@
+/*****************************************************************************\
+ * (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.                                       *
+ \*****************************************************************************/
+interface Props {
+    type: "int" | "uint" | "float";
+    value: number;
+    defaultValue?: number;
+    onChange: (v: number) => void;
+}
+export declare function NumParamInput({ type, onChange, value, defaultValue }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/tupleToolParams/NumParamInput.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } 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 { Form } from "react-bootstrap";
+export function NumParamInput({ type, onChange, value, defaultValue }) {
+    return (_jsx(Form.Control, { type: "number", value: value, placeholder: defaultValue?.toString(), onChange: (event) => {
+            const value = event.target.value;
+            let n = Number(value);
+            if (type === "int") {
+                n = Math.trunc(n);
+            }
+            else if (type === "uint") {
+                n = Math.trunc(Math.abs(n));
+            }
+            onChange(n);
+        }, ...(type === "int" || type === "uint" ? { step: 1 } : {}), ...(type === "uint" ? { min: 0 } : {}) }));
+}

package/dist/components/tupleToolParams/StrParamInput.d.ts

@@ -0,0 +1,19 @@
+/*****************************************************************************\
+ * (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.                                       *
+ \*****************************************************************************/
+export declare function sanitizeStrTupleToolParam(value: string): string;
+interface Props {
+    value: string;
+    defaultValue?: string;
+    onChange: (value: string) => void;
+    param?: string;
+}
+export declare function StrParamInput({ onChange, value, defaultValue, param }: Props): import("react/jsx-runtime").JSX.Element;
+export {};