@seedtactics/insight-client 16.4.0

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

@@ -0,0 +1,257 @@
+/* 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 { differenceInSeconds } from "date-fns";
+import { LogType } from "../network/api.js";
+import { LazySeq, HashMap, hashValues } from "@seedtactics/immutable-collections";
+import { durationToMinutes } from "../util/parseISODuration.js";
+import { atom } from "jotai";
+export class PartAndStationOperation {
+    constructor(part, statGroup, operation) {
+        this.part = part;
+        this.statGroup = statGroup;
+        this.operation = operation;
+    }
+    static ofLogCycle(c) {
+        return new PartAndStationOperation(c.material[0].part, c.loc, c.type === LogType.LoadUnloadCycle && 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);
+    }
+    compare(other) {
+        let cmp = this.part.localeCompare(other.part);
+        if (cmp !== 0)
+            return cmp;
+        cmp = this.statGroup.localeCompare(other.statGroup);
+        if (cmp !== 0)
+            return cmp;
+        return this.operation.localeCompare(other.operation);
+    }
+    hash() {
+        return hashValues(this.part, this.statGroup, this.operation);
+    }
+    toString() {
+        return `{part: ${this.part}}, statGroup: ${this.statGroup}, operation: ${this.operation}}`;
+    }
+}
+const last30EstimatedTimesRW = atom(HashMap.empty());
+export const last30EstimatedCycleTimes = last30EstimatedTimesRW;
+const specificMonthEstimatedTimesRW = atom(HashMap.empty());
+export const specificMonthEstimatedCycleTimes = specificMonthEstimatedTimesRW;
+// Assume: samples come from two distributions:
+//  - the program runs without interruption, giving a guassian iid around the cycle time.
+//  - the program is interrupted or stopped, which adds a random amount to the program
+//    and results in an outlier.
+//  - the program doesn't run at all, which results in a random short cycle time.
+// We use median absolute deviation to detect outliers, remove the outliers,
+// then compute average to find cycle time.
+export function isOutlier(s, mins) {
+    if (s.medianMinutesForSingleMat === 0) {
+        return false;
+    }
+    if (mins < s.medianMinutesForSingleMat) {
+        return (s.medianMinutesForSingleMat - mins) / s.MAD_belowMinutes > 2;
+    }
+    else {
+        return (mins - s.medianMinutesForSingleMat) / s.MAD_aboveMinutes > 2;
+    }
+}
+export function isOutlierAbove(s, mins) {
+    if (s.medianMinutesForSingleMat === 0) {
+        return false;
+    }
+    if (mins < s.medianMinutesForSingleMat) {
+        return false;
+    }
+    else {
+        return (mins - s.medianMinutesForSingleMat) / s.MAD_aboveMinutes > 2;
+    }
+}
+function median(vals) {
+    const sorted = vals.toMutableArray().sort((a, b) => a - b);
+    const cnt = sorted.length;
+    if (cnt === 0) {
+        return 0;
+    }
+    const half = Math.floor(sorted.length / 2);
+    if (sorted.length % 2 === 0) {
+        // average two middle
+        return (sorted[half - 1] + sorted[half]) / 2;
+    }
+    else {
+        // return middle
+        return sorted[half];
+    }
+}
+function estimateCycleTimes(cycles) {
+    // compute median
+    const medianMinutes = median(LazySeq.of(cycles));
+    // absolute deviation from median, but use different values for below and above
+    // median.  Below is assumed to be from fake cycles and above is from interrupted programs.
+    // since we assume gaussian, use consistantcy constant of 1.4826
+    let madBelowMinutes = 1.4826 *
+        median(LazySeq.of(cycles)
+            .filter((x) => x <= medianMinutes)
+            .map((x) => medianMinutes - x));
+    // clamp at 15 seconds
+    if (madBelowMinutes < 0.25) {
+        madBelowMinutes = 0.25;
+    }
+    let madAboveMinutes = 1.4826 *
+        median(LazySeq.of(cycles)
+            .filter((x) => x >= medianMinutes)
+            .map((x) => x - medianMinutes));
+    // clamp at 15 seconds
+    if (madAboveMinutes < 0.25) {
+        madAboveMinutes = 0.25;
+    }
+    const statCycleTime = {
+        medianMinutesForSingleMat: medianMinutes,
+        MAD_belowMinutes: madBelowMinutes,
+        MAD_aboveMinutes: madAboveMinutes,
+        expectedCycleMinutesForSingleMat: 0,
+    };
+    // filter to only inliers
+    const inliers = LazySeq.of(cycles)
+        .filter((x) => !isOutlier(statCycleTime, x))
+        .toRArray();
+    // compute average of inliers
+    const expectedCycleMinutesForSingleMat = inliers.reduce((sum, x) => sum + x, 0) / inliers.length;
+    return { ...statCycleTime, expectedCycleMinutesForSingleMat };
+}
+export function chunkCyclesWithSimilarEndTime(allCycles, getKey, getTime) {
+    return allCycles
+        .toLookupOrderedMap(getKey, getTime, (c) => [c], (cs, ds) => cs.concat(ds))
+        .toAscLazySeq()
+        .map(([k, cycles]) => {
+        const ret = [];
+        let chunk = [];
+        for (const c of cycles.valuesToAscLazySeq().flatMap((cs) => cs)) {
+            if (chunk.length === 0) {
+                chunk = [c];
+            }
+            else if (differenceInSeconds(getTime(c), getTime(chunk[chunk.length - 1])) < 10) {
+                chunk.push(c);
+            }
+            else {
+                ret.push(chunk);
+                chunk = [c];
+            }
+        }
+        if (chunk.length > 0) {
+            ret.push(chunk);
+        }
+        return [k, ret];
+    });
+}
+export function splitElapsedTimeAmongChunk(chunk, getElapsedMins, getActiveMins) {
+    let totalActiveMins = 0;
+    let totalMatCount = 0;
+    let allEventsHaveActive = true;
+    for (const cycle of chunk) {
+        if (getActiveMins(cycle) < 0) {
+            allEventsHaveActive = false;
+        }
+        totalMatCount += cycle.material.length;
+        totalActiveMins += getActiveMins(cycle);
+    }
+    if (allEventsHaveActive && totalActiveMins > 0) {
+        //split by active.  First multiply by (active/totalActive) ratio to get fraction of elapsed
+        //for this cycle, then by material count to get per-material
+        return chunk.map((cycle) => ({
+            cycle,
+            elapsedForSingleMaterialMinutes: (getElapsedMins(cycle) * getActiveMins(cycle)) / totalActiveMins / cycle.material.length,
+        }));
+    }
+    // split equally among all material
+    if (totalMatCount > 0) {
+        return chunk.map((cycle) => ({
+            cycle,
+            elapsedForSingleMaterialMinutes: getElapsedMins(cycle) / totalMatCount,
+        }));
+    }
+    // only when no events have material, which should never happen
+    return chunk.map((cycle) => ({
+        cycle,
+        elapsedForSingleMaterialMinutes: getElapsedMins(cycle),
+    }));
+}
+// In older versions of FMS Insight, load cycles had a shared elapsed time among all events
+// for the cycle and each event had the total elapsed time for the whole combination of operations.
+// An update to the server changed this so that the server splits the elapsed time among the events.
+// But, for backwards compatibility, detect if we need to split the elpased time in the client too.
+// To detect new vs old, the new version also started adding the material IDs to pallet begin and end events,
+// so if the material appears in a begin/end event that means it does not need to be split.
+export function calcElapsedForCycles(eventLog) {
+    const matsInPalEvts = new Set();
+    for (const e of eventLog) {
+        if (e.type === LogType.PalletCycle && e.material.length > 0) {
+            for (const m of e.material) {
+                matsInPalEvts.add(m.id);
+            }
+        }
+    }
+    return chunkCyclesWithSimilarEndTime(LazySeq.of(eventLog).filter((e) => (e.type === LogType.LoadUnloadCycle || e.type === LogType.MachineCycle) &&
+        !e.startofcycle &&
+        e.loc !== "" &&
+        e.material.length > 0), (c) => c.loc + " #" + c.locnum.toString(), (c) => c.endUTC)
+        .flatMap(([_lul, chunks]) => chunks)
+        .flatMap((chunk) => {
+        // Check if need to split the elapsed
+        const chunk0Elapsed = durationToMinutes(chunk[0].elapsed);
+        const shouldSplit = chunk.length >= 2 &&
+            chunk.every((c) => durationToMinutes(c.elapsed) === chunk0Elapsed &&
+                c.material.every((m) => !matsInPalEvts.has(m.id)));
+        if (shouldSplit) {
+            return splitElapsedTimeAmongChunk(chunk, (c) => durationToMinutes(c.elapsed), (c) => (c.active === "" ? -1 : durationToMinutes(c.active)));
+        }
+        else {
+            return chunk.map((c) => ({
+                cycle: c,
+                elapsedForSingleMaterialMinutes: c.material.length > 0 ? durationToMinutes(c.elapsed) / c.material.length : 0,
+            }));
+        }
+    });
+}
+function estimateCycleTimesOfParts(cycles) {
+    return calcElapsedForCycles(cycles)
+        .toLookup((c) => PartAndStationOperation.ofLogCycle(c.cycle), (c) => c.elapsedForSingleMaterialMinutes)
+        .mapValues(estimateCycleTimes);
+}
+export const setLast30EstimatedCycleTimes = atom(null, (_, set, log) => {
+    set(last30EstimatedTimesRW, (old) => (old.size === 0 ? estimateCycleTimesOfParts(log) : old));
+});
+export const setSpecificMonthEstimatedCycleTimes = atom(null, (_, set, log) => {
+    set(specificMonthEstimatedTimesRW, estimateCycleTimesOfParts(log));
+});

package/dist/cell-status/inspections.d.ts

@@ -0,0 +1,55 @@
+import { ILogEntry, IMaterialProcessActualPath } from "../network/api.js";
+import { HashMap } from "@seedtactics/immutable-collections";
+import type { ServerEventAndTime } from "./loading.js";
+import { Atom } from "jotai";
+export declare enum InspectionLogResultType {
+    Triggered = 0,
+    Forced = 1,
+    Completed = 2
+}
+export type InspectionLogResult = {
+    readonly type: InspectionLogResultType.Triggered;
+    readonly actualPath: ReadonlyArray<Readonly<IMaterialProcessActualPath>>;
+    readonly toInspect: boolean;
+} | {
+    readonly type: InspectionLogResultType.Forced;
+    readonly toInspect: boolean;
+} | {
+    readonly type: InspectionLogResultType.Completed;
+    readonly success: boolean;
+};
+export interface InspectionLogEntry {
+    readonly cntr: number;
+    readonly time: Date;
+    readonly materialID: number;
+    readonly serial?: string;
+    readonly workorder?: string;
+    readonly result: InspectionLogResult;
+    readonly part: string;
+    readonly inspType: string;
+}
+export type InspectionLogsByCntr = HashMap<number, InspectionLogEntry>;
+export declare class PartAndInspType {
+    readonly part: string;
+    readonly inspType: string;
+    constructor(part: string, inspType: string);
+    compare(other: PartAndInspType): number;
+    hash(): number;
+    toString(): string;
+}
+export type InspectionsByPartAndType = HashMap<PartAndInspType, InspectionLogsByCntr>;
+export declare const last30Inspections: Atom<InspectionsByPartAndType>;
+export declare const specificMonthInspections: Atom<InspectionsByPartAndType>;
+export declare function convertLogToInspections(c: Readonly<ILogEntry>): ReadonlyArray<{
+    key: PartAndInspType;
+    entry: InspectionLogEntry;
+}>;
+export declare const setLast30Inspections: import("jotai").WritableAtom<null, [log: readonly Readonly<ILogEntry>[]], void> & {
+    init: null;
+};
+export declare const updateLast30Inspections: import("jotai").WritableAtom<null, [ServerEventAndTime], void> & {
+    init: null;
+};
+export declare const setSpecificMonthInspections: import("jotai").WritableAtom<null, [log: readonly Readonly<ILogEntry>[]], void> & {
+    init: null;
+};

package/dist/cell-status/inspections.js

@@ -0,0 +1,213 @@
+/* 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 { hashValues } from "@seedtactics/immutable-collections";
+import { addDays } from "date-fns";
+import { LogType, MaterialProcessActualPath } from "../network/api.js";
+import { LazySeq, HashMap } from "@seedtactics/immutable-collections";
+import { atom } from "jotai";
+export var InspectionLogResultType;
+(function (InspectionLogResultType) {
+    InspectionLogResultType[InspectionLogResultType["Triggered"] = 0] = "Triggered";
+    InspectionLogResultType[InspectionLogResultType["Forced"] = 1] = "Forced";
+    InspectionLogResultType[InspectionLogResultType["Completed"] = 2] = "Completed";
+})(InspectionLogResultType || (InspectionLogResultType = {}));
+export class PartAndInspType {
+    constructor(part, inspType) {
+        this.part = part;
+        this.inspType = inspType;
+    }
+    compare(other) {
+        const cmp = this.part.localeCompare(other.part);
+        if (cmp !== 0) {
+            return cmp;
+        }
+        else {
+            return this.inspType.localeCompare(other.inspType);
+        }
+    }
+    hash() {
+        return hashValues(this.part, this.inspType);
+    }
+    toString() {
+        return `{part: ${this.part}}, inspType: ${this.inspType}}`;
+    }
+}
+const last30InspectionsRW = atom(HashMap.empty());
+export const last30Inspections = last30InspectionsRW;
+const specificMonthInspectionsRW = atom(HashMap.empty());
+export const specificMonthInspections = specificMonthInspectionsRW;
+export function convertLogToInspections(c) {
+    if (c.type !== LogType.Inspection &&
+        c.type !== LogType.InspectionForce &&
+        c.type !== LogType.InspectionResult) {
+        return [];
+    }
+    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 paths = [];
+            for (const pathJson of pathsJson) {
+                paths.push(MaterialProcessActualPath.fromJS(pathJson));
+            }
+            const inspType = (c.details || {}).InspectionType || "";
+            let toInspect;
+            if (c.result.toLowerCase() === "true" || c.result === "1") {
+                toInspect = true;
+            }
+            else {
+                toInspect = false;
+            }
+            const r = {
+                key: new PartAndInspType(m.part, inspType),
+                entry: {
+                    cntr: c.counter,
+                    time: c.endUTC,
+                    materialID: m.id,
+                    serial: m.serial,
+                    workorder: m.workorder,
+                    result: {
+                        type: InspectionLogResultType.Triggered,
+                        actualPath: paths,
+                        toInspect,
+                    },
+                    part: m.part,
+                    inspType: inspType,
+                },
+            };
+            return r;
+        }
+        else if (c.type === LogType.InspectionForce) {
+            let forceInspect;
+            if (c.result.toLowerCase() === "true" || c.result === "1") {
+                forceInspect = true;
+            }
+            else {
+                forceInspect = false;
+            }
+            const r = {
+                key: new PartAndInspType(m.part, c.program),
+                entry: {
+                    cntr: c.counter,
+                    time: c.endUTC,
+                    materialID: m.id,
+                    serial: m.serial,
+                    workorder: m.workorder,
+                    result: {
+                        type: InspectionLogResultType.Forced,
+                        toInspect: forceInspect,
+                    },
+                    part: m.part,
+                    inspType: c.program,
+                },
+            };
+            return r;
+        }
+        else {
+            // api.LogType.InspectionResult
+            let success;
+            if (c.result.toLowerCase() === "true" || c.result === "1") {
+                success = true;
+            }
+            else {
+                success = false;
+            }
+            const r = {
+                key: new PartAndInspType(m.part, c.program),
+                entry: {
+                    cntr: c.counter,
+                    time: c.endUTC,
+                    materialID: m.id,
+                    serial: m.serial,
+                    workorder: m.workorder,
+                    result: { type: InspectionLogResultType.Completed, success },
+                    part: m.part,
+                    inspType: c.program,
+                },
+            };
+            return r;
+        }
+    });
+}
+export const setLast30Inspections = atom(null, (_, set, log) => {
+    set(last30InspectionsRW, (oldEntries) => oldEntries.union(LazySeq.of(log)
+        .flatMap(convertLogToInspections)
+        .toLookupMap((e) => e.key, (e) => e.entry.cntr, (e) => e.entry), (e1, e2) => e1.union(e2)));
+});
+export const updateLast30Inspections = atom(null, (_, set, { evt, now, expire }) => {
+    if (evt.logEntry) {
+        const log = convertLogToInspections(evt.logEntry);
+        if (log.length === 0)
+            return;
+        set(last30InspectionsRW, (parts) => {
+            if (expire) {
+                const expireD = addDays(now, -30);
+                parts = parts.collectValues((entries) => {
+                    const newEntries = entries.filter((e) => e.time >= expireD);
+                    if (newEntries.size === 0) {
+                        return null;
+                    }
+                    else {
+                        return newEntries;
+                    }
+                });
+            }
+            return parts.union(LazySeq.of(log).toLookupMap((e) => e.key, (e) => e.entry.cntr, (e) => e.entry), (e1, e2) => e1.union(e2));
+        });
+    }
+    else if (evt.editMaterialInLog) {
+        const changedByCntr = evt.editMaterialInLog.editedEvents;
+        set(last30InspectionsRW, (parts) => parts.collectValues((entries) => {
+            for (const changed of changedByCntr) {
+                // inspection logs have only a single material
+                const mat = changed?.material[0];
+                const old = entries.get(changed.counter);
+                if (old !== undefined && mat) {
+                    const newEntry = {
+                        ...old,
+                        materialID: mat.id,
+                        serial: mat.serial,
+                        workorder: mat.workorder,
+                    };
+                    entries = entries.set(changed.counter, newEntry);
+                }
+            }
+            return entries;
+        }));
+    }
+});
+export const setSpecificMonthInspections = atom(null, (_, set, log) => {
+    set(specificMonthInspectionsRW, LazySeq.of(log)
+        .flatMap(convertLogToInspections)
+        .toLookupMap((e) => e.key, (e) => e.entry.cntr, (e) => e.entry));
+});

package/dist/cell-status/loading.d.ts

@@ -0,0 +1,26 @@
+import { ICurrentStatus, IHistoricData, ILogEntry, IRecentHistoricData, IServerEvent } from "../network/api.js";
+import { Atom } from "jotai";
+export interface ServerEventAndTime {
+    readonly evt: Readonly<IServerEvent>;
+    readonly now: Date;
+    readonly expire: boolean;
+}
+export declare const lastEventCounter: Atom<number | null>;
+export declare const onServerEvent: import("jotai").WritableAtom<null, [evt: ServerEventAndTime], void> & {
+    init: null;
+};
+export declare const onLoadLast30Jobs: import("jotai").WritableAtom<null, [historicData: Readonly<IRecentHistoricData>], void> & {
+    init: null;
+};
+export declare const onLoadLast30Log: import("jotai").WritableAtom<null, [log: readonly Readonly<ILogEntry>[]], void> & {
+    init: null;
+};
+export declare const onLoadCurrentSt: import("jotai").WritableAtom<null, [curSt: Readonly<ICurrentStatus>], void> & {
+    init: null;
+};
+export declare const onLoadSpecificMonthJobs: import("jotai").WritableAtom<null, [historicData: Readonly<IHistoricData>], void> & {
+    init: null;
+};
+export declare const onLoadSpecificMonthLog: import("jotai").WritableAtom<null, [log: readonly Readonly<ILogEntry>[]], void> & {
+    init: null;
+};

package/dist/cell-status/loading.js

@@ -0,0 +1,112 @@
+/* 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 * as simProd from "./sim-production.js";
+import * as simUse from "./sim-station-use.js";
+import * as schJobs from "./scheduled-jobs.js";
+import * as buffers from "./buffers.js";
+import * as currentSt from "./current-status.js";
+import * as insp from "./inspections.js";
+import * as mats from "./material-summary.js";
+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 statCycles from "./station-cycles.js";
+import * as toolReplace from "./tool-replacements.js";
+import * as simDayUsage from "./sim-day-usage.js";
+import * as rebookings from "./rebookings.js";
+import { atom } from "jotai";
+const lastEventCounterRW = atom(null);
+export const lastEventCounter = lastEventCounterRW;
+export const onServerEvent = atom(null, (_, set, evt) => {
+    set(simProd.updateLast30JobProduction, evt);
+    set(simUse.updateLast30SimStatUse, evt);
+    set(schJobs.updateLast30Jobs, evt);
+    set(buffers.updateLast30Buffer, evt);
+    set(currentSt.updateCurrentStatus, evt);
+    set(mats.updateLast30MatSummary, evt);
+    set(insp.updateLast30Inspections, evt);
+    set(names.updateNames, evt);
+    set(tool.updateLast30ToolUse, evt);
+    set(palCycles.updateLast30PalletCycles, evt);
+    set(toolReplace.updateLastToolReplacements, evt);
+    set(statCycles.updateLast30StationCycles, evt);
+    set(rebookings.updateLast30Rebookings, evt);
+    set(simDayUsage.updateLatestSimDayUsage, evt);
+    if (evt.evt.logEntry) {
+        const newCntr = evt.evt.logEntry.counter;
+        set(lastEventCounterRW, (old) => (old === null ? old : Math.max(old, newCntr)));
+    }
+});
+export const onLoadLast30Jobs = atom(null, (get, set, historicData) => {
+    const filtered = schJobs.filterExistingJobs(get(schJobs.last30SchIds), historicData);
+    set(simUse.setLast30SimStatUse, filtered);
+    set(simProd.setLast30JobProduction, filtered);
+    set(schJobs.setLast30Jobs, filtered);
+    set(names.setNamesFromLast30Jobs, filtered);
+    set(simDayUsage.setLatestSimDayUsage, filtered);
+    set(rebookings.setLast30RebookingJobs, filtered);
+});
+export const onLoadLast30Log = atom(null, (_, set, log) => {
+    set(estimated.setLast30EstimatedCycleTimes, log);
+    set(buffers.setLast30Buffer, log);
+    set(insp.setLast30Inspections, log);
+    set(mats.setLast30MatSummary, log);
+    set(names.setNamesFromLast30Evts, log);
+    set(tool.setLast30ToolUse, log);
+    set(palCycles.setLast30PalletCycles, log);
+    set(toolReplace.setLast30ToolReplacements, log);
+    set(statCycles.setLast30StationCycles, log);
+    set(rebookings.setLast30Rebookings, log);
+    const newCntr = LazySeq.of(log).maxBy((x) => x.counter)?.counter ?? null;
+    set(lastEventCounterRW, (oldCntr) => (oldCntr === null ? newCntr : Math.max(oldCntr, newCntr ?? -1)));
+});
+export const onLoadCurrentSt = atom(null, (_, set, curSt) => {
+    set(currentSt.setCurrentStatus, curSt);
+    set(names.setNamesFromCurrentStatus, curSt);
+});
+export const onLoadSpecificMonthJobs = atom(null, (_, set, historicData) => {
+    set(simUse.setSpecificMonthSimStatUse, historicData);
+    set(simProd.setSpecificMonthJobProduction, historicData);
+    set(schJobs.updateSpecificMonthJobs, historicData);
+});
+export const onLoadSpecificMonthLog = atom(null, (_, set, log) => {
+    set(estimated.setSpecificMonthEstimatedCycleTimes, log);
+    set(buffers.setSpecificMonthBuffer, log);
+    set(insp.setSpecificMonthInspections, log);
+    set(mats.setSpecificMonthMatSummary, log);
+    set(palCycles.setSpecificMonthPalletCycles, log);
+    set(toolReplace.setSpecificMonthToolReplacements, log);
+    set(statCycles.setSpecificMonthStationCycles, log);
+});