@seedtactics/insight-client 16.8.4-beta.1 → 16.8.4-beta.11

package/dist/components/station-monitor/InvalidateCycle.js

@@ -34,17 +34,41 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 import { Box, Button, ListItemIcon, ListItemText, ListSubheader, Stack } from "@mui/material";
 import { MenuItem } from "@mui/material";
 import { TextField } from "@mui/material";
-import { ActionType, LocType } from "../../network/api.js";
+import { ActionType, LocType, LogType, } from "../../network/api.js";
 import { JobsBackend } from "../../network/backend.js";
-import { LazySeq } from "@seedtactics/immutable-collections";
+import { HashMap, LazySeq } from "@seedtactics/immutable-collections";
 import { currentStatus } from "../../cell-status/current-status.js";
-import { barcodePotentialNewMaterial, inProcessMaterialInDialog, materialDialogOpen, materialInDialogInfo, materialInDialogLargestUsedProcess, } from "../../cell-status/material-details.js";
+import { barcodePotentialNewMaterial, inProcessMaterialInDialog, materialDialogOpen, materialInDialogInfo, materialInDialogLargestUsedProcess, materialInDialogLocalEvents, } from "../../cell-status/material-details.js";
 import { currentOperator } from "../../data/operators.js";
 import { fmsInformation } from "../../network/server-settings.js";
 import { useAtomValue, useSetAtom } from "jotai";
 import { useEffect, useRef } from "react";
 import { last30Jobs } from "../../cell-status/scheduled-jobs.js";
 import { PartIdenticon } from "./Material.js";
