lhcb-ntuple-wizard-test 2.0.7 → 2.2.0

package/dist/components/TagDropdown.d.ts

@@ -1,9 +1,9 @@
 import { TagHint } from "../providers/MetadataProvider.js";
 import { Props as SelectProps } from "react-select";
 import { DropdownOption } from "../models/dropdownOption.js";
-export declare function getSelectTagOptions(tags: {
-    [key: string]: TagHint;
-}, filter?: (tag: TagHint) => boolean): DropdownOption[];
+export declare function getSelectTagOptions<T extends TagHint>(tags: {
+    [key: string]: T;
+}, filter?: (tag: T) => boolean): DropdownOption[];
 interface Props extends SelectProps<DropdownOption, true> {
     type: "decayTags" | "particleTags";
     filter?: (tag: TagHint) => boolean;

package/dist/components/TagDropdown.js

@@ -22,8 +22,8 @@ export function getSelectTagOptions(tags, filter = () => true) {
 }
 export function TagDropdown({ type, filter, ...props }) {
     const metadata = useMetadata();
-    const options = getSelectTagOptions(metadata ? metadata.userHints[type] : {}, filter);
-    return (_jsx("div", { className: "react-select form-control p-0", children: _jsx(Select, { isMulti: true, options: options, isLoading: !metadata, ...props, 
+    const options = getSelectTagOptions(metadata.userHints[type], filter);
+    return (_jsx("div", { className: "react-select form-control p-0", children: _jsx(Select, { isMulti: true, options: options, ...props, 
             // Display the dropdown above text inputs and other elements
             menuPortalTarget: document.body, menuPosition: "fixed", styles: {
                 menuPortal: (base) => ({ ...base, zIndex: 9999 }),

package/dist/components/{TupleToolDropdown.d.ts → TupleToolClassDropdown.d.ts}

@@ -10,12 +10,9 @@
  \*****************************************************************************/
 import { GroupBase, Props as SelectProps } from "react-select";
 import { ReactNode } from "react";
-type ToolOption = {
+type ToolDropdownOption = {
     value: string;
     label: ReactNode;
 };
-interface Props extends SelectProps<ToolOption, false, GroupBase<ToolOption>> {
-    filterToolTags: string[];
-}
-export declare function TupleToolDropdown({ filterToolTags, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export declare function TupleToolClassDropdown(props: SelectProps<ToolDropdownOption, false, GroupBase<ToolDropdownOption>>): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/{TupleToolDropdown.js → TupleToolClassDropdown.js}

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

package/dist/components/TupleToolDocsAccordion.d.ts

@@ -1,5 +1,5 @@
 interface Props {
     toolClass: string;
 }
-export declare function TupleToolDocsAccordion({ toolClass }: Props): import("react/jsx-runtime").JSX.Element | null;
+export declare function TupleToolDocsAccordion({ toolClass }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/TupleToolDocsAccordion.js

@@ -1,14 +1,10 @@
 import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { Accordion, Spinner } from "react-bootstrap";
+import { Accordion } from "react-bootstrap";
 import { useMetadata } from "../providers/MetadataProvider";
-import DOMPurify from "dompurify";
 export function TupleToolDocsAccordion({ toolClass }) {
     const metadata = useMetadata();
-    if (!metadata) {
-        return null;
-    }
     const documentation = metadata.tupleTools.tupleTools[toolClass].documentation;
-    return (_jsx(Accordion, { children: _jsxs(Accordion.Item, { eventKey: "0", children: [_jsxs(Accordion.Header, { children: ["Documentation for ", toolClass] }), _jsx(Accordion.Body, { children: toolClass ? (_jsx("div", { dangerouslySetInnerHTML: {
-                            __html: DOMPurify.sanitize(documentation),
-                        } })) : (_jsx(Spinner, { animation: "border" })) })] }) }));
+    return (_jsx(Accordion, { children: _jsxs(Accordion.Item, { eventKey: "0", children: [_jsxs(Accordion.Header, { children: ["Documentation for ", toolClass] }), _jsx(Accordion.Body, { children: documentation ? (_jsx("div", { dangerouslySetInnerHTML: {
+                            __html: documentation,
+                        } })) : ("No documentation available.") })] }) }));
 }

package/dist/components/TupleToolGroupsAccordion.d.ts

@@ -0,0 +1,5 @@
+interface Props {
+    setActiveKey: (key: string) => void;
+}
+export declare function TupleToolGroupsAccordion({ setActiveKey }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/TupleToolGroupsAccordion.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Accordion, Button, ListGroup, OverlayTrigger, Tooltip } from "react-bootstrap";
+import { CircleSquare, PencilSquare, PlusLg } from "react-bootstrap-icons";
+import { getControlKey } from "../utils/utils";
+import { useDtt } from "../providers/DttProvider";
+import { ParticleLatex } from "./ParticleLatex";
+import _ from "lodash";
+import { AddTupleToolButton } from "./AddTupleToolButton";
+export function TupleToolGroupsAccordion({ setActiveKey }) {
+    const { dtt, selectedBranch, setSelectedBranch, hoveredBranch, setHoveredBranch, highlightedBranch } = useDtt();
+    function handleGroupSelected(branchGroup) {
+        setActiveKey("0");
+        setSelectedBranch(branchGroup);
+        setHoveredBranch([]);
+    }
+    const groupsWithTools = dtt.getGroupsWithTools();
+    return (_jsxs(Accordion.Item, { eventKey: "1", children: [_jsx(Accordion.Header, { children: _jsxs("div", { className: "d-flex align-items-center gap-2", children: [_jsx(CircleSquare, {}), groupsWithTools.length, " group", groupsWithTools.length === 1 ? "" : "s"] }) }), _jsx(Accordion.Body, { style: { padding: 4 }, children: groupsWithTools.length > 0 ? (_jsxs(ListGroup, { variant: "flush", children: [groupsWithTools.map((group) => {
+                            const branchGroup = group.split(",");
+                            return (_jsx(ListGroup.Item, { onMouseEnter: () => setHoveredBranch(branchGroup), onMouseLeave: () => setHoveredBranch([]), onClick: () => handleGroupSelected(branchGroup), style: {
+                                    cursor: "pointer",
+                                    backgroundColor: _.isEqual(hoveredBranch, branchGroup)
+                                        ? "var(--bs-gray-100)"
+                                        : "transparent",
+                                }, children: _jsxs("div", { className: "d-flex justify-content-between align-items-center", children: [_jsx("div", { className: "d-flex flex-wrap align-items-center gap-3", children: branchGroup.map((pid, i) => (_jsx(ParticleLatex, { particleId: pid, highlighted: _.isEqual(highlightedBranch, branchGroup) }, i))) }), _jsx(OverlayTrigger, { overlay: _jsx(Tooltip, { children: "Edit group TupleTools" }), children: _jsx(Button, { size: "sm", variant: "outline-secondary", onClick: () => handleGroupSelected(branchGroup), children: _jsx(PencilSquare, {}) }) })] }) }, group));
+                        }), selectedBranch.length > 1 && !groupsWithTools.includes(selectedBranch.join(",")) && (_jsx(ListGroup.Item, { onMouseEnter: () => setHoveredBranch(selectedBranch), onMouseLeave: () => setHoveredBranch([]), onClick: () => handleGroupSelected(selectedBranch), style: {
+                                cursor: "pointer",
+                                backgroundColor: _.isEqual(hoveredBranch, selectedBranch)
+                                    ? "var(--bs-gray-100)"
+                                    : "transparent",
+                            }, children: _jsxs("div", { className: "d-flex justify-content-between align-items-center", children: [_jsx("div", { className: "d-flex flex-wrap align-items-center gap-3", children: selectedBranch.map((pid, i) => (_jsx(ParticleLatex, { particleId: pid, highlighted: true }, i))) }), _jsx(OverlayTrigger, { overlay: _jsx(Tooltip, { children: "Create group" }), children: _jsx(Button, { size: "sm", variant: "success", onClick: () => handleGroupSelected(selectedBranch), children: _jsx(PlusLg, {}) }) })] }) }, selectedBranch.join(",")))] })) : (_jsxs("div", { className: "text-muted d-flex flex-column gap-2 p-3", children: [selectedBranch.length === 0 ? (_jsxs("div", { children: ["No groups have been created yet. Select multiple particles (", _jsx("code", { children: getControlKey() }), " + click) and add a TupleTool to create a group."] })) : selectedBranch.length === 1 ? (_jsxs("div", { children: ["Select multiple particles (", _jsx("code", { children: getControlKey() }), " + click) to create a group."] })) : (_jsxs("div", { children: ["No groups include the selected particle", selectedBranch.length > 1 ? "s" : "", ". Add a TupleTool to create a group."] })), selectedBranch.length > 1 && _jsx(AddTupleToolButton, {})] })) })] }));
+}

package/dist/components/TupleToolLabel.d.ts

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

package/dist/components/TupleToolLabel.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 /*****************************************************************************\
  * (c) Copyright 2021 CERN for the benefit of the LHCb Collaboration           *
  *                                                                             *
@@ -13,8 +13,5 @@ import { OverlayTrigger, Tooltip } from "react-bootstrap";
 import { useMetadata } from "../providers/MetadataProvider.js";
 export function TupleToolLabel({ tool }) {
     const metadata = useMetadata();
-    if (!metadata) {
-        return null;
-    }
-    return (_jsx(OverlayTrigger, { overlay: _jsx(Tooltip, { children: metadata.tupleTools.tupleTools[tool.class].description }), children: _jsx("span", { children: tool.toString() }) }));
+    return (_jsx(OverlayTrigger, { overlay: _jsx(Tooltip, { children: metadata.tupleTools.tupleTools[tool.class].description }), children: _jsxs("div", { className: "d-flex flex-column gap-1", children: [_jsx("code", { style: { textOverflow: "ellipsis", overflow: "hidden", whiteSpace: "nowrap" }, children: tool.class }), _jsx("p", { className: "m-0 text-muted", style: { textOverflow: "ellipsis", overflow: "hidden", whiteSpace: "nowrap" }, children: tool.name })] }) }));
 }

package/dist/components/TupleToolsAccordion.d.ts

@@ -0,0 +1 @@
+export declare function TupleToolsAccordion(): import("react/jsx-runtime").JSX.Element;

package/dist/components/TupleToolsAccordion.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Accordion, Button, ButtonGroup, ListGroup, OverlayTrigger, Tooltip } from "react-bootstrap";
+import { PencilSquare, Tools } from "react-bootstrap-icons";
+import { ConfigureTupleToolModal } from "./modals/ConfigureTupleToolModal";
+import { useState } from "react";
+import { useDtt } from "../providers/DttProvider";
+import { TupleToolLabel } from "./TupleToolLabel";
+import { DeleteButton } from "./DeleteButton";
+import { AddTupleToolButton } from "./AddTupleToolButton";
+import { GuideLinkButton } from "./GuideLinkButton";
+export function TupleToolsAccordion() {
+    const [showConfigModal, setShowConfigModal] = useState(null);
+    const { dtt, removeTool, selectedBranch } = useDtt();
+    const tools = dtt.listTools(selectedBranch);
+    return (_jsxs(_Fragment, { children: [showConfigModal && (_jsx(ConfigureTupleToolModal, { tool: showConfigModal.tool, deleteIfCancelled: false, onClose: () => setShowConfigModal(null) })), _jsxs(Accordion.Item, { eventKey: "0", children: [_jsx(Accordion.Header, { children: _jsxs("div", { className: "d-flex align-items-center gap-2", children: [_jsx(Tools, {}), tools.length, " TupleTool", tools.length === 1 ? "" : "s", selectedBranch.length === 0 ? " (global)" : selectedBranch.length > 1 ? " (group)" : "", _jsx(GuideLinkButton, { page: "tupleTools", topic: "TupleTools" })] }) }), _jsxs(Accordion.Body, { style: { padding: 4 }, children: [tools.length === 0 ? (_jsxs("div", { className: "text-muted pt-3 pb-2", style: { paddingLeft: "1rem", paddingRight: "1rem" }, children: ["No TupleTools have been added", " ", selectedBranch.length === 0
+                                        ? "to the decay"
+                                        : selectedBranch.length === 1
+                                            ? "to this particle"
+                                            : "to this group", " ", "yet."] })) : (_jsx(ListGroup, { variant: "flush", children: tools.map((tool) => {
+                                    return (_jsxs(ListGroup.Item, { className: "d-flex justify-content-between align-items-start", children: [_jsx("div", { style: { width: 240 }, children: _jsx(TupleToolLabel, { tool: tool }) }), _jsxs(ButtonGroup, { size: "sm", children: [_jsx(OverlayTrigger, { overlay: _jsx(Tooltip, { children: "Configure TupleTool" }), children: _jsx(Button, { variant: "outline-secondary", onClick: () => setShowConfigModal({ tool }), children: _jsx(PencilSquare, {}) }) }), _jsx(DeleteButton, { outline: true, action: () => removeTool(selectedBranch, tool), popupMessage: "Remove?", placement: "right" })] })] }, tool.toString()));
+                                }) })), _jsx("div", { className: "pb-2", style: { paddingLeft: "1rem", paddingRight: "1rem" }, children: _jsx(AddTupleToolButton, {}) })] })] })] }));
+}

package/dist/components/VerticalLine.d.ts

@@ -0,0 +1,7 @@
+interface Props {
+    width?: string;
+    height?: string;
+    color?: string;
+}
+export declare function VerticalLine({ width, height, color }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/VerticalLine.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+export function VerticalLine({ width = "1px", height = "100%", color = "#bbb" }) {
+    return _jsx("div", { style: { borderLeft: `${width} solid ${color}`, height } });
+}

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

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

package/dist/components/modals/AddTupleToolModal.js

@@ -1,18 +1,19 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Button, FormControl, InputGroup, Modal } from "react-bootstrap";
-import { TupleToolDropdown } from "../TupleToolDropdown";
+import { Button, ButtonGroup, FormControl, Modal } from "react-bootstrap";
+import { TupleToolClassDropdown } from "../TupleToolClassDropdown";
 import { TupleToolDocsAccordion } from "../TupleToolDocsAccordion";
 import { useDtt } from "../../providers/DttProvider";
 import { TupleTool } from "../../models/tupleTool";
 import { useEffect, useRef, useState } from "react";
-export function AddTupleToolModal({ branch, filterToolTags, onClose }) {
-    const { dtt, addTool } = useDtt();
+import { ParticleLatex } from "../ParticleLatex";
+export function AddTupleToolModal({ onClose }) {
+    const { dtt, addTool, selectedBranch } = useDtt();
     const nameInputRef = useRef(null);
     const [selectedTool, setSelectedTool] = useState(null);
     useEffect(() => {
         nameInputRef.current?.focus();
     }, [selectedTool]);
-    return (_jsxs(Modal, { show: true, onHide: onClose, children: [_jsx(Modal.Header, { closeButton: true, children: "Add TupleTool" }), _jsxs(Modal.Body, { className: "gap-3 d-flex flex-column", children: [_jsxs(InputGroup, { hasValidation: true, children: [_jsx(TupleToolDropdown, { filterToolTags: filterToolTags, placeholder: "TupleTool class", onChange: (option) => {
+    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 || ""));
                                     }
@@ -20,13 +21,13 @@ export function AddTupleToolModal({ branch, filterToolTags, onClose }) {
                                     // Remove all non-word characters
                                     const name = event.target.value.replaceAll(/[^\w]/g, "");
                                     setSelectedTool((prev) => new TupleTool(prev.class, name));
-                                }, value: selectedTool?.name || "", disabled: !selectedTool, isInvalid: !!selectedTool && dtt.toolExists(selectedTool, branch), onKeyDown: (event) => {
+                                }, value: selectedTool?.name || "", disabled: !selectedTool, isInvalid: !!selectedTool && dtt.toolExists(selectedTool, selectedBranch), onKeyDown: (event) => {
                                     if (event.key === "Enter") {
-                                        addTool(branch, selectedTool);
-                                        onClose();
+                                        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 }), _jsx(Button, { className: "align-self-end", variant: "success", disabled: !selectedTool || dtt.toolExists(selectedTool, branch), onClick: () => {
-                            addTool(branch, selectedTool);
-                            onClose();
-                        }, children: "Add tool" })] })] }));
+                                } }), 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: () => {
+                                    addTool(selectedBranch, selectedTool);
+                                    onClose(selectedTool);
+                                }, children: "Add tool" })] })] })] }));
 }

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

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

package/dist/components/modals/ConfigureTupleToolModal.js

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

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

@@ -3,5 +3,5 @@ interface Props {
     onClose: () => void;
     currentRow?: RowData;
 }
-export declare function UploadDttConfigModal({ onClose, currentRow }: Props): import("react/jsx-runtime").JSX.Element | null;
+export declare function UploadDttConfigModal({ onClose, currentRow }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/modals/UploadDttConfigModal.js

@@ -28,7 +28,7 @@ export function UploadDttConfigModal({ onClose, currentRow }) {
             if (importedConfig.descriptorTemplate === currentRow.decay.descriptors.template) {
                 updateRow(currentRow.id, (r) => ({
                     ...r,
-                    dtt: importedRow.dtt.withInputsFromLines(currentRow.lines),
+                    dtt: currentRow.line ? importedRow.dtt.withInputFromLine(currentRow.line) : importedRow.dtt,
                 }));
                 onClose();
             }
@@ -42,9 +42,6 @@ export function UploadDttConfigModal({ onClose, currentRow }) {
             onClose();
         }
     }
-    if (!metadata) {
-        return null;
-    }
     return (_jsxs(Modal, { show: true, animation: false, children: [_jsx(Modal.Header, { children: _jsx(Modal.Title, { children: " Upload configuration file " }) }), _jsxs(Modal.Body, { children: [_jsx(Form.Group, { controlId: "formFile2", className: "mb-3", children: _jsx(Form.Control, { type: "file", multiple: !currentRow, accept: ".yaml", onChange: (event) => {
                                 const files = event.target.files;
                                 if (files) {

package/dist/config.d.ts

@@ -1,3 +1,5 @@
+import { DagreLayoutOptions } from "cytoscape-dagre";
+import { ToolConfig } from "./models/dtt";
 export declare const config: {
     metadata_baseurl: string;
     metadata_files: {
@@ -21,58 +23,28 @@ export declare const config: {
         lifetime: string;
     };
     dttGraphOptions: {
-        layout: {
-            hierarchical: {
-                sortMethod: string;
-            };
-        };
+        height: string;
+        zoomMin: number;
+        zoomMax: number;
+        zoomStep: number;
+        layout: DagreLayoutOptions;
         nodes: {
-            borderWidth: number;
-            borderWidthSelected: number;
-            imagePadding: number;
-            font: {
-                strokeWidth: number;
-                background: string;
-            };
-            color: {
-                background: string;
-                highlight: {
-                    background: string;
-                };
-                hover: {
-                    background: string;
-                };
-            };
-            scaling: {
-                min: number;
-                max: number;
-            };
-            value: number;
-            shape: string;
-            shapeProperties: {
-                useBorderWithImage: boolean;
-                useImageSize: boolean;
-            };
+            draggable: boolean;
+            width: number;
+            height: number;
+            hoverColor: string;
         };
         edges: {
             color: string;
             width: number;
-            selectionWidth: number;
-            hoverWidth: number;
-        };
-        physics: {
-            enabled: boolean;
         };
-        interaction: {
-            dragNodes: boolean;
-            multiselect: boolean;
-            selectConnectedEdges: boolean;
-            hoverConnectedEdges: boolean;
-            hover: boolean;
-            zoomView: boolean;
-        };
-        height: string;
-        autoResize: boolean;
-        width: string;
     };
+    disabledTupleTools: string[];
+    tupleToolValidation: TupleToolValidation;
 };
+interface TupleToolValidation {
+    [toolClass: string]: {
+        validate: (config: ToolConfig) => string | null;
+    };
+}
+export {};

package/dist/config.js

@@ -21,52 +21,40 @@ export const config = {
         lifetime: "secondary",
     },
     dttGraphOptions: {
+        height: "500px",
+        zoomMin: 0.5, // multiplier
+        zoomMax: 2.0, // multiplier
+        zoomStep: 0.018,
         layout: {
-            hierarchical: { sortMethod: "directed" },
+            rankDir: "TB", // top -> bottom
+            nodeSep: 50,
+            rankSep: 80,
+            animate: false,
         },
         nodes: {
-            borderWidth: 0,
-            borderWidthSelected: 0,
-            imagePadding: 10,
-            font: {
-                strokeWidth: 20,
-                background: "white",
-            },
-            color: {
-                background: "white",
-                highlight: { background: "white" },
-                hover: { background: "#eee" },
-            },
-            scaling: {
-                min: 32,
-                max: 32,
-            },
-            value: 1,
-            shape: "image",
-            shapeProperties: {
-                useBorderWithImage: true,
-                useImageSize: false,
-            },
+            draggable: false,
+            width: 80,
+            height: 30,
+            hoverColor: "royalblue",
         },
         edges: {
-            color: "black",
+            color: "#222",
             width: 1,
-            selectionWidth: 0,
-            hoverWidth: 0,
         },
-        physics: {
-            enabled: false,
-        },
-        interaction: {
-            dragNodes: false,
-            multiselect: true,
-            selectConnectedEdges: false,
-            hoverConnectedEdges: false,
-            hover: true,
-            zoomView: false,
+    },
+    disabledTupleTools: ["LoKi__Hybrid__ArrayTupleTool"],
+    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) {
+                    return "Please add at least one variable";
+                }
+                return null;
+            },
         },
-        height: "500px",
-        autoResize: true,
-        width: "100%",
     },
 };

package/dist/models/bkPath.js

@@ -8,7 +8,7 @@ export class BkPath {
     fileName;
     constructor(path) {
         if (!BkPath.isValid(path)) {
-            throw new Error(`Invalid bookkeeping path: ${path}`);
+            throw new Error(`Invalid dataset: ${path}`);
         }
         const parts = path.split("/");
         const [, type, year] = parts;

package/dist/models/dtt.d.ts

@@ -81,7 +81,7 @@ export interface DttConfig {
         [particleId: string]: BranchConfig;
     };
     descriptorTemplate?: string;
-    inputs?: string[];
+    input?: string;
     groups: {
         [particleGroup: string]: GroupConfig;
     };
@@ -117,7 +117,7 @@ export default class Dtt {
     toSavedConfig(): SavedDttConfig;
     private static getBranchConfigs;
     static create(descriptorTemplate: string, branchItemsList: BranchMapItem[], inputs: string[], name: string, toolMetadata: ToolMetadata): Dtt;
-    withInputsFromLines(lines: StrippingLine[]): Dtt;
+    withInputFromLine(line: StrippingLine): Dtt;
     withName(name: string): Dtt;
     withConfig(config: DttConfig): Dtt;
     withAddedTool(tool: TupleTool, branch?: string[]): Dtt;
@@ -128,11 +128,14 @@ export default class Dtt {
     getToolsByBranch(branch?: string[]): {
         [toolString: string]: ToolConfig;
     };
+    getBranchTools(branch?: string[]): string[];
     private static getToolsByBranchFromConfig;
     getParticlesByBranchId(branchIds: string[]): string[];
     private static getDefaultToolConfig;
     getToolConfig(branch: string[], tool: TupleTool): ToolConfig;
     listTools(branch?: string[]): TupleTool[];
+    getGroupsWithTools(): string[];
+    getGroupsThatIncludeBranch(branch: string[]): string[];
     toolExists(tool: TupleTool, branch?: string[]): boolean;
 }
 export {};