@seedtactics/insight-client 16.4.0

package/dist/components/routes.js

@@ -0,0 +1,301 @@
+/* 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 { LazySeq } from "@seedtactics/immutable-collections";
+import { createElement, useEffect } from "react";
+import "urlpattern-polyfill";
+import { materialDialogOpen } from "../cell-status/material-details.js";
+import { atom, useAtomValue, useSetAtom } from "jotai";
+import { Link } from "@mui/material";
+export var RouteLocation;
+(function (RouteLocation) {
+    RouteLocation["ChooseMode"] = "/";
+    RouteLocation["Station_LoadMonitor"] = "/station/loadunload/:num";
+    RouteLocation["Station_InspectionMonitor"] = "/station/inspection";
+    RouteLocation["Station_InspectionMonitorWithType"] = "/station/inspection/:type";
+    RouteLocation["Station_Closeout"] = "/station/closeout";
+    RouteLocation["Station_Queues"] = "/station/queues";
+    RouteLocation["Station_Overview"] = "/station/overview";
+    RouteLocation["Operations_Dashboard"] = "/operations";
+    RouteLocation["Operations_LoadOutliers"] = "/operations/load-outliers";
+    RouteLocation["Operations_LoadHours"] = "/operations/load-hours";
+    RouteLocation["Operations_LoadCycles"] = "/operations/load-cycles";
+    RouteLocation["Operations_MachineOutliers"] = "/operations/machine-outliers";
+    RouteLocation["Operations_MachineHours"] = "/operations/machine-hours";
+    RouteLocation["Operations_MachineCycles"] = "/operations/machine-cycles";
+    RouteLocation["Operations_SystemOverview"] = "/operations/system-overview";
+    RouteLocation["Operations_AllMaterial"] = "/operations/material";
+    RouteLocation["Operations_RecentSchedules"] = "/operations/recent-schedules";
+    RouteLocation["Operations_CurrentWorkorders"] = "/operations/current-workorders";
+    RouteLocation["Operations_Production"] = "/operations/recent-production";
+    RouteLocation["Operations_Tools"] = "/operations/tools";
+    RouteLocation["Operations_Programs"] = "/operations/programs";
+    RouteLocation["Operations_Quality"] = "/operations/quality";
+    RouteLocation["Operations_Inspections"] = "/operations/inspections";
+    RouteLocation["Operations_CloseoutReport"] = "/operations/closeout";
+    RouteLocation["Operations_Rebookings"] = "/analysis/rebookings";
+    RouteLocation["Operations_Parts"] = "/operations/parts";
+    RouteLocation["Engineering_Cycles"] = "/engineering";
+    RouteLocation["Engineering_Hours"] = "/engineering/hours";
+    RouteLocation["Engineering_Outliers"] = "/engineering/outliers";
+    RouteLocation["Quality_Dashboard"] = "/quality";
+    RouteLocation["Quality_Paths"] = "/quality/paths";
+    RouteLocation["Quality_Quarantine"] = "/quality/quarantine";
+    RouteLocation["Tools_Dashboard"] = "/tools";
+    RouteLocation["Tools_Programs"] = "/tools/programs";
+    RouteLocation["Analysis_Buffers"] = "/analysis/buffers";
+    RouteLocation["Analysis_StationOEE"] = "/analysis/station-oee";
+    RouteLocation["Analysis_PartsCompleted"] = "/analysis/parts-completed";
+    RouteLocation["Analysis_MachineCycles"] = "/analysis/machine-cycles";
+    RouteLocation["Analysis_LoadCycles"] = "/analysis/load-cycles";
+    RouteLocation["Analysis_PalletCycles"] = "/analysis/pallet-cycles";
+    RouteLocation["Analysis_Schedules"] = "/analysis/schedules";
+    RouteLocation["Analysis_Quality"] = "/analysis/quality";
+    RouteLocation["Analysis_ToolReplacements"] = "/analysis/tool-replacements";
+    RouteLocation["Analysis_CostPercents"] = "/analysis/cost-percents";
+    RouteLocation["Analysis_CostPerPiece"] = "/analysis/cost";
+    RouteLocation["Sales_Dashboard"] = "/sales";
+    RouteLocation["Sales_ProjectedUsage"] = "/sales/projected-usage";
+    RouteLocation["VerboseLogging"] = "/logging";
+    RouteLocation["Client_Custom"] = "/client/:custom+";
+})(RouteLocation || (RouteLocation = {}));
+const patterns = LazySeq.ofObject(RouteLocation)
+    .map(([, loc]) => [loc, new URLPattern(loc, location.origin)])
+    // redirects from old URLs
+    .append([
+    RouteLocation.Operations_RecentSchedules,
+    new URLPattern("/operations/completed", location.origin),
+])
+    .append([RouteLocation.Station_Closeout, new URLPattern("/station/wash", location.origin)])
+    .toRArray();
+function routeToUrl(route) {
+    switch (route.route) {
+        case RouteLocation.Station_LoadMonitor:
+            if (route.queues.length > 0 || route.completed) {
+                const params = new URLSearchParams();
+                for (const q of route.queues) {
+                    params.append("queue", q);
+                }
+                if (route.completed) {
+                    params.append("completed", "t");
+                }
+                return `/station/loadunload/${route.loadNum}?${params.toString()}`;
+            }
+            else {
+                return `/station/loadunload/${route.loadNum}`;
+            }
+        case RouteLocation.Station_InspectionMonitorWithType:
+            return `/station/inspection/${encodeURIComponent(route.inspType)}`;
+        case RouteLocation.Station_Queues:
+            if (route.queues.length > 0) {
+                const params = new URLSearchParams();
+                for (const q of route.queues) {
+                    params.append("queue", q);
+                }
+                return `/station/queues?${params.toString()}`;
+            }
+            else {
+                return `/station/queues`;
+            }
+        case RouteLocation.Operations_CurrentWorkorders:
+            if (route.workorder) {
+                const params = new URLSearchParams();
+                params.append("workorder", route.workorder);
+                return `/operations/current-workorders?${params.toString()}`;
+            }
+            else {
+                return `/operations/current-workorders`;
+            }
+        case RouteLocation.Client_Custom:
+            return "/client/" + route.custom.map((r) => encodeURIComponent(r)).join("/");
+        default:
+            return route.route;
+    }
+}
+function urlToRoute(url) {
+    for (const [route, pattern] of patterns) {
+        const groups = pattern.exec(url.origin + url.pathname)?.pathname?.groups;
+        if (groups) {
+            switch (route) {
+                case RouteLocation.Station_LoadMonitor:
+                    return {
+                        route,
+                        loadNum: parseInt(groups["num"] ?? "1"),
+                        queues: url.searchParams.getAll("queue"),
+                        completed: url.searchParams.has("completed"),
+                    };
+                case RouteLocation.Station_InspectionMonitorWithType: {
+                    const inspType = groups["type"];
+                    if (inspType) {
+                        return {
+                            route: RouteLocation.Station_InspectionMonitorWithType,
+                            inspType,
+                        };
+                    }
+                    else {
+                        return { route: RouteLocation.Station_InspectionMonitor };
+                    }
+                }
+                case RouteLocation.Station_Queues: {
+                    return {
+                        route: RouteLocation.Station_Queues,
+                        queues: url.searchParams.getAll("queue"),
+                    };
+                }
+                case RouteLocation.Operations_CurrentWorkorders: {
+                    const workorder = url.searchParams.get("workorder");
+                    return {
+                        route: RouteLocation.Operations_CurrentWorkorders,
+                        workorder: workorder ?? undefined,
+                    };
+                }
+                case RouteLocation.Client_Custom:
+                    return {
+                        route: RouteLocation.Client_Custom,
+                        custom: groups?.["custom"]?.split("/")?.map((s) => decodeURIComponent(s)) ?? [],
+                    };
+                default:
+                    return { route };
+            }
+        }
+    }
+    return { route: RouteLocation.ChooseMode };
+}
+const currentRouteLocation = atom(urlToRoute(new URL(location.href)));
+export const isDemoAtom = atom(false);
+export const currentRoute = atom((get) => get(currentRouteLocation), (get, set, to) => {
+    const demo = get(isDemoAtom);
+    set(currentRouteLocation, to);
+    set(materialDialogOpen, null);
+    if (!demo) {
+        history.pushState(null, "", routeToUrl(to));
+    }
+});
+export function AppLink({ to, children }) {
+    const setRoute = useSetAtom(currentRoute);
+    return createElement(Link, {
+        href: routeToUrl(to),
+        onClick: (e) => {
+            e.preventDefault();
+            e.stopPropagation();
+            setRoute(to);
+        },
+    }, children);
+}
+export function useWatchHistory() {
+    const isDemo = useAtomValue(isDemoAtom);
+    const setCurRoute = useSetAtom(currentRouteLocation);
+    // check for changes in history (back, forwards)
+    useEffect(() => {
+        if (isDemo)
+            return;
+        function updateRoute() {
+            setCurRoute(urlToRoute(new URL(location.href)));
+        }
+        addEventListener("popstate", updateRoute);
+        return () => removeEventListener("popstate", updateRoute);
+    }, [isDemo, setCurRoute]);
+}
+export function useIsDemo() {
+    return useAtomValue(isDemoAtom);
+}
+export function useSetTitle(title) {
+    const demo = useIsDemo();
+    useEffect(() => {
+        document.title = title + " - FMS Insight";
+    }, [demo, title]);
+}
+export function helpUrl(r) {
+    switch (r.route) {
+        case RouteLocation.Station_LoadMonitor:
+        case RouteLocation.Station_InspectionMonitor:
+        case RouteLocation.Station_InspectionMonitorWithType:
+        case RouteLocation.Station_Closeout:
+        case RouteLocation.Station_Queues:
+        case RouteLocation.Station_Overview:
+            return "https://www.seedtactics.com/docs/fms-insight/client-station-monitor";
+        case RouteLocation.Operations_Dashboard:
+        case RouteLocation.Operations_LoadOutliers:
+        case RouteLocation.Operations_LoadHours:
+        case RouteLocation.Operations_LoadCycles:
+        case RouteLocation.Operations_SystemOverview:
+        case RouteLocation.Operations_AllMaterial:
+        case RouteLocation.Operations_RecentSchedules:
+        case RouteLocation.Operations_CurrentWorkorders:
+        case RouteLocation.Operations_CloseoutReport:
+        case RouteLocation.Operations_Production:
+        case RouteLocation.Operations_Rebookings:
+        case RouteLocation.Operations_Parts:
+            return "https://www.seedtactics.com/docs/fms-insight/client-operations";
+        case RouteLocation.Operations_MachineOutliers:
+        case RouteLocation.Operations_MachineHours:
+        case RouteLocation.Operations_MachineCycles:
+            return "https://www.seedtactics.com/docs/fms-insight/client-engineering";
+        case RouteLocation.Operations_Quality:
+        case RouteLocation.Operations_Inspections:
+            return "https://www.seedtactics.com/docs/fms-insight/client-quality";
+        case RouteLocation.Operations_Tools:
+        case RouteLocation.Operations_Programs:
+            return "https://www.seedtactics.com/docs/fms-insight/client-tools-programs";
+        case RouteLocation.Engineering_Cycles:
+        case RouteLocation.Engineering_Outliers:
+        case RouteLocation.Engineering_Hours:
+            return "https://www.seedtactics.com/docs/fms-insight/client-engineering";
+        case RouteLocation.Quality_Dashboard:
+        case RouteLocation.Quality_Paths:
+        case RouteLocation.Quality_Quarantine:
+            return "https://www.seedtactics.com/docs/fms-insight/client-quality";
+        case RouteLocation.Tools_Dashboard:
+        case RouteLocation.Tools_Programs:
+            return "https://www.seedtactics.com/docs/fms-insight/client-tools-programs";
+        case RouteLocation.Analysis_Schedules:
+        case RouteLocation.Analysis_Buffers:
+        case RouteLocation.Analysis_StationOEE:
+        case RouteLocation.Analysis_PartsCompleted:
+        case RouteLocation.Analysis_MachineCycles:
+        case RouteLocation.Analysis_LoadCycles:
+        case RouteLocation.Analysis_PalletCycles:
+        case RouteLocation.Analysis_Quality:
+        case RouteLocation.Analysis_CostPercents:
+        case RouteLocation.Analysis_ToolReplacements:
+        case RouteLocation.Analysis_CostPerPiece:
+            return "https://www.seedtactics.com/docs/fms-insight/client-efficiency";
+        case RouteLocation.Sales_Dashboard:
+        case RouteLocation.Sales_ProjectedUsage:
+            return "https://www.seedtactics.com/docs/fms-insight/client-sales";
+        case RouteLocation.ChooseMode:
+        case RouteLocation.VerboseLogging:
+        case RouteLocation.Client_Custom:
+        default:
+            return "https://www.seedtactics.com/docs/fms-insight/client-launch";
+    }
+}

package/dist/components/station-monitor/BulkRawMaterial.d.ts

@@ -0,0 +1,11 @@
+import * as api from "../../network/api.js";
+export declare const bulkAddCastingToQueue: import("jotai").PrimitiveAtom<string | null> & {
+    init: string | null;
+};
+export declare const BulkAddCastingWithoutSerialDialog: import("react").NamedExoticComponent<object>;
+export interface MultiMaterialDialogProps {
+    readonly material: ReadonlyArray<Readonly<api.IInProcessMaterial>> | null;
+    readonly closeDialog: () => void;
+    readonly operator: string | null;
+}
+export declare const MultiMaterialDialog: import("react").NamedExoticComponent<MultiMaterialDialogProps>;

package/dist/components/station-monitor/BulkRawMaterial.js

@@ -0,0 +1,251 @@
+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 { useState, memo, useRef, useEffect, useMemo } from "react";
+import { Button, Stack, Table, TableBody, TableCell, TableHead, TableRow, ListItemText, ListItemIcon, MenuItem, Dialog, DialogActions, DialogContent, DialogTitle, CircularProgress, TextField, } from "@mui/material";
+import { useReactToPrint } from "react-to-print";
+import { MaterialDetailTitle, PartIdenticon } from "./Material.js";
+import * as api from "../../network/api.js";
+import { LazySeq } from "@seedtactics/immutable-collections";
+import { extractJobRawMaterial, loadRawMaterialEvents } from "../../data/queue-material.js";
+import { currentOperator } from "../../data/operators.js";
+import { PrintedLabel, PrintOnClientButton } from "./PrintedLabel.js";
+import { fmsInformation } from "../../network/server-settings.js";
+import { currentStatus } from "../../cell-status/current-status.js";
+import { useAddNewCastingToQueue, usePrintLabel } from "../../cell-status/material-details.js";
+import { castingNames } from "../../cell-status/names.js";
+import { atom, useAtom, useAtomValue, useSetAtom } from "jotai";
+import { JobsBackend } from "../../network/backend.js";
+import { LogEntries } from "../LogEntry.js";
+export const bulkAddCastingToQueue = atom(null);
+const waitingForMaterialAssignmentDialog = atom(null);
+function WaitingForMaterialDialog() {
+    const [waiting, setWaiting] = useAtom(waitingForMaterialAssignmentDialog);
+    const st = useAtomValue(currentStatus);
+    const printRef = useRef(null);
+    const printStarted = useRef(false);
+    const print = useReactToPrint({
+        contentRef: printRef,
+        onAfterPrint: () => setWaiting(null),
+        ignoreGlobalStyles: true,
+    });
+    let materialToPrint = waiting ? st.material.filter((m) => waiting.materialIds.has(m.materialID)) : null;
+    if (materialToPrint?.length !== waiting?.materialIds.size) {
+        materialToPrint = null;
+    }
+    useEffect(() => {
+        if (waiting === null) {
+            if (printStarted.current) {
+                printStarted.current = false;
+            }
+            return;
+        }
+        if (printStarted.current || materialToPrint === null)
+            return;
+        print();
+        printStarted.current = true;
+    }, [waiting, materialToPrint, printStarted, print]);
+    console.log(waiting, materialToPrint);
+    return (_jsxs(_Fragment, { children: [_jsxs(Dialog, { open: waiting !== null, children: [_jsx(DialogTitle, { children: "Waiting for Material Assignment" }), _jsx(DialogContent, { children: materialToPrint === null ? (waiting === null ? (_jsx("div", {})) : (_jsxs(Stack, { direction: "column", spacing: 2, mt: "0.5em", mb: "0.5em", children: [_jsx(CircularProgress, { color: "secondary" }), _jsx("div", { children: "Waiting for material assignment. This could take a while if a download is currently in progress." })] }))) : (_jsx("div", { children: "Printing..." })) }), _jsx(DialogActions, { children: _jsx(Button, { color: "primary", onClick: () => setWaiting(null), children: "Cancel" }) })] }), _jsx("div", { style: { display: "none" }, children: _jsx("div", { ref: printRef, children: _jsx(PrintedLabel, { materialName: waiting?.selectedCasting, material: materialToPrint, operator: waiting?.operator, oneJobPerPage: true }) }) })] }));
+}
+function JobsForCasting({ casting, queue }) {
+    const currentSt = useAtomValue(currentStatus);
+    const jobs = useMemo(() => extractJobRawMaterial(currentSt.jobs, currentSt.material, queue).filter((j) => j.rawMatName === casting), [currentSt.jobs, currentSt.material, casting, queue]);
+    if (jobs.length === 0)
+        return null;
+    return (_jsxs(Table, { size: "small", children: [_jsx(TableHead, { children: _jsxs(TableRow, { children: [_jsx(TableCell, { children: "Job" }), _jsx(TableCell, { align: "right", children: "Plan" }), _jsx(TableCell, { align: "right", children: "Remaining" }), _jsx(TableCell, { align: "right", children: "Assigned" }), _jsx(TableCell, { align: "right", children: "Required" }), _jsx(TableCell, { align: "right", children: "Available" })] }) }), _jsxs(TableBody, { children: [jobs.map((j, idx) => (_jsxs(TableRow, { children: [_jsx(TableCell, { children: j.job.unique }), _jsx(TableCell, { align: "right", children: j.job.cycles }), _jsx(TableCell, { align: "right", children: j.remainingToStart }), _jsx(TableCell, { align: "right", children: j.assignedRaw }), _jsx(TableCell, { align: "right", children: Math.max(j.remainingToStart - j.assignedRaw, 0) }), _jsx(TableCell, { align: "right", children: j.availableUnassigned })] }, idx))), jobs.length >= 2 ? (_jsxs(TableRow, { children: [_jsx(TableCell, { children: "Total" }), _jsx(TableCell, { align: "right", children: LazySeq.of(jobs).sumBy((j) => j.job.cycles) }), _jsx(TableCell, { align: "right", children: LazySeq.of(jobs).sumBy((j) => j.remainingToStart) }), _jsx(TableCell, { align: "right", children: LazySeq.of(jobs).sumBy((j) => j.assignedRaw) }), _jsx(TableCell, { align: "right", children: LazySeq.of(jobs).sumBy((j) => Math.max(j.remainingToStart - j.assignedRaw, 0)) }), _jsx(TableCell, { align: "right", children: LazySeq.of(jobs).sumBy((j) => j.availableUnassigned) })] })) : undefined] })] }));
+}
+export const BulkAddCastingWithoutSerialDialog = memo(function BulkAddCastingWithoutSerialDialog() {
+    const [queue, setQueue] = useAtom(bulkAddCastingToQueue);
+    const operator = useAtomValue(currentOperator);
+    const fmsInfo = useAtomValue(fmsInformation);
+    const printOnAdd = fmsInfo.usingLabelPrinterForSerials && fmsInfo.useClientPrinterForLabels;
+    const [addNewCasting] = useAddNewCastingToQueue();
+    const setWaitingToPrint = useSetAtom(waitingForMaterialAssignmentDialog);
+    const [selectedCasting, setSelectedCasting] = useState(null);
+    const [enteredQty, setQty] = useState(null);
+    const [enteredOperator, setEnteredOperator] = useState(null);
+    const [adding, setAdding] = useState(false);
+    const currentSt = useAtomValue(currentStatus);
+    const historicCastNames = useAtomValue(castingNames);
+    const castings = useMemo(() => LazySeq.ofObject(currentSt.jobs)
+        .flatMap(([, j]) => j.procsAndPaths[0].paths)
+        .filter((p) => p.casting !== undefined && p.casting !== "")
+        .map((p) => ({ casting: p.casting, cnt: 1 }))
+        .concat(LazySeq.of(historicCastNames).map((c) => ({ casting: c, cnt: 0 })))
+        .buildOrderedMap((c) => c.casting, (old, c) => (old === undefined ? c.cnt : old + c.cnt))
+        .toAscLazySeq(), [currentSt.jobs, historicCastNames]);
+    function close() {
+        setQueue(null);
+        setSelectedCasting(null);
+        setEnteredOperator(null);
+        setAdding(false);
+        setQty(null);
+    }
+    function add() {
+        if (queue !== null &&
+            selectedCasting !== null &&
+            enteredQty !== null &&
+            !isNaN(enteredQty) &&
+            enteredQty > 0) {
+            addNewCasting({
+                casting: selectedCasting,
+                quantity: enteredQty,
+                queue: queue,
+                workorder: null,
+                operator: fmsInfo.requireOperatorNamePromptWhenAddingMaterial ? enteredOperator : operator,
+            });
+        }
+        close();
+    }
+    function addAndPrint() {
+        if (queue !== null && selectedCasting !== null && enteredQty !== null && !isNaN(enteredQty)) {
+            setAdding(true);
+            addNewCasting({
+                casting: selectedCasting,
+                quantity: enteredQty,
+                queue: queue,
+                operator: operator,
+                workorder: null,
+                onNewMaterial: (mats) => {
+                    setWaitingToPrint({
+                        selectedCasting: selectedCasting,
+                        operator: fmsInfo.requireOperatorNamePromptWhenAddingMaterial ? enteredOperator : operator,
+                        materialIds: new Set(mats.map((m) => m.materialID)),
+                    });
+                    close();
+                },
+                onError: () => {
+                    close();
+                },
+            });
+        }
+    }
+    return (_jsxs(_Fragment, { children: [_jsxs(Dialog, { open: queue !== null, onClose: () => close(), maxWidth: "md", children: [_jsx(DialogTitle, { children: "Add Raw Material" }), _jsx(DialogContent, { children: _jsxs(Stack, { direction: "column", spacing: 2, mt: "0.5em", children: [_jsx(TextField, { style: { minWidth: "15em" }, value: selectedCasting || "", onChange: (e) => setSelectedCasting(e.target.value), select: true, fullWidth: true, label: "Raw Material", slotProps: {
+                                        select: {
+                                            renderValue: selectedCasting === null
+                                                ? undefined
+                                                : () => (_jsxs("div", { style: { display: "flex", alignItems: "center" }, children: [_jsx("div", { style: { marginRight: "0.5em" }, children: _jsx(PartIdenticon, { part: selectedCasting, size: 25 }) }), _jsx("div", { children: selectedCasting })] })),
+                                        },
+                                    }, children: castings.map(([casting, jobCnt], idx) => (_jsxs(MenuItem, { value: casting, children: [_jsx(ListItemIcon, { children: _jsx(PartIdenticon, { part: casting }) }), _jsx(ListItemText, { primary: casting, slotProps: { primary: { variant: "h4" } }, secondary: jobCnt === 0
+                                                    ? "Not used by any current jobs"
+                                                    : `Used by ${jobCnt} current job${jobCnt > 1 ? "s" : ""}` })] }, idx))) }), _jsx(TextField, { fullWidth: true, type: "number", label: "Quantity", disabled: selectedCasting === null, slotProps: { htmlInput: { min: "1" } }, value: enteredQty === null || isNaN(enteredQty) || enteredQty <= 0 ? "" : enteredQty, onChange: (e) => setQty(parseInt(e.target.value)) }), fmsInfo.requireOperatorNamePromptWhenAddingMaterial ? (_jsx(TextField, { fullWidth: true, label: "Operator", value: enteredOperator || "", onChange: (e) => setEnteredOperator(e.target.value) })) : undefined, selectedCasting !== null && queue !== null ? (_jsx(JobsForCasting, { casting: selectedCasting, queue: queue })) : undefined] }) }), _jsxs(DialogActions, { children: [printOnAdd ? (_jsxs(Button, { color: "primary", disabled: adding ||
+                                    selectedCasting === null ||
+                                    enteredQty === null ||
+                                    isNaN(enteredQty) ||
+                                    (fmsInfo.requireOperatorNamePromptWhenAddingMaterial &&
+                                        (enteredOperator === null || enteredOperator === "")), onClick: addAndPrint, children: [adding ? _jsx(CircularProgress, { size: 10 }) : undefined, "Add ", enteredQty !== null && !isNaN(enteredQty) ? enteredQty.toString() + " " : "", "to ", queue] })) : (_jsxs(Button, { color: "primary", disabled: selectedCasting === null ||
+                                    enteredQty === null ||
+                                    isNaN(enteredQty) ||
+                                    (fmsInfo.requireOperatorNamePromptWhenAddingMaterial &&
+                                        (enteredOperator === null || enteredOperator === "")), onClick: add, children: ["Add ", enteredQty !== null && !isNaN(enteredQty) ? enteredQty.toString() + " " : "", "to ", queue] })), _jsx(Button, { color: "primary", disabled: adding && printOnAdd, onClick: close, children: "Cancel" })] })] }), _jsx(WaitingForMaterialDialog, {})] }));
+});
+export const MultiMaterialDialog = memo(function MultiMaterialDialog(props) {
+    const fmsInfo = useAtomValue(fmsInformation);
+    const jobs = useAtomValue(currentStatus).jobs;
+    const [printLabel, printingLabel] = usePrintLabel();
+    const [loading, setLoading] = useState(false);
+    const [events, setEvents] = useState([]);
+    const [showRemove, setShowRemove] = useState(false);
+    const [removeCnt, setRemoveCnt] = useState(NaN);
+    const [lastOperator, setLastOperator] = useState(undefined);
+    useEffect(() => {
+        if (props.material === null)
+            return;
+        let isSubscribed = true;
+        setLoading(true);
+        loadRawMaterialEvents(props.material)
+            .then((events) => {
+            if (isSubscribed) {
+                setEvents(events);
+                let operator;
+                for (const e of events) {
+                    if (e.type === api.LogType.AddToQueue && e.details?.["operator"] !== undefined) {
+                        operator = e.details["operator"];
+                    }
+                }
+                setLastOperator(operator);
+            }
+        })
+            .catch(console.error)
+            .finally(() => setLoading(false));
+        return () => {
+            isSubscribed = false;
+        };
+    }, [props.material]);
+    const rawMatName = useMemo(() => {
+        if (!props.material || props.material.length === 0)
+            return undefined;
+        const uniq = props.material[0].jobUnique;
+        if (!uniq || uniq === "" || !jobs[uniq])
+            return undefined;
+        return LazySeq.of(jobs[uniq].procsAndPaths[0].paths)
+            .filter((p) => p.casting !== undefined && p.casting !== "")
+            .head()?.casting;
+    }, [props.material, jobs]);
+    function close() {
+        props.closeDialog();
+        setShowRemove(false);
+        setRemoveCnt(NaN);
+        setLoading(false);
+        setEvents([]);
+    }
+    function remove() {
+        if (showRemove) {
+            if (!isNaN(removeCnt)) {
+                setLoading(true);
+                JobsBackend.bulkRemoveMaterialFromQueues(props.operator, LazySeq.of(props.material || [])
+                    .take(removeCnt)
+                    .map((m) => m.materialID)
+                    .toRArray())
+                    .catch(console.error)
+                    .finally(close);
+            }
+        }
+        else {
+            setShowRemove(true);
+        }
+    }
+    const mat1 = props.material?.[0];
+    return (_jsxs(Dialog, { open: props.material !== null, onClose: close, maxWidth: "md", children: [_jsx(DialogTitle, { children: mat1 && props.material && props.material.length > 0 ? (_jsx(MaterialDetailTitle, { partName: mat1.partName, subtitle: props.material.length.toString() +
+                        (mat1.jobUnique && mat1.jobUnique !== "" ? " assigned to " + mat1.jobUnique : " unassigned") })) : ("Material") }), _jsxs(DialogContent, { children: [loading ? _jsx(CircularProgress, { color: "secondary" }) : _jsx(LogEntries, { entries: events, copyToClipboard: true }), showRemove && props.material ? (_jsx("div", { style: { marginTop: "1em" }, children: _jsx(TextField, { type: "number", variant: "outlined", fullWidth: true, label: "Quantity to Remove", slotProps: { htmlInput: { min: "1", max: props.material.length.toString() } }, value: isNaN(removeCnt) ? "" : removeCnt, onChange: (e) => setRemoveCnt(parseInt(e.target.value)) }) })) : undefined] }), _jsxs(DialogActions, { children: [props.material && props.material.length > 0 && fmsInfo.usingLabelPrinterForSerials ? (fmsInfo.useClientPrinterForLabels ? (_jsx(PrintOnClientButton, { mat: props.material || [], materialName: rawMatName, operator: lastOperator })) : (_jsx(Button, { color: "primary", disabled: printingLabel, onClick: () => props.material && props.material.length > 0
+                            ? printLabel({
+                                materialId: props.material[0].materialID,
+                                proc: 0,
+                            })
+                            : void 0, children: "Print Label" }))) : undefined, _jsx(Button, { color: "primary", onClick: remove, disabled: loading || (showRemove && isNaN(removeCnt)), children: loading && showRemove
+                            ? "Removing..."
+                            : showRemove && !isNaN(removeCnt)
+                                ? `Remove ${removeCnt} material`
+                                : "Remove Material" }), _jsx(Button, { color: "primary", onClick: close, children: "Close" })] })] }));
+});

package/dist/components/station-monitor/Closeout.d.ts

@@ -0,0 +1,5 @@
+import { ReactNode } from "react";
+export declare function Closeout({ forceSingleColumn }: {
+    forceSingleColumn?: boolean;
+}): ReactNode;
+export declare function CloseoutPage(): ReactNode;