lhcb-ntuple-wizard-test 2.2.2 → 2.3.0

package/dist/components/DropdownOptionWithDesc.d.ts

@@ -0,0 +1,7 @@
+import { OptionProps } from "react-select";
+export interface SelectOption {
+    value: string;
+    label: string;
+    description?: string;
+}
+export declare function DropdownOptionWithDesc({ data, innerRef, innerProps, isFocused, isSelected }: OptionProps<SelectOption>): import("react/jsx-runtime").JSX.Element;

package/dist/components/DropdownOptionWithDesc.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export function DropdownOptionWithDesc({ data, innerRef, innerProps, isFocused, isSelected }) {
+    return (_jsxs("div", { ref: innerRef, ...innerProps, style: {
+            backgroundColor: isSelected ? "#0d6efd" : isFocused ? "#e9ecef" : "white",
+            color: isSelected ? "white" : "inherit",
+            padding: "6px 12px",
+            cursor: "pointer",
+        }, children: [data.label, isFocused && data.description && (_jsx("div", { style: {
+                    fontSize: "0.75em",
+                    color: isSelected ? "rgba(255,255,255,0.75)" : "#6c757d",
+                    marginTop: 2,
+                    whiteSpace: "normal",
+                    lineHeight: 1.3,
+                }, children: data.description }))] }));
+}

package/dist/components/TupleToolClassDropdown.d.ts

@@ -1,18 +1,3 @@
-/*****************************************************************************\
- * (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 { GroupBase, Props as SelectProps } from "react-select";
-import { ReactNode } from "react";
-type ToolDropdownOption = {
-    value: string;
-    label: ReactNode;
-};
-export declare function TupleToolClassDropdown(props: SelectProps<ToolDropdownOption, false, GroupBase<ToolDropdownOption>>): import("react/jsx-runtime").JSX.Element;
-export {};
+import { SelectOption } from "./DropdownOptionWithDesc";
+export declare function TupleToolClassDropdown(props: SelectProps<SelectOption, false, GroupBase<SelectOption>>): import("react/jsx-runtime").JSX.Element;

package/dist/components/TupleToolClassDropdown.js

@@ -9,24 +9,75 @@ import { jsx as _jsx } from "react/jsx-runtime";
  * granted to it by virtue of its status as an Intergovernmental Organization  *
  * or submit itself to any jurisdiction.                                       *
  \*****************************************************************************/
+import { useDeferredValue, useMemo, useState } from "react";
 import Select from "react-select";
+import Fuse from "fuse.js";
 import { useMetadata } from "../providers/MetadataProvider.js";
 import { TupleTool } from "../models/tupleTool";
 import { useDtt } from "../providers/DttProvider";
 import { config } from "../config";
+import { DropdownOptionWithDesc } from "./DropdownOptionWithDesc";
+function flattenVariableEntries(vars) {
+    const entries = [];
+    for (const [key, value] of Object.entries(vars)) {
+        if (typeof value === "string") {
+            entries.push(value ? `${key}: ${value}` : key);
+        }
+        else if (value !== null && typeof value === "object") {
+            entries.push(...flattenVariableEntries(value));
+        }
+    }
+    return entries;
+}
 export function TupleToolClassDropdown(props) {
     const metadata = useMetadata();
     const { selectedBranch } = useDtt();
-    const allowedTags = ["IParticleTupleTool", ...(selectedBranch.length === 0 ? ["IEventTupleTool"] : [])];
-    // Group tools by tag
-    const options = allowedTags.map((allowedTag) => ({
-        label: allowedTag,
-        options: Object.keys(metadata.tupleTools.tupleTools)
-            .sort()
-            .map(TupleTool.fromString)
-            .map((tool) => ({ value: tool.toString(), label: tool.class }))
-            .filter((tool) => metadata.tupleTools.tupleTools[tool.value].tags.includes(allowedTag) &&
-            !config.disabledTupleTools.includes(tool.value)),
-    }));
-    return (_jsx("div", { className: "react-select form-control p-0", children: _jsx(Select, { placeholder: "TupleTool class", options: options, ...props }) }));
+    const [inputValue, setInputValue] = useState("");
+    const deferredInput = useDeferredValue(inputValue);
+    const allowedTags = useMemo(() => ["IParticleTupleTool", ...(selectedBranch.length === 0 ? ["IEventTupleTool"] : [])], [selectedBranch.length]);
+    const allTools = useMemo(() => Object.keys(metadata.tupleTools.tupleTools)
+        .sort()
+        .map(TupleTool.fromString)
+        .map((tool) => ({
+        value: tool.toString(),
+        label: tool.class,
+        description: metadata.tupleTools.tupleTools[tool.toString()].description,
+        variables: metadata.kgdoc[tool.class]
+            ? flattenVariableEntries(metadata.kgdoc[tool.class].variables)
+            : [],
+    }))
+        .filter((tool) => metadata.tupleTools.tupleTools[tool.value].tags.some((tag) => allowedTags.includes(tag)) &&
+        !config.disabledTupleTools.includes(tool.value)), [metadata, allowedTags]);
+    const groupedOptions = useMemo(() => allowedTags.map((tag) => ({
+        label: tag,
+        options: allTools.filter((tool) => metadata.tupleTools.tupleTools[tool.value].tags.includes(tag)),
+    })), [allTools, allowedTags, metadata]);
+    const fuse = useMemo(() => new Fuse(allTools, {
+        keys: [
+            { name: "label", weight: 2 },
+            { name: "description", weight: 1 },
+            { name: "variables", weight: 0.5 },
+        ],
+        includeMatches: true,
+        threshold: 0.4,
+        minMatchCharLength: 2,
+        shouldSort: true,
+    }), [allTools]);
+    const displayOptions = useMemo(() => {
+        if (!deferredInput)
+            return groupedOptions;
+        return fuse.search(deferredInput, { limit: 50 }).map((r) => {
+            const matchedVars = (r.matches ?? [])
+                .filter((m) => m.key === "variables")
+                .map((m) => m.value)
+                .filter(Boolean)
+                .join(", ");
+            return matchedVars ? { ...r.item, description: matchedVars } : r.item;
+        });
+    }, [deferredInput, fuse, groupedOptions]);
+    return (_jsx("div", { className: "react-select form-control p-0", children: _jsx(Select, { placeholder: "Search by name, description, or variables...", styles: { control: (base) => ({ ...base, border: 0, boxShadow: "none" }) }, ...props, options: displayOptions, inputValue: inputValue, onInputChange: (val, { action }) => {
+                if (action !== "input-blur" && action !== "menu-close") {
+                    setInputValue(val);
+                }
+            }, filterOption: () => true, components: { Option: DropdownOptionWithDesc } }) }));
 }

