@seedtactics/insight-client 16.4.0

package/dist/data/all-material-bins.js

@@ -0,0 +1,224 @@
+/* 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 * as api from "../network/api.js";
+import { LazySeq } from "@seedtactics/immutable-collections";
+import { atomWithStorage } from "jotai/utils";
+export const LoadStationBinId = "__FMS_INSIGHT_LOAD_STATION_BIN__";
+export const PalletsBinId = "__FMS_INSIGHT_PALLETS_BIN__";
+export const ActiveQueuesBinId = "__FMS_INSIGHT_ACTIVE_QUEUE_BIN__";
+export const currentMaterialBinOrder = atomWithStorage("material-bins", []);
+export function moveMaterialBin(curBinOrder, oldIdx, newIdx) {
+    const newBinOrder = Array.from(curBinOrder);
+    const [removed] = newBinOrder.splice(oldIdx, 1);
+    newBinOrder.splice(newIdx, 0, removed);
+    return newBinOrder;
+}
+function addToMap(m, k, mat) {
+    const mats = m.get(k);
+    if (mats) {
+        mats.push(mat);
+    }
+    else {
+        m.set(k, [mat]);
+    }
+}
+export var MaterialBinType;
+(function (MaterialBinType) {
+    MaterialBinType["LoadStations"] = "Bin_LoadStations";
+    MaterialBinType["Pallets"] = "Bin_Pallets";
+    MaterialBinType["ActiveQueues"] = "Bin_ActiveQueues";
+    MaterialBinType["QuarantineQueues"] = "Bin_Quarantine";
+})(MaterialBinType || (MaterialBinType = {}));
+export function selectAllMaterialIntoBins(curSt, curBinOrder) {
+    const loadStations = new Map();
+    const pallets = new Map();
+    const queues = new Map();
+    const palLoc = LazySeq.ofObject(curSt.pallets).toRMap(([, st]) => [
+        st.palletNum,
+        st.palletNum.toString() +
+            " (" +
+            st.currentPalletLocation.group +
+            " #" +
+            st.currentPalletLocation.num.toString() +
+            ")",
+    ]);
+    for (const mat of curSt.material) {
+        switch (mat.location.type) {
+            case api.LocType.InQueue:
+                if (mat.action.type === api.ActionType.Loading) {
+                    const pal = curSt.pallets[mat.action.loadOntoPalletNum ?? 0];
+                    if (pal && pal.currentPalletLocation.loc === api.PalletLocationEnum.LoadUnload) {
+                        const lul = pal.currentPalletLocation.num;
+                        addToMap(loadStations, lul, mat);
+                    }
+                    else {
+                        addToMap(queues, mat.location.currentQueue || "Queue", mat);
+                    }
+                }
+                else {
+                    addToMap(queues, mat.location.currentQueue || "Queue", mat);
+                }
+                break;
+            case api.LocType.OnPallet:
+                if (mat.location.palletNum) {
+                    const palSt = curSt.pallets[mat.location.palletNum];
+                    if (palSt.currentPalletLocation.loc === api.PalletLocationEnum.LoadUnload) {
+                        addToMap(loadStations, palSt.currentPalletLocation.num, mat);
+                    }
+                    else {
+                        addToMap(pallets, palLoc.get(mat.location.palletNum) ?? "", mat);
+                    }
+                }
+                else {
+                    addToMap(pallets, "Pallet", mat);
+                }
+                break;
+            case api.LocType.Free:
+                switch (mat.action.type) {
+                    case api.ActionType.Loading: {
+                        const lul = curSt.pallets[mat.action.loadOntoPalletNum ?? 0]?.currentPalletLocation.num;
+                        addToMap(loadStations, lul, mat);
+                        break;
+                    }
+                    default:
+                        addToMap(queues, "Free Material", mat);
+                        break;
+                }
+                break;
+        }
+    }
+    const activeQueues = LazySeq.ofObject(curSt.jobs)
+        .flatMap(([_, job]) => job.procsAndPaths)
+        .flatMap((proc) => proc.paths)
+        .flatMap((path) => {
+        const q = [];
+        if (path.inputQueue !== undefined)
+            q.push(path.inputQueue);
+        if (path.outputQueue !== undefined)
+            q.push(path.outputQueue);
+        return q;
+    })
+        .concat(LazySeq.ofObject(curSt.queues)
+        .filter(([, info]) => info.role === api.QueueRole.RawMaterial || info.role === api.QueueRole.InProcessTransfer)
+        .map(([qname, _]) => qname))
+        .toRSet((x) => x);
+    const quarantineQueues = LazySeq.ofObject(curSt.queues)
+        .filter(([qname, _]) => !activeQueues.has(qname))
+        .toRSet(([qname, _]) => qname);
+    const bins = curBinOrder.filter((b) => b === LoadStationBinId || b === PalletsBinId || b === ActiveQueuesBinId || quarantineQueues.has(b));
+    if (bins.indexOf(ActiveQueuesBinId) < 0) {
+        bins.unshift(ActiveQueuesBinId);
+    }
+    if (bins.indexOf(PalletsBinId) < 0) {
+        bins.unshift(PalletsBinId);
+    }
+    if (bins.indexOf(LoadStationBinId) < 0) {
+        bins.unshift(LoadStationBinId);
+    }
+    for (const queue of LazySeq.of(quarantineQueues).sortBy((x) => x)) {
+        if (bins.indexOf(queue) < 0) {
+            bins.push(queue);
+        }
+    }
+    return bins.map((binId) => {
+        if (binId === LoadStationBinId) {
+            return { type: MaterialBinType.LoadStations, binId: LoadStationBinId, byLul: loadStations };
+        }
+        else if (binId === PalletsBinId) {
+            return { type: MaterialBinType.Pallets, binId: PalletsBinId, byPallet: pallets };
+        }
+        else if (binId === ActiveQueuesBinId) {
+            return {
+                type: MaterialBinType.ActiveQueues,
+                binId: ActiveQueuesBinId,
+                byQueue: LazySeq.of(activeQueues).toRMap((queueName) => {
+                    const mat = queues.get(queueName) ?? [];
+                    mat.sort((m1, m2) => (m1.location.queuePosition ?? 0) - (m2.location.queuePosition ?? 0));
+                    return [queueName, mat];
+                }, (ms1, ms2) => ms1.concat(ms2)),
+            };
+        }
+        else {
+            const queueName = binId;
+            const mat = queues.get(queueName) ?? [];
+            mat.sort((m1, m2) => (m1.location.queuePosition ?? 0) - (m2.location.queuePosition ?? 0));
+            return {
+                type: MaterialBinType.QuarantineQueues,
+                binId: queueName,
+                queueName,
+                material: mat,
+            };
+        }
+    });
+}
+export function moveMaterialInBin(bins, mat, queue, queuePosition) {
+    return bins.map((bin) => {
+        switch (bin.type) {
+            case MaterialBinType.QuarantineQueues:
+                if (bin.queueName === queue) {
+                    const mats = bin.material.filter((m) => m.materialID !== mat.materialID);
+                    mats.splice(queuePosition, 0, mat);
+                    return { ...bin, material: mats };
+                }
+                else {
+                    return { ...bin, material: bin.material.filter((m) => m.materialID !== mat.materialID) };
+                }
+            default:
+                return bin;
+        }
+    });
+}
+export function findMaterialInQuarantineQueues(matId, bins) {
+    for (const bin of bins) {
+        switch (bin.type) {
+            case MaterialBinType.QuarantineQueues:
+                for (let i = 0; i < bin.material.length; i++) {
+                    if (bin.material[i].materialID === matId) {
+                        return { bin, idx: i };
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    return null;
+}
+export function findQueueInQuarantineQueues(queue, bins) {
+    for (const bin of bins) {
+        if (bin.type === MaterialBinType.QuarantineQueues && bin.queueName === queue) {
+            return { bin, idx: 0 };
+        }
+    }
+    return null;
+}

package/dist/data/chart-times.d.ts

@@ -0,0 +1,20 @@
+import { Atom, WritableAtom } from "jotai";
+export type Last30ChartStart = "StartOfToday" | "StartOfYesterday" | "StartOfWeek" | "StartOfLastWeek" | "Last30";
+export type Last30ChartEnd = "Now" | "EndOfYesterday" | "EndOfLastWeek";
+export declare const last30WeekdayStartIdx: WritableAtom<0 | 2 | 1 | 3 | 4 | 5 | 6, [0 | 2 | 1 | 3 | 4 | 5 | 6 | typeof import("jotai/utils").RESET | ((prev: 0 | 2 | 1 | 3 | 4 | 5 | 6) => 0 | 2 | 1 | 3 | 4 | 5 | 6 | typeof import("jotai/utils").RESET)], void>;
+export declare const last30WeekdayStartMinuteOffset: WritableAtom<number, [number | typeof import("jotai/utils").RESET | ((prev: number) => number | typeof import("jotai/utils").RESET)], void>;
+export declare const last30ChartStartTimes: import("jotai-family").AtomFamily<Last30ChartStart, Atom<Date>>;
+export declare const last30ChartEndTimes: import("jotai-family").AtomFamily<Last30ChartEnd, Atom<Date | null>>;
+export type Last30ChartRangeAtom = WritableAtom<{
+    readonly startType: Last30ChartStart | Date;
+    readonly endType: Last30ChartEnd | Date;
+    readonly startDate: Date | null;
+    readonly endDate: Date | null;
+}, [
+    {
+        start: Last30ChartStart | Date;
+    } | {
+        end: Last30ChartEnd | Date;
+    }
+], void>;
+export declare function chartRangeAtom(chartName: string): Last30ChartRangeAtom;

package/dist/data/chart-times.js

@@ -0,0 +1,99 @@
+/* Copyright (c) 2025, John Lenz
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+
+    * Redistributions in binary form must reproduce the above
+      copyright notice, this list of conditions and the following
+      disclaimer in the documentation and/or other materials provided
+      with the distribution.
+
+    * Neither the name of John Lenz, Black Maple Software, SeedTactics,
+      nor the names of other contributors may be used to endorse or
+      promote products derived from this software without specific
+      prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+import { addDays, addMinutes, startOfDay, startOfWeek } from "date-fns";
+import { atom } from "jotai";
+import { atomWithStorage } from "jotai/utils";
+import { atomFamily } from "jotai-family";
+const minsSinceEpochAtom = atom(Math.floor(Date.now() / 60_000));
+minsSinceEpochAtom.onMount = (setSelf) => {
+    const interval = setInterval(() => {
+        setSelf(Math.floor(Date.now() / 60_000));
+    }, 60_000);
+    return () => clearInterval(interval);
+};
+export const last30WeekdayStartIdx = atomWithStorage("charts_last30WeekdayStartIdx", 0);
+export const last30WeekdayStartMinuteOffset = atomWithStorage("charts_last30WeekdayStartMinuteOffset", 6 * 60);
+export const last30ChartStartTimes = atomFamily((start) => atom((get) => {
+    const weekStart = get(last30WeekdayStartIdx);
+    const weekStartMins = get(last30WeekdayStartMinuteOffset);
+    const now = new Date(get(minsSinceEpochAtom) * 60_000);
+    const startOfT = addMinutes(startOfDay(now), weekStartMins);
+    const startOfW = addMinutes(startOfWeek(now, { weekStartsOn: weekStart }), weekStartMins);
+    switch (start) {
+        case "StartOfToday":
+            return startOfT;
+        case "StartOfYesterday":
+            return addDays(startOfT, -1);
+        case "StartOfWeek":
+            return startOfW;
+        case "StartOfLastWeek":
+            return addDays(startOfW, -7);
+        case "Last30":
+            return addDays(now, -30);
+    }
+}));
+export const last30ChartEndTimes = atomFamily((cEnd) => atom((get) => {
+    if (cEnd === "Now") {
+        return null;
+    }
+    const weekStart = get(last30WeekdayStartIdx);
+    const weekStartMins = get(last30WeekdayStartMinuteOffset);
+    const now = new Date(get(minsSinceEpochAtom) * 60_000);
+    switch (cEnd) {
+        case "EndOfYesterday":
+            return addMinutes(startOfDay(now), weekStartMins);
+        case "EndOfLastWeek":
+            return addMinutes(startOfWeek(now, { weekStartsOn: weekStart }), weekStartMins);
+    }
+}));
+export function chartRangeAtom(chartName) {
+    const startA = atomWithStorage(`charts_${chartName}_start`, "StartOfWeek");
+    const endA = atomWithStorage(`charts_${chartName}_end`, "Now");
+    return atom((get) => {
+        const start = get(startA);
+        const end = get(endA);
+        return {
+            startType: start,
+            endType: end,
+            startDate: start instanceof Date ? start : get(last30ChartStartTimes(start)),
+            endDate: end instanceof Date ? end : get(last30ChartEndTimes(end)),
+        };
+    }, (_, set, update) => {
+        if ("start" in update) {
+            set(startA, update.start);
+        }
+        if ("end" in update) {
+            set(endA, update.end);
+        }
+    });
+}

package/dist/data/cost-per-piece.d.ts

@@ -0,0 +1,32 @@
+import { MaterialSummaryAndCompletedData } from "../cell-status/material-summary.js";
+import { PartCycleData } from "../cell-status/station-cycles.js";
+import { HashMap, HashSet, LazySeq, OrderedMap } from "@seedtactics/immutable-collections";
+export interface PartCost {
+    readonly part: string;
+    readonly parts_completed: number;
+    readonly machine: OrderedMap<string, number>;
+    readonly labor: number;
+    readonly automation: number;
+}
+export type MachineCostPerYear = {
+    readonly [stationGroup: string]: number;
+};
+export interface CostData {
+    readonly machineQuantities: OrderedMap<string, number>;
+    readonly type: {
+        month: Date;
+    } | {
+        thirtyDaysAgo: Date;
+    };
+    readonly parts: ReadonlyArray<PartCost>;
+}
+export declare function compute_monthly_cost_percentages(cycles: LazySeq<PartCycleData>, partsToIgnore: HashSet<string>, matsById: HashMap<number, MaterialSummaryAndCompletedData>, type: {
+    month: Date;
+} | {
+    thirtyDaysAgo: Date;
+}): CostData;
+export declare function convert_cost_percent_to_cost_per_piece(costs: CostData, machineCostPerYear: MachineCostPerYear, automationCostPerYear: number | null, totalLaborCostForPeriod: number): CostData;
+export declare function buildCostPerPieceTable(costs: CostData): string;
+export declare function copyCostPerPieceToClipboard(costs: CostData): void;
+export declare function buildCostBreakdownTable(costs: CostData): string;
+export declare function copyCostBreakdownToClipboard(costs: CostData): void;

package/dist/data/cost-per-piece.js

@@ -0,0 +1,183 @@
+/* Copyright (c) 2020, 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 { addMonths, getDaysInMonth, addDays } from "date-fns";
+import copy from "copy-to-clipboard";
+import { LazySeq } from "@seedtactics/immutable-collections";
+function isUnloadCycle(c) {
+    return c.isLabor && c.operation === "UNLOAD";
+}
+function isMonthType(type) {
+    return Object.prototype.hasOwnProperty.call(type, "month");
+}
+export function compute_monthly_cost_percentages(cycles, partsToIgnore, matsById, type) {
+    const start = isMonthType(type) ? type.month : type.thirtyDaysAgo;
+    const end = isMonthType(type) ? addMonths(type.month, 1) : addDays(type.thirtyDaysAgo, 31);
+    let totalPalletCycles = 0;
+    const totalStatUseMinutes = new Map();
+    let totalLaborUseMinutes = 0;
+    const stationCount = new Map();
+    const filteredCycles = cycles.filter((c) => c.endTime >= start && c.endTime <= end && !c.material.some((m) => partsToIgnore.has(m.part)));
+    for (const c of filteredCycles) {
+        if (isUnloadCycle(c)) {
+            totalPalletCycles += 1;
+        }
+        if (c.isLabor) {
+            totalLaborUseMinutes += c.activeMinutes;
+        }
+        else {
+            totalStatUseMinutes.set(c.stationGroup, c.activeMinutes + (totalStatUseMinutes.get(c.stationGroup) ?? 0));
+            const s = stationCount.get(c.stationGroup);
+            if (s) {
+                s.add(c.stationNumber);
+            }
+            else {
+                stationCount.set(c.stationGroup, new Set([c.stationNumber]));
+            }
+        }
+    }
+    const completed = LazySeq.of(matsById)
+        .filter(([, details]) => {
+        if (partsToIgnore.has(details.partName))
+            return false;
+        if (details.numProcesses === undefined)
+            return false;
+        const unload = details.unloaded_processes?.[details.numProcesses];
+        return !!unload && unload >= start && unload <= end;
+    })
+        .toRMap(([, details]) => [details.partName, 1], (v1, v2) => v1 + v2);
+    const parts = filteredCycles
+        .groupBy((c) => c.part)
+        .map(([partName, forPart]) => ({
+        part: partName,
+        parts_completed: completed.get(partName) ?? 0,
+        machine: LazySeq.of(forPart)
+            .filter((c) => !c.isLabor)
+            .buildOrderedMap((c) => c.stationGroup, (old, c) => (old ?? 0) + c.activeMinutes)
+            .mapValues((minutes, statGroup) => {
+            const totalUse = totalStatUseMinutes.get(statGroup) ?? 1;
+            return minutes / totalUse;
+        }),
+        labor: LazySeq.of(forPart)
+            .filter((c) => c.isLabor)
+            .sumBy((c) => c.activeMinutes / totalLaborUseMinutes),
+        automation: forPart.reduce((acc, v) => (isUnloadCycle(v) ? acc + 1 : acc), 0) / totalPalletCycles,
+    }))
+        .toRArray();
+    const machineQuantities = LazySeq.of(stationCount).toOrderedMap(([statGroup, nums]) => [
+        statGroup,
+        nums.size,
+    ]);
+    return {
+        parts,
+        machineQuantities,
+        type,
+    };
+}
+export function convert_cost_percent_to_cost_per_piece(costs, machineCostPerYear, automationCostPerYear, totalLaborCostForPeriod) {
+    const days = isMonthType(costs.type) ? getDaysInMonth(costs.type.month) : 30;
+    const automationCostForPeriod = automationCostPerYear ? (automationCostPerYear * days) / 365 : 0;
+    const stationCostForPeriod = costs.machineQuantities.mapValues((cnt, statGroup) => ((machineCostPerYear[statGroup] ?? 0) * cnt * days) / 365);
+    return {
+        machineQuantities: costs.machineQuantities,
+        type: costs.type,
+        parts: costs.parts.map((p) => ({
+            part: p.part,
+            parts_completed: p.parts_completed,
+            machine: p.machine.mapValues((pct, statGroup) => p.parts_completed > 0 ? (pct * (stationCostForPeriod.get(statGroup) ?? 0)) / p.parts_completed : 0),
+            labor: p.parts_completed > 0 ? (p.labor * totalLaborCostForPeriod) / p.parts_completed : 0,
+            automation: p.parts_completed > 0 ? (p.automation * automationCostForPeriod) / p.parts_completed : 0,
+        })),
+    };
+}
+export function buildCostPerPieceTable(costs) {
+    let table = "<table>\n<thead><tr>";
+    table += "<th>Part</th>";
+    table += "<th>Completed Quantity</th>";
+    for (const m of costs.machineQuantities.keys()) {
+        table += "<th>" + m + " Cost %</th>";
+    }
+    table += "<th>Labor Cost</th>";
+    table += "<th>Automation Cost</th>";
+    table += "</tr></thead>\n<tbody>\n";
+    const rows = LazySeq.of(costs.parts).sortBy((c) => c.part);
+    const format = Intl.NumberFormat(undefined, {
+        maximumFractionDigits: 1,
+    });
+    for (const c of rows) {
+        table += "<tr><td>" + c.part + "</td>";
+        table += "<td>" + c.parts_completed.toString() + "</td>";
+        for (const m of costs.machineQuantities.keys()) {
+            table += "<td>" + format.format(c.machine.get(m) ?? 0) + "</td>";
+        }
+        table += "<td>" + (c.parts_completed > 0 ? format.format(c.labor) : "0") + "</td>";
+        table += "<td>" + (c.parts_completed > 0 ? format.format(c.automation) : "0") + "</td>";
+        table += "</tr>\n";
+    }
+    table += "</tbody>\n</table>";
+    return table;
+}
+export function copyCostPerPieceToClipboard(costs) {
+    copy(buildCostPerPieceTable(costs));
+}
+export function buildCostBreakdownTable(costs) {
+    let table = "<table>\n<thead><tr>";
+    table += "<th>Part</th>";
+    table += "<th>Completed Quantity</th>";
+    for (const m of costs.machineQuantities.keys()) {
+        table += "<th>" + m + " Cost %</th>";
+    }
+    table += "<th>Labor Cost %</th>";
+    table += "<th>Automation Cost %</th>";
+    table += "</tr></thead>\n<tbody>\n";
+    const rows = LazySeq.of(costs.parts).sortBy((c) => c.part);
+    const pctFormat = new Intl.NumberFormat(undefined, {
+        style: "percent",
+        minimumFractionDigits: 1,
+        maximumFractionDigits: 1,
+    });
+    for (const c of rows) {
+        table += "<tr><td>" + c.part + "</td>";
+        table += "<td>" + c.parts_completed.toString() + "</td>";
+        for (const m of costs.machineQuantities.keys()) {
+            table += "<td>" + pctFormat.format(c.machine.get(m) ?? 0) + "</td>";
+        }
+        table += "<td>" + pctFormat.format(c.labor) + "</td>";
+        table += "<td>" + pctFormat.format(c.automation) + "</td>";
+        table += "</tr>\n";
+    }
+    table += "</tbody>\n</table>";
+    return table;
+}
+export function copyCostBreakdownToClipboard(costs) {
+    copy(buildCostBreakdownTable(costs));
+}

package/dist/data/current-cycles.d.ts

@@ -0,0 +1,13 @@
+import { EstimatedCycleTimes } from "../cell-status/estimated-cycle-times.js";
+import { ICurrentStatus } from "../network/api.js";
+export type CurrentCycle = {
+    readonly station: string;
+    readonly start: Date;
+    readonly expectedEnd: Date;
+    readonly isOutlier: boolean;
+    readonly parts: ReadonlyArray<{
+        readonly part: string;
+        readonly oper: string;
+    }>;
+};
+export declare function currentCycles(currentSt: ICurrentStatus, estimated: EstimatedCycleTimes): ReadonlyArray<CurrentCycle>;