@seedtactics/insight-client 16.4.0

package/README.md

@@ -0,0 +1,37 @@
+# FMS Insight Client
+
+This is the client half of [FMS
+Insight](https://github.com/SeedTactics/fms-insight). FMS Insight is a program
+for a flexible machining system (FMS) cell controller which tracks material,
+records a log of events, helps with inspections and serial marking, presents
+details about the cell via webpages, and more. These web pages help operators
+on the shop floor manage material, supervisors monitor the day to day
+activities, and engineers evaluate the long-term efficiency of tools and the
+cell.
+
+The server is written in C# and available on nuget in the
+[BlackMaple.MachineFramework](https://www.nuget.org/packages/BlackMaple.MachineFramework)
+package. The client in this npm package is a React SPA which communicates with
+the server with HTTP JSON requests. The client is built using vite and served
+as static files, typically by the C# server. Because of that, the nuget package
+for the server contain a built version of the client. If you are just using
+FMS Insight and don't intend any changes to the client, you can just use the
+BlackMaple.MachineFramework nuget. This npm package is needed only if you wish
+to modify the client or import portions of the client into your own pages.
+
+## Code Overview
+
+The client stores data in [jotai](https://jotai.org/) stores. We use a
+thick-client approach: each client loads a large amout of events at startup and
+then uses a websocket connection to keep the stores updated as new events occur.
+Most of the reports and pages are then generated on the client, typically using
+jotai atoms. The atoms storing the information about the cell are in the
+`src/cell-status` directory. The code in the `src/network` directory handles
+the initial data load and the websocket connection to keep the jotai stores updated.
+
+The `src/data` directory contains a large amout of the client-side business logic
+and report generating typescript code. It takes the raw event data from the cell
+status and turns it into a format suitable for display. Finally, the `src/components`
+directory contains the React components which display the various reports and pages.
+To customize, you should look at `src/components/App.tsx` for inspiration: it imports
+the various pages and handles the routing.

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

@@ -0,0 +1,36 @@
+import type { ServerEventAndTime } from "./loading.js";
+import { ILogEntry } from "../network/api.js";
+import { HashMap } from "@seedtactics/immutable-collections";
+import { Atom } from "jotai";
+export type BufferType = {
+    readonly type: "Rotary";
+    readonly machineGroup: string;
+    readonly machineNum: number;
+} | {
+    readonly type: "StockerWaitForMC";
+    readonly stockerNum: number;
+} | {
+    readonly type: "StockerWaitForUnload";
+    readonly stockerNum: number;
+} | {
+    readonly type: "Queue";
+    readonly queue: string;
+};
+export interface BufferEntry {
+    readonly buffer: BufferType;
+    readonly endTime: Date;
+    readonly elapsedSeconds: number;
+    readonly numMaterial: number;
+}
+export type BufferEntryByCntr = HashMap<number, BufferEntry>;
+export declare const last30BufferEntries: Atom<BufferEntryByCntr>;
+export declare const specificMonthBufferEntries: Atom<BufferEntryByCntr>;
+export declare const setLast30Buffer: import("jotai").WritableAtom<null, [log: readonly Readonly<ILogEntry>[]], void> & {
+    init: null;
+};
+export declare const updateLast30Buffer: import("jotai").WritableAtom<null, [ServerEventAndTime], void> & {
+    init: null;
+};
+export declare const setSpecificMonthBuffer: import("jotai").WritableAtom<null, [log: readonly Readonly<ILogEntry>[]], void> & {
+    init: null;
+};

package/dist/cell-status/buffers.js

@@ -0,0 +1,127 @@
+/* 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 { LogType } from "../network/api.js";
+import { durationToSeconds } from "../util/parseISODuration.js";
+import { LazySeq, HashMap } from "@seedtactics/immutable-collections";
+import { atom } from "jotai";
+const last30BufferEntriesRW = atom(HashMap.empty());
+export const last30BufferEntries = last30BufferEntriesRW;
+const specificMonthBufferEntriesRW = atom(HashMap.empty());
+export const specificMonthBufferEntries = specificMonthBufferEntriesRW;
+function convertEntry(e) {
+    if (e.elapsed === "")
+        return null;
+    const elapsedSeconds = durationToSeconds(e.elapsed);
+    if (elapsedSeconds <= 0)
+        return null;
+    switch (e.type) {
+        case LogType.RemoveFromQueue:
+            return [
+                e.counter,
+                {
+                    buffer: { type: "Queue", queue: e.loc },
+                    endTime: e.endUTC,
+                    elapsedSeconds,
+                    numMaterial: e.material.length,
+                },
+            ];
+        case LogType.PalletInStocker:
+            if (!e.startofcycle && e.result === "WaitForMachine") {
+                return [
+                    e.counter,
+                    {
+                        buffer: { type: "StockerWaitForMC", stockerNum: e.locnum },
+                        endTime: e.endUTC,
+                        elapsedSeconds,
+                        numMaterial: e.material.length,
+                    },
+                ];
+            }
+            else if (!e.startofcycle) {
+                return [
+                    e.counter,
+                    {
+                        buffer: { type: "StockerWaitForUnload", stockerNum: e.locnum },
+                        endTime: e.endUTC,
+                        elapsedSeconds,
+                        numMaterial: e.material.length,
+                    },
+                ];
+            }
+            else {
+                return null;
+            }
+        case LogType.PalletOnRotaryInbound:
+            if (!e.startofcycle) {
+                return [
+                    e.counter,
+                    {
+                        buffer: { type: "Rotary", machineGroup: e.loc, machineNum: e.locnum },
+                        endTime: e.endUTC,
+                        elapsedSeconds,
+                        numMaterial: e.material.length,
+                    },
+                ];
+            }
+            else {
+                return null;
+            }
+        default:
+            return null;
+    }
+}
+export const setLast30Buffer = atom(null, (_, set, log) => {
+    set(last30BufferEntriesRW, (oldEntries) => oldEntries.union(LazySeq.of(log)
+        .collect(convertEntry)
+        .toHashMap((x) => x)));
+});
+export const updateLast30Buffer = atom(null, (_, set, { evt, now, expire }) => {
+    if (!evt.logEntry)
+        return;
+    const log = convertEntry(evt.logEntry);
+    if (!log)
+        return;
+    set(last30BufferEntriesRW, (entries) => {
+        if (expire) {
+            const expireD = addDays(now, -30);
+            entries = entries.filter((e) => e.endTime >= expireD);
+        }
+        return entries.set(log[0], log[1]);
+    });
+});
+export const setSpecificMonthBuffer = atom(null, (_, set, log) => {
+    set(specificMonthBufferEntriesRW, LazySeq.of(log)
+        .collect(convertEntry)
+        .toHashMap((x) => x));
+});

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

@@ -0,0 +1,30 @@
+import { ICurrentStatus } from "../network/api.js";
+import type { ServerEventAndTime } from "./loading.js";
+import { Atom } from "jotai";
+export declare const currentStatus: Atom<ICurrentStatus>;
+export declare const secondsSinceEpochAtom: import("jotai").PrimitiveAtom<number> & {
+    init: number;
+};
+export declare const setJobComment: import("jotai").WritableAtom<null, [uniq: string, newVal: string | null], void> & {
+    init: null;
+};
+export declare const addWorkorderComment: import("jotai").WritableAtom<null, [{
+    workorder: string;
+    comment: string;
+}], void> & {
+    init: null;
+};
+export declare const setCurrentStatus: import("jotai").WritableAtom<null, [st: Readonly<ICurrentStatus>], void> & {
+    init: null;
+};
+export declare const updateCurrentStatus: import("jotai").WritableAtom<null, [ServerEventAndTime], void> & {
+    init: null;
+};
+export interface QueueReordering {
+    readonly queue: string;
+    readonly matId: number;
+    readonly newIdx: number;
+}
+export declare const reorderQueuedMatInCurrentStatus: import("jotai").WritableAtom<null, [QueueReordering], void> & {
+    init: null;
+};

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

@@ -0,0 +1,200 @@
+/* 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 { JobsBackend, LogBackend } from "../network/backend.js";
+import { InProcessMaterial, LogType, LocType, ActiveJob, WorkorderComment, ActiveWorkorder, } from "../network/api.js";
+import { last30JobComment } from "./scheduled-jobs.js";
+import { atom } from "jotai";
+import { currentOperator } from "../data/operators.js";
+const currentStatusRW = atom({
+    timeOfCurrentStatusUTC: new Date(),
+    jobs: {},
+    pallets: {},
+    material: [],
+    alarms: [],
+    queues: {},
+});
+export const currentStatus = currentStatusRW;
+export const secondsSinceEpochAtom = atom(Math.floor(Date.now() / 1000));
+secondsSinceEpochAtom.onMount = (setSelf) => {
+    const interval = setInterval(() => {
+        setSelf(Math.floor(Date.now() / 1000));
+    }, 1000);
+    return () => clearInterval(interval);
+};
+export const setJobComment = atom(null, (_, set, uniq, newVal) => {
+    const newComment = newVal === null ? "" : newVal;
+    set(currentStatusRW, (st) => {
+        const oldJob = st.jobs[uniq];
+        if (oldJob) {
+            const newJob = new ActiveJob(oldJob);
+            newJob.comment = newComment;
+            return { ...st, jobs: { ...st.jobs, [uniq]: newJob } };
+        }
+        else {
+            return st;
+        }
+    });
+    set(last30JobComment(uniq), newComment);
+    void JobsBackend.setJobComment(uniq, newComment);
+});
+export const addWorkorderComment = atom(null, (get, set, { workorder, comment }) => {
+    const operator = get(currentOperator);
+    set(currentStatusRW, (st) => {
+        if (!st.workorders)
+            return st;
+        return {
+            ...st,
+            workorders: st.workorders.map((w) => w.workorderId === workorder
+                ? new ActiveWorkorder({
+                    ...w,
+                    comments: [...(w.comments ?? []), new WorkorderComment({ comment, timeUTC: new Date() })],
+                })
+                : w),
+        };
+    });
+    void LogBackend.recordWorkorderComment(workorder, operator, comment);
+});
+export const setCurrentStatus = atom(null, (_, set, st) => set(currentStatusRW, st));
+export const updateCurrentStatus = atom(null, (_, set, { evt }) => {
+    if (evt.logEntry) {
+        set(currentStatusRW, processEventsIntoCurrentStatus(evt.logEntry));
+    }
+    else if (evt.newCurrentStatus) {
+        set(currentStatusRW, evt.newCurrentStatus);
+    }
+});
+function processEventsIntoCurrentStatus(entry) {
+    return (curSt) => {
+        const mats = new Map();
+        function adjustMat(id, f) {
+            if (mats.size === 0) {
+                for (const m of curSt.material) {
+                    mats.set(m.materialID, m);
+                }
+            }
+            const oldMat = mats.get(id);
+            if (oldMat !== undefined) {
+                mats.set(id, new InProcessMaterial(f(oldMat)));
+            }
+        }
+        switch (entry.type) {
+            case LogType.PartMark:
+                for (const m of entry.material) {
+                    adjustMat(m.id, (inmat) => ({ ...inmat, serial: entry.result }));
+                }
+                break;
+            case LogType.OrderAssignment:
+                for (const m of entry.material) {
+                    adjustMat(m.id, (inmat) => ({ ...inmat, workorderId: entry.result }));
+                }
+                break;
+            case LogType.Inspection:
+            case LogType.InspectionForce:
+                if (entry.result.toLowerCase() === "true" || entry.result === "1") {
+                    let inspType;
+                    if (entry.type === LogType.InspectionForce) {
+                        inspType = entry.program;
+                    }
+                    else {
+                        inspType = (entry.details || {}).InspectionType;
+                    }
+                    if (inspType) {
+                        for (const m of entry.material) {
+                            adjustMat(m.id, (inmat) => ({
+                                ...inmat,
+                                signaledInspections: [...inmat.signaledInspections, inspType],
+                            }));
+                        }
+                    }
+                }
+                break;
+        }
+        if (mats.size === 0) {
+            return curSt;
+        }
+        else {
+            return {
+                ...curSt,
+                material: Array.from(mats.values()),
+            };
+        }
+    };
+}
+export const reorderQueuedMatInCurrentStatus = atom(null, (_, set, { queue, matId, newIdx }) => {
+    set(currentStatusRW, (curSt) => {
+        const oldMat = curSt.material.find((i) => i.materialID === matId);
+        if (!oldMat || oldMat.location.type !== LocType.InQueue) {
+            return curSt;
+        }
+        if (oldMat.location.currentQueue === queue && oldMat.location.queuePosition === newIdx) {
+            return curSt;
+        }
+        const oldQueue = oldMat.location.currentQueue;
+        const oldIdx = oldMat.location.queuePosition;
+        if (oldIdx === undefined || oldQueue === undefined) {
+            return curSt;
+        }
+        const newMats = curSt.material.map((m) => {
+            if (m.location.type !== LocType.InQueue ||
+                m.location.queuePosition === undefined ||
+                m.location.currentQueue === undefined) {
+                return m;
+            }
+            if (m.materialID === matId) {
+                return new InProcessMaterial({
+                    ...m,
+                    location: { type: LocType.InQueue, currentQueue: queue, queuePosition: newIdx },
+                });
+            }
+            let idx = m.location.queuePosition;
+            // old queue material is moved down
+            if (m.location.currentQueue === oldQueue && m.location.queuePosition > oldIdx) {
+                idx -= 1;
+            }
+            // new queue material is moved up to make room
+            if (m.location.currentQueue === queue && idx >= newIdx) {
+                idx += 1;
+            }
+            if (idx !== m.location.queuePosition) {
+                return new InProcessMaterial({
+                    ...m,
+                    location: { ...m.location, queuePosition: idx },
+                });
+            }
+            else {
+                return m;
+            }
+        });
+        return { ...curSt, material: newMats };
+    });
+});

package/dist/cell-status/estimated-cycle-times.d.ts

@@ -0,0 +1,41 @@
+import { ILogEntry } from "../network/api.js";
+import { LazySeq, HashMap, OrderedMapKey } from "@seedtactics/immutable-collections";
+import type { PartCycleData } from "./station-cycles.js";
+import { Atom } from "jotai";
+export interface StatisticalCycleTime {
+    readonly medianMinutesForSingleMat: number;
+    readonly MAD_belowMinutes: number;
+    readonly MAD_aboveMinutes: number;
+    readonly expectedCycleMinutesForSingleMat: number;
+}
+export declare class PartAndStationOperation {
+    readonly part: string;
+    readonly statGroup: string;
+    readonly operation: string;
+    constructor(part: string, statGroup: string, operation: string);
+    static ofLogCycle(c: Readonly<ILogEntry>): PartAndStationOperation;
+    static ofPartCycle(c: Readonly<PartCycleData>): PartAndStationOperation;
+    compare(other: PartAndStationOperation): number;
+    hash(): number;
+    toString(): string;
+}
+export type EstimatedCycleTimes = HashMap<PartAndStationOperation, StatisticalCycleTime>;
+export declare const last30EstimatedCycleTimes: Atom<EstimatedCycleTimes>;
+export declare const specificMonthEstimatedCycleTimes: Atom<EstimatedCycleTimes>;
+export declare function isOutlier(s: StatisticalCycleTime, mins: number): boolean;
+export declare function isOutlierAbove(s: StatisticalCycleTime, mins: number): boolean;
+export declare function chunkCyclesWithSimilarEndTime<T, K>(allCycles: LazySeq<T>, getKey: (t: T) => K & OrderedMapKey, getTime: (c: T) => Date): LazySeq<[K, ReadonlyArray<ReadonlyArray<T>>]>;
+export interface LogEntryWithSplitElapsed<T> {
+    readonly cycle: T;
+    readonly elapsedForSingleMaterialMinutes: number;
+}
+export declare function splitElapsedTimeAmongChunk<T extends {
+    material: ReadonlyArray<unknown>;
+}>(chunk: ReadonlyArray<T>, getElapsedMins: (c: T) => number, getActiveMins: (c: T) => number): ReadonlyArray<LogEntryWithSplitElapsed<T>>;
+export declare function calcElapsedForCycles(eventLog: ReadonlyArray<Readonly<ILogEntry>>): LazySeq<LogEntryWithSplitElapsed<Readonly<ILogEntry>>>;
+export declare const setLast30EstimatedCycleTimes: import("jotai").WritableAtom<null, [log: readonly Readonly<ILogEntry>[]], void> & {
+    init: null;
+};
+export declare const setSpecificMonthEstimatedCycleTimes: import("jotai").WritableAtom<null, [log: readonly Readonly<ILogEntry>[]], void> & {
+    init: null;
+};