lhcb-ntuple-wizard-test 1.3.3 → 2.0.1

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,120 @@
+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, { allRowsHaveDtt: allRowsHaveDtt, disabled: !allRowsHaveDtt ||
+                                        !allRowsHavePaths ||
+                                        !request.productionName ||
+                                        (submitLocation && !request.reasonForRequest) ||
+                                        !(emailIsKnown || isEmailValid) ||
+                                        !validDttNames, 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;
+}

package/dist/providers/MetadataProvider.d.ts

@@ -0,0 +1,87 @@
+/*****************************************************************************\
+ * (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 { ReactNode } from "react";
+import { Particle } from "../models/particle.js";
+import { DecayData } from "../models/decayData";
+import { ToolMetadata } from "../models/dtt.js";
+export type TagHint = DecayTagHint | ParticleTagHint;
+export interface DecayTagHint {
+    description: string;
+    hide: boolean;
+    warn: boolean;
+}
+export interface ParticleTagHint {
+    description: string;
+    group: string;
+    hide: boolean;
+}
+interface ApplicationInfo {
+    Analysis: string;
+    DaVinci: string;
+    Phys: string;
+}
+interface StrippingInfo {
+    full_decays: string[];
+    output: string;
+    prescale: number;
+    stream: string[];
+    url: {
+        [key: string]: string;
+    };
+}
+export interface MetadataContext {
+    dataset: string[];
+    decays: {
+        [key: string]: DecayData;
+    };
+    embedding: {
+        [key: string]: string;
+    };
+    kgdoc: {
+        [key: string]: object;
+    };
+    lokiVariables: {
+        applicationInfo: ApplicationInfo;
+        lokiVariables: object;
+    };
+    particleProperties: {
+        [key: string]: Particle;
+    };
+    stripping: {
+        [key: string]: {
+            [key: string]: StrippingInfo;
+        };
+    };
+    strippingHints: {
+        [key: string]: {
+            davinci: string;
+            description: string;
+        };
+    };
+    tupleTools: {
+        applicationInfo: ApplicationInfo;
+        tupleTools: ToolMetadata;
+    };
+    userHints: {
+        decayTags: {
+            [key: string]: DecayTagHint;
+        };
+        particleTags: {
+            [key: string]: ParticleTagHint;
+        };
+    };
+}
+interface Props {
+    children: ReactNode;
+}
+export declare function MetadataProvider({ children }: Props): import("react/jsx-runtime").JSX.Element;
+export declare const useMetadata: () => MetadataContext | null;
+export {};

package/dist/providers/MetadataProvider.js

@@ -0,0 +1,50 @@
+import { jsxs as _jsxs, 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 { createContext, useContext, useEffect, useState } from "react";
+import { config } from "../config.js";
+import pako from "pako";
+const MetadataContextType = createContext(null);
+export function MetadataProvider({ children }) {
+    const [error, setError] = useState(null);
+    const [metadata, setMetadata] = useState(null);
+    async function loadDict(path) {
+        const response = await fetch(`${config.metadata_baseurl}${path}.json.gz`);
+        if (!response.ok) {
+            console.error(response);
+            return null;
+        }
+        const data = await response.arrayBuffer();
+        const unzipped = pako.inflate(new Uint8Array(data));
+        const decoded = new TextDecoder("utf-8").decode(unzipped);
+        return JSON.parse(decoded);
+    }
+    useEffect(() => {
+        const metadataContextKeys = Object.keys(config.metadata_files);
+        // Load all metadata files
+        const promises = metadataContextKeys.map(async (key) => [key, await loadDict(config.metadata_files[key])]);
+        // Build the context object
+        Promise.all(promises)
+            .then((entries) => {
+            setMetadata(Object.fromEntries(entries));
+        })
+            .catch(setError);
+    }, []);
+    if (error) {
+        return _jsxs("h1", { children: ["Oops: ", `${error}`] });
+    }
+    else {
+        return _jsx(MetadataContextType.Provider, { value: metadata, children: children });
+    }
+}
+export const useMetadata = () => {
+    return useContext(MetadataContextType);
+};