@seedtactics/insight-client 17.0.1-beta.6 → 17.0.1-beta.8

package/dist/cell-status/inspections.js

@@ -185,26 +185,6 @@ export const updateLast30Inspections = atom(null, (_, set, { evt, now, expire })
             return parts.union(LazySeq.of(log).toLookupMap((e) => e.key, (e) => e.entry.cntr, (e) => e.entry), (e1, e2) => e1.union(e2));
         });
     }
-    else if (evt.editMaterialInLog) {
-        const changedByCntr = evt.editMaterialInLog.editedEvents;
-        set(last30InspectionsRW, (parts) => parts.collectValues((entries) => {
-            for (const changed of changedByCntr) {
-                // inspection logs have only a single material
-                const mat = changed?.material[0];
-                const old = entries.get(changed.counter);
-                if (old !== undefined && mat) {
-                    const newEntry = {
-                        ...old,
-                        materialID: mat.id,
-                        serial: mat.serial,
-                        workorder: mat.workorder,
-                    };
-                    entries = entries.set(changed.counter, newEntry);
-                }
-            }
-            return entries;
-        }));
-    }
 });
 export const setSpecificMonthInspections = atom(null, (_, set, log) => {
     set(specificMonthInspectionsRW, LazySeq.of(log)

package/dist/cell-status/material-summary.js

@@ -30,7 +30,7 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-import { LogType, } from "../network/api.js";
+import { LogType } from "../network/api.js";
 import { addDays } from "date-fns";
 import { HashMap, LazySeq, HashSet } from "@seedtactics/immutable-collections";
 import { atom } from "jotai";
@@ -203,88 +203,6 @@ function filter_old(expire, { matIdsForJob, matsById }) {
     matsById = matsById.filter((e) => e.last_event >= expire);
     return { matIdsForJob, matsById };
 }
-function process_swap(swap, st) {
-    let jobs = st.matIdsForJob;
-    const oldMatFromState = st.matsById.get(swap.oldMaterialID) ?? null;
-    const newMatFromState = st.matsById.get(swap.newMaterialID) ?? null;
-    if (oldMatFromState === null)
-        return st;
-    let oldMat = oldMatFromState;
-    let newMat;
-    if (newMatFromState === null) {
-        newMat = {
-            materialID: swap.newMaterialID,
-            jobUnique: oldMat.jobUnique,
-            partName: oldMat.partName,
-            last_event: oldMat.last_event,
-            numProcesses: oldMat.numProcesses,
-            startedProcess1: true,
-            unloaded_processes: {},
-            signaledInspections: [],
-            quarantineAfterUnload: null,
-            completedInspections: {},
-        };
-    }
-    else {
-        newMat = newMatFromState;
-    }
-    if (oldMat.jobUnique &&
-        oldMat.jobUnique !== "" &&
-        (!newMat.jobUnique || newMat.jobUnique === "")) {
-        // Swap newMat from raw material
-        const forJob = jobs.get(oldMat.jobUnique);
-        if (forJob !== undefined) {
-            jobs = jobs.set(oldMat.jobUnique, forJob.delete(oldMat.materialID).add(newMat.materialID));
-        }
-        newMat = { ...newMat, jobUnique: oldMat.jobUnique };
-        oldMat = { ...oldMat, jobUnique: "" };
-    }
-    const oldMatUnloads = oldMat.unloaded_processes;
-    oldMat = { ...oldMat, unloaded_processes: newMat.unloaded_processes };
-    newMat = { ...newMat, unloaded_processes: oldMatUnloads };
-    for (const evt of swap.editedEvents) {
-        const newMatFromEvt = evt.material.find((m) => m.id === swap.newMaterialID);
-        if (newMatFromEvt) {
-            newMat = {
-                ...newMat,
-                serial: newMatFromEvt.serial ?? newMat.serial,
-                workorderId: newMatFromEvt.workorder ?? newMat.workorderId,
-            };
-        }
-        switch (evt.type) {
-            case LogType.Inspection:
-            case LogType.InspectionForce: {
-                const inspType = evt.program;
-                let inspect;
-                if (evt.result.toLowerCase() === "true" || evt.result === "1") {
-                    inspect = true;
-                }
-                else {
-                    inspect = false;
-                }
-                if (inspect) {
-                    // remove from oldMat, add to newMat
-                    oldMat = {
-                        ...oldMat,
-                        signaledInspections: LazySeq.of(oldMat.signaledInspections)
-                            .filter((i) => i !== inspType)
-                            .toRArray(),
-                    };
-                    newMat = {
-                        ...newMat,
-                        signaledInspections: LazySeq.of([...newMat.signaledInspections, inspType])
-                            .distinct()
-                            .toSortedArray((x) => x),
-                    };
-                }
-            }
-        }
-    }
-    return {
-        matsById: st.matsById.set(oldMat.materialID, oldMat).set(newMat.materialID, newMat),
-        matIdsForJob: jobs,
-    };
-}
 export const setLast30MatSummary = atom(null, (_, set, log) => {
     set(last30MaterialSummaryRW, (st) => log.reduce(process_event, st));
 });
@@ -301,10 +219,6 @@ export const updateLast30MatSummary = atom(null, (_, set, { evt, now, expire })
             }
         });
     }
