@seedtactics/insight-client 16.7.0 → 16.7.2

package/dist/cell-status/material-details.d.ts

@@ -1,10 +1,20 @@
 import { IInProcessMaterial, ILogEntry, ILogMaterial, IMaterialDetails, IActiveWorkorder, IScannedPotentialNewMaterial } from "../network/api.js";
+import { type Atom } from "jotai";
 export type MaterialToShowInfo = {
     readonly materialID: number;
     readonly partName: string;
     readonly serial?: string;
     readonly workorderId?: string;
 };
+export type AsyncAtomState<T> = {
+    readonly state: "loading";
+} | {
+    readonly state: "hasData";
+    readonly data: T;
+} | {
+    readonly state: "hasError";
+    readonly error: unknown;
+};
 export type MaterialToShow = {
     readonly type: "InProcMat";
     readonly inproc: Readonly<IInProcessMaterial>;
@@ -30,25 +40,27 @@ export type MaterialToShow = {
     readonly toQueue: string;
 };
 export declare const materialDialogOpen: import("jotai").WritableAtom<MaterialToShow | null, [mat: MaterialToShow | null], void>;
-export declare const barcodePotentialNewMaterial: import("jotai").Atom<Promise<Readonly<IScannedPotentialNewMaterial> | null>>;
-export declare const materialInDialogInfo: import("jotai").Atom<Promise<MaterialToShowInfo | null>>;
-export declare const materialInDialogInfoUnwrapped: import("jotai").Atom<MaterialToShowInfo | null>;
-export declare const inProcessMaterialInDialog: import("jotai").Atom<Promise<IInProcessMaterial | null>>;
-export declare const serialInMaterialDialog: import("jotai").Atom<Promise<string | null>>;
-export declare const serialInMaterialDialogUnwrapped: import("jotai").Atom<string | null>;
-export declare const workorderInMaterialDialog: import("jotai").Atom<Promise<string | null>>;
-export declare const materialInDialogEvents: import("jotai").Atom<readonly Readonly<ILogEntry>[]>;
+export declare const barcodePotentialNewMaterial: Atom<Promise<Readonly<IScannedPotentialNewMaterial> | null>>;
+export declare const materialInDialogInfo: Atom<Promise<MaterialToShowInfo | null>>;
+export declare const materialInDialogInfoUnwrapped: Atom<MaterialToShowInfo | null>;
+export declare const materialInDialogInfoState: Atom<AsyncAtomState<MaterialToShowInfo | null>>;
+export declare const inProcessMaterialInDialog: Atom<Promise<IInProcessMaterial | null>>;
+export declare const serialInMaterialDialog: Atom<Promise<string | null>>;
+export declare const serialInMaterialDialogUnwrapped: Atom<string | null>;
+export declare const serialInMaterialDialogState: Atom<AsyncAtomState<string | null>>;
+export declare const workorderInMaterialDialog: Atom<Promise<string | null>>;
+export declare const materialInDialogEvents: Atom<readonly Readonly<ILogEntry>[]>;
 export type LargestUsedProces = {
     readonly process: number;
     readonly totalNumProcesses: number;
 };
-export declare const materialInDialogLargestUsedProcess: import("jotai").Atom<Promise<LargestUsedProces | null>>;
+export declare const materialInDialogLargestUsedProcess: Atom<Promise<LargestUsedProces | null>>;
 export interface MaterialToShowInspections {
     readonly signaledInspections: ReadonlyArray<string>;
     readonly completedInspections: ReadonlyArray<string>;
 }
-export declare const materialInDialogInspections: import("jotai").Atom<MaterialToShowInspections>;
-export declare const possibleWorkordersForMaterialInDialog: import("jotai").Atom<Promise<readonly IActiveWorkorder[]>>;
+export declare const materialInDialogInspections: Atom<MaterialToShowInspections>;
+export declare const possibleWorkordersForMaterialInDialog: Atom<Promise<readonly IActiveWorkorder[]>>;
 export interface ForceInspectionData {
     readonly mat: MaterialToShowInfo;
     readonly inspType: string;

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

@@ -112,6 +112,10 @@ export const materialInDialogInfo = atom(async (get) => {
     }
 });
 export const materialInDialogInfoUnwrapped = unwrap(materialInDialogInfo, (prev) => prev ?? null);
+function asyncAtomState(source) {
+    return unwrap(atom((get) => get(source).then((data) => ({ state: "hasData", data }), (error) => ({ state: "hasError", error }))), () => ({ state: "loading" }));
+}
+export const materialInDialogInfoState = asyncAtomState(materialInDialogInfo);
 export const inProcessMaterialInDialog = atom(async (get) => {
     const status = get(currentStatus);
     const toShow = get(matToShow);
@@ -147,6 +151,7 @@ export const serialInMaterialDialog = atom(async (get) => {
     }
 });
 export const serialInMaterialDialogUnwrapped = unwrap(serialInMaterialDialog, (prev) => prev ?? null);
+export const serialInMaterialDialogState = asyncAtomState(serialInMaterialDialog);
 export const workorderInMaterialDialog = atom(async (get) => {
     const toShow = get(matToShow);
     if (toShow === null)

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

@@ -439,9 +439,44 @@ export const MaterialDetailTitle = memo(function MaterialDetailTitle({ partName,
                 }, children: [_jsx(Typography, { variant: "h6", children: title }), subtitle ? _jsx(Typography, { variant: "caption", children: subtitle }) : undefined] })] }));
 });
 function MaterialDialogTitle({ notes }) {
-    const mat = useAtomValue(matDetails.materialInDialogInfoUnwrapped);
-    const serial = useAtomValue(matDetails.serialInMaterialDialogUnwrapped);
-    return _jsx(MaterialDetailTitle, { notes: notes, partName: mat?.partName ?? "", serial: mat?.serial ?? serial });
+    const toShow = useAtomValue(matDetails.materialDialogOpen);
+    const mat = useAtomValue(matDetails.materialInDialogInfoState);
+    const serial = useAtomValue(matDetails.serialInMaterialDialogState);
+    let partName = "";
+    let titleSerial = null;
+    switch (toShow?.type) {
+        case "InProcMat":
+            partName = toShow.inproc.partName;
+            titleSerial = toShow.inproc.serial;
+            break;
+        case "MatSummary":
+            partName = toShow.summary.partName;
+            titleSerial = toShow.summary.serial;
+            break;
+        case "MatDetails":
+            partName = toShow.details.partName;
+            titleSerial = toShow.details.serial;
+            break;
+        case "LogMat":
+            partName = toShow.logMat.part;
+            titleSerial = toShow.logMat.serial;
+            break;
+        case "Barcode":
+            titleSerial = toShow.barcode;
+            break;
+        case "ManuallyEnteredSerial":
+        case "AddMatWithEnteredSerial":
+            titleSerial = toShow.serial;
+            break;
+    }
+    if (mat.state === "hasData" && mat.data !== null) {
+        partName = mat.data.partName;
+        titleSerial = mat.data.serial ?? titleSerial;
+    }
+    if (serial.state === "hasData" && serial.data) {
+        titleSerial = serial.data;
+    }
+    return _jsx(MaterialDetailTitle, { notes: notes, partName: partName, serial: titleSerial });
 }
 function MaterialInspections() {
     const insps = useAtomValue(matDetails.materialInDialogInspections);

package/dist/components/station-monitor/Material.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,199 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/* Copyright (c) 2026, John Lenz
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of John Lenz, Black Maple Software, SeedTactics,
+      nor the names of other contributors may be used to endorse or
+      promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+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 { act } from "react";
+import { Provider, createStore } from "jotai";
+import { createRoot } from "react-dom/client";
+import { afterEach, expect, it, vi } from "vitest";
+import { MaterialDialog } from "./Material.js";
+import { materialDialogOpen } from "../../cell-status/material-details.js";
+import { ApiException } from "../../network/api.js";
+import { registerBackend } from "../../network/backend.js";
+const barcode = "1111222|SO100100|10000";
+const barcodeError = "Serial 1111222 is assigned to sales order SO100100 line 10000 which is not currently scheduled";
+function unexpectedCall(name) {
+    throw new Error(`Unexpected backend call in MaterialDialog test: ${name}`);
+}
+const logBackend = {
+    get() {
+        return unexpectedCall("LogAPI.get");
+    },
+    recent() {
+        return unexpectedCall("LogAPI.recent");
+    },
+    logForMaterial() {
+        return unexpectedCall("LogAPI.logForMaterial");
+    },
+    logForMaterials() {
+        return unexpectedCall("LogAPI.logForMaterials");
+    },
+    logForSerial() {
+        return unexpectedCall("LogAPI.logForSerial");
+    },
+    materialForSerial() {
+        return unexpectedCall("LogAPI.materialForSerial");
+    },
+    setInspectionDecision() {
+        return unexpectedCall("LogAPI.setInspectionDecision");
+    },
+    recordInspectionCompleted() {
+        return unexpectedCall("LogAPI.recordInspectionCompleted");
+    },
+    recordCloseoutCompleted() {
+        return unexpectedCall("LogAPI.recordCloseoutCompleted");
+    },
+    setWorkorder() {
+        return unexpectedCall("LogAPI.setWorkorder");
+    },
+    recordOperatorNotes() {
+        return unexpectedCall("LogAPI.recordOperatorNotes");
+    },
+    recordWorkorderComment() {
+        return unexpectedCall("LogAPI.recordWorkorderComment");
+    },
+    getActiveWorkorder() {
+        return unexpectedCall("LogAPI.getActiveWorkorder");
+    },
+    cancelRebooking() {
+        return unexpectedCall("LogAPI.cancelRebooking");
+    },
+    requestRebooking() {
+        return unexpectedCall("LogAPI.requestRebooking");
+    },
+};
+const jobBackend = {
+    history() {
+        return unexpectedCall("JobAPI.history");
+    },
+    recent() {
+        return unexpectedCall("JobAPI.recent");
+    },
+    currentStatus() {
+        return unexpectedCall("JobAPI.currentStatus");
+    },
+    setJobComment() {
+        return unexpectedCall("JobAPI.setJobComment");
+    },
+    removeMaterialFromAllQueues() {
+        return unexpectedCall("JobAPI.removeMaterialFromAllQueues");
+    },
+    bulkRemoveMaterialFromQueues() {
+        return unexpectedCall("JobAPI.bulkRemoveMaterialFromQueues");
+    },
+    setMaterialInQueue() {
+        return unexpectedCall("JobAPI.setMaterialInQueue");
+    },
+    addUnprocessedMaterialToQueue() {
+        return unexpectedCall("JobAPI.addUnprocessedMaterialToQueue");
+    },
+    addUnallocatedCastingToQueue() {
+        return unexpectedCall("JobAPI.addUnallocatedCastingToQueue");
+    },
+    signalMaterialForQuarantine() {
+        return unexpectedCall("JobAPI.signalMaterialForQuarantine");
+    },
+    swapMaterialOnPallet() {
+        return unexpectedCall("JobAPI.swapMaterialOnPallet");
+    },
+    invalidatePalletCycle() {
+        return unexpectedCall("JobAPI.invalidatePalletCycle");
+    },
+    unscheduledRebookings() {
+        return unexpectedCall("JobAPI.unscheduledRebookings");
+    },
+};
+const machineBackend = {
+    getToolsInMachines() {
+        return unexpectedCall("MachineAPI.getToolsInMachines");
+    },
+    getProgramsInCellController() {
+        return unexpectedCall("MachineAPI.getProgramsInCellController");
+    },
+    getProgramRevisionContent() {
+        return unexpectedCall("MachineAPI.getProgramRevisionContent");
+    },
+    getLatestProgramRevisionContent() {
+        return unexpectedCall("MachineAPI.getLatestProgramRevisionContent");
+    },
+    getProgramRevisionsInDescendingOrderOfRevision() {
+        return unexpectedCall("MachineAPI.getProgramRevisionsInDescendingOrderOfRevision");
+    },
+};
+const fmsBackend = {
+    fMSInformation() {
+        return unexpectedCall("FmsAPI.fMSInformation");
+    },
+    printLabel() {
+        return unexpectedCall("FmsAPI.printLabel");
+    },
+    parseBarcode() {
+        return Promise.reject(new ApiException("An unexpected server error occurred.", 400, barcodeError, {}, null));
+    },
+    enableVerboseLoggingForFiveMinutes() {
+        return unexpectedCall("FmsAPI.enableVerboseLoggingForFiveMinutes");
+    },
+};
+async function flushUi() {
+    for (let i = 0; i < 3; i += 1) {
+        await act(async () => {
+            await Promise.resolve();
+        });
+    }
+}
+afterEach(() => {
+    document.body.innerHTML = "";
+});
+it("shows barcode parse errors inside the material dialog", async () => {
+    const consoleError = vi.spyOn(console, "error").mockImplementation(() => { });
+    registerBackend(logBackend, jobBackend, fmsBackend, machineBackend);
+    const store = createStore();
+    store.set(materialDialogOpen, { type: "Barcode", barcode, toQueue: null });
+    const container = document.createElement("div");
+    document.body.append(container);
+    const root = createRoot(container);
+    try {
+        await act(async () => {
+            root.render(_jsx(Provider, { store: store, children: _jsx(MaterialDialog, {}) }));
+        });
+        await flushUi();
+        expect(document.body.textContent).toContain(barcode);
+        expect(document.body.textContent).toContain(barcodeError);
+        expect(document.body.textContent).not.toContain("An unexpected server error occurred.");
+    }
+    finally {
+        await act(async () => {
+            root.unmount();
+        });
+        consoleError.mockRestore();
+    }
+});

package/dist/data/queue-material.js

@@ -157,14 +157,14 @@ export function selectQueueData(queuesToCheck, curSt, rawMatQueues, inProcQueues
     for (const queueName of queueNames) {
         const isRawMat = rawMatQueues.has(queueName);
         if (isRawMat) {
-            const materialByPos = OrderedMap.empty();
+            let materialByPos = OrderedMap.empty();
             const matByPartThenUniq = new Map();
             for (const m of curSt.material) {
                 if (m.location.type === api.LocType.InQueue &&
                     m.location.currentQueue === queueName &&
                     m.location.queuePosition !== undefined) {
                     if ((m.serial && m.serial !== "") || m.action.type !== api.ActionType.Waiting) {
-                        materialByPos.set(m.location.queuePosition, m);
+                        materialByPos = materialByPos.set(m.location.queuePosition, m);
                     }
                     else {
                         let matsForPart = matByPartThenUniq.get(m.partName);

package/dist/index.html

@@ -44,7 +44,7 @@
         }
       }
     </style>
-    <script type="module" crossorigin src="/assets/index-bPAFn3jp.js"></script>
+    <script type="module" crossorigin src="/assets/index-BwbaiELK.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CbqW4-gR.css">
   </head>
   <body>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seedtactics/insight-client",
-  "version": "16.7.0",
+  "version": "16.7.2",
   "license": "BSD-3-Clause",
   "type": "module",
   "repository": {
@@ -29,8 +29,8 @@
     "@fontsource/roboto": "^5.2.10",
     "@mui/icons-material": "^9.0.1",
     "@mui/material": "^9.0.1",
-    "@react-spring/rafz": "^10.0.4",
-    "@react-spring/web": "^10.0.4",
+    "@react-spring/rafz": "^10.1.0",
+    "@react-spring/web": "^10.1.0",
     "@seedtactics/immutable-collections": "^1.1.1",
     "@yudiel/react-qr-scanner": "^2.6.0",
     "copy-to-clipboard": "^4.0.2",
@@ -38,7 +38,7 @@
     "d3-sankey": "^0.12.3",
     "d3-scale": "^4.0.2",
     "d3-shape": "^3.2.0",
-    "date-fns": "^4.2.1",
+    "date-fns": "^4.3.0",
     "highlight.js": "^11.11.1",
     "jdenticon": "^3.3.0",
     "jotai": "^2.20.0",
@@ -48,7 +48,7 @@
     "react": "^19.2.6",
     "react-calendar": "^6.0.1",
     "react-dom": "^19.2.6",
-    "react-error-boundary": "^6.1.1",
+    "react-error-boundary": "^6.1.2",
     "react-resize-detector": "^12.3.0",
     "react-timeago": "^8.3.0",
     "react-to-print": "^3.3.0",