+import { isLogEntryInvalidated } from "../LogEntry.js";
+import { ApiException } from "../../network/api.js";
+const invalidatableEventTypes = LazySeq.of([
+    LogType.AddToQueue,
+    LogType.RemoveFromQueue,
+    LogType.LoadUnloadCycle,
+    LogType.MachineCycle,
+    LogType.BasketLoadUnload,
+    LogType.BasketCycle,
+]).toRSet((eventType) => eventType);
+export function affectedMaterialForInvalidation(events, materialId, process) {
+    let affected = HashMap.empty();
+    for (const event of events) {
+        if (!invalidatableEventTypes.has(event.type) ||
+            isLogEntryInvalidated(event) ||
+            !event.material.some((material) => material.id === materialId && (process === null || material.proc >= process))) {
+            continue;
+        }
+        for (const material of event.material) {
+            affected = affected.set(material.id, material.serial ?? null);
+        }
+    }
+    return affected;
+}
 function InvalidateSelect(props) {
     const lastMat = useAtomValue(materialInDialogLargestUsedProcess);
     const possible = useAtomValue(barcodePotentialNewMaterial);
@@ -63,12 +87,13 @@ function InvalidateSelect(props) {
     function change(e) {
         props.setState({
             updating: false,
+            error: null,
             process: e.startsWith("proc") ? parseInt(e.substring(4)) : null,
             changeRawMat: e.startsWith("rawMat") ? e.substring(6) : null,
             changeJobUnique: e.startsWith("job") ? e.substring(3) : null,
         });
     }
-    return (_jsx(TextField, { value: props.st?.process
+    return (_jsx(TextField, { value: props.st?.process && hasProc
             ? "proc" + props.st.process.toString()
             : props.st?.changeRawMat
                 ? "rawMat" + props.st.changeRawMat
@@ -104,6 +129,8 @@ function InvalidateSelect(props) {
 }
 export function InvalidateCycleDialogContent(props) {
     const curMat = useAtomValue(materialInDialogInfo);
+    const events = useAtomValue(materialInDialogLocalEvents);
+    const status = useAtomValue(currentStatus);
     const show = props.st !== null && curMat !== null;
     const boxRef = useRef(null);
     useEffect(() => {
@@ -114,7 +141,17 @@ export function InvalidateCycleDialogContent(props) {
     }, [boxRef, show]);
     if (!show)
         return _jsx("div", {});
-    return (_jsx(Box, { ref: boxRef, sx: { display: "flex", flexDirection: "column", alignItems: "center", marginTop: "1em" }, children: _jsxs(Stack, { spacing: 2, children: [_jsx("p", { style: { maxWidth: "35em" }, children: "An invalidated cycle remains in the event log, but is not considered when determining the next process to be machined on a piece of material." }), _jsx(InvalidateSelect, { st: props.st, setState: props.setState })] }) }));
+    const process = props.st.process ?? (props.st.changeRawMat || props.st.changeJobUnique ? null : undefined);
+    const affected = process === undefined
+        ? HashMap.empty()
+        : affectedMaterialForInvalidation(events, curMat.materialID, process);
+    const affectedLabels = [...affected].map(([materialId, serial]) => ({
+        materialId,
+        serial,
+        queued: status.material.find((material) => material.materialID === materialId)?.location.type ===
+            LocType.InQueue,
+    }));
+    return (_jsx(Box, { ref: boxRef, sx: { display: "flex", flexDirection: "column", alignItems: "center", marginTop: "1em" }, children: _jsxs(Stack, { spacing: 2, children: [_jsx("p", { style: { maxWidth: "35em" }, children: "Invalidating removes whole recorded cycle events from active material reconstruction while retaining them in the event log." }), _jsx(InvalidateSelect, { st: props.st, setState: props.setState }), affectedLabels.length > 0 ? (_jsxs(_Fragment, { children: [_jsx("p", { children: "All material recorded on these events will be affected:" }), _jsx("ul", { children: affectedLabels.map((material) => (_jsxs("li", { children: [material.serial || `Material ID ${material.materialId}`, material.queued ? " (currently in a queue)" : ""] }, material.materialId))) })] })) : null, props.st.error ? _jsx("p", { role: "alert", children: props.st.error }) : null] }) }));
 }
 export function InvalidateCycleDialogButton(props) {
     const fmsInfo = useAtomValue(fmsInformation);
@@ -132,6 +169,8 @@ export function InvalidateCycleDialogButton(props) {
         return null;
     if (inProcMat && inProcMat.location.type === LocType.OnPallet)
         return null;
+    if (inProcMat && inProcMat.location.type === LocType.InQueue)
+        return null;
     const allowChange = possibleNew !== null &&
         (!LazySeq.ofObject(possibleNew.possibleCastingsByQueue ?? {}).isEmpty() ||
             !LazySeq.ofObject(possibleNew.possibleJobsByQueue ?? {}).isEmpty());
@@ -140,7 +179,13 @@ export function InvalidateCycleDialogButton(props) {
     if (props.ignoreOperator)
         operator = null;
     function showInvalidate() {
-        props.setState({ process: null, updating: false, changeRawMat: null, changeJobUnique: null });
+        props.setState({
+            process: null,
+            updating: false,
+            error: null,
+            changeRawMat: null,
+            changeJobUnique: null,
+        });
     }
     function invalidateCycle() {
         if (curMat && (props.st?.process || props.st?.changeRawMat || props.st?.changeJobUnique)) {
@@ -152,7 +197,7 @@ export function InvalidateCycleDialogButton(props) {
                         type: "MatDetails",
                         details: mat,
                     });
-                    props.onClose();
+                    props.setState(null);
                 }
                 else {
                     setMatToShow(null);
@@ -160,9 +205,15 @@ export function InvalidateCycleDialogButton(props) {
                 }
             })
                 .catch((e) => {
-                console.log(e);
-                setMatToShow(null);
-                props.onClose();
+                props.setState({
+                    ...props.st,
+                    updating: false,
+                    error: ApiException.isApiException(e)
+                        ? e.response
+                        : e instanceof Error
+                            ? e.message
+                            : String(e),
+                });
             });
         }
     }

package/dist/components/station-monitor/LoadStation.js

@@ -51,6 +51,7 @@ import { fmsInformation } from "../../network/server-settings.js";
 import { currentStatus, secondsSinceEpochAtom } from "../../cell-status/current-status.js";
 import { useIsDemo, useSetTitle } from "../routes.js";
 import { QuarantineMatButton } from "./QuarantineButton.js";
+import { CancelLoadButton } from "./CancelLoadButton.js";
 import { durationToSeconds } from "../../util/parseISODuration.js";
 import { formatSeconds } from "./SystemOverview.js";
 import { InvalidateCycleDialogButton, InvalidateCycleDialogContent, SwapMaterialButtons, SwapMaterialDialogContent, } from "./InvalidateCycle.js";
@@ -540,6 +541,7 @@ function AddMatButton({ queues, onClose, toQueue, showAddToQueue, setShowAddToQu
     const inProcMat = useAtomValue(matDetails.inProcessMaterialInDialog);
     const operator = useAtomValue(currentOperator);
     const [addExistingMat, addingExistingMat] = matDetails.useAddExistingMaterialToQueue();
+    const [addError, setAddError] = useState(null);
     if (!existingMat ||
         inProcMat?.location.type === api.LocType.OnPallet ||
         inProcMat?.action.type === api.ActionType.Loading ||
@@ -557,16 +559,26 @@ function AddMatButton({ queues, onClose, toQueue, showAddToQueue, setShowAddToQu
         return (_jsx(Button, { color: "primary", onClick: () => setShowAddToQueue(true), children: "Add To Queue" }));
     }
     else {
-        return (_jsxs(Button, { color: "primary", disabled: toQueue === null || addingExistingMat, onClick: () => {
-                addExistingMat({
-                    materialId: existingMat.materialID,
-                    queue: toQueue ?? "",
-                    queuePosition: -1,
-                    operator: operator,
-                });
-                setMatToShow(null);
-                onClose();
-            }, children: ["Add To ", toQueue ?? "Queue", " ", lastProcMat ? ` To Run Process ${lastProcMat.process + 1}` : ""] }));
+        return (_jsxs(_Fragment, { children: [_jsxs(Button, { color: "primary", disabled: toQueue === null || addingExistingMat, onClick: async () => {
+                        setAddError(null);
+                        try {
+                            await addExistingMat({
+                                materialId: existingMat.materialID,
+                                queue: toQueue ?? "",
+                                queuePosition: -1,
+                                operator: operator,
+                            });
+                            setMatToShow(null);
+                            onClose();
+                        }
+                        catch (e) {
+                            setAddError(api.ApiException.isApiException(e)
+                                ? e.response
+                                : e instanceof Error
+                                    ? e.message
+                                    : String(e));
+                        }
+                    }, children: ["Add To ", toQueue ?? "Queue", " ", lastProcMat ? ` To Run Process ${lastProcMat.process + 1}` : ""] }), addError ? _jsx(Typography, { role: "alert", children: addError }) : null] }));
     }
 }
 function AssignWorkorderButton() {
@@ -593,7 +605,7 @@ const LoadMatDialog = memo(function LoadMatDialog(props) {
         setShowAddMaterial(false);
         setSelectedQueue(null);
     }, [setSwapSt, setInvalidateSt]);
-    return (_jsx(MaterialDialog, { onClose: onClose, allowNote: true, highlightProcsGreaterOrEqualTo: invalidateSt?.process ?? undefined, extraDialogElements: _jsxs(_Fragment, { children: [_jsx(SwapMaterialDialogContent, { st: swapSt, setState: setSwapSt }), invalidateSt !== null ? (_jsx(InvalidateCycleDialogContent, { st: invalidateSt, setState: setInvalidateSt })) : null, showAddMaterial ? (_jsx(PromptForQueue, { selectedQueue: selectedQueue, setSelectedQueue: setSelectedQueue, queueNames: props.queues })) : undefined] }), buttons: _jsxs(_Fragment, { children: [_jsx(InstructionButton, { pallet: props.pallet }), _jsx(PrintLabelButton, {}), _jsx(QuarantineMatButton, {}), _jsx(SignalInspectionButton, {}), _jsx(AddMatButton, { toQueue: selectedQueue, queues: props.queues, onClose: onClose, showAddToQueue: showAddMaterial, setShowAddToQueue: setShowAddMaterial }), _jsx(SwapMaterialButtons, { st: swapSt, setState: setSwapSt, onClose: onClose }), _jsx(InvalidateCycleDialogButton, { st: invalidateSt, setState: setInvalidateSt, onClose: onClose, loadStation: true }), _jsx(AssignWorkorderButton, {})] }) }));
+    return (_jsx(MaterialDialog, { onClose: onClose, allowNote: true, highlightProcsGreaterOrEqualTo: invalidateSt?.process ?? undefined, extraDialogElements: _jsxs(_Fragment, { children: [_jsx(SwapMaterialDialogContent, { st: swapSt, setState: setSwapSt }), invalidateSt !== null ? (_jsx(InvalidateCycleDialogContent, { st: invalidateSt, setState: setInvalidateSt })) : null, showAddMaterial ? (_jsx(PromptForQueue, { selectedQueue: selectedQueue, setSelectedQueue: setSelectedQueue, queueNames: props.queues })) : undefined] }), buttons: _jsxs(_Fragment, { children: [_jsx(InstructionButton, { pallet: props.pallet }), _jsx(PrintLabelButton, {}), _jsx(QuarantineMatButton, {}), _jsx(CancelLoadButton, { onClose: onClose }), _jsx(SignalInspectionButton, {}), _jsx(AddMatButton, { toQueue: selectedQueue, queues: props.queues, onClose: onClose, showAddToQueue: showAddMaterial, setShowAddToQueue: setShowAddMaterial }), _jsx(SwapMaterialButtons, { st: swapSt, setState: setSwapSt, onClose: onClose }), _jsx(InvalidateCycleDialogButton, { st: invalidateSt, setState: setInvalidateSt, onClose: onClose, loadStation: true }), _jsx(AssignWorkorderButton, {})] }) }));
 });
 function useGridLayout({ numMatCols, maxNumFaces, horizontal, showMatInCompleted, }) {
     let rows = "";

package/dist/components/station-monitor/Material.js

@@ -235,14 +235,12 @@ export function MaterialAction({ mat, displayActionForSinglePallet, fsize, }) {
                 }
             }
         case api.ActionType.LoadingToBasket:
-            return (_jsxs(MatCardDetail, { fsize: fsize, children: ["Load into ", basketName, " ", mat.action.loadToBasketId ?? "", mat.action.loadToBasketSlot !== undefined
-                        ? ` slot ${mat.action.loadToBasketSlot + 1}`
-                        : ""] }));
+            return (_jsxs(MatCardDetail, { fsize: fsize, children: ["Load into ", basketName, " ", mat.action.loadToBasketId ?? "", mat.action.loadToBasketSlot !== undefined ? ` slot ${mat.action.loadToBasketSlot}` : ""] }));
         case api.ActionType.UnloadToInProcess:
         case api.ActionType.UnloadToCompletedMaterial:
             if (mat.action.unloadToBasketId) {
                 return (_jsxs(MatCardDetail, { fsize: fsize, children: ["Unload to ", basketName, " ", mat.action.unloadToBasketId, mat.action.unloadToBasketSlot !== undefined
-                            ? ` slot ${mat.action.unloadToBasketSlot + 1}`
+                            ? ` slot ${mat.action.unloadToBasketSlot}`
                             : ""] }));
             }
             else if (mat.action.unloadIntoQueue) {

package/dist/components/station-monitor/QuarantineButton.js

@@ -37,7 +37,7 @@ import { LazySeq } from "@seedtactics/immutable-collections";
 import { currentStatus } from "../../cell-status/current-status.js";
 import { inProcessMaterialInDialog, materialDialogOpen, useRemoveFromQueue, useSignalForQuarantine, } from "../../cell-status/material-details.js";
 import { currentOperator } from "../../data/operators.js";
-import { ActionType, LocType, PalletLocationEnum, QueueRole } from "../../network/api.js";
+import { ActionType, ApiException, LocType, QueueRole, } from "../../network/api.js";
 import { fmsInformation } from "../../network/server-settings.js";
 import { useAtomValue, useSetAtom } from "jotai";
 function useQuarantineMaterial(ignoreOperator) {
@@ -70,75 +70,48 @@ function useQuarantineMaterial(ignoreOperator) {
     const quarantineQueues = LazySeq.ofObject(curSt.queues)
         .filter(([qname, _]) => !activeQueues.has(qname))
         .toRSet(([qname, _]) => qname);
-    const palLoc = LazySeq.ofObject(curSt.pallets).toOrderedMap(([_, pal]) => [
-        pal.palletNum,
-        pal.currentPalletLocation,
-    ]);
     // If in a quarantine queue, allow removal from system
     if (inProcMat.location.type === LocType.InQueue &&
         inProcMat.location.currentQueue &&
         quarantineQueues.has(inProcMat.location.currentQueue)) {
         return {
             type: "Remove",
+            material: inProcMat,
             quarantine: () => removeFromQueue(inProcMat.materialID, operator),
             removing: removingFromQueue,
             quarantineQueueDestination: null,
+            removeFromQueues: null,
+            removingFromQueues: removingFromQueue,
         };
     }
     let type = null;
     switch (inProcMat.location.type) {
         case LocType.OnPallet:
-            if (fmsInfo.allowQuarantineToCancelLoad) {
-                // either cancel load or signal based on material action and pallet location
-                const palAtLoad = inProcMat.location.palletNum &&
-                    palLoc.get(inProcMat.location.palletNum)?.loc === PalletLocationEnum.LoadUnload;
-                if (inProcMat.action.type === ActionType.Loading || palAtLoad) {
-                    type = "CancelLoad";
-                }
-                else {
-                    type = "SignalForScrap";
-                }
+            if (inProcMat.action.type === ActionType.Loading) {
+                return null;
             }
-            else {
-                // must signal since it is currently on a pallet, but only if the material is not loading
-                if (inProcMat.action.type === ActionType.Loading) {
-                    return null;
-                }
-                // Check that the job outputs to a queue, only then can signaling for quarantine work
-                const job = curSt.jobs[inProcMat.jobUnique];
-                if (!job)
-                    return null;
-                const path = job.procsAndPaths?.[inProcMat.process - 1]?.paths?.[inProcMat.path - 1];
-                if (inProcMat.process != job.procsAndPaths.length && (!path || !path.outputQueue)) {
-                    return null;
-                }
-                type = "SignalForScrap";
+            // Check that the job outputs to a queue, only then can signaling for quarantine work
+            const job = curSt.jobs[inProcMat.jobUnique];
+            if (!job)
+                return null;
+            const path = job.procsAndPaths?.[inProcMat.process - 1]?.paths?.[inProcMat.path - 1];
+            if (inProcMat.process != job.procsAndPaths.length && (!path || !path.outputQueue)) {
+                return null;
             }
+            type = "SignalForScrap";
             break;
         case LocType.InQueue:
-            if ((inProcMat.action.type === ActionType.Loading ||
-                inProcMat.action.type === ActionType.LoadingToBasket) &&
-                !fmsInfo.allowQuarantineToCancelLoad) {
-                return null;
-            }
-            else if (inProcMat.action.type === ActionType.Loading ||
+            if (inProcMat.action.type === ActionType.Loading ||
                 inProcMat.action.type === ActionType.LoadingToBasket) {
-                type = "CancelLoad";
-            }
-            else {
-                type = "Scrap";
+                return null;
             }
+            type = "Scrap";
             break;
         case LocType.InBasket:
-            if (inProcMat.action.type === ActionType.Loading && !fmsInfo.allowQuarantineToCancelLoad) {
+            if (inProcMat.action.type === ActionType.Loading) {
                 return null;
             }
-            else if (inProcMat.action.type === ActionType.Loading) {
-                type = "CancelLoad";
-            }
-            else {
-                type = "Scrap";
-            }
+            type = "Scrap";
             break;
         case LocType.Free:
             type = "Scrap";
@@ -147,18 +120,51 @@ function useQuarantineMaterial(ignoreOperator) {
     if (type) {
         return {
             type,
-            quarantine: (reason) => signalQuarantine(inProcMat.materialID, operator, reason),
+            material: inProcMat,
+            quarantine: async (reason) => signalQuarantine(inProcMat.materialID, operator, reason),
             removing: signalingQuarantine,
             quarantineQueueDestination: quarantineQueue,
+            removeFromQueues: inProcMat.location.type === LocType.InQueue &&
+                inProcMat.location.currentQueue !== undefined &&
+                activeQueues.has(inProcMat.location.currentQueue) &&
+                inProcMat.action.type === ActionType.Waiting
+                ? () => removeFromQueue(inProcMat.materialID, operator)
+                : null,
+            removingFromQueues: removingFromQueue,
         };
     }
     else {
         return null;
     }
 }
+function RemoveFromQueuesButton({ material, removeFromQueues, removing, }) {
+    const [open, setOpen] = useState(false);
+    const [error, setError] = useState(null);
+    const setMatToShow = useSetAtom(materialDialogOpen);
+    async function remove() {
+        setError(null);
+        try {
+            await removeFromQueues();
+            setOpen(false);
+            setMatToShow({
+                type: "MatSummary",
+                summary: {
+                    materialID: material.materialID,
+                    partName: material.partName,
+                    serial: material.serial,
+                },
+            });
+        }
+        catch (e) {
+            setError(ApiException.isApiException(e) ? e.response : e instanceof Error ? e.message : String(e));
+        }
+    }
+    return (_jsxs(_Fragment, { children: [_jsx(Tooltip, { title: "Remove from all queues", children: _jsx(Button, { color: "primary", disabled: removing, onClick: () => setOpen(true), children: "Remove from Queues" }) }), _jsxs(Dialog, { open: open, onClose: () => setOpen(false), children: [_jsx(DialogTitle, { children: "Remove Material from Queues" }), _jsxs(DialogContent, { children: [_jsx("p", { children: "The material will be removed from all queues." }), error ? _jsx("p", { role: "alert", children: error }) : null] }), _jsxs(DialogActions, { children: [_jsx(Button, { color: "primary", disabled: removing, onClick: remove, children: "Remove from Queues" }), _jsx(Button, { color: "secondary", disabled: removing, onClick: () => setOpen(false), children: "Cancel" })] })] })] }));
+}
 export function QuarantineMatButton({ onClose, ignoreOperator, }) {
     const [open, setOpen] = useState(false);
     const [reason, setReason] = useState("");
+    const [error, setError] = useState(null);
     const q = useQuarantineMaterial(!!ignoreOperator);
     const setMatToShow = useSetAtom(materialDialogOpen);
     if (q === null)
@@ -182,19 +188,33 @@ export function QuarantineMatButton({ onClose, ignoreOperator, }) {
                 : "After unload, remove the part as scrap";
             btnTxt = q.quarantineQueueDestination ? "Quarantine" : "Scrap";
             break;
-        case "CancelLoad":
-            title = q.quarantineQueueDestination
-                ? `Cancel load and move to ${q.quarantineQueueDestination}`
-                : "Cancel load";
-            btnTxt = "Cancel Load";
-            break;
     }
-    function quarantine() {
-        q?.quarantine(reason);
-        setMatToShow(null);
-        setOpen(false);
-        setReason("");
-        onClose?.();
+    async function quarantine() {
+        if (!q)
+            return;
+        setError(null);
+        try {
+            await q.quarantine(reason);
+            setOpen(false);
+            setReason("");
+            if (q.type === "Remove") {
+                setMatToShow({
+                    type: "MatSummary",
+                    summary: {
+                        materialID: q.material.materialID,
+                        partName: q.material.partName,
+                        serial: q.material.serial,
+                    },
+                });
+            }
+            else {
+                setMatToShow(null);
+                onClose?.();
+            }
+        }
+        catch (e) {
+            setError(ApiException.isApiException(e) ? e.response : e instanceof Error ? e.message : String(e));
+        }
     }
-    return (_jsxs(_Fragment, { children: [_jsx(Tooltip, { title: title, children: _jsx(Button, { color: "primary", disabled: q.removing, onClick: () => setOpen(true), children: btnTxt }) }), _jsxs(Dialog, { open: open, onClose: () => setOpen(false), children: [_jsx(DialogTitle, { children: "Quarantine Material" }), _jsxs(DialogContent, { children: [_jsx("p", { children: title }), _jsx(TextField, { label: "Reason", value: reason, onChange: (e) => setReason(e.target.value), fullWidth: true, autoFocus: true, multiline: true })] }), _jsxs(DialogActions, { children: [_jsx(Button, { color: "primary", onClick: quarantine, children: btnTxt }), _jsx(Button, { color: "secondary", onClick: () => setOpen(false), children: "Cancel" })] })] })] }));
+    return (_jsxs(_Fragment, { children: [_jsx(Tooltip, { title: title, children: _jsx(Button, { color: "primary", disabled: q.removing, onClick: () => setOpen(true), children: btnTxt }) }), q.removeFromQueues ? (_jsx(RemoveFromQueuesButton, { material: q.material, removeFromQueues: q.removeFromQueues, removing: q.removingFromQueues })) : null, _jsxs(Dialog, { open: open, onClose: () => setOpen(false), children: [_jsx(DialogTitle, { children: "Quarantine Material" }), _jsxs(DialogContent, { children: [_jsx("p", { children: title }), _jsx(TextField, { label: "Reason", value: reason, onChange: (e) => setReason(e.target.value), fullWidth: true, autoFocus: true, multiline: true }), error ? _jsx("p", { role: "alert", children: error }) : null] }), _jsxs(DialogActions, { children: [_jsx(Button, { color: "primary", disabled: q.removing, onClick: quarantine, children: btnTxt }), _jsx(Button, { color: "secondary", onClick: () => setOpen(false), children: "Cancel" })] })] })] }));
 }

package/dist/components/station-monitor/Queues.js

@@ -69,6 +69,7 @@ import { materialDialogOpen } from "../../cell-status/material-details.js";
 import { PrintLabelButton } from "./PrintedLabel.js";
 import { AddToQueueButton, AddToQueueMaterialDialogCt, } from "./QueuesAddMaterial.js";
 import { QuarantineMatButton } from "./QuarantineButton.js";
+import { CancelLoadButton } from "./CancelLoadButton.js";
 import { AddByBarcodeDialog, scanBarcodeToAddToQueueDialog } from "../BarcodeScanning.js";
 import { InvalidateCycleDialogButton, InvalidateCycleDialogContent, } from "./InvalidateCycle.js";
 const JobTableRow = styled(TableRow, { shouldForwardProp: (prop) => prop.toString()[0] !== "$" })(({ $noBorderBottom, $highlightedRow, $noncompletedRow }) => ({
@@ -287,7 +288,7 @@ const QueuedMaterialDialog = memo(function QueuedMaterialDialog({ queueNames, })
         setInvalidateSt(null);
     }, []);
     queueNames = usePossibleQueuesForAdd(queueNames);
-    return (_jsx(MaterialDialog, { allowNote: true, onClose: onClose, highlightProcsGreaterOrEqualTo: invalidateSt?.process ?? undefined, extraDialogElements: _jsxs(_Fragment, { children: [_jsx(InvalidateCycleDialogContent, { st: invalidateSt, setState: setInvalidateSt }), _jsx(AddToQueueMaterialDialogCt, { queueNames: queueNames, st: addMatSt, setState: setAddMatSt })] }), buttons: _jsxs(_Fragment, { children: [_jsx(PrintLabelButton, {}), _jsx(QuarantineMatButton, { onClose: onClose }), _jsx(InvalidateCycleDialogButton, { onClose: onClose, st: invalidateSt, setState: setInvalidateSt }), _jsx(AddToQueueButton, { st: addMatSt, queueNames: queueNames, onClose: onClose })] }) }));
+    return (_jsx(MaterialDialog, { allowNote: true, onClose: onClose, highlightProcsGreaterOrEqualTo: invalidateSt?.process ?? undefined, extraDialogElements: _jsxs(_Fragment, { children: [_jsx(InvalidateCycleDialogContent, { st: invalidateSt, setState: setInvalidateSt }), _jsx(AddToQueueMaterialDialogCt, { queueNames: queueNames, st: addMatSt, setState: setAddMatSt })] }), buttons: _jsxs(_Fragment, { children: [_jsx(PrintLabelButton, {}), _jsx(QuarantineMatButton, { onClose: onClose }), _jsx(CancelLoadButton, { onClose: onClose }), _jsx(InvalidateCycleDialogButton, { onClose: onClose, st: invalidateSt, setState: setInvalidateSt }), _jsx(AddToQueueButton, { st: addMatSt, queueNames: queueNames, onClose: onClose })] }) }));
 });
 export const Queues = (props) => {
     const operator = useAtomValue(currentOperator);

package/dist/components/station-monitor/QueuesAddMaterial.js

@@ -183,6 +183,7 @@ export function AddToQueueButton({ st: { enteredOperator, newMaterialTy, toQueue
     const [addExistingMat, addingExistingMat] = matDetails.useAddExistingMaterialToQueue();
     const [addNewMat, addingNewMat] = matDetails.useAddNewMaterialToQueue();
     const [addNewCasting, addingNewCasting] = useAddNewCastingToQueue();
+    const [addError, setAddError] = useState(null);
     const allowAdd = useAllowAddToQueue(queueNames);
     if (!allowAdd) {
         return null;
@@ -213,52 +214,62 @@ export function AddToQueueButton({ st: { enteredOperator, newMaterialTy, toQueue
         withSerialMsg = " With Serial " + newSerial;
     }
     const curQueue = inProcMat?.location.currentQueue ?? null;
-    return (_jsx(_Fragment, { children: _jsx(Tooltip, { title: toQueue === null
-                ? "Select a queue to add the material to"
-                : fmsInfo.requireOperatorNamePromptWhenAddingMaterial &&
-                    (enteredOperator === null || enteredOperator === "")
-                    ? "Please enter an operator name"
-                    : "", children: _jsx("span", { children: _jsx(Button, { color: "primary", disabled: toQueue === null ||
-                        addingExistingMat ||
-                        addingNewMat ||
-                        addingNewCasting ||
-                        (existingMat === null && newMaterialTy === null) ||
-                        (fmsInfo.requireOperatorNamePromptWhenAddingMaterial &&
-                            (enteredOperator === null || enteredOperator === "")), onClick: () => {
-                        if (existingMat) {
-                            addExistingMat({
-                                materialId: existingMat.materialID,
-                                queue: toQueue ?? "",
-                                queuePosition: -1,
-                                operator: enteredOperator ?? operator,
-                            });
-                        }
-                        else if (newMaterialTy &&
-                            newMaterialTy.kind === "JobAndProc" &&
-                            newMaterialTy.jobUnique) {
-                            addNewMat({
-                                jobUnique: newMaterialTy.jobUnique,
-                                lastCompletedProcess: newMaterialTy.last_proc,
-                                serial: newSerial ?? undefined,
-                                workorder: newWorkorder ?? newMaterialTy?.workorder,
-                                queue: toQueue ?? "",
-                                queuePosition: -1,
-                                operator: enteredOperator ?? operator,
-                            });
-                        }
-                        else if (newMaterialTy &&
-                            newMaterialTy.kind === "RawMat" &&
-                            newMaterialTy.rawMatName) {
-                            addNewCasting({
-                                casting: newMaterialTy.rawMatName,
-                                quantity: 1,
-                                queue: toQueue ?? "",
-                                serials: newSerial ? [newSerial] : undefined,
-                                workorder: newWorkorder,
-                                operator: enteredOperator ?? operator,
-                            });
-                        }
-                        setMatToShow(null);
-                        onClose();
-                    }, children: toQueue === null ? ("Add to Queue") : (_jsxs("span", { children: [curQueue !== null ? `Move From ${curQueue} To` : "Add To", " ", toQueue, withSerialMsg, addProcMsg] })) }) }) }) }));
+    return (_jsxs(_Fragment, { children: [_jsx(Tooltip, { title: toQueue === null
+                    ? "Select a queue to add the material to"
+                    : fmsInfo.requireOperatorNamePromptWhenAddingMaterial &&
+                        (enteredOperator === null || enteredOperator === "")
+                        ? "Please enter an operator name"
+                        : "", children: _jsx("span", { children: _jsx(Button, { color: "primary", disabled: toQueue === null ||
+                            addingExistingMat ||
+                            addingNewMat ||
+                            addingNewCasting ||
+                            (existingMat === null && newMaterialTy === null) ||
+                            (fmsInfo.requireOperatorNamePromptWhenAddingMaterial &&
+                                (enteredOperator === null || enteredOperator === "")), onClick: async () => {
+                            setAddError(null);
+                            try {
+                                if (existingMat) {
+                                    await addExistingMat({
+                                        materialId: existingMat.materialID,
+                                        queue: toQueue ?? "",
+                                        queuePosition: -1,
+                                        operator: enteredOperator ?? operator,
+                                    });
+                                }
+                                else if (newMaterialTy &&
+                                    newMaterialTy.kind === "JobAndProc" &&
+                                    newMaterialTy.jobUnique) {
+                                    await addNewMat({
+                                        jobUnique: newMaterialTy.jobUnique,
+                                        lastCompletedProcess: newMaterialTy.last_proc,
+                                        serial: newSerial ?? undefined,
+                                        workorder: newWorkorder ?? newMaterialTy?.workorder,
+                                        queue: toQueue ?? "",
+                                        queuePosition: -1,
+                                        operator: enteredOperator ?? operator,
+                                    });
+                                }
+                                else if (newMaterialTy &&
+                                    newMaterialTy.kind === "RawMat" &&
+                                    newMaterialTy.rawMatName) {
+                                    await addNewCasting({
+                                        casting: newMaterialTy.rawMatName,
+                                        quantity: 1,
+                                        queue: toQueue ?? "",
+                                        serials: newSerial ? [newSerial] : undefined,
+                                        workorder: newWorkorder,
+                                        operator: enteredOperator ?? operator,
+                                    });
+                                }
+                                setMatToShow(null);
+                                onClose();
+                            }
+                            catch (e) {
+                                setAddError(api.ApiException.isApiException(e)
+                                    ? e.response
+                                    : e instanceof Error
+                                        ? e.message
+                                        : String(e));
+                            }
+                        }, children: toQueue === null ? ("Add to Queue") : (_jsxs("span", { children: [curQueue !== null ? `Move From ${curQueue} To` : "Add To", " ", toQueue, withSerialMsg, addProcMsg] })) }) }) }), addError ? _jsx("p", { role: "alert", children: addError }) : null] }));
 }

package/dist/components/station-monitor/SystemOverview.js

@@ -43,6 +43,7 @@ import { last30Jobs } from "../../cell-status/scheduled-jobs.js";
 import { addDays } from "date-fns";
 import { durationToSeconds } from "../../util/parseISODuration.js";
 import { InvalidateCycleDialogButton, InvalidateCycleDialogContent, SwapMaterialButtons, SwapMaterialDialogContent, } from "./InvalidateCycle.js";
+import { CancelLoadButton } from "./CancelLoadButton.js";
 import { QuarantineMatButton } from "./QuarantineButton.js";
 import { SelectInspTypeDialog, SignalInspectionButton } from "./SelectInspType.js";
 import { useSetTitle } from "../routes.js";
@@ -446,7 +447,7 @@ function PalletFaces({ maxNumFaces, mats: allMats, loadingOntoPallet, noFilter,
     }
 }
 function BasketContents({ mats }) {
-    const byPosition = LazySeq.of(mats).orderedGroupBy((m) => (m.location.basketSlot ?? 0) + 1);
+    const byPosition = LazySeq.of(mats).orderedGroupBy((m) => m.location.basketSlot ?? 0);
     return (_jsx(Box, { sx: {
             display: "flex",
             flexWrap: "wrap",
@@ -825,7 +826,7 @@ const SystemOverviewMaterialDialog = memo(function SystemOverviewMaterialDialog(
         setSwapSt(null);
         setInvalidateSt(null);
     }
-    return (_jsx(MaterialDialog, { onClose: onClose, allowNote: true, highlightProcsGreaterOrEqualTo: invalidateSt?.process ?? undefined, extraDialogElements: _jsxs(_Fragment, { children: [_jsx(SwapMaterialDialogContent, { st: swapSt, setState: setSwapSt }), invalidateSt !== null ? (_jsx(InvalidateCycleDialogContent, { st: invalidateSt, setState: setInvalidateSt })) : null] }), buttons: _jsxs(_Fragment, { children: [_jsx(QuarantineMatButton, { ignoreOperator: ignoreOperator }), _jsx(SignalInspectionButton, {}), _jsx(SwapMaterialButtons, { st: swapSt, setState: setSwapSt, onClose: onClose, ignoreOperator: ignoreOperator }), _jsx(InvalidateCycleDialogButton, { st: invalidateSt, setState: setInvalidateSt, onClose: onClose, ignoreOperator: ignoreOperator })] }) }));
+    return (_jsx(MaterialDialog, { onClose: onClose, allowNote: true, highlightProcsGreaterOrEqualTo: invalidateSt?.process ?? undefined, extraDialogElements: _jsxs(_Fragment, { children: [_jsx(SwapMaterialDialogContent, { st: swapSt, setState: setSwapSt }), invalidateSt !== null ? (_jsx(InvalidateCycleDialogContent, { st: invalidateSt, setState: setInvalidateSt })) : null] }), buttons: _jsxs(_Fragment, { children: [_jsx(QuarantineMatButton, { ignoreOperator: ignoreOperator }), _jsx(CancelLoadButton, { onClose: onClose, ignoreOperator: ignoreOperator }), _jsx(SignalInspectionButton, {}), _jsx(SwapMaterialButtons, { st: swapSt, setState: setSwapSt, onClose: onClose, ignoreOperator: ignoreOperator }), _jsx(InvalidateCycleDialogButton, { st: invalidateSt, setState: setInvalidateSt, onClose: onClose, ignoreOperator: ignoreOperator })] }) }));
 });
 export function SystemOverviewPage({ ignoreOperator, whiteBackground, }) {
     useSetTitle("System Overview");

package/dist/components/station-monitor/Whiteboard.js

@@ -58,12 +58,12 @@ export const SortableRegion = memo(function SortableRegion(props) {
             const overMatId = over ? numericId(over.id) : null;
             if (over && active.id !== over.id && activeMatId !== null && overMatId !== null) {
                 const overIdx = props.matIds.indexOf(overMatId);
-                addExistingMatToQueue({
+                void addExistingMatToQueue({
                     materialId: activeMatId,
                     queue: props.queueName,
                     queuePosition: overIdx,
                     operator: operator,
-                });
+                }).catch(console.error);
                 reorderQueuedMat({
                     queue: props.queueName,
                     matId: activeMatId,

package/dist/extension.d.ts

@@ -0,0 +1,11 @@
+import type { AppProps } from "./components/App.js";
+/**
+ * Starts one complete FMS Insight application with optional statically composed custom pages.
+ */
+export declare function bootstrapInsight(appProps?: AppProps, rootElement?: HTMLElement): Promise<void>;
+export { customState } from "./cell-status/custom-state.js";
+export type { AppProps };
+export { defaultChooseModes } from "./components/ChooseMode.js";
+export type { ChooseModeItem } from "./components/ChooseMode.js";
+export { RouteLocation } from "./components/routes.js";
+export { authenticatedFetch } from "./network/backend.js";