-    else if (evt.editMaterialInLog) {
-        const edit = evt.editMaterialInLog;
-        set(last30MaterialSummaryRW, (st) => process_swap(edit, st));
-    }
 });
 export const setSpecificMonthMatSummary = atom(null, (_, set, log) => {
     set(specificMonthMaterialSummaryRW, log.reduce(process_event, {

package/dist/cell-status/station-cycles.d.ts

@@ -43,6 +43,7 @@ export declare function loadStationDisplayName(stationNumber: number, loadStatio
 export declare function displayStationName(stationGroup: string, stationNumber: number, loadStationNames: {
     [key: string]: string;
 } | undefined): string;
+export declare function basketSlotLabel(slot: number): string;
 export declare function basketDisplayName(basketName: string | null | undefined): string;
 export declare function carrierLabel(cycle: Readonly<PartCycleData>, basketName?: string): string;
 export declare function carrierSortKey(cycle: Readonly<PartCycleData>): number;

package/dist/cell-status/station-cycles.js

@@ -72,6 +72,17 @@ export function displayStationName(stationGroup, stationNumber, loadStationNames
         ? loadStationDisplayName(stationNumber, loadStationNames)
         : stat_name_and_num(stationGroup, stationNumber);
 }
+// Basket slots retain one-based numeric identities in the API and persistence. The operator UI
+// displays them alphabetically: 1=A, 2=B, ..., 26=Z, 27=AA.
+export function basketSlotLabel(slot) {
+    if (!Number.isSafeInteger(slot) || slot <= 0)
+        return String(slot);
+    let label = "";
+    for (let remaining = slot; remaining > 0; remaining = Math.floor((remaining - 1) / 26)) {
+        label = String.fromCharCode(65 + ((remaining - 1) % 26)) + label;
+    }
+    return label;
+}
 export function basketDisplayName(basketName) {
     return basketName && basketName.trim().length > 0 ? basketName : "Basket";
 }
@@ -151,16 +162,6 @@ function convertOldLogsToCycles(estimateCycleTimes, log, loadStationNames) {
         .collect((c) => convertLogToCycle(estimateCycleTimes, c.cycle, c.elapsedForSingleMaterialMinutes, loadStationNames))
         .buildHashMap((c) => c.cntr);
 }
-function process_swap(swap, partCycles) {
-    for (const changed of swap.editedEvents) {
-        const c = partCycles.get(changed.counter);
-        if (c !== undefined) {
-            const newC = { ...c, material: changed.material };
-            partCycles = partCycles.set(changed.counter, newC);
-        }
-    }
-    return partCycles;
-}
 export const setLast30StationCycles = atom(null, (get, set, log) => {
     const estimatedCycleTimes = get(last30EstimatedCycleTimes);
     const loadStationNames = get(fmsInformation)?.loadStationNames;
@@ -204,10 +205,6 @@ export const updateLast30StationCycles = atom(null, (get, set, { evt, now, expir
             return cycles;
         });
     }
-    else if (evt.editMaterialInLog) {
-        const edit = evt.editMaterialInLog;
-        set(last30StationCyclesRW, (oldCycles) => process_swap(edit, oldCycles));
-    }
 });
 export const setSpecificMonthStationCycles = atom(null, (get, set, log) => {
     const estimatedCycleTimes = get(specificMonthEstimatedCycleTimes);

package/dist/components/operations/AllMaterial.js

@@ -39,7 +39,7 @@ import { Box } from "@mui/material";
 import { Typography } from "@mui/material";
 import { LazySeq } from "@seedtactics/immutable-collections";
 import { DragOverlayInProcMaterial, InProcMaterial, MaterialDialog, SortableInProcMaterial, } from "../station-monitor/Material.js";
-import { InvalidateCycleDialogButton, InvalidateCycleDialogContent, SwapMaterialButtons, SwapMaterialDialogContent, } from "../station-monitor/InvalidateCycle.js";
+import { InvalidateCycleDialogButton, InvalidateCycleDialogContent, } from "../station-monitor/InvalidateCycle.js";
 import { horizontalListSortingStrategy, SortableContext, useSortable, verticalListSortingStrategy, } from "@dnd-kit/sortable";
 import { closestCenter, DndContext, DragOverlay, getFirstCollision, MeasuringStrategy, pointerWithin, rectIntersection, } from "@dnd-kit/core";
 import { QuarantineMatButton } from "../station-monitor/QuarantineButton.js";
@@ -147,13 +147,11 @@ function MaterialBinColumn({ matBin, isDragOverlay, }) {
     }
 }
 const AllMatDialog = memo(function AllMatDialog() {
-    const [swapSt, setSwapSt] = useState(null);
     const [invalidateSt, setInvalidateSt] = useState(null);
     function onClose() {
-        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, { onClose: onClose, ignoreOperator: true }), _jsx(CancelLoadButton, { onClose: onClose, ignoreOperator: true }), _jsx(SwapMaterialButtons, { st: swapSt, setState: setSwapSt, onClose: onClose, ignoreOperator: true }), _jsx(InvalidateCycleDialogButton, { st: invalidateSt, setState: setInvalidateSt, onClose: onClose, ignoreOperator: true })] }) }));
+    return (_jsx(MaterialDialog, { onClose: onClose, allowNote: true, highlightProcsGreaterOrEqualTo: invalidateSt?.process ?? undefined, extraDialogElements: _jsx(_Fragment, { children: invalidateSt !== null ? (_jsx(InvalidateCycleDialogContent, { st: invalidateSt, setState: setInvalidateSt })) : null }), buttons: _jsxs(_Fragment, { children: [_jsx(QuarantineMatButton, { onClose: onClose, ignoreOperator: true }), _jsx(CancelLoadButton, { onClose: onClose, ignoreOperator: true }), _jsx(InvalidateCycleDialogButton, { st: invalidateSt, setState: setInvalidateSt, onClose: onClose, ignoreOperator: true })] }) }));
 });
 function useCollisionDetection(allBins) {
     return useCallback((args) => {

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

@@ -31,6 +31,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 import { useMemo, useState } from "react";
 import { Alert, Box, Button, Stack, Typography } from "@mui/material";
 import { LazySeq } from "@seedtactics/immutable-collections";
+import { basketSlotLabel } from "../../cell-status/station-cycles.js";
 import * as api from "../../network/api.js";
 import { InProcMaterial } from "./Material.js";
 import { MoveMaterialArrowNode } from "./MoveMaterialArrows.js";
@@ -69,14 +70,48 @@ function basketAction(mat, basketId) {
     }
     return undefined;
 }
-function confirmableWork(material, basketId) {
+function stationWork(material, basket) {
     const classifiedActions = LazySeq.of(material)
-        .collect((mat) => basketAction(mat, basketId))
+        .collect((mat) => basketAction(mat, basket.basketId))
         .toRArray();
     if (classifiedActions.some((action) => action.type === "invalid")) {
         return { type: "inconsistent" };
     }
     const validActions = classifiedActions.filter((action) => action.type === "valid");
+    const descriptor = basket.loadStationWork;
+    if (descriptor !== undefined) {
+        if (!descriptor ||
+            !isNonBlank(descriptor.workId) ||
+            typeof descriptor.readyToConfirm !== "boolean")
+            return { type: "inconsistent" };
+        const awaiting = descriptor.awaitingMaterialSlots ?? [];
+        if (!Array.isArray(awaiting) ||
+            !awaiting.every(isPositiveInteger) ||
+            new Set(awaiting).size !== awaiting.length ||
+            (descriptor.readyToConfirm && awaiting.length > 0) ||
+            validActions.some((action) => action.workId !== descriptor.workId))
+            return { type: "inconsistent" };
+        const empty = descriptor.type === api.BasketLoadStationWorkType.ConfirmEmptyBasket;
+        if (empty) {
+            if (validActions.length > 0 ||
+                awaiting.length > 0 ||
+                material.some((mat) => mat.location.type === api.LocType.InBasket && mat.location.basketId === basket.basketId))
+                return { type: "inconsistent" };
+        }
+        else if (descriptor.type !== api.BasketLoadStationWorkType.Material ||
+            (descriptor.readyToConfirm && validActions.length === 0)) {
+            return { type: "inconsistent" };
+        }
+        return {
+            type: "active",
+            work: {
+                workId: descriptor.workId,
+                ready: descriptor.readyToConfirm,
+                confirmEmpty: empty,
+                awaitingSlots: awaiting,
+            },
+        };
+    }
     if (validActions.length === 0)
         return { type: "none" };
     const tagged = validActions.filter((action) => isNonBlank(action.workId));
@@ -85,8 +120,8 @@ function confirmableWork(material, basketId) {
         return { type: "inconsistent" };
     }
     return {
-        type: "confirmable",
-        work: { workId: tagged[0].workId },
+        type: "active",
+        work: { workId: tagged[0].workId, ready: true, confirmEmpty: false, awaitingSlots: [] },
     };
 }
 function loadingInstruction(mat) {
@@ -105,21 +140,29 @@ function SlotMaterial({ material, fsize, }) {
 }
 export function BasketLoadStationWorkflow({ stationNumber, basket, material, fsize, submitCommand, }) {
     const [submission, setSubmission] = useState();
-    const workState = useMemo(() => confirmableWork(material, basket.basketId), [basket.basketId, material]);
-    const work = workState.type === "confirmable" ? workState.work : undefined;
-    const submissionState = submission !== undefined && submission.workId === work?.workId ? submission.state : "idle";
+    const workState = useMemo(() => stationWork(material, basket), [basket, material]);
+    const blockedReason = basket.loadStationWork?.confirmationBlockedReason?.trim();
+    const work = workState.type === "active" ? workState.work : undefined;
+    const submissionState = submission !== undefined &&
+        submission.workId === work?.workId &&
+        // A conflict rejects the submitted status snapshot, not the preserved occurrence.
+        // Compare the captured snapshot even when refresh precedes the response.
+        (submission.state !== "conflict" ||
+            (submission.basket === basket && submission.material === material))
+        ? submission.state
+        : "idle";
     const materialBySlot = useMemo(() => LazySeq.of(material)
         .filter((mat) => mat.location.type === api.LocType.InBasket &&
         mat.location.basketId === basket.basketId &&
         mat.location.basketSlot !== undefined)
         .groupBy((mat) => mat.location.basketSlot ?? 0)
-        .toHashMap((entry) => entry), [basket.basketId, material]);
+        .toHashMap((entry) => entry), [basket, material]);
     const loadsBySlot = useMemo(() => LazySeq.of(material)
         .filter((mat) => mat.action.type === api.ActionType.LoadingToBasket &&
         mat.action.loadToBasketId === basket.basketId &&
         mat.action.loadToBasketSlot !== undefined)
         .groupBy((mat) => mat.action.loadToBasketSlot ?? 0)
-        .toHashMap((entry) => entry), [basket.basketId, material]);
+        .toHashMap((entry) => entry), [basket, material]);
     const slots = useMemo(() => LazySeq.of(basket.emptySlots ?? [])
         .concat(basket.unknownSlots ?? [])
         .concat(materialBySlot.keysToLazySeq())
@@ -127,19 +170,21 @@ export function BasketLoadStationWorkflow({ stationNumber, basket, material, fsi
         .distinctBy((slot) => slot)
         .toSortedArray((slot) => slot), [basket.emptySlots, basket.unknownSlots, materialBySlot, loadsBySlot]);
     async function submit() {
-        if (work === undefined || submitCommand === undefined)
+        if (work === undefined || !work.ready || submitCommand === undefined)
             return;
         const submittedWorkId = work.workId;
-        setSubmission({ workId: submittedWorkId, state: "submitting" });
+        const pending = { workId: submittedWorkId, basket, material, state: "submitting" };
+        setSubmission(pending);
         try {
             const state = await submitCommand(stationNumber, { workId: submittedWorkId });
-            setSubmission((current) => current?.workId === submittedWorkId ? { workId: submittedWorkId, state } : current);
+            setSubmission((current) => (current === pending ? { ...pending, state } : current));
         }
         catch {
-            setSubmission((current) => current?.workId === submittedWorkId ? { workId: submittedWorkId, state: "error" } : current);
+            setSubmission((current) => (current === pending ? { ...pending, state: "error" } : current));
         }
     }
-    const submissionDisabled = submissionState === "submitting" ||
+    const submissionDisabled = !work?.ready ||
+        submissionState === "submitting" ||
         submissionState === "accepted" ||
         submissionState === "conflict";
     return (_jsxs(Stack, { spacing: 2, sx: { mt: 2 }, children: [_jsx(Typography, { variant: "h6", children: "Basket slots" }), _jsx(Box, { sx: {
@@ -154,6 +199,9 @@ export function BasketLoadStationWorkflow({ stationNumber, basket, material, fsi
                             type: MoveMaterialNodeKindType.BasketSlotZone,
                             basketId: basket.basketId,
                             slot,
-                        }, children: _jsxs(Box, { component: "section", "data-testid": `basket-load-station-slot-${slot}`, sx: { border: "1px solid", borderColor: "text.primary", p: 2 }, children: [_jsxs(Typography, { variant: "h6", children: ["Slot ", slot] }), slotMaterial.length > 0 ? (_jsx(SlotMaterial, { material: slotMaterial, fsize: fsize })) : (_jsx(Typography, { color: isUnknown ? "warning.main" : "text.secondary", children: isUnknown ? "Unknown" : "Empty" })), loads.map((mat, index) => (_jsxs(Box, { sx: { mt: 1 }, children: [_jsx(Typography, { children: loadingInstruction(mat) }), _jsxs(Typography, { variant: "body2", color: "text.secondary", children: [mat.partName, " \u00B7 Process ", mat.action.processAfterLoad ?? mat.process] })] }, `${mat.jobUnique}-${mat.process}-${index}`)))] }) }, slot));
-                }) }), work && submitCommand ? (_jsx(Box, { sx: { display: "flex", justifyContent: "flex-end" }, children: _jsx(Button, { variant: "contained", disabled: submissionDisabled, onClick: () => void submit(), children: "Confirm" }) })) : work ? (_jsx(Alert, { severity: "warning", children: "Basket work confirmation is not configured." })) : workState.type === "inconsistent" ? (_jsx(Alert, { severity: "warning", children: "Basket work is inconsistent. Wait for refreshed material actions before confirming." })) : null, submissionState === "accepted" ? (_jsx(Alert, { severity: "success", children: "Confirmation accepted. Waiting for refreshed work." })) : submissionState === "conflict" ? (_jsx(Alert, { severity: "warning", children: "Basket work changed before confirmation. Review the refreshed slots and try again." })) : submissionState === "error" ? (_jsx(Alert, { severity: "error", children: "Unable to confirm basket work. No work was assumed complete." })) : null] }));
+                        }, children: _jsxs(Box, { component: "section", "data-testid": `basket-load-station-slot-${slot}`, sx: { border: "1px solid", borderColor: "text.primary", p: 2 }, children: [_jsxs(Typography, { variant: "h6", children: ["Slot ", basketSlotLabel(slot)] }), slotMaterial.length > 0 ? (_jsx(SlotMaterial, { material: slotMaterial, fsize: fsize })) : (_jsx(Typography, { color: isUnknown ? "warning.main" : "text.secondary", children: isUnknown ? "Unknown" : "Empty" })), loads.map((mat, index) => (_jsxs(Box, { sx: { mt: 1 }, children: [_jsx(Typography, { children: loadingInstruction(mat) }), _jsxs(Typography, { variant: "body2", color: "text.secondary", children: [mat.partName, " \u00B7 Process ", mat.action.processAfterLoad ?? mat.process] })] }, `${mat.jobUnique}-${mat.process}-${index}`)))] }) }, slot));
+                }) }), work?.confirmEmpty && _jsxs(Typography, { children: ["Confirm basket ", basket.basketId, " is empty."] }), work && !work.ready && (_jsx(Alert, { severity: "info", children: blockedReason ||
+                    (work.awaitingSlots.length > 0
+                        ? `Waiting for material for slots ${work.awaitingSlots.map(basketSlotLabel).join(", ")}.`
+                        : "Basket work is not ready for confirmation.") })), work && submitCommand ? (_jsx(Box, { sx: { display: "flex", justifyContent: "flex-end" }, children: _jsx(Button, { variant: "contained", disabled: submissionDisabled, onClick: () => void submit(), children: "Confirm" }) })) : work ? (_jsx(Alert, { severity: "warning", children: "Basket work confirmation is not configured." })) : workState.type === "inconsistent" ? (_jsx(Alert, { severity: "warning", children: "Basket work is inconsistent. Wait for refreshed material actions before confirming." })) : null, submissionState === "accepted" ? (_jsx(Alert, { severity: "success", children: "Confirmation accepted. Waiting for refreshed work." })) : submissionState === "conflict" ? (_jsx(Alert, { severity: "warning", children: "Basket work changed before confirmation. Review the refreshed slots and try again." })) : submissionState === "error" ? (_jsx(Alert, { severity: "error", children: "Unable to confirm basket work. No work was assumed complete." })) : null] }));
 }

