@seedtactics/insight-client 16.4.0

package/dist/data/tools-programs.js

@@ -0,0 +1,376 @@
+/* Copyright (c) 2022, 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 { ActionType, } from "../network/api.js";
+import { durationToMinutes } from "../util/parseISODuration.js";
+import { MachineBackend } from "../network/backend.js";
+import { currentStatus } from "../cell-status/current-status.js";
+import copy from "copy-to-clipboard";
+import { last30ToolUse } from "../cell-status/tool-usage.js";
+import { last30EstimatedCycleTimes, PartAndStationOperation, } from "../cell-status/estimated-cycle-times.js";
+import { stat_name_and_num } from "../cell-status/station-cycles.js";
+import { LazySeq, HashMap, hashValues, OrderedSet } from "@seedtactics/immutable-collections";
+import { atom, useStore } from "jotai";
+import { useCallback } from "react";
+import { last30Jobs } from "../cell-status/scheduled-jobs.js";
+function averageToolUse(usage, sort) {
+    return usage.mapValues((cycles) => {
+        const tools = LazySeq.of(cycles.recentCycles)
+            .flatMap((c) => c.tools)
+            .filter((c) => !c.toolChangedDuringMiddleOfCycle)
+            .groupBy((t) => t.toolName)
+            .map(([toolName, usageInCycles]) => ({
+            toolName: toolName,
+            cycleUsageMinutes: LazySeq.of(usageInCycles).sumBy((c) => c.cycleUsageMinutes) / usageInCycles.length,
+            cycleUsageCnt: LazySeq.of(usageInCycles).sumBy((c) => c.cycleUsageCnt) / usageInCycles.length,
+            toolChangedDuringMiddleOfCycle: false,
+        }))
+            .toMutableArray();
+        if (sort) {
+            tools.sort((a, b) => a.toolName.localeCompare(b.toolName));
+        }
+        return { tools };
+    });
+}
+class StationOperation {
+    constructor(statGroup, operation) {
+        this.statGroup = statGroup;
+        this.operation = operation;
+    }
+    compare(other) {
+        const c = this.statGroup.localeCompare(other.statGroup);
+        if (c !== 0)
+            return c;
+        return this.operation.localeCompare(other.operation);
+    }
+    hash() {
+        return hashValues(this.statGroup, this.operation);
+    }
+    toString() {
+        return `{statGroup: ${this.statGroup}, operation: ${this.operation}}`;
+    }
+}
+function estimateToolMinutesPerCount(parts, machineName) {
+    let use = 0;
+    let numParts = 0;
+    // weighted average of (u.scheduledUseMinutes / u.scheduledUseCnt) by quantity
+    for (const u of LazySeq.of(parts).filter((p) => p.machines.has(machineName) ?? false)) {
+        use += u.quantity * (u.scheduledUseMinutes / u.scheduledUseCnt);
+        numParts += u.quantity;
+    }
+    return numParts === 0 ? 0 : use / numParts;
+}
+export function calcToolReport(currentSt, toolsInMach, usage) {
+    let partPlannedQtys = HashMap.empty();
+    for (const [uniq, job] of LazySeq.ofObject(currentSt.jobs)) {
+        const planQty = job.cycles ?? 0;
+        for (let procIdx = 0; procIdx < job.procsAndPaths.length; procIdx++) {
+            let completed = 0;
+            let programsToAfterInProc = HashMap.empty();
+            for (let pathIdx = 0; pathIdx < job.procsAndPaths[procIdx].paths.length; pathIdx++) {
+                completed += job.completed?.[procIdx]?.[pathIdx] ?? 0;
+                const path = job.procsAndPaths[procIdx].paths[pathIdx];
+                for (let stopIdx = 0; stopIdx < path.stops.length; stopIdx += 1) {
+                    const stop = path.stops[stopIdx];
+                    const inProcAfter = LazySeq.of(currentSt.material)
+                        .filter((m) => m.jobUnique === uniq &&
+                        m.process == procIdx + 1 &&
+                        m.path === pathIdx + 1 &&
+                        (m.action.type === ActionType.UnloadToCompletedMaterial ||
+                            m.action.type === ActionType.UnloadToInProcess ||
+                            (m.lastCompletedMachiningRouteStopIndex !== undefined &&
+                                m.lastCompletedMachiningRouteStopIndex > stopIdx)))
+                        .length();
+                    if (stop.program !== undefined && stop.program !== "") {
+                        programsToAfterInProc = programsToAfterInProc.modify(new StationOperation(stop.stationGroup, stop.program), (old) => (old ?? 0) + inProcAfter);
+                    }
+                }
+            }
+            for (const [op, afterInProc] of programsToAfterInProc) {
+                partPlannedQtys = partPlannedQtys.modify(new PartAndStationOperation(job.partName, op.statGroup, op.operation), (old) => (old ?? 0) + planQty - completed - afterInProc);
+            }
+        }
+    }
+    const parts = LazySeq.of(averageToolUse(usage, false))
+        .flatMap(([partAndProg, tools]) => {
+        const qty = window.bmsToolReportOverridePartQuantity ?? partPlannedQtys.get(partAndProg);
+        if (qty !== undefined && qty > 0) {
+            return tools.tools.map((tool) => {
+                return {
+                    toolName: tool.toolName,
+                    part: {
+                        partAndProg,
+                        quantity: qty,
+                        scheduledUseMinutes: tool.cycleUsageMinutes,
+                        // if no counts, just estimate as 1
+                        scheduledUseCnt: tool.cycleUsageCnt === 0 ? 1 : tool.cycleUsageCnt,
+                        machines: usage.get(partAndProg)?.machines ?? OrderedSet.empty(),
+                    },
+                };
+            });
+        }
+        else {
+            return [];
+        }
+    })
+        .sortBy((p) => p.part.partAndProg.part, (p) => p.part.partAndProg.operation)
+        .toLookup((t) => t.toolName, (t) => t.part);
+    return LazySeq.of(toolsInMach)
+        .orderedGroupBy((t) => t.toolName)
+        .map(([toolName, tools]) => {
+        let estimatedToolCounts = false;
+        const toolsInMachine = LazySeq.of(tools)
+            .sortBy((t) => t.machineGroupName, (t) => t.machineNum, (t) => t.pocket)
+            .map((m) => {
+            const currentUseMinutes = m.currentUse !== null && m.currentUse !== undefined && m.currentUse !== ""
+                ? durationToMinutes(m.currentUse)
+                : null;
+            const lifetimeMinutes = m.totalLifeTime !== null && m.totalLifeTime !== undefined && m.totalLifeTime !== ""
+                ? durationToMinutes(m.totalLifeTime)
+                : null;
+            const machineName = stat_name_and_num(m.machineGroupName, m.machineNum);
+            let currentUseCnt = m.currentUseCount ?? null;
+            let lifetimeCnt = m.totalLifeCount ?? null;
+            if (currentUseCnt === null && lifetimeCnt === null) {
+                // If both are not defined, then estimate
+                const estUse = estimateToolMinutesPerCount(parts.get(toolName) ?? [], machineName);
+                if (estUse > 0) {
+                    estimatedToolCounts = true;
+                    // unit analysis: mins / (mins / cnt) = cnt
+                    currentUseCnt = currentUseMinutes !== null ? currentUseMinutes / estUse : null;
+                    lifetimeCnt = lifetimeMinutes !== null ? lifetimeMinutes / estUse : null;
+                }
+            }
+            return {
+                machineName,
+                pocket: m.pocket,
+                serial: m.serial,
+                currentUseMinutes,
+                lifetimeMinutes,
+                remainingMinutes: currentUseMinutes !== null && lifetimeMinutes !== null
+                    ? Math.max(0, lifetimeMinutes - currentUseMinutes)
+                    : null,
+                currentUseCnt: currentUseCnt ?? null,
+                lifetimeCnt: lifetimeCnt ?? null,
+                remainingCnt: currentUseCnt !== null && lifetimeCnt !== null
+                    ? Math.max(0, lifetimeCnt - currentUseCnt)
+                    : null,
+            };
+        })
+            .toRArray();
+        return {
+            toolName,
+            machines: toolsInMachine,
+            parts: parts.get(toolName) ?? [],
+            estimatedToolCounts,
+        };
+    })
+        .toRArray();
+}
+const toolsInMachine = atom(null);
+export const toolReportRefreshTime = atom((get) => get(toolsInMachine)?.time ?? null, async (_, set, time) => {
+    set(toolsInMachine, {
+        tools: await MachineBackend.getToolsInMachines(),
+        time,
+    });
+});
+export const machinesWithTools = atom((get) => {
+    const toolsInMach = get(toolsInMachine);
+    if (toolsInMach === null)
+        return [];
+    const names = new Set();
+    for (const t of toolsInMach.tools) {
+        names.add(stat_name_and_num(t.machineGroupName, t.machineNum));
+    }
+    return Array.from(names).sort((a, b) => a.localeCompare(b));
+});
+export const currentToolReport = atom((get) => {
+    const toolsInMach = get(toolsInMachine);
+    if (toolsInMach === null)
+        return null;
+    const currentSt = get(currentStatus);
+    const usage = get(last30ToolUse);
+    return calcToolReport(currentSt, toolsInMach.tools, usage);
+});
+export const toolReportHasSerial = atom((get) => {
+    const report = get(currentToolReport);
+    if (!report)
+        return false;
+    return LazySeq.of(report)
+        .flatMap((r) => r.machines)
+        .some((t) => t.serial != null && t.serial !== "");
+});
+export const toolReportEstimatedToolCounts = atom((get) => {
+    const report = get(currentToolReport);
+    if (!report)
+        return false;
+    return LazySeq.of(report).some((r) => r.estimatedToolCounts);
+});
+function buildToolReportHTML(tools) {
+    const showTime = LazySeq.of(tools)
+        .flatMap((r) => r.machines)
+        .some((t) => t.currentUseMinutes != null);
+    const showCnts = LazySeq.of(tools)
+        .flatMap((r) => r.machines)
+        .some((t) => t.currentUseCnt != null);
+    let table = "<table>\n<thead><tr>";
+    table += "<th>Tool</th><th>Machine</th><th>Pocket</th>";
+    if (showTime) {
+        table +=
+            "<th>Scheduled Use (min)</th><th>Current Use (min)</th><th>Lifetime (min)</th><th>Remaining Life (min)</th>";
+    }
+    if (showCnts) {
+        table +=
+            "<th>Scheduled Use (cnt)</th><th>Current Use (cnt)</th><th>Lifetime (cnt)</th><th>Remaining Life (cnt)</th>";
+    }
+    table += "</tr></thead>\n<tbody>\n";
+    for (const tool of tools) {
+        for (const mach of tool.machines) {
+            table += `<tr><td>${tool.toolName}</td><td>${mach.machineName}</td><td>${mach.pocket}</td>`;
+            if (showTime) {
+                const schUse = LazySeq.of(tool.parts).sumBy((p) => p.scheduledUseMinutes * p.quantity);
+                table += "<td>" + schUse.toFixed(1) + "</td>";
+                table += "<td>" + (mach.currentUseMinutes ? mach.currentUseMinutes.toFixed(1) : "") + "</td>";
+                table += "<td>" + (mach.lifetimeMinutes ? mach.lifetimeMinutes.toFixed(1) : "") + "</td>";
+                table += "<td>" + (mach.remainingMinutes ? mach.remainingMinutes.toFixed(1) : "") + "</td>";
+            }
+            if (showCnts) {
+                const schUse = LazySeq.of(tool.parts).sumBy((p) => p.scheduledUseCnt * p.quantity);
+                table += "<td>" + schUse.toFixed(1) + "</td>";
+                table += "<td>" + (mach.currentUseCnt ? mach.currentUseCnt.toFixed(1) : "") + "</td>";
+                table += "<td>" + (mach.lifetimeCnt ? mach.lifetimeCnt.toFixed(1) : "") + "</td>";
+                table += "<td>" + (mach.remainingCnt ? mach.remainingCnt.toFixed(1) : "") + "</td>";
+            }
+            table += "</tr>\n";
+        }
+    }
+    table += "</tbody></table>";
+    return table;
+}
+export function useCopyToolReportToClipboard() {
+    const store = useStore();
+    return useCallback(() => {
+        const tools = store.get(currentToolReport);
+        if (!tools)
+            return;
+        copy(buildToolReportHTML(tools));
+    }, [store]);
+}
+export function calcProgramReport(usage, cycleTimes, jobs, progsInCellCtrl, progsToShow) {
+    const tools = averageToolUse(usage, true);
+    const progToPart = usage.keysToLazySeq().toRMap((op) => [op.operation, op], (_, x) => x);
+    let allPrograms = LazySeq.of(progsInCellCtrl);
+    if (progsToShow != null) {
+        allPrograms = allPrograms.filter((p) => progsToShow.has(p.programName));
+    }
+    const plannedTimes = jobs
+        ?.valuesToLazySeq()
+        .flatMap((j) => LazySeq.of(j.procsAndPaths)
+        .flatMap((p) => p.paths)
+        .flatMap((path) => LazySeq.of(path.stops).collect((stop) => {
+        const mins = durationToMinutes(stop.expectedCycleTime);
+        if (stop.program && mins > 0) {
+            return {
+                program: stop.program,
+                plannedMins: mins / path.partsPerPallet,
+                start: j.routeStartUTC,
+            };
+        }
+        else {
+            return null;
+        }
+    })))
+        .toOrderedMap((p) => [p.program, p], (v1, v2) => (v1.start > v2.start ? v1 : v2));
+    const programs = allPrograms
+        .map((prog) => {
+        const part = progToPart.get(prog.programName);
+        return {
+            programName: prog.programName,
+            cellControllerProgramName: prog.cellControllerProgramName,
+            comment: prog.comment ?? null,
+            revision: prog.revision ?? null,
+            partName: part?.part ?? null,
+            statisticalCycleTime: part ? (cycleTimes.get(part) ?? null) : null,
+            toolUse: part ? (tools.get(part) ?? null) : null,
+            plannedMins: plannedTimes?.get(prog.programName)?.plannedMins ?? null,
+        };
+    })
+        .toRArray();
+    return {
+        time: new Date(),
+        programs,
+        hasRevisions: programs.some((p) => p.revision !== null),
+        cellNameDifferentFromProgName: programs.some((p) => p.cellControllerProgramName !== p.programName),
+    };
+}
+export const programFilter = atom("AllPrograms");
+const programsInCellCtrl = atom(null);
+export const programReportRefreshTime = atom((get) => get(programsInCellCtrl)?.time ?? null, async (_, set, time) => {
+    set(programsInCellCtrl, {
+        progs: await MachineBackend.getProgramsInCellController(),
+        time,
+    });
+});
+export const currentProgramReport = atom((get) => {
+    const time = get(programReportRefreshTime);
+    if (time === null)
+        return null;
+    const filter = get(programFilter);
+    let progsToShow = null;
+    if (filter === "ActivePrograms") {
+        const status = get(currentStatus);
+        progsToShow = new Set(LazySeq.ofObject(status.jobs)
+            .flatMap(([, job]) => job.procsAndPaths)
+            .flatMap((p) => p.paths)
+            .flatMap((p) => p.stops)
+            .filter((s) => s.program !== null && s.program !== undefined && s.program !== "")
+            .map((s) => s.program ?? ""));
+    }
+    const progsInCell = get(programsInCellCtrl);
+    if (progsInCell === null)
+        return null;
+    return calcProgramReport(get(last30ToolUse), get(last30EstimatedCycleTimes), get(last30Jobs), progsInCell.progs, progsToShow);
+});
+export const programToShowContent = atom(null);
+export const programContent = atom(async (get) => {
+    const prog = get(programToShowContent);
+    if (prog === null) {
+        return "";
+    }
+    else if (prog.revision === null) {
+        return await MachineBackend.getLatestProgramRevisionContent(prog.programName);
+    }
+    else {
+        return await MachineBackend.getProgramRevisionContent(prog.programName, prog.revision);
+    }
+});
+export const programToShowHistory = atom(null);

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,60 @@
+/* Copyright (c) 2019, 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 { render } from "./renderer.js";
+import { registerNetworkBackend } from "./network/backend.js";
+import { fmsInformation, loadInfo } from "./network/server-settings.js";
+import { ApiException } from "./network/api.js";
+import { createStore } from "jotai";
+async function main() {
+    registerNetworkBackend();
+    const store = createStore();
+    store.set(fmsInformation, await loadInfo());
+    render(null, document.getElementById("root"), store);
+}
+main().catch((e) => {
+    console.log(e);
+    let msg = "Error loading Insight";
+    if (e instanceof ApiException) {
+        msg = "Error loading Insight: " + e.message + " " + e.response;
+    }
+    const p = document.createElement("p");
+    p.textContent = msg;
+    (document.getElementById("loading") ?? document.body).appendChild(p);
+});
+if ("serviceWorker" in navigator) {
+    void navigator.serviceWorker.getRegistrations().then((registrations) => {
+        for (const reg of registrations) {
+            void reg.unregister();
+        }
+    });
+}