@seedtactics/insight-client 16.4.0

package/dist/components/operations/ShiftSettings.js

@@ -0,0 +1,134 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/* 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 { ButtonBase, Stack, TextField, Tooltip } from "@mui/material";
+import { useMemo } from "react";
+import { Clear as ClearIcon } from "@mui/icons-material";
+import { addDays, addMinutes } from "date-fns";
+import { atom, useAtom, useAtomValue } from "jotai";
+import { atomWithStorage } from "jotai/utils";
+const shiftStartStorage = atomWithStorage("shift-starts", [
+    [1, 6 * 60],
+    [2, 14 * 60],
+    [3, 22 * 60],
+]);
+const shiftStartAtom = atom((get) => new Map(get(shiftStartStorage)), (get, set, update) => {
+    const shifts = new Map(get(shiftStartStorage));
+    update(shifts);
+    set(shiftStartStorage, Array.from(shifts.entries()));
+});
+export function useShifts(day) {
+    const shifts = useAtomValue(shiftStartAtom);
+    return useMemo(() => {
+        const starts = [];
+        for (let i = 1; i <= 3; i++) {
+            const cur = shifts.get(i);
+            if (cur === undefined)
+                continue;
+            if (starts.length >= 1 && starts[starts.length - 1] >= cur)
+                continue;
+            starts.push(cur);
+        }
+        if (starts.length === 0) {
+            return [
+                {
+                    start: day,
+                    end: addDays(day, 1),
+                },
+            ];
+        }
+        const finalShiftEnd = addMinutes(addDays(day, 1), starts[0]);
+        const startAndEnd = [];
+        for (let i = 0; i < starts.length; i++) {
+            startAndEnd.push({
+                start: addMinutes(day, starts[i]),
+                end: i === starts.length - 1 ? finalShiftEnd : addMinutes(day, starts[i + 1]),
+            });
+        }
+        return startAndEnd;
+    }, [shifts, day]);
+}
+function timespanToMinutes(t) {
+    const [h, m] = t.split(":");
+    return parseInt(h, 10) * 60 + parseInt(m, 10);
+}
+function minutesToTimespan(m) {
+    const h = Math.floor(m / 60);
+    const min = m % 60;
+    return `${h.toString().padStart(2, "0")}:${min.toString().padStart(2, "0")}`;
+}
+function shiftError(shiftNum, starts) {
+    const cur = starts.get(shiftNum);
+    if (cur === undefined) {
+        return false;
+    }
+    if (shiftNum === 1) {
+        const after = starts.get(2) ?? starts.get(3);
+        return after !== undefined && after <= cur;
+    }
+    else if (shiftNum === 2) {
+        const before = starts.get(1);
+        const after = starts.get(3);
+        return (before !== undefined && before >= cur) || (after !== undefined && after <= cur);
+    }
+    else if (shiftNum === 3) {
+        const before = starts.get(2) ?? starts.get(1);
+        return before !== undefined && before >= cur;
+    }
+    else {
+        return false;
+    }
+}
+function ShiftStartInput({ shiftNum }) {
+    const [shifts, setShifts] = useAtom(shiftStartAtom);
+    const val = shifts.get(shiftNum);
+    return (_jsx(TextField, { type: "time", label: `Shift ${shiftNum} Start`, error: shiftError(shiftNum, shifts), value: val === undefined ? "" : minutesToTimespan(val), onChange: (e) => {
+            const val = e.target.value;
+            if (val === "") {
+                setShifts((draft) => draft.delete(shiftNum));
+            }
+            else {
+                setShifts((draft) => draft.set(shiftNum, timespanToMinutes(val)));
+            }
+        }, variant: "standard", size: "small", slotProps: {
+            inputLabel: { shrink: true },
+            input: shiftNum === 1
+                ? undefined
+                : {
+                    endAdornment: (_jsx(Tooltip, { title: "Clear/Disable Shift", children: _jsx(ButtonBase, { sx: { mb: "4px" }, onClick: () => setShifts((draft) => draft.delete(shiftNum)), children: _jsx(ClearIcon, { fontSize: "small" }) }) })),
+                },
+        } }));
+}
+export function ShiftStart() {
+    return (_jsxs(Stack, { direction: "row", spacing: 2, children: [_jsx(ShiftStartInput, { shiftNum: 1 }), _jsx(ShiftStartInput, { shiftNum: 2 }), _jsx(ShiftStartInput, { shiftNum: 3 })] }));
+}

package/dist/components/operations/SimDayUsage.d.ts

@@ -0,0 +1 @@
+export declare function SimDayUsagePage(): import("react/jsx-runtime").JSX.Element;

package/dist/components/operations/SimDayUsage.js

@@ -0,0 +1,133 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/* 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 { useMemo } from "react";
+import { Box, Stack, Tooltip, Typography } from "@mui/material";
+import { green, grey } from "@mui/material/colors";
+import { LazySeq, OrderedSet } from "@seedtactics/immutable-collections";
+import { atom, useAtomValue } from "jotai";
+import { latestSimDayUsage } from "../../cell-status/sim-day-usage";
+import { useSetTitle } from "../routes";
+import { scaleLinear } from "d3-scale";
+import { Warning as WarningIcon } from "@mui/icons-material";
+const color1 = green[50];
+const color2 = green[600];
+const downtimeColor = grey[100];
+const monthBoxSize = "3em";
+const monthWidth = `calc(${monthBoxSize} * 7)`;
+const groupedSimDayUsage = atom((get) => {
+    const usage = get(latestSimDayUsage);
+    if (usage === null)
+        return null;
+    return LazySeq.of(usage.usage).toLookupOrderedMap((u) => u.machineGroup, (u) => new Date(u.day.getUTCFullYear(), u.day.getUTCMonth(), u.day.getUTCDate()));
+});
+const machineGroups = atom((get) => {
+    const usage = get(latestSimDayUsage);
+    if (usage === null)
+        return OrderedSet.empty();
+    return OrderedSet.build(usage.usage, (u) => u.machineGroup);
+});
+const usageMonths = atom((get) => {
+    const usage = get(latestSimDayUsage);
+    if (usage === null)
+        return OrderedSet.empty();
+    return OrderedSet.build(usage.usage, (u) => new Date(u.day.getUTCFullYear(), u.day.getUTCMonth(), 1));
+});
+const maxUsage = atom((get) => {
+    const usage = get(latestSimDayUsage);
+    if (usage === null)
+        return 0;
+    return (LazySeq.of(usage.usage)
+        .map((u) => Math.ceil(u.usage))
+        .maxBy((u) => u) ?? 1);
+});
+const minAndMaxUsageDay = atom((get) => {
+    const usage = get(latestSimDayUsage);
+    if (usage === null)
+        return [null, null];
+    return [
+        LazySeq.of(usage.usage)
+            .map((u) => new Date(u.day.getUTCFullYear(), u.day.getUTCMonth(), u.day.getUTCDate()))
+            .minBy((d) => d) ?? null,
+        LazySeq.of(usage.usage)
+            .map((u) => new Date(u.day.getUTCFullYear(), u.day.getUTCMonth(), u.day.getUTCDate()))
+            .maxBy((d) => d) ?? null,
+    ];
+});
+function ShowMonth({ date, dayColor, tooltip, }) {
+    const dayStart = new Date(date.getFullYear(), date.getMonth(), 1).getDay();
+    const numDaysInMonth = new Date(date.getFullYear(), date.getMonth() + 1, 0).getDate();
+    return (_jsxs(Box, { width: monthWidth, children: [_jsx(Typography, { variant: "h6", textAlign: "center", children: date.toLocaleString("default", { month: "long", year: "numeric" }) }), _jsxs(Box, { display: "flex", flexWrap: "wrap", children: [LazySeq.ofRange(0, dayStart).map((_, i) => (_jsx(Box, { height: monthBoxSize, width: monthBoxSize }, i))), LazySeq.ofRange(1, numDaysInMonth + 1).map((d, i) => (_jsx("div", { style: {
+                            width: monthBoxSize,
+                            height: monthBoxSize,
+                            cursor: "default",
+                            backgroundColor: dayColor(new Date(date.getFullYear(), date.getMonth(), d)),
+                        }, children: _jsx(Tooltip, { title: tooltip(new Date(date.getFullYear(), date.getMonth(), d)), children: _jsx(Box, { display: "flex", justifyContent: "center", alignItems: "center", height: "100%", children: d }) }) }, i)))] })] }));
+}
+function Warning() {
+    return (_jsxs(Stack, { direction: "row", spacing: 2, alignItems: "center", children: [_jsx(WarningIcon, { fontSize: "small" }), _jsx(Typography, { variant: "caption", children: "Projected dates are estimates" })] }));
+}
+function MonthHeatmap({ group, month }) {
+    const usage = useAtomValue(groupedSimDayUsage);
+    const [minDay, maxDay] = useAtomValue(minAndMaxUsageDay);
+    const maxUse = useAtomValue(maxUsage);
+    const dayColor = useMemo(() => {
+        const scale = scaleLinear().domain([0, maxUse]).range([color1, color2]);
+        return (d) => {
+            if (maxDay && d > maxDay) {
+                return "white";
+            }
+            if (minDay && d < minDay) {
+                return "white";
+            }
+            const u = usage?.get(group)?.get(d);
+            if (u) {
+                return scale(u.usage);
+            }
+            else {
+                return downtimeColor;
+            }
+        };
+    }, [usage, maxUse, minDay, maxDay, group]);
+    function tooltip(d) {
+        const u = usage?.get(group)?.get(d);
+        return (_jsxs(_Fragment, { children: [_jsx("div", { children: d.toLocaleDateString(undefined, { month: "short", day: "numeric", year: "numeric" }) }), maxDay && d > maxDay ? (_jsx("div", { children: "Not Simulated" })) : minDay && d < minDay ? (_jsx("div", {})) : u ? (_jsxs("div", { children: ["Usage: ", u.usage.toFixed(2)] })) : (_jsx("div", { children: "Downtime" }))] }));
+    }
+    return _jsx(ShowMonth, { date: month, dayColor: dayColor, tooltip: tooltip });
+}
+export function SimDayUsagePage() {
+    useSetTitle("Projected Machine Usage");
+    const groups = useAtomValue(machineGroups);
+    const months = useAtomValue(usageMonths);
+    return (_jsx(Box, { component: "main", padding: "24px", children: _jsxs(Stack, { direction: "column", spacing: 5, children: [_jsx(Warning, {}), groups.toAscLazySeq().map((g) => (_jsxs("div", { children: [_jsx(Typography, { variant: "h4", children: g }), _jsx(Box, { display: "flex", flexWrap: "wrap", columnGap: "50px", children: months.toAscLazySeq().map((m) => (_jsx(MonthHeatmap, { group: g, month: m }, m.getTime()))) })] }, g)))] }) }));
+}

package/dist/components/operations/ToolReport.d.ts

@@ -0,0 +1,3 @@
+import { ReactNode } from "react";
+export declare function ToolSummaryTable(): ReactNode;
+export declare function ToolReportPage(): ReactNode;

package/dist/components/operations/ToolReport.js

@@ -0,0 +1,233 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+/* 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 { useState, Fragment } from "react";
+import { Fab, styled, Box, FormControl } from "@mui/material";
+import { CircularProgress } from "@mui/material";
+import TimeAgo from "react-timeago";
+import { Table } from "@mui/material";
+import { TableHead } from "@mui/material";
+import { TableCell } from "@mui/material";
+import { TableRow } from "@mui/material";
+import { Tooltip } from "@mui/material";
+import { TableBody } from "@mui/material";
+import { IconButton } from "@mui/material";
+import { Select } from "@mui/material";
+import { MenuItem } from "@mui/material";
+import { Collapse } from "@mui/material";
+import { Refresh as RefreshIcon, ImportExport, KeyboardArrowDown as KeyboardArrowDownIcon, KeyboardArrowUp as KeyboardArrowUpIcon, } from "@mui/icons-material";
+import { currentToolReport, toolReportRefreshTime, machinesWithTools, toolReportHasSerial, useCopyToolReportToClipboard, toolReportEstimatedToolCounts, } from "../../data/tools-programs.js";
+import { LazySeq } from "@seedtactics/immutable-collections";
+import { PartIdenticon } from "../station-monitor/Material.js";
+import { useIsDemo, useSetTitle } from "../routes.js";
+import { DisplayLoadingAndError } from "../ErrorsAndLoading.js";
+import { atom, useAtom, useAtomValue } from "jotai";
+const cntFormat = new Intl.NumberFormat("en-US", {
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 1,
+});
+const ToolTableRow = styled(TableRow, { shouldForwardProp: (prop) => prop.toString()[0] !== "$" })(({ theme, $noBorderBottom, $highlightedRow, $noticeRow }) => ({
+    ...($noBorderBottom && {
+        "& > *": {
+            borderBottom: "unset",
+        },
+    }),
+    [theme.breakpoints.up("lg")]: {
+        "& td:not(:last-child), & th:not(:last-child)": {
+            whiteSpace: "nowrap",
+        },
+        "& td:last-child, & th:last-child": {
+            width: "100%",
+        },
+    },
+    backgroundColor: $highlightedRow ? "#BDBDBD" : $noticeRow ? "#E0E0E0" : undefined,
+}));
+const MachineDetailTableRow = styled(TableRow, { shouldForwardProp: (prop) => prop.toString()[0] !== "$" })(({ $borderBottom }) => ({
+    ...($borderBottom && {
+        "&:not(:last-child)": {
+            borderBottom: "2px solid black",
+        },
+    }),
+}));
+const VerticalSeperator = styled("span")({
+    fontSize: "x-large",
+    fontWeight: "lighter",
+});
+function FormatMinAndCnt({ min, cnt, showZero, extraMin, extraCnt, }) {
+    min ??= 0;
+    cnt ??= 0;
+    const minSpan = extraMin ? (_jsx(Tooltip, { title: extraMin, children: _jsxs("span", { children: [min.toFixed(1), " min"] }) })) : (min.toFixed(1) + " min");
+    const cntSpan = extraCnt ? (_jsx(Tooltip, { title: extraCnt, children: _jsxs("span", { children: [cntFormat.format(cnt), " cnt"] }) })) : (cntFormat.format(cnt) + " cnt");
+    if (min === 0 && cnt === 0) {
+        if (showZero) {
+            return "0";
+        }
+        else {
+            return "";
+        }
+    }
+    else if (min > 0 && cnt === 0) {
+        return minSpan;
+    }
+    else if (min === 0 && cnt > 0) {
+        return cntSpan;
+    }
+    else {
+        return (_jsxs("span", { children: [minSpan, " ", _jsx(VerticalSeperator, { children: "|" }), " ", cntSpan] }));
+    }
+}
+function PartDetailTable({ tool, machine }) {
+    const parts = machine
+        ? LazySeq.of(tool.parts).filter((p) => p.machines.has(machine))
+        : LazySeq.of(tool.parts);
+    return (_jsxs(Table, { size: "small", sx: {
+            width: "auto",
+            ml: "10em",
+            mb: "1em",
+        }, children: [_jsx(TableHead, { children: _jsxs(TableRow, { children: [_jsx(TableCell, { children: "Part" }), _jsx(TableCell, { children: "Program" }), !machine ? _jsx(TableCell, { children: "Machines" }) : undefined, _jsx(TableCell, { align: "right", children: "Quantity" }), _jsx(TableCell, { align: "right", children: "Use/Cycle (min)" }), _jsx(TableCell, { align: "right", children: "Use/Cycle (cnt)" })] }) }), _jsx(TableBody, { children: parts.isEmpty() ? (_jsx(TableRow, { children: _jsx(TableCell, { colSpan: 5, children: "No programs use this machine" }) })) : (parts.map((p, idx) => (_jsxs(TableRow, { children: [_jsx(TableCell, { children: _jsxs(Box, { sx: {
+                                    display: "flex",
+                                    alignItems: "center",
+                                }, children: [_jsx(PartIdenticon, { part: p.partAndProg.part, size: 20 }), _jsx("span", { children: p.partAndProg.part })] }) }), _jsx(TableCell, { children: p.partAndProg.operation }), !machine ? (_jsx(TableCell, { children: p.machines.foldl((acc, m) => (acc.length > 0 ? acc + ", " : "") + m, "") })) : undefined, _jsx(TableCell, { align: "right", children: p.quantity }), _jsx(TableCell, { align: "right", children: p.scheduledUseMinutes > 0 ? p.scheduledUseMinutes.toFixed(1) : "" }), _jsx(TableCell, { align: "right", children: p.scheduledUseCnt > 0 ? cntFormat.format(p.scheduledUseCnt) : "" })] }, idx)))) })] }));
+}
+function MachineDetailTable({ machines }) {
+    const showSerial = useAtomValue(toolReportHasSerial);
+    const byMachine = LazySeq.of(machines).toLookupOrderedMap((m) => m.machineName, (m) => m.pocket);
+    const anyHasSubtotal = byMachine.size > 1 && byMachine.valuesToAscLazySeq().some((tools) => tools.size > 1);
+    return (_jsxs(Table, { size: "small", sx: {
+            width: "auto",
+            ml: "10em",
+            mb: "1em",
+        }, children: [_jsx(TableHead, { children: _jsxs(TableRow, { children: [_jsx(TableCell, { children: "Machine" }), _jsx(TableCell, { align: "right", children: "Pocket" }), showSerial ? _jsx(TableCell, { children: "Serial" }) : undefined, _jsx(TableCell, { align: "right", children: "Current Use " }), _jsx(TableCell, { align: "right", children: "Lifetime " }), _jsx(TableCell, { align: "right", children: "Remaining Use " })] }) }), _jsxs(TableBody, { children: [byMachine.toAscLazySeq().map(([mach, tools]) => (_jsxs(Fragment, { children: [tools.valuesToAscLazySeq().map((m, idx) => (_jsxs(MachineDetailTableRow, { "$borderBottom": anyHasSubtotal && tools.size === 1, children: [_jsx(TableCell, { children: m.machineName }), _jsx(TableCell, { align: "right", children: m.pocket }), showSerial ? _jsx(TableCell, { children: m.serial ?? "" }) : undefined, _jsx(TableCell, { align: "right", children: _jsx(FormatMinAndCnt, { min: m.currentUseMinutes, cnt: m.currentUseCnt }) }), _jsx(TableCell, { align: "right", children: _jsx(FormatMinAndCnt, { min: m.lifetimeMinutes, cnt: m.lifetimeCnt }) }), _jsx(TableCell, { align: "right", children: _jsx(FormatMinAndCnt, { min: m.remainingMinutes, cnt: m.remainingCnt, showZero: true }) })] }, idx))), byMachine.size > 1 && tools.size > 1 ? (_jsxs(MachineDetailTableRow, { "$borderBottom": true, children: [_jsx(TableCell, { colSpan: showSerial ? 4 : 3 }), _jsx(TableCell, { children: "Subtotal" }), _jsx(TableCell, { align: "right", children: _jsx(FormatMinAndCnt, { min: tools.valuesToAscLazySeq().sumBy((m) => m.remainingMinutes ?? 0), cnt: tools.valuesToAscLazySeq().sumBy((m) => m.remainingCnt ?? 0) }) })] })) : undefined] }, mach))), _jsxs(TableRow, { children: [_jsx(TableCell, { colSpan: showSerial ? 4 : 3 }), _jsx(TableCell, { children: "Total" }), _jsx(TableCell, { align: "right", children: _jsx(FormatMinAndCnt, { min: LazySeq.of(machines).sumBy((m) => m.remainingMinutes ?? 0), cnt: LazySeq.of(machines).sumBy((m) => m.remainingCnt ?? 0) }) })] })] })] }));
+}
+function ToolSummaryHeader() {
+    const cntsWereEstimated = useAtomValue(toolReportEstimatedToolCounts);
+    return (_jsxs(ToolTableRow, { children: [_jsx(TableCell, {}), _jsx(TableCell, { children: "Tool" }), _jsx(TableCell, { align: "right", children: _jsx(Tooltip, { title: "Expected use for all currently scheduled parts." +
+                        (cntsWereEstimated ? " Counts are estimates." : ""), children: _jsx("span", { children: "Scheduled Use" }) }) }), _jsx(TableCell, { align: "right", children: _jsx(Tooltip, { title: "Remaining use summed over all machines which have a scheduled part." +
+                        (cntsWereEstimated ? " Counts are estimates." : ""), children: _jsx("span", { children: "Total Remaining Use" }) }) }), _jsx(TableCell, { align: "right", children: _jsx(Tooltip, { title: "Machine with the least remaining use." + (cntsWereEstimated ? " Counts are estimates." : ""), children: _jsx("span", { children: "Smallest Remaining Use" }) }) }), _jsx(TableCell, {})] }));
+}
+function ToolSummaryRow({ tool }) {
+    const [open, setOpen] = useState(false);
+    const machinesWithSomePart = LazySeq.of(tool.machines).filter((m) => tool.parts.some((p) => p.machines.has(m.machineName)));
+    const schUseMin = LazySeq.of(tool.parts).sumBy((p) => p.scheduledUseMinutes * p.quantity);
+    const schUseCnt = LazySeq.of(tool.parts).sumBy((p) => p.scheduledUseCnt * p.quantity);
+    const totalRemainMin = machinesWithSomePart.sumBy((m) => m.remainingMinutes ?? 0);
+    const totalRemainCnt = machinesWithSomePart.sumBy((m) => m.remainingCnt ?? 0);
+    const minRemainMin = machinesWithSomePart
+        .groupBy((m) => m.machineName)
+        .map(([mach, tools]) => ({ mach, remainMin: LazySeq.of(tools).sumBy((m) => m.remainingMinutes ?? 0) }))
+        .minBy(({ remainMin }) => remainMin);
+    const minRemainCnt = machinesWithSomePart
+        .groupBy((m) => m.machineName)
+        .map(([mach, tools]) => ({ mach, remainCnt: LazySeq.of(tools).sumBy((m) => m.remainingCnt ?? 0) }))
+        .minBy(({ remainCnt }) => remainCnt);
+    const numCols = 6;
+    return (_jsxs(_Fragment, { children: [_jsxs(ToolTableRow, { "$noBorderBottom": true, "$highlightedRow": schUseMin > totalRemainMin || schUseCnt > totalRemainCnt, "$noticeRow": schUseMin <= totalRemainMin &&
+                    schUseCnt <= totalRemainCnt &&
+                    ((minRemainMin && schUseMin > minRemainMin.remainMin) ||
+                        (minRemainCnt && schUseCnt > minRemainCnt.remainCnt)), children: [_jsx(TableCell, { children: _jsx(IconButton, { size: "small", onClick: () => setOpen(!open), children: open ? _jsx(KeyboardArrowUpIcon, {}) : _jsx(KeyboardArrowDownIcon, {}) }) }), _jsx(TableCell, { children: tool.toolName }), _jsx(TableCell, { align: "right", children: _jsx(FormatMinAndCnt, { min: schUseMin, cnt: schUseCnt }) }), _jsx(TableCell, { align: "right", children: _jsx(FormatMinAndCnt, { min: totalRemainMin, cnt: totalRemainCnt }) }), _jsx(TableCell, { align: "right", children: _jsx(FormatMinAndCnt, { min: minRemainMin?.remainMin, cnt: minRemainCnt?.remainCnt, showZero: true, extraMin: minRemainMin?.mach, extraCnt: minRemainCnt?.mach }) }), _jsx(TableCell, {})] }), _jsx(TableRow, { children: _jsx(TableCell, { sx: { pb: "0", pt: "0" }, colSpan: numCols, children: _jsx(Collapse, { in: open, timeout: "auto", unmountOnExit: true, children: _jsxs(Box, { sx: {
+                                display: "flex",
+                                flexWrap: "wrap",
+                                justifyContent: "space-around",
+                                ml: "1em",
+                                mr: "1em",
+                            }, children: [_jsx("div", { children: _jsx(MachineDetailTable, { machines: tool.machines }) }), tool.parts.length === 0 ? undefined : (_jsx("div", { children: _jsx(PartDetailTable, { tool: tool }) }))] }) }) }) })] }));
+}
+function ToolMachineHeader({ machine }) {
+    const cntsWereEstimated = useAtomValue(toolReportEstimatedToolCounts);
+    const showSerial = useAtomValue(toolReportHasSerial);
+    return (_jsxs(ToolTableRow, { children: [_jsx(TableCell, {}), _jsxs(TableCell, { children: ["Tool In ", machine] }), _jsx(TableCell, { align: "right", children: "Pocket" }), showSerial ? _jsx(TableCell, { children: "Serial" }) : undefined, _jsx(TableCell, { align: "right", children: _jsx(Tooltip, { title: "Expected use for all currently scheduled parts." +
+                        (cntsWereEstimated ? " Counts are estimates." : ""), children: _jsx("span", { children: "Scheduled Use" }) }) }), _jsx(TableCell, { align: "right", children: _jsx(Tooltip, { title: "Current recorded usage of this tool." + (cntsWereEstimated ? " Counts are estimates." : ""), children: _jsx("span", { children: "Current Use" }) }) }), _jsxs(TableCell, { align: "right", children: [_jsx(Tooltip, { title: "Current configured lifetime of this tool." + (cntsWereEstimated ? " Counts are estimates." : ""), children: _jsx("span", { children: "Lifetime" }) }), " "] }), _jsx(TableCell, { align: "right", children: _jsx(Tooltip, { title: "Lifetime minus current use." + (cntsWereEstimated ? " Counts are estimates." : ""), children: _jsx("span", { children: "Remaining Use" }) }) }), _jsx(TableCell, {})] }));
+}
+function ToolMachineRow({ report, pocket }) {
+    const [open, setOpen] = useState(false);
+    const showSerial = useAtomValue(toolReportHasSerial);
+    const numCols = showSerial ? 9 : 8;
+    const schMins = LazySeq.of(report.parts)
+        .filter((p) => p.machines.has(pocket.machineName))
+        .sumBy((p) => p.scheduledUseMinutes * p.quantity);
+    const schCnts = LazySeq.of(report.parts)
+        .filter((p) => p.machines.has(pocket.machineName))
+        .sumBy((p) => p.scheduledUseCnt * p.quantity);
+    return (_jsxs(_Fragment, { children: [_jsxs(ToolTableRow, { "$noBorderBottom": true, children: [_jsx(TableCell, { children: _jsx(IconButton, { size: "small", onClick: () => setOpen(!open), children: open ? _jsx(KeyboardArrowUpIcon, {}) : _jsx(KeyboardArrowDownIcon, {}) }) }), _jsx(TableCell, { children: report.toolName }), _jsx(TableCell, { align: "right", children: pocket.pocket }), showSerial ? _jsx(TableCell, { children: pocket.serial ?? "" }) : undefined, _jsx(TableCell, { align: "right", children: _jsx(FormatMinAndCnt, { min: schMins, cnt: schCnts }) }), _jsx(TableCell, { align: "right", children: _jsx(FormatMinAndCnt, { min: pocket.currentUseMinutes, cnt: pocket.currentUseCnt }) }), _jsx(TableCell, { align: "right", children: _jsx(FormatMinAndCnt, { min: pocket.lifetimeMinutes, cnt: pocket.lifetimeCnt }) }), _jsx(TableCell, { align: "right", children: _jsx(FormatMinAndCnt, { min: pocket.remainingMinutes, cnt: pocket.remainingCnt }) }), _jsx(TableCell, {})] }), _jsx(TableRow, { children: _jsx(TableCell, { sx: { pb: "0", pt: "0" }, colSpan: numCols, children: _jsx(Collapse, { in: open, timeout: "auto", unmountOnExit: true, children: _jsx(PartDetailTable, { tool: report, machine: pocket.machineName }) }) }) })] }));
+}
+const FilterAnyMachineKey = "__Insight__FilterAnyMachine__";
+const toolReportMachineFilter = atom(null);
+export function ToolSummaryTable() {
+    const machineFilter = useAtomValue(toolReportMachineFilter);
+    const tools = useAtomValue(currentToolReport);
+    if (tools === null) {
+        return _jsx("div", {});
+    }
+    return (_jsxs(Table, { stickyHeader: true, children: [_jsx(TableHead, { children: machineFilter === null ? _jsx(ToolSummaryHeader, {}) : _jsx(ToolMachineHeader, { machine: machineFilter }) }), _jsx(TableBody, { children: tools.map((tool) => machineFilter === null ? (_jsx(ToolSummaryRow, { tool: tool }, tool.toolName)) : (_jsx(Fragment, { children: tool.machines
+                        .filter((m) => m.machineName === machineFilter)
+                        .map((m) => (_jsx(ToolMachineRow, { report: tool, pocket: m }, m.pocket))) }, tool.toolName))) })] }));
+}
+function ToolNavHeader() {
+    const [machineFilter, setMachineFilter] = useAtom(toolReportMachineFilter);
+    const [reloadTime, refreshReport] = useAtom(toolReportRefreshTime);
+    const [loading, setLoading] = useState(false);
+    const machineNames = useAtomValue(machinesWithTools);
+    const copyToolReportToClipboard = useCopyToolReportToClipboard();
+    const demo = useIsDemo();
+    function refresh() {
+        setLoading(true);
+        refreshReport(new Date())
+            .catch(console.log)
+            .finally(() => setLoading(false));
+    }
+    if (demo) {
+        return _jsx("div", {});
+    }
+    else if (reloadTime === null) {
+        return (_jsx("main", { style: { margin: "2em", display: "flex", justifyContent: "center" }, children: _jsx(Fab, { color: "secondary", size: "large", variant: "extended", style: { margin: "2em" }, onClick: refresh, disabled: loading, children: _jsxs(_Fragment, { children: [loading ? (_jsx(CircularProgress, { size: 10, style: { marginRight: "1em" } })) : (_jsx(RefreshIcon, { fontSize: "inherit", style: { marginRight: "1em" } })), "Load Tools"] }) }) }));
+    }
+    else {
+        return (_jsxs(Box, { component: "nav", sx: {
+                display: "flex",
+                minHeight: "2.5em",
+                alignItems: "center",
+                maxWidth: "calc(100vw - 24px - 24px)",
+            }, children: [_jsx(Tooltip, { title: "Refresh Tools", children: _jsx("div", { children: _jsx(IconButton, { onClick: refresh, disabled: loading, size: "small", children: loading ? _jsx(CircularProgress, { size: 10 }) : _jsx(RefreshIcon, { fontSize: "inherit" }) }) }) }), _jsxs("span", { style: { marginLeft: "1em" }, children: ["Tools from ", _jsx(TimeAgo, { date: reloadTime })] }), _jsx("div", { style: { flexGrow: "1" } }), _jsx(FormControl, { size: "small", children: _jsxs(Select, { autoWidth: true, displayEmpty: true, value: machineFilter ?? FilterAnyMachineKey, style: { marginLeft: "1em" }, onChange: (e) => {
+                            if (e.target.value === FilterAnyMachineKey) {
+                                setMachineFilter(null);
+                            }
+                            else {
+                                setMachineFilter(e.target.value);
+                            }
+                        }, children: [_jsx(MenuItem, { value: FilterAnyMachineKey, children: _jsx("em", { children: "All Machines" }) }), machineNames.map((n) => (_jsx(MenuItem, { value: n, children: _jsx("div", { style: { display: "flex", alignItems: "center" }, children: _jsx("span", { style: { marginRight: "1em" }, children: n }) }) }, n)))] }) }), _jsx(Tooltip, { title: "Copy to Clipboard", children: _jsx(IconButton, { style: { height: "25px", paddingTop: 0, paddingBottom: 0 }, onClick: copyToolReportToClipboard, size: "large", children: _jsx(ImportExport, {}) }) })] }));
+    }
+}
+export function ToolReportPage() {
+    useSetTitle("Tool Report");
+    return (_jsxs(Box, { paddingLeft: "24px", paddingRight: "24px", paddingTop: "10px", children: [_jsx(ToolNavHeader, {}), _jsx("main", { children: _jsx(DisplayLoadingAndError, { children: _jsx(ToolSummaryTable, {}) }) })] }));
+}

package/dist/components/operations/WorkorderGantt.d.ts

@@ -0,0 +1 @@
+export declare function WorkorderGantt(): import("react/jsx-runtime").JSX.Element;

package/dist/components/operations/WorkorderGantt.js

@@ -0,0 +1,124 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+/* 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 { useRef, useCallback, useMemo } from "react";
+import { atom, useAtomValue, useSetAtom } from "jotai";
+import { green } from "@mui/material/colors";
+import { LazySeq } from "@seedtactics/immutable-collections";
+import { addDays, differenceInDays } from "date-fns";
+import { currentStatus } from "../../cell-status/current-status";
+import { Box, Stack } from "@mui/material";
+import { PartIdenticon } from "../station-monitor/Material";
+import { localPoint } from "../../util/chart-helpers.js";
+import { AxisTop, GridCols } from "../AxisAndGrid";
+import { scaleBand, scaleTime } from "d3-scale";
+import { Tooltip } from "../ChartTooltip";
+const tooltipData = atom(null);
+const namesWidth = 150;
+const marginTop = 40;
+const marginBottom = 10;
+const marginLeft = 20;
+const marginRight = 10;
+const rowSize = 80;
+function workorderKey(work) {
+    return `${work.workorderId}-${work.part}`;
+}
+function utcDateOnlyToLocal(d) {
+    if (d) {
+        return new Date(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate());
+    }
+    else {
+        return null;
+    }
+}
+function useScales(workorders) {
+    const workKeys = workorders.map(workorderKey);
+    const dates = LazySeq.of(workorders)
+        .flatMap((w) => {
+        const filled = utcDateOnlyToLocal(w.simulatedFilled);
+        return [utcDateOnlyToLocal(w.simulatedStart), filled ? addDays(filled, 2) : null];
+    })
+        .collect((t) => t);
+    const start = dates.minBy((t) => t) ?? new Date();
+    const end = dates.maxBy((t) => t) ?? addDays(new Date(), 7);
+    const xMax = Math.max(differenceInDays(end, start) * 50, 30);
+    const yMax = Math.max(workKeys.length * rowSize, rowSize);
+    const xScale = scaleTime().domain([start, end]).range([0, xMax]);
+    const yScale = scaleBand().domain(workKeys).range([0, yMax]);
+    return { xScale, yScale };
+}
+function WorkorderTooltip({ tooltip }) {
+    return (_jsxs(Stack, { children: [_jsxs("div", { children: ["Workorder: ", tooltip.data.workorderId] }), _jsxs("div", { children: ["Part: ", tooltip.data.part] }), _jsxs("div", { children: ["Due Date: ", tooltip.data.dueDate.toLocaleDateString()] }), _jsxs("div", { children: ["Priority: ", tooltip.data.priority] }), _jsxs("div", { children: ["Planned Quantity: ", tooltip.data.plannedQuantity] }), _jsxs("div", { children: ["Completed Quantity: ", tooltip.data.completedQuantity] }), _jsxs("div", { children: ["Projected Start: ", utcDateOnlyToLocal(tooltip.data.simulatedStart)?.toLocaleDateString()] }), _jsxs("div", { children: ["Projected Filled: ", utcDateOnlyToLocal(tooltip.data.simulatedFilled)?.toLocaleDateString()] })] }));
+}
+function YAxis({ workorders }) {
+    return (_jsx("div", { children: workorders.map((work) => (_jsxs(Stack, { height: rowSize, direction: "column", alignItems: "flex-end", paddingRight: "10px", justifyContent: "center", children: [_jsx(Box, { children: work.workorderId }), _jsxs(Box, { display: "flex", alignItems: "center", children: [_jsx(PartIdenticon, { part: work.part, size: 18 }), _jsx(Box, { ml: "3px", children: work.part })] })] }, workorderKey(work)))) }));
+}
+function XAxis({ xScale, yScale }) {
+    return (_jsxs(_Fragment, { children: [_jsx(AxisTop, { scale: xScale, top: 0 }), _jsx(GridCols, { scale: xScale, height: yScale.range()[1] - yScale.range()[0] })] }));
+}
+function Series({ workorders, xScale, yScale, }) {
+    const setTooltip = useSetAtom(tooltipData);
+    const hideTooltipRef = useRef(null);
+    function showTooltip(w) {
+        return (e) => {
+            const pt = localPoint(e);
+            if (!pt)
+                return;
+            if (hideTooltipRef.current !== null) {
+                clearTimeout(hideTooltipRef.current);
+                hideTooltipRef.current = null;
+            }
+            setTooltip({
+                left: pt.x,
+                top: pt.y,
+                data: w,
+            });
+        };
+    }
+    const hideTooltip = useCallback(() => {
+        hideTooltipRef.current = setTimeout(() => {
+            setTooltip(null);
+        }, 300);
+    }, [hideTooltipRef, setTooltip]);
+    return (_jsx("g", { children: workorders.map((work) => {
+            const key = workorderKey(work);
+            return (_jsx("g", { onMouseOver: showTooltip(work), onMouseLeave: hideTooltip, children: work.simulatedStart && work.simulatedFilled ? (_jsx("rect", { x: xScale(utcDateOnlyToLocal(work.simulatedStart)), y: (yScale(key) ?? 0) + 20, width: xScale(addDays(utcDateOnlyToLocal(work.simulatedFilled), 1)) -
+                        xScale(utcDateOnlyToLocal(work.simulatedStart)), height: rowSize - 40, fill: green[600] })) : undefined }, key));
+        }) }));
+}
+export function WorkorderGantt() {
+    const currentSt = useAtomValue(currentStatus);
+    const sortedWorkorders = useMemo(() => LazySeq.of(currentSt.workorders ?? []).toSortedArray((w) => w.simulatedFilled?.getTime() ?? null, (w) => w.simulatedStart?.getTime() ?? null, (w) => w.workorderId, (w) => w.part), [currentSt.workorders]);
+    const { xScale, yScale } = useScales(sortedWorkorders);
+    return (_jsxs(Box, { display: "flex", children: [_jsx(Box, { height: yScale.range()[1] + marginTop + marginBottom, width: namesWidth, paddingTop: `${marginTop}px`, children: _jsx(YAxis, { workorders: sortedWorkorders }) }), _jsxs(Box, { flexGrow: 1, width: 0, position: "relative", children: [_jsx("div", { style: { overflowX: "visible" }, children: _jsx("svg", { height: yScale.range()[1] + marginTop + marginBottom, width: xScale.range()[1] + marginRight + marginLeft, children: _jsxs("g", { transform: `translate(${marginLeft}, ${marginTop})`, children: [_jsx(XAxis, { yScale: yScale, xScale: xScale }), _jsx(Series, { workorders: sortedWorkorders, xScale: xScale, yScale: yScale })] }) }) }), _jsx(Tooltip, { atom: tooltipData, TooltipContent: WorkorderTooltip, chartHeight: yScale.range()[1] + marginTop + marginBottom, chartWidth: xScale.range()[1] + marginRight + marginLeft })] })] }));
+}

package/dist/components/quality/QualityMaterial.d.ts

@@ -0,0 +1,2 @@
+export declare function PartLookupStepper(): import("react/jsx-runtime").JSX.Element;
+export declare function QualityMaterialPage(): import("react/jsx-runtime").JSX.Element;