package/dist/components/station-monitor/InvalidateCycle.d.ts

@@ -1,6 +1,5 @@
-import { IInProcessMaterial, ILogEntry } from "../../network/api.js";
+import { ILogEntry } from "../../network/api.js";
 import { HashMap } from "@seedtactics/immutable-collections";
-import { ReactNode } from "react";
 export type InvalidateCycleState = {
     readonly process: number | null;
     readonly changeRawMat: string | null;
@@ -19,18 +18,3 @@ export declare function InvalidateCycleDialogButton(props: InvalidateCycleProps
     readonly ignoreOperator?: boolean;
     readonly loadStation?: boolean;
 }): import("react").JSX.Element | null;
-interface SwapMaterial {
-    readonly selectedMatToSwap: Readonly<IInProcessMaterial> | null;
-    readonly updating: boolean;
-}
-export type SwapMaterialState = SwapMaterial | null;
-export interface SwapMaterialProps {
-    readonly st: SwapMaterialState;
-    readonly setState: (s: SwapMaterialState) => void;
-}
-export declare function SwapMaterialDialogContent(props: SwapMaterialProps): ReactNode;
-export declare function SwapMaterialButtons(props: SwapMaterialProps & {
-    readonly onClose: () => void;
-    readonly ignoreOperator?: boolean;
-}): import("react").JSX.Element | null;
-export {};

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

