@seedtactics/insight-client 16.5.2 → 16.7.0

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

@@ -36,6 +36,25 @@ import { durationToMinutes } from "../util/parseISODuration.js";
 import { addDays } from "date-fns";
 import { HashMap } from "@seedtactics/immutable-collections";
 import { atom } from "jotai";
+import { fmsInformation } from "../network/server-settings.js";
+export function isLaborCycle(cycle) {
+    return cycle.carrier.kind !== "machining";
+}
+export function isMachineCycle(cycle) {
+    return cycle.carrier.kind === "machining";
+}
+export function isPalletLoadCycle(cycle) {
+    return cycle.carrier.kind === "pallet-lul";
+}
+export function isBasketLoadCycle(cycle) {
+    return cycle.carrier.kind === "basket-lul";
+}
+export function palletForCycle(cycle) {
+    return cycle.carrier.kind === "basket-lul" ? undefined : cycle.carrier.pallet;
+}
+export function basketForCycle(cycle) {
+    return cycle.carrier.kind === "basket-lul" ? cycle.carrier.basket : undefined;
+}
 export function stat_name_and_num(stationGroup, stationNumber) {
     if (stationGroup.startsWith("Inspect")) {
         return stationGroup;
@@ -44,21 +63,68 @@ export function stat_name_and_num(stationGroup, stationNumber) {
         return stationGroup + " #" + stationNumber.toString();
     }
 }
+export function loadStationDisplayName(stationNumber, loadStationNames) {
+    const name = loadStationNames?.[stationNumber.toString()];
+    return name && name.trim().length > 0 ? name : `L/U #${stationNumber}`;
+}
+export function displayStationName(stationGroup, stationNumber, loadStationNames) {
+    return stationGroup === "L/U"
+        ? loadStationDisplayName(stationNumber, loadStationNames)
+        : stat_name_and_num(stationGroup, stationNumber);
+}
+export function basketDisplayName(basketName) {
+    return basketName && basketName.trim().length > 0 ? basketName : "Basket";
+}
+export function carrierLabel(cycle, basketName = "Basket") {
+    switch (cycle.carrier.kind) {
+        case "machining":
+        case "pallet-lul":
+            return `Pallet ${cycle.carrier.pallet}`;
+        case "basket-lul":
+            return `${basketName} ${cycle.carrier.basket}`;
+    }
+}
+export function carrierSortKey(cycle) {
+    switch (cycle.carrier.kind) {
+        case "machining":
+        case "pallet-lul":
+            return cycle.carrier.pallet;
+        case "basket-lul":
+            return cycle.carrier.basket + 1000000;
+    }
+}
+function hasBasketCycles(cycles) {
+    return cycles.valuesToLazySeq().some((cycle) => cycle.carrier.kind === "basket-lul");
+}
 const last30StationCyclesRW = atom(HashMap.empty());
 export const last30StationCycles = last30StationCyclesRW;
+export const last30HasBasketCycles = atom((get) => hasBasketCycles(get(last30StationCyclesRW)));
 const specificMonthStationCyclesRW = atom(HashMap.empty());
 export const specificMonthStationCycles = specificMonthStationCyclesRW;
-function convertLogToCycle(estimatedCycleTimes, cycle, elapsedPerMat) {
+export const specificMonthHasBasketCycles = atom((get) => hasBasketCycles(get(specificMonthStationCyclesRW)));
+function convertLogToCycle(estimatedCycleTimes, cycle, elapsedPerMat, loadStationNames) {
     if (cycle.startofcycle ||
-        (cycle.type !== LogType.LoadUnloadCycle && cycle.type !== LogType.MachineCycle) ||
+        (cycle.type !== LogType.LoadUnloadCycle &&
+            cycle.type !== LogType.BasketLoadUnload &&
+            cycle.type !== LogType.MachineCycle) ||
         cycle.loc === "") {
         return null;
     }
+    const carrier = cycle.type === LogType.MachineCycle
+        ? { kind: "machining", pallet: cycle.pal }
+        : cycle.type === LogType.LoadUnloadCycle
+            ? { kind: "pallet-lul", pallet: cycle.pal }
+            : { kind: "basket-lul", basket: cycle.pal };
+    const activeMinsFromLog = durationToMinutes(cycle.active);
+    if (carrier.kind === "basket-lul" && elapsedPerMat <= 0 && activeMinsFromLog <= 0) {
+        // For pallet <-> basket transfers, the basket-side companion event carries zero time.
+        return null;
+    }
     const part = cycle.material.length > 0 ? cycle.material[0].part : "";
     const stats = cycle.material.length > 0
         ? estimatedCycleTimes.get(PartAndStationOperation.ofLogCycle(cycle))
         : undefined;
-    let activeMins = durationToMinutes(cycle.active);
+    let activeMins = activeMinsFromLog;
     if (cycle.active === "" || activeMins <= 0 || cycle.material.length == 0) {
         activeMins = (stats?.expectedCycleMinutesForSingleMat ?? 0) * cycle.material.length;
     }
@@ -70,19 +136,19 @@ function convertLogToCycle(estimatedCycleTimes, cycle, elapsedPerMat) {
         medianCycleMinutes: (stats?.medianMinutesForSingleMat ?? 0) * cycle.material.length,
         MAD_aboveMinutes: stats?.MAD_aboveMinutes ?? 0,
         part: part,
-        pallet: cycle.pal,
+        carrier: carrier,
         material: cycle.material,
-        isLabor: cycle.type === LogType.LoadUnloadCycle,
         isOutlier: stats ? isOutlier(stats, elapsedPerMat) : false,
         stationGroup: cycle.loc,
         stationNumber: cycle.locnum,
-        operation: cycle.type === LogType.LoadUnloadCycle ? cycle.result : cycle.program,
+        stationLabel: displayStationName(cycle.loc, cycle.locnum, loadStationNames),
+        operation: carrier.kind === "machining" ? cycle.program : cycle.result,
         operator: cycle.details ? cycle.details.operator || "" : "",
     };
 }
-function convertOldLogsToCycles(estimateCycleTimes, log) {
+function convertOldLogsToCycles(estimateCycleTimes, log, loadStationNames) {
     return calcElapsedForCycles(log)
-        .collect((c) => convertLogToCycle(estimateCycleTimes, c.cycle, c.elapsedForSingleMaterialMinutes))
+        .collect((c) => convertLogToCycle(estimateCycleTimes, c.cycle, c.elapsedForSingleMaterialMinutes, loadStationNames))
         .buildHashMap((c) => c.cntr);
 }
 function process_swap(swap, partCycles) {
@@ -97,7 +163,8 @@ function process_swap(swap, partCycles) {
 }
 export const setLast30StationCycles = atom(null, (get, set, log) => {
     const estimatedCycleTimes = get(last30EstimatedCycleTimes);
-    set(last30StationCyclesRW, (oldCycles) => oldCycles.union(convertOldLogsToCycles(estimatedCycleTimes, log)));
+    const loadStationNames = get(fmsInformation)?.loadStationNames;
+    set(last30StationCyclesRW, (oldCycles) => oldCycles.union(convertOldLogsToCycles(estimatedCycleTimes, log, loadStationNames)));
 });
 export const updateLast30StationCycles = atom(null, (get, set, { evt, now, expire }) => {
     if (evt.logEntry && evt.logEntry.type === LogType.InvalidateCycle) {
@@ -122,7 +189,8 @@ export const updateLast30StationCycles = atom(null, (get, set, { evt, now, expir
         const elapsedPerMat = evt.logEntry.material.length > 0
             ? durationToMinutes(evt.logEntry.elapsed) / evt.logEntry.material.length
             : 0;
-        const converted = convertLogToCycle(estimatedCycleTimes, evt.logEntry, elapsedPerMat);
+        const loadStationNames = get(fmsInformation)?.loadStationNames;
+        const converted = convertLogToCycle(estimatedCycleTimes, evt.logEntry, elapsedPerMat, loadStationNames);
         if (!converted)
             return;
         set(last30StationCyclesRW, (cycles) => {
@@ -141,5 +209,7 @@ export const updateLast30StationCycles = atom(null, (get, set, { evt, now, expir
 });
 export const setSpecificMonthStationCycles = atom(null, (get, set, log) => {
     const estimatedCycleTimes = get(specificMonthEstimatedCycleTimes);
-    set(specificMonthStationCyclesRW, convertOldLogsToCycles(estimatedCycleTimes, log));
+    const loadStationNames = get(fmsInformation)?.loadStationNames;
+    const cycles = convertOldLogsToCycles(estimatedCycleTimes, log, loadStationNames);
+    set(specificMonthStationCyclesRW, cycles);
 });

package/dist/cell-status/tool-replacements.js

@@ -77,7 +77,7 @@ function addReplacementsFromLog(old, e) {
             const totalCntAtEnd = use.totalToolUseCountAtEndOfCycle ?? null;
             if ((useDuring || cntDuring) && useDuring === totalUseAtEnd && cntDuring === totalCntAtEnd) {
                 // replace before cycle start
-                const last = old.recentUse.get(key)?.find((e) => e.tool === use.tool && e.pocket === use.pocket);
+                const last = old.recentUse.get(key)?.find((entry) => entry.tool === use.tool && entry.pocket === use.pocket);
                 if (last) {
                     const lastTotalUse = last.totalToolUseAtEndOfCycle
                         ? durationToMinutes(last.totalToolUseAtEndOfCycle)

package/dist/cell-status/tool-usage.js

@@ -84,7 +84,7 @@ function process_tools(cycle, estimatedCycleTimes, toolUsage) {
 }
 export const setLast30ToolUse = atom(null, (get, set, log) => {
     const estimated = get(last30EstimatedCycleTimes);
-    set(last30ToolUseRW, (oldUsage) => log.reduce((usage, log) => process_tools(log, estimated, usage), oldUsage));
+    set(last30ToolUseRW, (oldUsage) => log.reduce((usage, entry) => process_tools(entry, estimated, usage), oldUsage));
 });
 export const updateLast30ToolUse = atom(null, (get, set, { evt }) => {
     if (evt.logEntry) {

package/dist/components/App.js

@@ -70,6 +70,7 @@ import { BufferOccupancyChart } from "./analysis/BufferChart.js";
 import { CompletedCountHeatmap, StationOeeHeatmap } from "./analysis/EfficiencyPage.js";
 import { PartLoadStationCycleChart, PartMachineCycleChart } from "./analysis/PartCycleCards.js";
 import { PalletCycleChart } from "./analysis/PalletCycleCards.js";
+import { BasketCycleChart } from "./analysis/BasketCycleCards.js";
 import { ToolReplacementPage } from "./analysis/ToolReplacements.js";
 import { CurrentWorkordersPage } from "./operations/CurrentWorkorders.js";
 import { useAtom, useAtomValue } from "jotai";
@@ -78,6 +79,8 @@ import { latestSimDayUsage } from "../cell-status/sim-day-usage.js";
 import { CloseoutReport } from "./operations/CloseoutReport.js";
 import { RebookingsPage } from "./operations/Rebookings.js";
 import { RecentCompletedPartsPage } from "./operations/CompletedParts.js";
+import { basketDisplayName } from "../cell-status/station-cycles.js";
+import { last30HasBasketCycleData, specificMonthHasBasketCycleData } from "../cell-status/basket-cycles.js";
 const OperationsReportsTab = "bms-operations-reports-tab";
 const operationsReports = [
     { separator: "Load/Unload" },
@@ -166,59 +169,82 @@ const operationsReports = [
         hidden: (info) => info.supportsRebookings === null || info.supportsRebookings === "",
     },
 ];
-const analysisReports = [
-    { separator: "Efficiency" },
-    { name: "Buffers", route: { route: routes.RouteLocation.Analysis_Buffers }, icon: _jsx(BufferIcon, {}) },
-    {
-        name: "Station OEE",
-        route: { route: routes.RouteLocation.Analysis_StationOEE },
-        icon: _jsx(HourglassIcon, {}),
-    },
-    {
-        name: "Completed Parts",
-        route: { route: routes.RouteLocation.Analysis_PartsCompleted },
-        icon: _jsx(ExtensionIcon, {}),
-    },
-    { separator: "Cycles" },
-    {
-        name: "Machine Cycles",
-        route: { route: routes.RouteLocation.Analysis_MachineCycles },
-        icon: _jsx(WorkIcon, {}),
-    },
-    {
-        name: "L/U Cycles",
-        route: { route: routes.RouteLocation.Analysis_LoadCycles },
-        icon: _jsx(LoadUnloadIcon, {}),
-    },
-    {
-        name: "Pallet Cycles",
-        route: { route: routes.RouteLocation.Analysis_PalletCycles },
-        icon: _jsx(PalletIcon, {}),
-    },
-    { separator: "Cell" },
-    { name: "Quality", route: { route: routes.RouteLocation.Analysis_Quality }, icon: _jsx(BuildIcon, {}) },
-    {
-        name: "Tool Replacements",
-        route: { route: routes.RouteLocation.Analysis_ToolReplacements },
-        icon: _jsx(ToolIcon, {}),
-    },
-    {
-        name: "Schedules",
-        route: { route: routes.RouteLocation.Analysis_Schedules },
-        icon: _jsx(ScheduleIcon, {}),
-    },
-    { separator: "Costs" },
-    {
-        name: "Percentages",
-        route: { route: routes.RouteLocation.Analysis_CostPercents },
-        icon: _jsx(CallSplit, {}),
-    },
-    {
-        name: "Cost/Piece",
-        route: { route: routes.RouteLocation.Analysis_CostPerPiece },
-        icon: _jsx(CostIcon, {}),
-    },
-];
+function analysisReports(hasBasketCycles) {
+    return [
+        { separator: "Efficiency" },
+        { name: "Buffers", route: { route: routes.RouteLocation.Analysis_Buffers }, icon: _jsx(BufferIcon, {}) },
+        {
+            name: "Station OEE",
+            route: { route: routes.RouteLocation.Analysis_StationOEE },
+            icon: _jsx(HourglassIcon, {}),
+        },
+        {
+            name: "Completed Parts",
+            route: { route: routes.RouteLocation.Analysis_PartsCompleted },
+            icon: _jsx(ExtensionIcon, {}),
+        },
+        { separator: "Cycles" },
+        {
+            name: "Machine Cycles",
+            route: { route: routes.RouteLocation.Analysis_MachineCycles },
+            icon: _jsx(WorkIcon, {}),
+        },
+        {
+            name: "L/U Cycles",
+            route: { route: routes.RouteLocation.Analysis_LoadCycles },
+            icon: _jsx(LoadUnloadIcon, {}),
+        },
+        {
+            name: "Pallet Cycles",
+            route: { route: routes.RouteLocation.Analysis_PalletCycles },
+            icon: _jsx(PalletIcon, {}),
+        },
+        {
+            name: (info) => basketDisplayName(info.basketName) + " Cycles",
+            route: { route: routes.RouteLocation.Analysis_BasketCycles },
+            icon: _jsx(PalletIcon, {}),
+            hidden: () => !hasBasketCycles,
+        },
+        { separator: "Cell" },
+        { name: "Quality", route: { route: routes.RouteLocation.Analysis_Quality }, icon: _jsx(BuildIcon, {}) },
+        {
+            name: "Tool Replacements",
+            route: { route: routes.RouteLocation.Analysis_ToolReplacements },
+            icon: _jsx(ToolIcon, {}),
+        },
+        {
+            name: "Schedules",
+            route: { route: routes.RouteLocation.Analysis_Schedules },
+            icon: _jsx(ScheduleIcon, {}),
+        },
+        { separator: "Costs" },
+        {
+            name: "Percentages",
+            route: { route: routes.RouteLocation.Analysis_CostPercents },
+            icon: _jsx(CallSplit, {}),
+        },
+        {
+            name: "Cost/Piece",
+            route: { route: routes.RouteLocation.Analysis_CostPerPiece },
+            icon: _jsx(CostIcon, {}),
+        },
+    ];
+}
+function isRouteLocation(value) {
+    return typeof value === "string" && Object.values(routes.RouteLocation).includes(value);
+}
+function isSimpleRouteLocation(value) {
+    return (isRouteLocation(value) &&
+        value !== routes.RouteLocation.Client_Custom &&
+        value !== routes.RouteLocation.Operations_CurrentWorkorders &&
+        value !== routes.RouteLocation.Station_InspectionMonitorWithType &&
+        value !== routes.RouteLocation.Station_LoadMonitor &&
+        value !== routes.RouteLocation.Station_Queues);
+}
+function toRouteState(simpleRoute) {
+    // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- these routes do not carry extra payload.
+    return { route: simpleRoute };
+}
 export function NavTabs({ children }) {
     const [route, setRoute] = useAtom(routes.currentRoute);
     const theme = useTheme();
@@ -229,8 +255,8 @@ export function NavTabs({ children }) {
             if (v === OperationsReportsTab) {
                 setRoute({ route: routes.RouteLocation.Operations_MachineCycles });
             }
-            else {
-                setRoute({ route: v });
+            else if (isSimpleRouteLocation(v)) {
+                setRoute(toRouteState(v));
             }
         }), textColor: "inherit", scrollButtons: true, allowScrollButtonsMobile: true, indicatorColor: "secondary", children: children }));
 }
@@ -255,7 +281,10 @@ function SalesTabs() {
 const App = memo(function App(props) {
     routes.useWatchHistory();
     const fmsInfo = useAtomValue(serverSettings.fmsInformation);
+    const hasLast30BasketCycles = useAtomValue(last30HasBasketCycleData);
+    const hasSpecificMonthBasketCycles = useAtomValue(specificMonthHasBasketCycleData);
     const [route, setRoute] = useAtom(routes.currentRoute);
+    const analysisMenuNavItems = analysisReports(hasLast30BasketCycles || hasSpecificMonthBasketCycles);
     const showLogout = fmsInfo.user !== null && fmsInfo.user !== undefined;
     let page;
     let nav1 = undefined;
@@ -314,67 +343,73 @@ const App = memo(function App(props) {
             case routes.RouteLocation.Analysis_Quality:
                 page = _jsx(AnalysisQualityPage, {});
                 nav1 = AnalysisSelectToolbar;
-                menuNavItems = analysisReports;
+                menuNavItems = analysisMenuNavItems;
                 showAlarms = false;
                 break;
             case routes.RouteLocation.Analysis_ToolReplacements:
                 page = _jsx(ToolReplacementPage, {});
                 nav1 = AnalysisSelectToolbar;
-                menuNavItems = analysisReports;
+                menuNavItems = analysisMenuNavItems;
                 showAlarms = false;
                 break;
             case routes.RouteLocation.Analysis_Schedules:
                 page = _jsx(ScheduleHistory, {});
                 nav1 = AnalysisSelectToolbar;
-                menuNavItems = analysisReports;
+                menuNavItems = analysisMenuNavItems;
                 showAlarms = false;
                 break;
             case routes.RouteLocation.Analysis_Buffers:
                 page = _jsx(BufferOccupancyChart, {});
                 nav1 = AnalysisSelectToolbar;
-                menuNavItems = analysisReports;
+                menuNavItems = analysisMenuNavItems;
                 showAlarms = false;
                 break;
             case routes.RouteLocation.Analysis_StationOEE:
                 page = _jsx(StationOeeHeatmap, {});
                 nav1 = AnalysisSelectToolbar;
-                menuNavItems = analysisReports;
+                menuNavItems = analysisMenuNavItems;
                 showAlarms = false;
                 break;
             case routes.RouteLocation.Analysis_PartsCompleted:
                 page = _jsx(CompletedCountHeatmap, {});
                 nav1 = AnalysisSelectToolbar;
-                menuNavItems = analysisReports;
+                menuNavItems = analysisMenuNavItems;
                 showAlarms = false;
                 break;
             case routes.RouteLocation.Analysis_MachineCycles:
                 page = _jsx(PartMachineCycleChart, {});
                 nav1 = AnalysisSelectToolbar;
-                menuNavItems = analysisReports;
+                menuNavItems = analysisMenuNavItems;
                 showAlarms = false;
                 break;
             case routes.RouteLocation.Analysis_LoadCycles:
                 page = _jsx(PartLoadStationCycleChart, {});
                 nav1 = AnalysisSelectToolbar;
-                menuNavItems = analysisReports;
+                menuNavItems = analysisMenuNavItems;
                 showAlarms = false;
                 break;
             case routes.RouteLocation.Analysis_PalletCycles:
                 page = _jsx(PalletCycleChart, {});
                 nav1 = AnalysisSelectToolbar;
-                menuNavItems = analysisReports;
+                menuNavItems = analysisMenuNavItems;
+                showAlarms = false;
+                break;
+            case routes.RouteLocation.Analysis_BasketCycles:
+                page = _jsx(BasketCycleChart, {});
+                nav1 = AnalysisSelectToolbar;
+                menuNavItems = analysisMenuNavItems;
                 showAlarms = false;
                 break;
             case routes.RouteLocation.Analysis_CostPercents:
                 page = _jsx(CostBreakdownPage, {});
                 nav1 = AnalysisSelectToolbar;
-                menuNavItems = analysisReports;
+                menuNavItems = analysisMenuNavItems;
                 showAlarms = false;
                 break;
             case routes.RouteLocation.Analysis_CostPerPiece:
                 page = _jsx(CostPerPiecePage, {});
                 nav1 = AnalysisSelectToolbar;
-                menuNavItems = analysisReports;
+                menuNavItems = analysisMenuNavItems;
                 showAlarms = false;
                 break;
             case routes.RouteLocation.Operations_Dashboard:

package/dist/components/BarcodeScanning.js

@@ -114,7 +114,12 @@ export const QRScanButton = memo(function QRScanButton() {
         setDialogOpen(false);
         setManual("");
     }
-    return (_jsxs(_Fragment, { children: [_jsxs(Dialog, { open: dialogOpen, onClose: () => setDialogOpen(false), children: [_jsx(DialogTitle, { children: "Scan a QR Code" }), _jsxs(DialogContent, { children: [_jsx(Box, { width: "15em", height: "15em", children: dialogOpen ? _jsx(Scanner, { onScan: onScan }) : undefined }), _jsx(Box, { marginTop: "1em", children: _jsx(TextField, { label: "Manual Entry", value: manual, variant: "outlined", fullWidth: true, onKeyDown: (e) => {
+    return (_jsxs(_Fragment, { children: [_jsxs(Dialog, { open: dialogOpen, onClose: () => setDialogOpen(false), children: [_jsx(DialogTitle, { children: "Scan a QR Code" }), _jsxs(DialogContent, { children: [_jsx(Box, { sx: {
+                                    width: "15em",
+                                    height: "15em",
+                                }, children: dialogOpen ? _jsx(Scanner, { onScan: onScan }) : undefined }), _jsx(Box, { sx: {
+                                    marginTop: "1em",
+                                }, children: _jsx(TextField, { label: "Manual Entry", value: manual, variant: "outlined", fullWidth: true, onKeyDown: (e) => {
                                         if (e.key === "Enter") {
                                             onManual();
                                         }
@@ -142,7 +147,12 @@ export const AddByBarcodeDialog = memo(function AddByBarcodeDialog() {
         setManual("");
     }
     return (_jsxs(Dialog, { open: queue !== null, onClose: () => setQueue(null), maxWidth: "md", children: [_jsxs(DialogTitle, { children: ["Scan a Barcode To Add To ", queue] }), _jsxs(DialogContent, { children: [window.location.protocol === "https:" ||
-                        (import.meta.env.DEV && window.location.hostname === "localhost") ? (_jsx(Box, { width: "15em", height: "15em", children: queue !== null ? _jsx(Scanner, { onScan: onScan }) : undefined })) : undefined, _jsx(Box, { marginTop: "1em", children: _jsx(TextField, { label: "Manual Entry", value: manual, variant: "outlined", fullWidth: true, onKeyDown: (e) => {
+                        (import.meta.env.DEV && window.location.hostname === "localhost") ? (_jsx(Box, { sx: {
+                            width: "15em",
+                            height: "15em",
+                        }, children: queue !== null ? _jsx(Scanner, { onScan: onScan }) : undefined })) : undefined, _jsx(Box, { sx: {
+                            marginTop: "1em",
+                        }, children: _jsx(TextField, { label: "Manual Entry", value: manual, variant: "outlined", fullWidth: true, onKeyDown: (e) => {
                                 if (e.key === "Enter") {
                                     onManual();
                                 }

package/dist/components/ErrorsAndLoading.js

@@ -37,6 +37,15 @@ import { Card } from "@mui/material";
 import { CardContent } from "@mui/material";
 import { ErrorBoundary } from "react-error-boundary";
 import { ApiException } from "../network/api.js";
+function displayUnknownError(error) {
+    if (typeof error === "string") {
+        return error;
+    }
+    if (typeof error === "number" || typeof error === "boolean" || typeof error === "bigint") {
+        return error.toString();
+    }
+    return JSON.stringify(error) ?? "";
+}
 export function Loading() {
     return (_jsxs("div", { style: { textAlign: "center", marginTop: "4em" }, children: [_jsx(CircularProgress, {}), _jsx("p", { children: "Loading" })] }));
 }
@@ -50,7 +59,7 @@ export function DisplayError({ error }) {
         return (_jsx(Card, { children: _jsx(CardContent, { children: error.message }) }));
     }
     else {
-        return (_jsx(Card, { children: _jsxs(CardContent, { children: [_jsx("h3", { children: "Unknown Error" }), _jsx("p", { children: String(error) })] }) }));
+        return (_jsx(Card, { children: _jsxs(CardContent, { children: [_jsx("h3", { children: "Unknown Error" }), _jsx("p", { children: displayUnknownError(error) })] }) }));
     }
 }
 export function DisplayLoadingAndError(props) {

package/dist/components/LogEntry.d.ts

@@ -7,7 +7,6 @@ export interface LogEntryProps {
 }
 export declare function isLogEntryInvalidated(e: api.ILogEntry): boolean;
 export declare const LogEntry: import("react").MemoExoticComponent<(props: LogEntryProps) => import("react/jsx-runtime").JSX.Element>;
-export declare function filterRemoveAddQueue(entries: Iterable<Readonly<api.ILogEntry>>): Iterable<Readonly<api.ILogEntry>>;
 export interface LogEntriesProps {
     entries: Iterable<Readonly<api.ILogEntry>>;
     copyToClipboard?: boolean;

package/dist/components/LogEntry.js

@@ -44,6 +44,10 @@ import { ChevronRight as ChevronRightIcon, ImportExport } from "@mui/icons-mater
 import { copyLogEntriesToClipboard } from "../data/results.cycles.js";
 import { durationToMinutes, durationToSeconds } from "../util/parseISODuration.js";
 import { LazySeq } from "@seedtactics/immutable-collections";
+import { useAtomValue } from "jotai";
+import { fmsInformation } from "../network/server-settings.js";
+import { basketDisplayName, loadStationDisplayName } from "../cell-status/station-cycles.js";
+import { filterRemoveAddQueue } from "./log-entry-queue-filter.js";
 const ColoredSpan = styled("span", { shouldForwardProp: (prop) => prop.toString()[0] !== "$" })(({ $type }) => {
     switch ($type) {
         case "machine":
@@ -62,7 +66,8 @@ const ColoredSpan = styled("span", { shouldForwardProp: (prop) => prop.toString(
             return { color: "red" };
     }
 });
-function logType(entry) {
+function logType(entry, fmsInfo) {
+    const basketName = basketDisplayName(fmsInfo.basketName);
     switch (entry.type) {
         case api.LogType.LoadUnloadCycle:
             if (entry.startofcycle) {
@@ -71,6 +76,22 @@ function logType(entry) {
             else {
                 return "End " + entry.result.charAt(0).toUpperCase() + entry.result.substring(1).toLowerCase();
             }
+        case api.LogType.BasketLoadUnload:
+            if (entry.program === "LOAD") {
+                return `${basketName} Load`;
+            }
+            else {
+                return `${basketName} Unload`;
+            }
+        case api.LogType.BasketCycle:
+            return `${basketName} Cycle`;
+        case api.LogType.BasketInLocation:
+            if (entry.startofcycle) {
+                return "Depart";
+            }
+            else {
+                return "Arrive";
+            }
         case api.LogType.MachineCycle:
             if (entry.startofcycle) {
                 return "Start Cycle";
@@ -133,7 +154,7 @@ function displayMat(mats) {
     }
     else if (mats.length == 1) {
         if (mats[0].numproc == 1) {
-            return `${mats[0].part}`;
+            return mats[0].part;
         }
         else {
             return `${mats[0].part}-${mats[0].proc}`;
@@ -154,11 +175,33 @@ function displayQueueMat(mats) {
         return "";
     }
 }
-function display(props) {
+function display(props, fmsInfo) {
     const entry = props.entry;
     switch (entry.type) {
         case api.LogType.LoadUnloadCycle:
-            return (_jsxs("span", { children: [displayMat(entry.material), " on ", _jsxs(ColoredSpan, { "$type": "pallet", children: ["pallet ", entry.pal] }), " at", " ", _jsxs(ColoredSpan, { "$type": "loadStation", children: ["station ", entry.locnum.toString()] })] }));
+            return (_jsxs("span", { children: [displayMat(entry.material), " on ", _jsxs(ColoredSpan, { "$type": "pallet", children: ["pallet ", entry.pal] }), " at", " ", _jsx(ColoredSpan, { "$type": "loadStation", children: loadStationDisplayName(entry.locnum, fmsInfo.loadStationNames) })] }));
+        case api.LogType.BasketLoadUnload: {
+            const basketName = basketDisplayName(fmsInfo.basketName);
+            return (_jsxs("span", { children: [displayMat(entry.material), " ", entry.program === "LOAD" ? "loaded onto" : "unloaded from", " ", _jsxs(ColoredSpan, { "$type": "pallet", children: [basketName, " ", entry.pal] }), " ", "at", " ", _jsx(ColoredSpan, { "$type": "loadStation", children: loadStationDisplayName(entry.locnum, fmsInfo.loadStationNames) })] }));
+        }
+        case api.LogType.BasketCycle: {
+            const basketName = basketDisplayName(fmsInfo.basketName);
+            if (entry.startofcycle) {
+                return (_jsxs("span", { children: [basketName, " ", entry.pal, " started cycle"] }));
+            }
+            else {
+                return (_jsxs("span", { children: [basketName, " ", entry.pal, " completed cycle"] }));
+            }
+        }
+        case api.LogType.BasketInLocation: {
+            const basketName = basketDisplayName(fmsInfo.basketName);
+            if (entry.startofcycle) {
+                return (_jsxs("span", { children: [basketName, " ", entry.pal, " departed from ", entry.loc, entry.locnum > 0 ? ` position ${entry.locnum}` : ""] }));
+            }
+            else {
+                return (_jsxs("span", { children: [basketName, " ", entry.pal, " arrived at ", entry.loc, entry.locnum > 0 ? ` position ${entry.locnum}` : ""] }));
+            }
+        }
         case api.LogType.MachineCycle:
             return (_jsxs("span", { children: [displayMat(entry.material), " on ", _jsxs(ColoredSpan, { "$type": "pallet", children: ["pallet ", entry.pal] }), " at", " ", _jsxs(ColoredSpan, { "$type": "machine", children: [entry.loc, " ", entry.locnum.toString()] }), entry.program && entry.program !== "" ? _jsxs("span", { children: [" with program ", entry.program] }) : undefined] }));
         case api.LogType.PartMark:
@@ -312,6 +355,7 @@ const logTypesToHighlight = [
     api.LogType.AddToQueue,
     api.LogType.RemoveFromQueue,
     api.LogType.LoadUnloadCycle,
+    api.LogType.BasketLoadUnload,
     api.LogType.MachineCycle,
 ];
 const LogEntryTableRow = styled(TableRow, { shouldForwardProp: (prop) => prop.toString()[0] !== "$" })(({ $highlightProc, $invalidCycle }) => ({
@@ -321,6 +365,7 @@ const LogEntryTableRow = styled(TableRow, { shouldForwardProp: (prop) => prop.to
 export const LogEntry = memo(function LogEntry(props) {
     const details = detailsForEntry(props.entry);
     const highlight = props.highlightProcsGreaterOrEqualTo;
+    const fmsInfo = useAtomValue(fmsInformation);
     return (_jsxs(_Fragment, { children: [_jsxs(LogEntryTableRow, { "$highlightProc": highlight !== undefined &&
                     props.entry.material.findIndex((m) => m.proc >= highlight) >= 0 &&
                     logTypesToHighlight.indexOf(props.entry.type) >= 0, "$invalidCycle": isLogEntryInvalidated(props.entry), children: [_jsx(TableCell, { size: "small", children: props.entry.endUTC.toLocaleDateString(undefined, {
@@ -330,7 +375,7 @@ export const LogEntry = memo(function LogEntry(props) {
                         }) }), _jsx(TableCell, { size: "small", children: props.entry.endUTC.toLocaleTimeString(undefined, {
                             hour: "numeric",
                             minute: "2-digit",
-                        }) }), _jsx(TableCell, { size: "small", children: logType(props.entry) }), _jsx(TableCell, { size: "small", children: display(props) }), _jsx(TableCell, { padding: "checkbox", children: details.length > 0 ? (_jsx(IconButton, { style: {
+                        }) }), _jsx(TableCell, { size: "small", children: logType(props.entry, fmsInfo) }), _jsx(TableCell, { size: "small", children: display(props, fmsInfo) }), _jsx(TableCell, { padding: "checkbox", children: details.length > 0 ? (_jsx(IconButton, { style: {
                                 transition: "all ease 200ms",
                                 transform: props.entry.counter === props.detailLogCounter ? "rotate(90deg)" : "none",
                             }, onClick: (event) => {
@@ -338,27 +383,6 @@ export const LogEntry = memo(function LogEntry(props) {
                                 event.stopPropagation();
                             }, size: "small", children: _jsx(ChevronRightIcon, { fontSize: "inherit" }) })) : undefined })] }), details.length > 0 && props.entry.counter === props.detailLogCounter ? (_jsx(TableRow, { children: _jsx(TableCell, { colSpan: 5, children: _jsx("ul", { children: details.map((d, idx) => (_jsxs("li", { children: [d.name, ": ", d.value] }, idx))) }) }) })) : undefined] }));
 });
-export function* filterRemoveAddQueue(entries) {
-    let prev = null;
-    for (const e of entries) {
-        if (prev != null &&
-            prev.type === api.LogType.RemoveFromQueue &&
-            e.type === api.LogType.AddToQueue &&
-            prev.loc === e.loc) {
-            // skip both prev and e
-            prev = null;
-        }
-        else {
-            if (prev !== null) {
-                yield prev;
-            }
-            prev = e;
-        }
-    }
-    if (prev !== null) {
-        yield prev;
-    }
-}
 export const LogEntries = memo(function LogEntriesF(props) {
     const [curDetail, setDetail] = useState(null);
     return (_jsxs(Table, { children: [_jsx(TableHead, { children: _jsxs(TableRow, { children: [_jsx(TableCell, { children: "Date" }), _jsx(TableCell, { children: "Time" }), _jsx(TableCell, { children: "Type" }), _jsx(TableCell, { children: "Details" }), _jsx(TableCell, { padding: "checkbox", children: props.copyToClipboard ? (_jsx(Tooltip, { title: "Copy to Clipboard", children: _jsx(IconButton, { onClick: () => copyLogEntriesToClipboard(props.entries), style: { height: "25px", paddingTop: 0, paddingBottom: 0 }, size: "large", children: _jsx(ImportExport, {}) }) })) : undefined })] }) }), _jsx(TableBody, { children: Array.from(filterRemoveAddQueue(props.entries)).map((e, idx) => (_jsx(LogEntry, { entry: e, detailLogCounter: curDetail, setDetail: setDetail, highlightProcsGreaterOrEqualTo: props.highlightProcsGreaterOrEqualTo }, idx))) })] }));