@seedtactics/insight-client 16.4.0

package/dist/cell-status/rebookings.js

@@ -0,0 +1,139 @@
+/* Copyright (c) 2024, 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 { 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 { 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);
+}));
+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;
+    }
+});
+const canceledRebookingsRW = atom(OrderedMap.empty());
+export const canceledRebookings = canceledRebookingsRW;
+const scheduledRW = atom(OrderedMap.empty());
+export const last30ScheduledBookings = scheduledRW;
+function convertLogToRebooking(log) {
+    let qty = 1;
+    if (log.details?.["Quantity"]) {
+        qty = parseInt(log.details["Quantity"], 10);
+    }
+    return {
+        bookingId: log.result,
+        partName: log.program,
+        quantity: qty,
+        timeUTC: log.endUTC,
+        priority: log.locnum,
+        notes: log.details?.["Notes"],
+        workorder: log.details?.["Workorder"] ?? log.material?.[0]?.workorder,
+    };
+}
+export const setLast30Rebookings = atom(null, (get, set, log) => {
+    set(rebookingEvts, (old) => old.union(LazySeq.of(log)
+        .filter((e) => e.type === LogType.Rebooking)
+        .toOrderedMap((e) => [e.result, convertLogToRebooking(e)])));
+    set(canceledRebookingsRW, (old) => old.union(LazySeq.of(log)
+        .filter((e) => e.type === LogType.CancelRebooking)
+        .toOrderedMap((e) => [e.result, e.endUTC])));
+});
+function updateJobs(set, jobs, expire) {
+    set(scheduledRW, (old) => {
+        if (expire) {
+            old = old.filter((b) => b.scheduledTime >= expire);
+        }
+        return old.union(jobs
+            .flatMap((j) => (j.bookings ?? []).map((b) => [
+            b,
+            {
+                scheduledTime: j.routeStartUTC,
+                jobUnique: j.unique,
+            },
+        ]))
+            .toOrderedMap((x) => x));
+    });
+}
+export const setLast30RebookingJobs = atom(null, (_, set, historic) => {
+    updateJobs(set, LazySeq.ofObject(historic.jobs).map(([_, j]) => j));
+});
+export const updateLast30Rebookings = atom(null, (get, set, { evt, now, expire }) => {
+    if (evt.newJobs) {
+        updateJobs(set, LazySeq.of(evt.newJobs.jobs), expire ? addDays(now, -30) : undefined);
+    }
+    else if (evt.logEntry) {
+        const e = evt.logEntry;
+        if (e.type === LogType.Rebooking) {
+            set(rebookingEvts, (old) => old.set(e.result, convertLogToRebooking(e)));
+        }
+        else if (e.type === LogType.CancelRebooking) {
+            set(canceledRebookingsRW, (old) => old.set(e.result, e.endUTC));
+        }
+    }
+});
+export function useCancelRebooking() {
+    const [loading, setLoading] = useState(false);
+    const callback = useCallback((bookingId) => {
+        setLoading(true);
+        return LogBackend.cancelRebooking(bookingId)
+            .then(() => { })
+            .catch(console.log)
+            .finally(() => setLoading(false));
+    }, []);
+    return [callback, loading];
+}
+export function useNewRebooking() {
+    const [loading, setLoading] = useState(false);
+    const callback = useCallback((n) => {
+        setLoading(true);
+        return LogBackend.requestRebooking(n.part, n.qty && !isNaN(n.qty) ? n.qty : 1, n.workorder, n.priority !== undefined && n.priority !== null && !isNaN(n.priority) ? n.priority : undefined, n.notes)
+            .then(() => { })
+            .catch(console.log)
+            .finally(() => setLoading(false));
+    }, []);
+    return [callback, loading];
+}

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

@@ -0,0 +1,18 @@
+import type { ServerEventAndTime } from "./loading.js";
+import { IHistoricData, IHistoricJob, IRecentHistoricData } from "../network/api.js";
+import { HashMap, HashSet } from "@seedtactics/immutable-collections";
+import { Atom } from "jotai";
+export declare const last30Jobs: Atom<HashMap<string, Readonly<IHistoricJob>>>;
+export declare const last30SchIds: Atom<HashSet<string>>;
+export declare const specificMonthJobs: Atom<HashMap<string, Readonly<IHistoricJob>>>;
+export declare function filterExistingJobs(schIds: HashSet<string>, history: Readonly<IRecentHistoricData>): Readonly<IRecentHistoricData>;
+export declare const setLast30Jobs: import("jotai").WritableAtom<null, [history: Readonly<IHistoricData>], void> & {
+    init: null;
+};
+export declare const updateLast30Jobs: import("jotai").WritableAtom<null, [ServerEventAndTime], void> & {
+    init: null;
+};
+export declare const updateSpecificMonthJobs: import("jotai").WritableAtom<null, [history: Readonly<IHistoricData>], void> & {
+    init: null;
+};
+export declare const last30JobComment: import("jotai-family").AtomFamily<string, import("jotai").WritableAtom<string | null, [newVal: string | null], void>>;

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

@@ -0,0 +1,94 @@
+/* Copyright (c) 2021, 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 { HashMap, HashSet, LazySeq } from "@seedtactics/immutable-collections";
+import { atom } from "jotai";
+import { atomFamily } from "jotai-family";
+const last30JobsRW = atom(HashMap.empty());
+export const last30Jobs = last30JobsRW;
+const last30SchIdsRW = atom(HashSet.empty());
+export const last30SchIds = last30SchIdsRW;
+const specificMonthJobsRW = atom(HashMap.empty());
+export const specificMonthJobs = specificMonthJobsRW;
+export function filterExistingJobs(schIds, history) {
+    if (schIds.size === 0)
+        return history;
+    const newHistory = {
+        ...history,
+        jobs: { ...history.jobs },
+        stationUse: history.stationUse.filter((s) => !schIds.has(s.scheduleId)),
+    };
+    for (const [u, j] of Object.entries(history.jobs)) {
+        if (j.scheduleId && schIds.has(j.scheduleId)) {
+            delete newHistory.jobs[u];
+        }
+    }
+    return newHistory;
+}
+export const setLast30Jobs = atom(null, (_, set, history) => {
+    set(last30JobsRW, (oldJobs) => oldJobs.union(LazySeq.ofObject(history.jobs).toHashMap((x) => x)));
+    set(last30SchIdsRW, (oldIds) => oldIds.union(LazySeq.ofObject(history.jobs)
+        .collect(([, x]) => x.scheduleId)
+        .toHashSet((s) => s)));
+});
+export const updateLast30Jobs = atom(null, (_, set, { evt, now, expire }) => {
+    if (evt.newJobs) {
+        const schId = evt.newJobs.scheduleId;
+        const newJobs = LazySeq.of(evt.newJobs.jobs);
+        set(last30JobsRW, (oldJobs) => {
+            if (expire) {
+                const expire = addDays(now, -30);
+                oldJobs = oldJobs.filter((j) => j.routeStartUTC >= expire);
+            }
+            return oldJobs.union(newJobs.toHashMap((j) => [j.unique, { ...j, copiedToSystem: true }]));
+        });
+        if (schId) {
+            set(last30SchIdsRW, (oldIds) => oldIds.add(schId));
+        }
+    }
+});
+export const updateSpecificMonthJobs = atom(null, (_, set, history) => {
+    set(specificMonthJobsRW, LazySeq.ofObject(history.jobs).toHashMap((x) => x));
+});
+export const last30JobComment = atomFamily((uniq) => atom((get) => get(last30Jobs).get(uniq)?.comment ?? null, (_, set, newVal) => {
+    const newComment = newVal === null ? "" : newVal;
+    set(last30JobsRW, (oldJobs) => {
+        const old = oldJobs.get(uniq);
+        if (old !== undefined) {
+            return oldJobs.set(uniq, { ...old, comment: newComment ?? undefined });
+        }
+        else {
+            return oldJobs;
+        }
+    });
+}));

package/dist/cell-status/sim-day-usage.d.ts

@@ -0,0 +1,14 @@
+import { Atom } from "jotai";
+import { IRecentHistoricData, ISimulatedDayUsage } from "../network/api";
+import { ServerEventAndTime } from "./loading";
+export type LatestSimDayUsage = {
+    readonly simId: string;
+    readonly usage: ReadonlyArray<Readonly<ISimulatedDayUsage>>;
+};
+export declare const latestSimDayUsage: Atom<LatestSimDayUsage | null>;
+export declare const setLatestSimDayUsage: import("jotai").WritableAtom<null, [history: Readonly<IRecentHistoricData>], void> & {
+    init: null;
+};
+export declare const updateLatestSimDayUsage: import("jotai").WritableAtom<null, [ServerEventAndTime], void> & {
+    init: null;
+};

package/dist/cell-status/sim-day-usage.js

@@ -0,0 +1,54 @@
+/* Copyright (c) 2023, 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 { atom } from "jotai";
+const latestUsageRW = atom(null);
+export const latestSimDayUsage = latestUsageRW;
+function update(get, set, schId, usage) {
+    const old = get(latestSimDayUsage);
+    if (old === null || old.simId < schId) {
+        set(latestUsageRW, { simId: schId, usage });
+    }
+}
+export const setLatestSimDayUsage = atom(null, (get, set, history) => {
+    if (!history.mostRecentSimulationId ||
+        !history.mostRecentSimDayUsage ||
+        history.mostRecentSimDayUsage.length === 0) {
+        return;
+    }
+    update(get, set, history.mostRecentSimulationId, history.mostRecentSimDayUsage);
+});
+export const updateLatestSimDayUsage = atom(null, (get, set, { evt }) => {
+    if (evt.newJobs && evt.newJobs.simDayUsage && evt.newJobs.simDayUsage.length > 0) {
+        update(get, set, evt.newJobs.scheduleId, evt.newJobs.simDayUsage);
+    }
+});

package/dist/cell-status/sim-production.d.ts

@@ -0,0 +1,22 @@
+import type { ServerEventAndTime } from "./loading.js";
+import { IHistoricData } from "../network/api.js";
+import { Atom } from "jotai";
+export interface SimPartCompleted {
+    readonly partName: string;
+    readonly process: number;
+    readonly finalProcess: boolean;
+    readonly completeTime: Date;
+    readonly quantity: number;
+    readonly expectedMachineMins: number;
+}
+export declare const last30SimProduction: Atom<ReadonlyArray<SimPartCompleted>>;
+export declare const specificMonthSimProduction: Atom<ReadonlyArray<SimPartCompleted>>;
+export declare const setLast30JobProduction: import("jotai").WritableAtom<null, [history: Readonly<IHistoricData>], void> & {
+    init: null;
+};
+export declare const updateLast30JobProduction: import("jotai").WritableAtom<null, [ServerEventAndTime], void> & {
+    init: null;
+};
+export declare const setSpecificMonthJobProduction: import("jotai").WritableAtom<null, [history: Readonly<IHistoricData>], void> & {
+    init: null;
+};

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

@@ -0,0 +1,91 @@
+/* Copyright (c) 2021, 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 { durationToMinutes } from "../util/parseISODuration.js";
+import { LazySeq } from "@seedtactics/immutable-collections";
+import { addDays } from "date-fns";
+import { atom } from "jotai";
+const last30SimProductionRW = atom([]);
+export const last30SimProduction = last30SimProductionRW;
+const specificMonthSimProductionRW = atom([]);
+export const specificMonthSimProduction = specificMonthSimProductionRW;
+function* jobToPartCompleted(jobs) {
+    for (const j of jobs) {
+        for (let proc = 0; proc < j.procsAndPaths.length; proc++) {
+            const procInfo = j.procsAndPaths[proc];
+            for (let path = 0; path < procInfo.paths.length; path++) {
+                const pathInfo = procInfo.paths[path];
+                // machTime is per cycle, and so is pathInfo.simulatedProduction
+                // so we are correctly yielding the expected machine time for the entire cycle
+                let machTime = 0;
+                for (const stop of pathInfo.stops) {
+                    machTime += durationToMinutes(stop.expectedCycleTime);
+                }
+                let prevQty = 0;
+                for (const prod of pathInfo.simulatedProduction || []) {
+                    yield {
+                        partName: j.partName,
+                        process: proc + 1,
+                        finalProcess: proc === j.procsAndPaths.length - 1,
+                        completeTime: prod.timeUTC,
+                        quantity: prod.quantity - prevQty,
+                        expectedMachineMins: machTime,
+                    };
+                    prevQty = prod.quantity;
+                }
+            }
+        }
+    }
+}
+export const setLast30JobProduction = atom(null, (_, set, history) => {
+    set(last30SimProductionRW, (oldProd) => [...oldProd, ...jobToPartCompleted(Object.values(history.jobs))]);
+});
+export const updateLast30JobProduction = atom(null, (_, set, { evt, now, expire }) => {
+    if (evt.newJobs) {
+        const apiNewJobs = evt.newJobs.jobs;
+        set(last30SimProductionRW, (simProd) => {
+            if (expire) {
+                const expire = 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) {
+                    return simProd;
+                }
+                simProd = simProd.filter((e) => e.completeTime >= expire);
+            }
+            return [...simProd, ...jobToPartCompleted(apiNewJobs)];
+        });
+    }
+});
+export const setSpecificMonthJobProduction = atom(null, (_, set, history) => {
+    set(specificMonthSimProductionRW, Array.from(jobToPartCompleted(Object.values(history.jobs))));
+});

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

@@ -0,0 +1,25 @@
+import type { ServerEventAndTime } from "./loading.js";
+import { IHistoricData } from "../network/api.js";
+import { Atom } from "jotai";
+export interface SimStationUse {
+    readonly station: string;
+    readonly start: Date;
+    readonly end: Date;
+    readonly plannedDown: boolean;
+    readonly parts?: ReadonlyArray<{
+        readonly uniq: string;
+        readonly proc: number;
+        readonly path: number;
+    }>;
+}
+export declare const last30SimStationUse: Atom<ReadonlyArray<SimStationUse>>;
+export declare const specificMonthSimStationUse: Atom<ReadonlyArray<SimStationUse>>;
+export declare const setLast30SimStatUse: import("jotai").WritableAtom<null, [history: Readonly<IHistoricData>], void> & {
+    init: null;
+};
+export declare const updateLast30SimStatUse: import("jotai").WritableAtom<null, [ServerEventAndTime], void> & {
+    init: null;
+};
+export declare const setSpecificMonthSimStatUse: import("jotai").WritableAtom<null, [history: Readonly<IHistoricData>], void> & {
+    init: null;
+};

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

@@ -0,0 +1,71 @@
+/* Copyright (c) 2021, 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 { LazySeq } from "@seedtactics/immutable-collections";
+import { addDays } from "date-fns";
+import { atom } from "jotai";
+const last30SimStationUseRW = atom([]);
+export const last30SimStationUse = last30SimStationUseRW;
+const specificMonthSimStationUseRW = atom([]);
+export const specificMonthSimStationUse = specificMonthSimStationUseRW;
+function procSimUse(apiSimUse) {
+    return apiSimUse.map((simUse) => ({
+        station: simUse.stationGroup + " #" + simUse.stationNum.toString(),
+        start: simUse.startUTC,
+        end: simUse.endUTC,
+        plannedDown: simUse.planDown ?? false,
+        part: 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 updateLast30SimStatUse = atom(null, (_, set, { evt, now, expire }) => {
+    if (evt.newJobs?.stationUse) {
+        const apiSimUse = evt.newJobs?.stationUse;
+        set(last30SimStationUseRW, (simUse) => {
+            if (expire) {
+                const expireT = addDays(now, -30);
+                // check if nothing to expire and no new data
+                const minStat = LazySeq.of(simUse).minBy((e) => e.end.getTime());
+                if ((minStat === undefined || minStat.start >= expireT) && apiSimUse.length === 0) {
+                    return simUse;
+                }
+                simUse = simUse.filter((e) => e.start >= expireT);
+            }
+            return simUse.concat(procSimUse(apiSimUse));
+        });
+    }
+});
+export const setSpecificMonthSimStatUse = atom(null, (_, set, history) => {
+    set(specificMonthSimStationUseRW, procSimUse(history.stationUse));
+});

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

@@ -0,0 +1,34 @@
+import { ILogEntry, ILogMaterial } from "../network/api.js";
+import type { ServerEventAndTime } from "./loading.js";
+import { HashMap } from "@seedtactics/immutable-collections";
+import { Atom } from "jotai";
+export interface PartCycleData {
+    readonly endTime: Date;
+    readonly elapsedMinsPerMaterial: number;
+    readonly cntr: number;
+    readonly part: string;
+    readonly stationGroup: string;
+    readonly stationNumber: number;
+    readonly operation: string;
+    readonly pallet: number;
+    readonly activeMinutes: number;
+    readonly isLabor: boolean;
+    readonly material: ReadonlyArray<Readonly<ILogMaterial>>;
+    readonly operator: string;
+    readonly medianCycleMinutes: number;
+    readonly MAD_aboveMinutes: number;
+    readonly isOutlier: boolean;
+}
+export type StationCyclesByCntr = HashMap<number, PartCycleData>;
+export declare function stat_name_and_num(stationGroup: string, stationNumber: number): string;
+export declare const last30StationCycles: Atom<StationCyclesByCntr>;
+export declare const specificMonthStationCycles: Atom<StationCyclesByCntr>;
+export declare const setLast30StationCycles: import("jotai").WritableAtom<null, [log: readonly Readonly<ILogEntry>[]], void> & {
+    init: null;
+};
+export declare const updateLast30StationCycles: import("jotai").WritableAtom<null, [ServerEventAndTime], void> & {
+    init: null;
+};
+export declare const setSpecificMonthStationCycles: import("jotai").WritableAtom<null, [log: readonly Readonly<ILogEntry>[]], void> & {
+    init: null;
+};