@@ -47,14 +47,12 @@ import { last30Jobs } from "../../cell-status/scheduled-jobs.js";
 import { PartIdenticon } from "./Material.js";
 import { isLogEntryInvalidated } from "../LogEntry.js";
 import { ApiException } from "../../network/api.js";
-import { canInvalidateMaterial, isActiveLoadStationOperation, } from "../../data/material-operation-policy.js";
+import { canInvalidateMaterial } from "../../data/material-operation-policy.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();
@@ -245,91 +243,3 @@ export function InvalidateCycleDialogButton(props) {
                                 : "Invalidate Process " + props.st.process.toString()
                             : "Invalidate Cycle" })) : undefined] }));
 }
-function isNullOrEmpty(s) {
-    return s === undefined || s === null || s == "";
-}
-function matCanSwap(curMat, job) {
-    return (newMat) => {
-        if (isNullOrEmpty(newMat.serial))
-            return false;
-        if (newMat.location.type === LocType.OnPallet)
-            return false;
-        if (newMat.process !== curMat.process - 1)
-            return false;
-        if (isNullOrEmpty(newMat.jobUnique)) {
-            // if part name is wrong, check casting
-            if (isNullOrEmpty(newMat.partName))
-                return false;
-            if (newMat.partName !== curMat.partName) {
-                if (!job)
-                    return false;
-                if (!LazySeq.of(job.procsAndPaths)
-                    .flatMap((p) => p.paths)
-                    .some((p) => p.casting === newMat.partName)) {
-                    return false;
-                }
-            }
-        }
-        else {
-            // check path
-            if (newMat.jobUnique !== curMat.jobUnique)
-                return false;
-            if (newMat.path !== curMat.path)
-                return false;
-        }
-        return true;
-    };
-}
-export function SwapMaterialDialogContent(props) {
-    const status = useAtomValue(currentStatus);
-    const curMat = useAtomValue(inProcessMaterialInDialog);
-    if (curMat === null || props.st === null)
-        return _jsx("div", {});
-    const curMatJob = status.jobs[curMat.jobUnique];
-    const availMats = status.material.filter(matCanSwap(curMat, curMatJob));
-    if (availMats.length === 0) {
-        return (_jsx("p", { style: { margin: "2em" }, children: "No material with the same job is available for swapping. You must edit the pallet using the cell controller software to remove the material from the pallet. Insight will automatically refresh once the cell controller software is updated." }));
-    }
-    else {
-        return (_jsxs("div", { style: { margin: "2em" }, children: [_jsx("p", { children: "Swap serial on pallet with material from the same job." }), _jsx("p", { children: "If material on the pallet is from a different job, you cannot use this screen. Instead, the material must first be removed from the pallet using the cell controller software. Insight will automatically refresh when this occurs." }), _jsx(TextField, { value: props.st?.selectedMatToSwap?.serial ?? "", select: true, onChange: (e) => props.st &&
-                        props.setState({
-                            ...props.st,
-                            selectedMatToSwap: availMats.find((m) => m.serial === e.target.value) ?? null,
-                        }), style: { width: "20em" }, variant: "outlined", label: "Select serial to swap with " + (curMat.serial ?? ""), children: availMats.map((m) => (_jsx(MenuItem, { value: m.serial, children: m.serial }, m.materialID))) })] }));
-    }
-}
-export function SwapMaterialButtons(props) {
-    const fmsInfo = useAtomValue(fmsInformation);
-    const curMat = useAtomValue(inProcessMaterialInDialog);
-    const closeMatDialog = useSetAtom(materialDialogOpen);
-    let operator = useAtomValue(currentOperator);
-    if (!fmsInfo.allowSwapSerialAtLoadStation)
-        return null;
-    if (props.ignoreOperator)
-        operator = null;
-    if (!curMat ||
-        curMat.location.type !== LocType.OnPallet ||
-        isActiveLoadStationOperation(curMat)) {
-        return null;
-    }
-    function swapMats() {
-        if (curMat &&
-            props.st &&
-            props.st.selectedMatToSwap &&
-            curMat.location.type === LocType.OnPallet) {
-            props.setState({ selectedMatToSwap: props.st.selectedMatToSwap, updating: true });
-            JobsBackend.swapMaterialOnPallet(curMat.materialID, operator, {
-                pallet: curMat.location.palletNum ?? 0,
-                materialIDToSetOnPallet: props.st.selectedMatToSwap.materialID,
-            })
-                .catch(console.log)
-                .finally(() => {
-                closeMatDialog(null);
-                props.onClose();
-            });
-        }
-    }
-    return (_jsxs(_Fragment, { children: [props.st === null ? (_jsx(Button, { color: "primary", onClick: () => props.setState({ selectedMatToSwap: null, updating: false }), children: "Swap Serial" })) : undefined, props.st !== null ? (_jsx(Button, { color: "primary", onClick: swapMats, disabled: props.st.selectedMatToSwap === null || props.st.updating, children: props.st.selectedMatToSwap === null
-                    ? "Swap Serial"
-                    : "Swap with " + (props.st.selectedMatToSwap.serial ?? "") })) : undefined] }));
-}

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

