lhcb-ntuple-wizard 2.0.1 → 2.0.3

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,15 @@
-import { YamlFile } from "../models/yamlFile";
+import { InfoYaml, YamlFile } from "../models/yamlFile";
+import { SavedDttConfig } from "../models/dtt";
+import { RowData } from "../models/rowData";
+import { MetadataContext } from "../providers/MetadataProvider";
+export declare function parseProductionFiles(files: File[], metadata: MetadataContext): Promise<string | {
+    rows: RowData[];
+    emails: string[];
+}>;
+export declare function processProductionFiles(metadata: MetadataContext, configs: SavedDttConfig[], infoYaml: InfoYaml | null): string | {
+    rows: RowData[];
+    emails: string[];
+};
 /**
  * Sanitizes a user-provided filename to prevent path traversal (Zip Slip)
  * and unsafe filesystem characters.

package/dist/utils/utils.js

@@ -1,3 +1,5 @@
+import * as __typia_transform__accessExpressionAsString from "typia/lib/internal/_accessExpressionAsString.js";
+import * as __typia_transform__validateReport from "typia/lib/internal/_validateReport.js";
 /*****************************************************************************\
  * (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration           *
  *                                                                             *
@@ -9,6 +11,537 @@
  * or submit itself to any jurisdiction.                                       *
  \*****************************************************************************/
 import JsZip from "jszip";
