lhcb-ntuple-wizard 2.0.0 → 2.0.2

package/dist/models/bkPath.js

@@ -1,40 +1,47 @@
-export default class BkPath {
-    path;
-    isMC;
+const LHCB_PATH_LENGTH = 9;
+const MC_PATH_LENGTH = 10;
+export class BkPath {
+    year;
+    strippingVersion;
+    polarity;
+    eventType;
+    fileName;
     constructor(path) {
-        this.path = path;
-        this.isMC = path.split("/")[1] === "MC";
-    }
-    getStrippingVersion() {
-        return this.path.split("/")[this.isMC ? 7 : 6].replace("Stripping", "").replace("NoPrescalingFlagged", "");
-    }
-    getYear() {
-        return this.path.split("/")[2].replace("Collision", "20");
-    }
-    getPolarity() {
-        const matchingPolarities = ["MagUp", "MagDown"].filter((polarity) => this.path.includes(polarity));
-        return matchingPolarities.length === 1 ? matchingPolarities[0] : null;
+        if (!BkPath.isValid(path)) {
+            throw new Error(`Invalid bookkeeping path: ${path}`);
+        }
+        const parts = path.split("/");
+        const [, type, year] = parts;
+        const { strippingVersion, eventType, fileName } = type === "MC" ? BkPath.extractMcParts(parts) : BkPath.extractLhcbParts(parts);
+        this.year = year.replace("Collision", "20"); // e.g. Collision16 -> 2016
+        this.strippingVersion = strippingVersion.replace("Stripping", "").replace("NoPrescalingFlagged", "");
+        this.polarity = path.includes("MagUp") ? "MagUp" : path.includes("MagDown") ? "MagDown" : null;
+        this.eventType = eventType;
+        this.fileName = fileName;
     }
-    getFilename() {
-        return this.path.split("/")[this.isMC ? 9 : 8];
+    static extractMcParts(parts) {
+        return {
+            strippingVersion: parts[7],
+            eventType: parts[8],
+            fileName: parts[9],
+        };
     }
-    getEventType() {
-        return this.path.split("/")[this.isMC ? 8 : 7];
+    static extractLhcbParts(parts) {
+        return {
+            strippingVersion: parts[6],
+            eventType: parts[7],
+            fileName: parts[8],
+        };
     }
-    isValid() {
-        const bkArray = this.path.split("/");
-        if (bkArray[0] !== "") {
+    static isValid(path) {
+        if (!path.startsWith("/")) {
             return false;
         }
-        if (!this.path.toLowerCase().endsWith("dst")) {
+        if (!path.toLowerCase().endsWith("dst")) {
             return false;
         }
-        if (bkArray.length === 9 && bkArray[1] === "LHCb") {
-            return true;
-        }
-        else if (bkArray.length === 10 && bkArray[1] === "MC") {
-            return true;
-        }
-        return false;
+        const parts = path.split("/");
+        const [, type] = parts;
+        return ((parts.length === LHCB_PATH_LENGTH && type === "LHCb") || (parts.length === MC_PATH_LENGTH && type === "MC"));
     }
 }

package/dist/models/dtt.d.ts

@@ -51,31 +51,56 @@ export type AnyToolParam = {
 export interface ToolConfig {
     [toolParamName: string]: AnyToolParam;
 }
+interface SavedToolConfig {
+    [toolName: string]: {
+        [paramName: string]: ToolParamTypeMap[keyof ToolParamTypeMap];
+    };
+}
 export interface BranchConfig {
     particle: string;
     tools: {
         [toolString: string]: ToolConfig;
     };
 }
+interface SavedBranchConfig {
+    particle: string;
+    tools: SavedToolConfig[];
+}
 export interface GroupConfig {
     particles: string[];
     tools: {
         [toolString: string]: ToolConfig;
     };
 }
+interface SavedGroupConfig {
+    particles: string[];
+    tools: SavedToolConfig[];
+}
 export interface DttConfig {
-    inputs?: string[];
+    branches: {
+        [particleId: string]: BranchConfig;
+    };
     descriptorTemplate?: string;
+    inputs?: string[];
+    groups: {
+        [particleGroup: string]: GroupConfig;
+    };
+    name?: string;
     tools: {
         [toolName: string]: ToolConfig;
     };
+}
+export interface SavedDttConfig {
     branches: {
-        [particleId: string]: BranchConfig;
+        [particleId: string]: SavedBranchConfig;
     };
+    descriptorTemplate?: string;
     groups: {
-        [particleGroup: string]: GroupConfig;
+        [particleGroup: string]: SavedGroupConfig;
     };
+    inputs?: string[];
     name?: string;
+    tools: SavedToolConfig[];
 }
 export interface Branch {
     branch: string;
@@ -86,6 +111,10 @@ export default class Dtt {
     config: DttConfig;
     metadata: ToolMetadata;
     constructor(config: DttConfig, toolMetadata: ToolMetadata);
+    private static formatToolsForSaving;
+    private static formatToolsForLoading;
+    static fromSavedConfig(savedConfig: SavedDttConfig, toolMetadata: ToolMetadata): Dtt;
+    toSavedConfig(): SavedDttConfig;
     private static getBranchConfigs;
     static create(descriptorTemplate: string, branchItemsList: BranchMapItem[], inputs: string[], name: string, toolMetadata: ToolMetadata): Dtt;
     withInputsFromLines(lines: StrippingLine[]): Dtt;
@@ -106,3 +135,4 @@ export default class Dtt {
     listTools(branch?: string[]): TupleTool[];
     toolExists(tool: TupleTool, branch?: string[]): boolean;
 }
+export {};

package/dist/models/dtt.js

@@ -9,6 +9,68 @@ export default class Dtt {
         this.config = config;
         this.metadata = toolMetadata;
     }
+    static formatToolsForSaving(tools) {
+        return Object.entries(tools).map(([toolName, toolConfig]) => ({
+            [toolName]: Object.fromEntries(Object.entries(toolConfig).map(([paramName, param]) => [paramName, param.value])),
+        }));
+    }
+    static formatToolsForLoading(tools, toolMetadata) {
+        return Object.fromEntries(tools.map((toolConfig) => {
+            const toolName = Object.keys(toolConfig)[0];
+            const params = toolConfig[toolName];
+            return [
+                toolName,
+                Object.fromEntries(Object.entries(params).map(([paramName, value]) => {
+                    const paramMetadata = toolMetadata[toolName].interface.find((param) => param.name === paramName);
+                    if (!paramMetadata) {
+                        throw new Error(`No metadata for param ${paramName} of tool ${toolName}`);
+                    }
+                    return [paramName, { value, ...paramMetadata }];
+                })),
+            ];
+        }));
+    }
+    static fromSavedConfig(savedConfig, toolMetadata) {
+        const config = {
+            ...savedConfig,
+            tools: Dtt.formatToolsForLoading(savedConfig.tools, toolMetadata),
+            branches: Object.fromEntries(Object.entries(savedConfig.branches).map(([branchId, branchConfig]) => [
+                branchId,
+                {
+                    ...branchConfig,
+                    tools: Dtt.formatToolsForLoading(branchConfig.tools, toolMetadata),
+                },
+            ])),
+            groups: Object.fromEntries(Object.entries(savedConfig.groups).map(([groupId, groupConfig]) => [
+                groupId,
+                {
+                    ...groupConfig,
+                    tools: Dtt.formatToolsForLoading(groupConfig.tools, toolMetadata),
+                },
+            ])),
+        };
+        return new Dtt(config, {});
+    }
+    toSavedConfig() {
+        return {
+            ...this.config,
+            tools: Dtt.formatToolsForSaving(this.config.tools),
+            branches: Object.fromEntries(Object.entries(this.config.branches).map(([branchId, branchConfig]) => [
+                branchId,
+                {
+                    ...branchConfig,
+                    tools: Dtt.formatToolsForSaving(branchConfig.tools),
+                },
+            ])),
+            groups: Object.fromEntries(Object.entries(this.config.groups).map(([groupId, groupConfig]) => [
+                groupId,
+                {
+                    ...groupConfig,
+                    tools: Dtt.formatToolsForSaving(groupConfig.tools),
+                },
+            ])),
+        };
+    }
     static getBranchConfigs(branchItemsList) {
         const branches = {};
         const walk = (item, parentId) => {

package/dist/models/yamlFile.d.ts

@@ -6,6 +6,5 @@ export declare class YamlFile {
     content: string;
     constructor(name: string, content: string);
     static fromDtt(dtt: Dtt): YamlFile;
-    private static reformatTools;
     static createInfoYaml(rows: RowData[], metadata: MetadataContext): YamlFile;
 }

package/dist/models/yamlFile.js

@@ -8,30 +8,7 @@ export class YamlFile {
         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])),
-        }));
+        return new YamlFile(`${dtt.getName()}.yaml`, yaml.dump(dtt.toSavedConfig()));
     }
     static createInfoYaml(rows, metadata) {
         const uniquePathSet = new Set(rows.flatMap((row) => row.paths));

package/dist/pages/DecaySearchPage.js

@@ -191,7 +191,7 @@ export function DecaySearchPage({ basePath }) {
                                 ? 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 (" +
+    return (_jsxs(_Fragment, { children: [_jsx("h3", { children: "Decay 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.js

@@ -21,7 +21,7 @@ import { useEffect, useState } from "react";
 export function DecayTreeConfigPage({ basePath }) {
     const navigate = useNavigate();
     const metadata = useMetadata();
-    const { rows, setRows } = useRows();
+    const { rows, updateRow } = 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(() => {
@@ -40,9 +40,7 @@ export function DecayTreeConfigPage({ basePath }) {
     }
     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);
-                                    });
+                                    updateRow(row.id, (r) => ({ ...r, dtt: new Dtt(newConfig, {}) }));
                                 }, onDirtyUpdated: (dttName, dirty) => setDirtyDtts((prev) => {
                                     if (dirty) {
                                         return new Set(prev.add(dttName));

package/dist/pages/RequestPage.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from "react";
+export type NtupleWizardVariant = "standalone" | "embedded";
+interface Props {
+    basePath: string;
+    submitLocation?: string;
+    requestReasonMessage?: string;
+    requestSubmittedMessage?: ReactNode;
+}
+export declare function RequestPage({ basePath, submitLocation, requestReasonMessage, requestSubmittedMessage }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/pages/RequestPage.js

@@ -0,0 +1,105 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } 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 yaml from "js-yaml";
+import { useEffect, useState } from "react";
+import { Alert, Button, Col, Row, Stack } from "react-bootstrap";
+import { Download, Send } from "react-bootstrap-icons";
+import { useLocation } from "react-router-dom";
+import { downloadZip, parseProductionFiles } 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 { RequestRow } from "../components/RequestRow";
+import { UploadDttConfigModal } from "../components/modals/UploadDttConfigModal";
+import { VARIABLES_PATH } from "../constants";
+import { ReasonForRequestModal } from "../components/modals/ReasonForRequestModal";
+import { RowProvider } from "../providers/RowProvider";
+import { ProductionNameInput } from "../components/ProductionNameInput";
+import { RequestEmailInput } from "../components/RequestEmailInput";
+import { RequestButtonGroup } from "../components/RequestButtonGroup";
+export function RequestPage({ basePath, submitLocation, requestReasonMessage, requestSubmittedMessage }) {
+    const location = useLocation();
+    const metadata = useMetadata();
+    const { rows, setRows, generateAllFiles } = useRows();
+    const { emailIsKnown, productionName, validation, showErrors, clearAll, trySubmit } = useRequest();
+    const [showProdUploadModal, setShowProdUploadModal] = useState(false);
+    const [prodUploadLoading, setProdUploadLoading] = useState(false);
+    const [requestSubmitted, setRequestSubmitted] = useState(false);
+    const [showReasonForRequestModal, setShowReasonForRequestModal] = useState(false);
+    const variant = submitLocation ? "embedded" : "standalone";
+    useEffect(() => {
+        if (!metadata) {
+            return;
+        }
+        const urlParams = new URLSearchParams(location.search);
+        if (urlParams.get("clone") === "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 handlePrimaryAction = async () => {
+        if (trySubmit()) {
+            if (variant === "standalone") {
+                const files = generateAllFiles();
+                await downloadZip(files, `${productionName}.zip`);
+            }
+            else {
+                setShowReasonForRequestModal(true);
+            }
+        }
+    };
+    if (!metadata) {
+        return _jsx(LoadingIndicator, { height: "70vh" });
+    }
+    if (requestSubmitted) {
+        return (_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] }) }) }));
+    }
+    return (_jsxs(_Fragment, { children: [showReasonForRequestModal && (_jsx(ReasonForRequestModal, { submitLocation: submitLocation, requestReasonMessage: requestReasonMessage, onClose: (submitted) => {
+                    setShowReasonForRequestModal(false);
+                    if (submitted) {
+                        setRequestSubmitted(true);
+                    }
+                } })), showProdUploadModal && _jsx(UploadDttConfigModal, { onClose: () => setShowProdUploadModal(false) }), _jsxs("div", { className: "d-flex flex-column gap-3", children: [rows.map((row) => (_jsx(RowProvider, { row: row, children: _jsx(RequestRow, { hideDownloadButtons: variant === "standalone", hideUploadButtons: variant === "standalone", variablesPath: VARIABLES_PATH }, row.id) }, row.id))), prodUploadLoading && _jsx(ConfigFilesUploadingAlert, {}), requestSubmitted && (_jsxs(Alert, { variant: "success", dismissible: true, onClose: () => setRequestSubmitted(false), children: [_jsx(Alert.Heading, { children: "Request submitted!" }), requestSubmittedMessage] })), showErrors &&
+                        (rows.length === 0 ||
+                            !validation.allRowsHaveDtt ||
+                            !validation.allRowsHaveStrippingLine ||
+                            !validation.allRowsHavePaths) && (_jsx(Alert, { variant: "danger", className: "mb-0", children: rows.length === 0
+                            ? "Please select at least one decay"
+                            : "Please name all DecayTreeTuples and select at least one stripping line and bookkeeping path for each decay" })), _jsx(Row, { children: _jsx(Col, { xs: "auto", children: _jsx(RequestButtonGroup, { variant: variant, basePath: basePath }) }) }), _jsx(Row, { children: _jsxs(Col, { xs: 4, children: [_jsx(ProductionNameInput, {}), !emailIsKnown && _jsx(RequestEmailInput, {}), _jsxs(Stack, { direction: "horizontal", gap: 1, className: "mt-3 mb-3", children: [_jsxs(Button, { className: "align-items-center d-flex gap-1", onClick: () => void handlePrimaryAction(), children: [variant === "standalone" ? _jsx(Download, {}) : _jsx(Send, {}), variant === "standalone" ? "Download" : "Submit"] }), _jsx(DeleteButton, { action: clearAll, disabled: validation.isEmptySession, outline: undefined, children: "Clear all" })] })] }) })] })] }));
+}

package/dist/providers/RequestProvider.d.ts

@@ -1,15 +1,28 @@
 import { ReactNode } from "react";
 interface RequestContextType {
+    emailIsKnown: boolean;
     productionName: string;
     setProductionName: (name: string) => void;
     contactEmails: string[];
     setContactEmails: (emails: string[]) => void;
     reasonForRequest: string;
     setReasonForRequest: (reason: string) => void;
+    validation: {
+        isEmptySession: boolean;
+        isEmailValid: boolean;
+        allRowsHaveDtt: boolean;
+        allRowsHaveStrippingLine: boolean;
+        allRowsHavePaths: boolean;
+        validDttNames: boolean;
+    };
+    showErrors: boolean;
+    clearAll: () => void;
+    trySubmit: () => boolean;
 }
 interface RequestProviderProps {
+    emailIsKnown: boolean;
     children: ReactNode;
 }
-export declare const RequestProvider: ({ children }: RequestProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const RequestProvider: ({ emailIsKnown, children }: RequestProviderProps) => import("react/jsx-runtime").JSX.Element;
 export declare const useRequest: () => RequestContextType;
 export {};

package/dist/providers/RequestProvider.js

@@ -1,10 +1,14 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useState } from "react";
+import { createContext, useContext, useMemo, useState } from "react";
+import EmailValidator from "email-validator";
+import { useRows } from "./RowsProvider";
 const RequestContext = createContext(null);
-export const RequestProvider = ({ children }) => {
+export const RequestProvider = ({ emailIsKnown, children }) => {
+    const { rows, configuredRows, setRows } = useRows();
     const [productionName, setProductionName] = useState(localStorage.getItem("name") || "");
     const [contactEmails, setContactEmails] = useState((localStorage.getItem("email") || "").split(/,/).filter((s) => s));
     const [reasonForRequest, setReasonForRequest] = useState(localStorage.getItem("reasonForRequest") || "");
+    const [hasTriedSubmit, setHasTriedSubmit] = useState(false);
     const updateProductionName = (newProductionName) => {
         setProductionName(newProductionName);
         localStorage.setItem("name", newProductionName);
@@ -17,13 +21,55 @@ export const RequestProvider = ({ children }) => {
         setReasonForRequest(newReasonForRequest);
         localStorage.setItem("reasonForRequest", newReasonForRequest);
     };
+    const clearAll = () => {
+        setProductionName("");
+        setContactEmails([]);
+        setReasonForRequest("");
+        setRows([]);
+        setHasTriedSubmit(false);
+    };
+    const trySubmit = () => {
+        setHasTriedSubmit(true);
+        return canSubmit;
+    };
+    const validation = useMemo(() => {
+        const isEmptySession = !productionName && contactEmails.length === 0 && rows.length === 0;
+        const isEmailValid = contactEmails.length > 0 && contactEmails.every(EmailValidator.validate);
+        const allRowsHaveDtt = configuredRows.length > 0 && configuredRows.length === rows.length;
+        const allRowsHaveStrippingLine = rows.every((r) => r.lines.length > 0);
+        const allRowsHavePaths = rows.every((r) => r.paths.length > 0);
+        const dttNames = configuredRows.map((r) => r.dtt.getName().trim());
+        const validDttNames = dttNames.every(Boolean) && new Set(dttNames).size === dttNames.length;
+        return {
+            isEmptySession,
+            isEmailValid,
+            allRowsHaveDtt,
+            allRowsHaveStrippingLine,
+            allRowsHavePaths,
+            validDttNames,
+        };
+    }, [rows, configuredRows, productionName, contactEmails]);
+    const canSubmit = [
+        validation.allRowsHaveDtt,
+        validation.allRowsHaveStrippingLine,
+        validation.allRowsHavePaths,
+        Boolean(productionName),
+        emailIsKnown || validation.isEmailValid,
+        validation.validDttNames,
+    ].every(Boolean);
+    const showErrors = hasTriedSubmit && !canSubmit;
     return (_jsx(RequestContext.Provider, { value: {
+            emailIsKnown,
             productionName,
             setProductionName: updateProductionName,
             contactEmails,
             setContactEmails: updateContactEmails,
             reasonForRequest,
             setReasonForRequest: updateReasonForRequest,
+            validation,
+            showErrors,
+            clearAll,
+            trySubmit,
         }, children: children }));
 };
 export const useRequest = () => {

package/dist/providers/RowProvider.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from "react";
+import { RowData } from "../models/rowData";
+import { StrippingLine } from "../models/strippingLine";
+interface RowContextType {
+    row: RowData;
+    validateBkPath: (choice: string, lines?: StrippingLine[]) => boolean;
+    updateBkPaths: (paths: string[], lines?: StrippingLine[]) => void;
+}
+interface RowProviderProps {
+    row: RowData;
+    children: ReactNode;
+}
+export declare const RowProvider: ({ row, children }: RowProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useRow: () => RowContextType;
+export {};

package/dist/providers/RowProvider.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext } from "react";
+import { BkPath } from "../models/bkPath";
+import { useRows } from "./RowsProvider";
+const RowContext = createContext(null);
+export const RowProvider = ({ row, children }) => {
+    const { updateRow } = useRows();
+    const validateBkPathsForLines = useCallback((choice, lines = row.lines) => {
+        try {
+            const path = new BkPath(choice);
+            return lines.every((line) => {
+                const streamName = line.stream.toLowerCase();
+                const fileName = path.fileName.split(".")[0].toLowerCase();
+                const matchingVersion = line.versions.some((v) => path.strippingVersion === v);
+                return ["allstreams", streamName].includes(fileName) && matchingVersion;
+            });
+        }
+        catch {
+            return false;
+        }
+    }, [row.lines]);
+    const updateBkPathsForLines = useCallback((paths, lines = row.lines) => {
+        updateRow(row.id, (r) => ({
+            ...r,
+            paths: paths.filter((p) => validateBkPathsForLines(p, lines)),
+            pathOptions: r.pathOptions.filter((p) => validateBkPathsForLines(p, lines)),
+        }));
+    }, [row.id, validateBkPathsForLines, updateRow]);
+    return (_jsx(RowContext.Provider, { value: {
+            row,
+            validateBkPath: validateBkPathsForLines,
+            updateBkPaths: updateBkPathsForLines,
+        }, children: children }));
+};
+export const useRow = () => {
+    const ctx = useContext(RowContext);
+    if (!ctx) {
+        throw new Error("useRow must be used within a RowProvider");
+    }
+    return ctx;
+};

package/dist/providers/RowsProvider.d.ts

@@ -1,9 +1,12 @@
 import { Dispatch, ReactNode, SetStateAction } from "react";
-import { RowData } from "../models/rowData.js";
+import { ConfiguredRow, RowData } from "../models/rowData.js";
 import { YamlFile } from "../models/yamlFile";
 interface RowsContextType {
     rows: RowData[];
+    configuredRows: ConfiguredRow[];
     setRows: Dispatch<SetStateAction<RowData[]>>;
+    updateRow: (id: number, update: (row: RowData) => RowData) => void;
+    removeRow: (id: number) => void;
     generateAllFiles: () => YamlFile[];
 }
 interface Props {

package/dist/providers/RowsProvider.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useEffect, useState } from "react";
+import { createContext, useContext, useEffect, useMemo, useState } from "react";
 import Dtt from "../models/dtt";
 import { useMetadata } from "./MetadataProvider";
 import { YamlFile } from "../models/yamlFile";
@@ -11,6 +11,12 @@ export const RowsProvider = ({ children }) => {
     useEffect(() => {
         localStorage.setItem("rows", JSON.stringify(rows));
     }, [rows]);
+    const updateRow = (id, update) => {
+        setRows((prev) => prev.map((r) => (r.id === id ? update(r) : r)));
+    };
+    const removeRow = (id) => {
+        setRows((prev) => prev.filter((r) => r.id !== id));
+    };
     const generateAllFiles = () => {
         if (!metadata) {
             return [];
@@ -20,7 +26,8 @@ export const RowsProvider = ({ children }) => {
             YamlFile.createInfoYaml(rows, metadata),
         ];
     };
-    return _jsx(RowsContext.Provider, { value: { rows, setRows, generateAllFiles }, children: children });
+    const configuredRows = useMemo(() => rows.filter((r) => !!r.dtt), [rows]);
+    return (_jsx(RowsContext.Provider, { value: { rows, configuredRows, setRows, updateRow, removeRow, generateAllFiles }, children: children }));
 };
 export const useRows = () => {
     const context = useContext(RowsContext);

package/dist/utils/utils.d.ts

@@ -1,4 +1,19 @@
 import { YamlFile } from "../models/yamlFile";
+import { BlobFile } from "../models/blobFile";
+import { RowData } from "../models/rowData";
+import { MetadataContext } from "../providers/MetadataProvider";
+/**
+ * Parses a set of production configuration files to DttConfigs and returns the corresponding rows and emails.
+ * @param files The files to parse
+ * @param metadata The metadata to use for parsing
+ * @returns The parsed rows and emails
+ */
+export declare const parseProductionFiles: (files: (BlobFile | File)[], metadata: MetadataContext) => Promise<{
+    rows: RowData[];
+    emails: string[];
+    errors: Record<string, string>;
+    warnings: Record<string, string>;
+}>;
 /**
  * Sanitizes a user-provided filename to prevent path traversal (Zip Slip)
  * and unsafe filesystem characters.