@@ -54,7 +54,7 @@ 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";
+import { InvalidateCycleDialogButton, InvalidateCycleDialogContent, } from "./InvalidateCycle.js";
 import { last30MaterialSummary } from "../../cell-status/material-summary.js";
 import { addHours } from "date-fns";
 import { PromptForQueue } from "./QueuesAddMaterial.js";
@@ -625,18 +625,16 @@ function AssignWorkorderButton() {
     return (_jsx(Button, { color: "primary", onClick: () => setWorkorderDialogOpen(true), children: "Assign Workorder" }));
 }
 const LoadMatDialog = memo(function LoadMatDialog(props) {
-    const [swapSt, setSwapSt] = useState(null);
     const [invalidateSt, setInvalidateSt] = useState(null);
     // add material state
     const [showAddMaterial, setShowAddMaterial] = useState(false);
     const [selectedQueue, setSelectedQueue] = useState(null);
     const onClose = useCallback(function onClose() {
-        setSwapSt(null);
         setInvalidateSt(null);
         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(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, {})] }) }));
+    }, [setInvalidateSt]);
+    return (_jsx(MaterialDialog, { onClose: onClose, allowNote: true, highlightProcsGreaterOrEqualTo: invalidateSt?.process ?? undefined, extraDialogElements: _jsxs(_Fragment, { children: [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(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

@@ -48,7 +48,7 @@ import { currentStatus } from "../../cell-status/current-status.js";
 import { useAtom, useAtomValue, useSetAtom } from "jotai";
 import { last30Rebookings } from "../../cell-status/rebookings.js";
 import { fmsInformation } from "../../network/server-settings.js";
-import { basketDisplayName } from "../../cell-status/station-cycles.js";
+import { basketDisplayName, basketSlotLabel } from "../../cell-status/station-cycles.js";
 import { materialOperationState } from "../../data/material-operation-policy.js";
 export class PartIdenticon extends PureComponent {
     render() {
@@ -236,12 +236,14 @@ 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}` : ""] }));
+            return (_jsxs(MatCardDetail, { fsize: fsize, children: ["Load into ", basketName, " ", mat.action.loadToBasketId ?? "", mat.action.loadToBasketSlot !== undefined
+                        ? ` slot ${basketSlotLabel(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}`
+                            ? ` slot ${basketSlotLabel(mat.action.unloadToBasketSlot)}`
                             : ""] }));
             }
             else if (mat.action.unloadIntoQueue) {

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

@@ -42,7 +42,7 @@ import { materialDialogOpen } from "../../cell-status/material-details.js";
 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 { InvalidateCycleDialogButton, InvalidateCycleDialogContent, } from "./InvalidateCycle.js";
 import { CancelLoadButton } from "./CancelLoadButton.js";
 import { QuarantineMatButton } from "./QuarantineButton.js";
 import { SelectInspTypeDialog, SignalInspectionButton } from "./SelectInspType.js";
@@ -824,13 +824,11 @@ export const SystemOverview = memo(function SystemOverview({ overview, }) {
                 }, children: [overview.stockerPals.map((pal) => (_jsx(StockerPallet, { pallet: pal, maxNumFaces: overview.maxNumFacesOnPallet }, pal.pallet.palletNum))), overview.floatingBaskets.map((basket) => (_jsx(FloatingBasket, { basket: basket }, basket.basket.basketId))), overview.storageBaskets ? (_jsx(BasketStorageSummary, { empty: overview.storageBaskets.empty, filled: overview.storageBaskets.filled })) : undefined] })) : undefined] }));
 });
 const SystemOverviewMaterialDialog = memo(function SystemOverviewMaterialDialog({ ignoreOperator, }) {
-    const [swapSt, setSwapSt] = useState(null);
     const [invalidateSt, setInvalidateSt] = useState(null);
     function onClose() {
-        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(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 })] }) }));
+    return (_jsx(MaterialDialog, { onClose: onClose, allowNote: true, highlightProcsGreaterOrEqualTo: invalidateSt?.process ?? undefined, extraDialogElements: _jsx(_Fragment, { children: 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(InvalidateCycleDialogButton, { st: invalidateSt, setState: setInvalidateSt, onClose: onClose, ignoreOperator: ignoreOperator })] }) }));
 });
 export function SystemOverviewPage({ ignoreOperator, whiteBackground, }) {
     useSetTitle("System Overview");

package/dist/index.html

@@ -43,7 +43,7 @@
         }
       }
     </style>
-    <script type="module" crossorigin src="/assets/index-C6EBFHuW.js"></script>
+    <script type="module" crossorigin src="/assets/index-MFZreX-b.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-DXfAwuj-.css">
   </head>
   <body>