package/dist/components/modals/AddTupleToolModal.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Button, ButtonGroup, FormControl, Modal } from "react-bootstrap";
+import { Button, ButtonGroup, Form, FormControl, Modal } from "react-bootstrap";
 import { TupleToolClassDropdown } from "../TupleToolClassDropdown";
 import { TupleToolDocsAccordion } from "../TupleToolDocsAccordion";
 import { useDtt } from "../../providers/DttProvider";
@@ -13,20 +13,25 @@ export function AddTupleToolModal({ onClose }) {
     useEffect(() => {
         nameInputRef.current?.focus();
     }, [selectedTool]);
-    return (_jsxs(Modal, { show: true, onHide: () => onClose(null), size: "lg", children: [_jsx(Modal.Header, { closeButton: true, children: _jsx(Modal.Title, { children: "Add TupleTool" }) }), _jsxs(Modal.Body, { className: "gap-3 d-flex flex-column", children: [selectedBranch.length > 0 && (_jsxs("div", { className: "d-flex flex-row gap-2", children: [_jsx("h6", { className: "my-auto", children: "Target:" }), selectedBranch.map((pid, i) => (_jsx(ParticleLatex, { particleId: pid }, i)))] })), _jsxs("div", { className: "d-flex flex-row gap-2", children: [_jsx(TupleToolClassDropdown, { onChange: (option) => {
-                                    if (option) {
-                                        setSelectedTool((prev) => new TupleTool(option.value, prev?.name || ""));
-                                    }
-                                }, value: selectedTool ? { value: selectedTool.class, label: selectedTool.class } : null }), _jsx(FormControl, { ref: nameInputRef, placeholder: "TupleTool name", onChange: (event) => {
-                                    // Remove all non-word characters
-                                    const name = event.target.value.replaceAll(/[^\w]/g, "");
-                                    setSelectedTool((prev) => new TupleTool(prev.class, name));
-                                }, value: selectedTool?.name || "", disabled: !selectedTool, isInvalid: !!selectedTool && dtt.toolExists(selectedTool, selectedBranch), onKeyDown: (event) => {
-                                    if (event.key === "Enter") {
-                                        addTool(selectedBranch, selectedTool);
-                                        onClose(selectedTool);
-                                    }
-                                } }), selectedTool && (_jsxs(FormControl.Feedback, { type: "invalid", children: ["A ", selectedTool.class, " with the name \"", selectedTool.name, "\" already exists"] }))] }), selectedTool && _jsx(TupleToolDocsAccordion, { toolClass: selectedTool.class }), _jsxs(ButtonGroup, { className: "align-self-end", children: [_jsx(Button, { variant: "outline-dark", onClick: () => onClose(null), children: "Cancel" }), _jsx(Button, { disabled: !selectedTool || dtt.toolExists(selectedTool, selectedBranch), onClick: () => {
+    return (_jsxs(Modal, { show: true, onHide: () => onClose(null), size: "lg", children: [_jsx(Modal.Header, { closeButton: true, children: _jsx(Modal.Title, { children: "Add TupleTool" }) }), _jsxs(Modal.Body, { className: "gap-3 d-flex flex-column", children: [selectedBranch.length > 0 && (_jsxs("div", { className: "d-flex flex-row gap-2", children: [_jsx("h6", { className: "my-auto", children: "Target:" }), selectedBranch.map((pid, i) => (_jsx(ParticleLatex, { particleId: pid }, i)))] })), _jsxs("div", { className: "d-flex flex-column gap-1", children: [_jsxs("div", { className: "d-flex flex-row gap-2", children: [_jsxs(Form.Group, { className: "w-100", children: [_jsx(Form.Label, { className: "fw-bold", children: "Class" }), _jsx(TupleToolClassDropdown, { isClearable: true, onChange: (option) => {
+                                                    if (option) {
+                                                        setSelectedTool((prev) => new TupleTool(option.value, prev?.name || ""));
+                                                    }
+                                                    else {
+                                                        setSelectedTool(null);
+                                                    }
+                                                }, value: selectedTool ? { value: selectedTool.class, label: selectedTool.class } : null })] }), _jsxs(Form.Group, { className: "w-100", children: [_jsx(Form.Label, { className: "fw-bold", children: "Name (optional)" }), _jsx(FormControl, { ref: nameInputRef, placeholder: "e.g. MyTool", onChange: (event) => {
+                                                    // Remove all non-word characters
+                                                    const name = event.target.value.replaceAll(/[^\w]/g, "");
+                                                    setSelectedTool((prev) => new TupleTool(prev.class, name));
+                                                }, value: selectedTool?.name || "", disabled: !selectedTool, isInvalid: !!selectedTool &&
+                                                    !!selectedTool.name &&
+                                                    dtt.toolExists(selectedTool, selectedBranch), onKeyDown: (event) => {
+                                                    if (event.key === "Enter") {
+                                                        addTool(selectedBranch, selectedTool);
+                                                        onClose(selectedTool);
+                                                    }
+                                                } })] })] }), selectedTool && selectedTool.name && dtt.toolExists(selectedTool, selectedBranch) && (_jsxs(FormControl.Feedback, { type: "invalid", className: "d-block", children: ["A ", selectedTool.class, " with the name \"", selectedTool.name, "\" already exists"] }))] }), selectedTool && _jsx(TupleToolDocsAccordion, { toolClass: selectedTool.class }), _jsxs(ButtonGroup, { className: "align-self-end", children: [_jsx(Button, { variant: "outline-dark", onClick: () => onClose(null), children: "Cancel" }), _jsx(Button, { disabled: !selectedTool || dtt.toolExists(selectedTool, selectedBranch), onClick: () => {
                                     addTool(selectedBranch, selectedTool);
                                     onClose(selectedTool);
                                 }, children: "Add tool" })] })] })] }));

package/dist/components/modals/ConfigureTupleToolModal.js

@@ -5,13 +5,17 @@ import { BoolParamInput } from "../tupleToolParams/BoolParamInput";
 import { NumParamInput } from "../tupleToolParams/NumParamInput";
 import { ListParamInput } from "../tupleToolParams/ListParamInput";
 import { DictParamInput } from "../tupleToolParams/DictParamInput";
+import { LokiVariableDictInput } from "../tupleToolParams/LokiVariableDictInput";
 import { QuestionCircle } from "react-bootstrap-icons";
 import { TupleToolDocsAccordion } from "../TupleToolDocsAccordion";
 import { useDtt } from "../../providers/DttProvider";
+import { useMetadata } from "../../providers/MetadataProvider";
 import { config } from "../../config";
 import { toast } from "react-toastify";
+const LOKI_VARIABLE_PARAMS = new Set(["Variables", "BoolVariables", "FloatVariables", "IntVariables"]);
 export function ConfigureTupleToolModal({ tool, deleteIfCancelled, onClose }) {
     const { dtt, updateToolParam, removeTool, selectedBranch } = useDtt();
+    const { lokiVariables } = useMetadata();
     const toolConfig = dtt.getToolConfig(selectedBranch, tool);
     return (_jsxs(Modal, { show: true, size: "xl", fullscreen: "lg-down", backdrop: "static", keyboard: false, children: [_jsx(Modal.Header, { children: _jsxs(Modal.Title, { style: { textOverflow: "ellipsis", overflow: "hidden", whiteSpace: "nowrap" }, children: ["Configure ", tool.toString()] }) }), _jsxs(Modal.Body, { className: "gap-3 d-flex flex-column", children: [_jsx(Form, { children: Object.entries(toolConfig).map(([paramName, param]) => {
                             const { description, type, default: defaultValue, value } = param;
@@ -37,6 +41,13 @@ export function ConfigureTupleToolModal({ tool, deleteIfCancelled, onClose }) {
                                     inputComponent = (_jsx(ListParamInput, { initialValues: value, defaultValues: defaultValue, newItemValue: 0, onChange: (newValue) => updateToolParam(selectedBranch, tool, paramName, newValue), buildInnerInput: (props) => (_jsx(NumParamInput, { type: type.slice(1, -1), ...props })) }));
                                     break;
                                 case "{str:str}":
+                                    if (tool.class === "LoKi__Hybrid__TupleTool" && LOKI_VARIABLE_PARAMS.has(paramName)) {
+                                        inputComponent = (_jsx(LokiVariableDictInput, { value: value, onChange: (newValue) => updateToolParam(selectedBranch, tool, paramName, newValue), lokiVariables: lokiVariables.lokiVariables }));
+                                    }
+                                    else {
+                                        inputComponent = (_jsx(DictParamInput, { value: value, onChange: (newValue) => updateToolParam(selectedBranch, tool, paramName, newValue) }));
+                                    }
+                                    break;
                                 case "{str:[str]}":
                                     inputComponent = (_jsx(DictParamInput, { value: value, onChange: (newValue) => updateToolParam(selectedBranch, tool, paramName, newValue) }));
                                     break;

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

@@ -0,0 +1,14 @@
+import { LokiVariable } from "../../providers/MetadataProvider";
+interface Props {
+    value: {
+        [key: string]: string;
+    };
+    onChange: (value: {
+        [key: string]: string;
+    }) => void;
+    lokiVariables: {
+        [variableName: string]: LokiVariable;
+    };
+}
+export declare function LokiVariableDictInput({ value, onChange, lokiVariables }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/tupleToolParams/LokiVariableDictInput.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useDeferredValue, useMemo, useState } from "react";
+import { Button, CloseButton, Form, ListGroup } from "react-bootstrap";
+import { PlusLg } from "react-bootstrap-icons";
+import Select from "react-select";
+import Fuse from "fuse.js";
+import { DropdownOptionWithDesc } from "../DropdownOptionWithDesc";
+function LokiValueSelect({ value, onChange, allOptions, fuse }) {
+    const [inputValue, setInputValue] = useState("");
+    const deferredInput = useDeferredValue(inputValue);
+    const filteredOptions = useMemo(() => (deferredInput ? fuse.search(deferredInput, { limit: 50 }).map((r) => r.item) : allOptions), [deferredInput, fuse, allOptions]);
+    return (_jsx(Select, { options: filteredOptions, value: allOptions.find((o) => o.value === value) ?? null, inputValue: inputValue, onInputChange: (val, { action }) => {
+            if (action !== "input-blur" && action !== "menu-close") {
+                setInputValue(val);
+            }
+        }, filterOption: () => true, onChange: (opt) => onChange(opt?.value ?? ""), placeholder: "LoKi variable...", isClearable: true, components: { Option: DropdownOptionWithDesc } }));
+}
+const entriesToDict = (entries) => Object.fromEntries(entries.map(({ key, value }) => [key, value]));
+export function LokiVariableDictInput({ value, onChange, lokiVariables }) {
+    const [entries, setEntries] = useState(Object.entries(value).map(([k, v]) => ({ key: k, value: v })));
+    const allOptions = useMemo(() => Object.keys(lokiVariables)
+        .sort()
+        .map((name) => ({ value: name, label: name, description: lokiVariables[name].description })), [lokiVariables]);
+    const fuse = useMemo(() => new Fuse(allOptions, {
+        keys: [
+            { name: "label", weight: 2 },
+            { name: "description", weight: 1 },
+        ],
+        threshold: 0.4,
+        minMatchCharLength: 2,
+        shouldSort: true,
+    }), [allOptions]);
+    const update = (newEntries) => {
+        setEntries(newEntries);
+        onChange(entriesToDict(newEntries));
+    };
+    const handleAdd = () => update([...entries, { key: "", value: "" }]);
+    const handleRemove = (index) => update(entries.filter((_, i) => i !== index));
+    const handleKeyChange = (index, key) => update(entries.map((entry, i) => (i === index ? { ...entry, key } : entry)));
+    const handleValueChange = (index, val) => update(entries.map((entry, i) => (i === index ? { ...entry, value: val } : entry)));
+    return (_jsxs(_Fragment, { children: [_jsx(ListGroup, { variant: "flush", children: entries.map(({ key, value: entryValue }, i) => (_jsx(ListGroup.Item, { className: "px-0", children: _jsxs("div", { className: "d-flex gap-2 align-items-center", children: [_jsx(Form.Control, { type: "text", value: key, placeholder: "Branch name", style: { flex: "0 0 35%" }, onChange: (e) => handleKeyChange(i, e.target.value) }), _jsx("div", { style: { flex: 1 }, children: _jsx(LokiValueSelect, { value: entryValue, onChange: (val) => handleValueChange(i, val), allOptions: allOptions, fuse: fuse }) }), _jsx(CloseButton, { onClick: () => handleRemove(i) })] }) }, i))) }), _jsx(Button, { variant: "success", size: "sm", onClick: handleAdd, className: "mt-1", children: _jsx(PlusLg, {}) })] }));
+}

package/dist/config.js

@@ -46,11 +46,13 @@ export const config = {
     tupleToolValidation: {
         ["LoKi__Hybrid__TupleTool"]: {
             validate: (config) => {
-                const hasVariables = Object.entries(config["Variables"].value).length > 0;
-                const hasBoolVariables = Object.entries(config["BoolVariables"].value).length > 0;
-                const hasFloatVariables = Object.entries(config["FloatVariables"].value).length > 0;
-                const hasIntVariables = Object.entries(config["IntVariables"].value).length > 0;
-                if (!hasVariables && !hasBoolVariables && !hasFloatVariables && !hasIntVariables) {
+                const paramNames = ["Variables", "BoolVariables", "FloatVariables", "IntVariables"];
+                const allEntries = paramNames.flatMap((name) => Object.entries(config[name].value));
+                const hasIncomplete = allEntries.some(([key, value]) => !key || !value);
+                if (hasIncomplete) {
+                    return "All variable entries must have both a branch name and a LoKi variable selected";
+                }
+                if (allEntries.length === 0) {
                     return "Please add at least one variable";
                 }
                 return null;

package/dist/models/dtt.d.ts

@@ -39,6 +39,7 @@ export interface ToolMetadata {
         description: string;
         documentation: string;
         interface: ToolParamMetadata<keyof ToolParamTypeMap>[];
+        summary: string;
         tags: string[];
     };
 }

package/dist/models/dtt.js

@@ -17,14 +17,15 @@ export default class Dtt {
     static formatToolsForLoading(tools, toolMetadata) {
         return Object.fromEntries(tools
             .map((toolConfig) => {
-            const toolClass = Object.keys(toolConfig)[0];
-            const params = toolConfig[toolClass];
+            const toolString = Object.keys(toolConfig)[0];
+            const params = toolConfig[toolString];
+            const toolClass = toolString.split("/")[0];
             const toolInterface = toolMetadata[toolClass]?.interface;
             if (!toolInterface) {
                 return null;
             }
             return [
-                toolClass,
+                toolString,
                 Object.fromEntries(Object.entries(params)
                     .map(([paramName, value]) => {
                     const paramMetadata = toolInterface.find((param) => param.name === paramName);
@@ -40,7 +41,8 @@ export default class Dtt {
     }
     static fromSavedConfig(savedConfig, toolMetadata) {
         const config = {
-            ...savedConfig,
+            input: savedConfig.inputs?.length ? savedConfig.inputs[0] : undefined,
+            descriptorTemplate: savedConfig.descriptorTemplate,
             tools: Dtt.formatToolsForLoading(savedConfig.tools, toolMetadata),
             branches: Object.fromEntries(Object.entries(savedConfig.branches).map(([branchId, branchConfig]) => [
                 branchId,
@@ -56,12 +58,14 @@ export default class Dtt {
                     tools: Dtt.formatToolsForLoading(groupConfig.tools, toolMetadata),
                 },
             ])),
+            name: savedConfig.name,
         };
         return new Dtt(config, {});
     }
     toSavedConfig() {
         return {
-            ...this.config,
+            inputs: this.config.input ? [this.config.input] : undefined,
+            descriptorTemplate: this.config.descriptorTemplate,
             tools: Dtt.formatToolsForSaving(this.config.tools),
             branches: Object.fromEntries(Object.entries(this.config.branches).map(([branchId, branchConfig]) => [
                 branchId,
@@ -77,6 +81,7 @@ export default class Dtt {
                     tools: Dtt.formatToolsForSaving(groupConfig.tools),
                 },
             ])),
+            name: this.config.name,
         };
     }
     static getBranchConfigs(branchItemsList) {

package/dist/models/yamlFile.d.ts

@@ -1,6 +1,6 @@
 import Dtt from "./dtt";
 import { RowData } from "./rowData";
-import { MetadataContext } from "../providers/MetadataProvider";
+import { Metadata } from "../providers/MetadataProvider";
 import { JobConfig } from "./jobConfig";
 interface InfoYamlDefaults {
     application: string;
@@ -19,6 +19,6 @@ export declare class YamlFile {
     content: string;
     constructor(name: string, content: string);
     static fromDtt(dtt: Dtt): YamlFile;
-    static createInfoYaml(rows: RowData[], metadata: MetadataContext): YamlFile;
+    static createInfoYaml(rows: RowData[], metadata: Metadata): YamlFile;
 }
 export {};

package/dist/providers/DttProvider.d.ts

@@ -1,6 +1,6 @@
 import { ReactNode } from "react";
 import Dtt, { DttConfig, ToolParamTypeMap } from "../models/dtt";
-import { MetadataContext } from "./MetadataProvider";
+import { Metadata } from "./MetadataProvider";
 import { DecayData } from "../models/decayData";
 import { TupleTool } from "../models/tupleTool";
 interface DttContextType {
@@ -18,7 +18,7 @@ interface DttContextType {
 interface DttProviderProps {
     initialConfig: DttConfig;
     decay: DecayData;
-    metadata: MetadataContext;
+    metadata: Metadata;
     children: ReactNode;
 }
 export declare function DttProvider({ initialConfig, decay, metadata, children }: DttProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/providers/MetadataProvider.d.ts

@@ -37,7 +37,58 @@ interface StrippingInfo {
         [key: string]: string;
     };
 }
-export interface MetadataContext {
+export interface LokiVariable {
+    description: string;
+    documentation: string;
+    source: string;
+}
+interface KgDocItem {
+    variables: {
+        [key: string]: string | object;
+    };
+}
+export interface Metadata {
+    dataset: string[];
+    decays: {
+        [key: string]: DecayData;
+    };
+    kgdoc: {
+        [key: string]: KgDocItem;
+    };
+    lokiVariables: {
+        applicationInfo: ApplicationInfo;
+        lokiVariables: {
+            [key: string]: LokiVariable;
+        };
+    };
+    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;
+        };
+    };
+}
+export interface MetadataSchema {
     dataset: string[];
     decays: {
         [key: string]: DecayData;
@@ -46,11 +97,13 @@ export interface MetadataContext {
         [key: string]: string;
     };
     kgdoc: {
-        [key: string]: object;
+        [key: string]: KgDocItem;
     };
     lokiVariables: {
         applicationInfo: ApplicationInfo;
-        lokiVariables: object;
+        lokiVariables: {
+            [key: string]: LokiVariable;
+        };
     };
     particleProperties: {
         [key: string]: Particle;
@@ -83,5 +136,5 @@ interface Props {
     children: ReactNode;
 }
 export declare function MetadataProvider({ children }: Props): import("react/jsx-runtime").JSX.Element;
-export declare const useMetadata: () => MetadataContext;
+export declare const useMetadata: () => Metadata;
 export {};

package/dist/providers/MetadataProvider.js

@@ -32,10 +32,27 @@ export function MetadataProvider({ children }) {
         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
+        // Build the Metadata object
         Promise.all(promises)
             .then((entries) => {
-            setMetadata(Object.fromEntries(entries));
+            const m = Object.fromEntries(entries);
+            setMetadata({
+                dataset: m.dataset,
+                decays: m.decays,
+                kgdoc: m.kgdoc,
+                lokiVariables: m.lokiVariables,
+                particleProperties: m.particleProperties,
+                stripping: m.stripping,
+                strippingHints: m.strippingHints,
+                tupleTools: {
+                    applicationInfo: m.tupleTools?.applicationInfo ?? {},
+                    tupleTools: Object.fromEntries(Object.entries(m.tupleTools?.tupleTools ?? {}).map(([key, tool]) => [
+                        key,
+                        { ...tool, summary: m.embedding?.[key] ?? "" },
+                    ])),
+                },
+                userHints: m.userHints,
+            });
         })
             .catch(setError);
     }, []);

package/dist/tests/components/modals.test.js

@@ -63,7 +63,8 @@ const diverseToolMetadata = {
     ...mockToolMetadata,
     DiverseTool: {
         description: "Tool with diverse param types",
-        documentation: "",
+        documentation: "No documentation available.",
+        summary: "",
         tags: [],
         interface: [
             { name: "StrParam", type: "str", cpp_type: "string", default: "hello", description: "A string param" },
@@ -185,7 +186,7 @@ describe("AddTupleToolModal", () => {
     it("sanitizes the tool name on input and reflects the value", () => {
         render(_jsx(AddTupleToolModal, { onClose: vi.fn() }));
         fireEvent.click(screen.getByTestId("tool-class-dropdown"));
-        const nameInput = screen.getByPlaceholderText("TupleTool name");
+        const nameInput = screen.getByPlaceholderText("e.g. MyTool");
         fireEvent.change(nameInput, { target: { value: "my tool!" } });
         expect(nameInput).toHaveValue("mytool");
     });
@@ -194,7 +195,7 @@ describe("AddTupleToolModal", () => {
         const onClose = vi.fn();
         render(_jsx(AddTupleToolModal, { onClose: onClose }));
         fireEvent.click(screen.getByTestId("tool-class-dropdown"));
-        const nameInput = screen.getByPlaceholderText("TupleTool name");
+        const nameInput = screen.getByPlaceholderText("e.g. MyTool");
         fireEvent.keyDown(nameInput, { key: "Enter" });
         expect(mockAddTool).toHaveBeenCalled();
         expect(onClose).toHaveBeenCalledWith(expect.any(TupleTool));

package/dist/tests/models/Dtt.test.js

@@ -1,5 +1,9 @@
 import { describe, expect, it } from "vitest";
+import yaml from "js-yaml";
 import Dtt from "../../models/dtt";
+// @ts-expect-error this fixture import shows an error for some reason
+// but doesn't cause any problems in practice
+import fixtureYaml from "../fixtures/example_dtt.yaml?raw";
 import { TupleTool } from "../../models/tupleTool";
 import { mockBranchItems, mockToolMetadata } from "../testUtils";
 const DEFAULT_TOOLS = [
@@ -374,3 +378,145 @@ describe("Dtt", () => {
         });
     });
 });
+// ---------------------------------------------------------------------------
+// Fixture-based tests
+// ---------------------------------------------------------------------------
+const fixtureParsed = yaml.load(fixtureYaml);
+const fixtureToolMetadata = {
+    TupleToolKinematic: {
+        description: "",
+        documentation: "No documentation available.",
+        summary: "",
+        tags: [],
+        interface: [
+            { name: "ExtraName", type: "str", cpp_type: "std::string", default: "", description: "" },
+            { name: "Verbose", type: "bool", cpp_type: "bool", default: false, description: "" },
+            { name: "MaxPV", type: "uint", cpp_type: "unsigned int", default: 100, description: "" },
+            {
+                name: "Transporter",
+                type: "str",
+                cpp_type: "std::string",
+                default: "ParticleTransporter:PUBLIC",
+                description: "",
+            },
+        ],
+    },
+    TupleToolPid: {
+        description: "",
+        documentation: "No documentation available.",
+        summary: "",
+        tags: [],
+        interface: [
+            { name: "ExtraName", type: "str", cpp_type: "std::string", default: "", description: "" },
+            { name: "Verbose", type: "bool", cpp_type: "bool", default: false, description: "" },
+            { name: "MaxPV", type: "uint", cpp_type: "unsigned int", default: 100, description: "" },
+        ],
+    },
+    TupleToolANNPID: {
+        description: "",
+        documentation: "No documentation available.",
+        summary: "",
+        tags: [],
+        interface: [
+            { name: "ExtraName", type: "str", cpp_type: "std::string", default: "", description: "" },
+            { name: "Verbose", type: "bool", cpp_type: "bool", default: false, description: "" },
+            { name: "MaxPV", type: "uint", cpp_type: "unsigned int", default: 100, description: "" },
+            {
+                name: "ANNPIDTunes",
+                type: "text",
+                cpp_type: "std::vector<std::string>",
+                default: ["MC12TuneV2", "MC12TuneV3", "MC12TuneV4", "MC15TuneV1"],
+                description: "",
+            },
+            {
+                name: "PIDTypes",
+                type: "text",
+                cpp_type: "std::vector<std::string>",
+                default: ["Electron", "Muon", "Pion", "Kaon", "Proton", "Ghost"],
+                description: "",
+            },
+        ],
+    },
+    TupleToolAngles: {
+        description: "",
+        documentation: "No documentation available.",
+        summary: "",
+        tags: [],
+        interface: [
+            { name: "ExtraName", type: "str", cpp_type: "std::string", default: "", description: "" },
+            { name: "Verbose", type: "bool", cpp_type: "bool", default: false, description: "" },
+            { name: "MaxPV", type: "uint", cpp_type: "unsigned int", default: 100, description: "" },
+            { name: "WRTMother", type: "bool", cpp_type: "bool", default: false, description: "" },
+        ],
+    },
+    TupleToolCorrectedMass: {
+        description: "",
+        documentation: "No documentation available.",
+        summary: "",
+        tags: [],
+        interface: [
+            { name: "ExtraName", type: "str", cpp_type: "std::string", default: "", description: "" },
+            { name: "Verbose", type: "bool", cpp_type: "bool", default: false, description: "" },
+            { name: "MaxPV", type: "uint", cpp_type: "unsigned int", default: 100, description: "" },
+            { name: "MassInvisible", type: "float", cpp_type: "double", default: 0, description: "" },
+        ],
+    },
+};
+describe("fromSavedConfig() with fixture", () => {
+    let dtt;
+    dtt = Dtt.fromSavedConfig(fixtureParsed, fixtureToolMetadata);
+    it("loads the correct branch IDs and particle assignments", () => {
+        expect(Object.keys(dtt.config.branches).sort()).toEqual(["eminus", "eplus", "gamma"]);
+        expect(dtt.config.branches["gamma"].particle).toBe("gamma");
+        expect(dtt.config.branches["eplus"].particle).toBe("e+");
+        expect(dtt.config.branches["eminus"].particle).toBe("e-");
+    });
+    it("loads the descriptor template", () => {
+        expect(dtt.config.descriptorTemplate).toBe("${gamma}gamma -> ${eplus}e+ ${eminus}e-");
+    });
+    it("loads the name", () => {
+        expect(dtt.config.name).toBe("DecayTreeTuple/MyDecayTree0");
+    });
+    it("loads the input location", () => {
+        expect(dtt.config.input).toBe("/Event/Leptonic/Phys/BuToKJpsiee2Line/Particles");
+    });
+    it("loads global tools by class", () => {
+        expect(dtt.toolExists(TupleTool.fromString("TupleToolKinematic"))).toBe(true);
+        expect(dtt.toolExists(TupleTool.fromString("TupleToolPid"))).toBe(true);
+        expect(dtt.toolExists(TupleTool.fromString("TupleToolANNPID"))).toBe(true);
+    });
+    it("loads a named tool instance", () => {
+        expect(dtt.toolExists(TupleTool.fromString("TupleToolAngles/myNamedTool"))).toBe(true);
+    });
+    it("loads a modified string param (TupleToolPid ExtraName)", () => {
+        expect(dtt.config.tools["TupleToolPid"]["ExtraName"].value).toBe("myExtraName");
+    });
+    it("loads a string param (TupleToolKinematic Transporter)", () => {
+        expect(dtt.config.tools["TupleToolKinematic"]["Transporter"].value).toBe("ParticleTransporter:PUBLIC");
+    });
+    it("loads an array param (TupleToolANNPID ANNPIDTunes)", () => {
+        expect(dtt.config.tools["TupleToolANNPID"]["ANNPIDTunes"].value).toEqual([
+            "MC12TuneV2",
+            "MC12TuneV3",
+            "MC12TuneV4",
+            "MC15TuneV1",
+        ]);
+    });
+    it("loads a bool param on a named tool (TupleToolAngles/myNamedTool WRTMother)", () => {
+        expect(dtt.config.tools["TupleToolAngles/myNamedTool"]["WRTMother"].value).toBe(true);
+    });
+    it("loads the group key and its particle list", () => {
+        expect(dtt.config.groups["eminus,gamma"].particles).toEqual(["e-", "gamma"]);
+    });
+    it("loads the named group tool and its params", () => {
+        const groupTool = dtt.config.groups["eminus,gamma"].tools["TupleToolCorrectedMass/myGroupTool"];
+        expect(groupTool["MassInvisible"].value).toBe(0);
+        expect(groupTool["MaxPV"].value).toBe(100);
+    });
+});
+describe("toSavedConfig() roundtrip with fixture", () => {
+    it("fromSavedConfig -> toSavedConfig reproduces the fixture exactly", () => {
+        const dtt = Dtt.fromSavedConfig(fixtureParsed, fixtureToolMetadata);
+        expect(dtt.toSavedConfig()).toEqual(fixtureParsed);
+    });
+});

package/dist/tests/testUtils.d.ts

@@ -4,7 +4,7 @@ import Dtt from "../models/dtt";
 import { DecayData } from "../models/decayData";
 import { RowData } from "../models/rowData";
 import { StrippingLine } from "../models/strippingLine";
-import { MetadataContext } from "../providers/MetadataProvider";
+import { Metadata } from "../providers/MetadataProvider";
 import { Particle } from "../models/particle";
 export declare const mockToolMetadata: ToolMetadata;
 export declare const mockBranchItems: BranchMapItem[];
@@ -16,7 +16,7 @@ export declare function createMockRow(overrides?: Partial<RowData>): RowData;
 export declare const mockParticleProperties: {
     [key: string]: Particle;
 };
-export declare const mockMetadata: MetadataContext;
+export declare const mockMetadata: Metadata;
 export declare const mockInlineMath: ({ math }: {
     math: string;
 }) => import("react/jsx-runtime").JSX.Element;

package/dist/tests/testUtils.js

@@ -8,37 +8,43 @@ import Dtt from "../models/dtt";
 export const mockToolMetadata = {
     TupleToolKinematic: {
         description: "Kinematic information",
-        documentation: "",
+        documentation: "No documentation available.",
+        summary: "TupleToolKinematic summary",
         tags: [],
         interface: [{ name: "Verbose", type: "bool", cpp_type: "bool", default: false, description: "Verbose output" }],
     },
     TupleToolPid: {
         description: "PID information",
-        documentation: "",
+        documentation: "No documentation available.",
+        summary: "TupleToolPid summary",
         tags: [],
         interface: [{ name: "Verbose", type: "bool", cpp_type: "bool", default: false, description: "Verbose output" }],
     },
     TupleToolANNPID: {
         description: "ANN PID",
-        documentation: "",
+        documentation: "No documentation available.",
+        summary: "TupleToolANNPID summary",
         tags: [],
         interface: [],
     },
     TupleToolGeometry: {
         description: "Geometry",
-        documentation: "",
+        documentation: "No documentation available.",
+        summary: "TupleToolGeometry summary",
         tags: [],
         interface: [],
     },
     TupleToolEventInfo: {
         description: "Event info",
-        documentation: "",
+        documentation: "No documentation available.",
+        summary: "TupleToolEventInfo summary",
         tags: [],
         interface: [],
     },
     TupleToolL0Data: {
         description: "L0 trigger data",
-        documentation: "",
+        documentation: "No documentation available.",
+        summary: "TupleToolL0Data summary",
         tags: [],
         interface: [{ name: "Verbose", type: "bool", cpp_type: "bool", default: false, description: "Verbose output" }],
     },
@@ -136,7 +142,6 @@ export const mockMetadata = {
     decays: {
         "[B+ -> K+ mu+ mu-]cc": mockDecay,
     },
-    embedding: {},
     kgdoc: {},
     lokiVariables: {
         applicationInfo: { Analysis: "v25r1", DaVinci: "v45r7", Phys: "v26r2" },

package/dist/utils/latexUtils.d.ts

@@ -1,13 +1,13 @@
 import { DecayData } from "../models/decayData";
-import { MetadataContext } from "../providers/MetadataProvider";
+import { Metadata } from "../providers/MetadataProvider";
 export declare const LATEX_SELECTED_COLOR = "#0d6efd";
 /**
  * Converts a LoKi decay selector string to LaTeX representation
  */
-export declare const selectionDescriptorToLatex: (metadata: MetadataContext, decay: DecayData, selection: string[]) => string;
+export declare const selectionDescriptorToLatex: (metadata: Metadata, decay: DecayData, selection: string[]) => string;
 /**
  * Converts a single particle token to LaTeX representation.
  * Particle tokens may include a LoKi selection prefix ('^') and/or sub-decay parentheses.
  * The `highlighted` param can be used instead of a '^' prefix when calling directly.
  */
-export declare const convertParticleToLatex: (metadata: MetadataContext, particle: string, highlighted?: boolean) => string;
+export declare const convertParticleToLatex: (metadata: Metadata, particle: string, highlighted?: boolean) => string;

package/dist/utils/utils.d.ts

@@ -1,12 +1,12 @@
 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 | {
+import { Metadata } from "../providers/MetadataProvider";
+export declare function parseProductionFiles(files: File[], metadata: Metadata): Promise<string | {
     rows: RowData[];
     emails: string[];
 }>;
-export declare function processProductionFiles(metadata: MetadataContext, configs: SavedDttConfig[], infoYaml: InfoYaml | null): string | {
+export declare function processProductionFiles(metadata: Metadata, configs: SavedDttConfig[], infoYaml: InfoYaml | null): string | {
     rows: RowData[];
     emails: string[];
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lhcb-ntuple-wizard-test",
-  "version": "2.2.2",
+  "version": "2.3.0",
   "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,
@@ -21,6 +21,7 @@
     "cytoscape": "3.33.1",
     "cytoscape-dagre": "^2.5.0",
     "email-validator": "2.0.4",
+    "fuse.js": "^7.3.0",
     "js-yaml": "4.1.1",
     "jszip": "3.10.1",
     "katex": "^0.16.33",
@@ -43,7 +44,7 @@
   },
   "overrides": {
     "autoprefixer": "10.4.5",
-    "@xmldom/xmldom": "0.9.9"
+    "@xmldom/xmldom": "0.9.10"
   },
   "scripts": {
     "start": "vite --open",