+import yaml from "js-yaml";
+import Dtt from "../models/dtt";
+import typia from "typia";
+const parseInput = (decay, input) => {
+    const [, , stream, , lineName] = input.split("/");
+    const line = `Stripping${lineName}`;
+    return {
+        stream,
+        line,
+        versions: decay.lines[`${stream}/${line}`],
+    };
+};
+const addBkPathsToRows = (infoYaml, rows) => {
+    for (const row of rows) {
+        if (!row.dtt?.config.name) {
+            continue;
+        }
+        const dttName = row.dtt.config.name.split("/")[1];
+        for (const [key, jobConfig] of Object.entries(infoYaml)) {
+            if (key === "defaults") {
+                continue;
+            }
+            const job = jobConfig;
+            if (job.options.some((option) => option.split(".")[0] === dttName)) {
+                row.paths.push(job.input.bk_query);
+            }
+        }
+    }
+};
+async function parseYamlFile(file) {
+    const text = await file.text();
+    try {
+        return yaml.load(text, { schema: yaml.JSON_SCHEMA });
+    }
+    catch (e) {
+        console.error(`YAML file '${file.name}' is invalid:`, e);
+        return null;
+    }
+}
+async function parseInfoYamlFile(file) {
+    const rawConfig = await parseYamlFile(file);
+    if (!rawConfig) {
+        return "'info.yaml' is not a valid yaml file";
+    }
+    const validationResult = (() => { const _io0 = input => "object" === typeof input.defaults && null !== input.defaults && _io1(input.defaults) && Object.keys(input).every(key => {
+        if (["defaults"].some(prop => key === prop))
+            return true;
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return undefined === value || "object" === typeof value && null !== value && _io2(value);
+    }); const _io1 = input => "string" === typeof input.application && "string" === typeof input.wg && (Array.isArray(input.inform) && input.inform.every(elem => "string" === typeof elem)) && "boolean" === typeof input.automatically_configure && "string" === typeof input.output; const _io2 = input => Array.isArray(input.options) && input.options.every(elem => "string" === typeof elem) && ("object" === typeof input.input && null !== input.input && _io3(input.input)) && (undefined === input.root_in_tes || "string" === typeof input.root_in_tes); const _io3 = input => "string" === typeof input.bk_query; const _vo0 = (input, _path, _exceptionable = true) => [("object" === typeof input.defaults && null !== input.defaults || _report(_exceptionable, {
+            path: _path + ".defaults",
+            expected: "InfoYamlDefaults",
+            value: input.defaults
+        })) && _vo1(input.defaults, _path + ".defaults", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".defaults",
+            expected: "InfoYamlDefaults",
+            value: input.defaults
+        }), false === _exceptionable || Object.keys(input).map(key => {
+            if (["defaults"].some(prop => key === prop))
+                return true;
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return undefined === value || ("object" === typeof value && null !== value || _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                expected: "(JobConfig | undefined)",
+                value: value
+            })) && _vo2(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                expected: "(JobConfig | undefined)",
+                value: value
+            });
+        }).every(flag => flag)].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["string" === typeof input.application || _report(_exceptionable, {
+            path: _path + ".application",
+            expected: "string",
+            value: input.application
+        }), "string" === typeof input.wg || _report(_exceptionable, {
+            path: _path + ".wg",
+            expected: "string",
+            value: input.wg
+        }), (Array.isArray(input.inform) || _report(_exceptionable, {
+            path: _path + ".inform",
+            expected: "Array<string>",
+            value: input.inform
+        })) && input.inform.map((elem, _index3) => "string" === typeof elem || _report(_exceptionable, {
+            path: _path + ".inform[" + _index3 + "]",
+            expected: "string",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".inform",
+            expected: "Array<string>",
+            value: input.inform
+        }), "boolean" === typeof input.automatically_configure || _report(_exceptionable, {
+            path: _path + ".automatically_configure",
+            expected: "boolean",
+            value: input.automatically_configure
+        }), "string" === typeof input.output || _report(_exceptionable, {
+            path: _path + ".output",
+            expected: "string",
+            value: input.output
+        })].every(flag => flag); const _vo2 = (input, _path, _exceptionable = true) => [(Array.isArray(input.options) || _report(_exceptionable, {
+            path: _path + ".options",
+            expected: "Array<string>",
+            value: input.options
+        })) && input.options.map((elem, _index4) => "string" === typeof elem || _report(_exceptionable, {
+            path: _path + ".options[" + _index4 + "]",
+            expected: "string",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".options",
+            expected: "Array<string>",
+            value: input.options
+        }), ("object" === typeof input.input && null !== input.input || _report(_exceptionable, {
+            path: _path + ".input",
+            expected: "__type",
+            value: input.input
+        })) && _vo3(input.input, _path + ".input", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".input",
+            expected: "__type",
+            value: input.input
+        }), undefined === input.root_in_tes || "string" === typeof input.root_in_tes || _report(_exceptionable, {
+            path: _path + ".root_in_tes",
+            expected: "(string | undefined)",
+            value: input.root_in_tes
+        })].every(flag => flag); const _vo3 = (input, _path, _exceptionable = true) => ["string" === typeof input.bk_query || _report(_exceptionable, {
+            path: _path + ".bk_query",
+            expected: "string",
+            value: input.bk_query
+        })].every(flag => flag); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
+        if (false === __is(input)) {
+            errors = [];
+            _report = __typia_transform__validateReport._validateReport(errors);
+            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                path: _path + "",
+                expected: "InfoYaml",
+                value: input
+            })) && _vo0(input, _path + "", true) || _report(true, {
+                path: _path + "",
+                expected: "InfoYaml",
+                value: input
+            }))(input, "$input", true);
+            const success = 0 === errors.length;
+            return success ? {
+                success,
+                data: input
+            } : {
+                success,
+                errors,
+                data: input
+            };
+        }
+        return {
+            success: true,
+            data: input
+        };
+    }; })()(rawConfig);
+    if (!validationResult.success) {
+        return "'info.yaml' does not have the expected structure";
+    }
+    return validationResult.data;
+}
+async function parseDttConfigFile(file) {
+    const rawConfig = await parseYamlFile(file);
+    if (!rawConfig) {
+        return `'${file.name}' is not a valid yaml file`;
+    }
+    const validationResult = (() => { const _ip0 = input => {
+        const array = input;
+        const top = input[0];
+        if (0 === input.length)
+            return true;
+        const arrayPredicators = [
+            [
+                top => "string" === typeof top,
+                entire => entire.every(elem => "string" === typeof elem)
+            ],
+            [
+                top => "number" === typeof top,
+                entire => entire.every(elem => "number" === typeof elem)
+            ]
+        ];
+        const passed = arrayPredicators.filter(pred => pred[0](top));
+        if (1 === passed.length)
+            return passed[0][1](array);
+        else if (1 < passed.length)
+            for (const pred of passed)
+                if (array.every(value => true === pred[0](value)))
+                    return pred[1](array);
+        return false;
+    }; const _vp1 = (input, _path, _exceptionable = true) => {
+        const array = input;
+        const top = input[0];
+        if (0 === input.length)
+            return true;
+        const arrayPredicators = [
+            [
+                top => "string" === typeof top,
+                entire => entire.map((elem, _index16) => "string" === typeof elem || _report(_exceptionable, {
+                    path: _path + "[" + _index16 + "]",
+                    expected: "string",
+                    value: elem
+                })).every(flag => flag)
+            ],
+            [
+                top => "number" === typeof top,
+                entire => entire.map((elem, _index17) => "number" === typeof elem || _report(_exceptionable, {
+                    path: _path + "[" + _index17 + "]",
+                    expected: "number",
+                    value: elem
+                })).every(flag => flag)
+            ]
+        ];
+        const passed = arrayPredicators.filter(pred => pred[0](top));
+        if (1 === passed.length)
+            return passed[0][1](array);
+        else if (1 < passed.length)
+            for (const pred of passed)
+                if (array.every(value => true === pred[0](value)))
+                    return pred[1](array);
+        return _report(_exceptionable, {
+            path: _path,
+            expected: "(Array<string> | Array<number>)",
+            value: input
+        });
+    }; const _io0 = input => "object" === typeof input.branches && null !== input.branches && false === Array.isArray(input.branches) && _io1(input.branches) && (undefined === input.descriptorTemplate || "string" === typeof input.descriptorTemplate) && ("object" === typeof input.groups && null !== input.groups && false === Array.isArray(input.groups) && _io7(input.groups)) && (undefined === input.inputs || Array.isArray(input.inputs) && input.inputs.every(elem => "string" === typeof elem)) && (undefined === input.name || "string" === typeof input.name) && (Array.isArray(input.tools) && input.tools.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _io3(elem))); const _io1 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return "object" === typeof value && null !== value && _io2(value);
+    }); const _io2 = input => "string" === typeof input.particle && (Array.isArray(input.tools) && input.tools.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _io3(elem))); const _io3 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return "object" === typeof value && null !== value && false === Array.isArray(value) && _io4(value);
+    }); const _io4 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return null !== value && undefined !== value && ("string" === typeof value || "number" === typeof value || "boolean" === typeof value || (Array.isArray(value) && (_ip0(value) || false) || "object" === typeof value && null !== value && false === Array.isArray(value) && _iu0(value)));
+    }); const _io5 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return "string" === typeof value;
+    }); const _io6 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return Array.isArray(value) && value.every(elem => "string" === typeof elem);
+    }); const _io7 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return "object" === typeof value && null !== value && _io8(value);
+    }); const _io8 = input => Array.isArray(input.particles) && input.particles.every(elem => "string" === typeof elem) && (Array.isArray(input.tools) && input.tools.every(elem => "object" === typeof elem && null !== elem && false === Array.isArray(elem) && _io3(elem))); const _iu0 = input => (() => {
+        if (_io6(input))
+            return _io6(input);
+        if (_io5(input))
+            return _io5(input);
+        return false;
+    })(); const _vo0 = (input, _path, _exceptionable = true) => [("object" === typeof input.branches && null !== input.branches && false === Array.isArray(input.branches) || _report(_exceptionable, {
+            path: _path + ".branches",
+            expected: "__type",
+            value: input.branches
+        })) && _vo1(input.branches, _path + ".branches", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".branches",
+            expected: "__type",
+            value: input.branches
+        }), undefined === input.descriptorTemplate || "string" === typeof input.descriptorTemplate || _report(_exceptionable, {
+            path: _path + ".descriptorTemplate",
+            expected: "(string | undefined)",
+            value: input.descriptorTemplate
+        }), ("object" === typeof input.groups && null !== input.groups && false === Array.isArray(input.groups) || _report(_exceptionable, {
+            path: _path + ".groups",
+            expected: "__type.o4",
+            value: input.groups
+        })) && _vo7(input.groups, _path + ".groups", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".groups",
+            expected: "__type.o4",
+            value: input.groups
+        }), undefined === input.inputs || (Array.isArray(input.inputs) || _report(_exceptionable, {
+            path: _path + ".inputs",
+            expected: "(Array<string> | undefined)",
+            value: input.inputs
+        })) && input.inputs.map((elem, _index11) => "string" === typeof elem || _report(_exceptionable, {
+            path: _path + ".inputs[" + _index11 + "]",
+            expected: "string",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".inputs",
+            expected: "(Array<string> | undefined)",
+            value: input.inputs
+        }), undefined === input.name || "string" === typeof input.name || _report(_exceptionable, {
+            path: _path + ".name",
+            expected: "(string | undefined)",
+            value: input.name
+        }), (Array.isArray(input.tools) || _report(_exceptionable, {
+            path: _path + ".tools",
+            expected: "Array<SavedToolConfig>",
+            value: input.tools
+        })) && input.tools.map((elem, _index12) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || _report(_exceptionable, {
+            path: _path + ".tools[" + _index12 + "]",
+            expected: "SavedToolConfig",
+            value: elem
+        })) && _vo3(elem, _path + ".tools[" + _index12 + "]", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".tools[" + _index12 + "]",
+            expected: "SavedToolConfig",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".tools",
+            expected: "Array<SavedToolConfig>",
+            value: input.tools
+        })].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => [false === _exceptionable || Object.keys(input).map(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return ("object" === typeof value && null !== value || _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                expected: "SavedBranchConfig",
+                value: value
+            })) && _vo2(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                expected: "SavedBranchConfig",
+                value: value
+            });
+        }).every(flag => flag)].every(flag => flag); const _vo2 = (input, _path, _exceptionable = true) => ["string" === typeof input.particle || _report(_exceptionable, {
+            path: _path + ".particle",
+            expected: "string",
+            value: input.particle
+        }), (Array.isArray(input.tools) || _report(_exceptionable, {
+            path: _path + ".tools",
+            expected: "Array<SavedToolConfig>",
+            value: input.tools
+        })) && input.tools.map((elem, _index13) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || _report(_exceptionable, {
+            path: _path + ".tools[" + _index13 + "]",
+            expected: "SavedToolConfig",
+            value: elem
+        })) && _vo3(elem, _path + ".tools[" + _index13 + "]", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".tools[" + _index13 + "]",
+            expected: "SavedToolConfig",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".tools",
+            expected: "Array<SavedToolConfig>",
+            value: input.tools
+        })].every(flag => flag); const _vo3 = (input, _path, _exceptionable = true) => [false === _exceptionable || Object.keys(input).map(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return ("object" === typeof value && null !== value && false === Array.isArray(value) || _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                expected: "__type.o1",
+                value: value
+            })) && _vo4(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                expected: "__type.o1",
+                value: value
+            });
+        }).every(flag => flag)].every(flag => flag); const _vo4 = (input, _path, _exceptionable = true) => [false === _exceptionable || Object.keys(input).map(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return (null !== value || _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                expected: "(Array<number> | Array<string> | __type.o2 | __type.o3 | boolean | number | string)",
+                value: value
+            })) && (undefined !== value || _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                expected: "(Array<number> | Array<string> | __type.o2 | __type.o3 | boolean | number | string)",
+                value: value
+            })) && ("string" === typeof value || "number" === typeof value || "boolean" === typeof value || (Array.isArray(value) && (_vp1(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                expected: "Array<string> | Array<number>",
+                value: value
+            })) || "object" === typeof value && null !== value && false === Array.isArray(value) && _vu0(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                expected: "(Array<number> | Array<string> | __type.o2 | __type.o3 | boolean | number | string)",
+                value: value
+            })) || _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                expected: "(Array<number> | Array<string> | __type.o2 | __type.o3 | boolean | number | string)",
+                value: value
+            }));
+        }).every(flag => flag)].every(flag => flag); const _vo5 = (input, _path, _exceptionable = true) => [false === _exceptionable || Object.keys(input).map(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return "string" === typeof value || _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                expected: "string",
+                value: value
+            });
+        }).every(flag => flag)].every(flag => flag); const _vo6 = (input, _path, _exceptionable = true) => [false === _exceptionable || Object.keys(input).map(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return (Array.isArray(value) || _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                expected: "Array<string>",
+                value: value
+            })) && value.map((elem, _index18) => "string" === typeof elem || _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key) + "[" + _index18 + "]",
+                expected: "string",
+                value: elem
+            })).every(flag => flag) || _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                expected: "Array<string>",
+                value: value
+            });
+        }).every(flag => flag)].every(flag => flag); const _vo7 = (input, _path, _exceptionable = true) => [false === _exceptionable || Object.keys(input).map(key => {
+            const value = input[key];
+            if (undefined === value)
+                return true;
+            return ("object" === typeof value && null !== value || _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                expected: "SavedGroupConfig",
+                value: value
+            })) && _vo8(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || _report(_exceptionable, {
+                path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                expected: "SavedGroupConfig",
+                value: value
+            });
+        }).every(flag => flag)].every(flag => flag); const _vo8 = (input, _path, _exceptionable = true) => [(Array.isArray(input.particles) || _report(_exceptionable, {
+            path: _path + ".particles",
+            expected: "Array<string>",
+            value: input.particles
+        })) && input.particles.map((elem, _index19) => "string" === typeof elem || _report(_exceptionable, {
+            path: _path + ".particles[" + _index19 + "]",
+            expected: "string",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".particles",
+            expected: "Array<string>",
+            value: input.particles
+        }), (Array.isArray(input.tools) || _report(_exceptionable, {
+            path: _path + ".tools",
+            expected: "Array<SavedToolConfig>",
+            value: input.tools
+        })) && input.tools.map((elem, _index20) => ("object" === typeof elem && null !== elem && false === Array.isArray(elem) || _report(_exceptionable, {
+            path: _path + ".tools[" + _index20 + "]",
+            expected: "SavedToolConfig",
+            value: elem
+        })) && _vo3(elem, _path + ".tools[" + _index20 + "]", true && _exceptionable) || _report(_exceptionable, {
+            path: _path + ".tools[" + _index20 + "]",
+            expected: "SavedToolConfig",
+            value: elem
+        })).every(flag => flag) || _report(_exceptionable, {
+            path: _path + ".tools",
+            expected: "Array<SavedToolConfig>",
+            value: input.tools
+        })].every(flag => flag); const _vu0 = (input, _path, _exceptionable = true) => _vo6(input, _path, false && _exceptionable) || _vo5(input, _path, false && _exceptionable); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
+        if (false === __is(input)) {
+            errors = [];
+            _report = __typia_transform__validateReport._validateReport(errors);
+            ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+                path: _path + "",
+                expected: "SavedDttConfig",
+                value: input
+            })) && _vo0(input, _path + "", true) || _report(true, {
+                path: _path + "",
+                expected: "SavedDttConfig",
+                value: input
+            }))(input, "$input", true);
+            const success = 0 === errors.length;
+            return success ? {
+                success,
+                data: input
+            } : {
+                success,
+                errors,
+                data: input
+            };
+        }
+        return {
+            success: true,
+            data: input
+        };
+    }; })()(rawConfig);
+    if (!validationResult.success) {
+        return `'${file.name}' does not have the expected structure`;
+    }
+    return validationResult.data;
+}
+export async function parseProductionFiles(files, metadata) {
+    const infoYamlFile = files.find((f) => f.name === "info.yaml");
+    const infoYamlResult = infoYamlFile ? await parseInfoYamlFile(infoYamlFile) : null;
+    if (typeof infoYamlResult === "string") {
+        // The info.yaml is invalid
+        return infoYamlResult;
+    }
+    const dttConfigFiles = files.filter((f) => f.name !== "info.yaml");
+    const dttConfigPromises = dttConfigFiles.map((f) => parseDttConfigFile(f));
+    const dttConfigResults = await Promise.all(dttConfigPromises);
+    const dttConfigErrors = dttConfigResults.filter((r) => typeof r === "string");
+    if (dttConfigErrors.length > 0) {
+        // One of the DTT config files is invalid
+        return dttConfigErrors.join("\n");
+    }
+    return processProductionFiles(metadata, dttConfigResults, infoYamlResult);
+}
+export function processProductionFiles(metadata, configs, infoYaml) {
+    const rows = [];
+    const emailsToInform = [];
+    for (const config of configs) {
+        const decay = Object.values(metadata.decays).find((d) => d.descriptors.template === config.descriptorTemplate);
+        if (!decay) {
+            return `[${config.name}] Unknown decay '${config.descriptorTemplate}'`;
+        }
+        if (!config.inputs) {
+            return `[${config.name}] No inputs defined`;
+        }
+        rows.push({
+            id: rows.length,
+            decay,
+            lines: config.inputs.map((input) => parseInput(decay, input)),
+            paths: [],
+            pathOptions: [],
+            dtt: Dtt.fromSavedConfig(config, metadata.tupleTools.tupleTools),
+        });
+    }
+    if (infoYaml) {
+        const email = infoYaml.defaults.inform[0];
+        if (email) {
+            emailsToInform.push(email);
+        }
+        addBkPathsToRows(infoYaml, rows);
+    }
+    return { rows, emails: emailsToInform };
+}
 /**
  * Sanitizes a user-provided filename to prevent path traversal (Zip Slip)
  * and unsafe filesystem characters.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lhcb-ntuple-wizard",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "An application to access large-scale open data from LHCb",
   "url": "https://gitlab.cern.ch/lhcb-dpa/wp6-analysis-preservation-and-open-data/lhcb-ntuple-wizard-frontend/issues",
   "private": false,
@@ -31,7 +31,8 @@
     "react-bootstrap-icons": "1.11.6",
     "react-graph-vis": "1.0.7",
     "react-infinite-scroll-component": "^6.1.1",
-    "react-select": "5.10.2"
+    "react-select": "5.10.2",
+    "typia": "^11.0.3"
   },
   "peerDependencies": {
     "react": ">=19",
@@ -44,7 +45,8 @@
   "scripts": {
     "start": "vite --open",
     "build": "tsc",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "prepare": "ts-patch install"
   },
   "browserslist": {
     "production": [
@@ -66,6 +68,7 @@
     "@babel/preset-env": "7.28.3",
     "@babel/preset-react": "7.27.1",
     "@eslint/js": "^9.17.0",
+    "@kennethwkz/unplugin-typia": "^2.6.7",
     "@types/jest": "^30.0.0",
     "@types/js-yaml": "^4.0.9",
     "@types/lodash": "^4.17.21",
@@ -84,7 +87,8 @@
     "react": "^19.2.3",
     "react-dom": "^19.2.3",
     "react-router-dom": "^7.12.0",
-    "typescript": "^5.9.3",
+    "ts-patch": "^3.3.0",
+    "typescript": "~5.9.3",
     "vite": "7.3.0",
     "vite-tsconfig-paths": "^6.0.3"
   }

package/dist/components/LineTableRow.d.ts

@@ -1,9 +0,0 @@
-import { RowData } from "../models/rowData";
-interface Props {
-    row: RowData;
-    hideDownloadButtons: boolean;
-    hideUploadButtons: boolean;
-    variablesPath: string;
-}
-export declare function LineTableRow({ row, hideDownloadButtons, hideUploadButtons, variablesPath }: Props): import("react/jsx-runtime").JSX.Element | null;
-export {};