@seedtactics/insight-client 16.5.2 → 16.7.0

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

@@ -0,0 +1,21 @@
+import { ILogEntry } from "../network/api.js";
+import { HashMap } from "@seedtactics/immutable-collections";
+import type { ServerEventAndTime } from "./loading.js";
+import { Atom } from "jotai";
+import type { PalletCycleData } from "./pallet-cycles.js";
+export type BasketCycleData = PalletCycleData;
+export type BasketCyclesByCntr = HashMap<number, BasketCycleData>;
+export type BasketCyclesByBasket = HashMap<number, BasketCyclesByCntr>;
+export declare const last30BasketCycles: Atom<BasketCyclesByBasket>;
+export declare const last30HasBasketCycleData: Atom<boolean>;
+export declare const specificMonthBasketCycles: Atom<BasketCyclesByBasket>;
+export declare const specificMonthHasBasketCycleData: Atom<boolean>;
+export declare const setLast30BasketCycles: import("jotai").WritableAtom<null, [log: readonly Readonly<ILogEntry>[]], void> & {
+    init: null;
+};
+export declare const updateLast30BasketCycles: import("jotai").WritableAtom<null, [ServerEventAndTime], void> & {
+    init: null;
+};
+export declare const setSpecificMonthBasketCycles: import("jotai").WritableAtom<null, [log: readonly Readonly<ILogEntry>[]], void> & {
+    init: null;
+};

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

@@ -0,0 +1,80 @@
+/* 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 { addDays } from "date-fns";
+import { LogType } from "../network/api.js";
+import { HashMap, LazySeq } from "@seedtactics/immutable-collections";
+import { durationToMinutes } from "../util/parseISODuration.js";
+import { atom } from "jotai";
+const last30BasketCyclesRW = atom(HashMap.empty());
+export const last30BasketCycles = last30BasketCyclesRW;
+export const last30HasBasketCycleData = atom((get) => get(last30BasketCyclesRW).size > 0);
+const specificMonthBasketCyclesRW = atom(HashMap.empty());
+export const specificMonthBasketCycles = specificMonthBasketCyclesRW;
+export const specificMonthHasBasketCycleData = atom((get) => get(specificMonthBasketCyclesRW).size > 0);
+function logToBasketCycle(c) {
+    return {
+        cntr: c.counter,
+        x: c.endUTC,
+        y: durationToMinutes(c.elapsed),
+        active: durationToMinutes(c.active),
+        mats: c.material,
+    };
+}
+export const setLast30BasketCycles = atom(null, (_, set, log) => {
+    set(last30BasketCyclesRW, (oldCycles) => oldCycles.union(LazySeq.of(log)
+        .filter((c) => !c.startofcycle && c.type === LogType.BasketCycle && c.pal !== 0)
+        .toLookupMap((c) => c.pal, (c) => c.counter, logToBasketCycle), (e1, e2) => e1.union(e2)));
+});
+export const updateLast30BasketCycles = atom(null, (_, set, { evt, now, expire }) => {
+    if (evt.logEntry &&
+        !evt.logEntry.startofcycle &&
+        evt.logEntry.type === LogType.BasketCycle &&
+        evt.logEntry.pal !== 0) {
+        const log = evt.logEntry;
+        set(last30BasketCyclesRW, (oldCycles) => {
+            if (expire) {
+                const thirtyDaysAgo = addDays(now, -30);
+                oldCycles = oldCycles.collectValues((es) => {
+                    const newEs = es.filter((e) => e.x >= thirtyDaysAgo);
+                    return newEs.size > 0 ? newEs : null;
+                });
+            }
+            return oldCycles.modify(log.pal, (old) => (old ?? HashMap.empty()).set(log.counter, logToBasketCycle(log)));
+        });
+    }
+});
+export const setSpecificMonthBasketCycles = atom(null, (_, set, log) => {
+    set(specificMonthBasketCyclesRW, LazySeq.of(log)
+        .filter((c) => !c.startofcycle && c.type === LogType.BasketCycle && c.pal !== 0)
+        .toLookupMap((c) => c.pal, (c) => c.counter, logToBasketCycle));
+});

package/dist/cell-status/current-status.js

@@ -31,7 +31,7 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 import { JobsBackend, LogBackend } from "../network/backend.js";
-import { InProcessMaterial, LogType, LocType, ActiveJob, WorkorderComment, ActiveWorkorder, } from "../network/api.js";
+import { InProcessMaterial, LogType, LocType, ActiveJob, WorkorderComment, ActiveWorkorder, InProcessMaterialLocation, } from "../network/api.js";
 import { last30JobComment } from "./scheduled-jobs.js";
 import { atom } from "jotai";
 import { currentOperator } from "../data/operators.js";
@@ -173,7 +173,12 @@ export const reorderQueuedMatInCurrentStatus = atom(null, (_, set, { queue, matI
             if (m.materialID === matId) {
                 return new InProcessMaterial({
                     ...m,
-                    location: { type: LocType.InQueue, currentQueue: queue, queuePosition: newIdx },
+                    location: new InProcessMaterialLocation({
+                        ...m.location,
+                        type: LocType.InQueue,
+                        currentQueue: queue,
+                        queuePosition: newIdx,
+                    }),
                 });
             }
             let idx = m.location.queuePosition;
@@ -188,7 +193,10 @@ export const reorderQueuedMatInCurrentStatus = atom(null, (_, set, { queue, matI
             if (idx !== m.location.queuePosition) {
                 return new InProcessMaterial({
                     ...m,
-                    location: { ...m.location, queuePosition: idx },
+                    location: new InProcessMaterialLocation({
+                        ...m.location,
+                        queuePosition: idx,
+                    }),
                 });
             }
             else {

package/dist/cell-status/estimated-cycle-times.js

@@ -42,12 +42,14 @@ export class PartAndStationOperation {
         this.operation = operation;
     }
     static ofLogCycle(c) {
-        return new PartAndStationOperation(c.material[0].part, c.loc, c.type === LogType.LoadUnloadCycle && c.material.length > 0
+        return new PartAndStationOperation(c.material[0].part, c.loc, (c.type === LogType.LoadUnloadCycle || c.type === LogType.BasketLoadUnload) && c.material.length > 0
             ? c.result + "-" + c.material[0].proc.toString()
             : c.program);
     }
     static ofPartCycle(c) {
-        return new PartAndStationOperation(c.part, c.stationGroup, c.isLabor && c.material.length > 0 ? c.operation + "-" + c.material[0].proc.toString() : c.operation);
+        return new PartAndStationOperation(c.part, c.stationGroup, c.carrier.kind !== "machining" && c.material.length > 0
+            ? c.operation + "-" + c.material[0].proc.toString()
+            : c.operation);
     }
     compare(other) {
         let cmp = this.part.localeCompare(other.part);
@@ -99,7 +101,7 @@ export function isOutlierAbove(s, mins) {
     }
 }
 function median(vals) {
-    const sorted = vals.toMutableArray().sort((a, b) => a - b);
+    const sorted = vals.toSortedArray((x) => x);
     const cnt = sorted.length;
     if (cnt === 0) {
         return 0;
@@ -222,7 +224,9 @@ export function calcElapsedForCycles(eventLog) {
             }
         }
     }
-    return chunkCyclesWithSimilarEndTime(LazySeq.of(eventLog).filter((e) => (e.type === LogType.LoadUnloadCycle || e.type === LogType.MachineCycle) &&
+    return chunkCyclesWithSimilarEndTime(LazySeq.of(eventLog).filter((e) => (e.type === LogType.LoadUnloadCycle ||
+        e.type === LogType.BasketLoadUnload ||
+        e.type === LogType.MachineCycle) &&
         !e.startofcycle &&
         e.loc !== "" &&
         e.material.length > 0), (c) => c.loc + " #" + c.locnum.toString(), (c) => c.endUTC)

package/dist/cell-status/inspections.js

@@ -74,8 +74,8 @@ export function convertLogToInspections(c) {
     }
     return c.material.map((m) => {
         if (c.type === LogType.Inspection) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-            const pathsJson = JSON.parse((c.details || {}).ActualPath || "[]");
+            const parsedPaths = JSON.parse((c.details || {}).ActualPath || "[]");
+            const pathsJson = Array.isArray(parsedPaths) ? parsedPaths : [];
             const paths = [];
             for (const pathJson of pathsJson) {
                 paths.push(MaterialProcessActualPath.fromJS(pathJson));

package/dist/cell-status/loading.js

@@ -42,6 +42,7 @@ import * as names from "./names.js";
 import * as estimated from "./estimated-cycle-times.js";
 import * as tool from "./tool-usage.js";
 import * as palCycles from "./pallet-cycles.js";
+import * as basketCycles from "./basket-cycles.js";
 import * as statCycles from "./station-cycles.js";
 import * as toolReplace from "./tool-replacements.js";
 import * as simDayUsage from "./sim-day-usage.js";
@@ -60,6 +61,7 @@ export const onServerEvent = atom(null, (_, set, evt) => {
     set(names.updateNames, evt);
     set(tool.updateLast30ToolUse, evt);
     set(palCycles.updateLast30PalletCycles, evt);
+    set(basketCycles.updateLast30BasketCycles, evt);
     set(toolReplace.updateLastToolReplacements, evt);
     set(statCycles.updateLast30StationCycles, evt);
     set(rebookings.updateLast30Rebookings, evt);
@@ -86,6 +88,7 @@ export const onLoadLast30Log = atom(null, (_, set, log) => {
     set(names.setNamesFromLast30Evts, log);
     set(tool.setLast30ToolUse, log);
     set(palCycles.setLast30PalletCycles, log);
+    set(basketCycles.setLast30BasketCycles, log);
     set(toolReplace.setLast30ToolReplacements, log);
     set(statCycles.setLast30StationCycles, log);
     set(rebookings.setLast30Rebookings, log);
@@ -107,6 +110,7 @@ export const onLoadSpecificMonthLog = atom(null, (_, set, log) => {
     set(insp.setSpecificMonthInspections, log);
     set(mats.setSpecificMonthMatSummary, log);
     set(palCycles.setSpecificMonthPalletCycles, log);
+    set(basketCycles.setSpecificMonthBasketCycles, log);
     set(toolReplace.setSpecificMonthToolReplacements, log);
     set(statCycles.setSpecificMonthStationCycles, log);
 });

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

@@ -32,8 +32,10 @@ export type MaterialToShow = {
 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 type LargestUsedProces = {
@@ -66,7 +68,10 @@ export interface CompleteCloseoutData {
     readonly failed: boolean;
 }
 export declare function useCompleteCloseout(): [(d: CompleteCloseoutData) => void, boolean];
-export declare function useAssignWorkorder(): [(mat: MaterialToShowInfo, workorder: string) => void, boolean];
+export declare function useAssignWorkorder(): [
+    (mat: MaterialToShowInfo, workorder: string) => void,
+    boolean
+];
 export interface AddNoteData {
     readonly matId: number;
     readonly process: number;
@@ -90,7 +95,10 @@ export interface AddExistingMaterialToQueueData {
     readonly queuePosition: number;
     readonly operator: string | null;
 }
-export declare function useAddExistingMaterialToQueue(): [(d: AddExistingMaterialToQueueData) => void, boolean];
+export declare function useAddExistingMaterialToQueue(): [
+    (d: AddExistingMaterialToQueueData) => void,
+    boolean
+];
 export interface AddNewMaterialToQueueData {
     readonly jobUnique: string;
     readonly lastCompletedProcess: number;
@@ -100,7 +108,7 @@ export interface AddNewMaterialToQueueData {
     readonly operator: string | null;
     readonly workorder: string | null;
     readonly onNewMaterial?: (mat: Readonly<IInProcessMaterial>) => void;
-    readonly onError?: (reason: any) => void;
+    readonly onError?: (reason: unknown) => void;
 }
 export declare function useAddNewMaterialToQueue(): [(d: AddNewMaterialToQueueData) => void, boolean];
 export interface AddNewCastingToQueueData {
@@ -111,6 +119,6 @@ export interface AddNewCastingToQueueData {
     readonly workorder: string | null;
     readonly operator: string | null;
     readonly onNewMaterial?: (mats: ReadonlyArray<Readonly<IInProcessMaterial>>) => void;
-    readonly onError?: (reason: any) => void;
+    readonly onError?: (reason: unknown) => void;
 }
 export declare function useAddNewCastingToQueue(): [(d: AddNewCastingToQueueData) => void, boolean];

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

@@ -36,7 +36,7 @@ import { LogType, NewInspectionCompleted, NewCloseout, QueuePosition, } from "..
 import { useCallback, useState } from "react";
 import { currentStatus } from "./current-status.js";
 import { atom, useSetAtom } from "jotai";
-import { loadable } from "jotai/utils";
+import { unwrap } from "jotai/utils";
 import { isLogEntryInvalidated } from "../components/LogEntry.js";
 import { currentRoute, RouteLocation } from "../components/routes.js";
 const matToShow = atom(null);
@@ -55,6 +55,9 @@ export const materialDialogOpen = atom((get) => get(matToShow), (_, set, mat) =>
 const barcodeMaterialDetail = atom(async (get) => {
     const toShow = get(matToShow);
     if (toShow && toShow.type === "Barcode") {
+        if (typeof FmsServerBackend === "undefined") {
+            return null;
+        }
         const route = get(currentRoute);
         const queues = toShow.toQueue
             ? [toShow.toQueue]
@@ -101,10 +104,14 @@ export const materialInDialogInfo = atom(async (get) => {
         }
         case "ManuallyEnteredSerial":
         case "AddMatWithEnteredSerial": {
+            if (typeof LogBackend === "undefined") {
+                return null;
+            }
             return (await LogBackend.materialForSerial(curMat.serial))?.[0] ?? null;
         }
     }
 });
+export const materialInDialogInfoUnwrapped = unwrap(materialInDialogInfo, (prev) => prev ?? null);
 export const inProcessMaterialInDialog = atom(async (get) => {
     const status = get(currentStatus);
     const toShow = get(matToShow);
@@ -113,7 +120,9 @@ export const inProcessMaterialInDialog = atom(async (get) => {
     if (toShow.type === "InProcMat")
         return toShow.inproc;
     const matId = (await get(materialInDialogInfo))?.materialID ?? null;
-    return matId !== null && matId >= 0 ? (status.material.find((m) => m.materialID === matId) ?? null) : null;
+    return matId !== null && matId >= 0
+        ? (status.material.find((m) => m.materialID === matId) ?? null)
+        : null;
 });
 export const serialInMaterialDialog = atom(async (get) => {
     const toShow = get(matToShow);
@@ -130,13 +139,14 @@ export const serialInMaterialDialog = atom(async (get) => {
             return toShow.logMat.serial ?? null;
         case "Barcode": {
             const barcodeMat = await get(barcodeMaterialDetail);
-            return barcodeMat?.existingMaterial?.serial ?? barcodeMat?.potentialNewMaterial?.serial ?? null;
+            return (barcodeMat?.existingMaterial?.serial ?? barcodeMat?.potentialNewMaterial?.serial ?? null);
         }
         case "ManuallyEnteredSerial":
         case "AddMatWithEnteredSerial":
             return toShow.serial;
     }
 });
+export const serialInMaterialDialogUnwrapped = unwrap(serialInMaterialDialog, (prev) => prev ?? null);
 export const workorderInMaterialDialog = atom(async (get) => {
     const toShow = get(matToShow);
     if (toShow === null)
@@ -152,7 +162,9 @@ export const workorderInMaterialDialog = atom(async (get) => {
             return toShow.logMat.workorder ?? null;
         case "Barcode": {
             const barcodeMat = await get(barcodeMaterialDetail);
-            return barcodeMat?.existingMaterial?.workorder ?? barcodeMat?.potentialNewMaterial?.workorder ?? null;
+            return (barcodeMat?.existingMaterial?.workorder ??
+                barcodeMat?.potentialNewMaterial?.workorder ??
+                null);
         }
         case "ManuallyEnteredSerial":
         case "AddMatWithEnteredSerial":
@@ -168,6 +180,9 @@ const localMatEvents = atom(async (get, { signal }) => {
     if (mat === null) {
         return [];
     }
+    else if (typeof LogBackend === "undefined") {
+        return [];
+    }
     else if (mat.materialID >= 0) {
         return await LogBackend.logForMaterial(mat.materialID, signal);
     }
@@ -178,7 +193,7 @@ const localMatEvents = atom(async (get, { signal }) => {
         return [];
     }
 });
-const localMatEventsLoadable = loadable(localMatEvents);
+const localMatEventsUnwrapped = unwrap(localMatEvents, (prev) => prev ?? []);
 const otherMatEvents = atom(async (get, { signal }) => {
     const serial = await get(serialInMaterialDialog);
     if (serial === null || serial === "")
@@ -189,13 +204,11 @@ const otherMatEvents = atom(async (get, { signal }) => {
     }
     return evts;
 });
-const otherMatEventsLoadable = loadable(otherMatEvents);
+const otherMatEventsUnwrapped = unwrap(otherMatEvents, (prev) => prev ?? []);
 export const materialInDialogEvents = atom((get) => {
-    const localEvts = get(localMatEventsLoadable);
-    const otherEvts = get(otherMatEventsLoadable);
     const evtsFromUpdate = get(extraLogEventsFromUpdates);
-    return LazySeq.of(localEvts.state === "hasData" ? localEvts.data : [])
-        .concat(otherEvts.state === "hasData" ? otherEvts.data : [])
+    return LazySeq.of(get(localMatEventsUnwrapped))
+        .concat(get(otherMatEventsUnwrapped))
         .sortBy((e) => e.endUTC.getTime(), (e) => e.counter)
         .concat(evtsFromUpdate)
         .toRArray();
@@ -408,9 +421,7 @@ export function useAddNewCastingToQueue() {
     const [updating, setUpdating] = useState(false);
     const callback = useCallback((d) => {
         setUpdating(true);
-        JobsBackend.addUnallocatedCastingToQueue(d.casting, d.queue, d.quantity, d.operator, d.workorder, [
-            ...(d.serials || []),
-        ])
+        JobsBackend.addUnallocatedCastingToQueue(d.casting, d.queue, d.quantity, d.operator, d.workorder, [...(d.serials || [])])
             .then((ms) => {
             if (d.onNewMaterial)
                 d.onNewMaterial(ms);

package/dist/cell-status/rebookings.js

@@ -34,26 +34,24 @@ import { atom } from "jotai";
 import { LogType } from "../network/api";
 import { LazySeq, OrderedMap } from "@seedtactics/immutable-collections";
 import { JobsBackend, LogBackend } from "../network/backend";
-import { loadable } from "jotai/utils";
+import { unwrap } from "jotai/utils";
 import { addDays } from "date-fns";
 import { useCallback, useState } from "react";
 const rebookingEvts = atom(OrderedMap.empty());
 // unscheduled rebookings should be loaded from the last 30 events, but it is
-// possible for some to be older than 30 days, so load them here.  But don't
-// wait for them to be loaded before rendering, so everything is wrapped in loadable.
-const unschRebookings = loadable(atom(async (_, { signal }) => {
-    const b = await JobsBackend.unscheduledRebookings(signal);
-    return OrderedMap.build(b, (b) => b.bookingId);
-}));
+// possible for some to be older than 30 days, so load them here without
+// blocking rendering while the request is still pending.
+const unschRebookings = unwrap(atom(async (_, { signal }) => {
+    if (typeof JobsBackend === "undefined") {
+        return OrderedMap.empty();
+    }
+    const bookings = await JobsBackend.unscheduledRebookings(signal);
+    return OrderedMap.build(bookings, (booking) => booking.bookingId);
+}), (prev) => prev ?? OrderedMap.empty());
 export const last30Rebookings = atom((get) => {
     const evts = get(rebookingEvts);
     const unsch = get(unschRebookings);
-    if (unsch.state === "hasData") {
-        return evts.union(unsch.data, (fromEvt, fromUnsch) => fromEvt ?? fromUnsch);
-    }
-    else {
-        return evts;
-    }
+    return evts.union(unsch, (fromEvt, fromUnsch) => fromEvt ?? fromUnsch);
 });
 const canceledRebookingsRW = atom(OrderedMap.empty());
 export const canceledRebookings = canceledRebookingsRW;
@@ -85,11 +83,11 @@ export const setLast30Rebookings = atom(null, (get, set, log) => {
 function updateJobs(set, jobs, expire) {
     set(scheduledRW, (old) => {
         if (expire) {
-            old = old.filter((b) => b.scheduledTime >= expire);
+            old = old.filter((booking) => booking.scheduledTime >= expire);
         }
         return old.union(jobs
-            .flatMap((j) => (j.bookings ?? []).map((b) => [
-            b,
+            .flatMap((j) => (j.bookings ?? []).map((booking) => [
+            booking,
             {
                 scheduledTime: j.routeStartUTC,
                 jobUnique: j.unique,
@@ -99,7 +97,7 @@ function updateJobs(set, jobs, expire) {
     });
 }
 export const setLast30RebookingJobs = atom(null, (_, set, historic) => {
-    updateJobs(set, LazySeq.ofObject(historic.jobs).map(([_, j]) => j));
+    updateJobs(set, LazySeq.ofObject(historic.jobs).map(([, j]) => j));
 });
 export const updateLast30Rebookings = atom(null, (get, set, { evt, now, expire }) => {
     if (evt.newJobs) {

package/dist/cell-status/scheduled-jobs.d.ts

@@ -1,5 +1,5 @@
 import type { ServerEventAndTime } from "./loading.js";
-import { IHistoricData, IHistoricJob, IRecentHistoricData } from "../network/api.js";
+import { IHistoricData, IRecentHistoricData, IHistoricJob } from "../network/api.js";
 import { HashMap, HashSet } from "@seedtactics/immutable-collections";
 import { Atom } from "jotai";
 export declare const last30Jobs: Atom<HashMap<string, Readonly<IHistoricJob>>>;

package/dist/cell-status/scheduled-jobs.js

@@ -31,6 +31,7 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 import { addDays } from "date-fns";
+import { HistoricJob } from "../network/api.js";
 import { HashMap, HashSet, LazySeq } from "@seedtactics/immutable-collections";
 import { atom } from "jotai";
 import { atomFamily } from "jotai-family";
@@ -67,10 +68,16 @@ export const updateLast30Jobs = atom(null, (_, set, { evt, now, expire }) => {
         const newJobs = LazySeq.of(evt.newJobs.jobs);
         set(last30JobsRW, (oldJobs) => {
             if (expire) {
-                const expire = addDays(now, -30);
-                oldJobs = oldJobs.filter((j) => j.routeStartUTC >= expire);
+                const expireDate = addDays(now, -30);
+                oldJobs = oldJobs.filter((j) => j.routeStartUTC >= expireDate);
             }
-            return oldJobs.union(newJobs.toHashMap((j) => [j.unique, { ...j, copiedToSystem: true }]));
+            return oldJobs.union(newJobs.toHashMap((j) => {
+                const historicJob = new HistoricJob({
+                    ...j,
+                    copiedToSystem: true,
+                });
+                return [j.unique, historicJob];
+            }));
         });
         if (schId) {
             set(last30SchIdsRW, (oldIds) => oldIds.add(schId));

package/dist/cell-status/sim-production.js

@@ -74,13 +74,13 @@ export const updateLast30JobProduction = atom(null, (_, set, { evt, now, expire
         const apiNewJobs = evt.newJobs.jobs;
         set(last30SimProductionRW, (simProd) => {
             if (expire) {
-                const expire = addDays(now, -30);
+                const expireDate = addDays(now, -30);
                 // check if nothing to expire and no new data
                 const minProd = LazySeq.of(simProd).minBy((e) => e.completeTime.getTime());
-                if ((minProd === undefined || minProd.completeTime >= expire) && apiNewJobs.length === 0) {
+                if ((minProd === undefined || minProd.completeTime >= expireDate) && apiNewJobs.length === 0) {
                     return simProd;
                 }
-                simProd = simProd.filter((e) => e.completeTime >= expire);
+                simProd = simProd.filter((e) => e.completeTime >= expireDate);
             }
             return [...simProd, ...jobToPartCompleted(apiNewJobs)];
         });

package/dist/cell-status/sim-station-use.d.ts

@@ -3,6 +3,7 @@ import { IHistoricData } from "../network/api.js";
 import { Atom } from "jotai";
 export interface SimStationUse {
     readonly station: string;
+    readonly stationLabel: string;
     readonly start: Date;
     readonly end: Date;
     readonly plannedDown: boolean;

package/dist/cell-status/sim-station-use.js

@@ -33,25 +33,30 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 import { LazySeq } from "@seedtactics/immutable-collections";
 import { addDays } from "date-fns";
 import { atom } from "jotai";
+import { fmsInformation } from "../network/server-settings.js";
+import { displayStationName } from "./station-cycles.js";
 const last30SimStationUseRW = atom([]);
 export const last30SimStationUse = last30SimStationUseRW;
 const specificMonthSimStationUseRW = atom([]);
 export const specificMonthSimStationUse = specificMonthSimStationUseRW;
-function procSimUse(apiSimUse) {
+function procSimUse(apiSimUse, loadStationNames) {
     return apiSimUse.map((simUse) => ({
         station: simUse.stationGroup + " #" + simUse.stationNum.toString(),
+        stationLabel: displayStationName(simUse.stationGroup, simUse.stationNum, loadStationNames),
         start: simUse.startUTC,
         end: simUse.endUTC,
         plannedDown: simUse.planDown ?? false,
-        part: simUse.parts?.map((p) => ({ uniq: p.jobUnique, proc: p.process, path: p.path })),
+        parts: simUse.parts?.map((p) => ({ uniq: p.jobUnique, proc: p.process, path: p.path })),
     }));
 }
-export const setLast30SimStatUse = atom(null, (_, set, history) => {
-    set(last30SimStationUseRW, (oldSimUse) => oldSimUse.concat(procSimUse(history.stationUse)));
+export const setLast30SimStatUse = atom(null, (get, set, history) => {
+    const loadStationNames = get(fmsInformation)?.loadStationNames;
+    set(last30SimStationUseRW, (oldSimUse) => oldSimUse.concat(procSimUse(history.stationUse, loadStationNames)));
 });
-export const updateLast30SimStatUse = atom(null, (_, set, { evt, now, expire }) => {
+export const updateLast30SimStatUse = atom(null, (get, set, { evt, now, expire }) => {
     if (evt.newJobs?.stationUse) {
         const apiSimUse = evt.newJobs?.stationUse;
+        const loadStationNames = get(fmsInformation)?.loadStationNames;
         set(last30SimStationUseRW, (simUse) => {
             if (expire) {
                 const expireT = addDays(now, -30);
@@ -62,10 +67,11 @@ export const updateLast30SimStatUse = atom(null, (_, set, { evt, now, expire })
                 }
                 simUse = simUse.filter((e) => e.start >= expireT);
             }
-            return simUse.concat(procSimUse(apiSimUse));
+            return simUse.concat(procSimUse(apiSimUse, loadStationNames));
         });
     }
 });
-export const setSpecificMonthSimStatUse = atom(null, (_, set, history) => {
-    set(specificMonthSimStationUseRW, procSimUse(history.stationUse));
+export const setSpecificMonthSimStatUse = atom(null, (get, set, history) => {
+    const loadStationNames = get(fmsInformation)?.loadStationNames;
+    set(specificMonthSimStationUseRW, procSimUse(history.stationUse, loadStationNames));
 });

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

@@ -2,6 +2,16 @@ import { ILogEntry, ILogMaterial } from "../network/api.js";
 import type { ServerEventAndTime } from "./loading.js";
 import { HashMap } from "@seedtactics/immutable-collections";
 import { Atom } from "jotai";
+export type PartCycleCarrier = {
+    readonly kind: "machining";
+    readonly pallet: number;
+} | {
+    readonly kind: "pallet-lul";
+    readonly pallet: number;
+} | {
+    readonly kind: "basket-lul";
+    readonly basket: number;
+};
 export interface PartCycleData {
     readonly endTime: Date;
     readonly elapsedMinsPerMaterial: number;
@@ -9,10 +19,10 @@ export interface PartCycleData {
     readonly part: string;
     readonly stationGroup: string;
     readonly stationNumber: number;
+    readonly stationLabel: string;
     readonly operation: string;
-    readonly pallet: number;
+    readonly carrier: PartCycleCarrier;
     readonly activeMinutes: number;
-    readonly isLabor: boolean;
     readonly material: ReadonlyArray<Readonly<ILogMaterial>>;
     readonly operator: string;
     readonly medianCycleMinutes: number;
@@ -20,9 +30,26 @@ export interface PartCycleData {
     readonly isOutlier: boolean;
 }
 export type StationCyclesByCntr = HashMap<number, PartCycleData>;
+export declare function isLaborCycle(cycle: Readonly<PartCycleData>): boolean;
+export declare function isMachineCycle(cycle: Readonly<PartCycleData>): boolean;
+export declare function isPalletLoadCycle(cycle: Readonly<PartCycleData>): boolean;
+export declare function isBasketLoadCycle(cycle: Readonly<PartCycleData>): boolean;
+export declare function palletForCycle(cycle: Readonly<PartCycleData>): number | undefined;
+export declare function basketForCycle(cycle: Readonly<PartCycleData>): number | undefined;
 export declare function stat_name_and_num(stationGroup: string, stationNumber: number): string;
+export declare function loadStationDisplayName(stationNumber: number, loadStationNames: {
+    [key: string]: string;
+} | undefined): string;
+export declare function displayStationName(stationGroup: string, stationNumber: number, loadStationNames: {
+    [key: string]: string;
+} | undefined): 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;
 export declare const last30StationCycles: Atom<StationCyclesByCntr>;
+export declare const last30HasBasketCycles: Atom<boolean>;
 export declare const specificMonthStationCycles: Atom<StationCyclesByCntr>;
+export declare const specificMonthHasBasketCycles: Atom<boolean>;
 export declare const setLast30StationCycles: import("jotai").WritableAtom<null, [log: readonly Readonly<ILogEntry>[]], void> & {
     init: null;
 };